Fix it and test being able to be called recursively

Author: leeyi45

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

@@ -2,6 +2,7 @@ import { list } from 'js-slang/dist/stdlib/list';
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 import * as asserts from '../asserts';
 import * as testing from '../functions';
+import { UnitestBundleInternalError } from '../types';
 
 vi.spyOn(performance, 'now').mockReturnValue(0);
 
@@ -10,13 +11,27 @@ describe('Test \'it\' and \'describe\'', () => {
     testing.suiteResults.splice(0);
   });
 
+  test('it and describe correctly set and resets the value of current test and suite', () => {
+    expect(testing.currentTest).toBeNull();
+    expect(testing.currentSuite).toBeNull();
+    testing.describe('suite', () => {
+      expect(testing.currentSuite).not.toBeNull();
+      expect(testing.currentTest).toBeNull();
+      testing.it('test', () => {
+        expect(testing.currentTest).toEqual('test');
+      });
+    });
+
+    expect(testing.currentTest).toBeNull();
+  });
+
   test('it() throws an error when called without describe', () => {
-    expect(() => testing.it('desc', () => {})).toThrowError('\'it\' must be called from within a test suite!');
+    expect(() => testing.it('desc', () => {})).toThrowError('it must be called from within a test suite!');
   });
 
-  test('it() throws an error even after describe', () => {
+  test('it() throws an error even if it is called after describe', () => {
     testing.describe('a test', () => {});
-    expect(() => testing.it('desc', () => {})).toThrowError('\'it\' must be called from within a test suite!');
+    expect(() => testing.it('desc', () => {})).toThrowError('it must be called from within a test suite!');
   });
 
   test('it() works fine from within a describe block', () => {
@@ -97,6 +112,16 @@ describe('Test \'it\' and \'describe\'', () => {
       passed: true,
     });
   });
+
+  test('it() throws when called within another it block', () => {
+    const f = () => testing.describe('suite', () => {
+      testing.it('test0', () => {
+        testing.it('test1', () => {});
+      });
+    });
+
+    expect(f).toThrowError('it cannot be called from within another test!');
+  });
 });
 
 test('assert works', () => {
@@ -115,3 +140,9 @@ test('assert_contains works', () => {
   expect(() => asserts.assert_contains(list1, 2)).not.toThrow();
   expect(() => asserts.assert_contains(list1, 10)).toThrow();
 });
+
+test('internal errors are not handled', () => {
+  expect(() => {
+    throw new UnitestBundleInternalError();
+  }).toThrow();
+});

src/bundles/unittest/src/functions.ts

@@ -1,6 +1,13 @@
 import context from 'js-slang/context';
 
-import type { Suite, SuiteResult, Test, TestResult } from './types';
+import {
+  UnitestBundleInternalError,
+  type Suite,
+  type SuiteResult,
+  type Test,
+  type TestResult,
+  type TestSuite
+} from './types';
 
 function getNewSuite(name?: string): Suite {
   return {
@@ -14,7 +21,9 @@ function getNewSuite(name?: string): Suite {
  * to collect those Suite Results since none of them will have a parent suite
  */
 export const suiteResults: SuiteResult[] = [];
-let currentSuite: Suite | null = null;
+
+export let currentSuite: Suite | null = null;
+export let currentTest: string | null = null;
 
 function handleErr(err: any) {
   if (err.error && err.error.message) {
@@ -26,42 +35,54 @@ function handleErr(err: any) {
   throw err;
 }
 
-/**
- * Defines a single test.
- * @param name Description for this test.
- * @param func Function containing assertions.
- */
-export function it(name: string, func: Test): void {
+function runTest(name: string, funcName: string, func: Test) {
   if (currentSuite === null) {
-    throw new Error(`'${it.name}' must be called from within a test suite!`);
+    throw new UnitestBundleInternalError(`${funcName} must be called from within a test suite!`);
+  }
+
+  if (currentTest !== null) {
+    throw new UnitestBundleInternalError(`${funcName} cannot be called from within another test!`);
   }
 
   try {
+    currentTest = name;
     func();
     currentSuite.results.push({
       name,
       passed: true,
     });
   } catch (err) {
+    if (err instanceof UnitestBundleInternalError) {
+      throw err;
+    }
+
     const error = handleErr(err);
     currentSuite.results.push({
       name,
       passed: false,
       error,
     });
+  } finally {
+    currentTest = null;
   }
 }
 
+/**
+ * Defines a single test.
+ * @param name Description for this test.
+ * @param func Function containing assertions.
+ */
+export function it(name: string, func: Test): void {
+  runTest(name, it.name, func);
+}
+
 /**
  * Defines a single test.
  * @param msg Description for this test.
  * @param func Function containing assertions.
  */
 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);
+  runTest(msg, test.name, func);
 }
 
 function determinePassCount(results: (TestResult | SuiteResult)[]): number {
@@ -82,7 +103,7 @@ function determinePassCount(results: (TestResult | SuiteResult)[]): number {
  * @param msg Description for this test suite.
  * @param func Function containing tests.
  */
-export function describe(msg: string, func: Test): void {
+export function describe(msg: string, func: TestSuite): void {
   const oldSuite = currentSuite;
   const newSuite = getNewSuite(msg);
 

src/bundles/unittest/src/types.ts

@@ -1,8 +1,3 @@
-export type ErrorLogger = (
-  error: string[] | string,
-  isSlangError?: boolean
-) => void;
-
 /**
  * Represents a function that when called, should either execute successfully
  * or throw an assertion error
@@ -42,12 +37,12 @@ export interface SuiteResult {
   passed: boolean;
 }
 
-export type TestSuccess = {
+export interface TestSuccess {
   passed: true;
   name: string;
 };
 
-export type TestFailure = {
+export interface TestFailure {
   passed: false;
   name: string;
   error: string;
@@ -58,3 +53,10 @@ export type TestResult = TestSuccess | TestFailure;
 export interface UnittestModuleState {
   suiteResults: SuiteResult[];
 }
+
+/**
+ * These errors represent errors that shouldn't be handled as if they were thrown
+ * by the assertion functions
+ */
+export class UnitestBundleInternalError extends Error {
+};