@allurereport/web-allure2 3.0.0-beta.9

package/src/data/tree/TreeCollection.js

@@ -0,0 +1,153 @@
+import { reportDataUrl } from "@allurereport/web-commons";
+import { Collection } from "backbone";
+import { findWhere, flatten } from "underscore";
+import { values } from "@/utils/statuses.js";
+
+function updateTime(timeA, timeB, field, operation) {
+  if (timeB && timeB[field]) {
+    timeA[field] = operation(timeA[field], timeB[field]);
+  }
+}
+
+export default class TreeCollection extends Collection {
+  initialize(models, { url }) {
+    this.url = url;
+  }
+
+  fetch(options) {
+    return reportDataUrl(this.url, "application/json").then((value) => super.fetch({ ...options, url: value }));
+  }
+
+  findLeaf(parentUid, uid) {
+    return findWhere(this.allResults, { parentUid, uid });
+  }
+
+  getFlattenTestResults(children) {
+    return flatten(
+      children.map((child) => {
+        if (child.children) {
+          return this.getFlattenTestResults(child.children);
+        }
+        return child;
+      }),
+    );
+  }
+
+  parse({ uid, children }) {
+    const items = children || [];
+    this.uid = uid;
+    this.allResults = this.getFlattenTestResults(items);
+    this.allNodes = items;
+    this.time = this.calculateTime(this.allResults);
+    this.statistic = this.calculateStatistic(this.allResults);
+    return items;
+  }
+
+  applyFilterAndSorting(filter, sorter) {
+    const newChildren = this.getFilteredAndSortedChildren(this.allNodes, filter, sorter);
+    this.reset(newChildren);
+    this.testResults = this.getFlattenTestResults(newChildren);
+  }
+
+  getFilteredAndSortedChildren(children, filter, sorter) {
+    return this.calculateOrder(children)
+      .map((child) => {
+        if (child.children) {
+          const newChildren = this.getFilteredAndSortedChildren(child.children, filter, sorter);
+          return {
+            ...child,
+            children: newChildren,
+            statistic: this.calculateStatistic(newChildren),
+            time: this.calculateTime(newChildren),
+          };
+        }
+        return child;
+      })
+      .filter(filter)
+      .sort(sorter);
+  }
+
+  getFirstTestResult() {
+    if (this.testResults.length > 0) {
+      return this.testResults[0];
+    }
+  }
+
+  getLastTestResult() {
+    if (this.testResults.length > 0) {
+      return this.testResults[this.testResults.length - 1];
+    }
+  }
+
+  getNextTestResult(testResultUid) {
+    const index = this.testResults.findIndex((testResult) => testResult.uid === testResultUid);
+    if (index < this.testResults.length - 1) {
+      return this.testResults[index + 1];
+    }
+  }
+
+  getPreviousTestResult(testResultUid) {
+    const index = this.testResults.findIndex((testResult) => testResult.uid === testResultUid);
+    if (index > 0) {
+      return this.testResults[index - 1];
+    }
+  }
+
+  calculateOrder(items) {
+    if (items) {
+      let index = 0;
+      items.forEach((item) => {
+        if (item.children) {
+          this.calculateOrder(item.children);
+        } else {
+          item.order = ++index;
+        }
+      });
+      return items;
+    }
+    return [];
+  }
+
+  calculateStatistic(items) {
+    const statistic = {};
+    values.forEach((value) => {
+      statistic[value] = 0;
+    });
+    items.forEach((item) => {
+      if (item.children) {
+        values.forEach((value) => {
+          statistic[value] += item.statistic ? item.statistic[value] : 0;
+        });
+      } else {
+        statistic[item.status]++;
+      }
+    });
+    return statistic;
+  }
+
+  calculateTime(items) {
+    const time = {
+      maxDuration: Number.MIN_VALUE,
+      minDuration: Number.MAX_VALUE,
+      sumDuration: 0,
+      duration: 0,
+      start: Number.MAX_VALUE,
+      stop: Number.MIN_VALUE,
+    };
+    items.forEach((item) => {
+      if (item.children) {
+        updateTime(time, item.time, "maxDuration", Math.max);
+        updateTime(time, item.time, "minDuration", Math.min);
+        updateTime(time, item.time, "sumDuration", (a, b) => a + b);
+      } else if (item.time && isFinite(item.time.duration)) {
+        time.maxDuration = Math.max(time.maxDuration, item.time.duration);
+        time.minDuration = Math.min(time.minDuration, item.time.duration);
+        time.sumDuration = time.sumDuration + item.time.duration;
+      }
+      updateTime(time, item.time, "start", Math.min);
+      updateTime(time, item.time, "stop", Math.max);
+      time.duration = time.stop - time.start;
+    });
+    return time;
+  }
+}

