Async

app/javascript/components/bootcamp/SolveExercisePage/hooks/useConstructRunCode/useConstructRunCode.ts

@@ -42,7 +42,7 @@ export function useConstructRunCode({
    * This function is used to run the code in the editor
    */
   const runCode = useCallback(
-    (studentCode: string, editorView: EditorView | null) => {
+    async (studentCode: string, editorView: EditorView | null) => {
       if (!tasks) {
         console.error('tasks are missing in useRunCode')
         return
@@ -87,7 +87,7 @@ export function useConstructRunCode({
         return
       }
 
-      const testResults = generateAndRunTestSuite({
+      const testResults = await generateAndRunTestSuite({
         studentCode,
         tasks,
         config,

app/javascript/components/bootcamp/SolveExercisePage/test-runner/generateAndRunTestSuite/execProjectTest.ts

@@ -6,9 +6,13 @@ import { generateExpects } from './generateExpects'
 import { TestRunnerOptions } from '@/components/bootcamp/types/TestRunner'
 import { filteredStdLibFunctions } from '@/interpreter/stdlib'
 
-/**
- This is of type TestCallback
- */
+export function execProjectTestAsync(
+  project: Project,
+  testData: TaskTest,
+  options: TestRunnerOptions
+) {
+  return Promise.resolve(execProjectTest(project, testData, options))
+}
 export function execProjectTest(
   Project: Project,
   testData: TaskTest,

app/javascript/components/bootcamp/SolveExercisePage/test-runner/generateAndRunTestSuite/generateAndRunTestSuite.ts

@@ -2,42 +2,46 @@ import { describe } from '..'
 import exerciseMap, {
   type Project,
 } from '@/components/bootcamp/SolveExercisePage/utils/exerciseMap'
-import { execProjectTest } from './execProjectTest'
+import { execProjectTest, execProjectTestAsync } from './execProjectTest'
 import { execGenericTest } from './execGenericTest'
 import { type TestRunnerOptions } from '@/components/bootcamp/types/TestRunner'
 
 export default (options: TestRunnerOptions) => {
-  return describe(options.config.title, (test) => {
+  return describe(options.config.title, async (test) => {
     let project: Project | null = null
     if (options.config.projectType) {
       project = exerciseMap.get(options.config.projectType)
     }
-    options.tasks.map((taskData) => {
-      taskData.tests.map((testData) => {
-        test(testData.name, () => {
-          let result: ReturnType<TestCallback>
-          if (project) {
-            result = execProjectTest(project, testData, options)
-          } else {
-            result = execGenericTest(testData, options)
-          }
+    await mapTasks(test, options, project)
+  })
+}
 
-          const { frames } = result
-          let { expects } = result
+const mapTasks = async (test, options, project) => {
+  options.tasks.map((taskData) => {
+    taskData.tests.map((testData) => {
+      test(testData.name, async () => {
+        let result: ReturnType<TestCallback>
+        if (project) {
+          result = await execProjectTestAsync(project, testData, options)
+        } else {
+          result = execGenericTest(testData, options)
+        }
 
-          // make sure a test is only successful if all frames are successful
-          expects.push({
-            actual: 'running',
-            errorHtml: 'Your code has an error in it.',
-            name: 'Code passes',
-            expected: true,
-            pass: frames.every((frame) => frame.status === 'SUCCESS'),
-            slug: 'code-passes',
-            testsType: 'state',
-          })
+        const { frames } = result
+        let { expects } = result
 
-          return { ...result, expects }
+        // make sure a test is only successful if all frames are successful
+        expects.push({
+          actual: 'running',
+          errorHtml: 'Your code has an error in it.',
+          name: 'Code passes',
+          expected: true,
+          pass: frames.every((frame) => frame.status === 'SUCCESS'),
+          slug: 'code-passes',
+          testsType: 'state',
         })
+
+        return { ...result, expects }
       })
     })
   })

app/javascript/components/bootcamp/SolveExercisePage/test-runner/index.ts

@@ -1,16 +1,16 @@
-export function describe(
+export async function describe(
   suiteName: string,
   callback: (
     test: (testName: string, testCallback: TestCallback) => void
-  ) => void
-): TestSuiteResult<NewTestResult> {
+  ) => Promise<void>
+): Promise<TestSuiteResult<NewTestResult>> {
   // test results are collected in one shared array
   const tests: NewTestResult[] = []
 
   const test = createTestCallback(tests)
 
   // invokes the test callbacks, which mutate the tests array by pushing the new results to it
-  callback(test)
+  await callback(test)
 
   return {
     suiteName: suiteName,
@@ -20,8 +20,9 @@ export function describe(
 }
 
 function createTestCallback(tests: NewTestResult[]) {
-  return function (testName: string, testCallback: TestCallback): void {
-    const testCallbackResult = testCallback()
+  return async function (testName: string, testCallback: TestCallback): void {
+    const testCallbackResult = await testCallback()
+    console.log(testCallbackResult)
     tests.push({
       // we need testIndex, so we can retrieve quickly the test that we are currently inspecting/working on
       testIndex: tests.length,