Update unittest bundle and tab to allow multiple and nested calls to describe

Author: leeyi45

src/bundles/unittest/src/__tests__/index.ts

@@ -1,35 +1,102 @@
 import { list } from 'js-slang/dist/stdlib/list';
-import { beforeEach, expect, test, vi } from 'vitest';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
 import * as asserts from '../asserts';
 import * as testing from '../functions';
 
-beforeEach(() => {
-  testing.testContext.suiteResults = {
-    name: '',
-    results: [],
-    total: 0,
-    passed: 0,
-  };
-  testing.testContext.allResults.results = [];
-  testing.testContext.runtime = 0;
-  testing.testContext.called = false;
-});
+vi.spyOn(performance, 'now').mockReturnValue(0);
 
-test('context is created correctly', () => {
-  const mockTestFn = vi.fn();
-  testing.describe('Testing 321', () => {
-    testing.it('Testing 123', mockTestFn);
+describe('Test \'it\' and \'describe\'', () => {
+  beforeEach(() => {
+    testing.suiteResults.splice(0);
   });
-  expect(testing.testContext.suiteResults.passed).toEqual(1);
-  expect(mockTestFn).toHaveBeenCalled();
-});
 
-test('context fails correctly', () => {
-  testing.describe('Testing 123', () => {
-    testing.it('This test fails!', () => asserts.assert_equals(0, 1));
+  test('it() throws an error when called without describe', () => {
+    expect(() => testing.it('desc', () => {})).toThrowError('\'it\' must be called from within a test suite!');
+  });
+
+  test('it() throws an error even after describe', () => {
+    testing.describe('a test', () => {});
+    expect(() => testing.it('desc', () => {})).toThrowError('\'it\' must be called from within a test suite!');
+  });
+
+  test('it() works fine from within a describe block', () => {
+    expect(() => {
+      testing.describe('desc', () => {
+        testing.it('desc', () => {});
+      });
+    }).not.toThrow();
+  });
+
+  test('it() correctly assigns results to the correct suite', () => {
+    testing.describe('block1', () => {
+      testing.it('test1', () => {});
+    });
+
+    testing.describe('block2', () => {
+      testing.it('test2', () => {});
+    });
+
+    expect(testing.suiteResults.length).toEqual(2);
+    const [result1, result2] = testing.suiteResults;
+    expect(result1).toMatchObject({
+      name: 'block1',
+      results: [{ name: 'test1', passed: true }],
+      passed: true,
+      passCount: 1,
+      runtime: 0,
+    });
+
+    expect(result2).toMatchObject({
+      name: 'block2',
+      results: [{ name: 'test2', passed: true }],
+      runtime: 0,
+      passed: true,
+      passCount: 1
+    });
+  });
+
+  test('it() correctly assigns results to child suites', () => {
+    testing.describe('block1', () => {
+      testing.describe('block3', () => {
+        testing.it('test3', () => {});
+      });
+      testing.it('test1', () => {});
+    });
+
+    testing.describe('block2', () => {
+      testing.it('test2', () => {});
+    });
+
+    expect(testing.suiteResults.length).toEqual(2);
+    const [result1, result2] = testing.suiteResults;
+    // Verify Result 1 first
+    expect(result1.results.length).toEqual(2);
+    const [subResult1, subResult2] = result1.results;
+    expect(subResult1).toMatchObject({
+      name: 'block3',
+      results: [{ name: 'test3', passed: true }],
+      runtime: 0,
+      passCount: 1,
+      passed: true
+    });
+
+    expect(subResult2).toEqual({
+      name: 'test1',
+      passed: true
+    });
+
+    expect(result1.name).toEqual('block1');
+    expect(result1.runtime).toEqual(0);
+
+    // Verify result2 next
+    expect(result2).toMatchObject({
+      name: 'block2',
+      results: [{ name: 'test2', passed: true }],
+      runtime: 0,
+      passCount: 1,
+      passed: true,
+    });
   });
-  expect(testing.testContext.suiteResults.passed).toEqual(0);
-  expect(testing.testContext.suiteResults.total).toEqual(1);
 });
 
 test('assert works', () => {

src/bundles/unittest/src/functions.ts

@@ -1,93 +1,112 @@
 import context from 'js-slang/context';
 
-import type { Test, TestContext, TestSuite } from './types';
+import type { Suite, SuiteResult, Test, TestResult } from './types';
 
-const handleErr = (err: any) => {
+function getNewSuite(name?: string): Suite {
+  return {
+    name,
+    results: [],
+  };
+}
+
+/**
+ * If describe was called multiple times from the root level, we need somewhere
+ * to collect those Suite Results since none of them will have a parent suite
+ */
+export const suiteResults: SuiteResult[] = [];
+let currentSuite: Suite | null = null;
+
+function handleErr(err: any) {
   if (err.error && err.error.message) {
     return (err.error as Error).message;
   }
   if (err.message) {
     return (err as Error).message;
   }
   throw err;
-};
-
-export const testContext: TestContext = {
-  called: false,
-  describe(msg: string, suite: TestSuite) {
-    if (this.called) {
-      throw new Error(`${describe.name} can only be called once per program!`);
-    }
-
-    this.called = true;
-
-    const starttime = performance.now();
-    this.suiteResults = {
-      name: msg,
-      results: [],
-      total: 0,
-      passed: 0,
-    };
-
-    suite();
-
-    this.allResults.results.push(this.suiteResults);
-
-    const endtime = performance.now();
-    this.runtime += endtime - starttime;
-    return this.allResults;
-  },
-
-  it(msg: string, test: Test) {
-    const name = `${msg}`;
-    let error = '';
-    this.suiteResults.total += 1;
+}
 
-    try {
-      test();
-      this.suiteResults.passed += 1;
-    } catch (err: any) {
-      error = handleErr(err);
-    }
+/**
+ * Defines a single test.
+ * @param name Description for this test.
+ * @param func Function containing assertions.
+ */
+export function it(name: string, func: Test): void {
+  if (currentSuite === null) {
+    throw new Error(`'${it.name}' must be called from within a test suite!`);
+  }
 
-    this.suiteResults.results.push({
+  try {
+    func();
+    currentSuite.results.push({
       name,
+      passed: true,
+    });
+  } catch (err) {
+    const error = handleErr(err);
+    currentSuite.results.push({
+      name,
+      passed: false,
       error,
     });
-  },
-
-  suiteResults: {
-    name: '',
-    results: [],
-    total: 0,
-    passed: 0,
-  },
-
-  allResults: {
-    results: [],
-    toReplString: () =>
-      `${testContext.allResults.results.length} suites completed in ${testContext.runtime} ms.`,
-  },
-
-  runtime: 0,
-};
-
-context.moduleContexts.unittest.state = testContext;
+  }
+}
 
 /**
  * Defines a single test.
- * @param str Description for this test.
- * @param func Function containing tests.
+ * @param msg Description for this test.
+ * @param func Function containing assertions.
  */
-export function it(msg: string, func: Test) {
-  testContext.it(msg, func);
+export function test(msg: string, func: Test): void {
+  if (currentSuite === null) {
+    throw new Error(`${test.name} must be called from within a test suite!`);
+  }
+  it(msg, func);
+}
+
+function determinePassCount(results: (TestResult | SuiteResult)[]): number {
+  const passedItems = results.filter(each => {
+    if ('results' in each) {
+      const passCount = determinePassCount(each.results);
+      each.passed = passCount === each.results.length;
+    }
+
+    return each.passed;
+  });
+
+  return passedItems.length;
 }
 
 /**
  * Describes a test suite.
- * @param str Description for this test.
+ * @param msg Description for this test suite.
  * @param func Function containing tests.
  */
-export function describe(msg: string, func: TestSuite) {
-  return testContext.describe(msg, func);
+export function describe(msg: string, func: Test): void {
+  const oldSuite = currentSuite;
+  const newSuite = getNewSuite(msg);
+
+  currentSuite = newSuite;
+  newSuite.startTime = performance.now();
+  func();
+  currentSuite = oldSuite;
+
+  const passCount = determinePassCount(newSuite.results);
+  const suiteResult: SuiteResult = {
+    name: msg,
+    results: newSuite.results,
+    passCount,
+    passed: passCount === newSuite.results.length,
+    runtime: performance.now() - newSuite.startTime
+  };
+
+  if (oldSuite !== null) {
+    oldSuite.results.push(suiteResult);
+  } else {
+    suiteResults.push(suiteResult);
+  }
 }
+
+context.moduleContexts.unittest.state = {
+  suiteResults
+};

src/bundles/unittest/src/index.ts

@@ -12,7 +12,7 @@ export {
   assert_greater_equals,
   assert_length,
 } from './asserts';
-export { it, describe } from './functions';
+export { it, test, describe } from './functions';
 export { mock_fn } from './mocks';
 
 /**

src/bundles/unittest/src/types.ts

@@ -2,29 +2,45 @@ export type ErrorLogger = (
   error: string[] | string,
   isSlangError?: boolean
 ) => void;
+
+/**
+ * Represents a function that when called, should either execute successfully
+ * or throw an assertion error
+ */
 export type Test = () => void;
+
+/**
+ * Represents a function that when called, executes any number of {@link Test|tests}
+ */
 export type TestSuite = () => void;
-export type TestContext = {
-  called: boolean;
-  describe: (msg: string, tests: TestSuite) => Results;
-  it: (msg: string, test: Test) => void;
-  // This holds the result of a single suite and is cleared on every run
-  suiteResults: SuiteResult;
-  // This holds the results of the entire suite
-  allResults: Results;
+
+export interface Suite {
+  name?: string
+  results: (TestResult | SuiteResult)[]
+  startTime?: number,
+}
+
+export interface SuiteResult {
+  name: string,
+  results: (TestResult | SuiteResult)[]
   runtime: number;
+  passCount: number
+  passed: boolean
+}
+
+export type TestSuccess = {
+  passed: true
+  name: string
 };
-export type TestResult = {
-  name: string;
-  error: string;
-};
-export type SuiteResult = {
-  name: string;
-  results: TestResult[];
-  total: number;
-  passed: number;
-};
-export type Results = {
-  results: SuiteResult[];
-  toReplString: () => string;
+
+export type TestFailure = {
+  passed: false
+  name: string
+  error: string
 };
+
+export type TestResult = TestSuccess | TestFailure;
+
+export interface UnittestModuleState {
+  suiteResults: SuiteResult[]
+}