package/src/data/tree/comparator.js

@@ -0,0 +1,63 @@
+import { values } from "@/utils/statuses.js";
+
+function byOrder(a, b) {
+  return a.order < b.order ? -1 : 1;
+}
+
+function byName(a, b) {
+  return String(a.name).toLowerCase() < String(b.name).toLowerCase() ? -1 : 1;
+}
+
+function byDuration(a, b) {
+  if (a.time && a.time.duration && b.time && b.time.duration) {
+    return a.time.duration < b.time.duration ? -1 : 1;
+  }
+  return 1;
+}
+
+function byMaxDuration(a, b) {
+  if (a.time && a.time.maxDuration && b.time && b.time.maxDuration) {
+    return a.time.maxDuration < b.time.maxDuration ? -1 : 1;
+  }
+  return 1;
+}
+
+function byNodeStatus(a, b) {
+  return values.indexOf(a.status) > values.indexOf(b.status) ? -1 : 1;
+}
+
+function byGroupStatuses(a, b) {
+  return values.reduce((all, cur) => {
+    return a.statistic[cur] !== b.statistic[cur] && all === 0 ? a.statistic[cur] - b.statistic[cur] : all;
+  }, 0);
+}
+
+function compare(a, b, nodeCmp, groupCmp, direction) {
+  if (a.children && !b.children) {
+    return -1;
+  } else if (!a.children && b.children) {
+    return 1;
+  } else if (a.children && b.children) {
+    return direction * groupCmp(a, b);
+  } else if (!a.children && !b.children) {
+    return direction * nodeCmp(a, b);
+  } else {
+    return 0;
+  }
+}
+
+export default function getComparator({ sorter, ascending }) {
+  const direction = ascending ? 1 : -1;
+  switch (sorter) {
+    case "sorter.order":
+      return (a, b) => compare(a, b, byOrder, byName, direction);
+    case "sorter.name":
+      return (a, b) => compare(a, b, byName, byName, direction);
+    case "sorter.duration":
+      return (a, b) => compare(a, b, byDuration, byMaxDuration, direction);
+    case "sorter.status":
+      return (a, b) => compare(a, b, byNodeStatus, byGroupStatuses, direction);
+    default:
+      return 0;
+  }
+}

package/src/data/tree/filter.js

@@ -0,0 +1,66 @@
+import { values as marksValues } from "@/utils/marks.js";
+
+function byStatuses(statuses) {
+  return (child) => {
+    if (child.children) {
+      return child.children.length > 0;
+    }
+    return statuses[child.status];
+  };
+}
+
+function byDuration(min, max) {
+  return (child) => {
+    if (child.children) {
+      return child.children.length > 0;
+    }
+    return min <= child.time.duration && child.time.duration <= max;
+  };
+}
+
+function byCriteria(searchQuery) {
+  if (searchQuery && searchQuery.startsWith("tag:")) {
+    return byTags(searchQuery.substring(4));
+  } else {
+    return byText(searchQuery);
+  }
+}
+
+function byText(text) {
+  text = (text && text.toLowerCase()) || "";
+  return (child) => {
+    return (
+      !text || child.name.toLowerCase().indexOf(text) > -1 || (child.children && child.children.some(byText(text)))
+    );
+  };
+}
+
+function byTags(tag) {
+  tag = (tag && tag.toLowerCase().trim()) || "";
+  const tags = tag.split(/\s*,\s*/).filter((t) => t);
+  return (child) => {
+    const childTags = Array.isArray(child.tags) ? child.tags.filter((t) => t).map((t) => t.toLowerCase().trim()) : [];
+    return !tag || tags.every((t) => childTags.indexOf(t) > -1) || (child.children && child.children.some(byTags(tag)));
+  };
+}
+
+function byMark(marks) {
+  return (child) => {
+    if (child.children) {
+      return child.children.length > 0;
+    }
+    return marksValues.map((k) => !marks[k] || child[k]).reduce((a, b) => a && b, true);
+  };
+}
+
+function mix(...filters) {
+  return (child) => {
+    let result = true;
+    filters.forEach((filter) => {
+      result = result && filter(child);
+    });
+    return result;
+  };
+}
+
+export { byStatuses, byDuration, byCriteria, byText, byTags, byMark, mix };

