ci: Add Firefox testing for host

.github/workflows/ci-host.yaml

@@ -18,10 +18,13 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        shardIndex: [1, 2, 3, 4, 5, 6]
-        shardTotal: [6]
+        browser: ["Chrome", "Firefox"]
+        shardIndex: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        shardTotal: [10]
+    env:
+      TESTEM_BROWSER: ${{ matrix.browser }}
     concurrency:
-      group: boxel-host-test${{ github.head_ref || github.run_id }}-shard${{ matrix.shardIndex }}
+      group: boxel-host-test-${{ matrix.browser }}-${{ github.head_ref || github.run_id }}-shard${{ matrix.shardIndex }}
       cancel-in-progress: true
     steps:
       - uses: actions/checkout@v4
@@ -43,19 +46,20 @@ jobs:
       - name: create realm users
         run: pnpm register-realm-users
         working-directory: packages/matrix
+      # FIXME restore PErcy
       - name: host test suite (shard ${{ matrix.shardIndex }})
-        run: pnpm test-with-percy
+        run: pnpm test
         env:
-          PERCY_TOKEN: ${{ secrets.PERCY_TOKEN_HOST }}
-          PERCY_PARALLEL_NONCE: ${{ github.run_id }}-${{ github.run_attempt }}
+          # PERCY_TOKEN: ${{ secrets.PERCY_TOKEN_HOST }}
+          # PERCY_PARALLEL_NONCE: ${{ github.run_id }}-${{ github.run_attempt }}
           HOST_TEST_PARTITION: ${{ matrix.shardIndex }}
           HOST_TEST_PARTITION_COUNT: ${{ matrix.shardTotal }}
         working-directory: packages/host
       - name: Upload junit report to GitHub Actions Artifacts
         uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: host-test-report-${{ matrix.shardIndex }}
+          name: host-test-report-${{ matrix.browser }}-${{ matrix.shardIndex }}
           path: junit/host-${{ matrix.shardIndex }}.xml
           retention-days: 30
 
@@ -64,23 +68,28 @@ jobs:
     if: always()
     needs: host-test
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        browser: ["Chrome", "Firefox"]
 
     steps:
       - uses: actions/checkout@v4
       - uses: ./.github/actions/init
 
-      - name: Finalise Percy
-        run: npx percy build:finalize
-        working-directory: packages/host
-        env:
-          PERCY_TOKEN: ${{ secrets.PERCY_TOKEN_HOST }}
-          PERCY_PARALLEL_NONCE: ${{ github.run_id }}-${{ github.run_attempt }}
+      # FIXME restore Percy
+      # - name: Finalise Percy
+      #   run: npx percy build:finalize
+      #   working-directory: packages/host
+      #   env:
+      #     PERCY_TOKEN: ${{ secrets.PERCY_TOKEN_HOST }}
+      #     PERCY_PARALLEL_NONCE: ${{ github.run_id }}-${{ github.run_attempt }}
 
       - name: Download JUnit reports from GitHub Actions Artifacts
         uses: actions/download-artifact@v4
         with:
           path: all-host-reports
-          pattern: host-test-report-*
+          pattern: host-test-report-${{ matrix.browser }}-*
           merge-multiple: true
 
       - run: ls
@@ -93,7 +102,7 @@ jobs:
         uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: host-test-report-merged
+          name: host-test-report-merged-${{ matrix.browser }}
           path: host.xml
           retention-days: 30
 
@@ -102,4 +111,4 @@ jobs:
         if: always()
         with:
           junit_files: host.xml
-          check_name: Host Test Results
+          check_name: Host Test Results (${{ matrix.browser }})

package.json

@@ -38,8 +38,7 @@
       "style-loader@2.0.0": "patches/style-loader@2.0.0.patch",
       "ember-css-url@1.0.0": "patches/ember-css-url@1.0.0.patch",
       "matrix-js-sdk@31.0.0": "patches/matrix-js-sdk@31.0.0.patch",
