Deno Testing

Deno Testing Core Knowledge

Deep Knowledge: Use mcp__documentation__fetch_docs with technology: deno for comprehensive documentation.

Full Reference: See advanced.md for FakeTime, BDD Style, Snapshots, HTTP Testing, Integration Tests, Test Context, Custom Assertions, and Permissions Testing.

When NOT to Use This Skill

• Node.js Projects - Use vitest or jest for Node.js
• Browser-Only Code - Use Playwright for browser automation
• Python Projects - Use pytest for Python
• Java Projects - Use junit for Java
• Non-Deno TypeScript - Use vitest for standard TypeScript

Basic Testing

Unit Tests

// math.ts
export function add(a: number, b: number): number {
  return a + b;
}

export function divide(a: number, b: number): number {
  if (b === 0) {
    throw new Error("Division by zero");
  }
  return a / b;
}

// math_test.ts
import { assertEquals, assertThrows } from "https://deno.land/std@0.208.0/assert/mod.ts";
import { add, divide } from "./math.ts";

Deno.test("add positive numbers", () => {
  assertEquals(add(2, 3), 5);
});

Deno.test("divide by zero throws", () => {
  assertThrows(
    () => divide(10, 0),
    Error,
    "Division by zero"
  );
});

Running Tests

# Run all tests
deno test

# Run specific file
deno test math_test.ts

# Run tests matching pattern
deno test --filter "add"

# Allow permissions
deno test --allow-read --allow-net

# Watch mode
deno test --watch

# Coverage
deno test --coverage=cov_profile
deno coverage cov_profile --html

Assertions

import {
  assertEquals,
  assertNotEquals,
  assertStrictEquals,
  assertExists,
  assertInstanceOf,
  assertArrayIncludes,
  assertStringIncludes,
  assertMatch,
  assertThrows,
  assertRejects,
  assert,
} from "https://deno.land/std@0.208.0/assert/mod.ts";

Deno.test("assertions examples", () => {
  assertEquals({ a: 1 }, { a: 1 });
  assertNotEquals({ a: 1 }, { a: 2 });
  assertStrictEquals(obj, obj);           // Reference equality
  assertExists("value");                   // Not null/undefined
  assertInstanceOf(new Date(), Date);
  assertArrayIncludes([1, 2, 3], [2, 3]);
  assertStringIncludes("hello world", "world");
  assertMatch("hello123", /\d+/);
  assert(true);
});

Deno.test("error assertions", async () => {
  assertThrows(() => { throw new Error("oops"); }, Error, "oops");
  await assertRejects(async () => { throw new Error("async error"); }, Error);
});

Test Organization

Test Steps

Deno.test("user workflow", async (t) => {
  let userId: string;

  await t.step("create user", async () => {
    const response = await fetch("http://localhost:8000/users", {
      method: "POST",
      body: JSON.stringify({ name: "Alice" }),
    });
    const user = await response.json();
    userId = user.id;
    assertEquals(user.name, "Alice");
  });

  await t.step("get user", async () => {
    const response = await fetch(`http://localhost:8000/users/${userId}`);
    const user = await response.json();
    assertEquals(user.id, userId);
  });
});

Test Options

Deno.test({
  name: "test with options",
  permissions: { read: true, net: true },
  fn: async () => {
    const data = await Deno.readTextFile("./data.txt");
    assertEquals(data.length > 0, true);
  },
});

Deno.test({
  name: "ignored test",
  ignore: Deno.build.os === "windows",
  fn: () => { /* Skipped on Windows */ },
});

Deno.test({
  name: "test with sanitizers disabled",
  sanitizeResources: false,
  sanitizeOps: false,
  fn: async () => { /* Test that might leak resources */ },
});

Async Testing

Deno.test("async test", async () => {
  const result = await asyncOperation();
  assertEquals(result, "expected");
});

Deno.test("timeout handling", async () => {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 5000);

  try {
    const response = await fetch("http://example.com", {
      signal: controller.signal,
    });
    assertEquals(response.ok, true);
  } finally {
    clearTimeout(timeout);
  }
});

Mocking

Spy Functions

import { spy, assertSpyCalls, assertSpyCall } from "https://deno.land/std@0.208.0/testing/mock.ts";

Deno.test("spy example", () => {
  const func = spy((x: number) => x * 2);

  assertEquals(func(2), 4);
  assertEquals(func(3), 6);

  assertSpyCalls(func, 2);
  assertSpyCall(func, 0, { args: [2], returned: 4 });
});

Deno.test("spy on object method", () => {
  const obj = {
    greet(name: string) { return `Hello, ${name}!`; },
  };

  const greetSpy = spy(obj, "greet");

  assertEquals(obj.greet("Alice"), "Hello, Alice!");
  assertSpyCalls(greetSpy, 1);

  greetSpy.restore();
});

Stub Functions

import { stub, returnsNext } from "https://deno.land/std@0.208.0/testing/mock.ts";

Deno.test("stub example", () => {
  const obj = { getValue: () => Math.random() };

  const stubFn = stub(obj, "getValue", () => 42);

  assertEquals(obj.getValue(), 42);
  assertEquals(obj.getValue(), 42);

  stubFn.restore();
});

Deno.test("stub with different returns", () => {
  const obj = { getValue: () => 0 };

  const stubFn = stub(obj, "getValue", returnsNext([1, 2, 3]));

  assertEquals(obj.getValue(), 1);
  assertEquals(obj.getValue(), 2);
  assertEquals(obj.getValue(), 3);

  stubFn.restore();
});

Mocking Fetch

Deno.test("mock fetch", async () => {
  const mockResponse = new Response(JSON.stringify({ id: 1, name: "Alice" }), {
    status: 200,
    headers: { "Content-Type": "application/json" },
  });

  const fetchStub = stub(
    globalThis,
    "fetch",
    () => Promise.resolve(mockResponse)
  );

  try {
    const response = await fetch("http://api.example.com/users/1");
    const user = await response.json();

    assertEquals(user.name, "Alice");
  } finally {
    fetchStub.restore();
  }
});

Checklist

• Unit tests for all public functions
• Async tests for async operations
• BDD-style tests for complex features
• Mock external dependencies
• Snapshot tests for complex data
• HTTP handler tests
• Test steps for workflows
• Permission-aware tests
• Coverage reporting

Anti-Patterns

Quick Troubleshooting

Reference Documentation

• Deno Testing
• std/testing