package/src/data/trend/TrendCollection.js

@@ -0,0 +1,36 @@
+import { reportDataUrl } from "@allurereport/web-commons";
+import { Collection } from "backbone";
+import { flatten, keys, omit, uniq, values } from "underscore";
+
+export default class TrendCollection extends Collection {
+  initialize(models, options) {
+    this.options = options;
+    this.url = `widgets/${this.options.name}.json`;
+  }
+
+  fetch(options) {
+    return reportDataUrl(this.url, "application/json").then((value) => super.fetch({ ...options, url: value }));
+  }
+
+  parse(response) {
+    return response.reverse().map((item, id) => {
+      return {
+        ...item,
+        id,
+        name: item.buildOrder ? `#${item.buildOrder}` : "",
+        total: values(omit(item.data, "total")).reduce((prev, curr) => prev + curr, 0),
+        data: omit(item.data, "total"),
+      };
+    });
+  }
+
+  keys() {
+    return uniq(flatten(this.map((model) => keys(model.get("data")))));
+  }
+
+  sortedKeysByLastValue() {
+    const allKeys = this.keys();
+    const lastData = this.last().get("data");
+    return allKeys.sort((a, b) => (lastData[b] || 0) - (lastData[a] || 0));
+  }
+}

package/src/data/widgets/WidgetsModel.js

@@ -0,0 +1,25 @@
+import { reportDataUrl } from "@allurereport/web-commons";
+import { Model } from "backbone";
+
+export default class WidgetsModel extends Model {
+  initialize(model, options) {
+    this.options = options;
+  }
+
+  url() {
+    return `widgets/${this.options.name}.json`;
+  }
+
+  parse(data) {
+    return Array.isArray(data) ? { items: data } : data;
+  }
+
+  fetch(options) {
+    return reportDataUrl(this.url(), "application/json").then((value) => super.fetch({ ...options, url: value }));
+  }
+
+  getWidgetData(name) {
+    const items = this.get(name);
+    return new Model(Array.isArray(items) ? { items } : items);
+  }
+}

package/src/decorators/index.js

@@ -0,0 +1,53 @@
+import { clone, has, isFunction } from "underscore";
+
+function onDecoratorFactory(decoratorName, propertyName) {
+  return function (eventName) {
+    return function (target, name, descriptor) {
+      if (!eventName) {
+        throw new Error(`The ${decoratorName} decorator requires an eventName argument`);
+      }
+      if (isFunction(target[propertyName])) {
+        throw new Error(`The ${decoratorName} decorator is not compatible with ${propertyName} as method form`);
+      }
+      if (target[propertyName] && !has(target, propertyName)) {
+        target[propertyName] = clone(target[propertyName]);
+      }
+      if (!target[propertyName]) {
+        target[propertyName] = {};
+      }
+      target[propertyName][eventName] = name;
+      return descriptor;
+    };
+  };
+}
+
+export const on = onDecoratorFactory("on", "events");
+
+export function behavior(name, config = {}) {
+  return function (target) {
+    target.prototype.behaviors = Object.assign(
+      {
+        [name]: config,
+      },
+      target.prototype.behaviors,
+    );
+  };
+}
+
+export function className(name) {
+  return function (target) {
+    target.prototype.className = name;
+  };
+}
+
+export function regions(opts) {
+  return function (target) {
+    target.prototype.regions = Object.assign(opts, target.regions);
+  };
+}
+
+export function options(opts) {
+  return function (target) {
+    target.prototype.options = Object.assign(opts, target.options);
+  };
+}

package/src/helpers/allure-icon.js

