import { describe, expect, it, test, vi } from 'vitest';
import { userEvent } from 'vitest/browser';
import { screen, waitFor } from '@testing-library/react';
import { render } from 'vitest-browser-react';
import '@wordpress/theme/design-tokens.css';
import { useState } from '@wordpress/element';
import { formatLowercase, formatUppercase } from '@wordpress/icons';
import Button from '../../button';
import {
	ToggleGroupControl,
	ToggleGroupControlOption,
	ToggleGroupControlOptionIcon,
} from '../index';
import { TOOLTIP_DELAY } from '../../tooltip';
import type { ToggleGroupControlProps } from '../types';
import controlStyles from '../toggle-group-control/style.module.scss';
import optionStyles from '../toggle-group-control-option-base/style.module.scss';

const hoverOutside = async () => {
	await userEvent.hover( document.body );
};

const expectGroupChromeDisabled = ( group: HTMLElement ) => {
	expect( group ).toBeVisible();
	expect( group ).toHaveAttribute( 'aria-disabled', 'true' );
	// `toBeEnabled()` treats aria-disabled as disabled, so it cannot
	// catch an HTML `disabled` leak onto this div.
	// eslint-disable-next-line jest-dom/prefer-enabled-disabled
	expect( group ).not.toHaveAttribute( 'disabled' );
};

const sleep = ( milliseconds: number ) =>
	new Promise( ( resolve ) => setTimeout( resolve, milliseconds ) );

const ControlledToggleGroupControl = ( {
	value: valueProp,
	onChange,
	extraButtonOptions,
	...props
}: ToggleGroupControlProps & {
	extraButtonOptions?: { name: string; value: string }[];
} ) => {
	const [ value, setValue ] = useState( valueProp );

	return (
		<>
			<ToggleGroupControl
				{ ...props }
				onChange={ ( ...changeArgs ) => {
					setValue( ...changeArgs );
					onChange?.( ...changeArgs );
				} }
				value={ value }
			/>

			<Button
				onClick={ () => setValue( undefined ) }
				__next40pxDefaultSize
			>
				Reset
			</Button>
			{ extraButtonOptions?.map( ( obj ) => (
				<Button
					__next40pxDefaultSize
					key={ obj.value }
					onClick={ () => setValue( obj.value ) }
				>
					{ obj.name }
				</Button>
			) ) }
		</>
	);
};
const options = (
	<>
		<ToggleGroupControlOption value="rigas" label="R" />
		<ToggleGroupControlOption value="jack" label="J" />
	</>
);

const optionsWithTooltip = (
	<>
		<ToggleGroupControlOption
			value="gnocchi"
			label="Delicious Gnocchi"
			aria-label="Click for Delicious Gnocchi"
			showTooltip
		/>

		<ToggleGroupControlOption
			value="caponata"
			label="Sumptuous Caponata"
			aria-label="Click for Sumptuous Caponata"
		/>
	</>
);

const optionsWithDisabledOption = (
	<>
		<ToggleGroupControlOption value="pizza" label="Pizza" />
		<ToggleGroupControlOption value="rice" label="Rice" disabled />
		<ToggleGroupControlOption value="pasta" label="Pasta" />
	</>
);

describe( 'required context', () => {
	it( 'throws when ToggleGroupControlOption is outside ToggleGroupControl', async () => {
		await expect(
			render( <ToggleGroupControlOption value="value" label="Label" /> )
		).rejects.toThrow(
			'ToggleGroupControlOption can only be rendered inside ToggleGroupControl.'
		);
	} );

	it( 'throws when ToggleGroupControlOptionIcon is outside ToggleGroupControl', async () => {
		await expect(
			render(
				<ToggleGroupControlOptionIcon
					value="value"
					label="Label"
					icon={ formatUppercase }
				/>
			)
		).rejects.toThrow(
			'ToggleGroupControlOptionIcon can only be rendered inside ToggleGroupControl.'
		);
	} );
} );

