@allurereport/web-classic 3.0.0-beta.8 → 3.0.0

package/src/utils/attachments.ts

@@ -0,0 +1,156 @@
+import { fetchReportAttachment } from "@allurereport/web-commons";
+
+export interface Attachments {
+  id?: string;
+  ext?: string;
+  contentType?: string;
+}
+
+const fetchFromUrl = async ({ id, ext, contentType }: Attachments) => {
+  const fileName = `${id || "-"}${ext || ""}`;
+
+  return fetchReportAttachment(`data/attachments/${fileName}?attachment`, contentType);
+};
+
+export const fetchAttachment = async (id: string, ext: string, contentType: string) => {
+  if (!id && !ext) {
+    return;
+  }
+  const response = await fetchFromUrl({ id, ext, contentType });
+  const fileType = attachmentType(contentType);
+
+  switch (fileType.type) {
+    case "svg":
+    case "image": {
+      const blob = await response.blob();
+      const img = URL.createObjectURL(blob);
+      return { img, id };
+    }
+    case "uri":
+    case "code":
+    case "html":
+    case "table":
+    case "text": {
+      const text = await response.text();
+      return { text };
+    }
+    case "video": {
+      const blob = await response.blob();
+      const src = URL.createObjectURL(blob);
+      return { src, id, contentType };
+    }
+    default:
+      return;
+  }
+};
+
+export const blobAttachment = async (id: string, ext: string, contentType: string) => {
+  const response = await fetchFromUrl({ id, ext, contentType });
+  return await response.blob();
+};
+
+export const downloadAttachment = async (id: string, ext: string, contentType: string) => {
+  if (!id && !ext) {
+    return;
+  }
+
+  const fileName = `${id}${ext}`;
+  const blob = await blobAttachment(id, ext, contentType);
+  const linkUrl = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = linkUrl;
+  link.download = fileName;
+  link.click();
+  URL.revokeObjectURL(linkUrl);
+};
+
+export const openAttachmentInNewTab = async (id: string, ext: string, contentType: string) => {
+  if (!id && !ext) {
+    return;
+  }
+  const blob = await blobAttachment(id, ext, contentType);
+  const linkUrl = URL.createObjectURL(blob);
+  globalThis.open(linkUrl, "_blank");
+};
+
+export const attachmentType = (type: string) => {
+  switch (type) {
+    case "image/bmp":
+    case "image/gif":
+    case "image/tiff":
+    case "image/jpeg":
+    case "image/jpg":
+    case "image/png":
+    case "image/*":
+      return {
+        type: "image",
+        icon: "file",
+      };
+    case "text/xml":
+    case "application/xml":
+    case "application/json":
+    case "text/json":
+    case "text/yaml":
+    case "application/yaml":
+    case "application/x-yaml":
+    case "text/x-yaml":
+    case "text/css":
+      return {
+        type: "code",
+        icon: "file",
+      };
+    case "text/plain":
+    case "text/*":
+      return {
+        type: "text",
+        icon: "txt",
+      };
+    case "text/html":
+      return {
+        type: "html",
+        icon: "file",
+      };
+    case "text/csv":
+      return {
+        type: "table",
+        icon: "csv",
+      };
+    case "text/tab-separated-values":
+      return {
+        type: "table",
+        icon: "table",
+      };
+    case "image/svg+xml":
+      return {
+        type: "svg",
+        icon: "file",
+      };
+    case "video/mp4":
+    case "video/ogg":
+    case "video/webm":
+      return {
+        type: "video",
+        icon: "file",
+      };
+    case "text/uri-list":
+      return {
+        type: "uri",
+        icon: "list",
+      };
+    case "application/x-tar":
+    case "application/x-gtar":
+    case "application/x-bzip2":
+    case "application/gzip":
+    case "application/zip":
+      return {
+        type: "archive",
+        icon: "file",
+      };
+    default:
+      return {
+        type: null,
+        icon: "file",
+      };
+  }
+};
+export const restrictedContentTypes = ["application/gzip"];

package/src/utils/copyToClipboard.ts

@@ -0,0 +1,16 @@
+export const copyToClipboard = async (text: string) => {
+  if (navigator.clipboard) {
+    await navigator.clipboard.writeText(text);
+    return;
+  }
+
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  textarea.style.opacity = "0";
+  document.body.appendChild(textarea);
+  textarea.focus();
+  textarea.select();
+  document.execCommand("copy");
+  document.body.removeChild(textarea);
+};

package/src/utils/isMac.ts

