fragment-ts 1.0.17 → 1.0.19

package/src/testing/TEST.md

@@ -0,0 +1,321 @@
+// ============================================
+// user.service.spec.ts
+// Example test file for UserService
+// ============================================
+
+import 'reflect-metadata';
+import { UserService } from './user.service';
+import { UserRepository } from './user.repository';
+import { EmailService } from './email.service';
+import { DIContainer } from 'fragment-ts';
+
+describe('UserService', () => {
+  let userService: UserService;
+  let userRepository: UserRepository;
+  let emailService: EmailService;
+  let container: DIContainer;
+
+  // Setup before each test
+  beforeEach(() => {
+    // Create a fresh DI container for each test
+    container = DIContainer.getInstance();
+    container.reset();
+
+    // Mock dependencies
+    userRepository = {
+      findAll: async () => [],
+      findById: async (id: number) => null,
+      findByEmail: async (email: string) => null,
+      create: async (data: any) => ({ id: 1, ...data }),
+      update: async (id: number, data: any) => null,
+      delete: async (id: number) => true,
+    } as any;
+
+    emailService = {
+      sendWelcomeEmail: async (email: string, name: string) => {},
+      sendPasswordReset: async (email: string, token: string) => {},
+    } as any;
+
+    // Register mocks in container
+    container.register(UserRepository, userRepository);
+    container.register(EmailService, emailService);
+
+    // Create service instance (will auto-inject mocks)
+    userService = container.resolve(UserService);
+  });
+
+  it('should get all users', async () => {
+    const mockUsers = [
+      { id: 1, name: 'John', email: 'john@example.com', isActive: true },
+      { id: 2, name: 'Jane', email: 'jane@example.com', isActive: true },
+    ];
+
+    userRepository.findAll = async () => mockUsers;
+
+    const users = await userService.getAllUsers();
+
+    expect(users).toEqual(mockUsers);
+    expect(users).toHaveLength(2);
+  });
+
+  it('should get user by id', async () => {
+    const mockUser = {
+      id: 1,
+      name: 'John',
+      email: 'john@example.com',
+      isActive: true,
+    };
+
+    userRepository.findById = async (id: number) =>
+      id === 1 ? mockUser : null;
+
+    const user = await userService.getUserById(1);
+
+    expect(user).toEqual(mockUser);
+    expect(user?.name).toBe('John');
+  });
+
+  it('should create user and send welcome email', async () => {
+    const newUser = {
+      name: 'John',
+      email: 'john@example.com',
+    };
+
+    let emailSent = false;
+    emailService.sendWelcomeEmail = async () => {
+      emailSent = true;
+    };
+
+    const user = await userService.createUser(newUser);
+
+    expect(user.name).toBe('John');
+    expect(user.email).toBe('john@example.com');
+    expect(emailSent).toBeTruthy();
+  });
+
+  it('should throw error when creating duplicate email', async () => {
+    const existingUser = {
+      id: 1,
+      name: 'Existing',
+      email: 'test@example.com',
+      isActive: true,
+    };
+
+    userRepository.findByEmail = async (email: string) =>
+      email === 'test@example.com' ? existingUser : null;
+
+    try {
+      await userService.createUser({
+        name: 'New User',
+        email: 'test@example.com',
+      });
+      throw new Error('Should have thrown error');
+    } catch (error: any) {
+      expect(error.message).toContain('already exists');
+    }
+  });
+
+  it('should update user', async () => {
+    const existingUser = {
+      id: 1,
+      name: 'John',
+      email: 'john@example.com',
+      isActive: true,
+    };
+
+    userRepository.findById = async (id: number) =>
+      id === 1 ? existingUser : null;
+    userRepository.update = async (id: number, data: any) => ({
+      ...existingUser,
+      ...data,
+    });
+
+    const updated = await userService.updateUser(1, { name: 'John Updated' });
+
+    expect(updated?.name).toBe('John Updated');
+  });
+
+  it('should delete user', async () => {
+    const existingUser = {
+      id: 1,
+      name: 'John',
+      email: 'john@example.com',
+      isActive: true,
+    };
+
+    userRepository.findById = async (id: number) =>
+      id === 1 ? existingUser : null;
+
+    const deleted = await userService.deleteUser(1);
+
+    expect(deleted).toBeTruthy();
+  });
+
+  it('should throw error when deleting non-existent user', async () => {
+    userRepository.findById = async () => null;
+
+    try {
+      await userService.deleteUser(999);
+      throw new Error('Should have thrown error');
+    } catch (error: any) {
+      expect(error.message).toContain('not found');
+    }
+  });
+
+  it('should request password reset', async () => {
+    const existingUser = {
+      id: 1,
+      name: 'John',
+      email: 'john@example.com',
+      isActive: true,
+    };
+
+    userRepository.findByEmail = async (email: string) =>
+      email === 'john@example.com' ? existingUser : null;
+
+    let resetEmailSent = false;
+    let resetToken = '';
+
+    emailService.sendPasswordReset = async (email: string, token: string) => {
+      resetEmailSent = true;
+      resetToken = token;
+    };
+
+    await userService.requestPasswordReset('john@example.com');
+
+    expect(resetEmailSent).toBeTruthy();
+    expect(resetToken).toBeTruthy();
+  });
+});
+
+// ============================================
+// di-container.spec.ts
+// Example test file for DI Container
+// ============================================
+
+describe('DIContainer', () => {
+  let container: DIContainer;
+
+  beforeEach(() => {
+    container = DIContainer.getInstance();
+    container.reset();
+  });
+
+  it('should resolve singleton instances', () => {
+    class TestService {
+      counter = 0;
+    }
+
+    container.register(TestService);
+
+    const instance1 = container.resolve(TestService);
+    const instance2 = container.resolve(TestService);
+
+    instance1.counter = 5;
+
+    expect(instance2.counter).toBe(5);
+    expect(instance1).toBe(instance2);
+  });
+
+  it('should inject constructor dependencies', () => {
+    @Injectable()
+    class DependencyService {
+      getValue() {
+        return 'dependency';
+      }
+    }
+
+    @Injectable()
+    class TestService {
+      constructor(private dep: DependencyService) {}
+
+      getDepValue() {
+        return this.dep.getValue();
+      }
+    }
+
+    container.register(DependencyService);
+    container.register(TestService);
+
+    const service = container.resolve(TestService);
+
+    expect(service.getDepValue()).toBe('dependency');
+  });
+
+  it('should inject properties with @Autowired', () => {
+    @Injectable()
+    class DependencyService {
+      getValue() {
+        return 'autowired';
+      }
+    }
+
+    @Injectable()
+    class TestService {
+      @Autowired()
+      private dep!: DependencyService;
+
+      getDepValue() {
+        return this.dep.getValue();
+      }
+    }
+
+    container.register(DependencyService);
+    container.register(TestService);
+
+    const service = container.resolve(TestService);
+
+    expect(service.getDepValue()).toBe('autowired');
+  });
+
+  it('should inject values with @Value', () => {
+    process.env.TEST_VALUE = '42';
+
+    @Injectable()
+    class TestService {
+      @Value('${TEST_VALUE}')
+      private value!: number;
+
+      getValue() {
+        return this.value;
+      }
+    }
+
+    container.register(TestService);
+    const service = container.resolve(TestService);
+
+    expect(service.getValue()).toBe(42);
+
+    delete process.env.TEST_VALUE;
+  });
+
+  it('should detect circular dependencies', () => {
+    @Injectable()
+    class ServiceA {
+      constructor(private b: ServiceB) {}
+    }
+
+    @Injectable()
+    class ServiceB {
+      constructor(private a: ServiceA) {}
+    }
+
+    container.register(ServiceA);
+    container.register(ServiceB);
+
+    expect(() => container.resolve(ServiceA)).toThrow('Circular dependency');
+  });
+});
+
+// ============================================
+// Helper functions for testing
+// ============================================
+
+// Mock functions for testing
+global.beforeEach = (fn: () => void) => {
+  // Implement beforeEach hook
+};
+
+global.afterEach = (fn: () => void) => {
+  // Implement afterEach hook
+};

