@oalacea/daemon 0.6.4 → 0.7.0

package/templates/nestjs/fixtures/test-module.ts

@@ -0,0 +1,311 @@
+/**
+ * NestJS Test Module Fixture
+ *
+ * Reusable test module configuration for unit testing.
+ * Provides common providers, mocks, and utilities.
+ *
+ * @package test
+ */
+
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication, ValidationPipe } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { ConfigModule } from '@nestjs/config';
+import { PassportModule } from '@nestjs/passport';
+import { JwtModule } from '@nestjs/jwt';
+
+// Mock repositories
+export const mockRepository = () => ({
+  find: jest.fn(),
+  findOne: jest.fn(),
+  findOneBy: jest.fn(),
+  create: jest.fn(),
+  save: jest.fn(),
+  update: jest.fn(),
+  delete: jest.fn(),
+  count: jest.fn(),
+  query: jest.fn(),
+});
+
+// Mock JwtService
+export const mockJwtService = () => ({
+  sign: jest.fn(),
+  verify: jest.fn(),
+  verifyAsync: jest.fn(),
+  decode: jest.fn(),
+});
+
+// Mock ConfigService
+export const mockConfigService = () => ({
+  get: jest.fn((key: string) => {
+    const config: Record<string, any> = {
+      JWT_SECRET: 'test-secret',
+      JWT_EXPIRES_IN: '1h',
+      DATABASE_URL: 'sqlite::memory:',
+    };
+    return config[key];
+  }),
+});
+
+/**
+ * Create a test module with common configuration
+ */
+export async function createTestModule(options: {
+  imports?: any[];
+  providers?: any[];
+  controllers?: any[];
+}) {
+  const moduleFixture: TestingModule = await Test.createTestingModule({
+    imports: [
+      ConfigModule.forRoot({ isGlobal: true }),
+      PassportModule.register({ defaultStrategy: 'jwt' }),
+      JwtModule.register({
+        secret: 'test-secret',
+        signOptions: { expiresIn: '1h' },
+      }),
+      ...(options.imports ?? []),
+    ],
+    providers: options.providers ?? [],
+    controllers: options.controllers ?? [],
+  })
+    .overrideProvider(JwtService)
+    .useValue(mockJwtService())
+    .compile();
+
+  return moduleFixture;
+}
+
+/**
+ * Create a test application with global configuration
+ */
+export async function createTestApplication(module: TestingModule): Promise<INestApplication> {
+  const app = module.createNestApplication();
+
+  // Apply global validation pipe
+  app.useGlobalPipes(
+    new ValidationPipe({
+      whitelist: true,
+      transform: true,
+      forbidNonWhitelisted: true,
+      transformOptions: {
+        enableImplicitConversion: true,
+      },
+    })
+  );
+
+  // Enable shutdown hooks
+  app.enableShutdownHooks();
+
+  await app.init();
+
+  return app;
+}
+
+/**
+ * Mock user for authentication tests
+ */
+export const mockUser = {
+  id: '1',
+  email: 'test@example.com',
+  name: 'Test User',
+  roles: ['user'],
+  createdAt: new Date(),
+  updatedAt: new Date(),
+};
+
+/**
+ * Mock admin user for role tests
+ */
+export const mockAdmin = {
+  id: '2',
+  email: 'admin@example.com',
+  name: 'Admin User',
+  roles: ['admin'],
+  createdAt: new Date(),
+  updatedAt: new Date(),
+};
+
+/**
+ * Create mock ExecutionContext
+ */
+export function createMockExecutionContext(request: any = {}) {
+  return {
+    switchToHttp: () => ({
+      getRequest: () => ({
+        method: 'GET',
+        url: '/',
+        headers: {},
+        user: null,
+        ...request,
+      }),
+      getResponse: () => ({
+        statusCode: 200,
+      }),
+    }),
+    getHandler: () => ({}),
+    getClass: () => ({}),
+    getArgByIndex: () => ({}),
+    getArgs: () => [],
+    getType: () => 'http',
+  };
+}
+
+/**
+ * Create mock CallHandler
+ */
+export function createMockCallHandler(value: any = { data: 'test' }) {
+  return {
+    handle: () => of(value),
+  };
+}
+
+/**
+ * Helper to create test entity
+ */
+export function createTestEntity(overrides: Partial<any> = {}) {
+  return {
+    id: '1',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  };
+}
+
+/**
+ * Wait for async operations
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Create test database connection options
+ */
+export function createTestDatabaseOptions() {
+  return {
+    type: 'sqlite',
+    database: ':memory:',
+    dropSchema: true,
+    synchronize: true,
+    logging: false,
+  };
+}
+
+/**
+ * Setup test database
+ */
+export async function setupTestDatabase(entities: any[]) {
+  const { DataSource } = require('typeorm');
+
+  const dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    entities,
+    synchronize: true,
+    logging: false,
+  });
+
+  await dataSource.initialize();
+
+  return dataSource;
+}
+
+/**
+ * Clean test database
+ */
+export async function cleanTestDatabase(dataSource: any) {
+  const entities = dataSource.entityMetadatas;
+  const repositoryNames = entities.map((e: any) => e.name);
+
+  // Clear all tables
+  for (const name of repositoryNames) {
+    const repository = dataSource.getRepository(name);
+    await repository.clear();
+  }
+}
+
+/**
+ * Mock file upload for testing
+ */
+export function createMockFile(overrides: Partial<Express.Multer.File> = {}) {
+  return {
+    fieldname: 'file',
+    originalname: 'test.jpg',
+    encoding: '7bit',
+    mimetype: 'image/jpeg',
+    size: 1024,
+    buffer: Buffer.from('test'),
+    destination: '/tmp',
+    filename: 'test.jpg',
+    path: '/tmp/test.jpg',
+    stream: null,
+    ...overrides,
+  };
+}
+
+/**
+ * Create test DTO with validation
+ */
+export function createTestDto<T>(dto: Class<T>, data: Partial<T>): T {
+  return Object.assign(Object.create(dto.prototype), data);
+}
+
+/**
+ * Type for class reference
+ */
+type Class<T> = new (...args: any[]) => T;
+
+/**
+ * Mock pagination options
+ */
+export function createMockPaginationOptions(overrides: any = {}) {
+  return {
+    page: 1,
+    limit: 10,
+    sortBy: 'createdAt',
+    sortOrder: 'DESC' as const,
+    ...overrides,
+  };
+}
+
+/**
+ * Mock filtered query options
+ */
+export function createMockFilterOptions(overrides: any = {}) {
+  return {
+    search: '',
+    status: null,
+    dateFrom: null,
+    dateTo: null,
+    ...overrides,
+  };
+}
+
+/**
+ * Export all test utilities
+ */
+export const testUtils = {
+  createTestModule,
+  createTestApplication,
+  createMockExecutionContext,
+  createMockCallHandler,
+  createTestEntity,
+  delay,
+  createTestDatabaseOptions,
+  setupTestDatabase,
+  cleanTestDatabase,
+  createMockFile,
+  createTestDto,
+  createMockPaginationOptions,
+  createMockFilterOptions,
+  mockRepository,
+  mockJwtService,
+  mockConfigService,
+  mockUser,
+  mockAdmin,
+};
+
+// Import RxJS 'of' for observable creation
+import { of } from 'rxjs';

