Arquitectura & Ingeniería

// TDD - Test Driven Development con JUnit 5
// Ciclo: RED → GREEN → REFACTOR

// STEP 1: RED - Escribir test que falla
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {

    @Test
    @DisplayName("Suma de dos números positivos")
    void testSumaPositivos() {
        Calculator calc = new Calculator();
        assertEquals(5, calc.sumar(2, 3));
    }

    @Test
    @DisplayName("Suma con número negativo")
    void testSumaConNegativo() {
        Calculator calc = new Calculator();
        assertEquals(-1, calc.sumar(2, -3));
    }

    @Test
    @DisplayName("División por cero lanza excepción")
    void testDivisionPorCero() {
        Calculator calc = new Calculator();
        assertThrows(ArithmeticException.class,
            () -> calc.dividir(10, 0));
    }
}

// STEP 2: GREEN - Implementar código mínimo
public class Calculator {
    public int sumar(int a, int b) {
        return a + b;
    }

    public int dividir(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("División por cero");
        }
        return a / b;
    }
}

// STEP 3: REFACTOR - Mejorar sin romper tests
// Los tests pasan → código validado ✓

// BDD - Behavior Driven Development
// Lenguaje: Gherkin (Given-When-Then)

// login.feature
Feature: Inicio de sesión de usuario
  Como usuario registrado
  Quiero iniciar sesión en el sistema
  Para acceder a mi cuenta

  Scenario: Login exitoso con credenciales válidas
    Given un usuario registrado con email "juan@email.com"
    And su contraseña es "Password123"
    When el usuario ingresa sus credenciales
    And hace clic en "Iniciar Sesión"
    Then debe ver el mensaje "Bienvenido, Juan"
    And debe ser redirigido al dashboard

  Scenario: Login fallido con contraseña incorrecta
    Given un usuario registrado con email "juan@email.com"
    When el usuario ingresa email "juan@email.com"
    And ingresa contraseña "wrongpassword"
    And hace clic en "Iniciar Sesión"
    Then debe ver el mensaje de error "Credenciales inválidas"
    And debe permanecer en la página de login

// LoginSteps.java - Implementación de pasos
import io.cucumber.java.en.*;

public class LoginSteps {
    private LoginPage loginPage;
    private String mensaje;

    @Given("un usuario registrado con email {string}")
    public void usuarioRegistrado(String email) {
        // Setup: crear usuario en BD de prueba
    }

    @When("el usuario ingresa sus credenciales")
    public void ingresaCredenciales() {
        loginPage.enterCredentials(email, password);
    }

    @Then("debe ver el mensaje {string}")
    public void verificarMensaje(String expected) {
        assertEquals(expected, loginPage.getMessage());
    }
}

// Contract Testing con Pact
// Verifica contratos entre servicios (Consumer-Driven)

// Consumer Side (Frontend/Mobile)
const { Pact } = require('@pact-foundation/pact');

describe('User API Contract', () => {
  const provider = new Pact({
    consumer: 'FrontendApp',
    provider: 'UserService',
    port: 1234
  });

  beforeAll(() => provider.setup());
  afterAll(() => provider.finalize());

  describe('GET /api/users/:id', () => {
    it('returns user data for valid ID', async () => {
      // Define expected interaction
      await provider.addInteraction({
        state: 'user with ID 1 exists',
        uponReceiving: 'a request for user 1',
        withRequest: {
          method: 'GET',
          path: '/api/users/1',
          headers: { 'Accept': 'application/json' }
        },
        willRespondWith: {
          status: 200,
          headers: { 'Content-Type': 'application/json' },
          body: {
            id: 1,
            name: Matchers.string('John Doe'),
            email: Matchers.email()
          }
        }
      });

      // Execute consumer code
      const user = await userClient.getUser(1);
      expect(user.name).toBeDefined();
    });
  });
});

// Provider Side (Backend) - Verifica contra el contrato
// El Pact Broker almacena los contratos generados

// Mutation Testing con PIT (Java)
// Evalúa la calidad de los tests introduciendo mutaciones

// pom.xml - Configuración de PIT

    org.pitest
    pitest-maven
    1.15.0
    
        
            com.myapp.services.*
        
        
            com.myapp.services.*Test
        
        
            CONDITIONALS_BOUNDARY
            INCREMENTS
            MATH
            NEGATE_CONDITIONALS
            RETURN_VALS
        
    


// Código Original
public class PriceCalculator {
    public double calculateDiscount(double price, int quantity) {
        if (quantity > 10) {  // Mutación: > → >=
            return price * 0.9;  // Mutación: 0.9 → 0.8
        }
        return price;
    }
}

// Test Original - ¿Detecta las mutaciones?
@Test
void testDescuentoPorCantidad() {
    PriceCalculator calc = new PriceCalculator();
    // Este test NO detecta mutación ">" → ">="
    assertEquals(90.0, calc.calculateDiscount(100.0, 15));
}

