@sun-asterisk/sungen 3.2.31 → 3.2.33

package/src/orchestrator/templates/specs-mock.ts

@@ -25,7 +25,8 @@ export interface MockConfig {
   name: string;
   method: string;               // HTTP verb or '*'
   url: string;                  // page.route glob, or 're:<pattern>' for a regex
-  status: number;
+  status?: number;              // the server ANSWERED — absent exactly when `abort` is set
+  abort?: string;               // the request NEVER ARRIVED — a route.abort() errorCode
   headers?: Record<string, string>;
   body?: string;                // pre-serialized by the compiler (JSON string)
   delay_ms?: number;
@@ -104,9 +105,16 @@ class MockRouter {
       if (cfg.method !== '*' && route.request().method() !== cfg.method) return route.fallback();
       st.counts.set(cfg.name, (st.counts.get(cfg.name) ?? 0) + 1);
       if (cfg.delay_ms) await new Promise((r) => setTimeout(r, cfg.delay_ms));
-      // A delayed fulfill can race a page close / reset at teardown — that race must
-      // not surface as an unhandled rejection from inside a route handler.
-      try { await route.fulfill({ status: cfg.status, headers: cfg.headers, body: cfg.body }); } catch { /* page closing */ }
+      // A delayed response can race a page close / reset at teardown — that race must
+      // not surface as an unhandled rejection from inside a route handler. It wraps BOTH
+      // outcomes: an abort races teardown exactly like a fulfill does.
+      try {
+        // `abort` is the request that never reaches the server; `status` is the one the
+        // server answered. The catalog refuses an entry carrying both, so this is a real
+        // either/or, not a precedence rule (#676).
+        if (cfg.abort) await route.abort(cfg.abort);
+        else await route.fulfill({ status: cfg.status, headers: cfg.headers, body: cfg.body });
+      } catch { /* page closing */ }
     };
     await page.route(pattern, handler);
     st.routes.push({ pattern, handler });

package/src/orchestrator/templates/specs-url-assert.ts

@@ -46,6 +46,16 @@ export interface UrlExpectation {
   declared?: string;
   /** The test-data key behind `declared`, so a failure can name what an author must go fix. */
   dataRef?: string;
+  /**
+   * The page selector declared `query: any` — the query string is not part of this page's identity,
+   * so SILENCE from the step stops meaning "there must be no query" (#748).
+   *
+   * Emitted only for a page whose entry says so. The default stays strict: a bare page means a bare
+   * page, which is the #464 assertion and the reason a filter regression cannot read as green.
+   * It is the no-`dataRef` branch alone that this relaxes — a step that declares `with {{v}}` still
+   * asserts every param it names, on this page as on any other.
+   */
+  ignoreQuery?: boolean;
 }
 
 /**
@@ -113,8 +123,14 @@ function locationMatches(pathname: RegExp, hostname: RegExp | undefined, u: URL)
  *                      tracking/UTM param the test never cared about cannot turn it red.
  *                      A declared fragment is asserted too; a declared value carrying no query
  *                      at all constrains the path only (the compiler warns: SG-W014).
+ *
+ * `query: any` on the page's selector entry overrides the FIRST rule only (#748): silence then
+ * means "the query is not mine to judge" instead of "there must be none". It is the escape hatch
+ * for a page whose query is generated at run time — `/admins/detail?id=<the row just clicked>` —
+ * which the strict rule makes unassertable and `with {{v}}` cannot express, since that asserts a
+ * literal. The second rule is untouched: declare params and they are still all checked.
  */
-export function urlMatches({ pathname, hostname, declared, dataRef }: UrlExpectation): (u: URL) => boolean {
+export function urlMatches({ pathname, hostname, declared, dataRef, ignoreQuery }: UrlExpectation): (u: URL) => boolean {
   return (u: URL): boolean => {
     if (!locationMatches(pathname, hostname, u)) return false;
 
@@ -123,7 +139,13 @@ export function urlMatches({ pathname, hostname, declared, dataRef }: UrlExpecta
     // undefined, and they mean opposite things: the first is a real assertion (a bare page must be
     // bare), the second is broken test-data. Only the generator knows which, and it says so by
     // emitting `dataRef` exactly when the step carried a `with {{v}}`.
-    if (!dataRef) return u.search === '';
+    // `query: any` on the page entry (#748): the query is not part of this page's identity, so
+    // silence from the step is not an assertion about it. Without this there is NO way to express
+    // "this path, whatever the query" — `with {{v}}` asserts a LITERAL value, and a detail page
+    // keyed by `?id=<the row just clicked>` has no literal to declare. Checked before the bare-page
+    // rule, never instead of the declared-value rule below: a step that names params still asserts
+    // them here exactly as anywhere else.
+    if (!dataRef) return ignoreQuery ? true : u.search === '';
 
     // Silence is the whole bug class this assertion exists to kill, so an unusable declared value
     // is an ERROR, not a quiet verdict. Returning false would read as "the app is wrong"; these

package/src/orchestrator/templates/wdio.conf.ts

@@ -48,6 +48,14 @@ function evidenceSlug(s: string): string {
     .slice(0, 80) || 'unnamed';
 }
 
+/**
+ * True only in the launcher process. `@wdio/runner` re-parses this very config inside EVERY worker
+ * it spawns, so anything logged at module scope prints once per spec unless it is gated. WDIO's own
+ * "am I a worker" test is this env var (`@wdio/local-runner` sets it when spawning; `@wdio/utils`
+ * reads it) — reuse it rather than inventing a second signal.
+ */
+const IS_LAUNCHER = !process.env.WDIO_WORKER_ID;
+
 /**
  * Auto-select MOBILE specs and classify each by its target OS (dual-target routing).
  *
@@ -82,7 +90,12 @@ function classifyMobileSpecs(root: string): Array<{ file: string; platform: stri
     .filter((full) => {
       try {
         return fs.readFileSync(full, 'utf-8').includes('@wdio/globals');
-      } catch {
+      } catch (e) {
+        // A spec listed by readdir that cannot be read cannot be classified, so it is excluded.
+        // Excluding it SILENTLY is the fault: WDIO only fails the run when the spec list is
+        // EMPTY ("No specs found to run"), so dropping one spec out of ten leaves a green suite
+        // containing a test that never executed. Name it, and let the count below show the shortfall.
+        if (IS_LAUNCHER) console.warn(`[sungen] could not read ${full} — EXCLUDED from this run: ${(e as Error).message}`);
         return false;
       }
     })
@@ -98,6 +111,16 @@ const androidSpecs = specEntries.filter((e) => e.platform !== 'ios').map((e) =>
 const iosSpecs = specEntries.filter((e) => e.platform !== 'android').map((e) => e.file);
 const mobileSpecs = specEntries.map((e) => e.file); // union — top-level fallback
 
+// What DISCOVERY found — a mobile suite is only trustworthy if you can see how many specs it
+// resolved: WDIO fails loudly on an EMPTY list but says nothing when the list is merely short,
+// which is exactly what a dropped spec looks like.
+//
+// Two things this number is not. It is not an error on 0: WDIO already exits 1 there
+// ("No specs found to run"), and a `--shard` that legitimately receives none must still return 0.
+// And under `--shard` it is the PRE-SHARD total, because ConfigParser slices `specs` down to the
+// shard's portion only after this file has finished evaluating.
+if (IS_LAUNCHER) console.log(`[sungen] specs: ${specEntries.length} mobile spec(s) — android ${androidSpecs.length}, ios ${iosSpecs.length}`);
+
 // App under test — env overrides the init-configured defaults.
 const APP_PACKAGE = process.env.APP_PACKAGE || '__APP_PACKAGE__';
 const APP_ACTIVITY = process.env.APP_ACTIVITY || '__APP_ACTIVITY__';