.

qwen/nodejs/tests/unit/middleware/tenant.test.js

@@ -0,0 +1,97 @@
+// tests/unit/middleware/tenant.test.js
+const { resolveTenant, enforceTenantIsolation } = require('../../../middleware/tenant');
+
+describe('Tenant Middleware', () => {
+  describe('resolveTenant', () => {
+    test('should resolve tenant from subdomain', () => {
+      const mockReq = {
+        headers: { host: 'tenant1.merchants-of-hope.org' },
+        originalUrl: '/api/some-endpoint',
+        url: '/api/some-endpoint'
+      };
+      const mockRes = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+      let nextCalled = false;
+      
+      const next = () => { nextCalled = true; };
+      
+      resolveTenant(mockReq, mockRes, next);
+      
+      // In test environment, it falls back to default tenant for non-existent tenants
+      expect(mockReq.tenantId).toBe('default');
+      expect(mockReq.tenant).toBeDefined();
+      expect(nextCalled).toBe(true);
+    });
+    
+    test('should resolve tenant from header', () => {
+      const mockReq = {
+        headers: { 
+          host: 'localhost:19000',
+          'x-tenant-id': 'tenant2'
+        },
+        originalUrl: '/api/some-endpoint',
+        url: '/api/some-endpoint'
+      };
+      const mockRes = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+      let nextCalled = false;
+      
+      const next = () => { nextCalled = true; };
+      
+      resolveTenant(mockReq, mockRes, next);
+      
+      // In test environment, tenant2 is not in our tenant list, so falls back to default
+      expect(mockReq.tenantId).toBe('default');
+      expect(nextCalled).toBe(true);
+    });
+    
+    test('should resolve tenant from URL path', () => {
+      const mockReq = {
+        headers: { host: 'localhost:19000' },
+        originalUrl: '/tenant/tenant3/api/some-endpoint',
+        url: '/tenant/tenant3/api/some-endpoint'
+      };
+      const mockRes = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+      let nextCalled = false;
+      
+      const next = () => { nextCalled = true; };
+      
+      resolveTenant(mockReq, mockRes, next);
+      
+      // In test environment, tenant3 is not in our tenant list, so falls back to default
+      expect(mockReq.tenantId).toBe('default');
+      // Check that the URL was modified
+      expect(mockReq.originalUrl).toBe('/api/some-endpoint');
+      expect(nextCalled).toBe(true);
+    });
+    
+    test('should default to default tenant if none found', () => {
+      const mockReq = {
+        headers: { host: 'localhost:19000' },
+        originalUrl: '/api/some-endpoint',
+        url: '/api/some-endpoint'
+      };
+      const mockRes = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+      let nextCalled = false;
+      
+      const next = () => { nextCalled = true; };
+      
+      resolveTenant(mockReq, mockRes, next);
+      
+      expect(mockReq.tenantId).toBe('default');
+      expect(nextCalled).toBe(true);
+    });
+  });
+  
+  describe('enforceTenantIsolation', () => {
+    test('should call next to continue the request chain', () => {
+      const mockReq = { tenantId: 'test-tenant' };
+      const mockRes = {};
+      let nextCalled = false;
+      
+      const next = () => { nextCalled = true; };
+      
+      enforceTenantIsolation(mockReq, mockRes, next);
+      
+      expect(nextCalled).toBe(true);
+    });
+  });
+});

qwen/nodejs/tests/unit/models/User.test.js