describe.each( [
	[ 'uncontrolled', ToggleGroupControl ],
	[ 'controlled', ControlledToggleGroupControl ],
] )( 'ToggleGroupControl %s', ( ...modeAndComponent ) => {
	const [ mode, Component ] = modeAndComponent;

	describe( 'should render correctly', () => {
		it( 'with text options', async () => {
			await render(
				<Component label="Test Toggle Group Control">
					{ options }
				</Component>
			);

			expect(
				screen.getByRole( 'radiogroup', {
					name: 'Test Toggle Group Control',
				} )
			).toBeInTheDocument();
			expect(
				screen.getByRole( 'radio', { name: 'R' } )
			).toBeInTheDocument();
			expect(
				screen.getByRole( 'radio', { name: 'J' } )
			).toBeInTheDocument();
		} );

		it( 'with icons', async () => {
			await render(
				<Component value="uppercase" label="Test Toggle Group Control">
					<ToggleGroupControlOptionIcon
						value="uppercase"
						icon={ formatUppercase }
						label="Uppercase"
					/>

					<ToggleGroupControlOptionIcon
						value="lowercase"
						icon={ formatLowercase }
						label="Lowercase"
					/>
				</Component>
			);

			expect(
				screen.getByRole( 'radio', { name: 'Uppercase' } )
			).toBeChecked();
			expect(
				screen.getByRole( 'radio', { name: 'Lowercase' } )
			).not.toBeChecked();
		} );
	} );
	it( 'should render with the correct option initially selected when `value` is defined', async () => {
		await render(
			<Component value="jack" label="Test Toggle Group Control">
				{ options }
			</Component>
		);
		expect( screen.getByRole( 'radio', { name: 'R' } ) ).not.toBeChecked();
		expect( screen.getByRole( 'radio', { name: 'J' } ) ).toBeChecked();
	} );
	it( 'should render without a selected option when `value` is `undefined`', async () => {
		await render(
			<Component label="Test Toggle Group Control">{ options }</Component>
		);
		expect( screen.getByRole( 'radio', { name: 'R' } ) ).not.toBeChecked();
		expect( screen.getByRole( 'radio', { name: 'J' } ) ).not.toBeChecked();
	} );
	it( 'should call onChange with proper value', async () => {
		const mockOnChange = vi.fn();

		await render(
			<Component
				value="jack"
				onChange={ mockOnChange }
				label="Test Toggle Group Control"
			>
				{ options }
			</Component>
		);

		await userEvent.click( screen.getByRole( 'radio', { name: 'R' } ) );

		expect( mockOnChange ).toHaveBeenCalledWith( 'rigas' );
	} );

	it( 'should not set a value on focus', async () => {
		await render(
			<Component label="Test Toggle Group Control">{ options }</Component>
		);

		const radio = screen.getByRole( 'radio', { name: 'R' } );
		expect( radio ).not.toBeChecked();

		await userEvent.tab();
		expect( radio ).toHaveFocus();
		expect( radio ).not.toBeChecked();
	} );

	if ( mode === 'controlled' ) {
		it( 'should not set a value on focus, after the value is reset', async () => {
			await render(
				<Component label="Test Toggle Group Control" value="jack">
					{ options }
				</Component>
			);

			expect( screen.getByRole( 'radio', { name: 'J' } ) ).toBeChecked();

			await userEvent.click(
				screen.getByRole( 'button', { name: 'Reset' } )
			);

			expect(
				screen.getByRole( 'radio', { name: 'J' } )
			).not.toBeChecked();

			await userEvent.tab( { shift: true } );
			expect(
				screen.getByRole( 'radio', { name: 'R' } )
			).not.toBeChecked();
			expect(
				screen.getByRole( 'radio', { name: 'J' } )
			).not.toBeChecked();
		} );
	}

	it( 'should render tooltip where `showTooltip` === `true`', async () => {
		await render(
			<Component label="Test Toggle Group Control">
				{ optionsWithTooltip }
			</Component>
		);

		const firstRadio = screen.getByLabelText(
			'Click for Delicious Gnocchi'
		);

		await userEvent.hover( firstRadio );

		const tooltip = await screen.findByRole( 'tooltip', {
			name: 'Click for Delicious Gnocchi',
		} );

		await waitFor( () => expect( tooltip ).toBeVisible() );

		// hover outside of radio
		await hoverOutside();

		// Tooltip should hide
		expect(
			screen.queryByRole( 'tooltip', {
				name: 'Click for Delicious Gnocchi',
			} )
		).not.toBeInTheDocument();
	} );

	it( 'should not render tooltip', async () => {
		await render(
			<Component label="Test Toggle Group Control">
				{ optionsWithTooltip }
			</Component>
		);

		const secondRadio = screen.getByLabelText(
			'Click for Sumptuous Caponata'
		);

		await userEvent.hover( secondRadio );

		// Tooltip shouldn't show
		expect(
			screen.queryByText( 'Click for Sumptuous Caponata' )
		).not.toBeInTheDocument();

		// Advance time by default delay
		await sleep( TOOLTIP_DELAY );

		// Tooltip shouldn't show.
		expect(
			screen.queryByText( 'Click for Sumptuous Caponata' )
		).not.toBeInTheDocument();
	} );

	if ( mode === 'controlled' ) {
		it( 'should reset values correctly when default value is undefined', async () => {
			await render(
				<Component label="Test Toggle Group Control">
					{ options }
				</Component>
			);

			const rigasOption = screen.getByRole( 'radio', { name: 'R' } );
			const jackOption = screen.getByRole( 'radio', { name: 'J' } );

			await userEvent.click( rigasOption );

			expect( jackOption ).not.toBeChecked();
			expect( rigasOption ).toBeChecked();

			await userEvent.click(
				screen.getByRole( 'button', { name: 'Reset' } )
			);

			expect( rigasOption ).not.toBeChecked();
			expect( jackOption ).not.toBeChecked();
		} );

		it( 'should reset values correctly when default value is defined', async () => {
			await render(
				<Component label="Test Toggle Group Control" value="rigas">
					{ options }
				</Component>
			);

			const rigasOption = screen.getByRole( 'radio', {
				name: 'R',
			} );
			const jackOption = screen.getByRole( 'radio', {
				name: 'J',
			} );

			expect( rigasOption ).toBeChecked();
			expect( jackOption ).not.toBeChecked();

			await userEvent.click(
				screen.getByRole( 'button', { name: 'Reset' } )
			);

			expect( rigasOption ).not.toBeChecked();
			expect( jackOption ).not.toBeChecked();
		} );

		describe.each( [
			[ 'undefined', undefined ],
			[ 'defined', 'rigas' ],
		] )(
			'should update correctly when triggered by external updates',
			( defaultValueType, defaultValue ) => {
				it( `when default value is ${ defaultValueType }`, async () => {
					await render(
						<Component
							value={ defaultValue }
							label="Test Toggle Group Control"
							extraButtonOptions={ [
								{ name: 'Rigas', value: 'rigas' },
								{ name: 'Jack', value: 'jack' },
							] }
						>
							{ options }
						</Component>
					);

					await userEvent.click(
						screen.getByRole( 'button', { name: 'Jack' } )
					);
					expect(
						screen.getByRole( 'radio', { name: 'J' } )
					).toBeChecked();
					expect(
						screen.getByRole( 'radio', { name: 'R' } )
					).not.toBeChecked();

					await userEvent.click(
						screen.getByRole( 'button', { name: 'Rigas' } )
					);
					expect(
						screen.getByRole( 'radio', { name: 'R' } )
					).toBeChecked();
					expect(
						screen.getByRole( 'radio', { name: 'J' } )
					).not.toBeChecked();
				} );
			}
		);
	}

	it( 'should render the label', async () => {
		await render(
			<Component label="Test Toggle Group Control">{ options }</Component>
		);

		expect( screen.getByText( 'Test Toggle Group Control' ) ).toBeVisible();
	} );

	it( 'should still label the control accessibly when hideLabelFromVision is true', async () => {
		await render(
			<Component label="Test Toggle Group Control" hideLabelFromVision>
				{ options }
			</Component>
		);

		expect(
			screen.getByRole( 'radiogroup', {
				name: 'Test Toggle Group Control',
			} )
		).toBeVisible();
	} );

	it( 'should accessibly associate the help text', async () => {
		await render(
			<Component label="Test Toggle Group Control" help="Help text">
				{ options }
			</Component>
		);

		expect(
			screen.getByRole( 'radiogroup', {
				description: 'Help text',
			} )
		).toBeVisible();
	} );

	it( 'should accessibly associate the help text when isDeselectable', async () => {
		await render(
			<Component
				label="Test Toggle Group Control"
				help="Help text"
				isDeselectable
			>
				{ options }
			</Component>
		);

		expect(
			screen.getByRole( 'group', {
				description: 'Help text',
			} )
		).toBeVisible();
	} );

	describe( 'isDeselectable', () => {
		describe( 'isDeselectable = false', () => {
			it( 'should not be deselectable', async () => {
				const mockOnChange = vi.fn();

				await render(
					<Component
						value="rigas"
						label="Test"
						onChange={ mockOnChange }
					>
						{ options }
					</Component>
				);

				const rigas = screen.getByRole( 'radio', {
					name: 'R',
					checked: true,
				} );
				await userEvent.click( rigas );
				expect( mockOnChange ).toHaveBeenCalledTimes( 0 );
			} );

			it( 'should not tab to next radio option', async () => {
				await render(
					<>
						<Component value="rigas" label="Test">
							{ options }
						</Component>
						<button>After ToggleGroupControl</button>
					</>
				);

				const rigas = screen.getByRole( 'radio', {
					name: 'R',
				} );

				await userEvent.tab();
				expect( rigas ).toHaveFocus();

				await userEvent.tab();

				// When in controlled mode, there is an additional "Reset" button.
				const expectedFocusTarget =
					mode === 'uncontrolled'
						? screen.getByRole( 'button', {
								name: 'After ToggleGroupControl',
							} )
						: screen.getByRole( 'button', { name: 'Reset' } );

				expect( expectedFocusTarget ).toHaveFocus();
			} );

			it( 'should ignore disabled radio options', async () => {
				const mockOnChange = vi.fn();

				await render(
					<Component
						value="pizza"
						onChange={ mockOnChange }
						label="Test Toggle Group Control"
					>
						{ optionsWithDisabledOption }
					</Component>
				);

				await userEvent.tab();

				expect(
					screen.getByRole( 'radio', { name: 'Pizza' } )
				).toBeChecked();
				expect(
					screen.getByRole( 'radio', { name: 'Rice' } )
				).toBeDisabled();

				// Arrow navigation skips the disabled option
				await userEvent.keyboard( '{ArrowRight}' );
				expect(
					screen.getByRole( 'radio', { name: 'Pasta' } )
				).toBeChecked();
				expect( mockOnChange ).toHaveBeenCalledTimes( 1 );
				expect( mockOnChange ).toHaveBeenLastCalledWith( 'pasta' );

				// Arrow navigation skips the disabled option
				await userEvent.keyboard( '{ArrowLeft}' );
				expect(
					screen.getByRole( 'radio', { name: 'Pizza' } )
				).toBeChecked();
				expect( mockOnChange ).toHaveBeenCalledTimes( 2 );
				expect( mockOnChange ).toHaveBeenLastCalledWith( 'pizza' );

				// Clicks don't cause the option to be selected
				await userEvent.click(
					screen.getByRole( 'radio', { name: 'Rice' } ),
					{ force: true }
				);
				expect(
					screen.getByRole( 'radio', { name: 'Pizza' } )
				).toBeChecked();
				expect( mockOnChange ).toHaveBeenCalledTimes( 2 );
			} );
		} );

		describe( 'isDeselectable = true', () => {
			it( 'should be deselectable', async () => {
				const mockOnChange = vi.fn();

				await render(
					<Component
						value="rigas"
						label="Test"
						onChange={ mockOnChange }
						isDeselectable
					>
						{ options }
					</Component>
				);

				await userEvent.click(
					screen.getByRole( 'button', {
						name: 'R',
						pressed: true,
					} )
				);
				expect( mockOnChange ).toHaveBeenCalledTimes( 1 );
				expect( mockOnChange ).toHaveBeenLastCalledWith( undefined );

				await userEvent.click(
					screen.getByRole( 'button', {
						name: 'R',
						pressed: false,
					} )
				);
				expect( mockOnChange ).toHaveBeenCalledTimes( 2 );
				expect( mockOnChange ).toHaveBeenLastCalledWith( 'rigas' );
			} );

			it( 'should tab to the next option button', async () => {
				await render(
					<Component isDeselectable value="rigas" label="Test">
						{ options }
					</Component>
				);

				await userEvent.tab();
				expect(
					screen.getByRole( 'button', {
						name: 'R',
						pressed: true,
					} )
				).toHaveFocus();

				await userEvent.tab();
				expect(
					screen.getByRole( 'button', {
						name: 'J',
						pressed: false,
					} )
				).toHaveFocus();

				// Focus should not move with arrow keys
				await userEvent.keyboard( '{ArrowLeft}' );
				expect(
					screen.getByRole( 'button', {
						name: 'J',
						pressed: false,
					} )
				).toHaveFocus();
			} );

			it( 'should ignore disabled options', async () => {
				const mockOnChange = vi.fn();

				await render(
					<Component
						value="pizza"
						isDeselectable
						onChange={ mockOnChange }
						label="Test Toggle Group Control"
					>
						{ optionsWithDisabledOption }
					</Component>
				);

				await userEvent.tab();

				expect(
					screen.getByRole( 'button', {
						name: 'Pizza',
						pressed: true,
					} )
				).toBeVisible();
				expect(
					screen.getByRole( 'button', {
						name: 'Rice',
						pressed: false,
					} )
				).toBeDisabled();

				// Tab key navigation skips the disabled option
				await userEvent.tab();
				await userEvent.keyboard( ' ' );
				expect(
					screen.getByRole( 'button', {
						name: 'Pasta',
						pressed: true,
					} )
				).toHaveFocus();
				expect( mockOnChange ).toHaveBeenCalledTimes( 1 );
				expect( mockOnChange ).toHaveBeenLastCalledWith( 'pasta' );

				// Tab key navigation skips the disabled option
				await userEvent.tab( { shift: true } );
				expect(
					screen.getByRole( 'button', {
						name: 'Pizza',
						pressed: false,
					} )
				).toHaveFocus();

				// Clicks don't cause the option to be selected.
				await userEvent.click(
					screen.getByRole( 'button', { name: 'Rice' } ),
					{ force: true }
				);
				expect( mockOnChange ).toHaveBeenCalledTimes( 1 );
			} );
		} );
	} );

	describe( 'disabled', () => {
		it( 'should not select another option when the control is disabled', async () => {
			const mockOnChange = vi.fn();

			await render(
				<Component
					value="rigas"
					label="Test"
					disabled
					onChange={ mockOnChange }
				>
					{ options }
				</Component>
			);

			expectGroupChromeDisabled(
				screen.getByRole( 'radiogroup', { name: 'Test' } )
			);

			expect( screen.getByRole( 'radio', { name: 'R' } ) ).toBeChecked();

			// Force pointer input so pointer and mouse handlers still run while
			// Chromium suppresses the disabled control's click event.
			await userEvent.click( screen.getByRole( 'radio', { name: 'J' } ), {
				force: true,
			} );

			expect( screen.getByRole( 'radio', { name: 'R' } ) ).toBeChecked();
			expect(
				screen.getByRole( 'radio', { name: 'J' } )
			).not.toBeChecked();
			expect( mockOnChange ).not.toHaveBeenCalled();

			await userEvent.keyboard( '{ArrowRight}' );
			expect( mockOnChange ).not.toHaveBeenCalled();
		} );

		it( 'should skip the disabled control when tabbing', async () => {
			await render(
				<>
					<button>Before ToggleGroupControl</button>
					<Component value="rigas" label="Test" disabled>
						{ options }
					</Component>
					<button>After ToggleGroupControl</button>
				</>
			);

			await userEvent.tab();
			expect(
				screen.getByRole( 'button', {
					name: 'Before ToggleGroupControl',
				} )
			).toHaveFocus();

			await userEvent.tab();

			const expectedFocusTarget =
				mode === 'uncontrolled'
					? screen.getByRole( 'button', {
							name: 'After ToggleGroupControl',
						} )
					: screen.getByRole( 'button', { name: 'Reset' } );

			expect( expectedFocusTarget ).toHaveFocus();
		} );

		it( 'should keep the selected option when the control is disabled', async () => {
			await render(
				<Component value="jack" label="Test" disabled>
					{ options }
				</Component>
			);

			expect( screen.getByRole( 'radio', { name: 'J' } ) ).toBeChecked();
			expect(
				screen.getByRole( 'radio', { name: 'R' } )
			).not.toBeChecked();
		} );

		it( 'should not call onChange when a disabled control is clicked', async () => {
			const mockOnChange = vi.fn();

			await render(
				<Component
					value="rigas"
					label="Test"
					disabled
					onChange={ mockOnChange }
				>
					{ options }
				</Component>
			);

			await userEvent.click( screen.getByRole( 'radio', { name: 'J' } ), {
				force: true,
			} );
			await userEvent.click( screen.getByRole( 'radio', { name: 'R' } ), {
				force: true,
			} );

			expect( mockOnChange ).not.toHaveBeenCalled();
		} );

		it( 'should disable every option when the control is disabled, including options without their own disabled prop', async () => {
			await render(
				<Component value="pizza" label="Test" disabled>
					{ optionsWithDisabledOption }
				</Component>
			);

			expectGroupChromeDisabled(
				screen.getByRole( 'radiogroup', { name: 'Test' } )
			);

			expect(
				screen.getByRole( 'radio', { name: 'Pizza' } )
			).toBeDisabled();
			expect(
				screen.getByRole( 'radio', { name: 'Rice' } )
			).toBeDisabled();
			expect(
				screen.getByRole( 'radio', { name: 'Pasta' } )
			).toBeDisabled();
		} );

		it( 'should not deselect the pressed option when the control is disabled', async () => {
			const mockOnChange = vi.fn();

			await render(
				<Component
					value="rigas"
					label="Test"
					onChange={ mockOnChange }
					isDeselectable
					disabled
				>
					{ options }
				</Component>
			);

			expectGroupChromeDisabled(
				screen.getByRole( 'group', { name: 'Test' } )
			);

			const pressed = screen.getByRole( 'button', {
				name: 'R',
				pressed: true,
			} );
			expect( pressed ).toBeVisible();
			expect( pressed ).toBeDisabled();

			await userEvent.click( pressed, { force: true } );

			expect(
				screen.getByRole( 'button', {
					name: 'R',
					pressed: true,
				} )
			).toBeVisible();
			expect( mockOnChange ).not.toHaveBeenCalled();
		} );

		it( 'should skip a deselectable disabled control when tabbing', async () => {
			await render(
				<>
					<button>Before ToggleGroupControl</button>
					<Component
						isDeselectable
						value="rigas"
						label="Test"
						disabled
					>
						{ options }
					</Component>
					<button>After ToggleGroupControl</button>
				</>
			);

			await userEvent.tab();
			expect(
				screen.getByRole( 'button', {
					name: 'Before ToggleGroupControl',
				} )
			).toHaveFocus();

			await userEvent.tab();

			const expectedFocusTarget =
				mode === 'uncontrolled'
					? screen.getByRole( 'button', {
							name: 'After ToggleGroupControl',
						} )
					: screen.getByRole( 'button', { name: 'Reset' } );

			expect( expectedFocusTarget ).toHaveFocus();
		} );

		it( 'should not call onChange when a deselectable disabled control is clicked', async () => {
			const mockOnChange = vi.fn();

			await render(
				<Component
					value="rigas"
					label="Test"
					onChange={ mockOnChange }
					isDeselectable
					disabled
				>
					{ options }
				</Component>
			);

			await userEvent.click(
				screen.getByRole( 'button', { name: 'R', pressed: true } ),
				{ force: true }
			);
			await userEvent.click(
				screen.getByRole( 'button', { name: 'J', pressed: false } ),
				{ force: true }
			);

			expect( mockOnChange ).not.toHaveBeenCalled();
		} );
	} );
} );

