Tests

img

References

Unit Testing

Integration Testing

System Testing (End to End Testing)

Acceptance Testing

Regression Testing

Performance Testing

Load Testing

Security Testing

What it is: Testing whether the program is safe against people who try to do bad things, like stealing data. Example: Checking whether an online store protects customers’ credit card information well.

Usability Testing

What it is: Testing whether the program is easy to use and understand. Example: Checking whether a drawing application is easy for children to understand and use.

Compatibility Testing

What it is: Testing whether the program works well on different devices and operating systems. Example: Checking whether a music application works on both iPhones and Android phones.

In short

TDD - Test Driven Development

img

Arrange, Act, Assert

img img

Functional and Non-Functional Tests

Mocks, Stubs, Fakes and Spies

Mocks

// userService.ts
import axios from "axios";

export interface User {
  id: number;
  name: string;
}

export async function getUser(userId: number): Promise<User> {
  const response = await axios.get<User>(
    `https://api.example.com/users/${userId}`
  );
  return response.data;
}

import axios from "axios";
import { getUser, User } from "./userService";

// Mocking the axios module
jest.mock("axios");
const mockedAxios = axios as jest.Mocked<typeof axios>;

describe("getUser", () => {
  it("should return user data when the API responds correctly", async () => {
    // Arrange
    const userId = 1;
    const userData: User = { id: userId, name: "John Doe" };
    mockedAxios.get.mockResolvedValue({ data: userData });

    // Act
    const result = await getUser(userId);

    // Assert
    expect(result).toEqual(userData);
    expect(mockedAxios.get).toHaveBeenCalledWith(
      `https://api.example.com/users/${userId}`
    );
  });

  it("should throw an error when the API returns an error", async () => {
    // Arrange
    mockedAxios.get.mockRejectedValue(new Error("Network Error"));

    // Act and Assert
    await expect(getUser(1)).rejects.toThrow("Network Error");
  });
});

Stubs

// emailService.ts
export interface Email {
  to: string;
  subject: string;
  body: string;
}

export async function sendEmail(email: Email): Promise<void> {
  // Imagine this function actually sends an email
  console.log(`Sending email to ${email.to}`);
}

// notificationService.ts
import { Email, sendEmail } from "./emailService";

export async function notifyUser(
  email: string,
  message: string
): Promise<void> {
  const emailData: Email = {
    to: email,
    subject: "Notification",
    body: message,
  };

  await sendEmail(emailData);
}

// notificationService.test.ts
import { notifyUser } from "./notificationService";
import * as emailService from "./emailService";

describe("notifyUser", () => {
  it("should call sendEmail with the correct parameters", async () => {
    // Arrange
    const email = "test@example.com";
    const message = "Hello, this is a notification.";

    // Stub the sendEmail function
    const sendEmailStub = jest
      .spyOn(emailService, "sendEmail")
      .mockResolvedValue();

    // Act
    await notifyUser(email, message);

    // Assert
    expect(sendEmailStub).toHaveBeenCalledWith({
      to: email,
      subject: "Notification",
      body: message,
    });

    // Cleanup
    sendEmailStub.mockRestore();
  });
});

Fakes

// databaseService.ts
export interface User {
  id: number;
  name: string;
}

export interface Database {
  getUserById(id: number): Promise<User | null>;
  saveUser(user: User): Promise<void>;
}

export class RealDatabase implements Database {
  private users: User[] = [];

  async getUserById(id: number): Promise<User | null> {
    return this.users.find(user => user.id === id) || null;
  }

  async saveUser(user: User): Promise<void> {
    this.users.push(
  }
}

// userRepository.ts
import { Database, User } from "./databaseService";

export class UserRepository {
  constructor(private database: Database) {}

  async getUser(id: number): Promise<User | null> {
    return await this.database.getUserById(id);
  }

  async addUser(user: User): Promise<void> {
    await this.database.saveUser(user);
  }
}

// userRepository.test.ts
import { UserRepository } from "./userRepository";
import { Database, User } from "./databaseService";

// Fake implementation of the Database interface
class FakeDatabase implements Database {
  private users: User[] = [];

  async getUserById(id: number): Promise<User | null> {
    return this.users.find(user => user.id === id) || null;
  }

  async saveUser(user: User): Promise<void> {
    this.users.push(user);
  }
}

describe("UserRepository", () => {
  it("should add and retrieve a user", async () => {
    // Arrange
    const fakeDatabase = new FakeDatabase();
    const userRepository = new UserRepository(fakeDatabase);
    const user: User = { id: 1, name: "John Doe" };

    // Act
    await userRepository.addUser(user);
    const retrievedUser = await userRepository.getUser(user.id);

    // Assert
    expect(retrievedUser).toEqual(user);
  });

  it("should return null if user does not exist", async () => {
    // Arrange
    const fakeDatabase = new FakeDatabase();
    const userRepository = new UserRepository(fakeDatabase);

    // Act
    const retrievedUser = await userRepository.getUser(1);

    // Assert
    expect(retrievedUser).toBeNull();
  });
});

Spies

// paymentService.ts
export interface PaymentDetails {
  amount: number;
  method: string;
}

export class PaymentService {
  async processPayment(paymentDetails: PaymentDetails): Promise<void> {
    // Imagine this function actually processes a payment
    console.log(
      `Processing payment of ${paymentDetails.amount} using ${paymentDetails.method}`
    );
  }
}

// checkoutService.ts
import { PaymentService, PaymentDetails } from "./paymentService";

export class CheckoutService {
  constructor(private paymentService: PaymentService) {}

  async checkout(paymentDetails: PaymentDetails): Promise<void> {
    await this.paymentService.processPayment(paymentDetails);
  }
}

// checkoutService.test.ts
import { CheckoutService } from "./checkoutService";
import { PaymentService, PaymentDetails } from "./paymentService";

describe("CheckoutService", () => {
  it("should call processPayment with the correct parameters", async () => {
    // Arrange
    const paymentService = new PaymentService();
    const checkoutService = new CheckoutService(paymentService);
    const paymentDetails: PaymentDetails = {
      amount: 100,
      method: "CreditCard",
    };

    // Spy on the processPayment method
    const processPaymentSpy = jest
      .spyOn(paymentService, "processPayment")
      .mockResolvedValue();

    // Act
    await checkoutService.checkout(paymentDetails);

    // Assert
    expect(processPaymentSpy).toHaveBeenCalledWith(paymentDetails);
    expect(processPaymentSpy).toHaveBeenCalledTimes(1);

    // Cleanup
    processPaymentSpy.mockRestore();
  });
});

Use Cases

Simple Summary

Practical Example