// Test Mejorado - Detecta boundary mutation
@Test
void testBoundaryCondition() {
    PriceCalculator calc = new PriceCalculator();
    // Exactly 10 items → NO discount
    assertEquals(100.0, calc.calculateDiscount(100.0, 10));
    // 11 items → WITH discount
    assertEquals(90.0, calc.calculateDiscount(100.0, 11));
}

// Ejecutar: mvn org.pitest:pitest-maven:mutationCoverage
// Reporte: target/pit-reports/index.html

// Integration Testing con Spring Boot
// Prueba la interacción entre componentes reales

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.test.context.TestPropertySource;
import org.junit.jupiter.api.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@SpringBootTest
@AutoConfigureMockMvc
@TestPropertySource(locations = "classpath:application-test.properties")
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class UserControllerIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private UserRepository userRepository;

    @BeforeEach
    void setup() {
        userRepository.deleteAll();
    }

    @Test
    @Order(1)
    @DisplayName("POST /api/users - Crear usuario")
    void createUser() throws Exception {
        String userJson = """
            {
                "name": "Juan Pérez",
                "email": "juan@email.com",
                "role": "USER"
            }
            """;

        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(userJson))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").exists())
            .andExpect(jsonPath("$.name").value("Juan Pérez"));

        // Verificar que se guardó en BD real
        assertTrue(userRepository.findByEmail("juan@email.com").isPresent());
    }

    @Test
    @Order(2)
    @DisplayName("GET /api/users/{id} - Obtener usuario existente")
    void getUserById() throws Exception {
        // Arrange: crear usuario directamente en BD
        User saved = userRepository.save(new User("Test", "test@email.com"));

        // Act & Assert
        mockMvc.perform(get("/api/users/" + saved.getId()))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.name").value("Test"));
    }
}

// E2E Testing con Playwright
// Prueba flujos completos desde la perspectiva del usuario

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

test.describe('Flujo de Compra E-Commerce', () => {

  test.beforeEach(async ({ page }) => {
    await page.goto('https://myshop.com');
  });

  test('Usuario completa compra exitosamente', async ({ page }) => {
    // 1. Buscar producto
    await page.fill('[data-testid="search-input"]', 'laptop');
    await page.click('[data-testid="search-button"]');
    await expect(page.locator('.product-card')).toHaveCount.greaterThan(0);

    // 2. Seleccionar producto
    await page.click('.product-card:first-child');
    await expect(page).toHaveURL(/\/products\/\d+/);

    // 3. Agregar al carrito
    await page.click('[data-testid="add-to-cart"]');
    await expect(page.locator('.cart-badge')).toHaveText('1');

    // 4. Ir al checkout
    await page.click('[data-testid="cart-icon"]');
    await page.click('[data-testid="checkout-button"]');

    // 5. Completar datos de envío
    await page.fill('#shipping-name', 'Juan Pérez');
    await page.fill('#shipping-address', 'Av. Principal 123');
    await page.fill('#shipping-city', 'Santiago');
    await page.click('[data-testid="continue-payment"]');

    // 6. Completar pago (sandbox)
    await page.fill('#card-number', '4242424242424242');
    await page.fill('#card-expiry', '12/25');
    await page.fill('#card-cvv', '123');
    await page.click('[data-testid="pay-button"]');

    // 7. Verificar confirmación
    await expect(page.locator('.order-confirmation')).toBeVisible();
    await expect(page.locator('.order-number')).toHaveText(/ORD-\d+/);
  });

  test('Validación de campos obligatorios', async ({ page }) => {
    await page.goto('/checkout');
    await page.click('[data-testid="continue-payment"]');
    await expect(page.locator('.error-message')).toContainText('Nombre requerido');
  });
});

// TDD - Test Driven Development con JUnit 5
// Ciclo: RED → GREEN → REFACTOR

// STEP 1: RED - Escribir test que falla
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {

    @Test
    @DisplayName("Suma de dos números positivos")
    void testSumaPositivos() {
        Calculator calc = new Calculator();
        assertEquals(5, calc.sumar(2, 3));
    }

    @Test
    @DisplayName("Suma con número negativo")
    void testSumaConNegativo() {
        Calculator calc = new Calculator();
        assertEquals(-1, calc.sumar(2, -3));
    }

    @Test
    @DisplayName("División por cero lanza excepción")
    void testDivisionPorCero() {
        Calculator calc = new Calculator();
        assertThrows(ArithmeticException.class,
            () -> calc.dividir(10, 0));
    }
}

// STEP 2: GREEN - Implementar código mínimo
public class Calculator {
    public int sumar(int a, int b) {
        return a + b;
    }

    public int dividir(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("División por cero");
        }
        return a / b;
    }
}

// STEP 3: REFACTOR - Mejorar sin romper tests
// Los tests pasan → código validado ✓