@specific.dev/spectest 0.126.0 → 0.128.0

package/src/index.ts

@@ -6,7 +6,7 @@ import type { InjectRule, SignConfig } from "./fake-upstream.js";
 export type { InjectRule, InjectMatch, StringMatch, SignConfig, AwsSigV4Sign } from "./fake-upstream.js";
 export type { Phone, PhoneOptions, CallOptions, SpeechOptions } from "./phone.js";
 import type { Phone, PhoneOptions } from "./phone.js";
-import type { Android, AndroidApp } from "./android.js";
+import { ANDROID_ASSERT, type Android, type AndroidApp, type AndroidElement, type AndroidMatcher } from "./android.js";
 import { resolveEntrypoints, type InteractiveEntrypoint, type InteractiveEntrypoints } from "./interactive.js";
 export type { InteractiveEntrypoint, InteractiveEntrypoints } from "./interactive.js";
 export type { Android, AndroidApp, AndroidElement, AndroidRecordingOptions } from "./android.js";
@@ -175,7 +175,7 @@ export {
   type CoverageLoadContext,
   type ServiceCoverage,
 } from "./coverage.js";
-import { applyCoverageAdapters, validateCoverage, type ServiceCoverage } from "./coverage.js";
+import { applyCoverageAdapters, coverageAdapters, validateCoverage, type ServiceCoverage } from "./coverage.js";
 import { resolveExistingProjectPath } from "./project-files.js";
 export { ca } from "./environment-ca.js";
 
@@ -1138,6 +1138,15 @@ function expandServiceGroups(input: InputServicesMap): ServicesMap {
       // Rewrite relative dependsOn to final keys; a spread keeps function
       // fields (helpers/setup) and the enumerable-symbol ingress decls.
       const final: ServiceConfig = { ...svc, ...(part === entry.primary ? primaryOverrides : {}) };
+      // Component-owned nested containers keep their collection when callers
+      // add ordinary service coverage (for example browser coverage on k3s).
+      const collectors = coverageAdapters(svc.coverage).filter(adapter => adapter.collect);
+      if (part === entry.primary && collectors.length && primaryOverrides.coverage !== undefined) {
+        const extra = primaryOverrides.coverage;
+        final.coverage = { ...(typeof extra === "object" ? extra : {}), adapters: [
+          ...collectors, ...coverageAdapters(extra).filter(adapter => !collectors.includes(adapter)),
+        ] };
+      }
       if (final.dependsOn?.length) {
         final.dependsOn = final.dependsOn.map((d) =>
           partKeys.has(d) ? naming.key(d) : d,
@@ -3030,18 +3039,49 @@ export interface BrowserAssertion extends BrowserMatchers {
 // `expect(value)` the synchronous value matchers. The two object overloads are
 // listed first so they win over `Provenanced` (neither has `unwrap`); a
 // Locator and a Browser are structurally disjoint, so their order is free.
+export function expect(actual: AndroidElement, message?: string): AndroidAssertion;
 export function expect(actual: Locator, message?: string): LocatorAssertion;
 export function expect(actual: Browser, message?: string): BrowserAssertion;
 export function expect(actual: Provenanced, message?: string): Expectation;
 export function expect(
-  actual: Provenanced | Locator | Browser,
+  actual: Provenanced | Locator | Browser | AndroidElement,
   message?: string,
-): Expectation | LocatorAssertion | BrowserAssertion {
+): Expectation | LocatorAssertion | BrowserAssertion | AndroidAssertion {
+  if (actual && typeof actual === "object" && ANDROID_ASSERT in actual) return buildAndroidAssertion(actual as AndroidElement, message);
   if (isLocator(actual)) return buildLocatorAssertion(actual, message);
   if (isBrowserSession(actual)) return buildBrowserAssertion(actual, message);
   return expectValue(actual as Provenanced, message);
 }
 
+/** Retrying native Android assertions. Timeout is in milliseconds (default 10 s;
+ * zero performs one observation). Each assertion records one Android step. */
+export interface AndroidMatchers {
+  toBeVisible(options?: { timeout?: number }): Promise<void>;
+  toBeHidden(options?: { timeout?: number }): Promise<void>;
+  toHaveText(expected: string | RegExp, options?: { timeout?: number }): Promise<void>;
+  toContainText(expected: string | RegExp, options?: { timeout?: number }): Promise<void>;
+}
+export interface AndroidAssertion extends AndroidMatchers { not: AndroidMatchers }
+function buildAndroidAssertion(element: AndroidElement, message?: string): AndroidAssertion {
+  const matchers = (negated: boolean): AndroidMatchers => {
+    const run = async (matcher: AndroidMatcher, expected?: string | RegExp, timeout?: number) => {
+      const result = await element[ANDROID_ASSERT](matcher, negated, expected, timeout);
+      const error = result.error === undefined ? undefined : new ExpectationError(String(result.error));
+      if (error) error.cause = result.error;
+      recordAssertion({ matcher, negated, passed: !error, message, sourceSeq: result.sourceSeq,
+        actual: safeSerialize(result.actual), expected: expected === undefined ? undefined : safeSerialize(assertionExpected(expected)), error: error?.message });
+      if (error) throw error;
+    };
+    return {
+      toBeVisible: options => run("toBeVisible", undefined, options?.timeout),
+      toBeHidden: options => run("toBeHidden", undefined, options?.timeout),
+      toHaveText: (expected, options) => run("toHaveText", expected, options?.timeout),
+      toContainText: (expected, options) => run("toContainText", expected, options?.timeout),
+    };
+  };
+  return Object.assign(matchers(false), { not: matchers(true) });
+}
+
 function expectValue(actual: Provenanced, message?: string): Expectation {
   // The first parameter is typed to the {@link Provenanced} family so a raw
   // value (`expect(res.status === 200)`, `expect(2 + 2)`) is a *compile error* —