@oalacea/daemon 0.7.1 → 0.7.3

package/dist/templates/rust/integration.test.rs

@@ -0,0 +1,63 @@
+// Integration tests typically live in the `tests/` directory
+// Each file in tests/ is compiled as a separate crate
+
+use my_project::add;
+
+#[test]
+fn integration_test_add() {
+    // Test the public API of your library
+    let result = add(2, 3);
+    assert_eq!(result, 5);
+}
+
+#[test]
+fn integration_test_add_negative_numbers() {
+    let result = add(-2, -3);
+    assert_eq!(result, -5);
+}
+
+#[test]
+#[should_panic(expected = "overflow")]
+fn integration_test_add_overflow() {
+    // This test should panic
+    let _ = add(i32::MAX, 1);
+}
+
+/// Test API endpoint behavior
+#[tokio::test]
+async fn test_api_endpoint() {
+    // TODO: Set up test server
+    // let app = create_test_app().await;
+    // let response = app
+    //     .oneshot(Request::builder()
+    //         .uri("/api/test")
+    //         .body(Body::empty())
+    //         .unwrap())
+    //     .await
+    //     .unwrap();
+    // assert_eq!(response.status(), StatusCode::OK);
+}
+
+/// Test database operations
+#[tokio::test]
+async fn test_database_operation() {
+    // TODO: Set up test database
+    // let pool = create_test_pool().await;
+    // let result = sqlx::query("SELECT * FROM users WHERE id = $1")
+    //     .bind(1)
+    //     .fetch_one(&pool)
+    //     .await;
+    // assert!(result.is_ok());
+}
+
+/// Helper to create test application
+async fn create_test_app() -> Router {
+    // TODO: Initialize app with test configuration
+    Router::new()
+}
+
+/// Helper to create test database pool
+async fn create_test_pool() -> SqlitePool {
+    // TODO: Create in-memory database for testing
+    SqlitePool::connect(":memory:").await.unwrap()
+}

package/dist/templates/rust/rocket-route.test.rs

@@ -0,0 +1,106 @@
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rocket::http::{Header, ContentType, Status};
+    use rocket::local::blocking::Client;
+    use rocket::serde::json::Json;
+
+    /// Helper function to create test client
+    fn create_client() -> Client {
+        // TODO: Configure Rocket for testing
+        // Client::tracked(rocket().build().unwrap()).unwrap()
+        unimplemented!()
+    }
+
+    /// Test health check endpoint
+    #[test]
+    fn test_health_check() {
+        let client = create_client();
+        let response = client.get("/health").dispatch();
+
+        assert_eq!(response.status(), Status::Ok);
+    }
+
+    /// Test GET /api/users returns 200
+    #[test]
+    fn test_get_users_returns_200() {
+        let client = create_client();
+        let response = client.get("/api/users").dispatch();
+
+        assert_eq!(response.status(), Status::Ok);
+
+        // Optionally check response body
+        let body = response.into_string().unwrap();
+        assert!(!body.is_empty());
+    }
+
+    /// Test GET /api/users with authentication
+    #[test]
+    fn test_get_users_with_authentication() {
+        let client = create_client();
+        let token = "valid_token";
+
+        let response = client
+            .get("/api/users")
+            .add_header(Header::new("Authorization", format!("Bearer {}", token)))
+            .dispatch();
+
+        assert_eq!(response.status(), Status::Ok);
+    }
+
+    /// Test POST /api/users with valid data returns 201
+    #[test]
+    fn test_create_user_with_valid_data_returns_201() {
+        let client = create_client();
+        let body = serde_json::json!({
+            "name": "Test User",
+            "email": "test@example.com"
+        });
+
+        let response = client
+            .post("/api/users")
+            .header(ContentType::JSON)
+            .body(body.to_string())
+            .dispatch();
+
+        assert_eq!(response.status(), Status::Created);
+    }
+
+    /// Test POST /api/users with invalid data returns 400
+    #[test]
+    fn test_create_user_with_invalid_data_returns_400() {
+        let client = create_client();
+        let body = serde_json::json!({
+            "name": ""
+        });
+
+        let response = client
+            .post("/api/users")
+            .header(ContentType::JSON)
+            .body(body.to_string())
+            .dispatch();
+
+        assert_eq!(response.status(), Status::BadRequest);
+    }
+
+    /// TODO: Implement route handlers
+    #[get("/health")]
+    fn health_check() -> &'static str {
+        "OK"
+    }
+
+    #[get("/api/users")]
+    fn get_users() -> Json<serde_json::Value> {
+        Json(serde_json::json!([]))
+    }
+
+    #[post("/api/users", format = "json", data = "<user>")]
+    fn create_user(user: Json<serde_json::Value>) -> Status {
+        Status::Created
+    }
+
+    fn rocket() -> rocket::Rocket<rocket::Build> {
+        rocket::build()
+            .mount("/", routes![health_check, get_users, create_user])
+    }
+}