@@ -0,0 +1,8 @@
+export const testPlatform = (re: RegExp) => {
+  // @ts-ignore
+  const platform: string = window?.navigator?.userAgentData?.platform ?? window?.navigator?.platform;
+
+  return platform ? re.test(platform) : false;
+};
+
+export const isMac = testPlatform(/^Mac/i);

package/src/utils/navigate.ts

@@ -0,0 +1,7 @@
+export const navigateTo = (path: string) => {
+  globalThis.location.hash = path;
+};
+
+export const openInNewTab = (path: string) => {
+  window.open(`#${path}`, "_blank");
+};

package/src/utils/statuses.ts

@@ -0,0 +1,55 @@
+import type { DefaultTreeGroup, DefaultTreeLeaf, TestStatus, TreeData } from "@allurereport/core-api";
+
+export type Stats = Record<TestStatus, number> & { total?: number };
+
+const emptyStat: Stats = { failed: 0, broken: 0, passed: 0, skipped: 0, unknown: 0 };
+
+const statisticByIds = (tree: TreeData<DefaultTreeLeaf, DefaultTreeGroup>, ids: string[]): Stats => {
+  return ids
+    .map((id) => tree.leavesById[id])
+    .filter((v) => v)
+    .reduce(
+      (prev, current) => {
+        prev[current.status]++;
+        return prev;
+      },
+      { ...emptyStat },
+    );
+};
+
+const mergeStats = (stat1: Stats, stat2: Stats): Stats => {
+  Object.keys(stat1).forEach((key) => {
+    stat1[key as TestStatus] += stat2[key as TestStatus];
+  });
+  return stat1;
+};
+
+export const getGroupStatistics = (
+  tree: TreeData<DefaultTreeLeaf, DefaultTreeGroup>,
+  groupId: string,
+  statusFilter?: string,
+): Stats => {
+  const group = tree.groupsById[groupId];
+  let stat: Stats = { ...emptyStat };
+
+  if (group?.leaves?.length) {
+    stat = mergeStats(stat, statisticByIds(tree, group.leaves));
+  }
+
+  if (group?.groups?.length) {
+    for (const subGroupId of group.groups) {
+      const subGroupStat = getGroupStatistics(tree, subGroupId, statusFilter);
+      stat = mergeStats(stat, subGroupStat);
+    }
+  }
+
+  return stat;
+};
+
+export const getStatistics = (tree: TreeData<DefaultTreeLeaf, DefaultTreeGroup>) =>
+  tree.root.groups
+    ?.map((groupId) => {
+      const stat = getGroupStatistics(tree, groupId);
+      return { name: tree.groupsById[groupId].name, statistic: stat };
+    })
+    ?.sort((a, b) => a.name.localeCompare(b.name)) ?? [];

package/src/utils/time.ts

@@ -0,0 +1,17 @@
+import { useI18n } from "@/stores/locale";
+
+const defaultOptions: Intl.DateTimeFormatOptions = {
+  month: "numeric",
+  day: "numeric",
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  hour12: false,
+};
+
+export const timestampToDate = (timestamp: number, options = defaultOptions) => {
+  const date = new Date(timestamp);
+  const { t } = useI18n("ui");
+  return new Intl.DateTimeFormat("en-US", options).format(date).replace(",", ` ${t("at")}`);
+};

package/src/utils/treeFilters.ts