@@ -0,0 +1,90 @@
+// tests/unit/models/User.test.js
+const User = require('../../../models/User');
+
+describe('User Model', () => {
+  test('should create a new user with provided data', () => {
+    const userData = {
+      id: 'test-id',
+      email: 'test@example.com',
+      passwordHash: 'hashed_password',
+      firstName: 'John',
+      lastName: 'Doe',
+      userType: 'job-seeker',
+      tenantId: 'tenant1'
+    };
+
+    const user = User.create(userData);
+
+    expect(user.id).toBe('test-id');
+    expect(user.email).toBe('test@example.com');
+    expect(user.firstName).toBe('John');
+    expect(user.lastName).toBe('Doe');
+    expect(user.userType).toBe('job-seeker');
+    expect(user.tenantId).toBe('tenant1');
+  });
+
+  test('should generate ID if not provided', () => {
+    const userData = {
+      email: 'test@example.com',
+      passwordHash: 'hashed_password',
+      firstName: 'John',
+      lastName: 'Doe',
+      userType: 'job-seeker',
+      tenantId: 'tenant1'
+    };
+
+    const user = User.create(userData);
+
+    expect(user.id).toBeDefined();
+    expect(typeof user.id).toBe('string');
+    expect(user.id.length).toBeGreaterThan(0);
+  });
+
+  test('should validate required fields', () => {
+    const user = new User(
+      'test-id',
+      'test@example.com',
+      'hashed_password',
+      'John',
+      'Doe',
+      'job-seeker',
+      'tenant1'
+    );
+
+    expect(() => user.validate()).not.toThrow();
+  });
+
+  test('should throw error if missing required fields', () => {
+    const user = new User();
+
+    expect(() => user.validate()).toThrow('Missing required fields');
+  });
+
+  test('should throw error for invalid email format', () => {
+    const user = new User(
+      'test-id',
+      'invalid-email',
+      'hashed_password',
+      'John',
+      'Doe',
+      'job-seeker',
+      'tenant1'
+    );
+
+    expect(() => user.validate()).toThrow('Invalid email format');
+  });
+
+  test('should throw error for invalid user type', () => {
+    const user = new User(
+      'test-id',
+      'test@example.com',
+      'hashed_password',
+      'John',
+      'Doe',
+      'invalid-type',
+      'tenant1'
+    );
+
+    expect(() => user.validate()).toThrow('User type must be either job-seeker or job-provider');
+  });
+});

qwen/nodejs/tests/unit/services/authService.test.js

@@ -0,0 +1,96 @@
+// tests/unit/services/authService.test.js
+const authService = require('../../../services/authService');
+
+// Mock user data for testing
+const mockUsers = [];
+
+// Since we're testing the service logic, we'll need to test with the actual implementation
+// which uses a global array - this is a limitation of the current implementation
+// In a real app, we would use dependency injection or mocking
+
+describe('AuthService', () => {
+  // These tests will need to be adjusted since the service maintains state in a global array
+  
+  test('should return an error for invalid credentials', async () => {
+    const result = await authService.login('nonexistent@example.com', 'wrongpassword');
+    
+    expect(result).toHaveProperty('error');
+    expect(result.error).toBe('Invalid email or password');
+  });
+
+  test('should successfully register a new user', async () => {
+    const userData = {
+      email: 'newuser@example.com',
+      password: 'securepassword',
+      firstName: 'New',
+      lastName: 'User',
+      userType: 'job-seeker',
+      tenantId: 'test-tenant'
+    };
+
+    const result = await authService.register(
+      userData.email,
+      userData.password,
+      userData.firstName,
+      userData.lastName,
+      userData.userType,
+      userData.tenantId
+    );
+
+    expect(result).toHaveProperty('user');
+    expect(result.user).toHaveProperty('id');
+    expect(result.user.email).toBe(userData.email);
+    expect(result.user.firstName).toBe(userData.firstName);
+    expect(result.user.lastName).toBe(userData.lastName);
+    expect(result.user.userType).toBe(userData.userType);
+    expect(result.user.tenantId).toBe(userData.tenantId);
+  });
+  
+  test('should return error when trying to register with existing email', async () => {
+    const userData = {
+      email: 'existing@example.com',
+      password: 'password',
+      firstName: 'Existing',
+      lastName: 'User',
+      userType: 'job-seeker',
+      tenantId: 'test-tenant'
+    };
+    
+    // Register the user first
+    await authService.register(
+      userData.email,
+      userData.password,
+      userData.firstName,
+      userData.lastName,
+      userData.userType,
+      userData.tenantId
+    );
+    
+    // Try to register the same email again
+    const result = await authService.register(
+      userData.email,
+      userData.password,
+      userData.firstName,
+      userData.lastName,
+      userData.userType,
+      userData.tenantId
+    );
+    
+    expect(result).toHaveProperty('error');
+    expect(result.error).toBe('User with this email already exists');
+  });
+  
+  test('should return error for invalid user type', async () => {
+    const result = await authService.register(
+      'invalidtype@example.com',
+      'password',
+      'Test',
+      'User',
+      'invalid-type',
+      'test-tenant'
+    );
+    
+    expect(result).toHaveProperty('error');
+    expect(result.error).toBe('User type must be either job-seeker or job-provider');
+  });
+});