package/dist/templates/rust/unit.test.rs

@@ -0,0 +1,38 @@
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Test that a function returns expected value
+    #[test]
+    fn test_function_returns_expected() {
+        let input = "test";
+        let result = process(input);
+        assert_eq!(result, "expected");
+    }
+
+    /// Test that a function handles empty input
+    #[test]
+    fn test_function_handles_empty_input() {
+        let input = "";
+        let result = process(input);
+        assert!(result.is_empty());
+    }
+
+    /// Test that a function handles error cases
+    #[test]
+    fn test_function_handles_errors() {
+        let input = "invalid";
+        let result = process(input);
+        assert!(result.is_err());
+    }
+
+    /// Helper function to create test fixtures
+    fn setup_test_fixture() -> String {
+        String::from("fixture")
+    }
+
+    /// TODO: Replace with actual function under test
+    fn process(input: &str) -> Result<String, Box<dyn std::error::Error>> {
+        Ok(input.to_uppercase())
+    }
+}

package/dist/templates/vitest/angular-component.test.ts

@@ -0,0 +1,38 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { describe, it, expect } from 'vitest';
+
+// TODO: Import your component
+// import { ComponentName } from '@/components/component-name.component';
+
+describe('ComponentName', () => {
+  let component: ComponentFixture<any>;
+
+  beforeEach(async () => {
+    // TODO: Configure TestBed
+    // await TestBed.configureTestingModule({
+    //   imports: [ComponentName],
+    // }).compileComponents();
+
+    // component = TestBed.createComponent(ComponentName);
+    // component.detectChanges();
+  });
+
+  it('should create', () => {
+    // TODO: Test component creation
+    // expect(component.componentInstance).toBeTruthy();
+  });
+
+  it('should render title', () => {
+    // TODO: Test rendered content
+    // const compiled = component.nativeElement as HTMLElement;
+    // expect(compiled.querySelector('h1')?.textContent).toContain('Test');
+  });
+
+  it('should handle user interaction', () => {
+    // TODO: Test events
+    // const button = component.nativeElement.querySelector('button');
+    // button.click();
+    // component.detectChanges();
+    // expect(component.instance.value).toBe('updated');
+  });
+});

package/dist/templates/vitest/api.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { POST, GET, PATCH, DELETE } from '@/app/api/route';
+
+// TODO: Import database setup if needed
+// import { db } from '@test/db';
+
+describe('API Endpoint', () => {
+  beforeEach(async () => {
+    // TODO: Setup test database
+    // await db.begin();
+  });
+
+  afterEach(async () => {
+    // TODO: Cleanup test database
+    // await db.rollback();
+  });
+
+  it('should return 200 for GET request', async () => {
+    const request = new Request('http://localhost:3000/api/endpoint', {
+      method: 'GET',
+    });
+
+    const response = await GET(request);
+    expect(response.status).toBe(200);
+  });
+
+  it('should create resource with POST', async () => {
+    const request = new Request('http://localhost:3000/api/endpoint', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Test' }),
+    });
+
+    const response = await POST(request);
+    expect(response.status).toBe(201);
+
+    const data = await response.json();
+    expect(data).toHaveProperty('id');
+  });
+
+  it('should validate input data', async () => {
+    const request = new Request('http://localhost:3000/api/endpoint', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ invalid: 'data' }),
+    });
+
+    const response = await POST(request);
+    expect(response.status).toBe(400);
+  });
+});

package/dist/templates/vitest/component.test.ts

@@ -0,0 +1,27 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+import userEvent from '@testing-library/user-event';
+
+// TODO: Import your component
+// import { ComponentName } from '@/components/ComponentName';
+
+describe('ComponentName', () => {
+  it('should render', () => {
+    // TODO: Add component render
+    // render(<ComponentName />);
+    // expect(screen.getByRole('button')).toBeInTheDocument();
+  });
+
+  it('should render with children', () => {
+    // TODO: Test children rendering
+    // render(<ComponentName>Test content</ComponentName>);
+    // expect(screen.getByText('Test content')).toBeInTheDocument();
+  });
+
+  it('should handle user interaction', async () => {
+    // TODO: Test click/hover/etc
+    // const user = userEvent.setup();
+    // render(<ComponentName onClick={vi.fn()} />);
+    // await user.click(screen.getByRole('button'));
+  });
+});

package/dist/templates/vitest/hook.test.ts