-      "ember-basic-dropdown@8.0.4": "patches/ember-basic-dropdown@8.0.4.patch",
-      "ember-source@5.4.1": "patches/ember-source@5.4.1.patch"
+      "ember-basic-dropdown@8.0.4": "patches/ember-basic-dropdown@8.0.4.patch"
     }
   },
   "devDependencies": {

packages/host/app/lib/sqlite-adapter.ts

@@ -10,6 +10,8 @@ import {
   Deferred,
 } from '@cardstack/runtime-common';
 
+import { time } from '@cardstack/runtime-common/helpers/time';
+
 export default class SQLiteAdapter implements DBAdapter {
   private _sqlite: typeof SQLiteWorker | undefined;
   private _dbId: string | undefined;
@@ -98,7 +100,8 @@ export default class SQLiteAdapter implements DBAdapter {
 
   private async internalExecute(sql: string, opts?: ExecuteOptions) {
     sql = this.adjustSQL(sql);
-    return await this.query(sql, opts);
+
+    return await time('sql', this.query(sql, opts));
   }
 
   async close() {

packages/host/config/fastboot.js

@@ -16,6 +16,7 @@ module.exports = function () {
         Request: globalThis.Request,
         fetch: globalThis.fetch,
         btoa,
+        performance: globalThis.performance,
       });
     },
   };

packages/host/testem.js

@@ -8,7 +8,7 @@ const fs = require('fs');
 const config = {
   test_page: 'tests/index.html?hidepassed',
   disable_watching: true,
-  launch_in_ci: ['Chrome'],
+  launch_in_ci: [process.env.TESTEM_BROWSER || 'Chrome'],
   launch_in_dev: ['Chrome'],
   browser_start_timeout: 120,
   browser_args: {
@@ -24,6 +24,7 @@ const config = {
         '--window-size=1440,900',
       ].filter(Boolean),
     },
+    Firefox: ['--headless', '--width=1440', '--height=900'],
   },
 };
 

packages/host/tests/helpers/visit-operator-mode.ts

@@ -2,6 +2,8 @@ import { visit, waitFor } from '@ember/test-helpers';
 
 import stringify from 'safe-stable-stringify';
 
