Feature: Validacion de contrasena en el registro

  # Criterio acordado en refinamiento entre Producto, Dev y QA.
  # Define QUE significa "correcto". No ejecuta nada todavia.

  Scenario Outline: Se rechazan contrasenas debiles
    Given un usuario en el formulario de registro
    When ingresa la contrasena "<password>"
    Then el sistema muestra el error "<mensaje>"
    And el boton de registro permanece deshabilitado

    Examples:
      | password      | mensaje                                  |
      | abc           | Minimo 8 caracteres                      |
      | abcdefgh      | Debe incluir al menos un numero          |
      | abcdefg1      | Debe incluir al menos una mayuscula      |
      | 12345678      | Debe incluir al menos una letra          |

import pytest
from app.validators import validar_password, PasswordError


@pytest.mark.parametrize("password,mensaje_esperado", [
    ("abc",      "Minimo 8 caracteres"),
    ("abcdefgh", "Debe incluir al menos un numero"),
    ("abcdefg1", "Debe incluir al menos una mayuscula"),
    ("12345678", "Debe incluir al menos una letra"),
])
def test_passwords_debiles_son_rechazadas(password, mensaje_esperado):
    """Verifica el producto contra el criterio definido por QA."""
    with pytest.raises(PasswordError) as excinfo:
        validar_password(password)
    assert str(excinfo.value) == mensaje_esperado


def test_password_valida_es_aceptada():
    assert validar_password("Underc0de2026") is True

name: quality-gate

on:
  pull_request:
    branches: [main]

jobs:
  gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Linter (estandar de codigo definido por QA)
        run: ruff check .

      - name: Tests unitarios con umbral de cobertura
        run: pytest --cov=app --cov-fail-under=80

      - name: Analisis estatico de seguridad
        run: bandit -r app/ -ll

      # La politica: sin estos checks en verde, el merge no ocurre.
      # Eso es aseguramiento, no control.

-- Escape rate: defectos encontrados en produccion
-- sobre el total de defectos del periodo.
-- Si sube, el problema esta en el proceso, no en el ultimo build.

SELECT
    DATE_TRUNC('month', fecha_reporte)                       AS mes,
    COUNT(*) FILTER (WHERE entorno = 'produccion')           AS escapados,
    COUNT(*)                                                 AS total,
    ROUND(
        100.0 * COUNT(*) FILTER (WHERE entorno = 'produccion')
        / NULLIF(COUNT(*), 0)
    , 2)                                                     AS escape_rate_pct
FROM defectos
WHERE fecha_reporte >= NOW() - INTERVAL '12 months'
GROUP BY 1
ORDER BY 1;

https://mega4upload.net/8w53q8avpjm9
https://rg.to/file/a99c1226fa47bd3d7bea692df3a27d34
https://uploady.io/wpi98xet965n/NBS13Sep26fiction.rar
https://www.up-4ever.net/p15myhuekiaa

   ┌─────────────────────────────────────────────────┐
   │                                                 │
   ▼                                                 │
┌──────────┐   "abrí /login y                  ┌──────────┐
│  MODELO  │──── contame qué ves" ────────────▶│ HERRAMIENTAS│
│  (LLM)   │                                   │  browser  │
│          │◀─── árbol de accesibilidad, ──────│  archivos │
└──────────┘     errores, screenshots          │  shell    │
   │                                           └──────────┘
   │ ¿terminé?
   ▼
┌──────────────────────┐
│ test.spec.ts escrito │
│ y verificado         │
└──────────────────────┘

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [
        "@playwright/mcp@latest",
        "--headless",
        "--isolated",
        "--allowed-origins", "http://localhost:3000;https://staging.miapp.com"
      ]
    }
  }
}

npx playwright init-agents --loop=vscode
npx playwright init-agents --loop=claude
npx playwright init-agents --loop=codex
npx playwright init-agents --loop=opencode

App corriendo
     │
     ▼
 [PLANNER] ──▶ specs/plan.md          ← acá revisás VOS
     │                                   (esto es el control de calidad)
     ▼
