init

Bin

2025-12-16 9e0b2ba2c317b1a86212f24cbae3195ad1f3dbfa

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import cypressCoverageTask from "@cypress/code-coverage/task.js";
import lockfile from "proper-lockfile";
import fs from "fs";
import path from "path";
 
const LOCK_PATH = path.resolve(process.cwd(), "tmp");
const LOCK_WAITING_TIMEOUT = 100;
 
async function waitTime(timeout) {
  await new Promise((resolve) => {
    setTimeout(() => {
      resolve();
    }, timeout);
  });
}
 
async function beginSyncedPart(key) {
  let release;
 
  while (!release) {
    try {
      release = await lockfile.lock(path.resolve(LOCK_PATH, key), { realpath: false });
    } catch (err) {
      await waitTime(LOCK_WAITING_TIMEOUT);
    }
  }
  return release;
}
 
export const coverageParallel = (on, config) => {
  try {
    fs.rmSync(LOCK_PATH, { recursive: true, force: true });
    fs.mkdirSync(LOCK_PATH);
  } catch (err) {
    console.log(err);
  }
 
  cypressCoverageTask((_, tasks) => {
    // we use our own locking here to prevent a race condition with cypress-coverage and
    // cypress-parallel
    const paralleledTasks = {
      ...tasks,
      combineCoverage: async (sentCoverage) => {
        const endSyncedPart = await beginSyncedPart("cypressCombineCoverage");
        const ret = await tasks.combineCoverage(sentCoverage);
 
        await endSyncedPart();
        return ret;
      },
      coverageReport: async () => {
        const endSyncedPart = await beginSyncedPart("cypressCoverageReport");
        const ret = await tasks.coverageReport();
 
        await endSyncedPart();
        return ret;
      },
    };
 
    on("task", paralleledTasks);
  }, config);
  return config;
};