feat(core): upgrades MUI to v6

BREAKING CHANGE: Upgrades MUI version to v6

Author: pavankjadda

react-kit/src/tests/buttons/DeleteButton.test.tsx

@@ -0,0 +1,63 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { DeleteButton } from '../../lib/components/buttons/DeleteButton';
+import '@testing-library/jest-dom';
+import jest from 'jest-mock';
+
+test('renders DeleteButton component', () => {
+	render(
+		<DeleteButton
+			loading={false}
+			onClick={() => {
+				console.log('Clicked Delete Button');
+			}}
+		/>
+	);
+
+	const deleteButton = screen.getByRole('button', { name: 'Delete' });
+	expect(deleteButton).toBeInTheDocument();
+});
+
+test('renders DeleteButton with custom label', () => {
+	render(
+		<DeleteButton
+			loading={false}
+			label="Remove"
+			onClick={() => {
+				console.log('Clicked Delete Button');
+			}}
+		/>
+	);
+
+	const deleteButton = screen.getByRole('button', { name: 'Remove' });
+	expect(deleteButton).toBeInTheDocument();
+});
+
+test('renders with custom data-cy attribute', () => {
+	render(<DeleteButton loading={false} name="Delete" dataCy="custom-delete-button" onClick={() => {}} />);
+
+	const deleteButton = screen.getByRole('button', { name: 'Delete' });
+	expect(deleteButton).toHaveAttribute('data-cy', 'custom-delete-button');
+});
+
+test('renders with custom startIcon', () => {
+	render(<DeleteButton loading={false} name="Delete" startIcon={<span data-testid="custom-icon" />} onClick={() => {}} />);
+
+	const customIcon = screen.getByTestId('custom-icon');
+	expect(customIcon).toBeInTheDocument();
+});
+
+test('renders with custom type', () => {
+	render(<DeleteButton loading={false} name="Delete" type="submit" onClick={() => {}} />);
+
+	const deleteButton = screen.getByRole('button', { name: 'Delete' });
+	expect(deleteButton).toHaveAttribute('type', 'submit');
+});
+
+test('calls onClick when clicked', () => {
+	const handleClick = jest.fn();
+	render(<DeleteButton loading={false} name="Delete" onClick={handleClick} />);
+
+	const deleteButton = screen.getByRole('button', { name: 'Delete' });
+	fireEvent.click(deleteButton);
+	expect(handleClick).toHaveBeenCalledTimes(1);
+});

react-kit/src/tests/utils/BooleanUtils.test.ts

@@ -0,0 +1,35 @@
+import { parseBoolean } from '../../lib/utils/BooleanUtils';
+
+describe('parseBoolean', () => {
+	it('should return true for boolean true', () => {
+		expect(parseBoolean(true)).toBe(true);
+	});
+
+	it('should return false for boolean false', () => {
+		expect(parseBoolean(false)).toBe(false);
+	});
+
+	it('should return true for string "true"', () => {
+		expect(parseBoolean('true')).toBe(true);
+	});
+
+	it('should return false for string "false"', () => {
+		expect(parseBoolean('false')).toBe(false);
+	});
+
+	it('should return false for null', () => {
+		expect(parseBoolean(null)).toBe(false);
+	});
+
+	it('should return false for undefined', () => {
+		expect(parseBoolean(undefined)).toBe(false);
+	});
+
+	it('should return false for an empty string', () => {
+		expect(parseBoolean('')).toBe(false);
+	});
+
+	it('should return false for any other string', () => {
+		expect(parseBoolean('random')).toBe(false);
+	});
+});

react-kit/src/tests/utils/CssUtils.test.ts

@@ -0,0 +1,17 @@
+import { getCssVariable } from '../../lib/utils/CssUtils';
+
+describe('getCssVariable', () => {
+	beforeAll(() => {
+		document.documentElement.style.setProperty('--test-variable', 'test-value');
+	});
+
+	it('should return the value of the CSS variable', () => {
+		const value = getCssVariable('--test-variable');
+		expect(value).toBe('test-value');
+	});
+
+	it('should return an empty string for a non-existent variable', () => {
+		const value = getCssVariable('--non-existent-variable');
+		expect(value).toBe('');
+	});
+});