@@ -0,0 +1,139 @@
+import type { Comparator, DefaultTreeGroup, Statistic, TestStatus, TreeLeaf } from "@allurereport/core-api";
+import {
+  alphabetically,
+  andThen,
+  byStatistic,
+  byStatus,
+  compareBy,
+  emptyStatistic,
+  incrementStatistic,
+  mergeStatistic,
+  ordinal,
+  reverse,
+} from "@allurereport/core-api";
+import type { TreeFiltersState, TreeSortBy } from "@/stores/tree";
+import type { ClassicRecursiveTree, ClassicTree, ClassicTreeGroup, ClassicTreeLeaf } from "../../types";
+
+export const isIncluded = (leaf: TreeLeaf<ClassicTreeLeaf>, filterOptions: TreeFiltersState) => {
+  const queryMatched = !filterOptions?.query || leaf.name.toLowerCase().includes(filterOptions.query.toLowerCase());
+  const statusMatched =
+    !filterOptions?.status || filterOptions?.status === "total" || leaf.status === filterOptions.status;
+  const flakyMatched = !filterOptions?.filter?.flaky || leaf.flaky;
+  const retryMatched = !filterOptions?.filter?.retry || leaf.retry;
+  // TODO: at this moment we don't have a new field implementation even in the generator
+  // const newMatched = !filterOptions?.filter?.new || leaf.new;
+
+  return [queryMatched, statusMatched, flakyMatched, retryMatched].every(Boolean);
+};
+
+const leafComparatorByTreeSortBy = (sortBy: TreeSortBy): Comparator<TreeLeaf<ClassicTreeLeaf>> => {
+  const typedCompareBy = compareBy<TreeLeaf<ClassicTreeLeaf>>;
+  switch (sortBy) {
+    case "order":
+      return typedCompareBy("groupOrder", ordinal());
+    case "duration":
+      return typedCompareBy("duration", ordinal());
+    case "alphabet":
+      return typedCompareBy("name", alphabetically());
+    case "status":
+      return typedCompareBy("status", byStatus());
+  }
+};
+
+const groupComparatorByTreeSortBy = (sortBy: TreeSortBy): Comparator<DefaultTreeGroup> => {
+  const typedCompareBy = compareBy<DefaultTreeGroup>;
+  switch (sortBy) {
+    case "alphabet":
+      return typedCompareBy("name", alphabetically());
+    case "order":
+    case "duration":
+    case "status":
+      return typedCompareBy("statistic", byStatistic());
+  }
+};
+
+export const leafComparator = (filterOptions: TreeFiltersState): Comparator<TreeLeaf<ClassicTreeLeaf>> => {
+  const cmp = leafComparatorByTreeSortBy(filterOptions.sortBy);
+  const directional = filterOptions.direction === "asc" ? cmp : reverse(cmp);
+  // apply fallback sorting by name
+  return andThen([directional, compareBy("name", alphabetically())]);
+};
+
+export const groupComparator = (filterOptions: TreeFiltersState): Comparator<DefaultTreeGroup> => {
+  const cmp = groupComparatorByTreeSortBy(filterOptions.sortBy);
+  const directional = filterOptions.direction === "asc" ? cmp : reverse(cmp);
+  // apply fallback sorting by name
+  return andThen([directional, compareBy("name", alphabetically())]);
+};
+
+export const filterLeaves = (
+  leaves: string[] = [],
+  leavesById: ClassicTree["leavesById"],
+  filterOptions: TreeFiltersState,
+) => {
+  const filteredLeaves = [...leaves]
+    .map((leafId) => leavesById[leafId])
+    .filter((leaf: TreeLeaf<ClassicTreeLeaf>) => isIncluded(leaf, filterOptions));
+
+  const comparator = leafComparator(filterOptions);
+  return filteredLeaves.sort(comparator);
+};
+
+/**
+ * Fills the given tree from generator and returns recursive tree which includes leaves data instead of their IDs
+ * Filters leaves when `filterOptions` property is provided
+ * @param payload
+ */
+export const createRecursiveTree = (payload: {
+  group: ClassicTreeGroup;
+  groupsById: ClassicTree["groupsById"];
+  leavesById: ClassicTree["leavesById"];
+  filterOptions?: TreeFiltersState;
+}): ClassicRecursiveTree => {
+  const { group, groupsById, leavesById, filterOptions } = payload;
+  const groupLeaves: string[] = group.leaves ?? [];
+
+  const leaves = filterLeaves(groupLeaves, leavesById, filterOptions);
+  const trees =
+    group.groups
+      ?.map((groupId) =>
+        createRecursiveTree({
+          group: groupsById[groupId],
+          groupsById,
+          leavesById,
+          filterOptions,
+        }),
+      )
+      ?.filter((rt) => !isRecursiveTreeEmpty(rt)) ?? [];
+
+  const statistic: Statistic = emptyStatistic();
+  trees.forEach((rt: ClassicRecursiveTree) => {
+    if (rt.statistic) {
+      const additional: Statistic = rt.statistic;
+      mergeStatistic(statistic, additional);
+    }
+  });
+  leaves.forEach((leaf) => {
+    const status: TestStatus = leaf.status;
+    incrementStatistic(statistic, status);
+  });
+
+  return {
+    ...group,
+    statistic,
+    leaves,
+    trees: trees.sort(groupComparator(filterOptions)),
+  };
+};
+
+export const isRecursiveTreeEmpty = (tree: ClassicRecursiveTree): boolean => {
+  if (!tree.trees?.length && !tree.leaves?.length) {
+    return true;
+  }
+
+  if (tree.leaves?.length) {
+    return false;
+  }
+
+  return tree.trees?.every((subTree) => isRecursiveTreeEmpty(subTree));
+};

package/test/dummy.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "vitest";
+
+describe("dummy", () => {
+  it("works", () => {
+    expect(true).toBe(true);
+  });
+});