insforge 0.3.3 → 1.3.0

package/backend/tests/unit/cloud-token.test.ts

@@ -0,0 +1,48 @@
+import { TokenManager } from '../../src/infra/security/token.manager';
+import { jwtVerify } from 'jose';
+import { AppError } from '../../src/api/middlewares/error';
+import { describe, it, expect, beforeEach, afterAll, vi } from 'vitest';
+
+// Mock jose.jwtVerify
+vi.mock('jose', () => ({
+  jwtVerify: vi.fn(),
+  createRemoteJWKSet: vi.fn(() => 'mockedJwks'),
+}));
+
+describe('TokenManager.verifyCloudToken', () => {
+  const oldEnv = process.env;
+  let tokenManager: TokenManager;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    process.env = {
+      ...oldEnv,
+      PROJECT_ID: 'project_123',
+      CLOUD_API_HOST: 'https://mock-api.dev',
+      JWT_SECRET: 'test-secret-key',
+    };
+    tokenManager = TokenManager.getInstance();
+  });
+
+  afterAll(() => {
+    process.env = oldEnv;
+  });
+
+  it('returns payload and projectId if valid', async () => {
+    (jwtVerify as unknown as ReturnType<typeof vi.fn>).mockResolvedValue({
+      payload: { projectId: 'project_123', user: 'testUser' },
+    });
+
+    const result = await tokenManager.verifyCloudToken('valid-token');
+    expect(result.projectId).toBe('project_123');
+    expect(result.payload.user).toBe('testUser');
+  });
+
+  it('throws AppError if project ID mismatch or missing', async () => {
+    (jwtVerify as unknown as ReturnType<typeof vi.fn>).mockResolvedValue({
+      payload: {}, // missing projectId also counts as mismatch
+    });
+
+    await expect(tokenManager.verifyCloudToken('token')).rejects.toThrow(AppError);
+  });
+});

package/backend/tests/unit/constant.test.ts

@@ -0,0 +1,8 @@
+import { ADMIN_ID } from '../../src/utils/constants';
+import { describe, it, expect } from 'vitest';
+
+describe('ADMIN_ID constant', () => {
+  it('should have the correct fixed UUID value', () => {
+    expect(ADMIN_ID).toBe('00000000-0000-0000-0000-000000000001');
+  });
+});

package/backend/tests/unit/email.test.ts

