**Course Title:** Testing Frameworks: Principles and Practices **Section Title:** Mocking and Stubbing **Topic:** Implement mocks and stubs in unit tests for a sample project. (Lab topic) **Introduction** In the previous topics, we discussed the importance of mocking and stubbing in unit testing. We learned how to use these techniques to isolate dependencies and focus on testing specific units of code. In this lab topic, we will put the concepts into practice by implementing mocks and stubs in unit tests for a sample project. **Sample Project Overview** For this lab, we will use a simple e-commerce application written in Node.js and tested using Jest. The application consists of three main components: 1. **Product Service**: responsible for retrieving product information from a database. 2. **Order Service**: responsible for processing orders and integrating with the payment gateway. 3. **Payment Gateway**: a third-party service that handles payment processing. We will use this application to demonstrate how to implement mocks and stubs in unit tests. **Implementing Mocks and Stubs in Unit Tests** ### Step 1: Setting Up the Project To begin, create a new directory for the project and initialize a new Node.js project using `npm init`. Then, install the required dependencies, including Jest: ```bash npm install --save-dev jest ``` Next, create a `src` directory and add the following files: ```javascript // src/productService.js class ProductService { async getProducts() { // Simulate a database query return Promise.resolve([ { id: 1, name: 'Product 1' }, { id: 2, name: 'Product 2' }, ]); } } export default ProductService; ``` ```javascript // src/orderService.js class OrderService { async processOrder(order) { // Simulate payment processing return Promise.resolve({ status: 'success' }); } } export default OrderService; ``` ```javascript // src/paymentGateway.js class PaymentGateway { async processPayment(payment) { // Simulate payment processing return Promise.resolve({ status: 'success' }); } } export default PaymentGateway; ``` ### Step 2: Writing Unit Tests with Mocks and Stubs Create a new directory `__tests__` and add the following test files: ```javascript // __tests__/productService.test.js import ProductService from '../src/productService'; jest.mock('../src/paymentGateway', () => ({ processPayment: jest.fn(() => Promise.resolve({ status: 'success' })), })); describe('ProductService', () => { it('should return products', async () => { const productService = new ProductService(); const products = await productService.getProducts(); expect(products).toEqual([ { id: 1, name: 'Product 1' }, { id: 2, name: 'Product 2' }, ]); }); }); ``` ```javascript // __tests__/orderService.test.js import OrderService from '../src/orderService'; import PaymentGateway from '../src/paymentGateway'; jest.mock('../src/paymentGateway', () => ({ processPayment: jest.fn(() => Promise.resolve({ status: 'success' })), })); describe('OrderService', () => { it('should process order successfully', async () => { const orderService = new OrderService(); const order = { id: 1, price: 10.99 }; const result = await orderService.processOrder(order); expect(result).toEqual({ status: 'success' }); }); }); ``` In these tests, we use Jest's `jest.mock` function to mock the `PaymentGateway` module. We then use the `jest.fn` function to create a stub implementation for the `processPayment` method. ### Step 3: Verifying Mock Behavior To verify that the mocks are behaving as expected, we can use Jest's `expect` function to assert on the mock implementation: ```javascript // __tests__/orderService.test.js describe('OrderService', () => { it('should process order successfully', async () => { const orderService = new OrderService(); const order = { id: 1, price: 10.99 }; const result = await orderService.processOrder(order); expect(result).toEqual({ status: 'success' }); expect(PaymentGateway.processPayment).toHaveBeenCalledTimes(1); expect(PaymentGateway.processPayment).toHaveBeenCalledWith(order); }); }); ``` In this example, we assert that the `processPayment` method was called once with the expected argument. **Conclusion** In this lab topic, we implemented mocks and stubs in unit tests for a sample e-commerce application. We used Jest's `jest.mock` and `jest.fn` functions to create mock implementations for our dependencies and verified the mock behavior using Jest's `expect` function. **Key Takeaways** * Use `jest.mock` to create mock implementations for dependencies. * Use `jest.fn` to create stub implementations for methods. * Verify mock behavior using Jest's `expect` function. **What's Next?** In the next topic, we will explore integrating tests into continuous integration pipelines. **External Resources** * Jest Documentation: [https://jestjs.io/docs/getting-started](https://jestjs.io/docs/getting-started) * Jest Mock Function Documentation: [https://jestjs.io/docs/jest-object#jestmockmodname-factory](https://jestjs.io/docs/jest-object#jestmockmodname-factory) **Have Questions or Need Help?** Please leave a comment with your question or issue, and we'll respond promptly.