@testrevolution/bugbug-cli 12.0.0 → 12.20.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@testrevolution/bugbug-cli",
   "description": "BugBug CLI",
-  "version": "12.0.0",
+  "version": "12.20.0",
   "keywords": [
     "automation",
     "cli",
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "@sentry/node": "^8.55.0",
-    "axios": "^1.8.4",
+    "axios": "^1.10.0",
     "console-table-printer": "^2.12.1",
     "dotenv": "^16.4.7",
     "jest-junit": "^16.0.0",
@@ -41,16 +41,16 @@
     "node": ">= 20.12.2"
   },
   "devDependencies": {
-    "@babel/eslint-parser": "^7.25.9",
-    "@babel/plugin-proposal-throw-expressions": "^7.25.9",
+    "@babel/eslint-parser": "^7.27.1",
+    "@babel/plugin-proposal-throw-expressions": "^7.27.1",
     "babel-plugin-rewire": "^1.2.0",
     "cross-env": "^7.0.3",
     "eslint": "^8.57.1",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-jest": "^28.11.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jest": "^29.0.1",
     "eslint-plugin-node": "^11.1.0",
-    "jest": "^29.7.0"
+    "jest": "^30.0.3"
   },
   "author": "TestRevolution sp. z o.o."
 }

package/src/__tests__/helper.spec.js

@@ -0,0 +1,230 @@
+const { parseTimeFromDuration, getSecondsFromDuration } = require('../utils/helper');
+
+describe('timeParser', () => {
+  describe('parseTimeFromDuration', () => {
+    it('should parse full duration with microseconds', () => {
+      // Arrange
+      const duration = '00:01:15.704622';
+
+      // Act
+      const result = parseTimeFromDuration(duration);
+
+      // Assert
+      expect(result).toEqual({
+        hours: '00',
+        minutes: '01',
+        secondsWithMs: '15.704622',
+        seconds: '15',
+        microseconds: '704622',
+      });
+    });
+
+    it('should parse duration without microseconds', () => {
+      // Arrange
+      const duration = '01:30:45';
+
+      // Act
+      const result = parseTimeFromDuration(duration);
+
+      // Assert
+      expect(result).toEqual({
+        hours: '01',
+        minutes: '30',
+        secondsWithMs: '45',
+        seconds: '45',
+        microseconds: '0',
+      });
+    });
+
+    it('should parse duration with zero microseconds', () => {
+      // Arrange
+      const duration = '00:00:30.0';
+
+      // Act
+      const result = parseTimeFromDuration(duration);
+
+      // Assert
+      expect(result).toEqual({
+        hours: '00',
+        minutes: '00',
+        secondsWithMs: '30.0',
+        seconds: '30',
+        microseconds: '0',
+      });
+    });
+
+    it('should handle empty string', () => {
+      // Arrange
+      const duration = '';
+
+      // Act
+      const result = parseTimeFromDuration(duration);
+
+      // Assert
+      expect(result).toEqual({
+        hours: '00',
+        minutes: '0',
+        secondsWithMs: '0.0',
+        seconds: '0',
+        microseconds: '0',
+      });
+    });
+
+    it('should handle null or undefined', () => {
+      // Arrange & Act
+      const resultNull = parseTimeFromDuration(null);
+      const resultUndefined = parseTimeFromDuration(undefined);
+
+      // Assert
+      expect(resultNull).toEqual({
+        hours: '00',
+        minutes: '0',
+        secondsWithMs: '0.0',
+        seconds: '0',
+        microseconds: '0',
+      });
+      expect(resultUndefined).toEqual({
+        hours: '00',
+        minutes: '0',
+        secondsWithMs: '0.0',
+        seconds: '0',
+        microseconds: '0',
+      });
+    });
+
+    it('should handle short microseconds', () => {
+      // Arrange
+      const duration = '00:01:15.5';
+
+      // Act
+      const result = parseTimeFromDuration(duration);
+
+      // Assert
+      expect(result).toEqual({
+        hours: '00',
+        minutes: '01',
+        secondsWithMs: '15.5',
+        seconds: '15',
+        microseconds: '5',
+      });
+    });
+  });
+
+  describe('getSecondsFromDuration', () => {
+    it('should convert duration with microseconds to total float seconds', () => {
+      // Arrange
+      const duration = '00:01:15.704622';
+
+      // Act
+      const result = getSecondsFromDuration(duration);
+
+      // Assert
+      // 1 minute = 60 seconds, + 15 seconds = 75 seconds
+      // 75 * 1,000,000 = 75,000,000 microseconds
+      // + 704,622 microseconds = 75,704,622
+      expect(result).toBe(75.704622);
+    });
+
+    it('should convert duration without microseconds', () => {
+      // Arrange
+      const duration = '01:30:45';
+
+      // Act
+      const result = getSecondsFromDuration(duration);
+
+      // Assert
+      expect(result).toBe(5445);
+    });
+
+    it('should handle zero duration', () => {
+      // Arrange
+      const duration = '00:00:00.0';
+
+      // Act
+      const result = getSecondsFromDuration(duration);
+
+      // Assert
+      expect(result).toBe(0);
+    });
+
+    it('should pad short microseconds to 6 digits', () => {
+      // Arrange
+      const duration = '00:00:01.5';
+
+      // Act
+      const result = getSecondsFromDuration(duration);
+
+      // Assert
+      expect(result).toBe(1.5);
+    });
+
+    it('should truncate microseconds longer than 6 digits', () => {
+      // Arrange
+      const duration = '00:00:01.1234567890';
+
+      // Act
+      const result = getSecondsFromDuration(duration);
+
+      // Assert
+      expect(result).toBe(1.123456);
+    });
+
+    it('should handle missing microseconds with default padding', () => {
+      // Arrange
+      const duration = '00:00:05';
+
+      // Act
+      const result = getSecondsFromDuration(duration);
+
+      // Assert
+      expect(result).toBe(5);
+    });
+
+    it('should handle large durations', () => {
+      // Arrange
+      const duration = '23:59:59.999999';
+
+      // Act
+      const result = getSecondsFromDuration(duration);
+
+      // Assert
+      expect(result).toBe(86399.999999);
+    });
+
+    it('should handle empty string', () => {
+      // Arrange
+      const duration = '';
+
+      // Act
+      const result = getSecondsFromDuration(duration);
+
+      // Assert
+      expect(result).toBe(0);
+    });
+
+    it('should handle null or undefined', () => {
+      // Arrange & Act
+      const resultNull = getSecondsFromDuration(null);
+      const resultUndefined = getSecondsFromDuration(undefined);
+
+      // Assert
+      expect(resultNull).toBe(0);
+      expect(resultUndefined).toBe(0);
+    });
+
+    it('should handle malformed duration strings gracefully', () => {
+      // Arrange
+      const duration = 'invalid:time:format';
+
+      // Act
+      const parseResult = parseTimeFromDuration(duration);
+      const millisecondsResult = getSecondsFromDuration(duration);
+
+      // Assert
+      expect(parseResult.hours).toBe('invalid');
+      expect(parseResult.minutes).toBe('time');
+      expect(parseResult.seconds).toBe('format');
+      expect(millisecondsResult).toBeNaN();
+    });
+  });
+});

