@supatest/wdio-appium-reporter 0.0.2 → 0.0.3

package/dist/index.cjs

@@ -6534,6 +6534,8 @@ var AttachmentUploader = class {
 var import_reporter = __toESM(require("@wdio/reporter"));
 var VIDEO_WAIT_TIMEOUT_MS = 6e4;
 var VIDEO_POLL_INTERVAL_MS = 1e3;
+var COORDINATOR_LOCK_TIMEOUT_MS = 1e4;
+var COORDINATOR_LOCK_POLL_MS = 50;
 var SupatestAppiumReporter = class extends import_reporter.default {
   reporterOptions;
   client;
@@ -6564,6 +6566,9 @@ var SupatestAppiumReporter = class extends import_reporter.default {
   runCompletePromise;
   runComplete = false;
   unregisterInterruptHandler;
+  coordinatorPath;
+  currentSpecKey = "unknown";
+  expectedSpecs = [];
   testsForVideoUpload = [];
   // biome-ignore lint/suspicious/noExplicitAny: WDIOReporter options type is overly strict; we need to inject writeStream default
   constructor(options) {
@@ -6582,7 +6587,8 @@ var SupatestAppiumReporter = class extends import_reporter.default {
       timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
       dryRun: options.dryRun ?? process.env.SUPATEST_DRY_RUN === "true",
       screenshotDir: options.screenshotDir,
-      videoDir: options.videoDir
+      videoDir: options.videoDir,
+      runGroupId: options.runGroupId || process.env.SUPATEST_RUN_GROUP_ID
     };
   }
   onRunnerStart(runner) {
@@ -6630,6 +6636,10 @@ var SupatestAppiumReporter = class extends import_reporter.default {
     this.uploadLimit = pLimit(this.reporterOptions.maxConcurrentUploads);
     const capabilities = this.extractCapabilities(runner);
     const specs = runner.specs || [];
+    this.expectedSpecs = this.getExpectedSpecs(runner);
+    this.currentSpecKey = this.getCurrentSpecKey(runner);
+    this.coordinatorPath = this.getCoordinatorPath(runner);
+    const runSpecs = this.expectedSpecs.length > 0 ? this.expectedSpecs : specs;
     try {
       const runRequest = {
         projectId: this.reporterOptions.projectId,
@@ -6638,10 +6648,10 @@ var SupatestAppiumReporter = class extends import_reporter.default {
           version: this.getAppiumVersion(),
           framework: this.getFramework(runner),
           capabilities,
-          specs
+          specs: runSpecs
         },
         testStats: {
-          totalFiles: specs.length,
+          totalFiles: runSpecs.length,
           totalTests: 0,
           totalProjects: 1
         },
@@ -6649,15 +6659,14 @@ var SupatestAppiumReporter = class extends import_reporter.default {
         git: await this.getGitInfo(),
         rootDir: this.rootDir
       };
-      const response = await this.client.createRun(runRequest);
-      this.runId = response.runId;
+      this.runId = await this.getOrCreateRun(runRequest);
       this.unregisterInterruptHandler = registerInterruptHandler(
         this.client,
         () => this.runId
       );
       const platform = capabilities.platformName || "unknown";
       const device = capabilities.deviceName || "unknown device";
-      logInfo(`Appium run ${this.runId} started [${platform} / ${device}] (${specs.length} spec files)`);
+      logInfo(`Appium run ${this.runId} started [${platform} / ${device}] (${runSpecs.length} spec files)`);
     } catch (error) {
       const errorMsg = getErrorMessage2(error);
       this.errorCollector.recordError("RUN_CREATE", errorMsg, { error });
@@ -7046,6 +7055,11 @@ var SupatestAppiumReporter = class extends import_reporter.default {
     const endedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startTime = this.startedAt ? new Date(this.startedAt).getTime() : 0;
     this.unregisterInterruptHandler?.();
+    const shouldCompleteRun = await this.markSpecComplete();
+    if (!shouldCompleteRun) {
+      logInfo(`Appium run ${this.runId} still has pending spec files; skipping run completion in this worker`);
+      return;
+    }
     try {
       await this.client.completeRun(this.runId, {
         status: this.mapRunStatus(runner),
@@ -7179,6 +7193,151 @@ var SupatestAppiumReporter = class extends import_reporter.default {
     if (this.currentRunner?.specs?.[0]) return this.currentRunner.specs[0];
     return "unknown";
   }
+  getExpectedSpecs(runner) {
+    const configSpecs = this.flattenSpecEntries(runner.config?.specs);
+    const expandedConfigSpecs = configSpecs.flatMap((spec) => this.expandSpecPattern(spec));
+    const runnerSpecs = runner.specs || [];
+    const specs = expandedConfigSpecs.length > 0 ? expandedConfigSpecs : runnerSpecs;
+    return Array.from(new Set(specs.map((spec) => this.normalizeSpecPath(spec)))).sort();
+  }
+  flattenSpecEntries(value) {
+    if (typeof value === "string") return [value];
+    if (!Array.isArray(value)) return [];
+    return value.flatMap((entry) => this.flattenSpecEntries(entry));
+  }
+  isGlobSpec(spec) {
+    return /[*?[\]{}()!+@]/.test(spec);
+  }
+  expandSpecPattern(spec) {
+    if (!this.isGlobSpec(spec)) return [spec];
+    const absoluteSpec = import_node_path2.default.isAbsolute(spec) ? spec : import_node_path2.default.join(this.rootDir, spec);
+    const firstGlobIndex = absoluteSpec.search(/[*?[\]{}()!+@]/);
+    const basePrefix = firstGlobIndex >= 0 ? absoluteSpec.slice(0, firstGlobIndex) : absoluteSpec;
+    const baseDir = /[\\/]$/.test(basePrefix) ? basePrefix.replace(/[\\/]$/, "") : import_node_path2.default.dirname(basePrefix);
+    if (!import_node_fs.default.existsSync(baseDir)) return [];
+    const extensionMatch = spec.match(/\.([a-zA-Z0-9]+)$/);
+    const expectedExtension = extensionMatch ? `.${extensionMatch[1]}` : void 0;
+    const files = [];
+    const visit = (dir) => {
+      for (const entry of import_node_fs.default.readdirSync(dir, { withFileTypes: true })) {
+        const entryPath = import_node_path2.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          visit(entryPath);
+          continue;
+        }
+        if (!expectedExtension || entryPath.endsWith(expectedExtension)) {
+          files.push(entryPath);
+        }
+      }
+    };
+    visit(baseDir);
+    return files.sort();
+  }
+  normalizeSpecPath(spec) {
+    const normalized = import_node_path2.default.isAbsolute(spec) ? import_node_path2.default.relative(this.rootDir, spec) : spec;
+    return normalized.replace(/^[.][\\/]/, "").split(import_node_path2.default.sep).join("/");
+  }
+  getCurrentSpecKey(runner) {
+    const specs = runner.specs || [];
+    if (specs.length === 0) return runner.cid || "unknown";
+    return specs.map((spec) => this.normalizeSpecPath(spec)).sort().join("|");
+  }
+  getCoordinatorPath(runner) {
+    if (this.reporterOptions.dryRun) return void 0;
+    const env = this.getEnvironmentInfo();
+    const ciKey = env.ci ? [env.ci.provider, env.ci.runId, env.ci.jobId, env.ci.buildNumber].filter(Boolean).join(":") : "";
+    const groupId = this.reporterOptions.runGroupId || ciKey || `local:${process.ppid}`;
+    const configSpecs = this.flattenSpecEntries(runner.config?.specs).map((spec) => this.normalizeSpecPath(spec)).sort().join("|");
+    const key = hashKey([
+      this.reporterOptions.projectId,
+      this.rootDir,
+      groupId,
+      configSpecs
+    ].join("::"));
+    return import_node_path2.default.join(import_node_os.default.tmpdir(), "supatest-wdio-appium-runs", `${key}.json`);
+  }
+  async getOrCreateRun(runRequest) {
+    if (!this.coordinatorPath) {
+      const response = await this.client.createRun(runRequest);
+      return response.runId;
+    }
+    return this.withCoordinatorLock(async () => {
+      const state = await this.readCoordinatorState();
+      if (state.runId) return state.runId;
+      const response = await this.client.createRun(runRequest);
+      await this.writeCoordinatorState({
+        runId: response.runId,
+        startedAt: this.startedAt,
+        expectedSpecs: this.expectedSpecs,
+        completedSpecs: state.completedSpecs || []
+      });
+      return response.runId;
+    });
+  }
+  async markSpecComplete() {
+    if (!this.coordinatorPath) return true;
+    return this.withCoordinatorLock(async () => {
+      const state = await this.readCoordinatorState();
+      const completed = new Set(state.completedSpecs || []);
+      completed.add(this.currentSpecKey);
+      const expected = state.expectedSpecs.length > 0 ? state.expectedSpecs : this.expectedSpecs;
+      const complete = expected.length <= 1 || expected.every((spec) => completed.has(spec));
+      await this.writeCoordinatorState({
+        ...state,
+        runId: state.runId || this.runId,
+        startedAt: state.startedAt || this.startedAt,
+        expectedSpecs: expected,
+        completedSpecs: Array.from(completed).sort()
+      });
+      return complete;
+    });
+  }
+  async readCoordinatorState() {
+    if (!this.coordinatorPath) {
+      return { expectedSpecs: this.expectedSpecs, completedSpecs: [] };
+    }
+    try {
+      const raw = await import_node_fs.default.promises.readFile(this.coordinatorPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return {
+        runId: parsed.runId,
+        startedAt: parsed.startedAt,
+        expectedSpecs: parsed.expectedSpecs || this.expectedSpecs,
+        completedSpecs: parsed.completedSpecs || []
+      };
+    } catch {
+      return { expectedSpecs: this.expectedSpecs, completedSpecs: [] };
+    }
+  }
+  async writeCoordinatorState(state) {
+    if (!this.coordinatorPath) return;
+    await import_node_fs.default.promises.mkdir(import_node_path2.default.dirname(this.coordinatorPath), { recursive: true });
+    await import_node_fs.default.promises.writeFile(this.coordinatorPath, JSON.stringify(state, null, 2));
+  }
+  async withCoordinatorLock(fn) {
+    if (!this.coordinatorPath) return fn();
+    await import_node_fs.default.promises.mkdir(import_node_path2.default.dirname(this.coordinatorPath), { recursive: true });
+    const lockPath = `${this.coordinatorPath}.lock`;
+    const start = Date.now();
+    while (true) {
+      let handle;
+      try {
+        handle = await import_node_fs.default.promises.open(lockPath, "wx");
+        try {
+          return await fn();
+        } finally {
+          await handle.close();
+          await import_node_fs.default.promises.rm(lockPath, { force: true });
+        }
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        if (Date.now() - start > COORDINATOR_LOCK_TIMEOUT_MS) {
+          await import_node_fs.default.promises.rm(lockPath, { force: true });
+        }
+        await new Promise((resolve) => setTimeout(resolve, COORDINATOR_LOCK_POLL_MS));
+      }
+    }
+  }
   extractTags(title) {
     const tags = [];
     const seenIndices = /* @__PURE__ */ new Set();