feat: handle simple python tests (#398)

Simple meaning that it's not in the object form. i.e. not `{ test: () =>
{ // code } }`, but simply `// code`

Author: ojeytonwilliams

packages/python-evaluator/src/python-test-evaluator.ts

@@ -97,18 +97,54 @@ class PythonTestEvaluator implements TestEvaluator {
               const test: unknown = eval(testString);
               resolve(test);
             } catch (err) {
-              if (
+              const isUsingTopLevelAwait =
                 err instanceof SyntaxError &&
                 err.message.includes(
                   "await is only valid in async functions and the top level bodies of modules",
-                )
-              ) {
+                );
+
+              if (isUsingTopLevelAwait) {
                 const iifeTest = createAsyncIife(testString);
 
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
                 eval(iifeTest).then(resolve).catch(reject);
               } else {
-                reject(err as Error);
+                // The assumption is that if we're in this block, then the test
+                // is EITHER a standard JS test (in which case it should reject)
+                // OR a Python test that uses the `input()` function (in which case
+                // we need to fake the input function).
+
+                // While supporting both `{ test: () => { // test code } }` and
+                // `// test code /` we have to fake input before running the
+                // test. Otherwise any user code that uses `input()` will throw
+                // an error.
+                runPython(`
+def __fake_input(arg=None):
+  return ""
+
+input = __fake_input
+  `);
+
+                // Evaluates the learner's code so that any variables they
+                // define are available to the test.
+                try {
+                  // It looks the source might be evaluated twice, but they're
+                  // on separate branches.
+                  runPython(opts.source ?? "");
+                } catch (sourceErr) {
+                  // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                  reject(sourceErr);
+                  return;
+                }
+
+                try {
+                  eval(testString);
+                } catch (testErr) {
+                  // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                  reject(testErr);
+                }
+
+                resolve(undefined);
               }
             }
           },

packages/tests/integration-tests/index.test.ts

@@ -1448,5 +1448,43 @@ pattern = re.compile('l+')`;
         },
       });
     });
+
+    it("should support runPython in simple tests", async () => {
+      const result = await page.evaluate(async () => {
+        const runner = await window.FCCTestRunner.createTestRunner({
+          type: "python",
+        });
+        return runner?.runTest(`assert.equal(runPython('1 + 1'), 2)`);
+      });
+      expect(result).toEqual({ pass: true });
+    });
+
+    it("should evaluate user code before running tests", async () => {
+      const result = await page.evaluate(async () => {
+        const runner = await window.FCCTestRunner.createTestRunner({
+          type: "python",
+          source: "x = 3",
+        });
+        return runner?.runTest(`assert.equal(runPython('x + 1'), 5)`);
+      });
+
+      expect(result).toMatchObject({
+        err: {
+          actual: 4,
+          expected: 5,
+        },
+      });
+    });
+
+    it("should use a fake input function in simple tests", async () => {
+      const result = await page.evaluate(async () => {
+        const runner = await window.FCCTestRunner.createTestRunner({
+          type: "python",
+        });
+        return runner?.runTest(`assert.equal(runPython('input("test")'), "")`);
+      });
+
+      expect(result).toEqual({ pass: true });
+    });
   });
 });