Jassif Team Institution

// Load the test module
const test = require('node:test');
// Use strict assertion mode for better error messages
const assert = require('node:assert/strict');

// Simple synchronous test
test('basic arithmetic', (t) => {
  // Assert that 1 + 1 equals 2
  assert.equal(1 + 1, 2, '1 + 1 should equal 2');

  // Deep equality check for objects/arrays
  assert.deepEqual(
    { a: 1, b: { c: 2 } },
    { a: 1, b: { c: 2 } }
  );
});

// Asynchronous test with async/await
test('async test', async (t) => {
  const result = await Promise.resolve('async result');
  assert.strictEqual(result, 'async result');
});

# Run all test files in the test directory
node --test

# Run a specific test file
node --test test/example.test.js

# Run with coverage reporting
NODE_V8_COVERAGE=coverage node --test

project/
├── src/
│   ├── math.js
│   └── utils.js
└── test/
    ├── unit/
    │   ├── math.test.js
    │   └── utils.test.js
    └── integration/
        └── api.test.js

const { test, describe, before, after, beforeEach, afterEach } = require('node:test');
const assert = require('node:assert/strict');

describe('Test Suite with Hooks', (t) => {
  let testData = [];

  // Runs once before all tests
  before(() => {
    console.log('Running before all tests');
    testData = [1, 2, 3];
  });

  // Runs before each test
  beforeEach((t) => {
    console.log('Running before each test');
  });

  test('array length', () => {
    assert.strictEqual(testData.length, 3);
  });

  // Runs after each test
  afterEach(() => {
    console.log('Running after each test');
  });

  // Runs once after all tests
  after(() => {
    console.log('Running after all tests');
    testData = [];
  });
});

import test from 'node:test';
import assert from 'node:assert/strict';

// Using async/await
test('async test', async () => {
  // Simulate async operation
  const result = await Promise.resolve(42);
  assert.equal(result, 42);
});

// Using callbacks with done (older style)
test('callback test', (t, done) => {
  setTimeout(() => {
    assert.equal(1 + 1, 2);
    done();
  }, 100);
});

import test from 'node:test';
import assert from 'node:assert/strict';

test('math operations', async (t) => {
  await t.test('addition', () => {
    assert.equal(1 + 1, 2);
  });
  
  await t.test('multiplication', () => {
    assert.equal(2 * 3, 6);
  });
  
  await t.test('division', () => {
    assert.equal(10 / 2, 5);
  });
});

import test from 'node:test';

// Skip this test
test('skipped test', { skip: true }, () => {
  // This won't run
});

// Skip with a reason
test('skipped with reason', { skip: 'working on this later' }, () => {
  // This won't run
});

// Mark as TODO
test('todo test', { todo: true }, () => {
  // This won't run, but will be reported as TODO
});

// Conditional skip
test('conditional skip', { skip: process.platform === 'win32' }, () => {
  // This will be skipped on Windows
});

import assert from 'node:assert/strict';

// Equality checks
assert.equal(1, 1);                 // Loose equality (==)
assert.strictEqual(1, 1);           // Strict equality (===)
assert.deepEqual({a: 1}, {a: 1});   // Deep equality for objects
assert.deepStrictEqual({a: 1}, {a: 1}); // Strict deep equality

// Truthiness checks
assert.ok(true);                    // Checks if value is truthy
assert.ok(1);                       // Also truthy

// Comparing values
assert.notEqual(1, 2);              // Check inequality
assert.notStrictEqual(1, '1');      // Check strict inequality

// Throwing errors
assert.throws(() => { throw new Error('Boom!'); }); // Check if function throws
assert.doesNotThrow(() => { return 42; });         // Check if no error thrown

// Async assertions
await assert.rejects(               // Check if Promise rejects
  async () => { throw new Error('Async boom!'); }
);

import test from 'node:test';
import assert from 'node:assert/strict';

// Function we want to test
function processUser(user, logger) {
  if (!user.name) {
    logger.error('User has no name');
    return false;
  }
  logger.info(`Processing user: ${user.name}`);
  return true;
}

// Test with a mock logger
test('processUser logs correctly', () => {
  // Create a mock logger
  const mockCalls = [];
  const mockLogger = {
    error: (msg) => mockCalls.push(['error', msg]),
    info: (msg) => mockCalls.push(['info', msg])
  };
  
  // Test with valid user
  const validResult = processUser({name: 'Alice'}, mockLogger);
  assert.strictEqual(validResult, true);
  assert.deepStrictEqual(mockCalls[0], ['info', 'Processing user: Alice']);
  
  // Reset mock calls
  mockCalls.length = 0;
  
  // Test with invalid user
  const invalidResult = processUser({}, mockLogger);
  assert.strictEqual(invalidResult, false);
  assert.deepStrictEqual(mockCalls[0], ['error', 'User has no name']);
});

utils.js

exports.formatPrice = function(price) {
  if (typeof price !== 'number' || isNaN(price)) {
    throw new Error('Price must be a valid number');
  }
  return `$${price.toFixed(2)}`;
};

utils.test.js

const test = require('node:test');
const assert = require('node:assert/strict');
const { formatPrice } = require('./utils');

// Test cases
test('formatPrice formats numbers as currency strings', (t) => {
  assert.equal(formatPrice(10), '$10.00');
  assert.equal(formatPrice(10.5), '$10.50');
  assert.equal(formatPrice(0), '$0.00');
});

// Test for error
test('formatPrice throws error for invalid inputs', (t) => {
  assert.throws(() => formatPrice('not a number'), {
    message: 'Price must be a valid number'
  });
  assert.throws(() => formatPrice(NaN));
  assert.throws(() => formatPrice());
});

node --test --test-reporter=spec

node --test --test-name-pattern="user"

node --test --watch