Writing test functions in Deno - Deep Dive

Overview - Writing test functions

What is it?

Writing test functions means creating small pieces of code that check if other parts of your program work correctly. In Deno, a modern JavaScript and TypeScript runtime, test functions help you automatically verify your code behaves as expected. These functions run your code with specific inputs and compare the results to what you expect. If the results match, the test passes; if not, it fails, showing you where the problem is.

Why it matters

Without test functions, bugs and errors can hide in your code and cause problems later, sometimes in ways that are hard to find. Writing tests helps catch mistakes early, saving time and frustration. It also gives you confidence to change or improve your code because you can quickly check if anything breaks. In real life, it’s like double-checking your work before handing it in, so you avoid surprises.

Where it fits

Before learning to write test functions, you should understand basic programming concepts like functions, variables, and control flow in JavaScript or TypeScript. After mastering test functions, you can explore more advanced testing topics like mocking, test coverage, and integration testing to build reliable software.

Mental Model

Core Idea

A test function is a small, automatic check that runs your code with known inputs and confirms the outputs match what you expect.

Think of it like...

Writing test functions is like setting up a checklist for a recipe: you prepare the ingredients, follow the steps, and then taste the dish to make sure it turned out right every time you cook.

┌─────────────────────────────┐
│       Test Function         │
├─────────────┬───────────────┤
│ Input       │ Known values  │
│ Code        │ Your function │
│ Expected    │ Expected output│
├─────────────┴───────────────┤
│ Run code with input          │
│ Compare actual vs expected   │
│ Pass if match, fail if not   │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding basic test functions

Concept: Learn how to write a simple test function using Deno's built-in test API.

In Deno, you write a test function by calling `Deno.test` with a name and a function. Inside, you use assertions like `assertEquals` to check if your code returns the expected result. Example: import { assertEquals } from "https://deno.land/std@0.203.0/testing/asserts.ts"; Deno.test("adds two numbers", () => { const result = 1 + 2; assertEquals(result, 3); });

Result

When you run `deno test`, this test runs automatically and passes if the sum is 3.

Understanding how to write a basic test function is the first step to automating checks and catching errors early.

2

Foundation

Using assertions to check results

Concept: Learn how assertions work to compare actual and expected values inside test functions.

Assertions are functions that compare two values. If they match, the test continues; if not, the test fails and shows an error. Common assertions in Deno include: - `assertEquals(actual, expected)` checks if values are equal. - `assert(actual)` checks if a value is truthy. Example: import { assert, assertEquals } from "https://deno.land/std@0.203.0/testing/asserts.ts"; Deno.test("truthy check", () => { const value = true; assert(value); });

Result

Tests fail immediately if an assertion is false, helping you find exactly where your code breaks.

Knowing how assertions work lets you write precise checks that catch specific problems in your code.

3

Intermediate

Testing asynchronous code

🤔Before reading on: do you think test functions can handle code that waits for things like data loading? Commit to yes or no.

Concept: Learn how to write test functions that handle asynchronous code using async/await.

Many programs do things that take time, like fetching data. To test these, your test function must wait for the code to finish. In Deno, mark the test function as `async` and use `await` inside. Example: Deno.test("async fetch test", async () => { const data = await fetch("https://example.com"); assertEquals(data.status, 200); });

Result

The test waits for the fetch to complete and passes if the status is 200, otherwise it fails.

Understanding async tests is crucial because many real-world programs rely on waiting for data or events.

4

Intermediate

Organizing tests with descriptive names

🤔Before reading on: do you think test names affect how easy it is to find problems? Commit to yes or no.

Concept: Learn why giving clear, descriptive names to test functions helps maintain and debug code.