test( 'should render block styles with enclosing borders', async () => {
	await render(
		<ToggleGroupControl label="Test Toggle Group Control" isBlock>
			{ options }
		</ToggleGroupControl>
	);

	const control = screen.getByRole( 'radiogroup', {
		name: 'Test Toggle Group Control',
	} );

	expect( control ).toHaveClass(
		controlStyles[ 'toggle-group-control' ],
		controlStyles[ 'is-block' ],
		controlStyles[ 'has-border' ],
		controlStyles[ 'has-enclosing-borders' ]
	);
} );

test( 'should render deselectable styles without enclosing borders', async () => {
	await render(
		<ToggleGroupControl label="Test Toggle Group Control" isDeselectable>
			{ options }
		</ToggleGroupControl>
	);

	const control = screen.getByRole( 'group', {
		name: 'Test Toggle Group Control',
	} );
	const option = screen.getByRole( 'button', { name: 'R' } );

	expect( control ).toHaveClass( controlStyles[ 'toggle-group-control' ] );
	expect( control ).not.toHaveClass(
		controlStyles[ 'has-border' ],
		controlStyles[ 'has-enclosing-borders' ]
	);
	expect( option ).toHaveClass(
		optionStyles.button,
		optionStyles[ 'is-deselectable' ]
	);
} );

test( 'should keep its width when the pressed option changes', async () => {
	await render(
		<ControlledToggleGroupControl
			label="Test Toggle Group Control"
			value="narrow"
		>
			<ToggleGroupControlOption value="narrow" label="i" />
			<ToggleGroupControlOption value="wide" label="MMMMMMMM" />
		</ControlledToggleGroupControl>
	);

	const control = screen.getByRole( 'radiogroup', {
		name: 'Test Toggle Group Control',
	} );
	const wideOption = screen.getByRole( 'radio', { name: 'MMMMMMMM' } );
	const initialWidth = control.getBoundingClientRect().width;

	await userEvent.click( wideOption );
	await waitFor( () => expect( wideOption ).toBeChecked() );
	// Wait for the font weight transition to finish.
	await Promise.all(
		wideOption.getAnimations().map( ( animation ) => animation.finished )
	);

	expect( control.getBoundingClientRect().width ).toBe( initialWidth );
} );
