theus-cli 0.2.83 → 0.2.84

package/vendor/theus-arsenal/skills/testing-csharp/SKILL.md

@@ -1,321 +0,0 @@
----
-name: testing-csharp
-description: Patrones de testing para C# y .NET con xUnit, FluentAssertions, mocking, tests
-  de integración y buenas prácticas de organización de tests.
----
-
-# Patrones de testing en C#
-
-Patrones completos de testing para aplicaciones .NET usando xUnit, FluentAssertions y prácticas modernas de testing.
-
-## Cuándo usarla
-
-- Al escribir tests nuevos para código C#.
-- Al revisar la calidad y cobertura de los tests.
-- Al montar la infraestructura de tests de un proyecto .NET.
-- Al depurar tests inestables (flaky) o lentos.
-
-## Stack de frameworks de testing
-
-| Herramienta | Propósito |
-|---|---|
-| **xUnit** | Framework de tests (preferido para .NET) |
-| **FluentAssertions** | Sintaxis de aserciones legible |
-| **NSubstitute** o **Moq** | Mocking de dependencias |
-| **Testcontainers** | Infraestructura real en tests de integración |
-| **WebApplicationFactory** | Tests de integración de ASP.NET Core |
-| **Bogus** | Generación de datos de prueba realistas |
-
-## Estructura de tests unitarios
-
-### Arrange-Act-Assert
-
-```csharp
-public sealed class OrderServiceTests
-{
-    private readonly IOrderRepository _repository = Substitute.For<IOrderRepository>();
-    private readonly ILogger<OrderService> _logger = Substitute.For<ILogger<OrderService>>();
-    private readonly OrderService _sut;
-
-    public OrderServiceTests()
-    {
-        _sut = new OrderService(_repository, _logger);
-    }
-
-    [Fact]
-    public async Task PlaceOrderAsync_ReturnsSuccess_WhenRequestIsValid()
-    {
-        // Arrange (preparar)
-        var request = new CreateOrderRequest
-        {
-            CustomerId = "cust-123",
-            Items = [new OrderItem("SKU-001", 2, 29.99m)]
-        };
-
-        // Act (ejecutar)
-        var result = await _sut.PlaceOrderAsync(request, CancellationToken.None);
-
-        // Assert (verificar)
-        result.IsSuccess.Should().BeTrue();
-        result.Value.Should().NotBeNull();
-        result.Value!.CustomerId.Should().Be("cust-123");
-    }
-
-    [Fact]
-    public async Task PlaceOrderAsync_ReturnsFailure_WhenNoItems()
-    {
-        // Arrange
-        var request = new CreateOrderRequest
-        {
-            CustomerId = "cust-123",
-            Items = []
-        };
-
-        // Act
-        var result = await _sut.PlaceOrderAsync(request, CancellationToken.None);
-
-        // Assert
-        result.IsSuccess.Should().BeFalse();
-        result.Error.Should().Contain("at least one item");
-    }
-}
-```
-
-### Tests parametrizados con Theory
-
-```csharp
-[Theory]
-[InlineData("", false)]
-[InlineData("a", false)]
-[InlineData("ab@c.d", false)]
-[InlineData("user@example.com", true)]
-[InlineData("user+tag@example.co.uk", true)]
-public void IsValidEmail_ReturnsExpected(string email, bool expected)
-{
-    EmailValidator.IsValid(email).Should().Be(expected);
-}
-
-[Theory]
-[MemberData(nameof(InvalidOrderCases))]
-public async Task PlaceOrderAsync_RejectsInvalidOrders(CreateOrderRequest request, string expectedError)
-{
-    var result = await _sut.PlaceOrderAsync(request, CancellationToken.None);
-
-    result.IsSuccess.Should().BeFalse();
-    result.Error.Should().Contain(expectedError);
-}
-
-public static TheoryData<CreateOrderRequest, string> InvalidOrderCases => new()
-{
-    { new() { CustomerId = "", Items = [ValidItem()] }, "CustomerId" },
-    { new() { CustomerId = "c1", Items = [] }, "at least one item" },
-    { new() { CustomerId = "c1", Items = [new("", 1, 10m)] }, "SKU" },
-};
-```
-
-## Mocking con NSubstitute
-
-```csharp
-[Fact]
-public async Task GetOrderAsync_ReturnsNull_WhenNotFound()
-{
-    // Arrange
-    var orderId = Guid.NewGuid();
-    _repository.FindByIdAsync(orderId, Arg.Any<CancellationToken>())
-        .Returns((Order?)null);
-
-    // Act
-    var result = await _sut.GetOrderAsync(orderId, CancellationToken.None);
-
-    // Assert
-    result.Should().BeNull();
-}
-
-[Fact]
-public async Task PlaceOrderAsync_PersistsOrder()
-{
-    // Arrange
-    var request = ValidOrderRequest();
-
-    // Act
-    await _sut.PlaceOrderAsync(request, CancellationToken.None);
-
-    // Assert — verificar que se llamó al repositorio
-    await _repository.Received(1).AddAsync(
-        Arg.Is<Order>(o => o.CustomerId == request.CustomerId),
-        Arg.Any<CancellationToken>());
-}
-```
-
-## Tests de integración de ASP.NET Core
-
-### Configuración con WebApplicationFactory
-
-```csharp
-public sealed class OrderApiTests : IClassFixture<WebApplicationFactory<Program>>
-{
-    private readonly HttpClient _client;
-
-    public OrderApiTests(WebApplicationFactory<Program> factory)
-    {
-        _client = factory.WithWebHostBuilder(builder =>
-        {
-            builder.ConfigureServices(services =>
-            {
-                // Reemplazar la BD real por una en memoria para los tests
-                services.RemoveAll<DbContextOptions<AppDbContext>>();
-                services.AddDbContext<AppDbContext>(options =>
-                    options.UseInMemoryDatabase("TestDb"));
-            });
-        }).CreateClient();
-    }
-
-    [Fact]
-    public async Task GetOrder_Returns404_WhenNotFound()
-    {
-        var response = await _client.GetAsync($"/api/orders/{Guid.NewGuid()}");
-
-        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
-    }
-
-    [Fact]
-    public async Task CreateOrder_Returns201_WithValidRequest()
-    {
-        var request = new CreateOrderRequest
-        {
-            CustomerId = "cust-1",
-            Items = [new("SKU-001", 1, 19.99m)]
-        };
-
-        var response = await _client.PostAsJsonAsync("/api/orders", request);
-
-        response.StatusCode.Should().Be(HttpStatusCode.Created);
-        response.Headers.Location.Should().NotBeNull();
-    }
-}
-```
-
-### Tests con Testcontainers
-
-```csharp
-public sealed class PostgresOrderRepositoryTests : IAsyncLifetime
-{
-    private readonly PostgreSqlContainer _postgres = new PostgreSqlBuilder()
-        .WithImage("postgres:16-alpine")
-        .Build();
-
-    private AppDbContext _db = null!;
-
-    public async Task InitializeAsync()
-    {
-        await _postgres.StartAsync();
-        var options = new DbContextOptionsBuilder<AppDbContext>()
-            .UseNpgsql(_postgres.GetConnectionString())
-            .Options;
-        _db = new AppDbContext(options);
-        await _db.Database.MigrateAsync();
-    }
-
-    public async Task DisposeAsync()
-    {
-        await _db.DisposeAsync();
-        await _postgres.DisposeAsync();
-    }
-
-    [Fact]
-    public async Task AddAsync_PersistsOrder()
-    {
-        var repo = new SqlOrderRepository(_db);
-        var order = Order.Create("cust-1", [new OrderItem("SKU-001", 2, 10m)]);
-
-        await repo.AddAsync(order, CancellationToken.None);
-
-        var found = await repo.FindByIdAsync(order.Id, CancellationToken.None);
-        found.Should().NotBeNull();
-        found!.Items.Should().HaveCount(1);
-    }
-}
-```
-
-## Organización de tests
-
-```
-tests/
-  MyApp.UnitTests/
-    Services/
-      OrderServiceTests.cs
-      PaymentServiceTests.cs
-    Validators/
-      EmailValidatorTests.cs
-  MyApp.IntegrationTests/
-    Api/
-      OrderApiTests.cs
-    Repositories/
-      OrderRepositoryTests.cs
-  MyApp.TestHelpers/
-    Builders/
-      OrderBuilder.cs
-    Fixtures/
-      DatabaseFixture.cs
-```
-
-## Builders de datos de prueba
-
-```csharp
-public sealed class OrderBuilder
-{
-    private string _customerId = "cust-default";
-    private readonly List<OrderItem> _items = [new("SKU-001", 1, 10m)];
-
-    public OrderBuilder WithCustomer(string customerId)
-    {
-        _customerId = customerId;
-        return this;
-    }
-
-    public OrderBuilder WithItem(string sku, int quantity, decimal price)
-    {
-        _items.Add(new OrderItem(sku, quantity, price));
-        return this;
-    }
-
-    public Order Build() => Order.Create(_customerId, _items);
-}
-
-// Uso en los tests
-var order = new OrderBuilder()
-    .WithCustomer("cust-vip")
-    .WithItem("SKU-PREMIUM", 3, 99.99m)
-    .Build();
-```
-
-## Antipatrones comunes
-
-| Antipatrón | Corrección |
-|---|---|
-| Testear detalles de implementación | Testear comportamiento y resultados |
-| Estado mutable compartido entre tests | Instancia nueva por test (xUnit lo hace vía constructores) |
-| `Thread.Sleep` en tests async | Usar `Task.Delay` con timeout, o helpers de polling |
-| Asertar sobre la salida de `ToString()` | Asertar sobre propiedades tipadas |
-| Una aserción gigante por test | Una aserción lógica por test |
-| Nombres de test que describen la implementación | Nombrar por comportamiento: `Metodo_ResultadoEsperado_CuandoCondicion` |
-| Ignorar `CancellationToken` | Pasarlo siempre y verificar la cancelación |
-
-## Ejecutar los tests
-
-```bash
-# Ejecutar todos los tests
-dotnet test
-
-# Ejecutar con cobertura
-dotnet test --collect:"XPlat Code Coverage"
-
-# Ejecutar un proyecto concreto
-dotnet test tests/MyApp.UnitTests/
-
-# Filtrar por nombre de test
-dotnet test --filter "FullyQualifiedName~OrderService"
-
-# Modo watch durante el desarrollo
-dotnet watch test --project tests/MyApp.UnitTests/
-```

