Added tests

Author: jasny

.yarnrc.yml

@@ -0,0 +1,3 @@
+compressionLevel: mixed
+
+enableGlobalCache: false

package.json

@@ -80,7 +80,7 @@
       "^.+\\.(t|j)s$": "ts-jest"
     },
     "collectCoverageFrom": [
-      "**/*.(t|j)s"
+      "<rootDir>/**/*.service.ts"
     ],
     "moduleNameMapper": {
       "^@/(.*)$": "<rootDir>/$1"

src/app.service.spec.ts

@@ -0,0 +1,38 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppService } from './app.service';
+import { ConfigService } from '@/common/config/config.service';
+import Ajv, { AnySchema } from 'ajv';
+
+describe('AppService', () => {
+  let service: AppService;
+  let config: { get: jest.Mock };
+  let ajv: Ajv;
+
+  beforeEach(async () => {
+    config = { get: jest.fn().mockReturnValue('test') } as any;
+
+    ajv = new Ajv({ allErrors: true });
+    // Register a few schemas so that schemas listing is covered
+    ajv.addSchema({ $id: 'https://schemas.letsflow.io/example-1', type: 'object' } as AnySchema);
+    ajv.addSchema({ $id: 'https://json-schema.org/draft/2020-12/schema', type: 'object' } as AnySchema);
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AppService, { provide: ConfigService, useValue: config }, { provide: Ajv, useValue: ajv }],
+    }).compile();
+
+    service = module.get(AppService);
+  });
+
+  it('initializes info on module init', () => {
+    service.onModuleInit();
+
+    expect(service.info).toBeDefined();
+    expect(typeof service.info.name).toBe('string');
+    expect(typeof service.info.version).toBe('string');
+    expect(typeof service.info.description).toBe('string');
+    expect(service.info.env).toEqual('test');
+    // Should include our custom schema id
+    expect(service.info.schemas).toContain('https://schemas.letsflow.io/example-1');
+    expect(Array.isArray(service.info.schemas)).toBe(true);
+  });
+});

src/auth/auth.service.spec.ts

@@ -1,8 +1,10 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AuthService } from './auth.service';
 import { ConfigModule } from '@/common/config/config.module';
-import { JwtModule } from '@nestjs/jwt';
+import { JwtModule, JwtService } from '@nestjs/jwt';
 import { Db } from 'mongodb';