Each test function has a name string describing what it checks. Good names explain the behavior tested. Example: Deno.test("calculateSum returns correct total for positive numbers", () => { // test code }); Clear names help you quickly understand what failed when a test breaks.

Result

When tests run, you see meaningful messages that guide you to the exact problem.

Good test names save time and reduce frustration when fixing bugs or adding features.

5

Intermediate

Grouping tests with test steps

🤔Before reading on: do you think tests can have smaller parts inside them? Commit to yes or no.

Concept: Learn how to organize complex tests into smaller steps using Deno's `t.step` for clarity and better reporting.

Inside a test function, you can create steps to separate different checks. Example: Deno.test("complex calculation", async (t) => { await t.step("step 1: setup", () => { // setup code }); await t.step("step 2: calculation", () => { // calculation code }); });

Result

Test output shows each step separately, making it easier to see which part failed.

Breaking tests into steps improves readability and debugging for complex scenarios.

6

Advanced

Handling test failures and error messages

🤔Before reading on: do you think test failures always show clear reasons? Commit to yes or no.

Concept: Learn how Deno reports test failures and how to write tests that give helpful error messages.

When an assertion fails, Deno shows the expected and actual values with a stack trace. You can add custom messages to assertions for clarity. Example: assertEquals(actual, expected, "Sum should be correct"); Good error messages help you quickly understand what went wrong.

Result

When a test fails, you get detailed information to fix the problem faster.

Knowing how to interpret and improve failure messages makes debugging more efficient.

7

Expert

Advanced test configuration and flags

🤔Before reading on: do you think test functions can be customized to run differently? Commit to yes or no.

Concept: Learn how to use Deno test options like ignoring tests, setting timeouts, and running tests in parallel or sequentially.

Deno allows you to customize tests with options: - `ignore: true` skips a test. - `only: true` runs only that test. - `sanitizeResources: false` disables resource checks. - `sanitizeOps: false` disables async operation checks. - `timeout` sets max time for a test. Example: Deno.test({ name: "slow test", fn: async () => { /* code */ }, sanitizeResources: false, timeout: 5000 });

Result

You control test behavior to fit complex scenarios and improve test suite performance.

Mastering test options lets you handle edge cases and optimize your testing workflow.

Under the Hood

Deno's test runner scans your code for calls to `Deno.test`. Each test function is registered and run in a controlled environment. Assertions throw errors when checks fail, which the runner catches to mark tests as failed. Async tests use JavaScript's async/await to pause execution until promises resolve. The runner manages resources and operations to detect leaks or unfinished tasks, ensuring tests are isolated and reliable.

Why designed this way?

Deno was designed with modern JavaScript and TypeScript in mind, aiming for simplicity and security. Integrating testing directly into the runtime avoids external dependencies and ensures consistent behavior. The design balances ease of use with powerful features like async support and resource sanitization, which were harder to achieve in older tools.

┌───────────────┐
│ Source Code   │
│ with Deno.test│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Deno Test     │
│ Runner        │
├───────────────┤
│ Registers     │
│ test functions│
│ Executes tests│
│ Catches errors│
│ Reports       │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Console Output│
│ Pass/Fail     │
│ Messages      │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think a test function runs automatically without calling a test runner? Commit to yes or no.

Common Belief: Test functions run by themselves whenever you run your program.

Reality: Test functions only run when you execute the Deno test runner with `deno test` command.

Why it matters: If you expect tests to run automatically, you might miss running them and ship buggy code.

Quick: Do you think failing tests mean your code is always wrong? Commit to yes or no.

Common Belief: If a test fails, the code is definitely broken and must be rewritten.

Reality: Tests can fail due to wrong test code, incorrect expectations, or environment issues, not just bugs in the code under test.

Why it matters: Misinterpreting failures can waste time fixing non-existent bugs or ignoring real problems.

Quick: Do you think all tests should be written synchronously? Commit to yes or no.

Common Belief: Tests should never be async because they complicate the code.

Reality: Many real-world operations are asynchronous, and Deno supports async tests natively to handle them properly.

Why it matters: Avoiding async tests limits your ability to test real scenarios like network requests or timers.

Quick: Do you think test names don't affect debugging? Commit to yes or no.

Common Belief: Test names are just labels and don't impact how you find bugs.

Reality: Clear, descriptive test names are essential for quickly identifying what failed and why.

Why it matters: Poor test names slow down debugging and increase frustration during development.

Expert Zone

1

Tests in Deno run in isolated environments with resource and operation sanitizers to catch leaks, which many beginners overlook.

2

Using `t.step` inside tests allows hierarchical test reporting, improving clarity in complex test suites.

3

Deno's test runner supports running tests in parallel by default, but you can control concurrency to avoid flaky tests.

When NOT to use

Writing test functions is not suitable for manual exploratory testing or UI testing where user interaction is key. For those, use tools like Playwright or Puppeteer. Also, for performance or load testing, specialized tools like k6 or Artillery are better choices.

Production Patterns

In production, test functions are organized into suites with setup and teardown hooks for shared resources. Tests are run automatically in CI/CD pipelines on every code change to catch regressions early. Tests often mock external services to isolate code behavior and run quickly.

Connections

Continuous Integration (CI)

Test functions are a core part of CI pipelines that automatically run tests on code changes.

Understanding test functions helps you grasp how automated pipelines ensure code quality before deployment.

Error Handling

Test functions rely on catching errors thrown by assertions to detect failures.

Knowing how errors propagate in JavaScript clarifies how test failures are detected and reported.

Scientific Method

Writing test functions follows the scientific method: hypothesize expected behavior, run experiments (tests), and observe results.

Seeing tests as experiments helps appreciate their role in verifying hypotheses about code behavior.

Common Pitfalls

#1 Writing tests that depend on external services without mocking.

Wrong approach:

Deno.test("fetch data", async () => {
const response = await fetch("https://api.example.com/data");
assertEquals(response.status, 200);
});

Correct approach:

Deno.test("fetch data with mock", async () => {
const mockResponse = { status: 200 };
// mock fetch to return mockResponse
assertEquals(mockResponse.status, 200);
});

Root cause:

Not isolating tests from external dependencies causes flaky tests that fail due to network or service issues.

#2 Not marking asynchronous test functions as async.

Wrong approach:

Deno.test("async test", () => {
const data = await fetch("https://example.com");
assertEquals(data.status, 200);
});

Correct approach:

Deno.test("async test", async () => {
const data = await fetch("https://example.com");
assertEquals(data.status, 200);
});

Root cause:

Forgetting `async` causes syntax errors or tests that don't wait for async code, leading to false positives or failures.

#3 Using vague test names that don't describe behavior.

Wrong approach:

Deno.test("test1", () => {
// test code
});

Correct approach:

Deno.test("calculateSum returns correct total for positive numbers", () => {
// test code
});

Root cause:

Poor naming makes it hard to identify what failed, slowing debugging and maintenance.

Key Takeaways

Writing test functions in Deno automates checking your code’s correctness by running small, focused checks called assertions.

Tests can handle both synchronous and asynchronous code, making them suitable for real-world programs that wait for data or events.

Clear test names and organized test steps improve readability and make debugging faster and less frustrating.

Deno’s built-in test runner manages resources and operations to ensure tests are reliable and isolated.

Mastering test functions is essential for building trustworthy software and integrating automated quality checks in your development workflow.

Practice

1. What is the main purpose of using deno.test in your code?

easy

A. To write test functions that check if code works correctly

B. To run the main application server

C. To format code automatically

D. To deploy code to the cloud

Solution

1. Step 1: Understand the role of deno.test

   deno.test is used to define test functions that verify code behavior.

2. Step 2: Differentiate from other tasks

   Running servers, formatting, or deploying are not related to deno.test.

3. Final Answer:

   To write test functions that check if code works correctly -> Option A

4. Quick Check:

   Test functions = deno.test usage [OK]

Hint: Tests check code correctness using deno.test [OK]

Common Mistakes:

• Confusing test functions with running servers
• Thinking deno.test formats code
• Assuming deno.test deploys code

2. Which of the following is the correct syntax to define a test function in Deno?

easy

A. test(() => { /* test code */ });

B. test.deno(() => { /* test code */ });

C. deno.runTest(() => { /* test code */ });

D. deno.test(() => { /* test code */ });

Solution

1. Step 1: Recall correct Deno test syntax

   The correct way to define a test is deno.test(() => { ... }).

2. Step 2: Identify incorrect options

   Options B, C, and D use wrong method names or missing namespace.

3. Final Answer:

   deno.test(() => { /* test code */ }); -> Option D

4. Quick Check:

   Correct test syntax = deno.test [OK]

Hint: Use deno.test() exactly to define tests [OK]

Common Mistakes:

• Swapping method names like test.deno or deno.runTest
• Omitting 'deno.' prefix
• Using just test() without import or context

3. What will be the output when running this test code in Deno?

import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
deno.test("sum test", () => {
  const result = 2 + 3;
  assertEquals(result, 5);
});

medium

A. Runtime error: deno.test is undefined

B. Test fails with assertion error

C. Test passes with no errors

D. Syntax error due to import

Solution

1. Step 1: Analyze the test logic

   The test calculates 2 + 3 and checks if it equals 5, which is true.

2. Step 2: Check for syntax or runtime issues

   The import and usage of deno.test and assertEquals are correct.

3. Final Answer:

   Test passes with no errors -> Option C

4. Quick Check:

   Correct assertion means test passes [OK]

Hint: Correct assertEquals means test passes [OK]

Common Mistakes:

• Assuming test fails when assertion is true
• Thinking import causes syntax error
• Confusing runtime errors with correct usage

4. Identify the error in this Deno test code:

import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
deno.test("check value", () => {
  const value = 10;
  assertEquals(value, "10");
});

medium

A. Type mismatch causes assertion failure

B. Missing async keyword in test function

C. Incorrect import URL for assertEquals

D. deno.test requires a name and function separately

Solution

1. Step 1: Check assertion parameters

   The test compares number 10 with string "10", which are not equal.

2. Step 2: Confirm other syntax correctness

   Import URL and test function syntax are correct; async is not required here.

3. Final Answer:

   Type mismatch causes assertion failure -> Option A

4. Quick Check:

   assertEquals fails if types differ [OK]

Hint: assertEquals fails if types differ exactly [OK]

Common Mistakes:

• Thinking async is always needed
• Assuming string and number are equal
• Believing import URL is wrong

5. You want to write a test in Deno that checks if a function getUserName(id) returns a non-empty string for valid IDs. Which test function is best to write?

hard

A. deno.test("user name test", () => { const name = getUserName(1); assertEquals(typeof name, "number"); });

B. deno.test("user name test", () => { const name = getUserName(1); assert(name.length > 0); });

C. deno.test("user name test", () => { const name = getUserName(1); assertEquals(name, ""); });

D. deno.test("user name test", () => { const name = getUserName(1); assertEquals(name, null); });

Solution

1. Step 1: Understand the test goal

   The test should verify the returned name is a non-empty string.

2. Step 2: Evaluate each option

   deno.test("user name test", () => { const name = getUserName(1); assert(name.length > 0); }); checks if length > 0, which matches the goal. Options A, B, and D check for number type, empty string, or null, which are incorrect.

3. Final Answer:

   deno.test("user name test", () => { const name = getUserName(1); assert(name.length > 0); }); -> Option B

4. Quick Check:

   Check non-empty string with length > 0 [OK]

Hint: Check string length > 0 to confirm non-empty [OK]

Common Mistakes:

• Checking for empty string instead of non-empty
• Checking wrong type like number or null
• Using assertEquals with wrong expected value