react-kit/src/tests/utils/DateUtils.test.ts

@@ -0,0 +1,46 @@
+import { convertToIsoDate, formatDate, setCookieExpirationDate } from '../../lib/utils/DateUtils';
+import { format, parseISO } from 'date-fns';
+import { SystemConfig } from '../../lib/constants/AppConstants';
+import '@testing-library/jest-dom';
+
+describe('DateUtils', () => {
+	describe('setCookieExpirationDate', () => {
+		it('should set cookie expiration date to 24 hours from now', () => {
+			const now = new Date();
+			const expectedDate = new Date(now.getTime() + SystemConfig.SYSTEM_COOKIE_TIMEOUT_MILLI_SECONDS);
+
+			const result = setCookieExpirationDate();
+
+			expect(result).toEqual(expectedDate);
+		});
+	});
+
+	describe('convertToIsoDate', () => {
+		it('should convert current date time to ISO date format', () => {
+			const currentDateTime = '2023-10-01T12:00:00Z';
+			const formattedDate = format(new Date(currentDateTime), SystemConfig.ISO_DATE_FORMAT);
+
+			const result = convertToIsoDate(currentDateTime);
+
+			expect(result).toBe(formattedDate);
+		});
+	});
+
+	describe('formatDate', () => {
+		it('should return an empty string if date is undefined', () => {
+			const result = formatDate(undefined, 'yyyy-MM-dd');
+			expect(result).toBe('');
+		});
+
+		it('should format the date to the new format', () => {
+			const date = '2023-10-01T12:00:00Z';
+			const newFormat = 'yyyy-MM-dd';
+			const parsedDate = parseISO(date);
+			const formattedDate = format(parsedDate, newFormat);
+
+			const result = formatDate(date, newFormat);
+
+			expect(result).toBe(formattedDate);
+		});
+	});
+});

react-kit/src/tests/utils/NumberUtils.test.ts

@@ -0,0 +1,19 @@
+import { parseNumber } from '../../lib/utils/NumberUtils';
+
+describe('parseNumber', () => {
+	it('should return a number when a valid string is provided', () => {
+		expect(parseNumber('123')).toBe(123);
+	});
+
+	it('should return NaN when an invalid string is provided', () => {
+		expect(parseNumber('abc')).toBeNaN();
+	});
+
+	it('should return undefined when null is provided', () => {
+		expect(parseNumber(null)).toBeUndefined();
+	});
+
+	it('should return undefined when undefined is provided', () => {
+		expect(parseNumber(undefined)).toBeUndefined();
+	});
+});

react-kit/src/tests/utils/ProgressStateUtils.test.ts