[GENERATOR] ─▶ tests/*.spec.ts        ← código determinista, versionado
     │
     ▼
  npx playwright test  ──── falla ───▶ [HEALER] ──▶ propone el arreglo
     │                                                     │
     └────────────────── pasa ◀────────────────────────────┘

# el agente recibe la carpeta de artefactos y produce un resumen
npx playwright test --reporter=json > resultados.json
# → agente: leer resultados.json + traces, agrupar por causa raíz

GRUPO 1 (12 tests) — el endpoint /api/session devuelve 502
  → causa compartida, backend. No es un problema de los tests.
GRUPO 2 (1 test)  — el botón "Continuar" cambió de nombre a "Siguiente"
  → cambio legítimo de UI, el test necesita actualizarse.
GRUPO 3 (1 test)  — flaky: pasó en el reintento, race condition en el toast
  → revisar espera, no es regresión.

import anthropic

client = anthropic.Anthropic()

resp = client.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},
    tools=[{
        "name": "correr_test",
        "description": "Ejecuta un archivo de test de Playwright y devuelve stdout/stderr.",
        "input_schema": {
            "type": "object",
            "properties": {"archivo": {"type": "string"}},
            "required": ["archivo"],
            "additionalProperties": False,
        },
        "strict": True,
    }],
    messages=[{
        "role": "user",
        "content": "Corré tests/login.spec.ts y si falla, decime la causa raíz.",
    }],
)

for bloque in resp.content:
    if bloque.type == "tool_use":
        print("quiere ejecutar:", bloque.input)

npm init playwright@latest

npm install -D @playwright/test
npx playwright install --with-deps

import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 2 : undefined,
  reporter: [['html'], ['list']],

  use: {
    baseURL: process.env.BASE_URL || 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
    actionTimeout: 10000,
  },

  projects: [
    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
    { name: 'firefox',  use: { ...devices['Desktop Firefox'] } },
    { name: 'webkit',   use: { ...devices['Desktop Safari'] } },
    { name: 'mobile',   use: { ...devices['Pixel 7'] } },
  ],

  webServer: {
    command: 'npm run start',
    url: 'http://localhost:3000',
    reuseExistingServer: !process.env.CI,
  },
});

import { test, expect } from '@playwright/test';

test('un usuario puede iniciar sesión', async ({ page }) => {
  await page.goto('/login');

  await page.getByLabel('Usuario').fill('antrax');
  await page.getByLabel('Contraseña').fill('hunter2');
  await page.getByRole('button', { name: 'Ingresar' }).click();

  await expect(page.getByRole('heading', { name: 'Panel' })).toBeVisible();
  await expect(page).toHaveURL('/dashboard');
});

export class LoginPage {
  constructor(private page: Page) {}

  usuario  = () => this.page.getByLabel('Usuario');
  password = () => this.page.getByLabel('Contraseña');
  submit   = () => this.page.getByRole('button', { name: 'Ingresar' });

  async login(user: string, pass: string) {
    await this.page.goto('/login');
    await this.usuario().fill(user);
    await this.password().fill(pass);
    await this.submit().click();
  }
}

npx playwright codegen https://tu-sitio.com

npx playwright show-trace trace.zip

npx playwright test --ui

test('muestra un mensaje si la API falla', async ({ page }) => {
  await page.route('**/api/usuarios', route =>
    route.fulfill({ status: 500, body: '{"error":"boom"}' })
  );
  await page.goto('/usuarios');
  await expect(page.getByText('No pudimos cargar')).toBeVisible();
});

// auth.setup.ts
setup('autenticar', async ({ page }) => {
  await page.goto('/login');
  await page.getByLabel('Usuario').fill(process.env.TEST_USER);
  await page.getByLabel('Contraseña').fill(process.env.TEST_PASS);
  await page.getByRole('button', { name: 'Ingresar' }).click();
  await page.context().storageState({ path: 'playwright/.auth/user.json' });
});

name: e2e
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
      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: playwright-report
          path: playwright-report/

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("https://ejemplo.com/login")

driver.find_element(By.ID, "usuario").send_keys("[email protected]")
driver.find_element(By.ID, "password").send_keys("secreto")
driver.find_element(By.CSS_SELECTOR, "button[type=submit]").click()

# La espera es explícita: si no la ponés, el test es inestable.
WebDriverWait(driver, 10).until(
    EC.text_to_be_present_in_element((By.CSS_SELECTOR, "h1"), "Panel")
)

driver.quit()

it('inicia sesión correctamente', () => {
  cy.visit('/login')
  cy.get('#usuario').type('[email protected]')
  cy.get('#password').type('secreto')
  cy.get('button[type=submit]').click()

  // No hay waits: cada comando reintenta hasta que se cumple o expira.
  cy.get('h1').should('contain', 'Panel')
})

test('inicia sesión correctamente', async ({ page }) => {
  await page.goto('/login')
  await page.getByLabel('Usuario').fill('[email protected]')
  await page.getByLabel('Contraseña').fill('secreto')
  await page.getByRole('button', { name: 'Entrar' }).click()

  // Los selectores por rol sobreviven a cambios de maquetado.
  await expect(page.getByRole('heading')).toHaveText('Panel')
})