@bigbinary/neeto-playwright-reporter 1.5.2 → 1.5.3

package/index.js

@@ -789,10 +789,233 @@ function _includes(a, list) {
   return _indexOf(list, a, 0) >= 0;
 }
 
+function _map(fn, functor) {
+  var idx = 0;
+  var len = functor.length;
+  var result = Array(len);
+
+  while (idx < len) {
+    result[idx] = fn(functor[idx]);
+    idx += 1;
+  }
+
+  return result;
+}
+
+function _arrayReduce(reducer, acc, list) {
+  var index = 0;
+  var length = list.length;
+
+  while (index < length) {
+    acc = reducer(acc, list[index]);
+    index += 1;
+  }
+
+  return acc;
+}
+
 function _isObject(x) {
   return Object.prototype.toString.call(x) === '[object Object]';
 }
 
+var XMap =
+/*#__PURE__*/
+function () {
+  function XMap(f, xf) {
+    this.xf = xf;
+    this.f = f;
+  }
+
+  XMap.prototype['@@transducer/init'] = _xfBase.init;
+  XMap.prototype['@@transducer/result'] = _xfBase.result;
+
+  XMap.prototype['@@transducer/step'] = function (result, input) {
+    return this.xf['@@transducer/step'](result, this.f(input));
+  };
+
+  return XMap;
+}();
+
+var _xmap = function _xmap(f) {
+  return function (xf) {
+    return new XMap(f, xf);
+  };
+};
+
+/**
+ * Takes a function and
+ * a [functor](https://github.com/fantasyland/fantasy-land#functor),
+ * applies the function to each of the functor's values, and returns
+ * a functor of the same shape.
+ *
+ * Ramda provides suitable `map` implementations for `Array` and `Object`,
+ * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.
+ *
+ * Dispatches to the `map` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * Also treats functions as functors and will compose them together.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Functor f => (a -> b) -> f a -> f b
+ * @param {Function} fn The function to be called on every element of the input `list`.
+ * @param {Array} list The list to be iterated over.
+ * @return {Array} The new list.
+ * @see R.transduce, R.addIndex, R.pluck, R.project
+ * @example
+ *
+ *      const double = x => x * 2;
+ *
+ *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]
+ *
+ *      R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}
+ * @symb R.map(f, [a, b]) = [f(a), f(b)]
+ * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }
+ * @symb R.map(f, functor_o) = functor_o.map(f)
+ */
+
+var map =
+/*#__PURE__*/
+_curry2(
+/*#__PURE__*/
+_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {
+  switch (Object.prototype.toString.call(functor)) {
+    case '[object Function]':
+      return curryN(functor.length, function () {
+        return fn.call(this, functor.apply(this, arguments));
+      });
+
+    case '[object Object]':
+      return _arrayReduce(function (acc, key) {
+        acc[key] = fn(functor[key]);
+        return acc;
+      }, {}, keys(functor));
+
+    default:
+      return _map(fn, functor);
+  }
+}));
+
+/**
+ * Determine if the passed argument is an integer.
+ *
+ * @private
+ * @param {*} n
+ * @category Type
+ * @return {Boolean}
+ */
+var _isInteger = Number.isInteger || function _isInteger(n) {
+  return n << 0 === n;
+};
+
+function _isString(x) {
+  return Object.prototype.toString.call(x) === '[object String]';
+}
+
+/**
+ * Returns the nth element of the given list or string. If n is negative the
+ * element at index length + n is returned.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Number -> [a] -> a | Undefined
+ * @sig Number -> String -> String
+ * @param {Number} offset
+ * @param {*} list
+ * @return {*}
+ * @example
+ *
+ *      const list = ['foo', 'bar', 'baz', 'quux'];
+ *      R.nth(1, list); //=> 'bar'
+ *      R.nth(-1, list); //=> 'quux'
+ *      R.nth(-99, list); //=> undefined
+ *
+ *      R.nth(2, 'abc'); //=> 'c'
+ *      R.nth(3, 'abc'); //=> ''
+ * @symb R.nth(-1, [a, b, c]) = c
+ * @symb R.nth(0, [a, b, c]) = a
+ * @symb R.nth(1, [a, b, c]) = b
+ */
+
+var nth =
+/*#__PURE__*/
+_curry2(function nth(offset, list) {
+  var idx = offset < 0 ? list.length + offset : offset;
+  return _isString(list) ? list.charAt(idx) : list[idx];
+});
+
+/**
+ * Returns a function that when supplied an object returns the indicated
+ * property of that object, if it exists.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @typedefn Idx = String | Int | Symbol
+ * @sig Idx -> {s: a} -> a | Undefined
+ * @param {String|Number} p The property name or array index
+ * @param {Object} obj The object to query
+ * @return {*} The value at `obj.p`.
+ * @see R.path, R.props, R.pluck, R.project, R.nth
+ * @example
+ *
+ *      R.prop('x', {x: 100}); //=> 100
+ *      R.prop('x', {}); //=> undefined
+ *      R.prop(0, [100]); //=> 100
+ *      R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4
+ */
+
+var prop =
+/*#__PURE__*/
+_curry2(function prop(p, obj) {
+  if (obj == null) {
+    return;
+  }
+
+  return _isInteger(p) ? nth(p, obj) : obj[p];
+});
+
+/**
+ * Returns a new list by plucking the same named property off all objects in
+ * the list supplied.
+ *
+ * `pluck` will work on
+ * any [functor](https://github.com/fantasyland/fantasy-land#functor) in
+ * addition to arrays, as it is equivalent to `R.map(R.prop(k), f)`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Functor f => k -> f {k: v} -> f v
+ * @param {Number|String} key The key name to pluck off of each object.
+ * @param {Array} f The array or functor to consider.
+ * @return {Array} The list of values for the given key.
+ * @see R.project, R.prop, R.props
+ * @example
+ *
+ *      var getAges = R.pluck('age');
+ *      getAges([{name: 'fred', age: 29}, {name: 'wilma', age: 27}]); //=> [29, 27]
+ *
+ *      R.pluck(0, [[1, 2], [3, 4]]);               //=> [1, 3]
+ *      R.pluck('val', {a: {val: 3}, b: {val: 5}}); //=> {a: 3, b: 5}
+ * @symb R.pluck('x', [{x: 1, y: 2}, {x: 3, y: 4}, {x: 5, y: 6}]) = [1, 3, 5]
+ * @symb R.pluck(0, [[1, 2], [3, 4], [5, 6]]) = [1, 3, 5]
+ */
+
+var pluck =
+/*#__PURE__*/
+_curry2(function pluck(p, list) {
+  return map(prop(p), list);
+});
+
 /**
  * Checks if the input value is `null` or `undefined`.
  *
@@ -21206,6 +21429,10 @@ const onBegin = async (self, config, rootSuite) => {
     let attempts = {};
     self.totalTestCount = rootSuite.allTests().length;
     self.rootDir = config.rootDir;
+    if (self.totalTestCount === 0) {
+        consoleLogFormatted.error(ERRORS.onBegin.noTestsToReport);
+        return;
+    }
     try {
         const runDetails = {
             commitId: getCurrentCommitSha(),
@@ -21219,10 +21446,6 @@ const onBegin = async (self, config, rootSuite) => {
         };
         await runsApi.create(runDetails);
         self.hasRunStarted = true;
-        if (self.totalTestCount === 0) {
-            consoleLogFormatted.error(ERRORS.onBegin.noTestsToReport);
-            return;
-        }
         ({ data: attempts } = await testEntitiesApi.create(self.ciBuildId, {
             testEntities: getInitializerData(config, rootSuite),
             shard: currentShard,
@@ -21279,7 +21502,7 @@ const onTestBegin = async (self, test, { retry }) => {
     const { title, repeatEachIndex } = test;
     const { rootDir, currentShard, ciBuildId } = self;
     const { historyId } = getTestData(test, rootDir);
-    const startedAt = new Date();
+    const startedAt = new Date().toString();
     const attemptIndex = joinHyphenCase(retry, repeatEachIndex);
     self.unreportedAttemptCount++;
     consoleLogFormatted.invertBackground(MESSAGES.onTestBegin.startingTest(title, historyId));
@@ -21287,7 +21510,7 @@ const onTestBegin = async (self, test, { retry }) => {
         await waitUntilCondition(() => { var _a, _b; return (_b = (_a = self.attempts) === null || _a === void 0 ? void 0 : _a[historyId]) === null || _b === void 0 ? void 0 : _b[FIRST_ATTEMPT_INDEX]; });
         const attemptsPayload = {
             status: "running",
-            startedAt: startedAt.toString(),
+            startedAt,
             shard: currentShard,
             repeatEachIndex,
         };
@@ -21295,7 +21518,7 @@ const onTestBegin = async (self, test, { retry }) => {
             await attemptsApi.update(ciBuildId, historyId, self.attempts[historyId][FIRST_ATTEMPT_INDEX], attemptsPayload);
         }
         else {
-            const { data: { attemptId: attemptId }, } = await attemptsApi.create(ciBuildId, historyId, attemptsPayload);
+            const { data: { attemptId }, } = await attemptsApi.create(ciBuildId, historyId, attemptsPayload);
             self.attempts = mergeDeepRight(self.attempts, {
                 [historyId]: { [attemptIndex]: attemptId },
             });
@@ -22686,15 +22909,22 @@ const onTestEnd = async (self, testCase, { status, duration, errors, error, retr
             errorSnippet: error && generateErrorReport(error),
         };
         consoleLogFormatted.underline(title);
-        const bars = await Promise.all(attachments.map(async ({ name, path, body, contentType }) => {
+        const files = attachments
+            .map(({ name, path, body, contentType }) => {
             if (VALID_ASSET_TYPES.includes(name)) {
                 const buffer = path ? readFileSync(path) : body;
                 const fileName = generateFileName(path, name, contentType);
                 const { file, ...metadata } = getFileData(buffer, contentType, fileName);
-                const { data: { signedId, directUpload: directUploadMetaData }, } = await getDirectUploadURL(metadata);
-                testResult[`${name}s`].push(signedId);
-                return uploadToS3(file, directUploadMetaData, `${title} - ${name}`);
+                return { file, metadata, name };
             }
+        })
+            .filter((fileData) => fileData !== undefined);
+        const payload = { metadata: pluck("metadata", files) };
+        const { data: directUploadResponses } = await getDirectUploadURL(payload);
+        const bars = await Promise.all(directUploadResponses.map(async ({ signedId, directUpload }, index) => {
+            var _a, _b;
+            testResult[`${(_a = files[index]) === null || _a === void 0 ? void 0 : _a.name}s`].push(signedId);
+            return uploadToS3(files[index].file, directUpload, `${title} - ${(_b = files[index]) === null || _b === void 0 ? void 0 : _b.name}`);
         }));
         self.progressBars.push(...bars);
         await waitUntilCondition(() => self.attempts[historyId][attemptIndex]);