@oalacea/daemon 0.7.2 → 0.7.3

package/dist/prompts/UNIT.md

@@ -0,0 +1,260 @@
+# Unit Test Generation Guide
+
+This prompt is included by EXECUTE.md. It provides detailed guidance for generating unit tests.
+
+---
+
+## Component Test Patterns
+
+### Presentational Components
+
+```typescript
+// Button component test
+describe('Button', () => {
+  it('should render with default props', () => {
+    render(<Button>Click me</Button>);
+    expect(screen.getByRole('button')).toHaveTextContent('Click me');
+  });
+
+  it('should apply variant classes', () => {
+    render(<Button variant="danger">Delete</Button>);
+    expect(screen.getByRole('button')).toHaveClass('btn-danger');
+  });
+
+  it('should be disabled when loading', () => {
+    render(<Button loading>Submit</Button>);
+    expect(screen.getByRole('button')).toBeDisabled();
+    expect(screen.getByTestId('spinner')).toBeInTheDocument();
+  });
+});
+```
+
+### Container Components
+
+```typescript
+// UserList component test
+describe('UserList', () => {
+  it('should show loading state', () => {
+    vi.mocked(useUsers).mockReturnValue({ data: null, loading: true });
+    render(<UserList />);
+    expect(screen.getByTestId('skeleton')).toBeInTheDocument();
+  });
+
+  it('should show error state', () => {
+    vi.mocked(useUsers).mockReturnValue({
+      data: null,
+      loading: false,
+      error: new Error('Failed to fetch')
+    });
+    render(<UserList />);
+    expect(screen.getByText('Failed to fetch')).toBeInTheDocument();
+  });
+
+  it('should render users', () => {
+    vi.mocked(useUsers).mockReturnValue({
+      data: [{ id: '1', name: 'John' }],
+      loading: false,
+      error: null
+    });
+    render(<UserList />);
+    expect(screen.getByText('John')).toBeInTheDocument();
+  });
+});
+```
+
+---
+
+## Hook Test Patterns
+
+```typescript
+import { renderHook, act, waitFor } from '@testing-library/react';
+
+describe('useDebounce', () => {
+  vi.useFakeTimers();
+
+  it('should debounce value changes', async () => {
+    const { result } = renderHook(() => useDebounce('test', 500));
+
+    // Immediate value
+    expect(result.current).toBe('test');
+
+    // Change value immediately
+    act(() => {
+      result.current.setValue('test2');
+    });
+    expect(result.current.value).toBe('test'); // Not debounced yet
+
+    // Fast-forward
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    expect(result.current.value).toBe('test2');
+  });
+});
+```
+
+---
+
+## Utility Function Patterns
+
+```typescript
+describe('formatCurrency', () => {
+  it('should format positive numbers', () => {
+    expect(formatCurrency(1234.56)).toBe('$1,234.56');
+  });
+
+  it('should format zero', () => {
+    expect(formatCurrency(0)).toBe('$0.00');
+  });
+
+  it('should handle negative numbers', () => {
+    expect(formatCurrency(-100)).toBe('-$100.00');
+  });
+
+  it('should round to 2 decimal places', () => {
+    expect(formatCurrency(1.999)).toBe('$2.00');
+  });
+});
+```
+
+---
+
+## Validator Test Patterns (Zod)
+
+```typescript
+import { z } from 'zod';
+import { userSchema } from './schema';
+
+describe('userSchema', () => {
+  const validData = {
+    email: 'test@example.com',
+    age: 25,
+    name: 'John Doe'
+  };
+
+  it('should accept valid data', () => {
+    expect(() => userSchema.parse(validData)).not.toThrow();
+  });
+
+  it('should reject invalid email', () => {
+    expect(() =>
+      userSchema.parse({ ...validData, email: 'invalid' })
+    ).toThrow(z.ZodError);
+  });
+
+  it('should reject negative age', () => {
+    expect(() =>
+      userSchema.parse({ ...validData, age: -1 })
+    ).toThrow(z.ZodError);
+  });
+
+  it('should reject missing required fields', () => {
+    expect(() => userSchema.parse({})).toThrow(z.ZodError);
+  });
+});
+```
+
+---
+
+## Store Test Patterns (Zustand)
+
+```typescript
+import { create } from 'zustand';
+import { useAuthStore } from './authStore';
+
+describe('useAuthStore', () => {
+  beforeEach(() => {
+    useAuthStore.getState().reset();
+  });
+
+  it('should set user on login', () => {
+    const user = { id: '1', name: 'John' };
+    useAuthStore.getState().login(user);
+    expect(useAuthStore.getState().user).toEqual(user);
+    expect(useAuthStore.getState().isAuthenticated).toBe(true);
+  });
+
+  it('should clear user on logout', () => {
+    useAuthStore.getState().login({ id: '1', name: 'John' });
+    useAuthStore.getState().logout();
+    expect(useAuthStore.getState().user).toBeNull();
+    expect(useAuthStore.getState().isAuthenticated).toBe(false);
+  });
+});
+```
+
+---
+
+## Mock Patterns
+
+### Mocking React Query
+
+```typescript
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+
+function createTestQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: { retry: false },
+      mutations: { retry: false }
+    }
+  });
+}
+
+function Wrapper({ children }) {
+  return (
+    <QueryClientProvider client={createTestQueryClient()}>
+      {children}
+    </QueryClientProvider>
+  );
+}
+
+describe('MyComponent', () => {
+  it('should work with React Query', () => {
+    render(<MyComponent />, { wrapper: Wrapper });
+  });
+});
+```
+
+### Mocking Next.js Router
+
+```typescript
+import { useRouter } from 'next/navigation';
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({
+    push: vi.fn(),
+    replace: vi.fn(),
+    prefetch: vi.fn(),
+    back: vi.fn(),
+    pathname: '/test'
+  }),
+  useSearchParams: () => new URLSearchParams('foo=bar'),
+  usePathname: () => '/test'
+}));
+```
+
+### Mocking Fetch
+
+```typescript
+global.fetch = vi.fn(() =>
+  Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({ data: 'test' })
+  })
+) as ReturnType<typeof vi.fn>;
+
+// Or use MSW for more complex scenarios
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+
+const server = setupServer(
+  http.get('/api/users', () => {
+    return HttpResponse.json({ users: [] });
+  })
+);
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+```

