Preguntas sobre la Pirámide de Pruebas

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class MathUtilsTest {
    @Test
    public void testAdd() {
        assertEquals(5, MathUtils.add(2, 3));
    }
}
                    

import unittest

def add(x, y):
    return x + y

class TestMathUtils(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)
                    

using NUnit.Framework;

public class MathUtilsTests {
    [Test]
    public void TestAdd() {
        Assert.AreEqual(5, MathUtils.Add(2, 3));
    }
}
                    

import { add } from './mathUtils';

test('adds 2 + 3 to equal 5', () => {
  expect(add(2, 3)).toBe(5);
});
                    

import org.springframework.boot.test.context.SpringBootTest;
import org.junit.jupiter.api.Test;

@SpringBootTest
public class IntegrationTest {
    @Test
    public void testIntegration() {
        // Test de integración
    }
}
                    

import pytest

@pytest.fixture
def setup_database():
    # Configuración de la base de datos
    yield db
    # Limpieza de la base de datos

def test_database_query(setup_database):
    result = setup_database.query('SELECT * FROM table')
    assert result == expected
                    

[Binding]
public class IntegrationSteps {
    [Given(@"I have an API client")]
    public void GivenIHaveAnAPIClient() {
        // Configuración del cliente
    }

    [When(@"I send a request")]
    public void WhenISendARequest() {
        // Envío de la solicitud
    }

    [Then(@"I should receive a response")]
    public void ThenIShouldReceiveAResponse() {
        // Verificación de la respuesta
    }
}
                    

import request from 'supertest';
import app from './app';

describe('GET /api/resource', () => {
  it('should return a response', async () => {
    const response = await request(app).get('/api/resource');
    expect(response.status).toBe(200);
  });
});
                    

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.junit.jupiter.api.Test;

public class EndToEndTest {
    @Test
    public void testWebsite() {
        WebDriver driver = new ChromeDriver();
        driver.get("http://example.com");
        // Verificaciones
        driver.quit();
    }
}
                    

from selenium import webdriver
import pytest

@pytest.fixture
def driver():
    driver = webdriver.Chrome()
    yield driver
    driver.quit()

def test_website(driver):
    driver.get('http://example.com')
    assert "Example Domain" in driver.title
                    

[Binding]
public class EndToEndSteps {
    private IWebDriver _driver;

    [Given(@"I navigate to the website")]
    public void GivenINavigateToTheWebsite() {
        _driver = new ChromeDriver();
        _driver.Navigate().GoToUrl("http://example.com");
    }

    [Then(@"I should see the title")]
    public void ThenIShouldSeeTheTitle() {
        Assert.AreEqual("Example Domain", _driver.Title);
        _driver.Quit();
    }
}
                    

describe('Website Tests', () => {
  it('should load the website', () => {
    cy.visit('http://example.com');
    cy.title().should('include', 'Example Domain');
  });
});
                    

import static org.mockito.Mockito.*;

public class ServiceTest {
    @Test
    public void testService() {
        Dependency mockDependency = mock(Dependency.class);
        when(mockDependency.getValue()).thenReturn(42);
        Service service = new Service(mockDependency);
        assertEquals(42, service.getValue());
    }
}
                    

from unittest.mock import Mock

def test_service():
    mock_dependency = Mock()
    mock_dependency.get_value.return_value = 42
    service = Service(mock_dependency)
    assert service.get_value() == 42
                    

using Moq;

public class ServiceTests {
    [Test]
    public void TestService() {
        var mockDependency = new Mock();
        mockDependency.Setup(d => d.GetValue()).Returns(42);
        var service = new Service(mockDependency.Object);
        Assert.AreEqual(42, service.GetValue());
    }
}
                    

import { Service } from './service';
import { Dependency } from './dependency';

jest.mock('./dependency');

test('should return mocked value', () => {
  const mockDependency = new Dependency() as jest.Mocked;
  mockDependency.getValue.mockReturnValue(42);
  const service = new Service(mockDependency);
  expect(service.getValue()).toBe(42);
});