package/src/testing/runner.ts

@@ -1,6 +1,6 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
 
 /* ======================================================
  * Global augmentation
@@ -8,6 +8,8 @@ import { glob } from 'glob';
 type GlobalWithTestRunner = typeof globalThis & {
   __testRunner?: TestRunner;
   it?: (name: string, fn: () => void | Promise<void>) => void;
+  beforeEach?: (fn: () => void | Promise<void>) => void;
+  afterEach?: (fn: () => void | Promise<void>) => void;
 };
 
 const G = global as GlobalWithTestRunner;
@@ -18,6 +20,8 @@ const G = global as GlobalWithTestRunner;
 export interface TestSuite {
   name: string;
   tests: Test[];
+  beforeEachHooks: Array<() => void | Promise<void>>;
+  afterEachHooks: Array<() => void | Promise<void>>;
 }
 
 export interface Test {
@@ -34,43 +38,67 @@ export class TestRunner {
   private failed = 0;
 
   describe(name: string, fn: () => void): void {
-    const suite: TestSuite = { name, tests: [] };
+    const suite: TestSuite = {
+      name,
+      tests: [],
+      beforeEachHooks: [],
+      afterEachHooks: [],
+    };
+
     this.suites.push(suite);
 
-    const currentSuite = suite;
     const originalIt = G.it;
+    const originalBeforeEach = G.beforeEach;
+    const originalAfterEach = G.afterEach;
 
     G.it = (testName: string, testFn: () => void | Promise<void>) => {
-      currentSuite.tests.push({ name: testName, fn: testFn });
+      suite.tests.push({ name: testName, fn: testFn });
+    };
+
+    G.beforeEach = (hook: () => void | Promise<void>) => {
+      suite.beforeEachHooks.push(hook);
+    };
+
+    G.afterEach = (hook: () => void | Promise<void>) => {
+      suite.afterEachHooks.push(hook);
     };
 
     fn();
 
     G.it = originalIt;
+    G.beforeEach = originalBeforeEach;
+    G.afterEach = originalAfterEach;
   }
 
   async run(): Promise<void> {
-    console.log('\n🧪 Running Fragment Tests\n');
+    console.log("\nRunning Fragment Tests\n");
 
     for (const suite of this.suites) {
-      console.log(`\n📦 ${suite.name}`);
+      console.log(`\nSuite: ${suite.name}`);
 
       for (const test of suite.tests) {
         try {
+          for (const hook of suite.beforeEachHooks) {
+            await hook();
+          }
+
           await test.fn();
-          console.log(`  ✓ ${test.name}`);
+
+          for (const hook of suite.afterEachHooks) {
+            await hook();
+          }
+
+          console.log(`  PASS ${test.name}`);
           this.passed++;
-        } catch (error) {
-          console.log(`  ✗ ${test.name}`);
-          console.error(`    ${error}`);
+        } catch (error: any) {
+          console.log(`  FAIL ${test.name}`);
+          console.error(`    ${error?.message ?? error}`);
           this.failed++;
         }
       }
     }
 
-    console.log(
-      `\n\n📊 Results: ${this.passed} passed, ${this.failed} failed\n`,
-    );
+    console.log(`\nResults: ${this.passed} passed, ${this.failed} failed\n`);
 
     if (this.failed > 0) {
       process.exit(1);
@@ -90,13 +118,36 @@ export class TestRunner {
  * Global test helpers
  * ====================================================== */
 export function describe(name: string, fn: () => void): void {
-  G.__testRunner?.describe(name, fn);
+  if (!G.__testRunner) {
+    throw new Error("TestRunner not initialized");
+  }
+  G.__testRunner.describe(name, fn);
 }
 
 export function it(name: string, fn: () => void | Promise<void>): void {
-  // Implemented dynamically by TestRunner.describe
+  if (!G.it) {
+    throw new Error('"it" must be called inside describe()');
+  }
+  G.it(name, fn);
 }
 