package/vendor/theus-arsenal/skills/testing-e2e/SKILL.md

@@ -1,325 +0,0 @@
----
-name: testing-e2e
-description: Patrones de testing E2E con Playwright, Page Object Model, configuración, integración CI/CD, gestión de artefactos y estrategias contra tests inestables.
----
-
-# Patrones de testing E2E
-
-Patrones completos de Playwright para construir suites E2E estables, rápidas y mantenibles.
-
-## Organización de archivos de test
-
-```
-tests/
-├── e2e/
-│   ├── auth/
-│   │   ├── login.spec.ts
-│   │   ├── logout.spec.ts
-│   │   └── register.spec.ts
-│   ├── features/
-│   │   ├── browse.spec.ts
-│   │   ├── search.spec.ts
-│   │   └── create.spec.ts
-│   └── api/
-│       └── endpoints.spec.ts
-├── fixtures/
-│   ├── auth.ts
-│   └── data.ts
-└── playwright.config.ts
-```
-
-## Page Object Model (POM)
-
-```typescript
-import { Page, Locator } from '@playwright/test'
-
-export class ItemsPage {
-  readonly page: Page
-  readonly searchInput: Locator
-  readonly itemCards: Locator
-  readonly createButton: Locator
-
-  constructor(page: Page) {
-    this.page = page
-    this.searchInput = page.locator('[data-testid="search-input"]')
-    this.itemCards = page.locator('[data-testid="item-card"]')
-    this.createButton = page.locator('[data-testid="create-btn"]')
-  }
-
-  async goto() {
-    await this.page.goto('/items')
-    await this.page.waitForLoadState('networkidle')
-  }
-
-  async search(query: string) {
-    await this.searchInput.fill(query)
-    await this.page.waitForResponse(resp => resp.url().includes('/api/search'))
-    await this.page.waitForLoadState('networkidle')
-  }
-
-  async getItemCount() {
-    return await this.itemCards.count()
-  }
-}
-```
-
-## Estructura de tests
-
-```typescript
-import { test, expect } from '@playwright/test'
-import { ItemsPage } from '../../pages/ItemsPage'
-
-test.describe('Búsqueda de ítems', () => {
-  let itemsPage: ItemsPage
-
-  test.beforeEach(async ({ page }) => {
-    itemsPage = new ItemsPage(page)
-    await itemsPage.goto()
-  })
-
-  test('debería buscar por palabra clave', async ({ page }) => {
-    await itemsPage.search('test')
-
-    const count = await itemsPage.getItemCount()
-    expect(count).toBeGreaterThan(0)
-
-    await expect(itemsPage.itemCards.first()).toContainText(/test/i)
-    await page.screenshot({ path: 'artifacts/search-results.png' })
-  })
-
-  test('debería manejar la ausencia de resultados', async ({ page }) => {
-    await itemsPage.search('xyznoexiste123')
-
-    await expect(page.locator('[data-testid="no-results"]')).toBeVisible()
-    expect(await itemsPage.getItemCount()).toBe(0)
-  })
-})
-```
-
-## Configuración de Playwright
-
-```typescript
-import { defineConfig, devices } from '@playwright/test'
-
-export default defineConfig({
-  testDir: './tests/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: 'playwright-results.xml' }],
-    ['json', { outputFile: 'playwright-results.json' }]
-  ],
-  use: {
-    baseURL: process.env.BASE_URL || 'http://localhost:3000',
-    trace: 'on-first-retry',
-    screenshot: 'only-on-failure',
-    video: 'retain-on-failure',
-    actionTimeout: 10000,
-    navigationTimeout: 30000,
-  },
-  projects: [
-    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
-    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
-    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
-    { name: 'mobile-chrome', use: { ...devices['Pixel 5'] } },
-  ],
-  webServer: {
-    command: 'npm run dev',
-    url: 'http://localhost:3000',
-    reuseExistingServer: !process.env.CI,
-    timeout: 120000,
-  },
-})
-```
-
-## Patrones para tests inestables (flaky)
-
-### Cuarentena
-
-```typescript
-test('inestable: búsqueda compleja', async ({ page }) => {
-  test.fixme(true, 'Inestable - Issue #123')
-  // código del test...
-})
-
-test('skip condicional', async ({ page }) => {
-  test.skip(process.env.CI, 'Inestable en CI - Issue #123')
-  // código del test...
-})
-```
-
-### Identificar inestabilidad
-
-```bash
-npx playwright test tests/search.spec.ts --repeat-each=10
-npx playwright test tests/search.spec.ts --retries=3
-```
-
-### Causas comunes y correcciones
-
-**Condiciones de carrera:**
-```typescript
-// Mal: asume que el elemento está listo
-await page.click('[data-testid="button"]')
-
-// Bien: locator con espera automática
-await page.locator('[data-testid="button"]').click()
-```
-
-**Tiempos de red:**
-```typescript
-// Mal: timeout arbitrario
-await page.waitForTimeout(5000)
-
-// Bien: esperar una condición específica
-await page.waitForResponse(resp => resp.url().includes('/api/data'))
-```
-
-**Tiempos de animación:**
-```typescript
-// Mal: clic durante la animación
-await page.click('[data-testid="menu-item"]')
-
-// Bien: esperar estabilidad
-await page.locator('[data-testid="menu-item"]').waitFor({ state: 'visible' })
-await page.waitForLoadState('networkidle')
-await page.locator('[data-testid="menu-item"]').click()
-```
-
-## Gestión de artefactos
-
-### Capturas de pantalla
-
-```typescript
-await page.screenshot({ path: 'artifacts/after-login.png' })
-await page.screenshot({ path: 'artifacts/full-page.png', fullPage: true })
-await page.locator('[data-testid="chart"]').screenshot({ path: 'artifacts/chart.png' })
-```
-
-### Trazas
-
-```typescript
-await browser.startTracing(page, {
-  path: 'artifacts/trace.json',
-  screenshots: true,
-  snapshots: true,
-})
-// ... acciones del test ...
-await browser.stopTracing()
-```
-
-### Video
-
-```typescript
-// En playwright.config.ts
-use: {
-  video: 'retain-on-failure',
-  videosPath: 'artifacts/videos/'
-}
-```
-
-## Integración CI/CD
-
-```yaml
-# .github/workflows/e2e.yml
-name: E2E Tests
-on: [push, pull_request]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm ci
-      - run: npx playwright install --with-deps
-      - run: npx playwright test
-        env:
-          BASE_URL: ${{ vars.STAGING_URL }}
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: playwright-report
-          path: playwright-report/
-          retention-days: 30
-```
-
-## Plantilla de reporte de tests
-
-```markdown
-# Reporte de tests E2E
-
-**Fecha:** AAAA-MM-DD HH:MM
-**Duración:** Xm Ys
-**Estado:** APROBANDO / FALLANDO
-
-## Resumen
-- Total: X | Aprobados: Y (Z%) | Fallidos: A | Inestables: B | Omitidos: C
-
-## Tests fallidos
-
-### nombre-del-test
-**Archivo:** `tests/e2e/feature.spec.ts:45`
-**Error:** Se esperaba que el elemento fuera visible
-**Captura:** artifacts/failed.png
-**Corrección recomendada:** [descripción]
-
-## Artefactos
-- Reporte HTML: playwright-report/index.html
-- Capturas: artifacts/*.png
-- Videos: artifacts/videos/*.webm
-- Trazas: artifacts/*.zip
-```
-
-## Testing de wallets / Web3
-
-```typescript
-test('conexión de wallet', async ({ page, context }) => {
-  // Simular (mock) el proveedor de wallet
-  await context.addInitScript(() => {
-    window.ethereum = {
-      isMetaMask: true,
-      request: async ({ method }) => {
-        if (method === 'eth_requestAccounts')
-          return ['0x1234567890123456789012345678901234567890']
-        if (method === 'eth_chainId') return '0x1'
-      }
-    }
-  })
-
-  await page.goto('/')
-  await page.locator('[data-testid="connect-wallet"]').click()
-  await expect(page.locator('[data-testid="wallet-address"]')).toContainText('0x1234')
-})
-```
-
-## Testing de flujos financieros / críticos
-
-```typescript
-test('ejecución de una operación', async ({ page }) => {
-  // Omitir en producción — dinero real
-  test.skip(process.env.NODE_ENV === 'production', 'Omitir en producción')
-
-  await page.goto('/markets/test-market')
-  await page.locator('[data-testid="position-yes"]').click()
-  await page.locator('[data-testid="trade-amount"]').fill('1.0')
-
-  // Verificar la vista previa
-  const preview = page.locator('[data-testid="trade-preview"]')
-  await expect(preview).toContainText('1.0')
-
-  // Confirmar y esperar la blockchain
-  await page.locator('[data-testid="confirm-trade"]').click()
-  await page.waitForResponse(
-    resp => resp.url().includes('/api/trade') && resp.status() === 200,
-    { timeout: 30000 }
-  )
-
-  await expect(page.locator('[data-testid="trade-success"]')).toBeVisible()
-})
-```