@@ -0,0 +1,372 @@
+import { EmailService } from '../../src/core/email/email';
+import { AppError } from '../../src/api/middleware/error';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import axios from 'axios';
+import jwt from 'jsonwebtoken';
+
+// Mock dependencies
+vi.mock('axios');
+vi.mock('jsonwebtoken');
+vi.mock('../../src/utils/logger', () => ({
+  default: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  },
+}));
+vi.mock('../../src/app.config', () => ({
+  config: {
+    app: {
+      jwtSecret: 'test-jwt-secret',
+    },
+    cloud: {
+      projectId: 'test-project-123',
+      apiHost: 'https://api.test.com',
+    },
+  },
+}));
+
+describe('EmailService', () => {
+  let emailService: EmailService;
+  const oldEnv = process.env;
+
+  beforeEach(async () => {
+    // Reset all mocks
+    vi.resetAllMocks();
+
+    // Mock config values
+    const { config } = await import('../../src/app.config');
+    config.cloud.projectId = 'test-project-123';
+    config.app.jwtSecret = 'test-jwt-secret';
+    config.cloud.apiHost = 'https://api.test.com';
+
+    // Get fresh instance
+    emailService = EmailService.getInstance();
+
+    // Default mock for jwt.sign
+    (jwt.sign as unknown as ReturnType<typeof vi.fn>).mockReturnValue('mocked-jwt-token');
+  });
+
+  afterEach(() => {
+    process.env = oldEnv;
+  });
+
+  describe('getInstance', () => {
+    it('returns singleton instance', () => {
+      const instance1 = EmailService.getInstance();
+      const instance2 = EmailService.getInstance();
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe('sendWithTemplate', () => {
+    it('successfully sends email with verification code template', async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: { success: true },
+      });
+
+      await emailService.sendWithTemplate(
+        'user@example.com',
+        'John Doe',
+        'email-verification-code',
+        { token: '123456' }
+      );
+
+      expect(jwt.sign).toHaveBeenCalledWith({ sub: 'test-project-123' }, 'test-jwt-secret', {
+        expiresIn: '10m',
+      });
+
+      expect(axios.post).toHaveBeenCalledWith(
+        'https://api.test.com/email/v1/test-project-123/send-with-template',
+        {
+          email: 'user@example.com',
+          name: 'John Doe',
+          template: 'email-verification-code',
+          variables: { token: '123456' },
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            sign: 'mocked-jwt-token',
+          },
+          timeout: 10000,
+        }
+      );
+    });
+
+    it('successfully sends email with verification link template', async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: { success: true },
+      });
+
+      await emailService.sendWithTemplate(
+        'user@example.com',
+        'John Doe',
+        'email-verification-link',
+        { magic_link: 'https://example.com/verify?token=abc123' }
+      );
+
+      expect(axios.post).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          template: 'email-verification-link',
+          variables: { magic_link: 'https://example.com/verify?token=abc123' },
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('successfully sends email with reset-password code template', async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: { success: true },
+      });
+
+      await emailService.sendWithTemplate('user@example.com', 'Jane Smith', 'reset-password-code', {
+        token: 'reset123',
+      });
+
+      expect(axios.post).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          template: 'reset-password-code',
+          variables: { token: 'reset123' },
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('successfully sends email with reset-password link template', async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: { success: true },
+      });
+
+      await emailService.sendWithTemplate('user@example.com', 'Jane Smith', 'reset-password-link', {
+        magic_link: 'https://example.com/reset?token=xyz789',
+      });
+
+      expect(axios.post).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          template: 'reset-password-link',
+          variables: { magic_link: 'https://example.com/reset?token=xyz789' },
+        }),
+        expect.any(Object)
+      );
+    });
+
+    it('throws error if PROJECT_ID is not configured', async () => {
+      const { config } = await import('../../src/app.config');
+      config.cloud.projectId = 'local';
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow(AppError);
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('PROJECT_ID is not configured');
+
+      // Reset for other tests
+      config.cloud.projectId = 'test-project-123';
+    });
+
+    it('throws error if JWT_SECRET is not configured', async () => {
+      const { config } = await import('../../src/app.config');
+      config.app.jwtSecret = '';
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow(AppError);
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('JWT_SECRET is not configured');
+
+      // Reset for other tests
+      config.app.jwtSecret = 'test-jwt-secret';
+    });
+
+    it('throws error if required parameters are missing', async () => {
+      await expect(
+        emailService.sendWithTemplate('', 'John', 'email-verification-code')
+      ).rejects.toThrow('Missing required parameters');
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', '', 'email-verification-code')
+      ).rejects.toThrow('Missing required parameters');
+    });
+
+    it('throws error for invalid template type', async () => {
+      await expect(
+        emailService.sendWithTemplate(
+          'user@example.com',
+          'John',
+          '123456',
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          'invalid-template' as any
+        )
+      ).rejects.toThrow('Invalid template type');
+    });
+
+    it('throws error if cloud service returns unsuccessful response', async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: { success: false },
+      });
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('Email service returned unsuccessful response');
+    });
+
+    it('handles 401 authentication error', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const error = new Error('Request failed') as any;
+      error.isAxiosError = true;
+      error.response = {
+        status: 401,
+        data: { message: 'Unauthorized' },
+      };
+
+      vi.mocked(axios.post).mockRejectedValue(error);
+      vi.mocked(axios.isAxiosError).mockReturnValue(true);
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('Authentication failed with cloud email service');
+    });
+
+    it('handles 403 forbidden error', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const error = new Error('Request failed') as any;
+      error.isAxiosError = true;
+      error.response = {
+        status: 403,
+        data: { message: 'Forbidden' },
+      };
+
+      vi.mocked(axios.post).mockRejectedValue(error);
+      vi.mocked(axios.isAxiosError).mockReturnValue(true);
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('Authentication failed with cloud email service');
+    });
+
+    it('handles 429 rate limit error', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const error = new Error('Request failed') as any;
+      error.isAxiosError = true;
+      error.response = {
+        status: 429,
+        data: { message: 'Too many requests' },
+      };
+
+      vi.mocked(axios.post).mockRejectedValue(error);
+      vi.mocked(axios.isAxiosError).mockReturnValue(true);
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('Email rate limit exceeded');
+    });
+
+    it('handles 400 bad request error', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const error = new Error('Request failed') as any;
+      error.isAxiosError = true;
+      error.response = {
+        status: 400,
+        data: { message: 'Invalid email format' },
+      };
+
+      vi.mocked(axios.post).mockRejectedValue(error);
+      vi.mocked(axios.isAxiosError).mockReturnValue(true);
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('Invalid email request: Invalid email format');
+    });
+
+    it('handles generic axios error', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const error = new Error('Request failed') as any;
+      error.isAxiosError = true;
+      error.response = {
+        status: 500,
+        data: { message: 'Internal server error' },
+      };
+
+      vi.mocked(axios.post).mockRejectedValue(error);
+      vi.mocked(axios.isAxiosError).mockReturnValue(true);
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('Failed to send email: Internal server error');
+    });
+
+    it('handles network error without response', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const error = new Error('Network error') as any;
+      error.isAxiosError = true;
+
+      vi.mocked(axios.post).mockRejectedValue(error);
+      vi.mocked(axios.isAxiosError).mockReturnValue(true);
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('Failed to send email: Network error');
+    });
+
+    it('handles non-axios error', async () => {
+      vi.mocked(axios.post).mockRejectedValue(new Error('Unexpected error'));
+
+      await expect(
+        emailService.sendWithTemplate('user@example.com', 'John', 'email-verification-code', {
+          token: '123456',
+        })
+      ).rejects.toThrow('Failed to send email: Unexpected error');
+    });
+  });
+
+  describe('JWT token generation', () => {
+    it('generates JWT with correct payload and expiration', async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: { success: true },
+      });
+
+      await emailService.sendWithTemplate(
+        'user@example.com',
+        'John Doe',
+        'email-verification-code',
+        {
+          token: '123456',
+        }
+      );
+
+      expect(jwt.sign).toHaveBeenCalledWith({ sub: 'test-project-123' }, 'test-jwt-secret', {
+        expiresIn: '10m',
+      });
+    });
+  });
+});