+export function beforeEach(fn: () => void | Promise<void>): void {
+  if (!G.beforeEach) {
+    throw new Error('"beforeEach" must be called inside describe()');
+  }
+  G.beforeEach(fn);
+}
+
+export function afterEach(fn: () => void | Promise<void>): void {
+  if (!G.afterEach) {
+    throw new Error('"afterEach" must be called inside describe()');
+  }
+  G.afterEach(fn);
+}
+
+/* ======================================================
+ * Expect / Assertions
+ * ====================================================== */
 export function expect(actual: any) {
   return {
     toBe(expected: any) {
@@ -104,29 +155,85 @@ export function expect(actual: any) {
         throw new Error(`Expected ${actual} to be ${expected}`);
       }
     },
+
     toEqual(expected: any) {
-      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-        throw new Error(
-          `Expected ${JSON.stringify(actual)} to equal ${JSON.stringify(expected)}`,
-        );
+      const a = JSON.stringify(actual);
+      const e = JSON.stringify(expected);
+      if (a !== e) {
+        throw new Error(`Expected ${a} to equal ${e}`);
       }
     },
+
     toBeTruthy() {
       if (!actual) {
         throw new Error(`Expected ${actual} to be truthy`);
       }
     },
+
     toBeFalsy() {
       if (actual) {
         throw new Error(`Expected ${actual} to be falsy`);
       }
     },
+
     toThrow() {
+      if (typeof actual !== "function") {
+        throw new Error("toThrow expects a function");
+      }
+
+      let threw = false;
       try {
         actual();
-        throw new Error('Expected function to throw');
       } catch {
-        /* expected */
+        threw = true;
+      }
+
+      if (!threw) {
+        throw new Error("Expected function to throw an error");
+      }
+    },
+
+    toBeInstanceOf(expected: any) {
+      if (!(actual instanceof expected)) {
+        throw new Error(`Expected object to be instance of ${expected?.name}`);
+      }
+    },
+
+    toContain(expected: any) {
+      if (!Array.isArray(actual) && typeof actual !== "string") {
+        throw new Error("toContain works only on arrays or strings");
+      }
+
+      if (!actual.includes(expected)) {
+        throw new Error(`Expected ${actual} to contain ${expected}`);
+      }
+    },
+
+    toHaveProperty(prop: string) {
+      if (actual == null || !(prop in actual)) {
+        throw new Error(`Expected object to have property "${prop}"`);
+      }
+    },
+
+    toBeNull() {
+      if (actual !== null) {
+        throw new Error(`Expected ${actual} to be null`);
+      }
+    },
+
+    toBeUndefined() {
+      if (actual !== undefined) {
+        throw new Error(`Expected ${actual} to be undefined`);
+      }
+    },
+
+    toHaveLength(expected: number) {
+      if (actual == null || typeof actual.length !== "number") {
+        throw new Error("toHaveLength works only on arrays or strings");
+      }
+
+      if (actual.length !== expected) {
+        throw new Error(`Expected length ${expected}, got ${actual.length}`);
       }
     },
   };
@@ -139,5 +246,11 @@ if (require.main === module) {
   const runner = new TestRunner();
   G.__testRunner = runner;
 
-  runner.loadTestFiles('dist/**/*.spec.js').then(() => runner.run());
+  runner
+    .loadTestFiles("dist/**/*.spec.js")
+    .then(() => runner.run())
+    .catch((err) => {
+      console.error("Failed to run tests:", err);
+      process.exit(1);
+    });
 }