@allurereport/web-awesome 3.0.0 → 3.0.1

package/src/stores/treeFilters/store.ts

@@ -0,0 +1,73 @@
+import { batch, computed, effect, signal } from "@preact/signals";
+import type { AwesomeStatus } from "types";
+import { loadFromLocalStorage } from "@/utils/loadFromLocalStorage";
+import { persist } from "@/utils/persist";
+import { transitionFiltersList } from "./constants";
+import type { TreeDirection, TreeFilters, TreeFiltersState, TreeSortBy } from "./types";
+
+export const treeQuery = signal<string>("");
+export const treeStatus = signal<AwesomeStatus>("total");
+export const treeSortBy = signal<TreeSortBy>("order");
+export const treeDirection = signal<TreeDirection>("asc");
+export const treeFilter = signal<Record<TreeFilters, boolean>>({
+  flaky: false,
+  retry: false,
+  new: false,
+  fixed: false,
+  regressed: false,
+  malfunctioned: false,
+});
+
+const initialized = signal(false);
+
+const init = () => {
+  const initialState = loadFromLocalStorage<TreeFiltersState>("treeFilters", {
+    query: "",
+    status: "total",
+    filter: {
+      flaky: false,
+      retry: false,
+      new: false,
+      fixed: false,
+      regressed: false,
+      malfunctioned: false,
+    },
+    sortBy: "order",
+    direction: "asc",
+  });
+
+  batch(() => {
+    treeQuery.value = initialState.query;
+    treeStatus.value = initialState.status;
+    treeSortBy.value = initialState.sortBy;
+    treeDirection.value = initialState.direction;
+    treeFilter.value = initialState.filter;
+    initialized.value = true;
+  });
+};
+
+init();
+
+const treeFiltersState = computed(() => ({
+  query: treeQuery.value,
+  status: treeStatus.value,
+  sortBy: treeSortBy.value,
+  direction: treeDirection.value,
+  filter: treeFilter.value,
+}));
+
+effect(() => {
+  if (!initialized.value) {
+    return;
+  }
+
+  persist(["treeFilters", treeFiltersState.value]);
+});
+
+export const transitionFilters = computed(() =>
+  transitionFiltersList.map((transition) => [transition, treeFilter.value[transition]] as const),
+);
+
+export const testTypeFilters = computed(() =>
+  (["flaky", "retry"] as const).map((testType) => [testType, treeFilter.value[testType]] as const),
+);

package/src/stores/treeFilters/types.ts

@@ -0,0 +1,12 @@
+import type { AwesomeStatus } from "types";
+
+export type TreeSortBy = "order" | "duration" | "status" | "alphabet";
+export type TreeDirection = "asc" | "desc";
+export type TreeFilters = "flaky" | "retry" | "new" | "fixed" | "regressed" | "malfunctioned";
+export type TreeFiltersState = {
+  query: string;
+  status: AwesomeStatus;
+  filter: Record<TreeFilters, boolean>;
+  sortBy: TreeSortBy;
+  direction: TreeDirection;
+};

package/src/utils/persist.ts

@@ -0,0 +1,23 @@
+class AllurePersistError extends Error {
+  constructor(
+    message: string,
+    public readonly originalError?: Error,
+  ) {
+    super(message);
+    this.name = "AllurePersistError";
+  }
+
+  get message(): string {
+    return `${this.name}: ${this.message}${this.originalError ? `\n${this.originalError.message}` : ""}`;
+  }
+}
+
+export const persist = <T>(pair: [string, T], storage: Storage = localStorage) => {
+  const [key, value] = pair;
+  try {
+    storage.setItem(key, JSON.stringify(value));
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(new AllurePersistError(`Failed to persist ${key} to ${storage.name}`, e as Error));
+  }
+};

package/src/utils/tree.ts

@@ -1,7 +1,7 @@
 import type { RecursiveTree } from "@allurereport/web-components/global";
 import type { AwesomeTreeLeaf } from "types";
 