@@ -0,0 +1,131 @@
+import { initializeState, markError, markLoading, markSuccess } from '../../lib/utils/ProgressStateUtils';
+import { ProgressState } from '../../lib/types/ProgressState';
+
+describe('ProgressStateUtils', () => {
+	describe('initializeState', () => {
+		it('should initialize the state correctly', () => {
+			const expectedState: ProgressState = {
+				isLoading: false,
+				isSuccess: false,
+				isError: false,
+				isComplete: false,
+				message: '',
+			};
+
+			const result = initializeState();
+
+			expect(result).toEqual(expectedState);
+		});
+	});
+
+	describe('markLoading', () => {
+		it('should update the state to loading', () => {
+			const initialState: ProgressState = {
+				isLoading: false,
+				isSuccess: false,
+				isError: false,
+				isComplete: false,
+				message: '',
+			};
+
+			const expectedState: ProgressState = {
+				...initialState,
+				isLoading: true,
+			};
+
+			const result = markLoading(initialState);
+
+			expect(result).toEqual(expectedState);
+		});
+	});
+
+	describe('markSuccess', () => {
+		it('should update the state to success with a message', () => {
+			const initialState: ProgressState = {
+				isLoading: false,
+				isSuccess: false,
+				isError: false,
+				isComplete: false,
+				message: '',
+			};
+
+			const message = 'Operation successful';
+			const expectedState: ProgressState = {
+				...initialState,
+				isSuccess: true,
+				isComplete: true,
+				message,
+			};
+
+			const result = markSuccess(initialState, message);
+
+			expect(result).toEqual(expectedState);
+		});
+
+		it('should update the state to success without a message', () => {
+			const initialState: ProgressState = {
+				isLoading: false,
+				isSuccess: false,
+				isError: false,
+				isComplete: false,
+				message: '',
+			};
+
+			const expectedState: ProgressState = {
+				...initialState,
+				isSuccess: true,
+				isComplete: true,
+				message: '',
+			};
+
+			const result = markSuccess(initialState);
+
+			expect(result).toEqual(expectedState);
+		});
+	});
+
+	describe('markError', () => {
+		it('should update the state to error with a message', () => {
+			const initialState: ProgressState = {
+				isLoading: false,
+				isSuccess: false,
+				isError: false,
+				isComplete: false,
+				message: '',
+			};
+
+			const message = 'Operation failed';
+			const expectedState: ProgressState = {
+				...initialState,
+				isError: true,
+				isComplete: true,
+				message,
+			};
+
+			const result = markError(initialState, message);
+
+			expect(result).toEqual(expectedState);
+		});
+
+		it('should update the state to error without a message', () => {
+			const initialState: ProgressState = {
+				isLoading: false,
+				isSuccess: false,
+				isError: false,
+				isComplete: false,
+				message: '',
+			};
+
+			const expectedState: ProgressState = {
+				...initialState,
+				isError: true,
+				isComplete: true,
+				message: '',
+			};
+
+			const result = markError(initialState);
+
+			expect(result).toEqual(expectedState);
+		});
+	});
+});

react-kit/src/tests/utils/StringUtils.test.ts

@@ -0,0 +1,33 @@
+import { isBlankOrEmpty } from '../../lib/utils/StringUtils';
+
+describe('isBlankOrEmpty', () => {
+	it('should return true for null', () => {
+		expect(isBlankOrEmpty(null)).toBe(true);
+	});
+
+	it('should return true for undefined', () => {
+		expect(isBlankOrEmpty(undefined)).toBe(true);
+	});
+
+	it('should return true for an empty string', () => {
+		expect(isBlankOrEmpty('')).toBe(true);
+	});
+
+	it('should return true for a string with only spaces', () => {
+		expect(isBlankOrEmpty('   ')).toBe(true);
+	});
+
+	it('should return false for a non-empty string', () => {
+		expect(isBlankOrEmpty('hello')).toBe(false);
+	});
+
+	it('should return false for a string with non-space characters', () => {
+		expect(isBlankOrEmpty('  hello  ')).toBe(false);
+	});
+
+	it('should return false for non-string values', () => {
+		expect(isBlankOrEmpty(123)).toBe(false);
+		expect(isBlankOrEmpty({})).toBe(false);
+		expect(isBlankOrEmpty([])).toBe(false);
+	});
+});

react-kit/src/tests/utils/UrlUtils.test.ts

@@ -0,0 +1,19 @@
+import { isEncoded } from '../../lib/utils/UrlUtils';
+
+describe('isEncoded', () => {
+	it('should return true for an encoded URL', () => {
+		expect(isEncoded('https%3A%2F%2Fexample.com')).toBe(true);
+	});
+
+	it('should return false for a non-encoded URL', () => {
+		expect(isEncoded('https://example.com')).toBe(false);
+	});
+
+	it('should return false for an improperly encoded URL', () => {
+		expect(isEncoded('%E0%A4%A')).toBe(false);
+	});
+
+	it('should return false for an empty string', () => {
+		expect(isEncoded('')).toBe(false);
+	});
+});