javi-forge 0.1.0

package/ai-config/skills/testing/playwright-e2e/SKILL.md

@@ -0,0 +1,289 @@
+---
+name: playwright-e2e
+description: >
+  End-to-end testing with Playwright for web applications using Page Object Model and authentication fixtures.
+  Trigger: e2e testing, playwright, browser testing, visual regression, integration tests
+tools:
+  - Read
+  - Write
+  - Bash
+  - Grep
+metadata:
+  author: plataforma-industrial
+  version: "2.0"
+  tags: [testing, e2e, playwright, automation]
+  updated: "2026-02"
+---
+
+# Playwright E2E Testing
+
+## Configuration
+
+```typescript
+// playwright.config.ts
+import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: [
+    ['html', { outputFolder: 'playwright-report' }],
+    ['junit', { outputFile: 'results.xml' }],
+  ],
+  use: {
+    baseURL: process.env.BASE_URL || 'http://localhost:4321',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+  },
+  projects: [
+    { name: 'setup', testMatch: /.*\.setup\.ts/ },
+    { name: 'chromium', use: { ...devices['Desktop Chrome'] }, dependencies: ['setup'] },
+    { name: 'firefox', use: { ...devices['Desktop Firefox'] }, dependencies: ['setup'] },
+    { name: 'Mobile Chrome', use: { ...devices['Pixel 5'] }, dependencies: ['setup'] },
+  ],
+  webServer: {
+    command: 'npm run preview',
+    url: 'http://localhost:4321',
+    reuseExistingServer: !process.env.CI,
+    timeout: 120000,
+  },
+});
+```
+
+## Project Structure
+
+```
+e2e/
+├── auth.setup.ts           # Authentication setup
+├── fixtures/
+│   ├── auth.fixture.ts     # Auth fixture
+│   └── api.fixture.ts      # API fixture
+├── pages/
+│   ├── BasePage.ts         # Base POM
+│   ├── LoginPage.ts        # Login POM
+│   └── DashboardPage.ts    # Dashboard POM
+├── tests/
+│   ├── auth.spec.ts        # Auth tests
+│   └── dashboard.spec.ts   # Feature tests
+└── utils/
+    ├── test-data.ts        # Test data factories
+    └── helpers.ts          # Helper functions
+```
+
+## Authentication Setup
+
+```typescript
+// e2e/auth.setup.ts
+import { test as setup, expect } from '@playwright/test';
+
+const authFile = 'playwright/.auth/user.json';
+
+setup('authenticate', async ({ page }) => {
+  await page.goto('/login');
+  await page.getByLabel('Email').fill('user@example.com');
+  await page.getByLabel('Password').fill('password');
+  await page.getByRole('button', { name: 'Sign in' }).click();
+  await page.waitForURL('/dashboard');
+  await page.context().storageState({ path: authFile });
+});
+```
+
+## Page Object Model
+
+```typescript
+// e2e/pages/BasePage.ts
+import { Page, Locator, expect } from '@playwright/test';
+
+export abstract class BasePage {
+  protected page: Page;
+
+  constructor(page: Page) {
+    this.page = page;
+  }
+
+  get navbar(): Locator {
+    return this.page.getByRole('navigation');
+  }
+
+  async logout(): Promise<void> {
+    await this.page.getByTestId('user-menu').click();
+    await this.page.getByRole('menuitem', { name: 'Logout' }).click();
+  }
+
+  async expectToast(message: string): Promise<void> {
+    await expect(this.page.getByRole('alert').filter({ hasText: message })).toBeVisible();
+  }
+
+  async waitForLoader(): Promise<void> {
+    const loader = this.page.getByTestId('loader');
+    if (await loader.isVisible()) {
+      await loader.waitFor({ state: 'hidden' });
+    }
+  }
+}
+
+// e2e/pages/LoginPage.ts
+export class LoginPage extends BasePage {
+  readonly emailInput: Locator;
+  readonly passwordInput: Locator;
+  readonly submitButton: Locator;
+
+  constructor(page: Page) {
+    super(page);
+    this.emailInput = page.getByLabel('Email');
+    this.passwordInput = page.getByLabel('Password');
+    this.submitButton = page.getByRole('button', { name: 'Sign in' });
+  }
+
+  async goto(): Promise<void> {
+    await this.page.goto('/login');
+  }
+
+  async login(email: string, password: string): Promise<void> {
+    await this.emailInput.fill(email);
+    await this.passwordInput.fill(password);
+    await this.submitButton.click();
+  }
+}
+```
+
+## Test Examples
+
+```typescript
+// e2e/tests/auth.spec.ts
+import { test, expect } from '@playwright/test';
+import { LoginPage } from '../pages/LoginPage';
+
+test.describe('Authentication', () => {
+  test('successful login redirects to dashboard', async ({ page }) => {
+    const loginPage = new LoginPage(page);
+    await loginPage.goto();
+    await loginPage.login('user@example.com', 'password');
+    await expect(page).toHaveURL('/dashboard');
+  });
+
+  test('invalid credentials show error', async ({ page }) => {
+    const loginPage = new LoginPage(page);
+    await loginPage.goto();
+    await loginPage.login('wrong@email.com', 'wrongpassword');
+    await expect(page.getByRole('alert')).toContainText('Invalid');
+  });
+});
+
+// Using stored auth state
+test.describe('Dashboard', () => {
+  test.use({ storageState: 'playwright/.auth/user.json' });
+
+  test('displays data', async ({ page }) => {
+    await page.goto('/dashboard');
+    await expect(page.getByTestId('sensor-grid')).toBeVisible();
+  });
+});
+```
+
+## API Testing
+
+```typescript
+// e2e/fixtures/api.fixture.ts
+import { test as base, APIRequestContext } from '@playwright/test';
+
+export const test = base.extend<{ api: APIRequestContext }>({
+  api: async ({ playwright }, use) => {
+    const context = await playwright.request.newContext({
+      baseURL: process.env.API_URL || 'http://localhost:8080',
+      extraHTTPHeaders: {
+        'Authorization': `Bearer ${process.env.TEST_API_TOKEN}`,
+      },
+    });
+    await use(context);
+    await context.dispose();
+  },
+});
+
+// API test example
+test('GET /api/v1/items returns list', async ({ api }) => {
+  const response = await api.get('/api/v1/items');
+  expect(response.ok()).toBeTruthy();
+  const data = await response.json();
+  expect(Array.isArray(data.data)).toBe(true);
+});
+```
+
+## Visual Regression
+
+```typescript
+test('dashboard matches snapshot', async ({ page }) => {
+  await page.goto('/dashboard');
+  await page.waitForLoadState('networkidle');
+  await page.waitForTimeout(500); // Wait for animations
+
+  await expect(page).toHaveScreenshot('dashboard.png', {
+    maxDiffPixels: 100,
+  });
+});
+```
+
+## CI Integration
+
+```yaml
+# .github/workflows/e2e.yml
+name: E2E Tests
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  e2e:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm ci
+      - run: npx playwright install --with-deps
+      - run: npm run build
+      - run: npm run e2e
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: playwright-report
+          path: playwright-report/
+```
+
+## Scripts
+
+```json
+{
+  "scripts": {
+    "e2e": "playwright test",
+    "e2e:ui": "playwright test --ui",
+    "e2e:headed": "playwright test --headed",
+    "e2e:debug": "playwright test --debug",
+    "e2e:report": "playwright show-report",
+    "e2e:codegen": "playwright codegen localhost:4321"
+  }
+}
+```
+
+## Best Practices
+
+1. **Use Page Object Model** - Encapsulate page interactions
+2. **Wait for network idle** - `await page.waitForLoadState('networkidle')`
+3. **Test isolation** - Each test independent, use `beforeEach`
+4. **Prefer role locators** - `getByRole`, `getByLabel`, `getByText`
+5. **Parameterized tests** - Use loops for multiple scenarios
+
+## Related Skills
+
+- `vitest-testing`: Unit/integration tests
+- `frontend-web`: Frontend patterns to test
+- `mobile-ionic`: Mobile app testing
+- `devops-infra`: CI test automation

