@oalacea/daemon 0.6.3 → 0.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oalacea/daemon",
-  "version": "0.6.3",
-  "description": "AI-powered automated test generation and remediation for web applications",
+  "version": "0.7.0",
+  "description": "AI-powered code quality analysis, scoring, and optimization for web applications",
   "author": "Yanis",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,15 @@
     "performance",
     "vitest",
     "playwright",
-    "k6"
+    "k6",
+    "code-quality",
+    "scoring",
+    "seo",
+    "security",
+    "accessibility",
+    "optimization",
+    "rust",
+    "nestjs"
   ],
   "devDependencies": {
     "@types/node": "^20.19.33",

package/templates/README.md

@@ -14,6 +14,25 @@ templates/
 │   ├── angular-component.test.ts # Angular component template
 │   ├── hook.test.ts             # React hooks template
 │   └── api.test.ts              # API route template
+├── rust/                        # Rust test templates
+│   ├── unit.test.rs             # Basic unit test template
+│   ├── integration.test.rs      # Integration test template
+│   ├── axum-handler.test.rs     # Axum framework handler tests
+│   ├── actix-controller.test.rs # Actix-web controller tests
+│   ├── rocket-route.test.rs     # Rocket framework route tests
+│   └── Cargo.toml               # Test dependencies configuration
+├── nestjs/                      # NestJS test templates
+│   ├── controller.spec.ts       # Controller unit tests
+│   ├── service.spec.ts          # Service unit tests
+│   ├── module.spec.ts           # Module tests
+│   ├── guard.spec.ts            # Guard tests
+│   ├── interceptor.spec.ts      # Interceptor tests
+│   ├── pipe.spec.ts             # Pipe tests
+│   ├── e2e/                     # E2E tests
+│   │   ├── api.e2e-spec.ts      # API E2E tests
+│   │   └── auth.e2e-spec.ts     # Auth E2E tests
+│   └── fixtures/                # Test utilities
+│       └── test-module.ts       # Module fixture
 ├── playwright/                  # Playwright E2E templates
 │   ├── auth.spec.ts
 │   └── crud.spec.ts
@@ -25,6 +44,8 @@ templates/
 
 ## Framework Support
 
+### Frontend Frameworks
+
 | Framework | Template | Testing Library |
 |-----------|----------|-----------------|
 | React | `component.test.ts` | `@testing-library/react` |
@@ -33,6 +54,168 @@ templates/
 | Svelte | `svelte-component.test.ts` | `@testing-library/svelte` |
 | Angular | `angular-component.test.ts` | `@angular/core/testing` |
 
+### Backend Frameworks
+
+| Framework | Templates | Testing Library |
+|-----------|----------|-----------------|
+| NestJS | `*.spec.ts` | `@nestjs/testing` |
+| Rust - Axum | `axum-handler.test.rs` | `axum-test` |
+| Rust - Actix | `actix-controller.test.rs` | `actix-rt` |
+| Rust - Rocket | `rocket-route.test.rs` | Built-in |
+| Rust - Generic | `unit.test.rs`, `integration.test.rs` | Built-in |
+| Express | `api.test.ts` | `supertest` |
+| Fastify | `api.test.ts` | `supertest` |
+
+## Rust Templates
+
+The Rust templates provide test coverage for common Rust web frameworks and general testing patterns:
+
+### Unit Tests
+
+- **unit.test.rs**: Basic unit test template including:
+  - Test function examples
+  - Error handling tests
+  - Test fixtures
+  - Assertion patterns
+
+### Integration Tests
+
+- **integration.test.rs**: Integration test template including:
+  - API endpoint testing
+  - Database operations
+  - Test app setup helpers
+  - Test database pool creation
+
+### Framework-Specific Tests
+
+- **axum-handler.test.rs**: Axum framework tests including:
+  - Health check endpoint
+  - GET/POST handler tests
+  - Request/response validation
+  - Error status code verification
+
+- **actix-controller.test.rs**: Actix-web framework tests including:
+  - Controller initialization
+  - Route handler testing
+  - Query parameter handling
+  - JSON payload validation
+
+- **rocket-route.test.rs**: Rocket framework tests including:
+  - Route testing with blocking client
+  - Authentication header handling
+  - Form data testing
+  - Status code assertions
+
+### Configuration
+
+- **Cargo.toml**: Test dependencies including:
+  - `tokio-test` for async testing
+  - `criterion` for benchmarks
+  - Framework-specific test utilities
+
+## NestJS Templates
+
+The NestJS templates provide comprehensive test coverage for all NestJS components:
+
+### Unit Tests
+
+- **controller.spec.ts**: Tests for controllers including:
+  - Route handlers
+  - Request/response handling
+  - Query parameters
+  - DTO validation
+  - Error handling
+
+- **service.spec.ts**: Tests for services including:
+  - Business logic
+  - Repository mocking
+  - CRUD operations
+  - Transaction handling
+  - Database errors
+
+- **module.spec.ts**: Tests for modules including:
+  - Provider availability
+  - Dependency injection
+  - Module configuration
+  - Dynamic modules
+
+- **guard.spec.ts**: Tests for guards including:
+  - Authentication logic
+  - Authorization checks
+  - Role validation
+  - Public route handling
+
+- **interceptor.spec.ts**: Tests for interceptors including:
+  - Request/response transformation
+  - Logging behavior
+  - Caching
+  - Timeout handling
+
+- **pipe.spec.ts**: Tests for pipes including:
+  - Data transformation
+  - Validation logic
+  - Error handling
+  - Custom business rules
+
+### E2E Tests
+
+- **api.e2e-spec.ts**: Full API testing including:
+  - CRUD operations
+  - Pagination/filtering/sorting
+  - Error handling
+  - Performance tests
+  - CORS and rate limiting
+
+- **auth.e2e-spec.ts**: Authentication testing including:
+  - Registration flow
+  - Login/logout
+  - Token refresh
+  - Password reset
+  - Role-based access
+
+### Fixtures
+
+- **test-module.ts**: Common test utilities including:
+  - Mock repository factory
+  - Mock JWT service
+  - Test module builder
+  - Mock execution context
+  - Test data generators
+
+## Patterns Checked
+
+The NestJS analyzer verifies:
+
+### Dependency Injection
+- Circular dependencies between services
+- Proper provider exports
+- Missing @Injectable decorators
+- Constructor injection patterns
+
+### Decorators
+- @Controller with routes
+- @Injectable on services/guards/pipes
+- @UseGuards on protected routes
+- @UsePipes for validation
+- @UseInterceptors for cross-cutting concerns
+
+### Single Responsibility
+- Services with too many dependencies (>5)
+- Controllers without route handlers
+- Large service classes (potential refactoring)
+
+### Error Handling
+- Proper exception usage
+- HTTP exception decorators
+- Exception filters
+- Error response format
+
+### DTOs
+- class-validator decorators
+- class-transformer usage
+- Partial types for updates
+- Nested DTO validation
+
 ## Usage
 
 Templates are used by the test generator agent to create new test files based on the detected framework and patterns.

package/templates/nestjs/controller.spec.ts

@@ -0,0 +1,203 @@
+/**
+ * NestJS Controller Test Template
+ *
+ * Tests for NestJS controllers following best practices:
+ * - Isolated unit tests (no actual HTTP)
+ * - Mocked services and providers
+ * - Proper DTO validation
+ * - Error handling coverage
+ *
+ * @package test
+ */
+
+import { Test, TestingModule } from '@nestjs/testing';
+import { GameController } from './game.controller';
+import { GameService } from './game.service';
+import { CreateGameDto, UpdateGameDto } from './dto';
+import { NotFoundException, BadRequestException } from '@nestjs/common';
+
+describe('GameController', () => {
+  let controller: GameController;
+  let service: GameService;
+
+  // Mock service
+  const mockGameService = {
+    findAll: jest.fn(),
+    findOne: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+    remove: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [GameController],
+      providers: [
+        {
+          provide: GameService,
+          useValue: mockGameService,
+        },
+      ],
+    }).compile();
+
+    controller = module.get<GameController>(GameController);
+    service = module.get<GameService>(GameService);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('findAll', () => {
+    it('should return an array of games', async () => {
+      const expectedGames = [
+        { id: '1', name: 'Game 1' },
+        { id: '2', name: 'Game 2' },
+      ];
+
+      mockGameService.findAll.mockResolvedValue(expectedGames);
+
+      const result = await controller.findAll();
+
+      expect(result).toEqual(expectedGames);
+      expect(service.findAll).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle empty results', async () => {
+      mockGameService.findAll.mockResolvedValue([]);
+
+      const result = await controller.findAll();
+
+      expect(result).toEqual([]);
+      expect(service.findAll).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('findOne', () => {
+    it('should return a single game by id', async () => {
+      const expectedGame = { id: '1', name: 'Game 1' };
+
+      mockGameService.findOne.mockResolvedValue(expectedGame);
+
+      const result = await controller.findOne('1');
+
+      expect(result).toEqual(expectedGame);
+      expect(service.findOne).toHaveBeenCalledWith('1');
+    });
+
+    it('should throw NotFoundException when game not found', async () => {
+      mockGameService.findOne.mockRejectedValue(
+        new NotFoundException('Game not found')
+      );
+
+      await expect(controller.findOne('999')).rejects.toThrow(
+        NotFoundException
+      );
+      expect(service.findOne).toHaveBeenCalledWith('999');
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new game', async () => {
+      const createGameDto: CreateGameDto = {
+        name: 'New Game',
+        type: 'action',
+      };
+
+      const createdGame = { id: '1', ...createGameDto };
+
+      mockGameService.create.mockResolvedValue(createdGame);
+
+      const result = await controller.create(createGameDto);
+
+      expect(result).toEqual(createdGame);
+      expect(service.create).toHaveBeenCalledWith(createGameDto);
+    });
+
+    it('should throw BadRequestException for invalid DTO', async () => {
+      const invalidDto = { name: '' };
+
+      mockGameService.create.mockRejectedValue(
+        new BadRequestException('Invalid data')
+      );
+
+      await expect(controller.create(invalidDto as any)).rejects.toThrow(
+        BadRequestException
+      );
+    });
+  });
+
+  describe('update', () => {
+    it('should update an existing game', async () => {
+      const updateGameDto: UpdateGameDto = {
+        name: 'Updated Game',
+      };
+
+      const updatedGame = { id: '1', ...updateGameDto };
+
+      mockGameService.update.mockResolvedValue(updatedGame);
+
+      const result = await controller.update('1', updateGameDto);
+
+      expect(result).toEqual(updatedGame);
+      expect(service.update).toHaveBeenCalledWith('1', updateGameDto);
+    });
+
+    it('should throw NotFoundException when updating non-existent game', async () => {
+      const updateGameDto: UpdateGameDto = { name: 'Updated' };
+
+      mockGameService.update.mockRejectedValue(
+        new NotFoundException('Game not found')
+      );
+
+      await expect(controller.update('999', updateGameDto)).rejects.toThrow(
+        NotFoundException
+      );
+    });
+  });
+
+  describe('remove', () => {
+    it('should delete a game', async () => {
+      mockGameService.remove.mockResolvedValue(undefined);
+
+      await controller.remove('1');
+
+      expect(service.remove).toHaveBeenCalledWith('1');
+    });
+
+    it('should throw NotFoundException when deleting non-existent game', async () => {
+      mockGameService.remove.mockRejectedValue(
+        new NotFoundException('Game not found')
+      );
+
+      await expect(controller.remove('999')).rejects.toThrow(
+        NotFoundException
+      );
+    });
+  });
+
+  describe('query parameters', () => {
+    it('should handle query parameters correctly', async () => {
+      const expectedGames = [{ id: '1', name: 'Filtered Game' }];
+
+      mockGameService.findAll.mockResolvedValue(expectedGames);
+
+      const result = await controller.findAll({
+        page: '1',
+        limit: '10',
+        search: 'test',
+      } as any);
+
+      expect(result).toEqual(expectedGames);
+      expect(service.findAll).toHaveBeenCalledWith({
+        page: 1,
+        limit: 10,
+        search: 'test',
+      });
+    });
+  });
+});