@@ -0,0 +1,228 @@
+import { SafeString } from "handlebars/runtime.js";
+import allureLogo from "@/assets/icons/allure-logo.svg";
+import bamboo from "@/assets/icons/bamboo.svg";
+import bitbucket from "@/assets/icons/bitbucket.svg";
+import bomb from "@/assets/icons/bomb.svg";
+import broken from "@/assets/icons/broken.svg";
+import bug from "@/assets/icons/bug.svg";
+import chevronDown from "@/assets/icons/chevron-down.svg";
+import chevronLeft from "@/assets/icons/chevron-left.svg";
+import chevronRightFat from "@/assets/icons/chevron-right-fat.svg";
+import chevronRight from "@/assets/icons/chevron-right.svg";
+import chevronUp from "@/assets/icons/chevron-up.svg";
+import circleci from "@/assets/icons/circleci.svg";
+import close from "@/assets/icons/close.svg";
+import collapse from "@/assets/icons/collapse.svg";
+import compare from "@/assets/icons/compare.svg";
+import copy from "@/assets/icons/copy.svg";
+import csv from "@/assets/icons/csv.svg";
+import download from "@/assets/icons/download.svg";
+import draggable from "@/assets/icons/draggable.svg";
+import expand from "@/assets/icons/expand.svg";
+import failed from "@/assets/icons/failed.svg";
+import file from "@/assets/icons/file.svg";
+import folder from "@/assets/icons/folder.svg";
+import github from "@/assets/icons/github.svg";
+import gitlab from "@/assets/icons/gitlab.svg";
+import graphs from "@/assets/icons/graphs.svg";
+import info from "@/assets/icons/info.svg";
+import jenkins from "@/assets/icons/jenkins.svg";
+import jobs from "@/assets/icons/jobs.svg";
+import link from "@/assets/icons/link.svg";
+import list from "@/assets/icons/list.svg";
+import maximize from "@/assets/icons/maximize.svg";
+import newBroken from "@/assets/icons/new-broken.svg";
+import newFailed from "@/assets/icons/new-failed.svg";
+import newPassed from "@/assets/icons/new-passed.svg";
+import overview from "@/assets/icons/overview.svg";
+import passed from "@/assets/icons/passed.svg";
+import pdf from "@/assets/icons/pdf.svg";
+import retries from "@/assets/icons/retries.svg";
+import save from "@/assets/icons/save.svg";
+import skipped from "@/assets/icons/skipped.svg";
+import sortDown from "@/assets/icons/sort-down.svg";
+import sortUp from "@/assets/icons/sort-up.svg";
+import sort from "@/assets/icons/sort.svg";
+import task from "@/assets/icons/task.svg";
+import teamcity from "@/assets/icons/teamcity.svg";
+import timeline from "@/assets/icons/timeline.svg";
+import tree from "@/assets/icons/tree.svg";
+import txt from "@/assets/icons/txt.svg";
+import unknown from "@/assets/icons/unknown.svg";
+import translate from "./t.js";
+
+const icons = {
+  jobs: {
+    id: jobs.id,
+  },
+  draggable: {
+    id: draggable.id,
+  },
+  github: {
+    id: github.id,
+  },
+  gitlab: {
+    id: gitlab.id,
+  },
+  teamcity: {
+    id: teamcity.id,
+  },
+  jenkins: {
+    id: jenkins.id,
+  },
+  bitbucket: {
+    id: bitbucket.id,
+  },
+  bamboo: {
+    id: bamboo.id,
+  },
+  circleci: {
+    id: circleci.id,
+  },
+  maximize: {
+    id: maximize.id,
+  },
+  expand: {
+    id: expand.id,
+  },
+  collapse: {
+    id: collapse.id,
+  },
+  close: {
+    id: close.id,
+  },
+  bug: {
+    id: bug.id,
+  },
+  compare: {
+    id: compare.id,
+  },
+  save: {
+    id: save.id,
+  },
+  link: {
+    id: link.id,
+  },
+  file: {
+    id: file.id,
+  },
+  txt: {
+    id: txt.id,
+  },
+  pdf: {
+    id: pdf.id,
+  },
+  csv: {
+    id: csv.id,
+  },
+  chevronDown: {
+    id: chevronDown.id,
+  },
+  chevronRight: {
+    id: chevronRight.id,
+  },
+  chevronRightFat: {
+    id: chevronRightFat.id,
+  },
+  chevronUp: {
+    id: chevronUp.id,
+  },
+  chevronLeft: {
+    id: chevronLeft.id,
+  },
+  sort: {
+    id: sort.id,
+  },
+  sortUp: {
+    id: sortUp.id,
+  },
+  sortDown: {
+    id: sortDown.id,
+  },
+  task: {
+    id: task.id,
+  },
+  graphs: {
+    id: graphs.id,
+  },
+  overview: {
+    id: overview.id,
+  },
+  tree: {
+    id: tree.id,
+  },
+  timeline: {
+    id: timeline.id,
+  },
+  folder: {
+    id: folder.id,
+  },
+  list: {
+    id: list.id,
+  },
+  copy: {
+    id: copy.id,
+  },
+  allureLogo: {
+    id: allureLogo.id,
+  },
+  info: {
+    id: info.id,
+  },
+  download: {
+    id: download.id,
+  },
+  flaky: {
+    id: bomb.id,
+    tooltip: "marks.flaky",
+  },
+  newFailed: {
+    id: newFailed.id,
+    tooltip: "marks.newFailed",
+  },
+  newBroken: {
+    id: newBroken.id,
+    tooltip: "marks.newBroken",
+  },
+  newPassed: {
+    id: newPassed.id,
+    tooltip: "marks.newPassed",
+  },
+  retriesStatusChange: {
+    id: retries.id,
+    tooltip: "marks.retriesStatusChange",
+  },
+  failed: {
+    id: failed.id,
+    tooltip: "status.failed",
+  },
+  broken: {
+    id: broken.id,
+    tooltip: "status.broken",
+  },
+  passed: {
+    id: passed.id,
+    tooltip: "status.passed",
+  },
+  skipped: {
+    id: skipped.id,
+    tooltip: "status.skipped",
+  },
+  unknown: {
+    id: unknown.id,
+    tooltip: "status.unknown",
+  },
+};
+
+export default function (value, opts) {
+  const {
+    hash: { extraClasses = "", noTooltip = false, width = "20px", height = "20px" },
+  } = opts;
+  const icon = icons[value];
+
+  return icon
+    ? new SafeString(
+        `<svg width="${width}" height="${height}" class="${extraClasses}" ${noTooltip ? "" : `data-tooltip="${translate(icon.tooltip)}"`}><use xlink:href="#${icon.id}"></use></svg>`,
+      )
+    : "";
+}

