update repo structure

local/playwright-tooling/index.d.ts

@@ -0,0 +1,4 @@
+declare module '@local/playwright-tooling' {
+  export function playwrightRollup(): void; 
+  export function expectSuccess(page: any): void; 
+}

local/playwright-tooling/package.json

@@ -0,0 +1,7 @@
+{
+  "private": true,
+  "name": "@local/playwright-tooling",
+  "main": "./src/index.js",
+  "types": "index.d.ts",
+  "version": "0.0.0"
+}

local/playwright-tooling/src/coverage.js

@@ -0,0 +1,43 @@
+const fs = require('fs');
+const { execSync } = require("child_process");
+const { basename, dirname, join } = require('path');
+const v8toIstanbul = require('v8-to-istanbul');
+
+const tmpCoveragePath = './.coverage/.nycPlaywright';
+const reportDir = './.coverage/playwright';
+
+module.exports = {
+  collectCoverage: async (coverageOutputDir, sourceDir, coverage, testfile) => {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const entry of coverage) {
+      process.chdir(sourceDir);
+      const converter = v8toIstanbul('', 0, { source: entry.source });
+      // eslint-disable-next-line no-await-in-loop
+      await converter.load();
+      converter.applyCoverage(entry.functions);
+
+      const coveragePath = join(
+        coverageOutputDir,
+        `${tmpCoveragePath}/${basename(dirname(testfile))}_${Date.now()}.json`
+      );
+      fs.mkdirSync(dirname(coveragePath), { recursive: true });
+      fs.writeFileSync(coveragePath, JSON.stringify(converter.toIstanbul()));
+    }
+  },
+  mergeCoverage: async () => {
+    if(fs.existsSync(tmpCoveragePath)) {
+      const mergeDestination = join(tmpCoveragePath, `merged_${Date.now()}.json`)
+      execSync(`nyc merge ${tmpCoveragePath} ${mergeDestination}`);
+      const files = fs.readdirSync(tmpCoveragePath);
+      files.forEach((file) => {
+        const filePath = join(tmpCoveragePath, file);
+        if (filePath !== mergeDestination) {
+          fs.rmSync(filePath);
+        }
+      });
+  
+      execSync(`nyc report --reporter=lcov --reporter=text --reporter=clover --reporter=json --report-dir=${reportDir} --temp-dir=${tmpCoveragePath}`, {stdio:'inherit' });
+      fs.rmSync(tmpCoveragePath, { recursive: true });
+    }
+  }
+}

local/playwright-tooling/src/expectSuccess.js

@@ -0,0 +1,8 @@
+const { expect } = require('@playwright/test');
+
+const resultSelector = '#testResult';
+
+module.exports = async (page) => {
+  await page.locator(resultSelector).waitFor({ state: 'visible', timeout: 10 * 60 * 1000 }); // 10mins
+  await expect(page.locator(resultSelector)).toHaveClass('passed', { timeout: 500 });
+}

local/playwright-tooling/src/index.js

@@ -0,0 +1,7 @@
+const playwrightRollup = require('./playwrightRollup');
+const expectSuccess = require('./expectSuccess');
+
+module.exports = {
+  playwrightRollup,
+  expectSuccess,
+};

local/playwright-tooling/src/playwrightRollup.js

@@ -0,0 +1,82 @@
+const { dirname } = require('path');
+const { rollup, watch: rollupWatch } = require('rollup');
+const { test } = require('@playwright/test');
+const createPlaywrightRollupConfig = require('@local/rollup/playwright');
+const { collectCoverage } = require('./coverage');
+
+const createRollupBundle = async (testDir, watch = false) => {
+  let server;
+  const onListening = (srv) => {
+    server = srv;
+  };
+  const config = await createPlaywrightRollupConfig(testDir, 'dev', onListening);
+
+  if (watch) {
+    const watcher = rollupWatch(config);
+    let outputPath = '';
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((resolve) => {
+      watcher.on('event', ({ code, error, result, output }) => {
+        if (code === 'ERROR') {
+          console.log('Error:', error); // eslint-disable-line
+        }
+        if (code === 'BUNDLE_END') {
+          outputPath = output[0];
+          if (result && result.close) {
+            result.close();
+          }
+        }
+        if (code === 'END') {
+          /*
+          console.log('Watching for changes, press ENTER to continue.'); // eslint-disable-line
+          console.log(''); // eslint-disable-line
+          */
+          resolve();
+        }
+      });
+    });
+
+    const { address, port } = server.address();
+    return {
+      url: `${address}:${port}`,
+      output: outputPath,
+      close: () => {
+        server.close();
+        watcher.close();
+      },
+    };
+  }
+
+  const bundle = await rollup(config);
+  await bundle.write(config.output);
+};
+
+module.exports = () => {
+  const originalCwd = process.cwd();
+  let url;
+  let close;
+  let output;
+
+  // eslint-disable-next-line no-empty-pattern
+  test.beforeAll(async ({}, { file }) => {
+    ({ close, url, output } = await createRollupBundle(dirname(file), true));
+  });
+
+  test.beforeEach(async ({ page, browserName }) => {
+    await page.goto(url);
+    if (browserName === 'chromium') {
+      await page.coverage.startJSCoverage();
+    }
+  });
+
+  test.afterEach(async ({ page, browserName }, { file }) => {
+    if (browserName === 'chromium') {
+      const coverage = await page.coverage.stopJSCoverage();
+      await collectCoverage(originalCwd, dirname(output), coverage, file);
+    }
+  });
+
+  test.afterAll(() => {
+    close();
+  });
+};