package/src/utils/helper.js

@@ -28,7 +28,7 @@ const getUnknownOptions = async (args, knownKeys) => {
 const printErrorResponse = async (spinner, error) => {
   if (
     error.response?.status === 400
-    && error.response?.data[0]?.message) {
+        && error.response?.data[0]?.message) {
     spinner.fail(error.response.data[0].message);
   } else {
     spinner.fail(error.toString());
@@ -45,28 +45,36 @@ const overrideSettings = async (args) => {
 
 const parseTimeFromDuration = (duration) => {
   const [hours, minutes = '0', secondsWithMs = '0.0'] = (duration || '').split(':');
-  const [seconds, milliSeconds] = secondsWithMs.split('.');
+  const [seconds, microseconds = '0'] = secondsWithMs.split('.');
   return {
-    hours: hours || '00', minutes, secondsWithMs, seconds, milliSeconds,
+    hours: hours || '00',
+    minutes,
+    secondsWithMs,
+    seconds,
+    microseconds,
   };
 };
 
-const getMillisecondsFromDuration = (duration) => {
+const getSecondsFromDuration = (duration) => {
   const {
-    hours, minutes, seconds, milliSeconds,
+    hours, minutes, seconds, microseconds,
   } = parseTimeFromDuration(duration);
-  return (
-    parseInt(hours, 10) * 3600
-    + parseInt(minutes, 10) * 60
-    + parseInt(seconds, 10)
-  ) * 1000 + parseInt(milliSeconds, 10);
+  const totalSeconds = parseInt(hours, 10) * 3600
+        + parseInt(minutes, 10) * 60
+        + parseInt(seconds, 10);
+
+  const paddedMicroseconds = (microseconds || '0').padEnd(6, '0').substring(0, 6);
+  const fractionalSeconds = parseInt(paddedMicroseconds, 10) / 1_000_000;
+
+  return totalSeconds + fractionalSeconds;
 };
 
 module.exports = {
   getExitCode,
+  getSecondsFromDuration,
   getUnknownOptions,
   overrideSettings,
+  parseTimeFromDuration,
   parseVariables,
   printErrorResponse,
-  getMillisecondsFromDuration,
 };

package/src/utils/testReports.js

@@ -3,7 +3,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const settings = require('../settings');
-const { getMillisecondsFromDuration } = require('./helper');
+const { getSecondsFromDuration } = require('./helper');
 
 const getTestInJunitFormat = (testRun) => {
   const errorDetails = testRun.errorCode ? {
@@ -14,7 +14,7 @@ const getTestInJunitFormat = (testRun) => {
   return {
     id: testRun.id,
     name: testRun.name,
-    time: getMillisecondsFromDuration(testRun.duration),
+    time: getSecondsFromDuration(testRun.duration),
     classname: null,
     errors: testRun.status === settings.STATUS_ERROR ? [errorDetails] : [],
     failures: testRun.status === settings.STATUS_FAILED ? [errorDetails] : [],
@@ -24,14 +24,14 @@ const getTestInJunitFormat = (testRun) => {
 const getSuiteInJunitFormat = (suiteRun) => ({
   id: suiteRun.id,
   name: suiteRun.name,
-  time: getMillisecondsFromDuration(suiteRun.duration),
+  time: getSecondsFromDuration(suiteRun.duration),
   testCases: suiteRun.details.map((testRun) => getTestInJunitFormat(testRun)),
 });
 
 const generateJunitReport = async (type, result, outputPath) => {
   const testReport = {};
   testReport.name = 'BugBug Report';
-  testReport.time = getMillisecondsFromDuration(result.duration);
+  testReport.time = getSecondsFromDuration(result.duration);
   testReport.suites = [];
 
   if (type === settings.TYPE_TEST) {