package/src/helpers/and.js

@@ -0,0 +1,3 @@
+export default function (a, b) {
+  return !!a && !!b;
+}

package/src/helpers/angle.js

@@ -0,0 +1,15 @@
+import { SafeString } from "handlebars/runtime.js";
+import allureIcon from "./allure-icon.js";
+
+export default function () {
+  const icon = allureIcon("chevronRight", {
+    hash: {
+      noTooltip: true,
+      width: "18px",
+      height: "18px",
+    },
+  });
+  const template = `<span class="angle">${icon}</span>`;
+
+  return new SafeString(template);
+}

package/src/helpers/arrow.js

@@ -0,0 +1,17 @@
+import { SafeString } from "handlebars/runtime.js";
+import allureIcon from "./allure-icon.js";
+
+export default function (status = "unknown", ...args) {
+  const options = args.pop();
+  const chevronIcon = options?.hash?.fat ? "chevronRightFat" : "chevronRight";
+  const icon = allureIcon(chevronIcon, {
+    hash: {
+      noTooltip: true,
+      width: "18px",
+      height: "18px",
+    },
+  });
+  const template = `<span class="text_status_${status}">${icon}</span>`;
+
+  return new SafeString(template);
+}

package/src/helpers/b.js

@@ -0,0 +1,6 @@
+import b from "b_";
+
+export default function (...args) {
+  const options = args.pop();
+  return b(...args, options.hash);
+}

package/src/helpers/concat.js

@@ -0,0 +1,3 @@
+export default function concat(...args) {
+  return args.slice(0, -1).join("");
+}

package/src/helpers/date.js

@@ -0,0 +1,11 @@
+import i18next from "@/utils/translation.js";
+
+export default function (date) {
+  if (!date) {
+    return "unknown";
+  }
+  if (!(date instanceof Date)) {
+    date = new Date(date);
+  }
+  return new Intl.DateTimeFormat(i18next.language).format(date);
+}

package/src/helpers/default.js

@@ -0,0 +1,8 @@
+export default function (...values) {
+  values.pop();
+  for (const value of values) {
+    if (value) {
+      return value;
+    }
+  }
+}