package/ai-config/skills/testing/testcontainers/SKILL.md

@@ -0,0 +1,299 @@
+---
+name: testcontainers
+description: >
+  Testing con TestContainers en APiGen. PostgreSQL, Redis, integración Spring Boot.
+  Trigger: testcontainers, integration test, PostgreSQL test, container test
+tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+metadata:
+  author: apigen-team
+  version: "1.0"
+  tags: [testing, testcontainers, integration]
+  scope: ["**/src/test/**"]
+---
+
+# TestContainers
+
+## Dependencias
+
+```groovy
+testImplementation 'org.springframework.boot:spring-boot-testcontainers'
+testImplementation 'org.testcontainers:junit-jupiter'
+testImplementation 'org.testcontainers:postgresql'
+testImplementation 'org.testcontainers:rabbitmq'  // si aplica
+```
+
+## @ServiceConnection (Spring Boot 3.1+)
+
+```java
+@SpringBootTest
+@Testcontainers
+class UserRepositoryIT {
+
+    @Container
+    @ServiceConnection
+    static PostgreSQLContainer<?> postgres =
+        new PostgreSQLContainer<>("postgres:16-alpine");
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Test
+    void shouldSaveAndFindUser() {
+        var user = User.builder()
+            .name("Test User")
+            .email("test@example.com")
+            .build();
+
+        var saved = userRepository.save(user);
+
+        assertThat(saved.getId()).isNotNull();
+        assertThat(userRepository.findById(saved.getId()))
+            .isPresent()
+            .hasValueSatisfying(u -> assertThat(u.getName()).isEqualTo("Test User"));
+    }
+}
+```
+
+## Container Singleton (Reusable)
+
+```java
+public abstract class AbstractContainerIT {
+
+    @Container
+    @ServiceConnection
+    protected static final PostgreSQLContainer<?> POSTGRES =
+        new PostgreSQLContainer<>("postgres:16-alpine")
+            .withDatabaseName("testdb")
+            .withUsername("test")
+            .withPassword("test")
+            .withReuse(true);  // Reuse entre tests
+
+    static {
+        POSTGRES.start();
+    }
+}
+
+// Heredar en tests
+@SpringBootTest
+class UserServiceIT extends AbstractContainerIT {
+    // ...
+}
+```
+
+## Multiple Containers
+
+```java
+@SpringBootTest
+@Testcontainers
+class FullStackIT {
+
+    @Container
+    @ServiceConnection
+    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16");
+
+    @Container
+    @ServiceConnection
+    static GenericContainer<?> redis = new GenericContainer<>("redis:7-alpine")
+        .withExposedPorts(6379);
+
+    @DynamicPropertySource
+    static void redisProperties(DynamicPropertyRegistry registry) {
+        registry.add("spring.data.redis.host", redis::getHost);
+        registry.add("spring.data.redis.port", () -> redis.getMappedPort(6379));
+    }
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private RedisTemplate<String, Object> redisTemplate;
+
+    @Test
+    void shouldCacheUserInRedis() {
+        var user = userService.create(new CreateUserDTO("Test", "test@test.com"));
+
+        // First call - from DB
+        userService.findById(user.getId());
+
+        // Second call - from cache
+        var cached = redisTemplate.opsForValue().get("users::" + user.getId());
+        assertThat(cached).isNotNull();
+    }
+}
+```
+
+## Test Profile (application-test.yml)
+
+```yaml
+# src/test/resources/application-test.yml
+spring:
+  jpa:
+    hibernate:
+      ddl-auto: create-drop
+    show-sql: true
+  flyway:
+    enabled: false  # TestContainers crea schema
+
+logging:
+  level:
+    org.hibernate.SQL: DEBUG
+    org.testcontainers: INFO
+```
+
+## Controller Integration Test
+
+```java
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@Testcontainers
+@ActiveProfiles("test")
+class UserControllerIT {
+
+    @Container
+    @ServiceConnection
+    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16");
+
+    @Autowired
+    private TestRestTemplate restTemplate;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @BeforeEach
+    void setUp() {
+        userRepository.deleteAll();
+    }
+
+    @Test
+    void shouldCreateUser() {
+        var request = new CreateUserRequest("John Doe", "john@example.com");
+
+        var response = restTemplate.postForEntity(
+            "/api/users",
+            request,
+            UserDTO.class
+        );
+
+        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+        assertThat(response.getBody()).isNotNull();
+        assertThat(response.getBody().name()).isEqualTo("John Doe");
+    }
+
+    @Test
+    void shouldReturnNotFoundForInvalidId() {
+        var response = restTemplate.getForEntity(
+            "/api/users/{id}",
+            ProblemDetail.class,
+            UUID.randomUUID()
+        );
+
+        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+    }
+}
+```
+
+## WebTestClient (WebFlux style)
+
+```java
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@Testcontainers
+class UserControllerWebClientIT {
+
+    @Container
+    @ServiceConnection
+    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16");
+
+    @Autowired
+    private WebTestClient webClient;
+
+    @Test
+    void shouldListUsers() {
+        webClient.get()
+            .uri("/api/users")
+            .exchange()
+            .expectStatus().isOk()
+            .expectBodyList(UserDTO.class)
+            .hasSize(0);
+    }
+
+    @Test
+    void shouldCreateUser() {
+        webClient.post()
+            .uri("/api/users")
+            .bodyValue(new CreateUserRequest("Test", "test@test.com"))
+            .exchange()
+            .expectStatus().isCreated()
+            .expectBody()
+            .jsonPath("$.id").exists()
+            .jsonPath("$.name").isEqualTo("Test");
+    }
+}
+```
+
+## Compilar Proyecto Generado (apigen-server)
+
+```java
+@SpringBootTest
+@Testcontainers
+@Tag("slow")
+class GeneratedProjectCompilationIT {
+
+    @Container
+    @ServiceConnection
+    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16");
+
+    @Autowired
+    private GenerationService generationService;
+
+    @TempDir
+    Path tempDir;
+
+    @Test
+    @EnabledIfEnvironmentVariable(named = "CI_COMPILE_GENERATED_PROJECT", matches = "true")
+    void generatedJavaProjectShouldCompile() throws Exception {
+        var request = GenerationRequest.builder()
+            .projectName("test-project")
+            .basePackage("com.test")
+            .language("java")
+            .framework("spring-boot")
+            .schema("CREATE TABLE users (id UUID PRIMARY KEY, name VARCHAR(100));")
+            .build();
+
+        byte[] zipBytes = generationService.generate(request);
+
+        // Extract ZIP
+        Path projectDir = extractZip(zipBytes, tempDir);
+
+        // Compile
+        ProcessBuilder pb = new ProcessBuilder("./gradlew", "compileJava", "--no-daemon");
+        pb.directory(projectDir.toFile());
+        pb.inheritIO();
+
+        int exitCode = pb.start().waitFor();
+
+        assertThat(exitCode)
+            .withFailMessage("Generated project failed to compile")
+            .isZero();
+    }
+}
+```
+
+## Best Practices
+
+1. **Use @ServiceConnection** - Auto-configura datasource
+2. **Singleton containers** - `withReuse(true)` para velocidad
+3. **@ActiveProfiles("test")** - Config específica de test
+4. **@TempDir** - Para archivos temporales
+5. **@Tag("slow")** - Marcar tests lentos
+6. **@EnabledIf** - Condicionar ejecución en CI
+
+## Related Skills
+
+- `spring-boot-4`: Spring Boot testing
+- `apigen-architecture`: Estructura de tests
+
+