@@ -0,0 +1,36 @@
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// TODO: Import your hook
+// import { useHookName } from '@/hooks/useHookName';
+
+describe('useHookName', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return initial state', () => {
+    // TODO: Test initial state
+    // const { result } = renderHook(() => useHookName());
+    // expect(result.current).toBeDefined();
+  });
+
+  it('should update state', async () => {
+    // TODO: Test state updates
+    // const { result } = renderHook(() => useHookName());
+    // act(() => {
+    //   result.current.setValue('test');
+    // });
+    // await waitFor(() => {
+    //   expect(result.current.value).toBe('test');
+    // });
+  });
+
+  it('should cleanup on unmount', () => {
+    // TODO: Test cleanup
+    // const { unmount } = renderHook(() => useHookName());
+    // const cleanup = vi.fn();
+    // unmount();
+    // expect(cleanup).toHaveBeenCalled();
+  });
+});

package/dist/templates/vitest/solid-component.test.ts

@@ -0,0 +1,34 @@
+import { render, screen } from '@solidjs/testing-library';
+import { describe, it, expect, vi } from 'vitest';
+
+// TODO: Import your component
+// import ComponentName from '@/components/ComponentName';
+
+describe('ComponentName', () => {
+  it('should render', () => {
+    // TODO: Add component render
+    // render(() => <ComponentName />);
+    // expect(screen.getByRole('button')).toBeInTheDocument();
+  });
+
+  it('should render with props', () => {
+    // TODO: Test props
+    // render(() => <ComponentName title="Test Title" />);
+    // expect(screen.getByText('Test Title')).toBeInTheDocument();
+  });
+
+  it('should handle user interaction', async () => {
+    // TODO: Test events
+    // const handleClick = vi.fn();
+    // render(() => <ComponentName onClick={handleClick} />);
+    // const button = screen.getByRole('button');
+    // button.click();
+    // expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('should update with reactive state', () => {
+    // TODO: Test reactivity
+    // const { container } = render(() => <ComponentName count={5} />);
+    // expect(container.textContent).toContain('5');
+  });
+});

package/dist/templates/vitest/svelte-component.test.ts

@@ -0,0 +1,33 @@
+import { render, screen } from '@testing-library/svelte';
+import { describe, it, expect, vi } from 'vitest';
+
+// TODO: Import your component
+// import ComponentName from '@/components/ComponentName.svelte';
+
+describe('ComponentName', () => {
+  it('should render', () => {
+    // TODO: Add component render
+    // render(ComponentName);
+    // expect(container).toBeTruthy();
+  });
+
+  it('should render with props', () => {
+    // TODO: Test props
+    // const { container } = render(ComponentName, { props: { title: 'Test Title' } });
+    // expect(container.textContent).toContain('Test Title');
+  });
+
+  it('should handle user interaction', async () => {
+    // TODO: Test events
+    // const { container, component } = render(ComponentName);
+    // const button = container.querySelector('button');
+    // button.click();
+    // expect(component.$$).toBeDefined();
+  });
+
+  it('should update when props change', async () => {
+    // TODO: Test reactivity
+    // const { container } = render(ComponentName, { props: { count: 0 } });
+    // // Update props and check reactivity
+  });
+});

package/dist/templates/vitest/vue-component.test.ts

@@ -0,0 +1,39 @@
+import { mount } from '@vue/test-utils';
+import { describe, it, expect, vi } from 'vitest';
+
+// TODO: Import your component
+// import ComponentName from '@/components/ComponentName.vue';
+
+describe('ComponentName', () => {
+  it('should render', () => {
+    // TODO: Add component render
+    // const wrapper = mount(ComponentName);
+    // expect(wrapper.exists()).toBe(true);
+  });
+
+  it('should render with props', () => {
+    // TODO: Test props
+    // const wrapper = mount(ComponentName, {
+    //   props: { title: 'Test Title' }
+    // });
+    // expect(wrapper.text()).toContain('Test Title');
+  });
+
+  it('should handle user interaction', async () => {
+    // TODO: Test events
+    // const wrapper = mount(ComponentName, {
+    //   props: { onClick: vi.fn() }
+    // });
+    // await wrapper.find('button').trigger('click');
+    // expect(wrapper.emitted('click')).toBeTruthy();
+  });
+
+  it('should update when props change', async () => {
+    // TODO: Test reactivity
+    // const wrapper = mount(ComponentName, {
+    //   props: { count: 0 }
+    // });
+    // await wrapper.setProps({ count: 5 });
+    // expect(wrapper.text()).toContain('5');
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oalacea/daemon",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "AI-powered code quality analysis, scoring, and optimization for web applications",
   "author": "Yanis",
   "license": "MIT",
@@ -13,7 +13,7 @@
     "daemon": "./dist/cli/index.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node -e \"const fs=require('fs');fs.cpSync('prompts','dist/prompts',{recursive:true});fs.cpSync('templates','dist/templates',{recursive:true});\"",
     "dev": "tsx src/cli/index.ts",
     "test": "vitest",
     "test:run": "node --experimental-strip-types dist/cli/index.js",