@allurereport/web-awesome 3.8.2 → 3.10.0

package/test/components/ReportMetadata.test.tsx

@@ -0,0 +1,131 @@
+import { getReportOptions } from "@allurereport/web-commons";
+import { cleanup, render, screen } from "@testing-library/preact";
+import { type Mock, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ReportMetadata } from "@/components/ReportMetadata";
+
+vi.mock("@allurereport/web-commons", async (importOriginal) => ({
+  ...(await importOriginal()),
+  getReportOptions: vi.fn(),
+}));
+
+vi.mock("@allurereport/web-components", () => {
+  const Menu = Object.assign(
+    (props: { children: unknown; menuTrigger: (props: { onClick: () => void }) => unknown }) => (
+      <>
+        {props.menuTrigger({ onClick: vi.fn() })}
+        {props.children}
+      </>
+    ),
+    {
+      Section: (props: { children: unknown }) => <>{props.children}</>,
+    },
+  );
+
+  return {
+    ArrowButton: () => <span />,
+    Button: (props: { text?: string; onClick?: () => void }) => <button onClick={props.onClick}>{props.text}</button>,
+    ButtonLink: (props: { href: string; text?: string }) => <a href={props.href}>{props.text}</a>,
+    Counter: (props: { count: number }) => <span>{props.count}</span>,
+    Loadable: (props: {
+      source: { value?: { data?: unknown } };
+      transformData?: (data: unknown) => unknown;
+      renderData: (data: unknown) => unknown;
+    }) =>
+      props.renderData(props.transformData ? props.transformData(props.source.value?.data) : props.source.value?.data),
+    Menu,
+    SvgIcon: () => <span />,
+    Text: (props: { children: unknown }) => <span>{props.children}</span>,
+    TooltipWrapper: (props: { children: unknown }) => props.children,
+    allureIcons: {
+      lineGeneralCopy3: "copy",
+      lineGeneralLinkExternal: "external",
+    },
+    useElementTruncation: () => ({ ref: { current: null }, isTruncated: false }),
+  };
+});
+
+vi.mock("@/stores", () => ({
+  reportStatsStore: { value: { data: undefined } },
+  statsByEnvStore: { value: { data: {} } },
+  useI18n: () => ({
+    t: (key: string) => key,
+  }),
+}));
+
+vi.mock("@/stores/env", () => ({
+  currentEnvironment: { value: undefined },
+}));
+
+vi.mock("@/stores/envInfo", () => ({
+  envInfoStore: { value: { data: [] } },
+}));
+
+vi.mock("@/stores/tree", () => ({
+  collapsedTrees: { value: new Set() },
+  toggleTree: vi.fn(),
+}));
+
+vi.mock("@/stores/variables", () => ({
+  fetchVariables: vi.fn(),
+  variables: { value: { data: { default: {} } } },
+}));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  cleanup();
+});
+
+describe("components > ReportMetadata", () => {
+  it("should render executor metadata as a clickable build link", () => {
+    (getReportOptions as Mock).mockReturnValue({
+      executor: {
+        name: "TeamCity",
+        buildName: "Wrike #123",
+        url: "https://teamcity.example",
+        reportUrl: "https://teamcity.example/report/123",
+        buildUrl: "https://teamcity.example/build/123",
+      },
+    });
+
+    render(<ReportMetadata />);
+
+    expect(screen.getByText("executor")).toBeInTheDocument();
+    expect(screen.getByRole("link", { name: "TeamCity · Wrike #123" })).toHaveAttribute(
+      "href",
+      "https://teamcity.example/build/123",
+    );
+  });
+
+  it("should fall back to report url when executor build url is missing", () => {
+    (getReportOptions as Mock).mockReturnValue({
+      executor: {
+        name: "TeamCity",
+        buildName: "Wrike #123",
+        reportUrl: "https://teamcity.example/report/123",
+      },
+    });
+
+    render(<ReportMetadata />);
+
+    expect(screen.getByRole("link", { name: "TeamCity · Wrike #123" })).toHaveAttribute(
+      "href",
+      "https://teamcity.example/report/123",
+    );
+  });
+
+  it("should render executor metadata as plain text when url is unsafe", () => {
+    (getReportOptions as Mock).mockReturnValue({
+      executor: {
+        name: "TeamCity",
+        buildName: "Wrike #123",
+        buildUrl: "javascript:alert(1)",
+      },
+    });
+
+    render(<ReportMetadata />);
+
+    expect(screen.queryByRole("link", { name: "TeamCity · Wrike #123" })).not.toBeInTheDocument();
+    expect(screen.getByTestId("metadata-item")).toHaveTextContent("TeamCity · Wrike #123");
+  });
+});

