JavaScript Tests, Jest & Vitest

const results = [];

function expect(actual) {
  return {
    toBe(expected) {
      if (actual !== expected) throw new Error(`expected ${expected}, received ${actual}`);
    },
    toEqual(expected) {
      const a = JSON.stringify(actual);
      const b = JSON.stringify(expected);
      if (a !== b) throw new Error(`expected ${b}, received ${a}`);
    },
    toThrow(message) {
      try {
        actual();
      } catch (error) {
        if (message && !error.message.includes(message)) {
          throw new Error(`threw "${error.message}", expected "${message}"`);
        }
        return;
      }
      throw new Error("expected function to throw");
    },
  };
}

function test(name, fn) {
  try {
    fn();
    results.push(`  ✓ ${name}`);
  } catch (error) {
    results.push(`  ✗ ${name}: ${error.message}`);
  }
}

// Code under test
function cartTotal(items, couponPercent = 0) {
  const subtotal = items.reduce((sum, item) => sum + item.price * item.qty, 0);
  return subtotal - (subtotal * couponPercent) / 100;
}

const items = [
  { name: "Notebook", price: 60, qty: 2 },
  { name: "Pen", price: 15, qty: 4 },
];

test("adds price times quantity", () => expect(cartTotal(items)).toBe(180));
test("applies a 10% coupon", () => expect(cartTotal(items, 10)).toBe(162));
test("empty cart costs nothing", () => expect(cartTotal([])).toBe(0));
test("3% coupon on 3 pens", () => expect(cartTotal([{ price: 9.99, qty: 3 }], 3)).toBe(29.07));
test("arrays compare by content", () => expect(items.map((i) => i.name)).toEqual(["Notebook", "Pen"]));
test("rejects bad JSON", () => expect(() => JSON.parse("{bad")).toThrow("JSON"));

console.log("cartTotal");
for (const line of results) console.log(line);
const failed = results.filter((r) => r.includes("✗")).length;
console.log(`Tests: ${failed} failed, ${results.length - failed} passed, ${results.length} total`);

// A fake API call that answers after a short delay
function fetchOrderStatus(orderId) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (orderId.startsWith("ORD-")) resolve({ id: orderId, status: "SHIPPED" });
      else reject(new Error(`Invalid order id ${orderId}`));
    }, 50);
  });
}

async function test(name, fn) {
  try {
    await fn();
    console.log(`✓ ${name}`);
  } catch (error) {
    console.log(`✗ ${name}: ${error.message}`);
  }
}

await test("returns the status of a real order", async () => {
  const order = await fetchOrderStatus("ORD-1042");
  if (order.status !== "SHIPPED") throw new Error(`got ${order.status}`);
});

await test("rejects a malformed id", async () => {
  try {
    await fetchOrderStatus("1042");
    throw new Error("expected a rejection");
  } catch (error) {
    if (!error.message.includes("Invalid order id")) throw error;
  }
});

await test("forgetting await hides the result", async () => {
  const order = fetchOrderStatus("ORD-7");   // missing await: this is a Promise
  if (order.status !== "SHIPPED") throw new Error(`status is ${order.status}`);
});

npm install --save-dev jest

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

// cart.test.js
const { cartTotal, applyCoupon } = require("./cart");

describe("cartTotal", () => {
  const items = [
    { name: "Notebook", price: 60, qty: 2 },
    { name: "Pen", price: 15, qty: 4 },
  ];

  test("adds price times quantity", () => {
    expect(cartTotal(items)).toBe(180);
  });

  test("applies a percentage coupon", () => {
    expect(cartTotal(items, 10)).toBe(162);
  });

  test("empty cart costs nothing", () => {
    expect(cartTotal([])).toBe(0);
  });
});

describe("applyCoupon", () => {
  test("knows FEST10", () => {
    expect(applyCoupon("FEST10")).toBe(10);
  });

  test("rejects unknown codes", () => {
    expect(() => applyCoupon("FREE100")).toThrow("Unknown coupon FREE100");
  });
});

// cart.test.js (ES module project)
import { describe, it, expect, vi } from "vitest";
import { cartTotal } from "./cart.js";

describe("cartTotal", () => {
  it("adds price times quantity", () => {
    expect(cartTotal([{ price: 60, qty: 2 }])).toBe(120);
  });

  it("returns a new order object", () => {
    const order = { items: 2, total: 120 };
    expect({ ...order }).toEqual({ items: 2, total: 120 });
  });

  it("calls the notifier once", () => {
    const notify = vi.fn();
    notify("Order placed");
    expect(notify).toHaveBeenCalledWith("Order placed");
    expect(notify).toHaveBeenCalledTimes(1);
  });
});