feat: 70+ coverage

Author: Bccorb

package-lock.json

@@ -80,6 +80,7 @@
     "husky": "^9.1.7",
     "lint-staged": "^16.2.6",
     "prettier": "^3.8.1",
+    "sqlite3": "^6.0.1",
     "supertest": "^7.1.4",
     "ts-node": "^10.9.2",
     "tsx": "^4.21.0",

package.json

@@ -49,6 +49,10 @@ export async function requestMagicLink(req: Request, res: Response) {
 
   const { ip_hash, user_agent_hash } = hashDeviceFingerprint(req.ip, req.headers['user-agent']);
 
+  if (!ip_hash || !user_agent_hash) {
+    logger.error('Could not identify devive metadata to send a magic link');
+    return res.status(400).json({ error: 'Invalid device data' });
+  }
   // Expire all previous links
   await MagicLinkToken.update(
     { expires_at: new Date() },

src/controllers/magicLinks.ts

@@ -7,6 +7,7 @@ import { verifyBearerAuth } from './verifyBearerAuth.js';
 import { verifyCookieAuth } from './verifyCookieAuth.js';
 
 export function attachAuthMiddleware(cookieType: CookieType = 'access') {
+  console.log(process.env.AUTH_MODE);
   const mode = (process.env.AUTH_MODE || 'web').toLowerCase();
   return mode === 'server' ? verifyBearerAuth : verifyCookieAuth(cookieType);
 }

src/middleware/attachAuthMiddleware.ts

@@ -72,7 +72,7 @@ export function validateRedirectUrl(
 
     const isAllowed = allowedOrigins.some((origin) => url.origin === origin);
 
-    if (!isAllowed) {
+    if (!isAllowed || !url) {
       return null;
     }
 

src/schemas/magicLink.schema.ts

@@ -1,3 +1,5 @@
+import { vi } from 'vitest';
+
 export function buildSession(overrides: any = {}) {
   return {
     id: 'session-1',
@@ -8,6 +10,7 @@ export function buildSession(overrides: any = {}) {
     lastUsedAt: new Date().toDateString(),
     expiresAt: new Date(Date.now() + 100000).toDateString(),
     revokedAt: null,
+    save: vi.fn(),
     ...overrides,
   };
 }

src/utils/utils.ts

@@ -1,6 +1,5 @@
 import { vi } from 'vitest';
 
-let idCounter = 1;
 export let testGuid = 'c6e39f68-a09d-49dd-86b4-eab2c1e5de52';
 
 export function buildUser(overrides: Partial<any> = {}) {
@@ -11,6 +10,8 @@ export function buildUser(overrides: Partial<any> = {}) {
     roles: ['user'],
     challenge: 'challenge',
     createdAt: Date.now(),
+    emailVerified: true,
+    phoneVerified: true,
     toJSON: vi.fn(() => ({ id: 'user-1' })),
     update: vi.fn(),
     destroy: vi.fn(),

tests/factories/sessionFactory.ts

@@ -0,0 +1,118 @@
+import { vi } from 'vitest';
+
+vi.mock('../../../src/models/systemConfig', () => ({
+  SystemConfig: {
+    findByPk: vi.fn(),
+    create: vi.fn(),
+  },
+}));
+
+vi.mock('../../../src/utils/parseEnvConfigs', () => ({
+  parseSystemConfigEnvValue: vi.fn(),
+}));
+
+vi.mock('../../../src/config/systemConfig.envMap', () => ({
+  SYSTEM_CONFIG_ENV_MAP: {
+    app_name: 'APP_NAME',
+    rate_limit: 'RATE_LIMIT',
+  },
+}));
+
+vi.mock('../../../src/schemas/systemConfig.schema', () => ({
+  SystemConfigSchema: {
+    safeParse: vi.fn(),
+  },
+}));
+
+function resetEnv() {
+  delete process.env.APP_NAME;
+  delete process.env.RATE_LIMIT;
+}
+
+import { describe, it, expect, beforeEach } from 'vitest';
+
+describe('bootstrapSystemConfig', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    resetEnv();
+  });
+
+  it('uses existing config from DB', async () => {
+    const { SystemConfig } = await import('../../../src/models/systemConfig');
+    const { SystemConfigSchema } = await import('../../../src/schemas/systemConfig.schema');
+
+    (SystemConfig.findByPk as any).mockResolvedValue({
+      value: 'existing',
+    });
+
+    (SystemConfigSchema.safeParse as any).mockReturnValue({
+      success: true,
+      data: { app_name: 'existing', rate_limit: 'existing' },
+    });
+
+    const { bootstrapSystemConfig } = await import('../../../src/config/bootstrapSystemConfig');
+
+    const result = await bootstrapSystemConfig();
+
+    expect(result).toBeDefined();
+    expect(SystemConfig.create).not.toHaveBeenCalled();
+  });
+
+  it('creates config from env when missing', async () => {
+    const { SystemConfig } = await import('../../../src/models/systemConfig');
+    const { parseSystemConfigEnvValue } = await import('../../../src/utils/parseEnvConfigs');
+    const { SystemConfigSchema } = await import('../../../src/schemas/systemConfig.schema');
+
+    (SystemConfig.findByPk as any).mockResolvedValue(null);
+
+    process.env.APP_NAME = 'TestApp';
+    process.env.RATE_LIMIT = '100';
+
+    (parseSystemConfigEnvValue as any).mockReturnValue('parsed');
+
+    (SystemConfigSchema.safeParse as any).mockReturnValue({
+      success: true,
+      data: { app_name: 'parsed', rate_limit: 'parsed' },
+    });
+
+    const { bootstrapSystemConfig } = await import('../../../src/config/bootstrapSystemConfig');
+
+    const result = await bootstrapSystemConfig();
+
+    expect(SystemConfig.create).toHaveBeenCalled();
+    expect(result).toBeDefined();
+  });
+
+  it('throws when env missing', async () => {
+    const { SystemConfig } = await import('../../../src/models/systemConfig');
+
+    (SystemConfig.findByPk as any).mockResolvedValue(null);
+
+    const { bootstrapSystemConfig } = await import('../../../src/config/bootstrapSystemConfig');
+
+    await expect(bootstrapSystemConfig()).rejects.toThrow('Missing required system config');
+  });
+
+  it('throws when schema invalid', async () => {
+    const { SystemConfig } = await import('../../../src/models/systemConfig');
+    const { parseSystemConfigEnvValue } = await import('../../../src/utils/parseEnvConfigs');
+    const { SystemConfigSchema } = await import('../../../src/schemas/systemConfig.schema');
+
+    (SystemConfig.findByPk as any).mockResolvedValue(null);
+
+    process.env.APP_NAME = 'TestApp';
+    process.env.RATE_LIMIT = '100';
+
+    (parseSystemConfigEnvValue as any).mockReturnValue('parsed');
+
+    (SystemConfigSchema.safeParse as any).mockReturnValue({
+      success: false,
+      error: { toString: () => 'invalid schema' },
+    });
+
+    const { bootstrapSystemConfig } = await import('../../../src/config/bootstrapSystemConfig');
+
+    await expect(bootstrapSystemConfig()).rejects.toThrow('Invalid system configuration');
+  });
+});

tests/factories/userFactory.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.unmock('../../../src/config/getSystemConfig');
+
+describe('getSystemConfig', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+  });
+
+  it('fetches config from DB when cache empty', async () => {
+    const { SystemConfig } = await import('../../../src/models/systemConfig');
+
+    (SystemConfig.findAll as any).mockResolvedValue([{ key: 'app_name', value: 'TestApp' }]);
+
+    const { getSystemConfig } = await import('../../../src/config/getSystemConfig');
+
+    const result = await getSystemConfig();
+
+    expect(SystemConfig.findAll).toHaveBeenCalled();
+    expect(result).toEqual({ app_name: 'TestApp' });
+  });
+
+  it('returns cached config when within TTL', async () => {
+    const { SystemConfig } = await import('../../../src/models/systemConfig');
+
+    (SystemConfig.findAll as any).mockResolvedValue([{ key: 'app_name', value: 'TestApp' }]);
+
+    const { getSystemConfig } = await import('../../../src/config/getSystemConfig');
+
+    const first = await getSystemConfig();
+    const second = await getSystemConfig();
+
+    expect(SystemConfig.findAll).toHaveBeenCalledTimes(1);
+    expect(second).toEqual(first);
+  });
+
+  it('refreshes cache after TTL expires', async () => {
+    const { SystemConfig } = await import('../../../src/models/systemConfig');
+
+    (SystemConfig.findAll as any)
+      .mockResolvedValueOnce([{ key: 'app_name', value: 'A' }])
+      .mockResolvedValueOnce([{ key: 'app_name', value: 'B' }]);
+
+    const { getSystemConfig } = await import('../../../src/config/getSystemConfig');
+
+    const first = await getSystemConfig();
+
+    // simulate time passing
+    vi.spyOn(Date, 'now')
+      .mockReturnValueOnce(Date.now() + 1)
+      .mockReturnValueOnce(Date.now() + 400_000); // > TTL
+
+    const second = await getSystemConfig();
+
+    expect(second).not.toEqual(first);
+    expect(SystemConfig.findAll).toHaveBeenCalledTimes(2);
+  });
+
+  it('invalidates cache manually', async () => {
+    const { SystemConfig } = await import('../../../src/models/systemConfig');
+
+    (SystemConfig.findAll as any)
+      .mockResolvedValueOnce([{ key: 'app_name', value: 'A' }])
+      .mockResolvedValueOnce([{ key: 'app_name', value: 'B' }]);
+
+    const { getSystemConfig, invalidateSystemConfigCache } =
+      await import('../../../src/config/getSystemConfig');
+
+    await getSystemConfig();
+
+    invalidateSystemConfigCache();
+
+    const result = await getSystemConfig();
+
+    expect(result).toEqual({ app_name: 'B' });
+    expect(SystemConfig.findAll).toHaveBeenCalledTimes(2);
+  });
+});