@allurereport/web-awesome 3.9.0 → 3.11.0

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

@@ -19,9 +19,25 @@ vi.hoisted(() => {
 
 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 passedStep = {
+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",
@@ -33,10 +49,10 @@ const passedStep = {
     hasSimilarErrorInSubSteps: false,
   },
   suppressInlineError: false,
-  bodyItems: [],
+  bodyItems: [nestedPassedStep],
 } satisfies TrBodyItem;
 
-const failedStep = {
+const failedStepWithContent = {
   type: "step",
   item: {
     stepId: "failed-step",
@@ -48,7 +64,7 @@ const failedStep = {
     hasSimilarErrorInSubSteps: false,
   },
   suppressInlineError: false,
-  bodyItems: [],
+  bodyItems: [nestedPassedStep],
 } satisfies TrBodyItem;
 
 describe("components > TestResult > TrSteps", () => {
@@ -59,15 +75,34 @@ describe("components > TestResult > TrSteps", () => {
     globalThis.allureReportOptions = { stepTreeExpansion: "expand_failed_only" } as any;
   });
 
-  it("collapses passed-only root steps by default with expand_failed_only", () => {
-    const view = render(<TrSteps id="passed-test" bodyItems={[passedStep]} />);
+  it("always shows the steps root container regardless of step status", () => {
+    const view = render(<TrSteps id="test" bodyItems={[passedStepWithContent]} />);
 
-    expect(view.queryByTestId("test-result-steps-root")).not.toBeInTheDocument();
+    expect(view.getByTestId("test-result-steps-root")).toBeInTheDocument();
   });
 
-  it("opens root steps by default when expand_failed_only finds failed context", () => {
-    const view = render(<TrSteps id="failed-test" bodyItems={[passedStep, failedStep]} />);
+  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-steps-root")).toBeInTheDocument();
+    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/stores/treeSort.test.ts

@@ -0,0 +1,58 @@
+import { epic, feature, label, story } from "allure-js-commons";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const STORAGE_KEY = "ALLURE_REPORT_SORT_BY";
+
+beforeEach(async () => {
+  await epic("coverage");
+  await feature("sort");
+  await story("treeSort");
+  await label("coverage", "sort");
+});
+
+describe("stores > treeSort", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    localStorage.clear();
+    delete (globalThis as any).allureReportOptions;
+  });
+
+  it("defaults to order,asc when no config and no localStorage value", async () => {
+    const { sortBy } = await import("../../src/stores/treeSort.js");
+
+    expect(sortBy.value).toBe("order,asc");
+  });
+
+  it("uses defaultSortBy from reportOptions when localStorage is empty", async () => {
+    (globalThis as any).allureReportOptions = { defaultSortBy: "name,asc" };
+
+    const { sortBy } = await import("../../src/stores/treeSort.js");
+
+    expect(sortBy.value).toBe("name,asc");
+  });
+
+  it("is case-insensitive for defaultSortBy", async () => {
+    (globalThis as any).allureReportOptions = { defaultSortBy: "Name,ASC" };
+
+    const { sortBy } = await import("../../src/stores/treeSort.js");
+
+    expect(sortBy.value).toBe("name,asc");
+  });
+
+  it("ignores invalid defaultSortBy and falls back to order,asc", async () => {
+    (globalThis as any).allureReportOptions = { defaultSortBy: "invalid,value" };
+
+    const { sortBy } = await import("../../src/stores/treeSort.js");
+
+    expect(sortBy.value).toBe("order,asc");
+  });
+
+  it("localStorage takes priority over defaultSortBy from reportOptions", async () => {
+    localStorage.setItem(STORAGE_KEY, "duration,desc");
+    (globalThis as any).allureReportOptions = { defaultSortBy: "name,asc" };
+
+    const { sortBy } = await import("../../src/stores/treeSort.js");
+
+    expect(sortBy.value).toBe("duration,desc");
+  });
+});

package/test/utils/time.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { timestampToDate } from "@/utils/time";
+
+const numericDateTimeOptions: Intl.DateTimeFormatOptions = {
+  month: "numeric",
+  day: "numeric",
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  hour12: false,
+};
+
+vi.mock("@/stores/locale", () => ({
+  currentLocale: { value: "en" },
+  currentLocaleIso: { value: "en-US" },
+  useI18n: () => ({
+    t: (key: string) => (key === "at" ? "at" : key),
+  }),
+}));
+
+vi.mock("@allurereport/web-commons", async (importOriginal) => ({
+  ...(await importOriginal()),
+  getLocaleDateTimeOverride: () => undefined,
+}));
+
+describe("utils > timestampToDate", () => {
+  it("should keep Intl-provided at separator for long English dates", () => {
+    const timestamp = 1527776360360;
+    const options: Intl.DateTimeFormatOptions = {
+      month: "long",
+      day: "numeric",
+      year: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric",
+    };
+    const intlFormatted = new Intl.DateTimeFormat("en-US", options).format(new Date(timestamp));
+    const formatted = timestampToDate(timestamp, options);
+
+    expect(formatted).toBe(intlFormatted);
+    expect(formatted).not.toContain("May 31 at 2018 at");
+  });
+
+  it("should add at separator when Intl returns comma-separated date and time", () => {
+    const timestamp = 1779887536194;
+    const intlFormatted = new Intl.DateTimeFormat("en-US", numericDateTimeOptions).format(new Date(timestamp));
+
+    expect(timestampToDate(timestamp, numericDateTimeOptions)).toBe(intlFormatted.replace(",", " at"));
+  });
+});

package/test/utils/treeFilters.test.ts

@@ -345,6 +345,110 @@ describe("utils > treeFilters", () => {
       );
     });
 
+    it("sorts groups by earliest leaf groupOrder when sorting by order ascending", () => {
+      const group = {
+        leaves: [],
+        groups: ["groupA", "groupB", "groupC"],
+      };
+      const leavesById = {
+        t1: { name: "t1", status: "passed", groupOrder: 5 } as AwesomeTestResult,
+        t2: { name: "t2", status: "passed", groupOrder: 2 } as AwesomeTestResult,
+        t3: { name: "t3", status: "passed", groupOrder: 8 } as AwesomeTestResult,
+      };
+      const groupsById = {
+        groupA: { name: "groupA", leaves: ["t1"], groups: [] as string[] },
+        groupB: { name: "groupB", leaves: ["t2"], groups: [] as string[] },
+        groupC: { name: "groupC", leaves: ["t3"], groups: [] as string[] },
+      };
+      const result = createRecursiveTree({
+        group: group as any,
+        leavesById: leavesById as any,
+        groupsById: groupsById as any,
+        filterPredicate: alwaysTruePredicate,
+        sortBy: "order,asc",
+      });
+
+      expect(result.trees.map((t) => t.name)).toEqual(["groupB", "groupA", "groupC"]);
+    });
+
+    it("sorts groups by earliest leaf groupOrder when sorting by order descending", () => {
+      const group = {
+        leaves: [],
+        groups: ["groupA", "groupB", "groupC"],
+      };
+      const leavesById = {
+        t1: { name: "t1", status: "passed", groupOrder: 5 } as AwesomeTestResult,
+        t2: { name: "t2", status: "passed", groupOrder: 2 } as AwesomeTestResult,
+        t3: { name: "t3", status: "passed", groupOrder: 8 } as AwesomeTestResult,
+      };
+      const groupsById = {
+        groupA: { name: "groupA", leaves: ["t1"], groups: [] as string[] },
+        groupB: { name: "groupB", leaves: ["t2"], groups: [] as string[] },
+        groupC: { name: "groupC", leaves: ["t3"], groups: [] as string[] },
+      };
+      const result = createRecursiveTree({
+        group: group as any,
+        leavesById: leavesById as any,
+        groupsById: groupsById as any,
+        filterPredicate: alwaysTruePredicate,
+        sortBy: "order,desc",
+      });
+
+      expect(result.trees.map((t) => t.name)).toEqual(["groupC", "groupA", "groupB"]);
+    });
+
+    it("sorts groups by aggregated duration when sorting by duration ascending", () => {
+      const group = {
+        leaves: [],
+        groups: ["groupA", "groupB", "groupC"],
+      };
+      const leavesById = {
+        t1: { name: "t1", status: "passed", duration: 3000 } as AwesomeTestResult,
+        t2: { name: "t2", status: "passed", duration: 1000 } as AwesomeTestResult,
+        t3: { name: "t3", status: "passed", duration: 5000 } as AwesomeTestResult,
+      };
+      const groupsById = {
+        groupA: { name: "groupA", leaves: ["t1"], groups: [] as string[] },
+        groupB: { name: "groupB", leaves: ["t2"], groups: [] as string[] },
+        groupC: { name: "groupC", leaves: ["t3"], groups: [] as string[] },
+      };
+      const result = createRecursiveTree({
+        group: group as any,
+        leavesById: leavesById as any,
+        groupsById: groupsById as any,
+        filterPredicate: alwaysTruePredicate,
+        sortBy: "duration,asc",
+      });
+
+      expect(result.trees.map((t) => t.name)).toEqual(["groupB", "groupA", "groupC"]);
+    });
+
+    it("sorts groups by aggregated duration when sorting by duration descending", () => {
+      const group = {
+        leaves: [],
+        groups: ["groupA", "groupB", "groupC"],
+      };
+      const leavesById = {
+        t1: { name: "t1", status: "passed", duration: 3000 } as AwesomeTestResult,
+        t2: { name: "t2", status: "passed", duration: 1000 } as AwesomeTestResult,
+        t3: { name: "t3", status: "passed", duration: 5000 } as AwesomeTestResult,
+      };
+      const groupsById = {
+        groupA: { name: "groupA", leaves: ["t1"], groups: [] as string[] },
+        groupB: { name: "groupB", leaves: ["t2"], groups: [] as string[] },
+        groupC: { name: "groupC", leaves: ["t3"], groups: [] as string[] },
+      };
+      const result = createRecursiveTree({
+        group: group as any,
+        leavesById: leavesById as any,
+        groupsById: groupsById as any,
+        filterPredicate: alwaysTruePredicate,
+        sortBy: "duration,desc",
+      });
+
+      expect(result.trees.map((t) => t.name)).toEqual(["groupC", "groupA", "groupB"]);
+    });
+
     it("keeps problem-heavy groups first when sorting by status in descending order", () => {
       const group = {
         leaves: [],

package/types.d.ts

@@ -14,6 +14,23 @@ import type {
 export type Layout = "base" | "split";
 export type StepTreeExpansion = "collapsed" | "expand_failed_only" | "expanded";
 
+export type AwesomeRunSummary = {
+  start: number;
+  stop: number;
+  duration: number;
+};
+
+export type AwesomeExecutorInfo = {
+  name?: string;
+  type?: string;
+  url?: string;
+  buildOrder?: number;
+  buildName?: string;
+  buildUrl?: string;
+  reportName?: string;
+  reportUrl?: string;
+};
+
 export type AwesomeReportOptions = {
   allureVersion: string;
   reportName?: string;
@@ -28,7 +45,10 @@ export type AwesomeReportOptions = {
   sections?: string[];
   cacheKey: string;
   ci?: CiDescriptor;
+  executor?: AwesomeExecutorInfo;
+  runSummary?: AwesomeRunSummary;
   stepTreeExpansion?: StepTreeExpansion;
+  defaultSortBy?: string;
 };
 
 export type AwesomeFixtureResult = Omit<
@@ -122,6 +142,8 @@ export type AwesomeRecursiveTree = DefaultTreeGroup & {
   nodeId: string;
   leaves: AwesomeTreeLeaf[];
   trees: AwesomeRecursiveTree[];
+  duration: number;
+  groupOrder: number;
 };
 
 // TODO: maybe it should call `TestCase` instead of Group

package/webpack.config.js

@@ -1,14 +1,16 @@
+import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { env } from "node:process";
 import { fileURLToPath } from "node:url";
 
-import ForkTsCheckerPlugin from "fork-ts-checker-webpack-plugin";
-import HtmlWebpackPlugin from "html-webpack-plugin";
-import MiniCssExtractPlugin from "mini-css-extract-plugin";
-import SpriteLoaderPlugin from "svg-sprite-loader/plugin.js";
-import TerserPlugin from "terser-webpack-plugin";
-import webpack from "webpack";
-import { WebpackManifestPlugin } from "webpack-manifest-plugin";
+const require = createRequire(import.meta.url);
+const ForkTsCheckerPlugin = require("fork-ts-checker-webpack-plugin");
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+const MiniCssExtractPlugin = require("mini-css-extract-plugin");
+const SpriteLoaderPlugin = require("svg-sprite-loader/plugin");
+const TerserPlugin = require("terser-webpack-plugin");
+const webpack = require("webpack");
+const { WebpackManifestPlugin } = require("webpack-manifest-plugin");
 
 const { SINGLE_FILE_MODE } = env;
 const baseDir = dirname(fileURLToPath(import.meta.url));

package/dist/multi/173.app-d36b0855e3e7a53eeee9.js

@@ -1 +0,0 @@
-"use strict";(self.webpackChunk_allurereport_web_awesome=self.webpackChunk_allurereport_web_awesome||[]).push([[173],{9173:function(t){t.exports=JSON.parse('{"statuses":{"passed":"წარმატებული","failed":"წარუმატებელი","broken":"დამტვრეული","skipped":"გამოტოვებული","unknown":"უცნობი","total":"ჯამი","flakyTests":"არასტაბილური","newTests":"ახალი","retryTests":"ხელახალი ცდა"},"testSummary":{"total":"ჯამი","flaky":"არასტაბილური ტესტები","retries":"ხელახალი ტესტები","new":"ახალი ტესტები"},"tabs":{"total":"ყველა","results":"შედეგები","globalAttachments":"გლობალური დანართები","globalErrors":"გლობალური შეცდომები","qualityGates":"ხარისხის კარიბჭეები","categories":"კატეგორიები"},"search":{"search":"ძებნა","search-placeholder":"ტესტების ძიება"},"filters":{"flaky":"არასტაბილური","nonFlaky":"სტაბილური","retry":"ხელახალი","new":"ახალი","fixed":"გასწორებული","regressed":"რეგრესია","malfunctioned":"დაზიანებული","transition":"გადასვლა","status":"სტატუსი","severity":"სიმძიმე","owner":"მფლობელი","layer":"ფენა","tags":"ტეგები","categories":"კატეგორიები","goto_filter":"ფილტრზე გადასვლა","errors":{"max_values_one":"ფილტრაციისთვის გამოიყენება მხოლოდ პირველი {{count}} მნიშვნელობა.\\nდამატებითი მნიშვნელობები იგნორირდება","max_values_other":"ფილტრაციისთვის გამოიყენება მხოლოდ პირველი {{count}} მნიშვნელობა.\\nდამატებითი მნიშვნელობები იგნორირდება"},"description":{"flaky":"არასტაბილური ტესტების ჩვენება","retry":"განმეორებით გაშვებული ტესტების შედეგების ჩვენება","new":"აჩვენებს ტესტების შედეგებს, რომლებიც პირველად ჩანს ამ ანგარიშში","fixed":"აჩვენებს ტესტებს, რომლებიც ახლა წარმატებულია, მაგრამ ადრე იყო \\"წარუმატებელი\\" ან \\"დამტვრეული\\"","regressed":"აჩვენებს ტესტების შედეგებს, რომლებმაც შეცვალეს სტატუსი \\"წარმატებული\\" ან \\"დამტვრეული\\"-დან \\"წარუმატებელი\\"-ზე","malfunctioned":"აჩვენებს ტესტების შედეგებს, რომლებმაც შეცვალეს სტატუსი \\"წარმატებული\\" ან \\"წარუმატებელი\\"-დან \\"დამტვრეული\\"-ზე","tags":"აჩვენებს ტესტების შედეგებს, რომლებსაც აქვთ მითითებული ტეგები","categories":"აჩვენებს ტესტების შედეგებს, რომლებსაც აქვთ მითითებული კატეგორიები"}},"sort-by":{"sort-by-text":"დალაგება:","sort-by-category":"დალაგება","direction-category":"მიმართულება"},"sort-by.values":{"order":"შეკვეთა","alphabet":"ანბანი","duration":"ხანგრძლივობა","status":"სტატუსი"},"sort-by.directions":{"order-desc":"ბოლო – პირველი","order-asc":"პირველი – ბოლო","order-asc-short":"პირველი","order-desc-short":"ბოლო","alphabet-asc":"ა – ჰ","alphabet-desc":"ჰ – ა","alphabet-asc-short":"ა – ჰ","alphabet-desc-short":"ჰ – ა","duration-asc":"1 – 9","duration-desc":"9 – 1","duration-asc-short":"1 – 9","duration-desc-short":"9 – 1","status-asc":"როგორც ფილტრის სიაში","status-desc":"შებრუნებული","status-asc-short":"ჩვეულებრივი","status-desc-short":"შებრუნებული"},"empty":{"no-results":"შედეგები არ არის","no-value":"მნიშვნელობა არ არის","no-value-for":"მნიშვნელობა არ არის: {{entity}}","no-transition":"გადასვლა არ არის","no-layer":"ფენა არ არის","no-owner":"მფლობელი არ არის","no-severity":"სიმძიმე არ არის","no-status":"სტატუსი არ არის","no-environment":"გარემო არ არის","no-flaky":"არასტაბილურობა არ არის","empty-value":"ცარიელი","no-tests-found":"შედეგები არ მოიძებნა","no-message-provided":"შეტყობინება არ არის მოწოდებული","clear-filters":"ფილტრების გასუფთავება","no-attachments-results":"დანართების ინფორმაცია არ არის ხელმისაწვდომი","no-global-errors-results":"გლობალური შეცდომების ინფორმაცია არ არის ხელმისაწვდომი","no-quality-gate-results":"ხარისხის კარიბჭის შედეგები არ არის ხელმისაწვდომი","no-history-results":"ისტორიის ინფორმაცია არ არის ხელმისაწვდომი","no-retries-results":"ხელახალი ცდების ინფორმაცია არ არის ხელმისაწვდომი","no-test-steps-results":"ტესტის ნაბიჯების ინფორმაცია ხელმისაწვდომი არ არის","no-test-case-results":"ტესტის შემთხვევის შედეგები არ არის","no-environments-results":"გარემობის ინფორმაცია არ არის ხელმისაწვდომი","no-categories-results":"კატეგორიები ხელმისაწვდომი არ არის"},"severity":{"blocker":"ბლოკერი","critical":"კრიტიკული","normal":"ჩვეულებრივი","minor":"მნიშვნელობა","trivial":"უმნიშვნელო"},"execution":{"name":"შესრულება","body":"ტესტის შინაარსი","setup":"მომზადება","teardown":"დასრულება"},"environments":{"environment_one":"გარემობა","environment_other":"გარემობები","all":"ყველა"},"ui":{"labels":"ლეიბლები","metadata":"მეტამონაცემები","parameters":"პარამეტრები","category":"კატეგორია","description":"აღწერა","links":"ბმულები","overview":"მიმოხილვა","history":"ისტორია","attachments":"დანართები","retries":"ხელახალი ცდები","environments":"გარემობები","error":"შეცდომა","goToStep":"გადადით საფეხურზე","showLess":"ნაკლების ჩვენება","showMore":"მეტის ჩვენება","copy":"კოპირება","copy-email":"ელფოსტის კოპირება","attempt":"მცდელობა {{attempt}} {{total}}-დან","at":"ზე","variables":"ცვლადები","openPwTrace":"გახსენი Playwright Trace","pwTracePopupBlocked":"ბრაუზერმა დაბლოკა Playwright Trace Viewer-ის გახსნა.","pwTracePopupBlockedHint":"დაუშვით ამომხტარი ფანჯრები და ხელახლა სცადეთ.","finishedAtOriginal":"{{formattedCreatedAt}}, გამოსვლის კოდით {{original}}","finishedAtBoth":"{{formattedCreatedAt}}, გამოსვლის კოდით {{actual}} (თავდაპირველი {{original}})"},"controls":{"newTabAttachment":"დანართის გახსნა ახალ ჩანართში","nextTR":"შემდეგი ტესტის შედეგი","prevTR":"წინა ტესტის შედეგი","downloadAttachment":"დანართის ჩამოტვირთვა","previewAttachment":"წინასწარი ნახვა","viewCode":"კოდის ჩვენება","syntaxHighlight":"სინტაქსის მონიშვნა","backto":"უკან დაბრუნება","clipboard":"კოპირება ბუფერში","clipboardError":"ბუფერში კოპირება ვერ მოხერხდა. შესაძლოა, ფუნქცია არ იყოს მხარდაჭერილი თქვენს ბრაუზერში","clipboardSuccess":"წარმატებით დაკოპირდა","collapse":"ჩაკეცვა","expand":"გახსნა","fullscreen":"სრულ ეკრანზე","language":"ენის შეცვლა","openInNewTab":"გახსნა ახალ ჩანართში","openPreview":"გახსენი წინასწარი დათვალიერება","noSelectedTR":"არჩეული ტესტის შედეგი არ არის","comparison":"შედარება","showDiff":"მაჩვენე განსხვავება","viewMode":"ნახვის რეჟიმი","unified":"გაერთიანებული","side-by-side":"გვერდიგვერდ","compareBy":"შედარება","chars":"სიმბოლოები","words":"სიტყვები","lines":"ხაზები","actual":"ნამდვილი","expected":"მოსალოდნელი"},"errors":{"missedAttachment":"დანართი ვერ მოიძებნა"},"sections":{"report":"Report","charts":"გრაფიკები","timeline":"დროის ხაზი"},"timeline":{"empty":"მონაცემები არ არის","empty_host":"მონაცემები არ არის {{ host }}-ისთვის","selected_one":"არჩეულია {{ count }} ტესტი ({{ percentage }}%) {{ minDuration }}-ზე მეტი და {{ maxDuration }}-ზე ნაკლები ხანგრძლივობით","selected_other":"არჩეულია {{ count }} ტესტი ({{ percentage }}%) {{ minDuration }}-ზე მეტი და {{ maxDuration }}-ზე ნაკლები ხანგრძლივობით","host":"ჰოსტი: {{ host }}"},"charts":{"trend":{"title":"ტრენდის გრაფიკი: {{type}}","type":{"status":"სტატუსი","severity":"სიმძიმე"}},"currentStatus":{"title":"მიმდინარე სტატუსი","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":"{{total}}-დან","total":"სულ","tests":{"new_zero":"ახალი ტესტები არ არის","new_one":"{{count}} ახალი ტესტი","new_other":"{{count}} ახალი ტესტი","flaky_zero":"არასტაბილური ტესტები არ არის","flaky_one":"{{count}} არასტაბილური ტესტი","flaky_other":"{{count}} არასტაბილური ტესტი","retries_zero":"განმეორებითი ტესტები არ არის","retries_one":"{{count}} განმეორებითი ტესტი","retries_other":"{{count}} განმეორებითი ტესტი"}},"statusDynamics":{"title":"სტატუსის დინამიკა","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":"ბოლო ანგარიში ({{timestamp, timestamp_long_no_seconds}})","history":"{{timestamp, timestamp_long_no_seconds}} ანგარიში"},"ticks":{"current":"ბოლო","history":"{{timestamp, timestamp_date}}"}},"statusTransitions":{"title":"სტატუსის გადასვლები","legend":{"trend":"გამოსწორების მაჩვენებელი"},"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":"ბოლო ანგარიში ({{timestamp, timestamp_long_no_seconds}})","history":"{{timestamp, timestamp_long_no_seconds}} ანგარიში"},"ticks":{"current":"ბოლო","history":"{{timestamp, timestamp_date}}"}},"durations":{"title":"ხანგრძლივობის ჰისტოგრამა {{groupBy}}-ის მიხედვით","title_none":"ხანგრძლივობის ჰისტოგრამა","no-results":"$t(empty:no-results)","groupBy":{"none":"არცერთი","layer":"ფენა"},"ticks":{"durationRange":"{{from, format_duration}} - {{to, format_duration}}"},"tooltips":{"durationRange":"{{from, format_duration}} - {{to, format_duration}}"},"legend":{"value":"{{value}}","total":"ტესტების რაოდენობა"}},"stabilityDistribution":{"title":"სტაბილურობის განაწილება","no-results":"$t(empty:no-results)","legend":{"stabilityRate":"სტაბილურობის მაჩვენებელი"}},"testBaseGrowthDynamics":{"title":"ტესტების ბაზის ზრდის დინამიკა","status":{"newpassed":"ახალი $t(statuses:passed)","newfailed":"ახალი $t(statuses:failed)","newbroken":"ახალი $t(statuses:broken)","newskipped":"ახალი $t(statuses:skipped)","newunknown":"ახალი $t(statuses:unknown)","removedpassed":"წაშლილი $t(statuses:passed)","removedfailed":"წაშლილი $t(statuses:failed)","removedbroken":"წაშლილი $t(statuses:broken)","removedskipped":"წაშლილი $t(statuses:skipped)","removedunknown":"წაშლილი $t(statuses:unknown)"},"legend":{"trend":"ზრდის ტენდენция"},"no-history":"$t(empty:no-history-results)","no-results":"$t(empty:no-results)","tooltips":{"current":"უახლესი ანგარიში ({{timestamp, timestamp_long_no_seconds}})","history":"ანგარიში {{timestamp, timestamp_long_no_seconds}}"},"ticks":{"current":"უახლესი","history":"{{timestamp, timestamp_date}}"}},"statusAgePyramid":{"title":"ასაკობრივი პირამიდა სტატუსის მიხედვით","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":"უახლესი ანგარიში ({{timestamp, timestamp_long_no_seconds}})","history":"ანგარიში {{timestamp, timestamp_long_no_seconds}}"},"ticks":{"current":"უახლესი","history":"{{timestamp, timestamp_date}}"}},"trSeverities":{"title":"ტესტის შედეგები სიმძიმის მიხედვით","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":"სიმძიმე არ არის"}},"durationDynamics":{"title":"ხანგრძლივობის დინამიკა","durations":{"sequential":"თანმიმდევრული ხანგრძლივობა","duration":"ტესტის ხანგრძლივობა","speedup":"აჩქარება"},"no-results":"$t(empty:no-results)","tooltips":{"current":"ბოლო ანგარიში ({{timestamp, timestamp_long_no_seconds}})","history":"{{timestamp, timestamp_long_no_seconds}} ანგარიში"},"ticks":{"current":"ბოლო","history":"{{timestamp, timestamp_date}}"},"legend":{"duration":"{{duration, format_duration}}","speedup":"{{speedup}}x"}}},"transitions":{"description":{"new":"ამ ტესტის შედეგის პირველი გამოჩენა ანგარიშში","fixed":"ადრე \\"წარუმატებელი\\" ან \\"დამტვრეული\\" ტესტი, რომელიც ახლა \\"წარმატებული\\"ა","regressed":"ადრე \\"წარმატებული\\" ან \\"დამტვრეული\\" ტესტი, რომელიც ახლა \\"წარუმატებელი\\"ა","malfunctioned":"ადრე \\"წარმატებული\\" ან \\"წარუმატებელი\\" ტესტი, რომელიც ახლა \\"დამტვრეული\\"ა","retries":"{{count}} ხელახალი ცდა","flaky":"შედეგები არასტაბილურია გაშვებებს შორის"},"new":"ახალი","fixed":"გასწორებული","regressed":"რეგრესია","malfunctioned":"დაზიანებული"},"trHistory":{"unknown-date":"უცნობი თარიღი"},"attachments":{"imageDiff":{"mode":{"diff":"სხვაობა","actual":"ფაქტობრივი","expected":"მოსალოდნელი","side-by-side":"გვერდიგვერდ","overlay":"ფენა"},"empty":{"failed-to-load":"სურათების შედარების ჩატვირთვა ვერ მოხერხდა"},"image":{"diff":"სხვაობა","actual":"ფაქტობრივი","expected":"მოსალოდნელი"}}},"shortcuts":{"title":"კლავიატურის მალსახმობები","groups":{"global":"ზოგადი","tree":"ხე","testResult":"ტესტის შედეგი"},"items":{"toggleHelp":"მალსახმობების ჩვენება ან დამალვა","focusSearch":"ძიებაზე ფოკუსირება","blurSearch":"ძიებიდან გასვლა","focusTree":"ხის პანელზე ფოკუსირება","focusTestResult":"ტესტის შედეგის პანელზე ფოკუსირება","toggleLayout":"გაყოფილი ხედის გადართვა (Shift+L)","toggleLayoutAlt":"გაყოფილი ხედის გადართვა (Ctrl/Cmd+\\\\)","moveUp":"ზევით გადაადგილება","moveDown":"ქვევით გადაადგილება","collapse":"ჩაკეცვა / მშობელზე გადასვლა","expand":"გაშლა / პირველი შვილი","parent":"მშობელზე გადასვლა (p)","parentAlt":"მშობელზე გადასვლა (u)","openNode":"ტესტის გახსნა / ჯგუფის გადართვა (o)","collapseNode":"კვანძის ჩაკეცვა (-)","expandNode":"კვანძის გაშლა (+)","collapseAll":"ყველა შვილის ჩაკეცვა (C)","expandAll":"ყველა შვილის გაშლა (A)","subtreeCycle":"ქვეხის ჩაკეცვა/გაშლის ციკლი — ისრის ღილაკის მსგავსად (>)","subtreeCollapse":"მთელი ქვეხის ჩაკეცვა (Shift+C)","subtreeExpand":"მთელი ქვეხის გაშლა (Shift+A)","subtreeFirstLevel":"მხოლოდ პირველი დონის გაშლა (f)","toggleNode":"ჯგუფის ან გარემოს გადართვა","openTest":"ტესტის შედეგის გახსნა","firstTest":"პირველ ტესტზე გადასვლა (g g), სიის ზევით გადახვევა","lastTest":"ბოლო ტესტზე გადასვლა","treeTop":"პირველი მწკრივი + ზევით გადახვევა (Home)","scrollTreeTop":"ზევით გადახვევა — ცვლადების და ფილტრების ჩვენება (z t)","toggleReportVariables":"ცვლადების ჩვენება/დამალვა","toggleReportMetadata":"მეტამონაცემების ჩვენება/დამალვა","reportTabResults":"ანგარიშის ჩანართი: შედეგები","reportTabCategories":"ანგარიშის ჩანართი: კატეგორიები","reportTabQualityGate":"ანგარიშის ჩანართი: ხარისხის კარიბჭე","reportTabGlobalAttachments":"ანგარიშის ჩანართი: გლობალური დანართები","reportTabGlobalErrors":"ანგარიშის ჩანართი: გლობალური შეცდომები","reportTabNext":"შემდეგი ანგარიშის ჩანართი","reportTabPrev":"წინა ანგარიშის ჩანართი","nextTest":"შემდეგი ტესტის შედეგი","prevTest":"წინა ტესტის შედეგი","testTabNext":"შემდეგი ტესტის ჩანართი","testTabPrev":"წინა ტესტის ჩანართი","tabOverview":"მიმოხილვის ჩანართი","tabHistory":"ისტორიის ჩანართი","tabRetries":"გამეორებების ჩანართი","tabAttachments":"დანართების ჩანართი","tabEnvironments":"გარემოების ჩანართი","toggleLabels":"ლეიბლების ჩვენება/დამალვა","toggleParameters":"პარამეტრების ჩვენება/დამალვა","toggleLinks":"ბმულების ჩვენება/დამალვა","backToTree":"ხეზე დაბრუნება"}}}')}}]);