package/backend/tests/unit/environment.test.ts

@@ -0,0 +1,59 @@
+import {
+  isCloudEnvironment,
+  isOAuthSharedKeysAvailable,
+  isDevelopment,
+  isProduction,
+} from '../../src/utils/environment';
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+
+describe('Environment utils', () => {
+  const OLD_ENV = process.env;
+
+  beforeEach(() => {
+    process.env = { ...OLD_ENV };
+  });
+
+  afterAll(() => {
+    process.env = OLD_ENV;
+  });
+
+  it('isCloudEnvironment returns true if AWS_INSTANCE_PROFILE_NAME is set', () => {
+    process.env.AWS_INSTANCE_PROFILE_NAME = 'my-profile';
+    expect(isCloudEnvironment()).toBe(true);
+  });
+
+  it('isCloudEnvironment returns false if AWS_INSTANCE_PROFILE_NAME is missing', () => {
+    delete process.env.AWS_INSTANCE_PROFILE_NAME;
+    expect(isCloudEnvironment()).toBe(false);
+  });
+
+  it('isOAuthSharedKeysAvailable returns same as isCloudEnvironment', () => {
+    process.env.AWS_INSTANCE_PROFILE_NAME = 'profile';
+    expect(isOAuthSharedKeysAvailable()).toBe(true);
+
+    delete process.env.AWS_INSTANCE_PROFILE_NAME;
+    expect(isOAuthSharedKeysAvailable()).toBe(false);
+  });
+
+  it('isDevelopment works correctly', () => {
+    process.env.NODE_ENV = 'development';
+    expect(isDevelopment()).toBe(true);
+
+    process.env.NODE_ENV = 'production';
+    expect(isDevelopment()).toBe(false);
+
+    delete process.env.NODE_ENV;
+    expect(isDevelopment()).toBe(true);
+  });
+
+  it('isProduction works correctly', () => {
+    process.env.NODE_ENV = 'production';
+    expect(isProduction()).toBe(true);
+
+    process.env.NODE_ENV = 'development';
+    expect(isProduction()).toBe(false);
+
+    delete process.env.NODE_ENV;
+    expect(isProduction()).toBe(false);
+  });
+});