package/templates/nestjs/guard.spec.ts

@@ -0,0 +1,314 @@
+/**
+ * NestJS Guard Test Template
+ *
+ * Tests for NestJS guards following best practices:
+ * - Authentication logic
+ * - Authorization checks
+ * - Role/permission validation
+ * - Context handling
+ *
+ * @package test
+ */
+
+import { ExecutionContext, ForbiddenException } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { AuthGuard } from './auth.guard';
+import { RolesGuard } from './roles.guard';
+import { JwtAuthGuard } from './jwt-auth.guard';
+
+describe('AuthGuard', () => {
+  let guard: AuthGuard;
+  let reflector: Reflector;
+
+  beforeEach(() => {
+    reflector = new Reflector();
+    guard = new AuthGuard(reflector);
+  });
+
+  describe('canActivate', () => {
+    it('should allow access with valid token', () => {
+      const context = createMockExecutionContext({
+        headers: {
+          authorization: 'Bearer valid-token',
+        },
+      });
+
+      jest.spyOn(guard, 'validateToken').mockResolvedValue(true);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(true);
+    });
+
+    it('should deny access without token', () => {
+      const context = createMockExecutionContext({
+        headers: {},
+      });
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(false);
+    });
+
+    it('should deny access with invalid token', () => {
+      const context = createMockExecutionContext({
+        headers: {
+          authorization: 'Bearer invalid-token',
+        },
+      });
+
+      jest.spyOn(guard, 'validateToken').mockResolvedValue(false);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(false);
+    });
+
+    it('should handle malformed authorization header', () => {
+      const context = createMockExecutionContext({
+        headers: {
+          authorization: 'InvalidFormat token',
+        },
+      });
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(false);
+    });
+
+    it('should extract user from request and attach to context', async () => {
+      const context = createMockExecutionContext({
+        headers: {
+          authorization: 'Bearer valid-token',
+        },
+      });
+
+      const mockUser = { id: '1', username: 'test' };
+      jest.spyOn(guard, 'getUserFromToken').mockResolvedValue(mockUser);
+
+      await guard.canActivate(context);
+
+      const request = context.switchToHttp().getRequest();
+      expect(request.user).toEqual(mockUser);
+    });
+  });
+
+  describe('public routes', () => {
+    it('should allow access to public routes', () => {
+      const context = createMockExecutionContext({
+        headers: {},
+      });
+
+      jest.spyOn(reflector, 'get').mockReturnValue(true);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(true);
+      expect(reflector.get).toHaveBeenCalledWith('isPublic', expect.any());
+    });
+
+    it('should check for isPublic decorator on handler', () => {
+      const context = createMockExecutionContext();
+
+      jest.spyOn(reflector, 'get').mockReturnValue(true);
+
+      guard.canActivate(context);
+
+      expect(reflector.get).toHaveBeenCalledWith(
+        'isPublic',
+        context.getHandler()
+      );
+    });
+  });
+});
+
+describe('RolesGuard', () => {
+  let guard: RolesGuard;
+  let reflector: Reflector;
+
+  beforeEach(() => {
+    reflector = new Reflector();
+    guard = new RolesGuard(reflector);
+  });
+
+  describe('canActivate', () => {
+    it('should allow access when user has required role', () => {
+      const context = createMockExecutionContext({
+        user: { roles: ['admin'] },
+      });
+
+      jest.spyOn(reflector, 'get').mockReturnValue(['admin']);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(true);
+    });
+
+    it('should deny access when user lacks required role', () => {
+      const context = createMockExecutionContext({
+        user: { roles: ['user'] },
+      });
+
+      jest.spyOn(reflector, 'get').mockReturnValue(['admin']);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(false);
+    });
+
+    it('should allow access when no roles are required', () => {
+      const context = createMockExecutionContext({
+        user: { roles: ['user'] },
+      });
+
+      jest.spyOn(reflector, 'get').mockReturnValue(null);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(true);
+    });
+
+    it('should allow access when user has multiple roles including required', () => {
+      const context = createMockExecutionContext({
+        user: { roles: ['user', 'moderator', 'admin'] },
+      });
+
+      jest.spyOn(reflector, 'get').mockReturnValue(['admin', 'moderator']);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(true);
+    });
+
+    it('should handle user without roles property', () => {
+      const context = createMockExecutionContext({
+        user: {},
+      });
+
+      jest.spyOn(reflector, 'get').mockReturnValue(['user']);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(false);
+    });
+
+    it('should handle missing user in request', () => {
+      const context = createMockExecutionContext({
+        user: null,
+      });
+
+      jest.spyOn(reflector, 'get').mockReturnValue(['admin']);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(false);
+    });
+  });
+
+  describe('role hierarchy', () => {
+    it('should respect role hierarchy', () => {
+      const context = createMockExecutionContext({
+        user: { roles: ['super-admin'] },
+      });
+
+      jest.spyOn(reflector, 'get').mockReturnValue(['admin']);
+      jest.spyOn(guard, 'hasHigherRole').mockReturnValue(true);
+
+      const result = guard.canActivate(context);
+
+      expect(result).resolves.toBe(true);
+    });
+  });
+});
+
+describe('JwtAuthGuard', () => {
+  let guard: JwtAuthGuard;
+  let jwtService: any;
+
+  beforeEach(() => {
+    jwtService = {
+      verifyAsync: jest.fn(),
+    };
+    guard = new JwtAuthGuard(jwtService);
+  });
+
+  describe('canActivate', () => {
+    it('should validate JWT token', async () => {
+      const context = createMockExecutionContext({
+        headers: {
+          authorization: 'Bearer valid.jwt.token',
+        },
+      });
+
+      const payload = { sub: '1', username: 'test' };
+      jest.spyOn(jwtService, 'verifyAsync').mockResolvedValue(payload);
+
+      const result = await guard.canActivate(context);
+
+      expect(result).toBe(true);
+      expect(jwtService.verifyAsync).toHaveBeenCalledWith('valid.jwt.token');
+    });
+
+    it('should attach user payload to request', async () => {
+      const context = createMockExecutionContext({
+        headers: {
+          authorization: 'Bearer valid.jwt.token',
+        },
+      });
+
+      const payload = { sub: '1', username: 'test' };
+      jest.spyOn(jwtService, 'verifyAsync').mockResolvedValue(payload);
+
+      await guard.canActivate(context);
+
+      const request = context.switchToHttp().getRequest();
+      expect(request.user).toEqual(payload);
+    });
+
+    it('should throw UnauthorizedException for invalid token', async () => {
+      const context = createMockExecutionContext({
+        headers: {
+          authorization: 'Bearer invalid.token',
+        },
+      });
+
+      jest.spyOn(jwtService, 'verifyAsync').mockRejectedValue(
+        new Error('Invalid token')
+      );
+
+      await expect(guard.canActivate(context)).rejects.toThrow();
+    });
+
+    it('should handle expired tokens', async () => {
+      const context = createMockExecutionContext({
+        headers: {
+          authorization: 'Bearer expired.token',
+        },
+      });
+
+      jest.spyOn(jwtService, 'verifyAsync').mockRejectedValue(
+        new Error('Token expired')
+      );
+
+      await expect(guard.canActivate(context)).rejects.toThrow();
+    });
+  });
+});
+
+// Helper function to create mock ExecutionContext
+function createMockExecutionContext(requestData: any = {}): ExecutionContext {
+  return {
+    switchToHttp: () => ({
+      getRequest: () => ({
+        headers: requestData.headers || {},
+        user: requestData.user,
+        ...requestData,
+      }),
+    }),
+    getHandler: () => ({}),
+    getClass: () => ({}),
+    getArgByIndex: () => ({}),
+    getArgs: () => [],
+    getType: () => 'http',
+  } as unknown as ExecutionContext;
+}