Mockt 2: Advanced Concepts and Applications

Testes unitários devem ser independentes de ambiente externo (banco de dados, APIs, arquivos). Mocking resolve isso: você assume que o banco de dados funciona e retorna dados conforme esperado, gravando respostas fixas para cada caso de teste. Em Node.js, testes usam módulos nativos: 'test' para suites, 'it' para casos, 'before' e 'after' para setup. O contexto do Node.js permite mocking sem bibliotecas externas. Para mocks assíncronos (Promises), você deve retornar Promises para manter a assinatura correta. Você pode validar chamadas de dependências, quantas vezes foram chamadas, e argumentos passados.

Tests should not call real APIs because they are asynchronous and depend on external services. APIs should be mocked using libraries like Axios Mock Adapter to simulate responses. Mocks are configured by defining expected requests and their responses. Components that make asynchronous API calls require special handling in tests. The findByText query waits for elements to appear, making it suitable for asynchronous operations. GetByText does not wait and fails immediately if elements are not found.

This section presents the second rule: mock your own API, not external APIs. When testing with TDD, developers write failing tests, implement functionality, and refactor. If the system is not bound to external APIs, internal changes won't break tests. However, if tests mock external APIs, any changes to those APIs will break tests, making them fragile. The third rule addresses test performance: when tests are slow, developers should ask whether they have influence over the slow part. If the slow part involves external systems (databases, networks) outside developer control, it may be a candidate for mocking. The section then explains database operations testing, covering the four phases of testing: Setup (creating test data), Exercise (executing code), Verify (checking expected state), and Teardown (cleaning up). For simple find operations, mocks may not be necessary if implementation is unlikely to change. However, for complex queries or operations that might be replaced (like switching to Elasticsearch), mocks are appropriate. Database operations are external sources and good candidates for mocking because developers cannot control their internal implementation.

Async testing is important for functions that make API calls, database queries, or file operations. There are two main patterns: testing successful async functions using await and expect(result).toBe(expected), and testing failed async functions using expect(result).rejects.toThrow(expectedError). Real API calls should not be made in unit tests because they're slow, unstable, and unpredictable. Instead, mock the global fetch function using global.fetch = jest.fn(). Use beforeEach to set up the mock before each test, and afterEach with jest.clearAllMocks() to clean up. For successful API calls, mock fetch to return a successful response with the expected data using mockReturnValueOnce({ ok: true, json: async () => ({ id: 1, title: '...' }) }). Include all fields that your function needs in the mock response.

Standard mocking libraries don't support asynchronous mocks, so you need to create fixtures that return mock objects and stubbed coroutines. A fixture can return a function that creates a mock object and a stub coroutine that calls the mock. This allows you to patch async functions like asyncio.sleep or database calls without actually waiting for them to complete. You can then assert that mocks were called with expected parameters and side effects.

After implementation is complete, mocks can be removed and replaced with real objects to verify the system works correctly with real dependencies. Tests should verify that the system calls the right methods on real dependencies with the right arguments. Tests for the repository layer should verify that save and find methods work correctly, testing that the repository correctly persists and retrieves data from the database or data source.

Unit tests exercise code independently of external resources and should not require mocks, as mocks indicate design deficiencies; integration tests exercise code dependent on external resources like databases and APIs, where mocks are essential for repeatable testing. The test pyramid concept shows unit tests form the largest base (fastest, most numerous), followed by fewer integration tests, and even fewer end-to-end tests, with each level serving different purposes in ensuring system reliability.

Integration tests test entire application scenarios and flows (like creating a user and then logging in), while unit tests only test individual functions. Integration tests are easier because they don't require mocks - you simply call your API and write assertions. SuperTest is a testing library that works well with Jest for writing these tests. Good practice is to keep unit tests separate from end-to-end tests in different folders. In package.json, add a test script like 'test:e2e' that uses Jest with the testPathPattern flag pointing to the e2e folder.

In end-to-end testing, mocks can provide control and prevent test failures from external dependencies like API outages, but they also reduce test realism by preventing detection of real issues such as incorrect data formats or database problems; the recommended approach is to minimize mocks in end-to-end tests and use them primarily in API tests, following the automation pyramid principle where higher-level tests should test the actual system as much as possible.

This segment demonstrates the practical process of converting unit tests to integration tests. It shows how to copy test files, rename them, and replace mocked repositories with real database repositories. The video explains that integration tests use real repositories (e.g., 'commitRepository') instead of mock beans, requiring actual database interactions. It covers handling auto-generated IDs by setting expected values in test objects, and demonstrates running specific tests using the '-Dit.test' Maven flag.

Hexagonal Architecture is a design pattern that separates IO (databases, external services, frameworks) from non-IO code (domain logic, business rules) to make software more testable. The architecture uses ports and adapters to define clear boundaries, with dependencies flowing inward so that domain code remains pure and can be easily tested in isolation. This separation allows developers to write IO-free tests that are fast, predictable, and easy to maintain, while minimizing the number of tests that depend on external infrastructure.

Hexagonal Architecture, also known as Ports & Adapters, is a software design pattern that treats an application as a standalone component with defined interfaces (ports) on both sides—one side for incoming requests (API/Driving Ports) and one side for outgoing data access (SPI/Driven Ports)—allowing developers to substitute databases, drivers, or other external systems without modifying the core application logic, thereby enabling easier testing, technology upgrades, and protection of business logic from I/O coupling.

Hexagonal Architecture, also known as Ports and Adapters, is a software design pattern that separates an application's core logic from external dependencies by defining contracts (ports) that external systems must implement, with adapters serving as translation layers between the core and specific technologies; this architecture enables testability by allowing isolation of core logic from external systems, promotes technology independence by making it easy to swap out external implementations, and follows a simple rule of one port with two adapters (one for production and one for testing).

Hexagonal Architecture (Ports and Adapters) is a software design pattern discovered by Alistair Cockburn about 20 years ago, formally documented in a book the previous year. The core problem it solves is separating essential complexity (business logic) from accidental complexity (technology-specific concerns like input/output handling). This separation provides two key benefits: transparent changes to input/output components without affecting business logic, and independent testability of business logic without peripheral dependencies. The architecture places the application at the center of a hexagon, with essential complexity inside and accidental complexity outside.

Hexagonal architecture, invented by Alistair Cockburn in 2005, treats the application as a hexagon where dependencies point inward. The hexagon contains the domain (value objects, domain rules) and application logic. Outside the hexagon are adapters connecting to external systems. Dependencies always point inward—nothing inside can import anything outside. This enables pure Java testing without framework dependencies. There are two types of ports: inbound ports (driving ports) define what the application can do and represent use case APIs, living in application.port.in. Outbound ports (driven ports) define what the application needs from the outside world, living in application.port.out. The rule is absolute: adapters know nothing about the domain, and the domain knows nothing about adapters. This separation creates a clean, testable architecture where business logic can be tested in isolation.