javi-forge 1.2.0 → 1.3.0

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

@@ -1,289 +0,0 @@
----
-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

@@ -1,299 +0,0 @@
----
-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
-
-