working on cdn remote reports assets

Author: epszaw

.pnp.cjs

@@ -12,6 +12,8 @@ export interface PluginInstance {
   enabled: boolean;
   plugin: Plugin;
   options: Record<string, any>;
+  packageName?: string;
+  packageVersion?: string;
 }
 
 export interface FullConfig {
@@ -46,6 +48,5 @@ export interface FullConfig {
     url?: string;
     project?: string;
     accessToken?: string;
-    publish?: boolean;
   };
 }

packages/core/src/api.ts

@@ -1,12 +1,12 @@
 import type { Config, PluginDescriptor } from "@allurereport/plugin-api";
 import * as console from "node:console";
-import { stat } from "node:fs/promises";
-import { resolve } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { join, resolve, sep } from "node:path";
 import * as process from "node:process";
 import type { FullConfig, PluginInstance } from "./api.js";
 import { readKnownIssues } from "./known.js";
 import { FileSystemReportFiles } from "./plugin.js";
-import { importWrapper } from "./utils/module.js";
+import { importWrapper, resolveWrapper } from "./utils/module.js";
 import { normalizeImportPath } from "./utils/path.js";
 
 export const getPluginId = (key: string) => {
@@ -177,22 +177,52 @@ export const enforcePlugin = (config: FullConfig, pluginInstance: PluginInstance
   return newConfig;
 };
 
-export const resolvePlugin = async (path: string) => {
+export const getPluginRootPath = (packageName: string, packagePath: string) => {
+  const parts = packagePath.split(sep);
+  const pkgIdx = parts.indexOf(packageName);
+
+  return parts.slice(0, pkgIdx - 1).join(sep);
+};
+
+export const getPluginVersion = async (packagePath: string) => {
+  const packageJsonPath = join(packagePath, "package.json");
+  const packageJson = await readFile(packageJsonPath, "utf-8");
+  const { version } = JSON.parse(packageJson);
+
+  return version;
+};
+
+export const resolvePlugin = async (pkg: string) => {
   // try to append @allurereport/plugin- scope
-  if (!path.startsWith("@allurereport/plugin-")) {
+  if (!pkg.startsWith("@allurereport/plugin-")) {
     try {
-      const module = await importWrapper(`@allurereport/plugin-${path}`);
-
-      return module.default;
-    } catch (err) {}
+      const packageName = `@allurereport/plugin-${pkg}`;
+      const packageFsPath = resolveWrapper(packageName);
+      const packageRootPath = getPluginRootPath(packageName, packageFsPath);
+      const packageVersion = await getPluginVersion(packageRootPath);
+      const module = await importWrapper(packageName);
+
+      return {
+        packageName,
+        packageVersion,
+        module: module.default,
+      };
+    } catch (ignored) {}
   }
 
   try {
-    const module = await importWrapper(path);
-
-    return module.default;
-  } catch (err) {
-    throw new Error(`Cannot resolve plugin: ${path}`);
+    const packageFsPath = resolveWrapper(pkg);
+    const packageRootPath = getPluginRootPath(pkg, packageFsPath);
+    const packageVersion = await getPluginVersion(packageRootPath);
+    const module = await importWrapper(pkg);
+
+    return {
+      packageName: pkg,
+      packageVersion,
+      module: module.default,
+    };
+  } catch (ignored) {
+    throw new Error(`Cannot resolve plugin: ${pkg}`);
   }
 };
 
@@ -201,13 +231,15 @@ const resolvePlugins = async (plugins: Record<string, PluginDescriptor>) => {
 
   for (const id in plugins) {
     const pluginConfig = plugins[id];
-    const Plugin = await resolvePlugin(pluginConfig.import ?? id);
+    const { module: Plugin, packageName, packageVersion } = await resolvePlugin(pluginConfig.import ?? id);
 
     pluginInstances.push({
       id: getPluginId(id),
       enabled: pluginConfig.enabled ?? true,
       options: pluginConfig.options ?? {},
       plugin: new Plugin(pluginConfig.options),
+      packageName,
+      packageVersion,
     });
   }
 

packages/core/src/config.ts

@@ -7,10 +7,15 @@ import type {
   ReportFiles,
   ResultFile,
 } from "@allurereport/plugin-api";
-import AwesomePlugin from "@allurereport/plugin-awesome";
 import { allure1, allure2, attachments, cucumberjson, junitXml, readXcResultBundle } from "@allurereport/reader";
 import { PathResultFile, type ResultsReader } from "@allurereport/reader-api";
-import { AllureRemoteHistory, AllureServiceClient, KnownError, UnknownError } from "@allurereport/service";
+import {
+  AllureRemoteHistory,
+  AllureServiceClient,
+  KnownError,
+  type RemotePluginsMap,
+  UnknownError,
+} from "@allurereport/service";
 import { generateSummary } from "@allurereport/summary";
 import console from "node:console";
 import { randomUUID } from "node:crypto";
@@ -43,7 +48,7 @@ export class AllureReport {
   readonly #output: string;
   readonly #history: AllureHistory | undefined;
   readonly #allureServiceClient: AllureServiceClient | undefined;
-  readonly #publish: boolean;
+
   #reportUrl?: string;
   #state?: Record<string, PluginState>;
   #stage: "init" | "running" | "done" = "init";
@@ -66,7 +71,6 @@ export class AllureReport {
     } = opts;
 
     this.#allureServiceClient = allureServiceConfig?.url ? new AllureServiceClient(allureServiceConfig) : undefined;
-    this.#publish = allureServiceConfig?.publish ?? false;
     this.#reportUuid = randomUUID();
     this.#reportName = name;
     this.#eventEmitter = new EventEmitter<AllureStoreEvents>();
@@ -111,6 +115,37 @@ export class AllureReport {
     return this.#qualityGate.result;
   }
 
+  get #remotePluginsMap() {
+    return this.#plugins
+      .filter(({ enabled, options }) => enabled && options.publish)
+      .reduce(
+        (acc, { id, packageName, packageVersion, options }) => ({
+          ...acc,
+          [id]: {
+            packageName,
+            packageVersion,
+            singleFile: options.singleFile ?? false,
+          },
+        }),
+        {} as RemotePluginsMap,
+      );
+  }
+
+  #filterRemoteFiles(files: Record<string, string>) {
+    return Object.entries(files).reduce(
+      (acc, [key, filename]) => {
+        if (!/^(data|widgets|index\.html$)/.test(key)) {
+          return acc;
+        }
+
+        acc[key] = filename;
+
+        return acc;
+      },
+      {} as Record<string, string>,
+    );
+  }
+
   readDirectory = async (resultsDir: string) => {
     if (this.#stage !== "running") {
       throw new Error(initRequired);
@@ -174,10 +209,11 @@ export class AllureReport {
     this.#stage = "running";
 
     // create remote report to publish files into
-    if (this.#allureServiceClient && this.#publish) {
+    if (this.#allureServiceClient && Object.keys(this.#remotePluginsMap).length > 0) {
       const { url } = await this.#allureServiceClient.createReport({
         reportUuid: this.#reportUuid,
         reportName: this.#reportName,
+        plugins: this.#remotePluginsMap,
       });
 
       this.#reportUrl = url;
@@ -216,27 +252,24 @@ export class AllureReport {
     // closing it early, to prevent future reads
     this.#stage = "done";
 
-    await this.#eachPlugin(false, async (plugin, context, id) => {
+    await this.#eachPlugin(false, async (plugin, context, { id }) => {
       const pluginFiles = (await context.state.get("files")) ?? {};
+      const remotePlugin = this.#remotePluginsMap[id];
 
       await plugin.done?.(context, this.#store);
 
-      // publish only Allure Awesome reports
-      if (
-        plugin instanceof AwesomePlugin &&
-        this.#history &&
-        this.#allureServiceClient &&
-        this.#publish &&
-        Object.keys(pluginFiles).length
-      ) {
+      if (this.#allureServiceClient && remotePlugin) {
+        const filteredPluginFiles = this.#filterRemoteFiles(pluginFiles as Record<string, string>);
+
         await Promise.all(
-          Object.entries(pluginFiles).map(([key, filepath]) =>
+          Object.entries(filteredPluginFiles).map(([key, filepath]) => {
             this.#allureServiceClient?.addReportFile({
               reportUuid: this.#reportUuid,
+              pluginId: id,
               key,
               filepath,
-            }),
-          ),
+            });
+          }),
         );
       }
 
@@ -313,20 +346,18 @@ export class AllureReport {
 
   #eachPlugin = async (
     initState: boolean,
-    consumer: (plugin: Plugin, context: PluginContext, id: string) => Promise<void>,
+    consumer: (plugin: Plugin, context: PluginContext, options: { id: string }) => Promise<void>,
   ) => {
     if (initState) {
       // reset state on start;
       this.#state = {};
     }
 
-    for (const descriptor of this.#plugins) {
-      if (!descriptor.enabled) {
+    for (const { enabled, id, plugin } of this.#plugins) {
+      if (!enabled) {
         continue;
       }
 
-      const id = descriptor.id;
-      const plugin = descriptor.plugin;
       const pluginState = this.#getPluginState(initState, id);
 
       if (!pluginState) {
@@ -357,7 +388,7 @@ export class AllureReport {
       };
 
       try {
-        await consumer.call(this, plugin, pluginContext, id);
+        await consumer.call(this, plugin, pluginContext, { id });
 
         if (initState) {
           this.#state![id] = pluginState;

packages/core/src/report.ts

@@ -3,10 +3,18 @@ import { normalizeImportPath } from "./path.js";
 
 const require = createRequire(import.meta.url);
 
+/**
+ * Dead simple wrapper around require.resolve to make it possible to mock it in the tests
+ * @param path
+ */
+export const resolveWrapper = (path: string) => {
+  return require.resolve(path);
+};
+
 /**
  * Dead simple wrapper around import function to make it possible to mock it in the tests
  * @param path
  */
 export const importWrapper = async (path: string) => {
-  return import(normalizeImportPath(require.resolve(path)));
+  return import(normalizeImportPath(resolveWrapper(path)));
 };

packages/core/src/utils/module.ts

@@ -19,6 +19,7 @@ class PluginFixture {}
 
 vi.mock("../src/utils/module.js", () => ({
   importWrapper: vi.fn(),
+  resolveWrapper: vi.fn(),
 }));
 
 beforeEach(() => {
@@ -136,7 +137,10 @@ describe("resolvePlugin", () => {
     expect(importWrapper).toHaveBeenCalledTimes(2);
     expect(importWrapper).toHaveBeenCalledWith("@allurereport/plugin-classic");
     expect(importWrapper).toHaveBeenCalledWith("classic");
-    expect(plugin).toEqual(fixture);
+    expect(plugin).toEqual({
+      module: fixture,
+      package: "classic",
+    });
   });
 
   it("throws an error when plugin can't be resolved", async () => {
@@ -229,12 +233,14 @@ describe("resolveConfig", () => {
       id: "awesome",
       enabled: true,
       options: {},
+      package: "@allurereport/plugin-awesome",
       plugin: expect.any(PluginFixture),
     });
     expect((await resolveConfig({ plugins: {} })).plugins).toContainEqual({
       id: "awesome",
       enabled: true,
       options: {},
+      package: "@allurereport/plugin-awesome",
       plugin: expect.any(PluginFixture),
     });
   });
@@ -305,6 +311,8 @@ describe("enforcePlugin", () => {
       options: {
         groupBy: ["test"],
       },
+      packageName: "awesome",
+      packageVersion: "1.0.0",
       plugin: new PluginFixture(),
     } as PluginInstance;
     const config = {
@@ -324,6 +332,8 @@ describe("enforcePlugin", () => {
       options: {
         groupBy: ["test"],
       },
+      packageName: "awesome",
+      packageVersion: "1.0.0",
       plugin: new PluginFixture(),
     } as PluginInstance;
     const config = {

packages/core/test/config.test.ts

@@ -43,7 +43,6 @@ export interface Config {
     url?: string;
     project?: string;
     accessToken?: string;
-    publish?: boolean;
   };
 }
 

packages/plugin-api/src/config.ts

@@ -330,21 +330,23 @@ export const generateStaticFiles = async (
 
   if (!payload.singleFile) {
     for (const key in manifest) {
-      const fileName = manifest[key];
+      // file path including query parameter for cache busting
+      const fileHref = manifest[key];
+      const fileName = fileHref.replace(/\?\S+$/, "");
       const filePath = require.resolve(
         join("@allurereport/web-awesome/dist", singleFile ? "single" : "multi", fileName),
       );
 
       if (key.includes(".woff")) {
-        headTags.push(createFontLinkTag(fileName));
+        headTags.push(createFontLinkTag(fileHref));
       }
 
       if (key === "main.css") {
-        headTags.push(createStylesLinkTag(fileName));
+        headTags.push(createStylesLinkTag(fileHref));
       }
 
       if (key === "main.js") {
-        bodyTags.push(createScriptTag(fileName));
+        bodyTags.push(createScriptTag(fileHref));
       }
 
       // we don't need to handle another files in single file mode

packages/plugin-awesome/src/generators.ts

@@ -19,6 +19,7 @@ export type AwesomeOptions = {
   charts?: ChartOptions[];
   sections?: string[];
   defaultSection?: string;
+  publish?: boolean;
 };
 
 export type TemplateManifest = Record<string, string>;