Testing is a crucial part of software development, ensuring that your code works as expected and helping to catch bugs early. In this section, we will cover how to test TypeScript code using popular testing frameworks and tools.

• Unit Testing: Testing individual units or components of the code.
• Integration Testing: Testing the interaction between different units or components.
• End-to-End (E2E) Testing: Testing the complete flow of an application from start to finish.

• Jest: A delightful JavaScript testing framework with a focus on simplicity.
• Mocha: A flexible JavaScript test framework for Node.js.
• Chai: A BDD / TDD assertion library for Node.js and the browser.
• Sinon: Standalone test spies, stubs, and mocks for JavaScript.

1. Initialize a new Node.js project:

   npm init -y
   

2. Install Jest and TypeScript:

   npm install --save-dev jest @types/jest ts-jest typescript
   

3. Configure Jest: Create a jest.config.js file:

   module.exports = {
     preset: 'ts-jest',
     testEnvironment: 'node',
   };
   

4. Add a TypeScript configuration file: Create a tsconfig.json file:

   {
     "compilerOptions": {
       "target": "ES6",
       "module": "commonjs",
       "strict": true,
       "esModuleInterop": true,
       "skipLibCheck": true,
       "forceConsistentCasingInFileNames": true
     }
   }
   

5. Add a test script to package.json:

   "scripts": {
     "test": "jest"
   }
   

1. Create a simple function: Create a file src/sum.ts:

   export function sum(a: number, b: number): number {
     return a + b;
   }
   

2. Write a test for the function: Create a file src/sum.test.ts:

   import { sum } from './sum';
   
   test('adds 1 + 2 to equal 3', () => {
     expect(sum(1, 2)).toBe(3);
   });
   

3. Run the test:

   npm test
   

• import { sum } from './sum';: Import the function to be tested.
• test('adds 1 + 2 to equal 3', () => { ... });: Define a test case.
• expect(sum(1, 2)).toBe(3);: Assert that the result of sum(1, 2) is 3.

Mocking is useful for isolating the unit of code being tested.

1. Mocking a function:

   const mockFn = jest.fn().mockReturnValue(42);
   expect(mockFn()).toBe(42);
   

2. Mocking a module:

   jest.mock('./moduleToMock');
   import { functionToMock } from './moduleToMock';
   

1. Using async/await:

   test('async test', async () => {
     const data = await fetchData();
     expect(data).toBe('some data');
   });
   

2. Using Promises:

   test('promise test', () => {
     return fetchData().then(data => {
       expect(data).toBe('some data');
     });
   });
   

1. Create a calculator module:

   // src/calculator.ts
   export class Calculator {
     add(a: number, b: number): number {
       return a + b;
     }
   
     subtract(a: number, b: number): number {
       return a - b;
     }
   
     multiply(a: number, b: number): number {
       return a * b;
     }
   
     divide(a: number, b: number): number {
       if (b === 0) throw new Error('Cannot divide by zero');
       return a / b;
     }
   }
   

2. Write tests for the calculator module:

   // src/calculator.test.ts
   import { Calculator } from './calculator';
   
   let calculator: Calculator;
   
   beforeEach(() => {
     calculator = new Calculator();
   });
   
   test('adds 1 + 2 to equal 3', () => {
     expect(calculator.add(1, 2)).toBe(3);
   });
   
   test('subtracts 5 - 2 to equal 3', () => {
     expect(calculator.subtract(5, 2)).toBe(3);
   });
   
   test('multiplies 2 * 3 to equal 6', () => {
     expect(calculator.multiply(2, 3)).toBe(6);
   });
   
   test('divides 6 / 2 to equal 3', () => {
     expect(calculator.divide(6, 2)).toBe(3);
   });
   
   test('throws error when dividing by zero', () => {
     expect(() => calculator.divide(1, 0)).toThrow('Cannot divide by zero');
   });
   

• beforeEach: Initializes a new instance of Calculator before each test.
• expect: Asserts the expected outcome of each method.

• Not isolating tests: Ensure each test is independent.
• Ignoring edge cases: Test for edge cases like dividing by zero.
• Not using mocks: Use mocks to isolate the unit of code being tested.

• Use descriptive test names: Clearly describe what each test is verifying.
• Keep tests small and focused: Test one thing at a time.
• Run tests frequently: Integrate tests into your development workflow.

In this section, we covered the basics of testing TypeScript code using Jest. We set up a testing environment, wrote our first test, and explored advanced testing techniques. Testing is an essential skill for any developer, and mastering it will help you write more reliable and maintainable code. In the next module, we will delve into using TypeScript with Webpack to bundle and optimize your code.