+import { time } from '@cardstack/runtime-common/helpers/time';
+
 import { SerializedState } from '@cardstack/host/services/operator-mode-state-service';
 
 export default async function visitOperatorMode({
@@ -21,12 +23,17 @@ export default async function visitOperatorMode({
 
   let operatorModeStateParam = stringify(operatorModeState)!;
 
-  await visit(
-    `/?operatorModeEnabled=true&operatorModeState=${encodeURIComponent(
-      operatorModeStateParam,
-    )}`,
-  );
+  await time('visitOperatorMode:visit', async () => {
+    return await visit(
+      `/?operatorModeEnabled=true&operatorModeState=${encodeURIComponent(
+        operatorModeStateParam,
+      )}`,
+    );
+  });
+
   if (stacks && stacks.length > 0 && (!submode || submode === 'interact')) {
-    await waitFor('[data-test-operator-mode-stack]');
+    await time('visitOperatorMode:waitFor', async () => {
+      return await waitFor('[data-test-operator-mode-stack]');
+    });
   }
 }

packages/host/tests/test-helper.js

@@ -2,10 +2,69 @@ import Application from '@cardstack/host/app';
 import config from '@cardstack/host/config/environment';
 import * as QUnit from 'qunit';
 import { setApplication } from '@ember/test-helpers';
+import { logger } from '@cardstack/runtime-common';
 import { setup } from 'qunit-dom';
+import { getTimes } from '@cardstack/runtime-common/helpers/time';
+
 import setupOperatorModeParametersMatchAssertion from '@cardstack/host/tests/helpers/operator-mode-parameters-match';
 import start from 'ember-exam/test-support/start';
 
+const log = logger('current-run');
+
+console.log('Setting Qunit hooks?');
+
+log.error('Setting Qunit hooks?');
+
+QUnit.on('runStart', () => {
+  log.error('Starting tests abcdefghijklmnopqrstuvwxyz');
+});
+
+QUnit.on('suiteEnd', (suiteEnd) => {
+  console.log(`Done tests for ${suiteEnd.name}`);
+
+  let times = getTimes();
+
+  [...times.keys()].forEach((key) => {
+    log.error(`${key}: ${times.get(key)}`);
+  });
+  log.error(JSON.stringify(Array.from(times.entries())));
+
+  log.error('that is all');
+});
+
+QUnit.on('runEnd', () => {
+  console.log('Done all tests');
+
+  let times = getTimes();
+
+  [...times.keys()].forEach((key) => {
+    log.error(`${key}: ${times.get(key)}`);
+  });
+  log.error(JSON.stringify(Array.from(times.entries())));
+
+  log.error('that is all');
+});
+
+QUnit.done(async () => {
+  console.log('Done all tests?? again');
+
+  let times = getTimes();
+
+  [...times.keys()].forEach((key) => {
+    log.error(`${key}: ${times.get(key)}`);
+  });
+
+  log.error('that is all…?');
+
+  return new Promise((resolve) => {
+    log.error('waiting for logs to flush');
+    setTimeout(() => {
+      log.error('logs flushed?');
+      resolve();
+    }, 5000);
+  });
+});
+
 setApplication(Application.create(config.APP));
 
 setup(QUnit.assert);

packages/runtime-common/helpers/time.ts

@@ -0,0 +1,49 @@
+let labelToTime = new Map<string, number>();
+let labelToStartTime = new Map<string, number>();
+
+export async function time(
+  label: string,
+  promiseOrFunction: Promise<any> | (() => Promise<any>) | (() => any),
+) {
+  let now = performance.now();
+
+  let result;
+  try {
+    if (typeof promiseOrFunction === 'function') {
+      result = await promiseOrFunction();
+    } else {
+      result = await promiseOrFunction;
+    }
+  } finally {
+    let diff = performance.now() - now;
+    let lastTime = labelToTime.get(label) || 0;
+    labelToTime.set(label, lastTime + diff);
+
+    return result;
+  }
+}
+
+export async function timeStart(label: string) {
+  labelToStartTime.set(label, performance.now());
+}
+
+export async function timeEnd(label: string) {
+  let now = performance.now();
+  let startTime = labelToStartTime.get(label);
+  if (startTime === undefined) {
+    console.error(`No start time found for label ${label}`);
+    return NaN;
+  }
+
+  let diff = now - startTime;
+  let lastTime = labelToTime.get(label) || 0;
+  labelToTime.set(label, lastTime + diff);
+
+  labelToStartTime.delete(label);
+
+  return diff;
+}
+
+export function getTimes() {
+  return labelToTime;
+}

packages/runtime-common/virtual-network.ts

@@ -8,6 +8,7 @@ import { simulateNetworkBehaviors } from './fetcher';
 export interface ResponseWithNodeStream extends Response {
   nodeStream?: Readable;
 }
+import { time } from './helpers/time';
 
 export type Handler = (req: Request) => Promise<ResponseWithNodeStream | null>;
 
@@ -134,10 +135,14 @@ export class VirtualNetwork {
     request: Request,
     direction: 'virtual-to-real' | 'real-to-virtual',
   ) {
-    let remappedUrl = this.resolveURLMapping(request.url, direction);
+    let remappedUrl = await time('mapRequest:resolveURLMapping', () =>
+      this.resolveURLMapping(request.url, direction),
+    );
 
     if (remappedUrl) {
-      return await buildRequest(remappedUrl, request);
+      return await time('mapRequest:buildRequest', () =>
+        buildRequest(remappedUrl, request),
+      );
     } else {
       return request;
     }