package/dist/templates/README.md

@@ -0,0 +1,221 @@
+# Daemon Templates
+
+This directory contains test templates for different frameworks and tools.
+
+## Structure
+
+```
+templates/
+├── vitest/                      # Vitest test templates
+│   ├── component.test.ts        # React component template
+│   ├── vue-component.test.ts    # Vue component template
+│   ├── solid-component.test.ts  # Solid component template
+│   ├── svelte-component.test.ts # Svelte component template
+│   ├── 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
+├── k6/                          # k6 backend performance templates
+│   └── load-test.js
+└── lighthouse/                  # Lighthouse frontend performance (via CLI)
+    └── (run directly with npx lighthouse)
+```
+
+## Framework Support
+
+### Frontend Frameworks
+
+| Framework | Template | Testing Library |
+|-----------|----------|-----------------|
+| React | `component.test.ts` | `@testing-library/react` |
+| Vue | `vue-component.test.ts` | `@vue/test-utils` |
+| Solid | `solid-component.test.ts` | `@solidjs/testing-library` |
+| 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/dist/templates/k6/load-test.js

@@ -0,0 +1,54 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+
+// Configuration
+export const options = {
+  stages: [
+    { duration: '30s', target: 20 },   // Ramp up to 20 users
+    { duration: '1m', target: 20 },    // Stay at 20 users
+    { duration: '30s', target: 50 },   // Ramp up to 50 users
+    { duration: '1m', target: 50 },    // Stay at 50 users
+    { duration: '30s', target: 0 },    // Ramp down
+  ],
+  thresholds: {
+    http_req_duration: ['p(95)<200', 'p(99)<500'],
+    http_req_failed: ['rate<0.01'],
+  },
+};
+
+const BASE_URL = __ENV.BASE_URL || 'http://host.docker.internal:3000';
+
+export default function () {
+  // Test homepage
+  let res = http.get(`${BASE_URL}/`);
+  check(res, {
+    'homepage status 200': (r) => r.status === 200,
+    'homepage response time < 200ms': (r) => r.timings.duration < 200,
+  });
+
+  sleep(1);
+
+  // Test API endpoint
+  res = http.get(`${BASE_URL}/api/users`);
+  check(res, {
+    'users API status 200': (r) => r.status === 200,
+    'users response time < 200ms': (r) => r.timings.duration < 200,
+  });
+
+  sleep(1);
+
+  // Test POST endpoint
+  res = http.post(`${BASE_URL}/api/contact`, JSON.stringify({
+    name: 'Test User',
+    email: 'test@example.com',
+    message: 'Test message',
+  }), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  check(res, {
+    'contact API status 200': (r) => r.status === 200,
+  });
+
+  sleep(1);
+}