test(core): add coverage tests for uncovered utilities

Author: bobbor

packages/core/__tests__/errors/APIError.test.ts

@@ -0,0 +1,47 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { ApiError } from '../../src/errors/APIError';
+
+describe('ApiError', () => {
+	it('creates error without response', () => {
+		const error = new ApiError({
+			name: 'TestError',
+			message: 'Test message',
+		});
+		expect(error.name).toBe('TestError');
+		expect(error.message).toBe('Test message');
+		expect(error.response).toBeUndefined();
+	});
+
+	it('creates error with response', () => {
+		const response = {
+			statusCode: 404,
+			headers: { 'content-type': 'application/json' },
+			body: '{"error":"Not found"}',
+		};
+		const error = new ApiError({
+			name: 'NotFoundError',
+			message: 'Resource not found',
+			response,
+		});
+		expect(error.response).toEqual(response);
+		expect(error.response).not.toBe(response);
+		expect(error.response?.headers).not.toBe(response.headers);
+	});
+
+	it('replicates response to prevent mutation', () => {
+		const response = {
+			statusCode: 500,
+			headers: { 'x-custom': 'value' },
+		};
+		const error = new ApiError({
+			name: 'ServerError',
+			message: 'Server error',
+			response,
+		});
+		const errorResponse = error.response;
+		response.headers['x-custom'] = 'modified';
+		expect(errorResponse?.headers['x-custom']).toBe('value');
+	});
+});

packages/core/__tests__/singleton/Auth/utils/index.test.ts

@@ -1,4 +1,9 @@
-import { decodeJWT } from '../../../../src/singleton/Auth/utils';
+import {
+	assertIdentityPoolIdConfig,
+	assertOAuthConfig,
+	assertTokenProviderConfig,
+	decodeJWT,
+} from '../../../../src/singleton/Auth/utils';
 
 const testSamples = [
 	{
@@ -35,4 +40,111 @@ describe('decodeJWT', () => {
 			expect(result.toString()).toEqual(token);
 		},
 	);
+
+	it('throws error for invalid token format', () => {
+		expect(() => decodeJWT('invalid')).toThrow('Invalid token');
+	});
+
+	it('throws error for malformed payload', () => {
+		expect(() => decodeJWT('header.invalid-payload.signature')).toThrow(
+			'Invalid token payload',
+		);
+	});
+});
+
+describe('assertTokenProviderConfig', () => {
+	it('passes with valid user pool config', () => {
+		expect(() => {
+			assertTokenProviderConfig({
+				userPoolId: 'us-east-1_test',
+				userPoolClientId: 'client123',
+			});
+		}).not.toThrow();
+	});
+
+	it('throws when config is undefined', () => {
+		expect(() => {
+			assertTokenProviderConfig(undefined);
+		}).toThrow();
+	});
+
+	it('throws when userPoolId is missing', () => {
+		expect(() => {
+			assertTokenProviderConfig({
+				userPoolClientId: 'client123',
+			} as any);
+		}).toThrow();
+	});
+
+	it('throws when userPoolClientId is missing', () => {
+		expect(() => {
+			assertTokenProviderConfig({
+				userPoolId: 'us-east-1_test',
+			} as any);
+		}).toThrow();
+	});
+});
+
+describe('assertOAuthConfig', () => {
+	it('passes with valid oauth config', () => {
+		expect(() => {
+			assertOAuthConfig({
+				userPoolId: 'us-east-1_test',
+				userPoolClientId: 'client123',
+				loginWith: {
+					oauth: {
+						domain: 'example.auth.us-east-1.amazoncognito.com',
+						redirectSignIn: ['http://localhost:3000/'],
+						redirectSignOut: ['http://localhost:3000/'],
+						responseType: 'code',
+						scopes: ['openid'],
+					},
+				},
+			});
+		}).not.toThrow();
+	});
+
+	it('throws when oauth config is missing', () => {
+		expect(() => {
+			assertOAuthConfig(undefined);
+		}).toThrow();
+	});
+
+	it('throws when domain is missing', () => {
+		expect(() => {
+			assertOAuthConfig({
+				userPoolId: 'us-east-1_test',
+				userPoolClientId: 'client123',
+				loginWith: {
+					oauth: {
+						redirectSignIn: ['http://localhost:3000/'],
+						redirectSignOut: ['http://localhost:3000/'],
+						responseType: 'code',
+					} as any,
+				},
+			});
+		}).toThrow();
+	});
+});
+
+describe('assertIdentityPoolIdConfig', () => {
+	it('passes with valid identity pool config', () => {
+		expect(() => {
+			assertIdentityPoolIdConfig({
+				identityPoolId: 'us-east-1:test-id',
+			});
+		}).not.toThrow();
+	});
+
+	it('throws when identityPoolId is missing', () => {
+		expect(() => {
+			assertIdentityPoolIdConfig(undefined);
+		}).toThrow();
+	});
+
+	it('throws when identityPoolId is empty', () => {
+		expect(() => {
+			assertIdentityPoolIdConfig({} as any);
+		}).toThrow();
+	});
 });

packages/core/__tests__/singleton/contextBrand.test.ts

@@ -0,0 +1,28 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AMPLIFY_CONTEXT_BRAND, isAmplifyContext } from '@aws-amplify/core';
+
+describe('isAmplifyContext', () => {
+	it('returns true for branded context', () => {
+		const ctx = { [AMPLIFY_CONTEXT_BRAND]: true };
+		expect(isAmplifyContext(ctx)).toBe(true);
+	});
+
+	it('returns false for null', () => {
+		expect(isAmplifyContext(null)).toBe(false);
+	});
+
+	it('returns false for undefined', () => {
+		expect(isAmplifyContext(undefined)).toBe(false);
+	});
+
+	it('returns false for non-object', () => {
+		expect(isAmplifyContext('string')).toBe(false);
+		expect(isAmplifyContext(123)).toBe(false);
+	});
+
+	it('returns false for object without brand', () => {
+		expect(isAmplifyContext({})).toBe(false);
+	});
+});

