From 3bef15f3bd7c146dc3768d95642185d983f69b8b Mon Sep 17 00:00:00 2001 From: Marc Mintel Date: Sat, 24 Jan 2026 02:05:43 +0100 Subject: [PATCH] core tests --- .../InMemoryAdminUserRepository.test.ts | 8 +- .../inmemory}/InMemoryAdminUserRepository.ts | 10 +- .../entities/AdminUserOrmEntity.test.ts | 0 .../typeorm/entities/AdminUserOrmEntity.ts | 0 .../errors/TypeOrmAdminSchemaError.test.ts | 0 .../typeorm/errors/TypeOrmAdminSchemaError.ts | 2 +- .../mappers/AdminUserOrmMapper.test.ts | 0 .../typeorm/mappers/AdminUserOrmMapper.ts | 2 +- .../TypeOrmAdminUserRepository.test.ts | 2 +- .../TypeOrmAdminUserRepository.ts | 2 +- .../schema/TypeOrmAdminSchemaGuards.test.ts | 365 ++++++++++++++++++ .../schema/TypeOrmAdminSchemaGuards.ts | 2 +- .../schema/TypeOrmAdminSchemaGuards.test.ts | 253 ------------ 13 files changed, 379 insertions(+), 267 deletions(-) rename {core/admin/infrastructure/persistence => adapters/admin/persistence/inmemory}/InMemoryAdminUserRepository.test.ts (99%) rename {core/admin/infrastructure/persistence => adapters/admin/persistence/inmemory}/InMemoryAdminUserRepository.ts (96%) rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/entities/AdminUserOrmEntity.test.ts (100%) rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/entities/AdminUserOrmEntity.ts (100%) rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/errors/TypeOrmAdminSchemaError.test.ts (100%) rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/errors/TypeOrmAdminSchemaError.ts (99%) rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/mappers/AdminUserOrmMapper.test.ts (100%) rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/mappers/AdminUserOrmMapper.ts (99%) rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/repositories/TypeOrmAdminUserRepository.test.ts (99%) rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/repositories/TypeOrmAdminUserRepository.ts (99%) create mode 100644 adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts rename {core/admin/infrastructure => adapters/admin/persistence}/typeorm/schema/TypeOrmAdminSchemaGuards.ts (99%) delete mode 100644 core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts diff --git a/core/admin/infrastructure/persistence/InMemoryAdminUserRepository.test.ts b/adapters/admin/persistence/inmemory/InMemoryAdminUserRepository.test.ts similarity index 99% rename from core/admin/infrastructure/persistence/InMemoryAdminUserRepository.test.ts rename to adapters/admin/persistence/inmemory/InMemoryAdminUserRepository.test.ts index c7fa74e39..01e476227 100644 --- a/core/admin/infrastructure/persistence/InMemoryAdminUserRepository.test.ts +++ b/adapters/admin/persistence/inmemory/InMemoryAdminUserRepository.test.ts @@ -1,6 +1,6 @@ -import { AdminUser } from '../../domain/entities/AdminUser'; -import { UserRole } from '../../domain/value-objects/UserRole'; -import { UserStatus } from '../../domain/value-objects/UserStatus'; +import { AdminUser } from '@core/admin/domain/entities/AdminUser'; +import { UserRole } from '@core/admin/domain/value-objects/UserRole'; +import { UserStatus } from '@core/admin/domain/value-objects/UserStatus'; import { InMemoryAdminUserRepository } from './InMemoryAdminUserRepository'; describe('InMemoryAdminUserRepository', () => { @@ -787,4 +787,4 @@ describe('InMemoryAdminUserRepository', () => { }); }); }); -}); \ No newline at end of file +}); diff --git a/core/admin/infrastructure/persistence/InMemoryAdminUserRepository.ts b/adapters/admin/persistence/inmemory/InMemoryAdminUserRepository.ts similarity index 96% rename from core/admin/infrastructure/persistence/InMemoryAdminUserRepository.ts rename to adapters/admin/persistence/inmemory/InMemoryAdminUserRepository.ts index a537bd70d..e3ea716ad 100644 --- a/core/admin/infrastructure/persistence/InMemoryAdminUserRepository.ts +++ b/adapters/admin/persistence/inmemory/InMemoryAdminUserRepository.ts @@ -1,7 +1,7 @@ -import { AdminUser } from '../../domain/entities/AdminUser'; -import { AdminUserRepository, StoredAdminUser, UserFilter, UserListQuery, UserListResult } from '../../domain/repositories/AdminUserRepository'; -import { Email } from '../../domain/value-objects/Email'; -import { UserId } from '../../domain/value-objects/UserId'; +import { AdminUser } from '@core/admin/domain/entities/AdminUser'; +import { AdminUserRepository, StoredAdminUser, UserFilter, UserListQuery, UserListResult } from '@core/admin/domain/repositories/AdminUserRepository'; +import { Email } from '@core/admin/domain/value-objects/Email'; +import { UserId } from '@core/admin/domain/value-objects/UserId'; /** * In-memory implementation of AdminUserRepository for testing and development @@ -254,4 +254,4 @@ export class InMemoryAdminUserRepository implements AdminUserRepository { return AdminUser.rehydrate(props); } -} \ No newline at end of file +} diff --git a/core/admin/infrastructure/typeorm/entities/AdminUserOrmEntity.test.ts b/adapters/admin/persistence/typeorm/entities/AdminUserOrmEntity.test.ts similarity index 100% rename from core/admin/infrastructure/typeorm/entities/AdminUserOrmEntity.test.ts rename to adapters/admin/persistence/typeorm/entities/AdminUserOrmEntity.test.ts diff --git a/core/admin/infrastructure/typeorm/entities/AdminUserOrmEntity.ts b/adapters/admin/persistence/typeorm/entities/AdminUserOrmEntity.ts similarity index 100% rename from core/admin/infrastructure/typeorm/entities/AdminUserOrmEntity.ts rename to adapters/admin/persistence/typeorm/entities/AdminUserOrmEntity.ts diff --git a/core/admin/infrastructure/typeorm/errors/TypeOrmAdminSchemaError.test.ts b/adapters/admin/persistence/typeorm/errors/TypeOrmAdminSchemaError.test.ts similarity index 100% rename from core/admin/infrastructure/typeorm/errors/TypeOrmAdminSchemaError.test.ts rename to adapters/admin/persistence/typeorm/errors/TypeOrmAdminSchemaError.test.ts diff --git a/core/admin/infrastructure/typeorm/errors/TypeOrmAdminSchemaError.ts b/adapters/admin/persistence/typeorm/errors/TypeOrmAdminSchemaError.ts similarity index 99% rename from core/admin/infrastructure/typeorm/errors/TypeOrmAdminSchemaError.ts rename to adapters/admin/persistence/typeorm/errors/TypeOrmAdminSchemaError.ts index 99315f8bd..4fba5d04c 100644 --- a/core/admin/infrastructure/typeorm/errors/TypeOrmAdminSchemaError.ts +++ b/adapters/admin/persistence/typeorm/errors/TypeOrmAdminSchemaError.ts @@ -10,4 +10,4 @@ export class TypeOrmAdminSchemaError extends Error { super(`[TypeOrmAdminSchemaError] ${details.entityName}.${details.fieldName}: ${details.reason} - ${details.message}`); this.name = 'TypeOrmAdminSchemaError'; } -} \ No newline at end of file +} diff --git a/core/admin/infrastructure/typeorm/mappers/AdminUserOrmMapper.test.ts b/adapters/admin/persistence/typeorm/mappers/AdminUserOrmMapper.test.ts similarity index 100% rename from core/admin/infrastructure/typeorm/mappers/AdminUserOrmMapper.test.ts rename to adapters/admin/persistence/typeorm/mappers/AdminUserOrmMapper.test.ts diff --git a/core/admin/infrastructure/typeorm/mappers/AdminUserOrmMapper.ts b/adapters/admin/persistence/typeorm/mappers/AdminUserOrmMapper.ts similarity index 99% rename from core/admin/infrastructure/typeorm/mappers/AdminUserOrmMapper.ts rename to adapters/admin/persistence/typeorm/mappers/AdminUserOrmMapper.ts index 869f780f3..6a468a0d3 100644 --- a/core/admin/infrastructure/typeorm/mappers/AdminUserOrmMapper.ts +++ b/adapters/admin/persistence/typeorm/mappers/AdminUserOrmMapper.ts @@ -92,4 +92,4 @@ export class AdminUserOrmMapper { toStored(entity: AdminUserOrmEntity): AdminUser { return this.toDomain(entity); } -} \ No newline at end of file +} diff --git a/core/admin/infrastructure/typeorm/repositories/TypeOrmAdminUserRepository.test.ts b/adapters/admin/persistence/typeorm/repositories/TypeOrmAdminUserRepository.test.ts similarity index 99% rename from core/admin/infrastructure/typeorm/repositories/TypeOrmAdminUserRepository.test.ts rename to adapters/admin/persistence/typeorm/repositories/TypeOrmAdminUserRepository.test.ts index 9bee18c42..ff07e08c2 100644 --- a/core/admin/infrastructure/typeorm/repositories/TypeOrmAdminUserRepository.test.ts +++ b/adapters/admin/persistence/typeorm/repositories/TypeOrmAdminUserRepository.test.ts @@ -1016,4 +1016,4 @@ describe('TypeOrmAdminUserRepository', () => { expect(count).toBe(1); }); }); -}); \ No newline at end of file +}); diff --git a/core/admin/infrastructure/typeorm/repositories/TypeOrmAdminUserRepository.ts b/adapters/admin/persistence/typeorm/repositories/TypeOrmAdminUserRepository.ts similarity index 99% rename from core/admin/infrastructure/typeorm/repositories/TypeOrmAdminUserRepository.ts rename to adapters/admin/persistence/typeorm/repositories/TypeOrmAdminUserRepository.ts index 55ca30ceb..e82c30185 100644 --- a/core/admin/infrastructure/typeorm/repositories/TypeOrmAdminUserRepository.ts +++ b/adapters/admin/persistence/typeorm/repositories/TypeOrmAdminUserRepository.ts @@ -185,4 +185,4 @@ export class TypeOrmAdminUserRepository implements AdminUserRepository { return AdminUser.rehydrate(props); } -} \ No newline at end of file +} diff --git a/adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts b/adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts new file mode 100644 index 000000000..5300628ac --- /dev/null +++ b/adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts @@ -0,0 +1,365 @@ +import { describe, expect, it } from 'vitest'; +import { TypeOrmAdminSchemaError } from '../errors/TypeOrmAdminSchemaError'; +import { + assertNonEmptyString, + assertStringArray, + assertDate, + assertOptionalDate, + assertOptionalString, +} from './TypeOrmAdminSchemaGuards'; + +describe('TypeOrmAdminSchemaGuards', () => { + describe('TDD - Test First', () => { + describe('assertNonEmptyString', () => { + it('should pass for valid non-empty string', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'email'; + const value = 'test@example.com'; + + // Act & Assert + expect(() => assertNonEmptyString(entityName, fieldName, value)).not.toThrow(); + }); + + it('should throw error for empty string', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'email'; + const value = ''; + + // Act & Assert + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string'); + }); + + it('should throw error for string with only spaces', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'email'; + const value = ' '; + + // Act & Assert + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string'); + }); + + it('should throw error for non-string value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'email'; + const value = 123; + + // Act & Assert + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string'); + }); + + it('should throw error for null value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'email'; + const value = null; + + // Act & Assert + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string'); + }); + + it('should throw error for undefined value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'email'; + const value = undefined; + + // Act & Assert + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertNonEmptyString(entityName, fieldName, value)).toThrow('Field email must be a non-empty string'); + }); + }); + + describe('assertStringArray', () => { + it('should pass for valid string array', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'roles'; + const value = ['admin', 'user']; + + // Act & Assert + expect(() => assertStringArray(entityName, fieldName, value)).not.toThrow(); + }); + + it('should pass for empty array', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'roles'; + const value = []; + + // Act & Assert + expect(() => assertStringArray(entityName, fieldName, value)).not.toThrow(); + }); + + it('should throw error for non-array value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'roles'; + const value = 'admin'; + + // Act & Assert + expect(() => assertStringArray(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertStringArray(entityName, fieldName, value)).toThrow('Field roles must be an array of strings'); + }); + + it('should throw error for array with non-string items', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'roles'; + const value = ['admin', 123]; + + // Act & Assert + expect(() => assertStringArray(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertStringArray(entityName, fieldName, value)).toThrow('Field roles must be an array of strings'); + }); + + it('should throw error for null value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'roles'; + const value = null; + + // Act & Assert + expect(() => assertStringArray(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertStringArray(entityName, fieldName, value)).toThrow('Field roles must be an array of strings'); + }); + + it('should throw error for undefined value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'roles'; + const value = undefined; + + // Act & Assert + expect(() => assertStringArray(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertStringArray(entityName, fieldName, value)).toThrow('Field roles must be an array of strings'); + }); + }); + + describe('assertDate', () => { + it('should pass for valid Date', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'createdAt'; + const value = new Date(); + + // Act & Assert + expect(() => assertDate(entityName, fieldName, value)).not.toThrow(); + }); + + it('should pass for specific date', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'createdAt'; + const value = new Date('2024-01-01'); + + // Act & Assert + expect(() => assertDate(entityName, fieldName, value)).not.toThrow(); + }); + + it('should throw error for invalid date', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'createdAt'; + const value = new Date('invalid'); + + // Act & Assert + expect(() => assertDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertDate(entityName, fieldName, value)).toThrow('Field createdAt must be a valid Date'); + }); + + it('should throw error for non-Date value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'createdAt'; + const value = '2024-01-01'; + + // Act & Assert + expect(() => assertDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertDate(entityName, fieldName, value)).toThrow('Field createdAt must be a valid Date'); + }); + + it('should throw error for null value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'createdAt'; + const value = null; + + // Act & Assert + expect(() => assertDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertDate(entityName, fieldName, value)).toThrow('Field createdAt must be a valid Date'); + }); + + it('should throw error for undefined value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'createdAt'; + const value = undefined; + + // Act & Assert + expect(() => assertDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertDate(entityName, fieldName, value)).toThrow('Field createdAt must be a valid Date'); + }); + }); + + describe('assertOptionalDate', () => { + it('should pass for valid Date', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'lastLoginAt'; + const value = new Date(); + + // Act & Assert + expect(() => assertOptionalDate(entityName, fieldName, value)).not.toThrow(); + }); + + it('should pass for null value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'lastLoginAt'; + const value = null; + + // Act & Assert + expect(() => assertOptionalDate(entityName, fieldName, value)).not.toThrow(); + }); + + it('should pass for undefined value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'lastLoginAt'; + const value = undefined; + + // Act & Assert + expect(() => assertOptionalDate(entityName, fieldName, value)).not.toThrow(); + }); + + it('should throw error for invalid date', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'lastLoginAt'; + const value = new Date('invalid'); + + // Act & Assert + expect(() => assertOptionalDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertOptionalDate(entityName, fieldName, value)).toThrow('Field lastLoginAt must be a valid Date'); + }); + + it('should throw error for non-Date value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'lastLoginAt'; + const value = '2024-01-01'; + + // Act & Assert + expect(() => assertOptionalDate(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertOptionalDate(entityName, fieldName, value)).toThrow('Field lastLoginAt must be a valid Date'); + }); + }); + + describe('assertOptionalString', () => { + it('should pass for valid string', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'primaryDriverId'; + const value = 'driver-123'; + + // Act & Assert + expect(() => assertOptionalString(entityName, fieldName, value)).not.toThrow(); + }); + + it('should pass for null value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'primaryDriverId'; + const value = null; + + // Act & Assert + expect(() => assertOptionalString(entityName, fieldName, value)).not.toThrow(); + }); + + it('should pass for undefined value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'primaryDriverId'; + const value = undefined; + + // Act & Assert + expect(() => assertOptionalString(entityName, fieldName, value)).not.toThrow(); + }); + + it('should throw error for non-string value', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'primaryDriverId'; + const value = 123; + + // Act & Assert + expect(() => assertOptionalString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertOptionalString(entityName, fieldName, value)).toThrow('Field primaryDriverId must be a string or undefined'); + }); + + it('should throw error for empty string', () => { + // Arrange + const entityName = 'AdminUser'; + const fieldName = 'primaryDriverId'; + const value = ''; + + // Act & Assert + expect(() => assertOptionalString(entityName, fieldName, value)).toThrow(TypeOrmAdminSchemaError); + expect(() => assertOptionalString(entityName, fieldName, value)).toThrow('Field primaryDriverId must be a string or undefined'); + }); + }); + + describe('real-world scenarios', () => { + it('should validate complete admin user entity', () => { + // Arrange + const entityName = 'AdminUser'; + const id = 'user-123'; + const email = 'admin@example.com'; + const displayName = 'Admin User'; + const roles = ['owner', 'admin']; + const status = 'active'; + const createdAt = new Date(); + const updatedAt = new Date(); + + // Act & Assert + expect(() => assertNonEmptyString(entityName, 'id', id)).not.toThrow(); + expect(() => assertNonEmptyString(entityName, 'email', email)).not.toThrow(); + expect(() => assertNonEmptyString(entityName, 'displayName', displayName)).not.toThrow(); + expect(() => assertStringArray(entityName, 'roles', roles)).not.toThrow(); + expect(() => assertNonEmptyString(entityName, 'status', status)).not.toThrow(); + expect(() => assertDate(entityName, 'createdAt', createdAt)).not.toThrow(); + expect(() => assertDate(entityName, 'updatedAt', updatedAt)).not.toThrow(); + }); + + it('should validate admin user with optional fields', () => { + // Arrange + const entityName = 'AdminUser'; + const primaryDriverId = 'driver-456'; + const lastLoginAt = new Date(); + + // Act & Assert + expect(() => assertOptionalString(entityName, 'primaryDriverId', primaryDriverId)).not.toThrow(); + expect(() => assertOptionalDate(entityName, 'lastLoginAt', lastLoginAt)).not.toThrow(); + }); + + it('should validate admin user without optional fields', () => { + // Arrange + const entityName = 'AdminUser'; + const primaryDriverId = undefined; + const lastLoginAt = null; + + // Act & Assert + expect(() => assertOptionalString(entityName, 'primaryDriverId', primaryDriverId)).not.toThrow(); + expect(() => assertOptionalDate(entityName, 'lastLoginAt', lastLoginAt)).not.toThrow(); + }); + }); + }); +}); diff --git a/core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.ts b/adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.ts similarity index 99% rename from core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.ts rename to adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.ts index 3743ce3ff..e1964d5d7 100644 --- a/core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.ts +++ b/adapters/admin/persistence/typeorm/schema/TypeOrmAdminSchemaGuards.ts @@ -52,4 +52,4 @@ export function assertOptionalString(entityName: string, fieldName: string, valu message: `Field ${fieldName} must be a string or undefined`, }); } -} \ No newline at end of file +} diff --git a/core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts b/core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts deleted file mode 100644 index 734893635..000000000 --- a/core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts +++ /dev/null @@ -1,253 +0,0 @@ -import { describe, expect, it } from 'vitest'; -import { - assertNonEmptyString, - assertStringArray, - assertDate, - assertOptionalDate, - assertOptionalString, -} from './TypeOrmAdminSchemaGuards'; -import { TypeOrmAdminSchemaError } from '../errors/TypeOrmAdminSchemaError'; - -describe('TypeOrmAdminSchemaGuards', () => { - describe('TDD - Test First', () => { - describe('assertNonEmptyString', () => { - it('should not throw for valid non-empty string', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('TestEntity', 'fieldName', 'valid string')).not.toThrow(); - }); - - it('should throw for empty string', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('TestEntity', 'fieldName', '')).toThrow(TypeOrmAdminSchemaError); - expect(() => assertNonEmptyString('TestEntity', 'fieldName', '')).toThrow('Field fieldName must be a non-empty string'); - }); - - it('should throw for string with only whitespace', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('TestEntity', 'fieldName', ' ')).toThrow(TypeOrmAdminSchemaError); - expect(() => assertNonEmptyString('TestEntity', 'fieldName', ' ')).toThrow('Field fieldName must be a non-empty string'); - }); - - it('should throw for null', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertNonEmptyString('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be a non-empty string'); - }); - - it('should throw for undefined', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertNonEmptyString('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be a non-empty string'); - }); - - it('should throw for number', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('TestEntity', 'fieldName', 123)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertNonEmptyString('TestEntity', 'fieldName', 123)).toThrow('Field fieldName must be a non-empty string'); - }); - - it('should throw for object', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError); - expect(() => assertNonEmptyString('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a non-empty string'); - }); - - it('should throw for array', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('TestEntity', 'fieldName', [])).toThrow(TypeOrmAdminSchemaError); - expect(() => assertNonEmptyString('TestEntity', 'fieldName', [])).toThrow('Field fieldName must be a non-empty string'); - }); - - it('should include entity name in error message', () => { - // Arrange & Act & Assert - expect(() => assertNonEmptyString('AdminUser', 'email', '')).toThrow('[TypeOrmAdminSchemaError] AdminUser.email: INVALID_STRING - Field email must be a non-empty string'); - }); - }); - - describe('assertStringArray', () => { - it('should not throw for valid string array', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 'b', 'c'])).not.toThrow(); - }); - - it('should not throw for empty array', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', [])).not.toThrow(); - }); - - it('should throw for non-array', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', 'not an array')).toThrow(TypeOrmAdminSchemaError); - expect(() => assertStringArray('TestEntity', 'fieldName', 'not an array')).toThrow('Field fieldName must be an array of strings'); - }); - - it('should throw for null', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertStringArray('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be an array of strings'); - }); - - it('should throw for undefined', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertStringArray('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be an array of strings'); - }); - - it('should throw for array with non-string items', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 123, 'c'])).toThrow(TypeOrmAdminSchemaError); - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 123, 'c'])).toThrow('Field fieldName must be an array of strings'); - }); - - it('should throw for array with null items', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', null, 'c'])).toThrow(TypeOrmAdminSchemaError); - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', null, 'c'])).toThrow('Field fieldName must be an array of strings'); - }); - - it('should throw for array with undefined items', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', undefined, 'c'])).toThrow(TypeOrmAdminSchemaError); - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', undefined, 'c'])).toThrow('Field fieldName must be an array of strings'); - }); - - it('should throw for array with object items', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', {}, 'c'])).toThrow(TypeOrmAdminSchemaError); - expect(() => assertStringArray('TestEntity', 'fieldName', ['a', {}, 'c'])).toThrow('Field fieldName must be an array of strings'); - }); - - it('should include entity name in error message', () => { - // Arrange & Act & Assert - expect(() => assertStringArray('AdminUser', 'roles', null)).toThrow('[TypeOrmAdminSchemaError] AdminUser.roles: INVALID_STRING_ARRAY - Field roles must be an array of strings'); - }); - }); - - describe('assertDate', () => { - it('should not throw for valid Date', () => { - // Arrange & Act & Assert - expect(() => assertDate('TestEntity', 'fieldName', new Date())).not.toThrow(); - }); - - it('should not throw for Date with valid timestamp', () => { - // Arrange & Act & Assert - expect(() => assertDate('TestEntity', 'fieldName', new Date('2024-01-01'))).not.toThrow(); - }); - - it('should throw for null', () => { - // Arrange & Act & Assert - expect(() => assertDate('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertDate('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be a valid Date'); - }); - - it('should throw for undefined', () => { - // Arrange & Act & Assert - expect(() => assertDate('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertDate('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be a valid Date'); - }); - - it('should throw for string', () => { - // Arrange & Act & Assert - expect(() => assertDate('TestEntity', 'fieldName', '2024-01-01')).toThrow(TypeOrmAdminSchemaError); - expect(() => assertDate('TestEntity', 'fieldName', '2024-01-01')).toThrow('Field fieldName must be a valid Date'); - }); - - it('should throw for number', () => { - // Arrange & Act & Assert - expect(() => assertDate('TestEntity', 'fieldName', 1234567890)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertDate('TestEntity', 'fieldName', 1234567890)).toThrow('Field fieldName must be a valid Date'); - }); - - it('should throw for object', () => { - // Arrange & Act & Assert - expect(() => assertDate('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError); - expect(() => assertDate('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a valid Date'); - }); - - it('should throw for invalid Date (NaN)', () => { - // Arrange & Act & Assert - expect(() => assertDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow(TypeOrmAdminSchemaError); - expect(() => assertDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow('Field fieldName must be a valid Date'); - }); - - it('should include entity name in error message', () => { - // Arrange & Act & Assert - expect(() => assertDate('AdminUser', 'createdAt', null)).toThrow('[TypeOrmAdminSchemaError] AdminUser.createdAt: INVALID_DATE - Field createdAt must be a valid Date'); - }); - }); - - describe('assertOptionalDate', () => { - it('should not throw for valid Date', () => { - // Arrange & Act & Assert - expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date())).not.toThrow(); - }); - - it('should not throw for null', () => { - // Arrange & Act & Assert - expect(() => assertOptionalDate('TestEntity', 'fieldName', null)).not.toThrow(); - }); - - it('should not throw for undefined', () => { - // Arrange & Act & Assert - expect(() => assertOptionalDate('TestEntity', 'fieldName', undefined)).not.toThrow(); - }); - - it('should throw for invalid Date', () => { - // Arrange & Act & Assert - expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow(TypeOrmAdminSchemaError); - expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow('Field fieldName must be a valid Date'); - }); - - it('should throw for string', () => { - // Arrange & Act & Assert - expect(() => assertOptionalDate('TestEntity', 'fieldName', '2024-01-01')).toThrow(TypeOrmAdminSchemaError); - expect(() => assertOptionalDate('TestEntity', 'fieldName', '2024-01-01')).toThrow('Field fieldName must be a valid Date'); - }); - - it('should include entity name in error message', () => { - // Arrange & Act & Assert - expect(() => assertOptionalDate('AdminUser', 'lastLoginAt', new Date('invalid'))).toThrow('[TypeOrmAdminSchemaError] AdminUser.lastLoginAt: INVALID_DATE - Field lastLoginAt must be a valid Date'); - }); - }); - - describe('assertOptionalString', () => { - it('should not throw for valid string', () => { - // Arrange & Act & Assert - expect(() => assertOptionalString('TestEntity', 'fieldName', 'valid string')).not.toThrow(); - }); - - it('should not throw for null', () => { - // Arrange & Act & Assert - expect(() => assertOptionalString('TestEntity', 'fieldName', null)).not.toThrow(); - }); - - it('should not throw for undefined', () => { - // Arrange & Act & Assert - expect(() => assertOptionalString('TestEntity', 'fieldName', undefined)).not.toThrow(); - }); - - it('should throw for number', () => { - // Arrange & Act & Assert - expect(() => assertOptionalString('TestEntity', 'fieldName', 123)).toThrow(TypeOrmAdminSchemaError); - expect(() => assertOptionalString('TestEntity', 'fieldName', 123)).toThrow('Field fieldName must be a string or undefined'); - }); - - it('should throw for object', () => { - // Arrange & Act & Assert - expect(() => assertOptionalString('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError); - expect(() => assertOptionalString('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a string or undefined'); - }); - - it('should throw for array', () => { - // Arrange & Act & Assert - expect(() => assertOptionalString('TestEntity', 'fieldName', [])).toThrow(TypeOrmAdminSchemaError); - expect(() => assertOptionalString('TestEntity', 'fieldName', [])).toThrow('Field fieldName must be a string or undefined'); - }); - - it('should include entity name in error message', () => { - // Arrange & Act & Assert - expect(() => assertOptionalString('AdminUser', 'primaryDriverId', 123)).toThrow('[TypeOrmAdminSchemaError] AdminUser.primaryDriverId: INVALID_OPTIONAL_STRING - Field primaryDriverId must be a string or undefined'); - }); - }); - }); -});