favor: restore test running

Author: sparecycles

packages/core/src/entry/testing/cli/index.ts

@@ -112,6 +112,7 @@ async function main() {
   }
 
   const { cases, patterns, antipatterns } = await testplanner(
+    environment,
     parseSmokeConfig(smoke),
     ...positionals,
   );
@@ -154,11 +155,11 @@ No testcases were specified!
     console.info(
       `${testplan
         .map(
-          ({ testcase, environment }) =>
+          ({ testcase, testenv }) =>
             `${testcase}${
               plan || verbose
                 ? `\n` +
-                  JSON.stringify(environment, null, 2)
+                  JSON.stringify(testenv, null, 2)
                     .split("\n")
                     .slice(1, -1)
                     .join("\n") +

packages/core/src/entry/testing/cli/runner.ts

@@ -54,7 +54,7 @@ declare global {
 export type TestSetup = {
   test: () => Promise<void>;
   testcase: string;
-  environment: Record<string, unknown>;
+  testenv: Record<string, unknown>;
 };
 
 const inflight = new AsyncLocalStorage<{
@@ -111,11 +111,7 @@ ${failing.map(({ testcase }) => `${testcase}: FAIL\n`).join("")}
 
 export async function executeSelectedTests(
   configuration: PardonTestConfiguration,
-  selectedTests: {
-    test: () => Promise<void>;
-    testcase: string;
-    environment: Record<string, unknown>;
-  }[],
+  selectedTests: TestSetup[],
   report: string,
   ff: boolean | undefined,
 ) {
@@ -136,7 +132,7 @@ export async function executeSelectedTests(
 
   const testResults = await all_disconnected(
     selectedTests.map(
-      async ({ test, testcase, environment: { ...testenv } }) =>
+      async ({ test, testcase, testenv: { ...testenv } }) =>
         await concurrently(() =>
           /*
            * `concurrently(() => disconnected(...))`
@@ -665,9 +661,7 @@ export async function loadTests(
   const trialRegistry = await flushTrialRegistry(configuration);
 
   return {
-    testplanner: async (smokeConfig?: SmokeConfig, ...filter: string[]) => {
-      const testenv = { ...environment };
-
+    async testplanner(testenv: Record<string, unknown>, smokeConfig?: SmokeConfig, ...filter: string[]) {
       const alltestcases = describeCases(
         configuration.closing || (() => {}),
         trialRegistry.flatMap(({ descriptions }) => {
@@ -693,13 +687,13 @@ export async function loadTests(
           environment: {
             testcase,
             "::testexecution": testexecution,
-            ...environment
+            ...testenv
           },
         }) =>
           ({
-            test: () => testexecution(environment),
+            test: () => testexecution(testenv),
             testcase,
-            environment,
+            testenv,
           }) as TestSetup,
       );
 

packages/favor/electron/pardon-worker.ts

@@ -58,16 +58,16 @@ const currentHttpSequence = new AsyncLocalStorage<{
   values: Record<string, unknown>;
 }>();
 
-type TestSetup = ReturnType<
+type TestSetup = Awaited<ReturnType<
   Awaited<ReturnType<typeof loadTests>>["testplanner"]
->[number];
+>>["cases"][number];
 
 export type TestStepPayloads = {
   "test:run:start": {
     id: "test:event";
     type: "test:run:start";
     run: TestRunId;
-    tests: Pick<TestSetup, "testcase" | "environment">[];
+    tests: Pick<TestSetup, "testcase" | "testenv">[];
     input: string;
   };
   "test:case:start": {
@@ -593,9 +593,8 @@ const handlers = {
     { smoke, filter }: { smoke?: SmokeConfig; filter?: string[] },
   ) {
     const { testing } = await ready;
-    return (await testing)
-      ?.testplanner(environment, smoke, ...(filter || []))
-      ?.map(({ environment, testcase }) => ({ environment, testcase }));
+    const testplan = await (await testing)?.testplanner(environment, smoke, ...(filter || []));
+    return testplan.cases.map(({ testenv, testcase }) => ({ testenv, testcase }));
   },
   async executeTestcases(
     testenv: Record<string, unknown>,
@@ -607,18 +606,20 @@ const handlers = {
   ) {
     const testRun: TestRunId = `T${nextTestRunId++}`;
     const { testing } = await ready;
-    const tests = (await testing)?.testplanner(
+    const testplan = await (await testing)?.testplanner(
       testenv,
       undefined,
       ...testcases,
     );
 
+    const tests = (await testplan)?.cases;
+
     parentPort!.postMessage(
       ship({
         id: "test:event",
         type: "test:run:start",
         run: testRun,
-        tests: tests,
+        tests,
         input,
       }) satisfies TestStepPayloads["test:run:start"],
     );

packages/favor/package-lock.json

@@ -26,7 +26,7 @@ export function InfoDrawer(
     side?: Parameters<typeof Drawer>[0]["side"];
     "no-close-button"?: boolean;
   },
-) {
+): JSX.Element {
   const [ourProps, contentProps] = splitProps(props, [
     "side",
     "children",

packages/favor/src/components/InfoDrawer.tsx

@@ -225,7 +225,7 @@ export default function TestcaseSystem(props: {
                             class="flex max-h-[80%] flex-col bg-lime-300 dark:bg-lime-700"
                             content={
                               <div class="flex flex-initial flex-col overflow-auto">
-                                <KeyValueCopier data={item.environment} />
+                                <KeyValueCopier data={item.testenv} />
                               </div>
                             }
                           >
@@ -380,7 +380,7 @@ function compileTestReport(events: TestEventType[]) {
       events: TestEventType[];
       sequences: TestSequenceRecord[];
       input: string;
-      tests: { testcase: string; environment: Record<string, unknown> }[];
+      tests: { testcase: string; testenv: Record<string, unknown> }[]; // Pick<TestSetup, "testcase" | "testenv">[]
       testcases: Record<
         string,
         {