TypeScript Testing Patterns

// Instead of 'any', use Partial<T> to build test doubles
interface UserRepository {
  findById(id: string): Promise<User | null>;
  findByEmail(email: string): Promise<User | null>;
  save(user: User): Promise<void>;
  delete(id: string): Promise<void>;
  count(): Promise<number>;
}

interface User {
  id: string;
  name: string;
  email: string;
  admin: boolean;
  createdAt: Date;
}

// Type-safe factory for test data - all required fields have defaults
function makeUser(overrides: Partial<User> = {}): User {
  return {
    id:        overrides.id        ?? 'test-user-id',
    name:      overrides.name      ?? 'Test User',
    email:     overrides.email     ?? 'test@example.com',
    admin:     overrides.admin     ?? false,
    createdAt: overrides.createdAt ?? new Date('2024-01-01'),
    ...overrides,
  };
}

// Type-safe mock repository - only implement what the test needs
function makeUserRepo(overrides: Partial<UserRepository> = {}): UserRepository {
  const defaultUser = makeUser();
  return {
    findById:    async (id) => id === defaultUser.id ? defaultUser : null,
    findByEmail: async ()   => defaultUser,
    save:        async ()   => {},
    delete:      async ()   => {},
    count:       async ()   => 1,
    ...overrides,
  };
}

// Usage in tests (framework-agnostic)
async function testRegisterUser() {
  const savedUsers: User[] = [];
  const repo = makeUserRepo({
    save: async (user) => { savedUsers.push(user); },
  });

  const svc = new UserService(repo, new NoOpEmailService(), new ConsoleLogger());
  const newUser = await svc.registerUser('Alice', 'alice@example.com');

  console.assert(newUser.name === 'Alice', 'Name should be Alice');
  console.assert(savedUsers.length === 1, 'Should have saved one user');
  console.assert(savedUsers[0].email === 'alice@example.com', 'Email should match');
}

// Test that invalid usage is rejected by the type checker

// @ts-expect-error - asserts the NEXT LINE must be a type error
// If the line is valid TS, the @ts-expect-error itself becomes an error
function acceptString(s: string): void {}

// @ts-expect-error
acceptString(42);       // Error: number is not assignable to string
// @ts-expect-error
acceptString(null);     // Error: null is not assignable to string

acceptString('hello');  // No @ts-expect-error needed - this is valid

// Type equality testing with a helper
type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends
                   (<T>() => T extends B ? 1 : 2) ? true : false;

type Assert<T extends true> = T;

// These compile successfully - the types ARE equal
type _1 = Assert<Equal<string, string>>;
type _2 = Assert<Equal<{ a: number }, { a: number }>>;

// These fail to compile - the types are NOT equal (catches regressions)
// type _3 = Assert<Equal<string, number>>;        // Error
// type _4 = Assert<Equal<string[], number[]>>;    // Error

// Test that a utility type produces the correct output
type MyPartial<T> = { [K in keyof T]?: T[K] };

type UserPartial = MyPartial<User>;

// Verify specific properties are optional in the result
type _5 = Assert<Equal<UserPartial['name'], string | undefined>>;
type _6 = Assert<Equal<UserPartial['admin'], boolean | undefined>>;

// Verify the keys are the same
type _7 = Assert<Equal<keyof UserPartial, keyof User>>;

// Testing a generic function by instantiating with concrete types
function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

// Type tests - these fail to compile if the types are wrong
const strResult  = first(['a', 'b', 'c']);
type _strResult  = Assert<Equal<typeof strResult, string | undefined>>;

const numResult  = first([1, 2, 3]);
type _numResult  = Assert<Equal<typeof numResult, number | undefined>>;

const emptyResult = first([]);
type _emptyResult = Assert<Equal<typeof emptyResult, never | undefined>>;

// Test conditional types produce the correct results
type Flatten<T> = T extends (infer U)[] ? U : T;

type _f1 = Assert<Equal<Flatten<string[]>, string>>;
type _f2 = Assert<Equal<Flatten<number[][]>, number[]>>;
type _f3 = Assert<Equal<Flatten<string>, string>>;    // Non-array passes through

// Test discriminated union narrowing behavior
type Shape =
  | { kind: 'circle';   radius: number }
  | { kind: 'square';   side: number }
  | { kind: 'triangle'; base: number; height: number };

function area(s: Shape): number {
  switch (s.kind) {
    case 'circle':   return Math.PI * s.radius ** 2;
    case 'square':   return s.side ** 2;
    case 'triangle': return 0.5 * s.base * s.height;
  }
}

// Test exhaustiveness: if a new Shape is added without updating area(),
// the switch is no longer exhaustive and TypeScript errors on the function

// Runtime test to complement the type test
console.assert(area({ kind: 'square', side: 4 }) === 16, 'Square area');
console.assert(
  Math.abs(area({ kind: 'circle', radius: 1 }) - Math.PI) < 0.001,
  'Circle area'
);