@oalacea/daemon 0.7.1 → 0.7.3

package/dist/templates/nestjs/service.spec.ts

@@ -0,0 +1,296 @@
+/**
+ * NestJS Service Test Template
+ *
+ * Tests for NestJS services following best practices:
+ * - Business logic coverage
+ * - Repository/database mocking
+ * - Error handling
+ * - Edge cases
+ *
+ * @package test
+ */
+
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Test, TestingModule } from '@nestjs/testing';
+import { Repository } from 'typeorm';
+import { GameService } from './game.service';
+import { Game } from './entities/game.entity';
+import { CreateGameDto, UpdateGameDto } from './dto';
+import { NotFoundException, ConflictException } from '@nestjs/common';
+
+describe('GameService', () => {
+  let service: GameService;
+  let repository: Repository<Game>;
+
+  // Mock repository
+  const mockRepository = {
+    find: jest.fn(),
+    findOne: jest.fn(),
+    create: jest.fn(),
+    save: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn(),
+    findOneBy: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        GameService,
+        {
+          provide: getRepositoryToken(Game),
+          useValue: mockRepository,
+        },
+      ],
+    }).compile();
+
+    service = module.get<GameService>(GameService);
+    repository = module.get<Repository<Game>>(getRepositoryToken(Game));
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('findAll', () => {
+    it('should return an array of games', async () => {
+      const expectedGames = [
+        { id: '1', name: 'Game 1', active: true },
+        { id: '2', name: 'Game 2', active: true },
+      ];
+
+      mockRepository.find.mockResolvedValue(expectedGames);
+
+      const result = await service.findAll();
+
+      expect(result).toEqual(expectedGames);
+      expect(repository.find).toHaveBeenCalledTimes(1);
+      expect(repository.find).toHaveBeenCalledWith();
+    });
+
+    it('should support filtering options', async () => {
+      const expectedGames = [{ id: '1', name: 'Game 1', active: true }];
+      const options = { where: { active: true } };
+
+      mockRepository.find.mockResolvedValue(expectedGames);
+
+      const result = await service.findAll(options);
+
+      expect(result).toEqual(expectedGames);
+      expect(repository.find).toHaveBeenCalledWith(options);
+    });
+
+    it('should handle empty results', async () => {
+      mockRepository.find.mockResolvedValue([]);
+
+      const result = await service.findAll();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle database errors', async () => {
+      mockRepository.find.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.findAll()).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('findOne', () => {
+    it('should return a single game by id', async () => {
+      const expectedGame = { id: '1', name: 'Game 1', active: true };
+
+      mockRepository.findOneBy.mockResolvedValue(expectedGame);
+
+      const result = await service.findOne('1');
+
+      expect(result).toEqual(expectedGame);
+      expect(repository.findOneBy).toHaveBeenCalledWith({ id: '1' });
+    });
+
+    it('should throw NotFoundException when game not found', async () => {
+      mockRepository.findOneBy.mockResolvedValue(null);
+
+      await expect(service.findOne('999')).rejects.toThrow(NotFoundException);
+      await expect(service.findOne('999')).rejects.toThrow('Game not found');
+    });
+
+    it('should handle database errors', async () => {
+      mockRepository.findOneBy.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.findOne('1')).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('create', () => {
+    const createGameDto: CreateGameDto = {
+      name: 'New Game',
+      type: 'action',
+    };
+
+    it('should create a new game', async () => {
+      const savedGame = { id: '1', ...createGameDto };
+
+      mockRepository.create.mockReturnValue(savedGame);
+      mockRepository.save.mockResolvedValue(savedGame);
+
+      const result = await service.create(createGameDto);
+
+      expect(result).toEqual(savedGame);
+      expect(repository.create).toHaveBeenCalledWith(createGameDto);
+      expect(repository.save).toHaveBeenCalledWith(savedGame);
+    });
+
+    it('should handle unique constraint violations', async () => {
+      const duplicateError = { code: '23505' }; // PostgreSQL unique violation
+
+      mockRepository.create.mockReturnValue(createGameDto);
+      mockRepository.save.mockRejectedValue(duplicateError);
+
+      await expect(service.create(createGameDto)).rejects.toThrow(
+        ConflictException
+      );
+    });
+
+    it('should validate DTO before creation', async () => {
+      const invalidDto = { name: '' }; // Invalid DTO
+
+      mockRepository.create.mockReturnValue(invalidDto);
+      mockRepository.save.mockResolvedValue(invalidDto);
+
+      // Validation should happen before repository call
+      // This test assumes class-validator is used
+      const result = await service.create(invalidDto as any);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('update', () => {
+    const updateGameDto: UpdateGameDto = {
+      name: 'Updated Game',
+    };
+
+    it('should update an existing game', async () => {
+      const existingGame = { id: '1', name: 'Old Name', active: true };
+      const updatedGame = { ...existingGame, ...updateGameDto };
+
+      mockRepository.findOneBy.mockResolvedValue(existingGame);
+      mockRepository.save.mockResolvedValue(updatedGame);
+
+      const result = await service.update('1', updateGameDto);
+
+      expect(result).toEqual(updatedGame);
+      expect(repository.findOneBy).toHaveBeenCalledWith({ id: '1' });
+      expect(repository.save).toHaveBeenCalledWith(updatedGame);
+    });
+
+    it('should throw NotFoundException when updating non-existent game', async () => {
+      mockRepository.findOneBy.mockResolvedValue(null);
+
+      await expect(service.update('999', updateGameDto)).rejects.toThrow(
+        NotFoundException
+      );
+    });
+
+    it('should handle partial updates', async () => {
+      const existingGame = {
+        id: '1',
+        name: 'Game Name',
+        type: 'action',
+        active: true,
+      };
+      const partialDto: UpdateGameDto = { name: 'New Name' };
+
+      mockRepository.findOneBy.mockResolvedValue(existingGame);
+      mockRepository.save.mockResolvedValue({
+        ...existingGame,
+        ...partialDto,
+      });
+
+      const result = await service.update('1', partialDto);
+
+      expect(result.name).toBe('New Name');
+      expect(result.type).toBe('action'); // Unchanged
+    });
+  });
+
+  describe('remove', () => {
+    it('should delete a game', async () => {
+      const existingGame = { id: '1', name: 'Game 1', active: true };
+
+      mockRepository.findOneBy.mockResolvedValue(existingGame);
+      mockRepository.delete.mockResolvedValue({ affected: 1 });
+
+      await service.remove('1');
+
+      expect(repository.findOneBy).toHaveBeenCalledWith({ id: '1' });
+      expect(repository.delete).toHaveBeenCalledWith('1');
+    });
+
+    it('should throw NotFoundException when deleting non-existent game', async () => {
+      mockRepository.findOneBy.mockResolvedValue(null);
+
+      await expect(service.remove('999')).rejects.toThrow(NotFoundException);
+    });
+
+    it('should handle delete with no affected rows', async () => {
+      const existingGame = { id: '1', name: 'Game 1', active: true };
+
+      mockRepository.findOneBy.mockResolvedValue(existingGame);
+      mockRepository.delete.mockResolvedValue({ affected: 0 });
+
+      await service.remove('1');
+
+      // Should not throw even if no rows affected
+      expect(repository.delete).toHaveBeenCalledWith('1');
+    });
+  });
+
+  describe('business logic', () => {
+    it('should calculate derived properties correctly', async () => {
+      const games = [
+        { id: '1', name: 'Game 1', score: 100 },
+        { id: '2', name: 'Game 2', score: 200 },
+      ];
+
+      mockRepository.find.mockResolvedValue(games);
+
+      const result = await service.getHighScoreGames();
+
+      expect(result).toBeDefined();
+    });
+
+    it('should enforce business rules', async () => {
+      const createGameDto: CreateGameDto = {
+        name: 'Game with invalid business rule',
+        type: 'invalid',
+      };
+
+      // Business rule validation
+      mockRepository.create.mockReturnValue(createGameDto);
+      mockRepository.save.mockResolvedValue(createGameDto);
+
+      const result = await service.create(createGameDto);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('transactions', () => {
+    it('should handle operations requiring transactions', async () => {
+      // For complex operations requiring multiple updates
+      mockRepository.findOneBy.mockResolvedValue({ id: '1', name: 'Game' });
+      mockRepository.save.mockResolvedValue({ id: '1', name: 'Updated' });
+
+      const result = await service.complexUpdate('1', {
+        name: 'Updated',
+      });
+
+      expect(result).toBeDefined();
+    });
+  });
+});

package/dist/templates/playwright/e2e.spec.ts

@@ -0,0 +1,61 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('Authentication Flow', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/login');
+  });
+
+  test('should login with valid credentials', async ({ page }) => {
+    await page.fill('input[name="email"]', 'test@example.com');
+    await page.fill('input[name="password"]', 'password123');
+    await page.click('button[type="submit"]');
+
+    // Should redirect to dashboard
+    await expect(page).toHaveURL(/\/dashboard/);
+    await expect(page.locator('h1')).toContainText('Dashboard');
+  });
+
+  test('should show error with invalid credentials', async ({ page }) => {
+    await page.fill('input[name="email"]', 'test@example.com');
+    await page.fill('input[name="password"]', 'wrong-password');
+    await page.click('button[type="submit"]');
+
+    await expect(page.locator('.error')).toContainText('Invalid credentials');
+    await expect(page).toHaveURL('/login');
+  });
+});
+
+test.describe('Navigation', () => {
+  test('should navigate between pages', async ({ page }) => {
+    await page.goto('/');
+
+    await page.click('text=About');
+    await expect(page).toHaveURL('/about');
+
+    await page.goBack();
+    await expect(page).toHaveURL('/');
+
+    await page.goForward();
+    await expect(page).toHaveURL('/about');
+  });
+});
+
+test.describe('Form Interaction', () => {
+  test('should submit form successfully', async ({ page }) => {
+    await page.goto('/form');
+
+    await page.fill('input[name="name"]', 'Test User');
+    await page.fill('input[name="email"]', 'test@example.com');
+    await page.click('button[type="submit"]');
+
+    await expect(page.locator('.success')).toContainText('Form submitted');
+  });
+
+  test('should show validation errors', async ({ page }) => {
+    await page.goto('/form');
+    await page.click('button[type="submit"]');
+
+    await expect(page.locator('input[name="name"]')).toHaveAttribute('aria-invalid', 'true');
+    await expect(page.locator('input[name="email"]')).toHaveAttribute('aria-invalid', 'true');
+  });
+});

package/dist/templates/rust/Cargo.toml

@@ -0,0 +1,72 @@
+[package]
+name = "my-project"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+# Web frameworks (uncomment the one you're using)
+# axum = "0.7"
+# actix-web = "4.9"
+# rocket = "0.5"
+
+# Async runtime
+tokio = { version = "1.40", features = ["full"] }
+
+# Serialization
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# Database (uncomment as needed)
+# sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres", "sqlite", "mysql"] }
+# diesel = { version = "2.2", features = ["postgres", "sqlite"] }
+
+# HTTP client (if needed)
+# reqwest = { version = "0.12", features = ["json"] }
+
+# Environment variables
+# dotenv = "0.15"
+
+# Logging
+# tracing = "0.1"
+# tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+# Error handling
+# anyhow = "1.0"
+# thiserror = "1.0"
+
+[dev-dependencies]
+# Testing utilities
+tokio-test = "0.4"
+
+# HTTP testing for Axum
+# axum-test = "16.0"
+
+# HTTP testing for Actix
+# actix-rt = "2.10"
+
+# Database testing
+# sqlx-cli = "0.8"
+
+# Mocking
+# mockall = "0.13"
+
+[features]
+# Default features
+default = []
+
+# Test features
+test-utils = []
+
+[profile.dev]
+# Optimize dependencies in dev mode for faster compilation
+opt-level = 0
+
+[profile.release]
+# Optimize for size
+opt-level = "z"
+lto = true
+codegen-units = 1
+
+[profile.test]
+# Optimize tests for speed
+opt-level = 3

package/dist/templates/rust/actix-controller.test.rs

@@ -0,0 +1,114 @@
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_web::{
+        body::MessageBody,
+        dev::{Service, ServiceResponse},
+        http::{header, StatusCode},
+        test, web, App,
+    };
+
+    /// Helper function to create test app
+    async fn create_app() -> App<
+        impl Service<
+            actix_web::dev::ServiceRequest,
+            Response = ServiceResponse<impl MessageBody>,
+            Error = actix_web::Error,
+        >,
+    > {
+        test::init_service(
+            App::new()
+                .route("/health", web::get().to(health_check))
+                .route("/api/users", web::get().to(get_users).post(create_user)),
+        )
+        .await
+    }
+
+    /// Test health check endpoint
+    #[actix_web::test]
+    async fn test_health_check() {
+        let app = create_app().await;
+        let req = test::TestRequest::get().uri("/health").to_request();
+
+        let resp = test::call_service(&app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
+    /// Test GET /api/users returns 200
+    #[actix_web::test]
+    async fn test_get_users_returns_200() {
+        let app = create_app().await;
+        let req = test::TestRequest::get()
+            .uri("/api/users")
+            .to_request();
+
+        let resp = test::call_service(&app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        // Optionally check response body
+        let body = test::read_body(resp).await;
+        assert!(!body.is_empty());
+    }
+
+    /// Test GET /api/users with pagination
+    #[actix_web::test]
+    async fn test_get_users_with_pagination() {
+        let app = create_app().await;
+        let req = test::TestRequest::get()
+            .uri("/api/users?page=1&limit=10")
+            .to_request();
+
+        let resp = test::call_service(&app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
+    /// Test POST /api/users with valid data returns 201
+    #[actix_web::test]
+    async fn test_create_user_with_valid_data_returns_201() {
+        let app = create_app().await;
+        let payload = serde_json::json!({
+            "name": "Test User",
+            "email": "test@example.com"
+        });
+
+        let req = test::TestRequest::post()
+            .uri("/api/users")
+            .insert_header((header::CONTENT_TYPE, "application/json"))
+            .set_json(&payload)
+            .to_request();
+
+        let resp = test::call_service(&app, req).await;
+        assert_eq!(resp.status(), StatusCode::CREATED);
+    }
+
+    /// Test POST /api/users with invalid data returns 400
+    #[actix_web::test]
+    async fn test_create_user_with_invalid_data_returns_400() {
+        let app = create_app().await;
+        let payload = serde_json::json!({
+            "name": ""
+        });
+
+        let req = test::TestRequest::post()
+            .uri("/api/users")
+            .insert_header((header::CONTENT_TYPE, "application/json"))
+            .set_json(&payload)
+            .to_request();
+
+        let resp = test::call_service(&app, req).await;
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+
+    /// TODO: Implement handler functions
+    async fn health_check() -> &'static str {
+        "OK"
+    }
+
+    async fn get_users() -> &'static str {
+        "[]"
+    }
+
+    async fn create_user() -> &'static str {
+        "Created"
+    }
+}

package/dist/templates/rust/axum-handler.test.rs

@@ -0,0 +1,117 @@
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::{
+        body::Body,
+        http::{Method, Request, StatusCode},
+    };
+    use tower::ServiceExt;
+
+    /// Helper function to create test app
+    async fn create_app() -> Router {
+        Router::new()
+            .route("/health", get(health_check))
+            .route("/api/users", get(get_users).post(create_user))
+    }
+
+    /// Test health check endpoint
+    #[tokio::test]
+    async fn test_health_check() {
+        let app = create_app().await;
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .uri("/health")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+    }
+
+    /// Test GET /api/users returns 200
+    #[tokio::test]
+    async fn test_get_users_returns_200() {
+        let app = create_app().await;
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .method(Method::GET)
+                    .uri("/api/users")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+    }
+
+    /// Test POST /api/users with valid data returns 201
+    #[tokio::test]
+    async fn test_create_user_with_valid_data_returns_201() {
+        let app = create_app().await;
+
+        let body = serde_json::json!({
+            "name": "Test User",
+            "email": "test@example.com"
+        });
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .method(Method::POST)
+                    .uri("/api/users")
+                    .header("content-type", "application/json")
+                    .body(Body::from(body.to_string()))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::CREATED);
+    }
+
+    /// Test POST /api/users with invalid data returns 400
+    #[tokio::test]
+    async fn test_create_user_with_invalid_data_returns_400() {
+        let app = create_app().await;
+
+        let body = serde_json::json!({
+            "name": ""
+        });
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .method(Method::POST)
+                    .uri("/api/users")
+                    .header("content-type", "application/json")
+                    .body(Body::from(body.to_string()))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    }
+
+    /// TODO: Implement handler functions
+    async fn health_check() -> StatusCode {
+        StatusCode::OK
+    }
+
+    async fn get_users() -> StatusCode {
+        StatusCode::OK
+    }
+
+    async fn create_user() -> StatusCode {
+        StatusCode::CREATED
+    }
+
+    use axum::{routing::{get, post}, Router};
+}