+import { Logger } from '@nestjs/common';
+import { ConfigService } from '@/common/config/config.service';
 
 const developmentJwtOptions = {
   global: true,
@@ -12,6 +14,7 @@ const developmentJwtOptions = {
 
 describe('AuthService', () => {
   let service: AuthService;
+  let module: TestingModule;
   let apiKeysCollection: { findOne: jest.Mock; updateOne: jest.Mock };
 
   beforeEach(async () => {
@@ -20,7 +23,7 @@ describe('AuthService', () => {
       updateOne: jest.fn(),
     };
 
-    const module: TestingModule = await Test.createTestingModule({
+    module = await Test.createTestingModule({
       imports: [ConfigModule, JwtModule.register(developmentJwtOptions)],
       providers: [
         AuthService,
@@ -34,9 +37,104 @@ describe('AuthService', () => {
     }).compile();
 
     service = module.get<AuthService>(AuthService);
+
+    // Default init
+    const config = module.get(ConfigService);
+    jest.spyOn(config, 'get').mockImplementation((key: any) => {
+      if (key === 'jwt.transform') return '';
+      if (key === 'dev.demoAccounts') return false;
+      return undefined as any;
+    });
+    service.onModuleInit();
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks();
+    await module.close();
   });
 
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  it('onModuleInit initializes demo accounts when enabled', () => {
+    const config = module.get(ConfigService);
+    jest
+      .spyOn(config, 'get')
+      .mockImplementation((key: any) =>
+        key === 'jwt.transform'
+          ? ''
+          : key === 'dev.demoAccounts'
+            ? true
+            : key === 'dev.defaultAccount'
+              ? 'alice'
+              : (config as any).get(key),
+      );
+
+    service.onModuleInit();
+
+    expect(service.demoAccounts).toBeDefined();
+    expect(service.defaultAccount?.id).toBe('alice');
+  });
+
+  it('devAccount creates token for provided account', () => {
+    const account = service.devAccount({ id: 'x', info: { name: 'X' }, roles: ['r'] });
+    expect(account?.token).toBeDefined();
+    expect(account?.id).toBe('x');
+  });
+
+  it('hasPrivilege checks privileges correctly', () => {
+    const config = module.get(ConfigService);
+    jest.spyOn(config, 'get').mockImplementation((key: any) => {
+      if (key === 'auth.roles') return { admin: ['*'], user: ['process:start'], viewer: [] } as any;
+      if (key === 'jwt.transform') return '';
+      return undefined as any;
+    });
+
+    service.onModuleInit();
+
+    expect(service.hasPrivilege({ id: '1', roles: ['user'], token: '', info: {} }, 'process:start')).toBe(true);
+    expect(service.hasPrivilege({ id: '1', roles: ['viewer'], token: '', info: {} }, 'process:start')).toBe(false);
+    expect(service.hasPrivilege({ id: '1', roles: ['admin'], token: '', info: {} }, 'process:super')).toBe(true);
+    expect(service.hasPrivilege({ id: '1', roles: ['user'], token: '', info: {} }, ['process:start'])).toBe(true);
+  });
+
+  it('verifyJWT returns null on invalid token', () => {
+    expect(service.verifyJWT('invalid.token.value')).toBeNull();
+  });
+
+  it('verifyJWT uses transform and throws when id missing', () => {
+    const warn = jest.spyOn(Logger.prototype, 'warn').mockImplementation(() => undefined);
+    const config = module.get(ConfigService);
+    jest.spyOn(config, 'get').mockImplementation((key: any) => {
+      if (key === 'jwt.transform') return '{roles: roles, info: info}';
+      return undefined as any;
+    });
+
+    service.onModuleInit();
+
+    const token = module.get(JwtService).sign({ name: 'No id' } as any);
+
+    expect(() => service.verifyJWT(token)).toThrow('Invalid JWT payload');
+    expect(warn).toHaveBeenCalled();
+  });
+
+  it('verifyJWT returns account when token valid', () => {
+    const token = module.get(JwtService).sign({ id: 'abc', roles: ['x'], info: { a: 1 } } as any);
+    const acc = service.verifyJWT(token);
+    expect(acc).toEqual({ id: 'abc', roles: ['x'], info: { a: 1 }, token });
+  });
+
+  it('verifyApiKey returns data and updates lastUsed when found', async () => {
+    apiKeysCollection.findOne.mockResolvedValue({ privileges: ['p'], service: 'svc' });
+    const res = await service.verifyApiKey('t');
+    expect(res).toEqual({ privileges: ['p'], service: 'svc' });
+    expect(apiKeysCollection.updateOne).toHaveBeenCalled();
+  });
+
+  it('verifyApiKey returns null when not found', async () => {
+    apiKeysCollection.findOne.mockResolvedValue(null);
+    const res = await service.verifyApiKey('t');
+    expect(res).toBeNull();
+  });
 });

src/notify/notify.service.spec.ts

@@ -7,49 +7,37 @@ import { ProcessService } from '@/process/process.service';
 import { WebhookService } from '@/notify/webhook/webhook.service';
 import { AmqpService } from '@/notify/amqp/ampq.service';
 
+jest.mock('@letsflow/core/process', () => ({
+  determineTrigger: jest.fn(),
+}));
+import { determineTrigger } from '@letsflow/core/process';
+
 describe('NotifyService', () => {
   let service: NotifyService;
+  let config: { get: jest.Mock };
+  let processes: { step: jest.Mock };
+  let amqp: { notify: jest.Mock };
+  let webhook: { notify: jest.Mock };
+  let zeromq: { notify: jest.Mock };
+  let logger: { error: jest.Mock };
 
   beforeEach(async () => {
+    config = { get: jest.fn() } as any;
+    processes = { step: jest.fn() } as any;
+    amqp = { notify: jest.fn() } as any;
+    webhook = { notify: jest.fn() } as any;
+    zeromq = { notify: jest.fn() } as any;
+    logger = { error: jest.fn() } as any;
+
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         NotifyService,
-        {
-          provide: ConfigService,
-          useValue: {
-            get: jest.fn(),
-          },
-        },
-        {
-          provide: ProcessService,
-          useValue: {
-            get: jest.fn(),
-          },
-        },
-        {
-          provide: AmqpService,
-          useValue: {
-            notify: jest.fn(),
-          },
-        },
-        {
-          provide: WebhookService,
-          useValue: {
-            notify: jest.fn(),
-          },
-        },
-        {
-          provide: ZeromqService,
-          useValue: {
-            notify: jest.fn(),
-          },
-        },
-        {
-          provide: Logger,
-          useValue: {
-            error: jest.fn(),
-          },
-        },
+        { provide: ConfigService, useValue: config },
+        { provide: ProcessService, useValue: processes },
+        { provide: AmqpService, useValue: amqp },
+        { provide: WebhookService, useValue: webhook },
+        { provide: ZeromqService, useValue: zeromq },
+        { provide: Logger, useValue: logger },
       ],
     }).compile();
 
@@ -59,4 +47,75 @@ describe('NotifyService', () => {
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe('getProvider', () => {
+    it('returns provider based on config', () => {
+      config.get.mockReturnValue({
+        email: { provider: 'amqp' },
+        hook: { provider: 'webhook' },
+        zmq: { provider: 'zeromq' },
+      });
+      expect((service as any)['getProvider']('email')).toBe(amqp);
+      expect((service as any)['getProvider']('hook')).toBe(webhook);
+      expect((service as any)['getProvider']('zmq')).toBe(zeromq);
+    });
+
+    it('throws when service not configured', () => {
+      config.get.mockReturnValue({});
+      expect(() => (service as any)['getProvider']('foo')).toThrow("Service 'foo' not configured");
+    });
+
+    it('throws when provider unspecified', () => {
+      config.get.mockReturnValue({ foo: {} });
+      expect(() => (service as any)['getProvider']('foo')).toThrow("Provider not specified for service 'foo'");
+    });
+
+    it('throws on unsupported provider', () => {
+      config.get.mockReturnValue({ foo: { provider: 'unknown' } });
+      expect(() => (service as any)['getProvider']('foo')).toThrow("Unsupported provider 'unknown' for service 'foo'");
+    });
+  });
+
+  describe('step', () => {
+    it('calls processes.step when action determined', async () => {
+      (determineTrigger as unknown as jest.Mock).mockReturnValue('complete');
+      const process: any = { current: { key: 'initial' } };
+      // Access private for test
+      await (service as any)['step'](process, 'email', { ok: true });
+      expect(processes.step).toHaveBeenCalledWith(process, 'complete', { key: 'service:email' }, { ok: true });
+    });
+
+    it('throws if action cannot be determined', async () => {
+      (determineTrigger as unknown as jest.Mock).mockReturnValue(undefined);
+      const process: any = { current: { key: 'initial' } };
+      await expect(
+        // Access private for test
+        (service as any)['step'](process, 'email', { ok: true }),
+      ).rejects.toThrow("Service 'email' gave a response, but unable to determine which action was executed");
+    });
+  });
+
+  describe('notify', () => {
+    it('logs error if provider throws', async () => {
+      config.get.mockReturnValue({ email: { provider: 'amqp' } });
+      amqp.notify.mockRejectedValue(new Error('boom'));
+      await service.notify({} as any, { service: 'email' } as any);
+      expect(logger.error).toHaveBeenCalledWith('boom');
+    });
+
+    it('steps when provider returns response', async () => {
+      config.get.mockReturnValue({ email: { provider: 'amqp' } });
+      amqp.notify.mockResolvedValue({ ok: true });
+      (determineTrigger as unknown as jest.Mock).mockReturnValue('complete');
+      await service.notify({} as any, { service: 'email' } as any);
+      expect(processes.step).toHaveBeenCalled();
+    });
+
+    it('does nothing when provider returns undefined', async () => {
+      config.get.mockReturnValue({ email: { provider: 'amqp' } });
+      amqp.notify.mockResolvedValue(undefined);
+      await service.notify({} as any, { service: 'email' } as any);
+      expect(processes.step).not.toHaveBeenCalled();
+    });
+  });
 });