theus-cli-linux-x64 0.2.84

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

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

@@ -0,0 +1,325 @@
+---
+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()
+})
+```