packages/core/__tests__/storage/InMemoryStorage.test.ts

@@ -37,6 +37,11 @@ describe('InMemoryStorage', () => {
 		expect(inMemoryStorage.key(1)).toEqual('2');
 	});
 
+	it('should return null for out of bounds index', () => {
+		inMemoryStorage.setItem('1', value);
+		expect(inMemoryStorage.key(10)).toBeNull();
+	});
+
 	it('should not throw if trying to delete a non existing key', () => {
 		const badKey = 'nonExistingKey';
 		expect(() => {

packages/core/__tests__/storage/SyncKeyValueStorage.test.ts

@@ -0,0 +1,35 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { SyncKeyValueStorage } from '../../src/storage/SyncKeyValueStorage';
+
+describe('SyncKeyValueStorage', () => {
+	it('throws when accessing storage without initialization', () => {
+		const storage = new SyncKeyValueStorage();
+		expect(() => {
+			storage.setItem('key', 'value');
+		}).toThrow();
+	});
+
+	it('works with provided storage', () => {
+		const mockStorage = {
+			setItem: jest.fn(),
+			getItem: jest.fn(() => 'value'),
+			removeItem: jest.fn(),
+			clear: jest.fn(),
+		} as any;
+
+		const storage = new SyncKeyValueStorage(mockStorage);
+		storage.setItem('key', 'value');
+		expect(mockStorage.setItem).toHaveBeenCalledWith('key', 'value');
+
+		const value = storage.getItem('key');
+		expect(value).toBe('value');
+
+		storage.removeItem('key');
+		expect(mockStorage.removeItem).toHaveBeenCalledWith('key');
+
+		storage.clear();
+		expect(mockStorage.clear).toHaveBeenCalled();
+	});
+});

packages/core/__tests__/utils/WordArray.test.ts

@@ -0,0 +1,42 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { WordArray } from '../../src/utils/WordArray';
+
+describe('WordArray', () => {
+	test('creates empty WordArray', () => {
+		const wa = new WordArray();
+		expect(wa.words).toEqual([]);
+		expect(wa.sigBytes).toBe(0);
+	});
+
+	test('creates WordArray with words', () => {
+		const wa = new WordArray([0x12345678, 0x9abcdef0]);
+		expect(wa.words).toEqual([0x12345678, 0x9abcdef0]);
+		expect(wa.sigBytes).toBe(8);
+	});
+
+	test('creates WordArray with custom sigBytes', () => {
+		const wa = new WordArray([0x12345678], 3);
+		expect(wa.sigBytes).toBe(3);
+	});
+
+	test('random generates WordArray', () => {
+		const wa = new WordArray();
+		const random = wa.random(8);
+		expect(random.words.length).toBe(2);
+		expect(random.sigBytes).toBe(8);
+	});
+
+	test('toString converts to hex', () => {
+		const wa = new WordArray([0x12345678], 4);
+		const hex = wa.toString();
+		expect(hex).toBe('12345678');
+	});
+
+	test('toString handles partial bytes', () => {
+		const wa = new WordArray([0x12345678], 2);
+		const hex = wa.toString();
+		expect(hex).toBe('1234');
+	});
+});

packages/core/__tests__/utils/deepFreeze.test.ts

@@ -0,0 +1,26 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { deepFreeze } from '../../src/utils/deepFreeze';
+
+describe('deepFreeze', () => {
+	test('freezes simple object', () => {
+		const obj = { a: 1, b: 2 };
+		const frozen = deepFreeze(obj);
+		expect(Object.isFrozen(frozen)).toBe(true);
+	});
+
+	test('freezes nested objects', () => {
+		const obj = { a: { b: { c: 1 } } };
+		const frozen = deepFreeze(obj);
+		expect(Object.isFrozen(frozen)).toBe(true);
+		expect(Object.isFrozen(frozen.a)).toBe(true);
+		expect(Object.isFrozen(frozen.a.b)).toBe(true);
+	});
+
+	test('freezes functions', () => {
+		const obj = { fn: () => 'test' };
+		const frozen = deepFreeze(obj);
+		expect(Object.isFrozen(frozen.fn)).toBe(true);
+	});
+});

packages/core/__tests__/utils/getClientInfo/getClientInfo.test.ts

@@ -179,4 +179,29 @@ describe('getClientInfo', () => {
 			expect(result).toEqual(expect.objectContaining(expectedResult));
 		},
 	);
+
+	test('returns empty object when window is undefined', () => {
+		const originalWindow = (global as any).window;
+		delete (global as any).window;
+		const result = getClientInfo();
+		expect(result).toEqual({});
+		(global as any).window = originalWindow;
+	});
+
+	test('returns empty object when navigator is undefined', () => {
+		mockNavigator.mockReturnValueOnce(undefined as any);
+		const result = getClientInfo();
+		expect(result).toEqual({});
+	});
+
+	test('handles unknown user agent', () => {
+		mockNavigator.mockReturnValueOnce({
+			userAgent: 'UnknownBrowser',
+			platform: 'Unknown',
+			language: 'en',
+		} as any);
+		const result = getClientInfo();
+		expect(result.model).toBe('');
+		expect(result.version).toBe('');
+	});
 });