package/backend/tests/unit/helpers.test.ts

@@ -0,0 +1,63 @@
+import { convertSqlTypeToColumnType } from '../../src/utils/utils';
+import { ColumnType } from '@insforge/shared-schemas';
+import { describe, it, expect } from 'vitest';
+describe('convertSqlTypeToColumnType', () => {
+  it('converts UUID correctly', () => {
+    expect(convertSqlTypeToColumnType('uuid')).toBe(ColumnType.UUID);
+    expect(convertSqlTypeToColumnType('UUID')).toBe(ColumnType.UUID);
+  });
+
+  it('converts timestamp types correctly', () => {
+    expect(convertSqlTypeToColumnType('timestamptz')).toBe(ColumnType.DATETIME);
+    expect(convertSqlTypeToColumnType('timestamp with time zone')).toBe(ColumnType.DATETIME);
+  });
+
+  it('converts integer types correctly', () => {
+    const integers = [
+      'integer',
+      'bigint',
+      'smallint',
+      'int',
+      'int2',
+      'int4',
+      'serial',
+      'serial2',
+      'serial4',
+      'serial8',
+      'smallserial',
+      'bigserial',
+    ];
+    integers.forEach((type) => {
+      expect(convertSqlTypeToColumnType(type)).toBe(ColumnType.INTEGER);
+    });
+  });
+
+  it('converts float types correctly', () => {
+    const floats = ['double precision', 'real', 'numeric', 'float', 'float4', 'float8', 'decimal'];
+    floats.forEach((type) => {
+      expect(convertSqlTypeToColumnType(type)).toBe(ColumnType.FLOAT);
+    });
+  });
+
+  it('converts boolean types correctly', () => {
+    expect(convertSqlTypeToColumnType('boolean')).toBe(ColumnType.BOOLEAN);
+    expect(convertSqlTypeToColumnType('bool')).toBe(ColumnType.BOOLEAN);
+  });
+
+  it('converts JSON types correctly', () => {
+    expect(convertSqlTypeToColumnType('json')).toBe(ColumnType.JSON);
+    expect(convertSqlTypeToColumnType('jsonb')).toBe(ColumnType.JSON);
+    expect(convertSqlTypeToColumnType('array')).toBe(ColumnType.JSON);
+  });
+
+  it('converts string types correctly', () => {
+    const strings = ['text', 'varchar', 'char', 'character', 'character varying'];
+    strings.forEach((type) => {
+      expect(convertSqlTypeToColumnType(type)).toBe(ColumnType.STRING);
+    });
+  });
+
+  it('returns first 5 chars for unknown types', () => {
+    expect(convertSqlTypeToColumnType('customtype')).toBe('custo');
+  });
+});

package/backend/tests/unit/logger.test.ts

@@ -0,0 +1,22 @@
+import { logger } from '../../src/utils/logger';
+import { describe, it, expect, vi } from 'vitest';
+
+describe('Logger', () => {
+  it('should initialize with correct log level from environment or default', () => {
+    expect(logger.level).toBe(process.env.LOG_LEVEL || 'info');
+  });
+
+  it('should log messages without throwing', () => {
+    expect(() => logger.info('Test info message')).not.toThrow();
+    expect(() => logger.warn('Test warn message')).not.toThrow();
+    expect(() => logger.error('Test error message')).not.toThrow();
+  });
+
+  it('should call logger.error when logging errors', () => {
+    const error = new Error('Test error');
+    const logSpy = vi.spyOn(logger, 'error').mockImplementation(() => logger);
+    logger.error(error);
+    expect(logSpy).toHaveBeenCalled();
+    logSpy.mockRestore();
+  });
+});