-type Localizer = (data: string) => string;
+type Localizer = (data: string, params?: Record<string, unknown>) => string;
 
 type Localizers = {
   tooltip: Localizer;
@@ -9,10 +9,17 @@ type Localizers = {
 
 export const createLeafLocalizer =
   (t: Localizers) =>
-  (leaf: AwesomeTreeLeaf): AwesomeTreeLeaf => ({
-    ...leaf,
-    transitionTooltip: t.tooltip(leaf.transition),
-  });
+  (leaf: AwesomeTreeLeaf): AwesomeTreeLeaf => {
+    const tooltips = {
+      transition: t.tooltip(leaf.transition),
+      flaky: leaf.flaky && t.tooltip("flaky"),
+      retries: leaf.retriesCount && t.tooltip("retries", { count: leaf.retriesCount }),
+    };
+    return {
+      ...leaf,
+      tooltips,
+    };
+  };
 
 export const createTreeLocalizer =
   (t: Localizers) =>

package/src/utils/treeFilters.ts

@@ -11,11 +11,23 @@ import {
   ordinal,
   reverse,
 } from "@allurereport/core-api";
-import type { TreeFiltersState, TreeSortBy } from "@/stores/tree";
+import type { TreeFiltersState, TreeSortBy } from "@/stores/treeFilters";
 import type { AwesomeRecursiveTree, AwesomeTree, AwesomeTreeGroup, AwesomeTreeLeaf } from "../../types";
 
+const matchesName = (name: string, query: string) => {
+  return name.toLocaleLowerCase().includes(query.toLocaleLowerCase());
+};
+
+const matchesNodeId = (nodeId: string, query: string) => {
+  return nodeId.toLowerCase() === query.toLocaleLowerCase();
+};
+
 export const isIncluded = (leaf: TreeLeaf<AwesomeTreeLeaf>, filterOptions: TreeFiltersState) => {
-  const queryMatched = !filterOptions?.query || leaf.name.toLowerCase().includes(filterOptions.query.toLowerCase());
+  const queryMatched =
+    !filterOptions?.query ||
+    matchesName(leaf.name, filterOptions.query) ||
+    matchesNodeId(leaf.nodeId, filterOptions.query);
+
   const statusMatched =
     !filterOptions?.status || filterOptions?.status === "total" || leaf.status === filterOptions.status;
   const flakyMatched = !filterOptions?.filter?.flaky || leaf.flaky;
@@ -23,7 +35,7 @@ export const isIncluded = (leaf: TreeLeaf<AwesomeTreeLeaf>, filterOptions: TreeF
   const newMatched = !filterOptions?.filter?.new || leaf.transition === "new";
   const fixedMatched = !filterOptions?.filter?.fixed || leaf.transition === "fixed";
   const regressedMatched = !filterOptions?.filter?.regressed || leaf.transition === "regressed";
-  const malfuctionedMatched = !filterOptions?.filter?.malfunctioned || leaf.transition === "malfunctioned";
+  const malfunctionedMatched = !filterOptions?.filter?.malfunctioned || leaf.transition === "malfunctioned";
 
   return [
     queryMatched,
@@ -33,7 +45,7 @@ export const isIncluded = (leaf: TreeLeaf<AwesomeTreeLeaf>, filterOptions: TreeF
     newMatched,
     fixedMatched,
     regressedMatched,
-    malfuctionedMatched,
+    malfunctionedMatched,
   ].every(Boolean);
 };
 

package/test/stores/treeFilters.test.ts

@@ -0,0 +1,302 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  clearTreeFilters,
+  setTestTypeFilter,
+  setTransitionFilter,
+  setTreeDirection,
+  setTreeQuery,
+  setTreeSortBy,
+  setTreeStatus,
+  treeDirection,
+  treeFilter,
+  treeQuery,
+  treeSortBy,
+  treeStatus,
+} from "@/stores/treeFilters";
+
+const defaultFilter = {
+  flaky: false,
+  retry: false,
+  new: false,
+  fixed: false,
+  regressed: false,
+  malfunctioned: false,
+};
+
+describe("stores > treeFilters", () => {
+  beforeEach(() => {
+    // Reset all signals to default state before each test
+    treeQuery.value = "";
+    treeStatus.value = "total";
+    treeSortBy.value = "order";
+    treeDirection.value = "asc";
+    treeFilter.value = { ...defaultFilter };
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("clearTreeFilters", () => {
+    it("should reset query, status and filters to default state", () => {
+      // Set some non-default values
+      treeQuery.value = "test query";
+      treeStatus.value = "passed";
+      treeFilter.value = {
+        flaky: true,
+        retry: true,
+        new: true,
+        fixed: true,
+        regressed: true,
+        malfunctioned: true,
+      };
+
+      clearTreeFilters();
+
+      expect(treeQuery.value).toBe("");
+      expect(treeStatus.value).toBe("total");
+      expect(treeFilter.value).toEqual(defaultFilter);
+    });
+
+    it("should not reset sortBy and direction", () => {
+      treeSortBy.value = "duration";
+      treeDirection.value = "desc";
+
+      clearTreeFilters();
+
+      expect(treeSortBy.value).toBe("duration");
+      expect(treeDirection.value).toBe("desc");
+    });
+  });
+
+  describe("setTreeQuery", () => {
+    it("should update query", () => {
+      setTreeQuery("search term");
+
+      expect(treeQuery.value).toBe("search term");
+    });
+
+    it("should update query to empty string", () => {
+      treeQuery.value = "some query";
+
+      setTreeQuery("");
+
+      expect(treeQuery.value).toBe("");
+    });
+  });
+
+  describe("setTreeStatus", () => {
+    it("should update status to passed", () => {
+      setTreeStatus("passed");
+
+      expect(treeStatus.value).toBe("passed");
+    });
+
+    it("should update status to failed", () => {
+      setTreeStatus("failed");
+
+      expect(treeStatus.value).toBe("failed");
+    });
+
+    it("should update status to broken", () => {
+      setTreeStatus("broken");
+
+      expect(treeStatus.value).toBe("broken");
+    });
+
+    it("should update status to skipped", () => {
+      setTreeStatus("skipped");
+
+      expect(treeStatus.value).toBe("skipped");
+    });
+
+    it("should update status to total", () => {
+      treeStatus.value = "passed";
+
+      setTreeStatus("total");
+
+      expect(treeStatus.value).toBe("total");
+    });
+  });
+
+  describe("setTreeSortBy", () => {
+    it("should update sortBy to duration", () => {
+      setTreeSortBy("duration");
+
+      expect(treeSortBy.value).toBe("duration");
+    });
+
+    it("should update sortBy to status", () => {
+      setTreeSortBy("status");
+
+      expect(treeSortBy.value).toBe("status");
+    });
+
+    it("should update sortBy to alphabet", () => {
+      setTreeSortBy("alphabet");
+
+      expect(treeSortBy.value).toBe("alphabet");
+    });
+
+    it("should update sortBy to order", () => {
+      treeSortBy.value = "duration";
+
+      setTreeSortBy("order");
+
+      expect(treeSortBy.value).toBe("order");
+    });
+  });
+
+  describe("setTreeDirection", () => {
+    it("should update direction to desc", () => {
+      setTreeDirection("desc");
+
+      expect(treeDirection.value).toBe("desc");
+    });
+
+    it("should update direction to asc", () => {
+      treeDirection.value = "desc";
+
+      setTreeDirection("asc");
+
+      expect(treeDirection.value).toBe("asc");
+    });
+  });
+
+  describe("setTestTypeFilter", () => {
+    it("should enable flaky filter", () => {
+      setTestTypeFilter("flaky", true);
+
+      expect(treeFilter.value.flaky).toBe(true);
+    });
+
+    it("should disable flaky filter", () => {
+      treeFilter.value = { ...defaultFilter, flaky: true };
+
+      setTestTypeFilter("flaky", false);
+
+      expect(treeFilter.value.flaky).toBe(false);
+    });
+
+    it("should enable retry filter", () => {
+      setTestTypeFilter("retry", true);
+
+      expect(treeFilter.value.retry).toBe(true);
+    });
+
+    it("should disable retry filter", () => {
+      treeFilter.value = { ...defaultFilter, retry: true };
+
+      setTestTypeFilter("retry", false);
+
+      expect(treeFilter.value.retry).toBe(false);
+    });
+
+    it("should enable both flaky and retry filters independently", () => {
+      setTestTypeFilter("flaky", true);
+      setTestTypeFilter("retry", true);
+
+      expect(treeFilter.value.flaky).toBe(true);
+      expect(treeFilter.value.retry).toBe(true);
+    });
+
+    it("should not affect transition filters", () => {
+      treeFilter.value = { ...defaultFilter, new: true };
+
+      setTestTypeFilter("flaky", true);
+
+      expect(treeFilter.value.new).toBe(true);
+      expect(treeFilter.value.flaky).toBe(true);
+    });
+  });
+
+  describe("setTransitionFilter", () => {
+    it("should enable new filter", () => {
+      setTransitionFilter("new", true);
+
+      expect(treeFilter.value.new).toBe(true);
+    });
+
+    it("should enable fixed filter", () => {
+      setTransitionFilter("fixed", true);
+
+      expect(treeFilter.value.fixed).toBe(true);
+    });
+
+    it("should enable regressed filter", () => {
+      setTransitionFilter("regressed", true);
+
+      expect(treeFilter.value.regressed).toBe(true);
+    });
+
+    it("should enable malfunctioned filter", () => {
+      setTransitionFilter("malfunctioned", true);
+
+      expect(treeFilter.value.malfunctioned).toBe(true);
+    });
+
+    it("should disable the previous transition when enabling a new one", () => {
+      setTransitionFilter("new", true);
+      expect(treeFilter.value.new).toBe(true);
+
+      setTransitionFilter("fixed", true);
+
+      expect(treeFilter.value.new).toBe(false);
+      expect(treeFilter.value.fixed).toBe(true);
+      expect(treeFilter.value.regressed).toBe(false);
+      expect(treeFilter.value.malfunctioned).toBe(false);
+    });
+
+    it("should disable all other transitions when enabling regressed", () => {
+      treeFilter.value = { ...defaultFilter, new: true, fixed: true };
+
+      setTransitionFilter("regressed", true);
+
+      expect(treeFilter.value.new).toBe(false);
+      expect(treeFilter.value.fixed).toBe(false);
+      expect(treeFilter.value.regressed).toBe(true);
+      expect(treeFilter.value.malfunctioned).toBe(false);
+    });
+
+    it("should allow only one transition to be enabled at a time", () => {
+      setTransitionFilter("new", true);
+      setTransitionFilter("fixed", true);
+      setTransitionFilter("regressed", true);
+      setTransitionFilter("malfunctioned", true);
+
+      expect(treeFilter.value.new).toBe(false);
+      expect(treeFilter.value.fixed).toBe(false);
+      expect(treeFilter.value.regressed).toBe(false);
+      expect(treeFilter.value.malfunctioned).toBe(true);
+    });
+
+    it("should disable the transition when value is false", () => {
+      treeFilter.value = { ...defaultFilter, new: true };
+
+      setTransitionFilter("new", false);
+
+      expect(treeFilter.value.new).toBe(false);
+    });
+
+    it("should disable all transitions when disabling the active one", () => {
+      setTransitionFilter("fixed", true);
+
+      setTransitionFilter("fixed", false);
+
+      expect(treeFilter.value.new).toBe(false);
+      expect(treeFilter.value.fixed).toBe(false);
+      expect(treeFilter.value.regressed).toBe(false);
+      expect(treeFilter.value.malfunctioned).toBe(false);
+    });
+
+    it("should not affect test type filters (flaky, retry)", () => {
+      treeFilter.value = { ...defaultFilter, flaky: true, retry: true };
+
+      setTransitionFilter("new", true);
+
+      expect(treeFilter.value.flaky).toBe(true);
+      expect(treeFilter.value.retry).toBe(true);
+      expect(treeFilter.value.new).toBe(true);
+    });
+  });
+});

package/test/utils/treeFilters.test.ts

@@ -139,6 +139,151 @@ describe("utils > treeFilters", () => {
       expect(result).toEqual([expect.objectContaining({ name: "a1" })]);
     });
 
+    it("filters leaves by name query", () => {
+      const leaves = ["a1", "b2", "c3"];
+      const leavesById = {
+        a1: {
+          name: "Login test",
+          nodeId: "id-001",
+        },
+        b2: {
+          name: "Logout test",
+          nodeId: "id-002",
+        },
+        c3: {
+          name: "Registration test",
+          nodeId: "id-003",
+        },
+      };
+      const result = filterLeaves(leaves, leavesById as any, {
+        query: "Login",
+      });
+
+      expect(result).toEqual([expect.objectContaining({ name: "Login test" })]);
+    });
+
+    it("filters leaves by nodeId query", () => {
+      const leaves = ["a1", "b2", "c3"];
+      const leavesById = {
+        a1: {
+          name: "Login test",
+          nodeId: "abc-123",
+        },
+        b2: {
+          name: "Logout test",
+          nodeId: "def-456",
+        },
+        c3: {
+          name: "Registration test",
+          nodeId: "ghi-789",
+        },
+      };
+      const result = filterLeaves(leaves, leavesById as any, {
+        query: "def-456",
+      });
+
+      expect(result).toEqual([expect.objectContaining({ name: "Logout test", nodeId: "def-456" })]);
+    });
+
+    it("does not match partial nodeId (exact match only)", () => {
+      const leaves = ["a1", "b2", "c3"];
+      const leavesById = {
+        a1: {
+          name: "Test 1",
+          nodeId: "feature-login-001",
+        },
+        b2: {
+          name: "Test 2",
+          nodeId: "feature-login-002",
+        },
+        c3: {
+          name: "Test 3",
+          nodeId: "feature-logout-001",
+        },
+      };
+      const result = filterLeaves(leaves, leavesById as any, {
+        query: "login",
+      });
+
+      // nodeId requires exact match, so no results by nodeId
+      expect(result).toEqual([]);
+    });
+
+    it("matches nodeId with exact query", () => {
+      const leaves = ["a1", "b2", "c3"];
+      const leavesById = {
+        a1: {
+          name: "Test 1",
+          nodeId: "feature-login-001",
+        },
+        b2: {
+          name: "Test 2",
+          nodeId: "feature-login-002",
+        },
+        c3: {
+          name: "Test 3",
+          nodeId: "feature-logout-001",
+        },
+      };
+      const result = filterLeaves(leaves, leavesById as any, {
+        query: "feature-login-001",
+      });
+
+      expect(result).toEqual([expect.objectContaining({ nodeId: "feature-login-001" })]);
+    });
+
+    it("filters leaves matching by name (partial) or nodeId (exact)", () => {
+      const leaves = ["a1", "b2", "c3"];
+      const leavesById = {
+        a1: {
+          name: "Search functionality",
+          nodeId: "test-001",
+        },
+        b2: {
+          name: "Login test",
+          nodeId: "search",
+        },
+        c3: {
+          name: "Logout test",
+          nodeId: "test-003",
+        },
+      };
+      const result = filterLeaves(leaves, leavesById as any, {
+        query: "search",
+      });
+
+      // Both results match: one by name (partial), one by nodeId (exact)
+      expect(result).toHaveLength(2);
+      expect(result).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ name: "Search functionality" }),
+          expect.objectContaining({ nodeId: "search" }),
+        ]),
+      );
+    });
+
+    it("filters leaves case-insensitively by name (partial) and nodeId (exact)", () => {
+      const leaves = ["a1", "b2"];
+      const leavesById = {
+        a1: {
+          name: "LOGIN Test",
+          nodeId: "id-001",
+        },
+        b2: {
+          name: "Other test",
+          nodeId: "login",
+        },
+      };
+      const result = filterLeaves(leaves, leavesById as any, {
+        query: "login",
+      });
+
+      expect(result).toEqual([
+        expect.objectContaining({ name: "LOGIN Test" }),
+        expect.objectContaining({ nodeId: "login" }),
+      ]);
+    });
+
     it("sorts leave by duration in ascending order", () => {
       const leaves = ["a1", "b2", "c3"];
       const leavesById = {

package/types.d.ts

@@ -77,6 +77,7 @@ export type AwesomeTestResult = Omit<
   retry: boolean;
   categories?: AwesomeCategory[];
   environment?: string | "default";
+  tooltips?: Record<string, string>;
 };
 
 export type AwesomeTreeLeaf = Pick<
@@ -85,6 +86,7 @@ export type AwesomeTreeLeaf = Pick<
 > & {
   nodeId: string;
   transitionTooltip?: string;
+  tooltips?: Record<string, string>;
 };
 
 export type AwesomeTreeGroup = WithChildren & DefaultTreeGroup & { nodeId: string };

package/dist/multi/174.app-9931797d1602fc52db5b.js

@@ -1 +0,0 @@
-"use strict";(self.webpackChunk_allurereport_web_awesome=self.webpackChunk_allurereport_web_awesome||[]).push([[174],{4174:function(t){t.exports=JSON.parse('{"statuses":{"passed":"passed","failed":"failed","broken":"broken","skipped":"skipped","unknown":"unknown","total":"total","flakyTests":"flaky","newTests":"new","retryTests":"retry"},"testSummary":{"total":"Total","flaky":"Flaky tests","retries":"Retried tests","new":"New tests"},"tabs":{"total":"All","results":"Results","globalAttachments":"Global Attachments","globalErrors":"Global Errors","qualityGates":"Quality Gates"},"search":{"search":"Search","search-placeholder":"Name or ID"},"filters":{"more-filters":"More filters","enable-filter":"Enable \\"{{filter}}\\" filter","flaky":"Flaky","retry":"Retry","new":"New","fixed":"Fixed","regressed":"Regressed","malfunctioned":"Malfuctioned"},"filters.description":{"flaky":"Show unstable tests","retry":"Show test results that were rerun","new":"Show test results that appear for the first time in this report","fixed":"Show tests that are passed now but had been \\"failed\\" or \\"broken\\" in a previous report","regressed":"Show test results that changed to \\"failed\\" status from \\"passed\\" or \\"broken\\" status","malfunctioned":"Show test results that changed to \\"broken\\" status from \\"passed\\" or \\"failed\\" status"},"sort-by":{"sort-by-text":"Sort by:","sort-by-category":"Sort by","direction-category":"Direction"},"sort-by.values":{"order":"Order","alphabet":"Alphabet","duration":"Duration","status":"Status"},"sort-by.directions":{"order-desc":"Latest – Earliest","order-asc":"Earliest – Latest","order-asc-short":"Earliest","order-desc-short":"Latest","alphabet-asc":"A – Z","alphabet-desc":"Z – A","alphabet-asc-short":"A – Z","alphabet-desc-short":"Z – A","duration-asc":"1 – 9","duration-desc":"9 – 1","duration-asc-short":"1 – 9","duration-desc-short":"9 – 1","status-asc":"As in the filter list","status-desc":"Reversed","status-asc-short":"Regular","status-desc-short":"Reversed"},"empty":{"no-results":"No results","no-tests-found":"No results found","no-message-provided":"No message is provided","clear-filters":"Clear filters","no-attachments-results":"No attachments information available","no-global-errors-results":"No global errors information available","no-quality-gate-results":"No quality gate results available","no-history-results":"No history information available","no-retries-results":"No retries information available","no-test-steps-results":"No test steps information available","no-test-case-results":"No test case results","no-environments-results":"No environments information available"},"severity":{"blocker":"blocker","critical":"critical","normal":"normal","minor":"minor","trivial":"trivial"},"execution":{"name":"Execution","body":"Test body","setup":"Set up","teardown":"Tear down"},"environments":{"environment_one":"Environment","environment_other":"Environments","all":"All"},"ui":{"labels":"Labels","metadata":"Metadata","parameters":"Parameters","description":"Description","links":"Links","overview":"Overview","history":"History","attachments":"Attachments","retries":"Retries","environments":"Environments","error":"Error","goToStep":"Go to step","showLess":"Show less","showMore":"Show more","copy":"Copy","attempt":"Attempt {{attempt}} of {{total}}","at":"at","variables":"Variables","openPwTrace":"Open Playwright Trace","finishedAtOriginal":"{{formattedCreatedAt}}, with exit code {{original}}","finishedAtBoth":"{{formattedCreatedAt}}, with exit code {{actual}} (original {{original}})"},"controls":{"newTabAttachment":"Open attachment in new tab","nextTR":"Next Test result","prevTR":"Previous Test result","downloadAttachment":"Download attachment","backto":"Back to","clipboard":"Copy to clipboard","clipboardError":"Can not copy value to clipboard. Seems like this feature is not supported for your browser","clipboardSuccess":"Successfully copied","collapse":"Collapse","expand":"Expand","fullscreen":"Full screen","language":"Change language","openInNewTab":"Open in new tab","openPreview":"Open preview","noSelectedTR":"No selected Test result","comparison":"Comparison","showDiff":"Show difference","viewMode":"View mode","unified":"Unified","side-by-side":"Side by Side","compareBy":"Compare by","chars":"chars","words":"words","lines":"lines","actual":"Actual","expected":"Expected"},"errors":{"missedAttachment":"Attachment not found"},"sections":{"report":"Report","charts":"Graphs","timeline":"Timeline"},"timeline":{"empty":"No data","empty_host":"No data for {{ host }}","selected_one":"Selected {{ count }} test ({{ percentage }}%) with duration more than {{ minDuration }} and less than {{ maxDuration }}","selected_other":"Selected {{ count }} tests ({{ percentage }}%) with duration more than {{ minDuration }} and less than {{ maxDuration }}","host":"Host: {{ host }}"},"charts":{"trend":{"title":"Trend Chart: {{type}}","type":{"status":"Status","severity":"Severity"}},"currentStatus":{"title":"Current Status","status":{"passed":"$t(statuses:passed, capitalize)","failed":"$t(statuses:failed, capitalize)","broken":"$t(statuses:broken, capitalize)","skipped":"$t(statuses:skipped, capitalize)","unknown":"$t(statuses:unknown, capitalize)"},"percentage":"{{percentage}}%","of":"of {{total}}","total":"total","tests":{"new_zero":"No new tests","new_one":"{{count}} new test","new_other":"{{count}} new tests","flaky_zero":"No flaky tests","flaky_one":"{{count}} flaky test","flaky_other":"{{count}} flaky tests","retries_zero":"No retried tests","retries_one":"{{count}} retried test","retries_other":"{{count}} retried tests"}},"statusDynamics":{"title":"Status dynamics","status":{"passed":"$t(statuses:passed, capitalize)","failed":"$t(statuses:failed, capitalize)","broken":"$t(statuses:broken, capitalize)","skipped":"$t(statuses:skipped, capitalize)","unknown":"$t(statuses:unknown, capitalize)"},"no-history":"$t(empty:no-history-results)","no-results":"$t(empty:no-results)","tooltips":{"current":"Latest report ({{timestamp, timestamp_long_no_seconds}})","history":"Report from {{timestamp, timestamp_long_no_seconds}}"},"ticks":{"current":"Latest","history":"{{timestamp, timestamp_date}}"}},"statusTransitions":{"title":"Status transitions","legend":{"trend":"Fix rate"},"transitions":{"new":"$t(transitions:new, capitalize)","fixed":"$t(transitions:fixed, capitalize)","regressed":"$t(transitions:regressed, capitalize)","malfunctioned":"$t(transitions:malfunctioned, capitalize)"},"no-history":"$t(empty:no-history-results)","no-results":"$t(empty:no-results)","tooltips":{"current":"Latest report ({{timestamp, timestamp_long_no_seconds}})","history":"Report from {{timestamp, timestamp_long_no_seconds}}"},"ticks":{"current":"Latest","history":"{{timestamp, timestamp_date}}"}},"durations":{"title":"Durations by {{groupBy}} histogram","title_none":"Durations histogram","no-results":"$t(empty:no-results)","groupBy":{"none":"None","layer":"Layer"},"ticks":{"durationRange":"{{from, format_duration}} - {{to, format_duration}}"},"tooltips":{"durationRange":"{{from, format_duration}} - {{to, format_duration}}"},"legend":{"value":"{{value}}","total":"Tests count"}},"stabilityDistribution":{"title":"Stability distribution","no-results":"$t(empty:no-results)","legend":{"stabilityRate":"Stability rate"}},"testBaseGrowthDynamics":{"title":"Test base growth dynamics","status":{"newpassed":"New $t(statuses:passed)","newfailed":"New $t(statuses:failed)","newbroken":"New $t(statuses:broken)","newskipped":"New $t(statuses:skipped)","newunknown":"New $t(statuses:unknown)","removedpassed":"Removed $t(statuses:passed)","removedfailed":"Removed $t(statuses:failed)","removedbroken":"Removed $t(statuses:broken)","removedskipped":"Removed $t(statuses:skipped)","removedunknown":"Removed $t(statuses:unknown)"},"legend":{"trend":"Growth trend"},"no-history":"$t(empty:no-history-results)","no-results":"$t(empty:no-results)","tooltips":{"current":"Latest report ({{timestamp, timestamp_long_no_seconds}})","history":"Report from {{timestamp, timestamp_long_no_seconds}}"},"ticks":{"current":"Latest","history":"{{timestamp, timestamp_date}}"}},"fbsuAgePyramid":{"title":"FBSU age pyramid","status":{"passed":"$t(statuses:passed, capitalize)","failed":"$t(statuses:failed, capitalize)","broken":"$t(statuses:broken, capitalize)","skipped":"$t(statuses:skipped, capitalize)","unknown":"$t(statuses:unknown, capitalize)"},"no-history":"$t(empty:no-history-results)","no-results":"$t(empty:no-results)","tooltips":{"current":"Latest report ({{timestamp, timestamp_long_no_seconds}})","history":"Report from {{timestamp, timestamp_long_no_seconds}}"},"ticks":{"current":"Latest","history":"{{timestamp, timestamp_date}}"}},"trSeverities":{"title":"Test results by severities","no-results":"$t(empty:no-results)","status":{"passed":"$t(statuses:passed, capitalize)","failed":"$t(statuses:failed, capitalize)","broken":"$t(statuses:broken, capitalize)","skipped":"$t(statuses:skipped, capitalize)","unknown":"$t(statuses:unknown, capitalize)"},"severity":{"blocker":"$t(severity:blocker, capitalize)","critical":"$t(severity:critical, capitalize)","normal":"$t(severity:normal, capitalize)","minor":"$t(severity:minor, capitalize)","trivial":"$t(severity:trivial, capitalize)","unset":"No severity"}},"durationDynamics":{"title":"Duration dynamics","durations":{"sequential":"Sequential duration","duration":"Test duration","speedup":"Speedup"},"no-results":"$t(empty:no-results)","tooltips":{"current":"Latest report ({{timestamp, timestamp_long_no_seconds}})","history":"Report from {{timestamp, timestamp_long_no_seconds}}"},"ticks":{"current":"Latest","history":"{{timestamp, timestamp_date}}"},"legend":{"duration":"{{duration, format_duration}}","speedup":"{{speedup}}x"}}},"transitions":{"description":{"new":"The first occurrence of this test result in the report","fixed":"A previously \\"failed\\" or \\"broken\\" test that is now \\"passed\\"","regressed":"A previously \\"passed\\" or \\"broken\\" test that is now \\"failed\\"","malfunctioned":"A previously \\"passed\\" or \\"failed\\" test that is now \\"broken\\""},"new":"new","fixed":"fixed","regressed":"regressed","malfunctioned":"malfunctioned"}}')}}]);