package/test/components/TestResult/PwTraceButton.test.tsx

@@ -1,6 +1,14 @@
 import { fireEvent, render, screen, waitFor } from "@testing-library/preact";
+import { epic, feature, label, story } from "allure-js-commons";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+beforeEach(async () => {
+  await epic("coverage");
+  await feature("ui-components");
+  await story("PwTraceButton");
+  await label("coverage", "ui-components");
+});
+
 type SetupOptions = {
   canOpenInNewTab: boolean;
   failFetch?: boolean;

package/test/components/TestResult/TrErrorStep.test.tsx

@@ -1,6 +1,14 @@
 import { cleanup, fireEvent, render } from "@testing-library/preact";
+import { epic, feature, label, story } from "allure-js-commons";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+beforeEach(async () => {
+  await epic("coverage");
+  await feature("ui-components");
+  await story("TrErrorStep");
+  await label("coverage", "ui-components");
+});
+
 const { matchMediaMock } = vi.hoisted(() => {
   const matchMediaMock = vi.fn().mockImplementation(() => ({
     matches: false,

package/test/components/TestResult/TrOverview.test.tsx

@@ -1,7 +1,15 @@
 import { cleanup, render, screen } from "@testing-library/preact";
+import { epic, feature, label, story } from "allure-js-commons";
 import type { AwesomeTestResult } from "types";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+beforeEach(async () => {
+  await epic("coverage");
+  await feature("ui-components");
+  await story("TrOverview");
+  await label("coverage", "ui-components");
+});
+
 import { TrOverview } from "@/components/TestResult/TrOverview";
 
 vi.mock("@/components/TestResult/TestStepsEmpty", () => ({
@@ -12,32 +20,36 @@ vi.mock("@/components/TestResult/TrSteps", () => ({
   TrSteps: () => <div data-testid="tr-steps" />,
 }));
 
+vi.mock("@/components/TestResult/TrError", () => ({
+  TrError: () => <div data-testid="test-result-error" />,
+}));
+
 vi.mock("@/components/TestResult/TrDescription", () => ({
-  TrDescription: () => null,
+  TrDescription: () => null as any,
 }));
 
 vi.mock("@/components/TestResult/TrLinks", () => ({
-  TrLinks: () => null,
+  TrLinks: () => null as any,
 }));
 
 vi.mock("@/components/TestResult/TrMetadata", () => ({
-  TrMetadata: () => null,
+  TrMetadata: () => null as any,
 }));
 
 vi.mock("@/components/TestResult/TrParameters", () => ({
-  TrParameters: () => null,
+  TrParameters: () => null as any,
 }));
 
 vi.mock("@/components/TestResult/TrPwTraces", () => ({
-  TrPwTraces: () => null,
+  TrPwTraces: () => null as any,
 }));
 
 vi.mock("@/components/TestResult/TrSetup", () => ({
-  TrSetup: () => null,
+  TrSetup: () => null as any,
 }));
 
 vi.mock("@/components/TestResult/TrTeardown", () => ({
-  TrTeardown: () => null,
+  TrTeardown: () => null as any,
 }));
 
 vi.mock("@/stores/locale", () => ({
@@ -48,6 +60,7 @@ vi.mock("@/stores/locale", () => ({
 
 vi.mock("@/stores/testResult", () => ({
   currentTrId: { value: "current-test-result-id" },
+  trCurrentTab: { value: "overview" },
 }));
 
 const makeTestResult = (overrides: Partial<AwesomeTestResult> = {}): AwesomeTestResult =>
@@ -59,7 +72,7 @@ const makeTestResult = (overrides: Partial<AwesomeTestResult> = {}): AwesomeTest
     flaky: false,
     muted: false,
     known: false,
-    hidden: false,
+    isRetry: false,
     labels: [],
     groupedLabels: {},
     parameters: [],
@@ -98,8 +111,15 @@ describe("components > TestResult > TrOverview", () => {
     expect(screen.queryByTestId("test-steps-empty")).not.toBeInTheDocument();
   });
 
-  it("should render TrSteps when the test has an error", () => {
-    render(<TrOverview testResult={makeTestResult({ error: { message: "boom" } })} />);
+  it("should render TrSteps when the test has steps and an error", () => {
+    render(
+      <TrOverview
+        testResult={makeTestResult({
+          error: { message: "boom" },
+          steps: [{ type: "step", name: "step", status: "passed", parameters: [], steps: [] }],
+        })}
+      />,
+    );
 
     expect(screen.getByTestId("tr-steps")).toBeInTheDocument();
     expect(screen.queryByTestId("test-steps-empty")).not.toBeInTheDocument();

package/test/components/TestResult/TrRetriesItem.test.tsx

@@ -0,0 +1,163 @@
+import { fireEvent, render, screen } from "@testing-library/preact";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { TrRetriesItem } from "@/components/TestResult/TrRetriesView/TrRetriesItem";
+
+import type { AwesomeTestResult } from "../../../types";
+
+vi.mock("@allurereport/web-components", () => ({
+  ArrowButton: () => <button data-testid="test-result-retries-item-arrow-button" type="button" />,
+  IconButton: (props: { "onClick": () => void; "data-testid"?: string }) => (
+    <button data-testid={props["data-testid"]} type="button" onClick={props.onClick} />
+  ),
+  Text: (props: { "children": unknown; "data-testid"?: string }) => (
+    <span data-testid={props["data-testid"]}>{props.children}</span>
+  ),
+  TreeItemIcon: () => <span data-testid="retry-status" />,
+  allureIcons: {
+    lineArrowsChevronDown: "chevron",
+    lineGeneralLinkExternal: "external",
+  },
+}));
+
+vi.mock("@/components/TestResult/TrError", () => ({
+  TrError: (props: { message?: string; trace?: string; actual?: string; expected?: string }) => (
+    <div data-testid="test-result-error">{props.message || props.trace || `${props.actual} ${props.expected}`}</div>
+  ),
+}));
+
+vi.mock("@/stores/locale", () => ({
+  useI18n: (namespace: string) =>
+    namespace === "controls"
+      ? {
+          t: (key: string) => (key === "comparison" ? "Comparison" : key),
+        }
+      : {
+          t: (_key: string, params: { attempt: number; total: number }) =>
+            `Attempt ${params.attempt} of ${params.total}`,
+        },
+}));
+
+vi.mock("@/stores/router", () => ({
+  navigateToTestResult: vi.fn(),
+}));
+
+vi.mock("@/utils/time", () => ({
+  timestampToDate: (value: number) => `date:${value}`,
+}));
+
+const makeRetry = (overrides: Partial<AwesomeTestResult> = {}): AwesomeTestResult =>
+  ({
+    id: "retry-id",
+    name: "retry",
+    status: "failed",
+    fullName: "retry.fullName",
+    flaky: false,
+    muted: false,
+    known: false,
+    isRetry: true,
+    labels: [],
+    groupedLabels: {},
+    parameters: [],
+    links: [],
+    steps: [],
+    error: undefined,
+    environment: "default",
+    setup: [],
+    teardown: [],
+    history: [],
+    retries: [],
+    breadcrumbs: [],
+    titlePath: [],
+    attachments: [],
+    ...overrides,
+  }) as AwesomeTestResult;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("components > TestResult > TrRetriesItem", () => {
+  it("should render retry error message preview without expanding details", () => {
+    render(
+      <TrRetriesItem
+        attempt={1}
+        totalAttempts={2}
+        testResultItem={makeRetry({
+          stop: 1000,
+          duration: 500,
+          error: {
+            message: "Expected true to be false",
+            trace: "stack trace",
+          },
+        })}
+      />,
+    );
+
+    expect(screen.getByTestId("test-result-retries-item-error-preview")).toHaveTextContent("Expected true to be false");
+    expect(screen.queryByTestId("test-result-error")).not.toBeInTheDocument();
+
+    fireEvent.click(screen.getByTestId("test-result-retries-item-arrow-button"));
+
+    expect(screen.getByTestId("test-result-error")).toHaveTextContent("Expected true to be false");
+  });
+
+  it("should use first meaningful trace line when message is missing", () => {
+    render(
+      <TrRetriesItem
+        attempt={1}
+        totalAttempts={2}
+        testResultItem={makeRetry({
+          error: {
+            trace: "\n\nAssertionError: timeout\n    at test.ts:1",
+          },
+        })}
+      />,
+    );
+
+    expect(screen.getByTestId("test-result-retries-item-error-preview")).toHaveTextContent("AssertionError: timeout");
+  });
+
+  it("should use trace preview when message is only whitespace", () => {
+    render(
+      <TrRetriesItem
+        attempt={1}
+        totalAttempts={2}
+        testResultItem={makeRetry({
+          error: {
+            message: "   ",
+            trace: "\nAssertionError: retry failed",
+          },
+        })}
+      />,
+    );
+
+    expect(screen.getByTestId("test-result-retries-item-arrow-button")).toBeInTheDocument();
+    expect(screen.getByTestId("test-result-retries-item-error-preview")).toHaveTextContent(
+      "AssertionError: retry failed",
+    );
+  });
+
+  it("should render diff-only retry preview and keep details expandable", () => {
+    render(
+      <TrRetriesItem
+        attempt={1}
+        totalAttempts={2}
+        testResultItem={makeRetry({
+          error: {
+            actual: "actual value",
+            expected: "expected value",
+          },
+        })}
+      />,
+    );
+
+    expect(screen.getByTestId("test-result-retries-item-arrow-button")).toBeInTheDocument();
+    expect(screen.getByTestId("test-result-retries-item-error-preview")).toHaveTextContent("Comparison");
+    expect(screen.queryByTestId("test-result-error")).not.toBeInTheDocument();
+
+    fireEvent.click(screen.getByTestId("test-result-retries-item-arrow-button"));
+
+    expect(screen.getByTestId("test-result-error")).toHaveTextContent("actual value expected value");
+  });
+});

package/test/components/TestResult/TrSteps.test.tsx

@@ -0,0 +1,108 @@
+import { cleanup, render } from "@testing-library/preact";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.hoisted(() => {
+  vi.stubGlobal(
+    "matchMedia",
+    vi.fn().mockImplementation(() => ({
+      matches: false,
+      media: "",
+      onchange: null,
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    })),
+  );
+});
+
+import type { TrBodyItem } from "@/components/TestResult/bodyItems";
+import { TrSteps } from "@/components/TestResult/TrSteps";
+import { TrStep } from "@/components/TestResult/TrSteps/TrStep";
+import { collapsedTrees, expandedTrees } from "@/stores/tree";
+
+const nestedPassedStep = {
+  type: "step",
+  item: {
+    stepId: "nested-passed-step",
+    name: "nested passed step",
+    status: "passed",
+    parameters: [],
+    message: "",
+    trace: "",
+    hasSimilarErrorInSubSteps: false,
+  },
+  suppressInlineError: false,
+  bodyItems: [],
+} satisfies TrBodyItem;
+
+const passedStepWithContent = {
+  type: "step",
+  item: {
+    stepId: "passed-step",
+    name: "passed step",
+    status: "passed",
+    parameters: [],
+    message: "",
+    trace: "",
+    hasSimilarErrorInSubSteps: false,
+  },
+  suppressInlineError: false,
+  bodyItems: [nestedPassedStep],
+} satisfies TrBodyItem;
+
+const failedStepWithContent = {
+  type: "step",
+  item: {
+    stepId: "failed-step",
+    name: "failed step",
+    status: "failed",
+    parameters: [],
+    message: "failed",
+    trace: "trace",
+    hasSimilarErrorInSubSteps: false,
+  },
+  suppressInlineError: false,
+  bodyItems: [nestedPassedStep],
+} satisfies TrBodyItem;
+
+describe("components > TestResult > TrSteps", () => {
+  beforeEach(() => {
+    cleanup();
+    collapsedTrees.value = new Set();
+    expandedTrees.value = new Set();
+    globalThis.allureReportOptions = { stepTreeExpansion: "expand_failed_only" } as any;
+  });
+
+  it("always shows the steps root container regardless of step status", () => {
+    const view = render(<TrSteps id="test" bodyItems={[passedStepWithContent]} />);
+
+    expect(view.getByTestId("test-result-steps-root")).toBeInTheDocument();
+  });
+
+  it("opens top-level passed steps by default even with expand_failed_only", () => {
+    const view = render(<TrStep item={passedStepWithContent} stepIndex={1} isTopLevel={true} />);
+
+    expect(view.getByTestId("test-result-step-content")).toBeInTheDocument();
+  });
+
+  it("collapses top-level steps when policy is collapsed", () => {
+    globalThis.allureReportOptions = { stepTreeExpansion: "collapsed" } as any;
+    const view = render(<TrStep item={passedStepWithContent} stepIndex={1} isTopLevel={true} />);
+
+    expect(view.queryByTestId("test-result-step-content")).not.toBeInTheDocument();
+  });
+
+  it("opens top-level failed steps by default with expand_failed_only", () => {
+    const view = render(<TrSteps id="failed-test" bodyItems={[failedStepWithContent]} />);
+
+    expect(view.getByTestId("test-result-step-content")).toBeInTheDocument();
+  });
+
+  it("collapses nested passed steps by default with expand_failed_only", () => {
+    const view = render(<TrStep item={passedStepWithContent} stepIndex={1} isTopLevel={true} />);
+
+    expect(view.queryAllByTestId("test-result-step-content")).toHaveLength(1);
+  });
+});

package/test/components/TestResult/bodyItems.test.ts

@@ -1,6 +1,14 @@
 import type { AttachmentTestStepResult, DefaultTestStepResult } from "@allurereport/core-api";
+import { epic, feature, label, story } from "allure-js-commons";
 import type { AwesomeFixtureResult, AwesomeTestResult } from "types";
-import { describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it } from "vitest";
+
+beforeEach(async () => {
+  await epic("coverage");
+  await feature("ui-components");
+  await story("bodyItems");
+  await label("coverage", "ui-components");
+});
 
 import {
   fixtureResultToTrStepItem,

package/test/components/TestResult/openPwTraceInNewTab.test.ts

@@ -1,5 +1,13 @@
+import { epic, feature, label, story } from "allure-js-commons";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+beforeEach(async () => {
+  await epic("coverage");
+  await feature("ui-components");
+  await story("openPwTraceInNewTab");
+  await label("coverage", "ui-components");
+});
+
 describe("components > TestResult > openPlaywrightTraceInNewTab", () => {
   beforeEach(() => {
     vi.resetModules();

package/test/components/TestResult/stepTreeExpansion.test.ts

@@ -1,14 +1,22 @@
-import { describe, expect, it } from "vitest";
+import { getNextSubtreeToggleState } from "@allurereport/web-commons";
+import { epic, feature, label, story } from "allure-js-commons";
+import { beforeEach, describe, expect, it } from "vitest";
 
 import type { TrBodyItem } from "@/components/TestResult/bodyItems";
 import {
   collectExpandableStepNodes,
-  getNextSubtreeToggleState,
   hasFailedStepContext,
   isOpenByDefaultForPolicy,
   isStepOpenedByDefault,
 } from "@/components/TestResult/TrSteps/stepTreeExpansion";
 
+beforeEach(async () => {
+  await epic("coverage");
+  await feature("ui-components");
+  await story("stepTreeExpansion");
+  await label("coverage", "ui-components");
+});
+
 describe("components > TestResult > stepTreeExpansion", () => {
   it("should detect failed context in nested steps", () => {
     const bodyItems = [

package/test/components/Timeline.test.tsx

@@ -1,12 +1,20 @@
 import { signal } from "@preact/signals";
 import { cleanup, render, screen } from "@testing-library/preact";
+import { epic, feature, label, story } from "allure-js-commons";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+beforeEach(async () => {
+  await epic("coverage");
+  await feature("ui-components");
+  await story("Timeline");
+  await label("coverage", "ui-components");
+});
+
 type TimelineTestResult = {
   id: string;
   name: string;
   status: "passed" | "failed";
-  hidden: boolean;
+  isRetry: boolean;
   environment: string;
   environmentName?: string;
   host: string;
@@ -30,11 +38,11 @@ const setup = async (timelineData: TimelineTestResult[]) => {
     Timeline: ({ data, dataId }: { data: TimelineTestResult[]; dataId: string }) => (
       <div data-testid={`timeline-${dataId}`}>{data.map(({ id }) => id).join(",")}</div>
     ),
-    Grid: ({ children }: { children: unknown }) => <div>{children}</div>,
-    GridItem: ({ children }: { children: unknown }) => <div>{children}</div>,
-    Loadable: ({ renderData }: { renderData: () => JSX.Element }) => renderData(),
+    Grid: ({ children }: { children: unknown }) => <div>{children as any}</div>,
+    GridItem: ({ children }: { children: unknown }) => <div>{children as any}</div>,
+    Loadable: ({ renderData }: { renderData: () => any }) => renderData(),
     PageLoader: () => <div>loading</div>,
-    Widget: ({ children }: { children: unknown }) => <div>{children}</div>,
+    Widget: ({ children }: { children: unknown }) => <div>{children as any}</div>,
   }));
   vi.doMock("@/stores", () => ({
     useI18n: () => ({
@@ -76,7 +84,7 @@ describe("components > Timeline", () => {
         id: "tr-qa-a",
         name: "qa a test",
         status: "passed",
-        hidden: false,
+        isRetry: false,
         environment: "qa_a",
         environmentName: "QA",
         host: "shared-host",
@@ -88,7 +96,7 @@ describe("components > Timeline", () => {
         id: "tr-qa-b",
         name: "qa b test",
         status: "failed",
-        hidden: false,
+        isRetry: false,
         environment: "qa_b",
         environmentName: "QA",
         host: "shared-host",