@testomatio/reporter 2.1.0-beta-nightwatch → 2.1.0-beta.1-codeceptjs

package/lib/pipe/testomatio.js

@@ -5,19 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const debug_1 = __importDefault(require("debug"));
 const picocolors_1 = __importDefault(require("picocolors"));
-// Retry interceptor function
-const axios_retry_1 = __importDefault(require("axios-retry"));
-// Default axios instance
-const axios_1 = __importDefault(require("axios"));
+const gaxios_1 = require("gaxios");
 const json_cycle_1 = __importDefault(require("json-cycle"));
 const constants_js_1 = require("../constants.js");
 const utils_js_1 = require("../utils/utils.js");
 const pipe_utils_js_1 = require("../utils/pipe_utils.js");
 const config_js_1 = require("../config.js");
 const debug = (0, debug_1.default)('@testomatio/reporter:pipe:testomatio');
-if (process.env.TESTOMATIO_RUN) {
-    // process.env.runId = process.env.TESTOMATIO_RUN;
-}
+if (process.env.TESTOMATIO_RUN)
+    process.env.runId = process.env.TESTOMATIO_RUN;
 /**
  * @typedef {import('../../types/types.js').Pipe} Pipe
  * @typedef {import('../../types/types.js').TestData} TestData
@@ -55,48 +51,37 @@ class TestomatioPipe {
         this.groupTitle = params.groupTitle || process.env.TESTOMATIO_RUNGROUP_TITLE;
         this.env = process.env.TESTOMATIO_ENV;
         this.label = process.env.TESTOMATIO_LABEL;
-        // Create a new instance of axios with a custom config
-        this.axios = axios_1.default.create({
+        // Create a new instance of gaxios with a custom config
+        this.client = new gaxios_1.Gaxios({
             baseURL: `${this.url.trim()}`,
             timeout: constants_js_1.AXIOS_TIMEOUT,
-            proxy: proxy
-                ? {
-                    host: proxy.hostname,
-                    port: parseInt(proxy.port, 10),
-                    protocol: proxy.protocol,
-                }
-                : false,
-        });
-        // Pass the axios instance to the retry function
-        (0, axios_retry_1.default)(this.axios, {
-            // do not use retries for unit tests
-            retries: constants_js_1.REPORTER_REQUEST_RETRIES.retriesPerRequest, // Number of retries
-            shouldResetTimeout: true,
-            retryCondition: error => {
-                if (!error.response)
-                    return false;
-                switch (error.response?.status) {
-                    case 400: // Bad request (probably wrong API key)
-                    case 404: // Test not matched
-                    case 429: // Rate limit exceeded
-                    case 500: // Internal server error
+            proxy: proxy ? proxy.toString() : undefined,
+            retry: true,
+            retryConfig: {
+                retry: constants_js_1.REPORTER_REQUEST_RETRIES.retriesPerRequest,
+                retryDelay: constants_js_1.REPORTER_REQUEST_RETRIES.retryTimeout,
+                httpMethodsToRetry: ['GET', 'PUT', 'HEAD', 'OPTIONS', 'DELETE', 'POST'],
+                shouldRetry: (error) => {
+                    if (!error.response)
                         return false;
-                    default:
-                        break;
+                    switch (error.response?.status) {
+                        case 400: // Bad request (probably wrong API key)
+                        case 404: // Test not matched
+                        case 429: // Rate limit exceeded
+                        case 500: // Internal server error
+                            return false;
+                        default:
+                            break;
+                    }
+                    return error.response?.status >= 401; // Retry on 401+ and 5xx
                 }
-                return error.response?.status >= 401; // Retry on 401+ and 5xx
-            },
-            retryDelay: () => constants_js_1.REPORTER_REQUEST_RETRIES.retryTimeout, // sum = 15sec
-            onRetry: async (retryCount, error) => {
-                this.retriesTimestamps.push(Date.now());
-                debug(`${error.message || `Request failed ${error.status}`}. Retry #${retryCount} ...`);
-            },
+            }
         });
         this.isEnabled = true;
         // do not finish this run (for parallel testing)
         this.proceed = process.env.TESTOMATIO_PROCEED;
         this.jiraId = process.env.TESTOMATIO_JIRA_ID;
-        this.runId = params.runId || process.env.runId;
+        this.runId = params.runId || process.env.TESTOMATIO_RUN;
         this.createNewTests = params.createNewTests ?? !!process.env.TESTOMATIO_CREATE;
         this.hasUnmatchedTests = false;
         this.requestFailures = 0;
@@ -125,11 +110,14 @@ class TestomatioPipe {
             if (!q) {
                 return;
             }
-            const resp = await this.axios.get('/api/test_grep', q);
-            const { data } = resp;
-            if (Array.isArray(data?.tests) && data?.tests?.length > 0) {
-                (0, utils_js_1.foundedTestLog)(constants_js_1.APP_PREFIX, data.tests);
-                return data.tests;
+            const resp = await this.client.request({
+                method: 'GET',
+                url: '/api/test_grep',
+                params: q
+            });
+            if (Array.isArray(resp.data?.tests) && resp.data?.tests?.length > 0) {
+                (0, utils_js_1.foundedTestLog)(constants_js_1.APP_PREFIX, resp.data.tests);
+                return resp.data.tests;
             }
             console.log(constants_js_1.APP_PREFIX, `⛔  No tests found for your --filter --> ${type}=${id}`);
         }
@@ -181,16 +169,23 @@ class TestomatioPipe {
         if (this.runId) {
             this.store.runId = this.runId;
             debug(`Run with id ${this.runId} already created, updating...`);
-            const resp = await this.axios.put(`/api/reporter/${this.runId}`, runParams);
+            const resp = await this.client.request({
+                method: 'PUT',
+                url: `/api/reporter/${this.runId}`,
+                data: runParams
+            });
             if (resp.data.artifacts)
                 (0, pipe_utils_js_1.setS3Credentials)(resp.data.artifacts);
             return;
         }
         debug('Creating run...');
         try {
-            const resp = await this.axios.post(`/api/reporter`, runParams, {
+            const resp = await this.client.request({
+                method: 'POST',
+                url: '/api/reporter',
+                data: runParams,
                 maxContentLength: Infinity,
-                maxBodyLength: Infinity,
+                responseType: 'json'
             });
             this.runId = resp.data.uid;
             this.runUrl = `${this.url}/${resp.data.url.split('/').splice(3).join('/')}`;
@@ -206,6 +201,7 @@ class TestomatioPipe {
         }
         catch (err) {
             const errorText = err.response?.data?.message || err.message;
+            debug('Error creating run', err);
             console.log(errorText || err);
             if (!this.apiKey)
                 console.error('Testomat.io API key is not set');
@@ -246,7 +242,15 @@ class TestomatioPipe {
         }
         const json = json_cycle_1.default.stringify(data);
         debug('Adding test', json);
-        return this.axios.post(`/api/reporter/${this.runId}/testrun`, json, axiosAddTestrunRequestConfig).catch(err => {
+        return this.client.request({
+            method: 'POST',
+            url: `/api/reporter/${this.runId}/testrun`,
+            data: json,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            maxContentLength: Infinity
+        }).catch(err => {
             this.requestFailures++;
             this.notReportedTestsCount++;
             if (err.response) {
@@ -291,9 +295,19 @@ class TestomatioPipe {
         // get tests from batch and clear batch
         const testsToSend = this.batch.tests.splice(0);
         debug('📨 Batch upload', testsToSend.length, 'tests');
-        return this.axios
-            .post(`/api/reporter/${this.runId}/testrun`, { api_key: this.apiKey, tests: testsToSend, batch_index: this.batch.batchIndex }, axiosAddTestrunRequestConfig)
-            .catch(err => {
+        return this.client.request({
+            method: 'POST',
+            url: `/api/reporter/${this.runId}/testrun`,
+            data: {
+                api_key: this.apiKey,
+                tests: testsToSend,
+                batch_index: this.batch.batchIndex
+            },
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            maxContentLength: Infinity
+        }).catch(err => {
             this.requestFailures++;
             this.notReportedTestsCount += testsToSend.length;
             if (err.response) {
@@ -317,6 +331,7 @@ class TestomatioPipe {
      * Adds a test to the batch uploader (or reports a single test if batch uploading is disabled)
      */
     addTest(data) {
+        this.isEnabled = this.apiKey ?? this.isEnabled;
         if (!this.isEnabled)
             return;
         if (!this.runId)
@@ -326,13 +341,16 @@ class TestomatioPipe {
             data.rid = `${this.runId}-${data.rid}`;
         data.api_key = this.apiKey;
         data.create = this.createNewTests;
+        let uploading = null;
         if (!this.batch.isEnabled)
-            this.#uploadSingleTest(data);
+            uploading = this.#uploadSingleTest(data);
         else
             this.batch.tests.push(data);
         // if test is added after run which is already finished
         if (!this.batch.intervalFunction)
-            this.#batchUpload();
+            uploading = this.#batchUpload();
+        // return promise to be able to wait for it
+        return uploading;
     }
     /**
      * @param {import('../../types/types.js').RunData} params
@@ -367,12 +385,16 @@ class TestomatioPipe {
             status_event += '_parallel';
         try {
             if (this.runId && !this.proceed) {
-                await this.axios.put(`/api/reporter/${this.runId}`, {
-                    api_key: this.apiKey,
-                    duration: params.duration,
-                    status_event,
-                    detach: params.detach,
-                    tests: params.tests,
+                await this.client.request({
+                    method: 'PUT',
+                    url: `/api/reporter/${this.runId}`,
+                    data: {
+                        api_key: this.apiKey,
+                        duration: params.duration,
+                        status_event,
+                        detach: params.detach,
+                        tests: params.tests,
+                    }
                 });
                 if (this.runUrl) {
                     console.log(constants_js_1.APP_PREFIX, '📊 Report Saved. Report URL:', picocolors_1.default.magenta(this.runUrl));
@@ -388,17 +410,13 @@ class TestomatioPipe {
             }
             if (this.hasUnmatchedTests) {
                 console.log('');
-                // eslint-disable-next-line max-len
                 console.log(constants_js_1.APP_PREFIX, picocolors_1.default.yellow(picocolors_1.default.bold('⚠️ Some reported tests were not found in Testomat.io project')));
-                // eslint-disable-next-line max-len
                 console.log(constants_js_1.APP_PREFIX, `If you use Testomat.io as a reporter only, please re-run tests using ${picocolors_1.default.bold('TESTOMATIO_CREATE=1')}`);
-                // eslint-disable-next-line max-len
                 console.log(constants_js_1.APP_PREFIX, `But to keep your tests consistent it is recommended to ${picocolors_1.default.bold('import tests first')}`);
                 console.log(constants_js_1.APP_PREFIX, 'If tests were imported but still not matched, assign test IDs to your tests.');
                 console.log(constants_js_1.APP_PREFIX, 'You can do that automatically via command line tools:');
                 console.log(constants_js_1.APP_PREFIX, picocolors_1.default.bold('npx check-tests ... --update-ids'), 'See: https://bit.ly/js-update-ids');
                 console.log(constants_js_1.APP_PREFIX, 'or for Cucumber:');
-                // eslint-disable-next-line max-len
                 console.log(constants_js_1.APP_PREFIX, picocolors_1.default.bold('npx check-cucumber ... --update-ids'), 'See: https://bit.ly/bdd-update-ids');
             }
         }
@@ -420,24 +438,16 @@ function printCreateIssue(err) {
     process.on('exit', () => {
         console.log();
         console.log(constants_js_1.APP_PREFIX, 'There was an error reporting to Testomat.io:');
-        console.log(constants_js_1.APP_PREFIX, 'If you think this is a bug please create an issue: https://github.com/testomatio/reporter/issues/new'); // eslint-disable-line max-len
+        console.log(constants_js_1.APP_PREFIX, 'If you think this is a bug please create an issue: https://github.com/testomatio/reporter/issues/new');
         console.log(constants_js_1.APP_PREFIX, 'Provide this information:');
         console.log('Error:', err.message || err.code);
         if (!err.config)
             return;
         const time = new Date().toUTCString();
-        const { data, url, baseURL, method } = err?.config || {};
+        const { body, url, baseURL, method } = err?.config || {};
         console.log('```js');
-        console.log({ data: data?.replace(/"(tstmt_[^"]+)"/g, 'tstmt_*'), url, baseURL, method, time });
+        console.log({ body: body?.replace(/"(tstmt_[^"]+)"/g, 'tstmt_*'), url, baseURL, method, time });
         console.log('```');
     });
 }
-const axiosAddTestrunRequestConfig = {
-    maxContentLength: Infinity,
-    maxBodyLength: Infinity,
-    headers: {
-        // Overwrite Axios's automatically set Content-Type
-        'Content-Type': 'application/json',
-    },
-};
 module.exports = TestomatioPipe;

package/lib/replay.d.ts

@@ -0,0 +1,31 @@
+export class Replay {
+    constructor(options?: {});
+    apiKey: any;
+    dryRun: any;
+    onProgress: any;
+    onLog: any;
+    onError: any;
+    /**
+     * Get the default debug file path
+     * @returns {string} Path to the latest debug file
+     */
+    getDefaultDebugFile(): string;
+    /**
+     * Parse a debug file and extract test data
+     * @param {string} debugFile - Path to the debug file
+     * @returns {Object} Parsed debug data
+     */
+    parseDebugFile(debugFile: string): any;
+    /**
+     * Restore environment variables from debug data
+     * @param {Object} envVars - Environment variables to restore
+     */
+    restoreEnvironmentVariables(envVars: any): void;
+    /**
+     * Replay test data to Testomat.io
+     * @param {string} debugFile - Path to debug file (optional, uses default if not provided)
+     * @returns {Promise<Object>} Replay results
+     */
+    replay(debugFile: string): Promise<any>;
+}
+export default Replay;

package/lib/replay.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Replay = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const client_js_1 = __importDefault(require("./client.js"));
+const constants_js_1 = require("./constants.js");
+const config_js_1 = require("./config.js");
+class Replay {
+    constructor(options = {}) {
+        this.apiKey = options.apiKey || config_js_1.config.TESTOMATIO || undefined;
+        this.dryRun = options.dryRun || false;
+        this.onProgress = options.onProgress || (() => { });
+        this.onLog = options.onLog || console.log;
+        this.onError = options.onError || console.error;
+    }
+    /**
+     * Get the default debug file path
+     * @returns {string} Path to the latest debug file
+     */
+    getDefaultDebugFile() {
+        return path_1.default.join(os_1.default.tmpdir(), 'testomatio.debug.latest.json');
+    }
+    /**
+     * Parse a debug file and extract test data
+     * @param {string} debugFile - Path to the debug file
+     * @returns {Object} Parsed debug data
+     */
+    parseDebugFile(debugFile) {
+        if (!fs_1.default.existsSync(debugFile)) {
+            throw new Error(`Debug file not found: ${debugFile}`);
+        }
+        const fileContent = fs_1.default.readFileSync(debugFile, 'utf-8');
+        const lines = fileContent.trim().split('\n').filter(line => line.trim() !== '');
+        if (lines.length === 0) {
+            throw new Error('Debug file is empty');
+        }
+        let runParams = {};
+        let finishParams = {};
+        let parseErrors = 0;
+        const testsMap = new Map(); // Use Map to deduplicate by rid
+        const testsWithoutRid = []; // For tests without rid (backward compatibility)
+        const envVars = {};
+        let runId = null;
+        // Parse debug file line by line
+        for (const [lineIndex, line] of lines.entries()) {
+            try {
+                const logEntry = JSON.parse(line);
+                if (logEntry.data === 'variables' && logEntry.testomatioEnvVars) {
+                    Object.assign(envVars, logEntry.testomatioEnvVars);
+                }
+                else if (logEntry.action === 'createRun') {
+                    runParams = logEntry.params || {};
+                }
+                else if (logEntry.action === 'addTestsBatch' && logEntry.tests) {
+                    // Extract runId if available
+                    if (logEntry.runId && !runId) {
+                        runId = logEntry.runId;
+                    }
+                    // Process each test in the batch
+                    for (const test of logEntry.tests) {
+                        if (test.rid) {
+                            // Handle tests with rid (deduplicate)
+                            const existingTest = testsMap.get(test.rid);
+                            if (existingTest) {
+                                // Merge test data - prioritize non-null/non-empty values
+                                const mergedTest = { ...existingTest };
+                                Object.keys(test).forEach(key => {
+                                    if (test[key] !== null && test[key] !== undefined) {
+                                        if (key === 'files' && Array.isArray(test[key]) && test[key].length > 0) {
+                                            // Merge files arrays
+                                            mergedTest.files = [...(existingTest.files || []), ...test[key]];
+                                        }
+                                        else if (key === 'artifacts' && Array.isArray(test[key]) && test[key].length > 0) {
+                                            // Merge artifacts arrays
+                                            mergedTest.artifacts = [...(existingTest.artifacts || []), ...test[key]];
+                                        }
+                                        else if (existingTest[key] === null || existingTest[key] === undefined ||
+                                            (Array.isArray(existingTest[key]) && existingTest[key].length === 0)) {
+                                            // Use new value if existing is null/undefined/empty array
+                                            mergedTest[key] = test[key];
+                                        }
+                                    }
+                                });
+                                testsMap.set(test.rid, mergedTest);
+                            }
+                            else {
+                                testsMap.set(test.rid, { ...test });
+                            }
+                        }
+                        else {
+                            // Handle tests without rid (no deduplication)
+                            testsWithoutRid.push({ ...test });
+                        }
+                    }
+                }
+                else if (logEntry.action === 'addTest' && logEntry.testId) {
+                    // Extract runId if available
+                    if (logEntry.runId && !runId) {
+                        runId = logEntry.runId;
+                    }
+                    const test = logEntry.testId;
+                    if (test.rid) {
+                        // Handle tests with rid (deduplicate)
+                        const existingTest = testsMap.get(test.rid);
+                        if (existingTest) {
+                            // Merge with existing test
+                            const mergedTest = { ...existingTest, ...test };
+                            testsMap.set(test.rid, mergedTest);
+                        }
+                        else {
+                            testsMap.set(test.rid, { ...test });
+                        }
+                    }
+                    else {
+                        // Handle tests without rid (no deduplication)
+                        testsWithoutRid.push({ ...test });
+                    }
+                }
+                else if (logEntry.actions === 'finishRun') {
+                    finishParams = logEntry.params || {};
+                }
+            }
+            catch (err) {
+                parseErrors++;
+                if (parseErrors <= 3) {
+                    // Only show first 3 parse errors
+                    this.onError(`Failed to parse line ${lineIndex + 1}: ${line.substring(0, 100)}...`);
+                }
+            }
+        }
+        if (parseErrors > 3) {
+            this.onError(`${parseErrors - 3} more parse errors occurred`);
+        }
+        // Combine tests with rid and tests without rid
+        const allTests = [...Array.from(testsMap.values()), ...testsWithoutRid];
+        return {
+            runParams,
+            finishParams,
+            tests: allTests,
+            envVars,
+            parseErrors,
+            totalLines: lines.length,
+            runId
+        };
+    }
+    /**
+     * Restore environment variables from debug data
+     * @param {Object} envVars - Environment variables to restore
+     */
+    restoreEnvironmentVariables(envVars) {
+        // Only restore env vars that aren't already set (don't override current values)
+        Object.keys(envVars).forEach(key => {
+            if (process.env[key] === undefined || process.env[key] === '') {
+                process.env[key] = envVars[key];
+            }
+        });
+    }
+    /**
+     * Replay test data to Testomat.io
+     * @param {string} debugFile - Path to debug file (optional, uses default if not provided)
+     * @returns {Promise<Object>} Replay results
+     */
+    async replay(debugFile) {
+        if (!debugFile) {
+            debugFile = this.getDefaultDebugFile();
+        }
+        if (!this.apiKey) {
+            throw new Error('TESTOMATIO API key not found. Set TESTOMATIO environment variable.');
+        }
+        this.onLog(`Replaying data from debug file: ${debugFile}`);
+        // Parse the debug file
+        const debugData = this.parseDebugFile(debugFile);
+        const { runParams, finishParams, tests, envVars, runId } = debugData;
+        this.onLog(`Found ${tests.length} tests to replay`);
+        if (tests.length === 0) {
+            throw new Error('No test data found in debug file');
+        }
+        // Restore environment variables
+        this.restoreEnvironmentVariables(envVars);
+        if (this.dryRun) {
+            return {
+                success: true,
+                testsCount: tests.length,
+                runParams,
+                finishParams,
+                envVars,
+                runId,
+                dryRun: true
+            };
+        }
+        // Create client and restore the run
+        const client = new client_js_1.default({
+            apiKey: this.apiKey,
+            isBatchEnabled: true,
+            ...runParams,
+        });
+        // Use the stored runId if available, otherwise create a new run
+        if (runId) {
+            this.onLog(`Using existing run ID: ${runId}`);
+            client.runId = runId;
+        }
+        else {
+            this.onLog('Publishing to run...');
+            await client.createRun(runParams);
+        }
+        // Send each test result
+        let successCount = 0;
+        let failureCount = 0;
+        for (const [index, test] of tests.entries()) {
+            try {
+                await client.addTestRun(test.status, test);
+                successCount++;
+                this.onProgress({
+                    current: index + 1,
+                    total: tests.length,
+                    test,
+                    success: true
+                });
+            }
+            catch (err) {
+                failureCount++;
+                this.onError(`Failed to send test ${index + 1}: ${err.message}`);
+                this.onProgress({
+                    current: index + 1,
+                    total: tests.length,
+                    test,
+                    success: false,
+                    error: err.message
+                });
+            }
+        }
+        await client.updateRunStatus(finishParams.status || constants_js_1.STATUS.FINISHED, finishParams.parallel || false);
+        const result = {
+            success: true,
+            testsCount: tests.length,
+            successCount,
+            failureCount,
+            runParams,
+            finishParams,
+            envVars,
+            runId: runId || client.runId
+        };
+        this.onLog(`Successfully replayed ${successCount}/${tests.length} tests from debug file`);
+        return result;
+    }
+}
+exports.Replay = Replay;
+module.exports = Replay;
+
+module.exports.Replay = Replay;

package/lib/reporter-functions.d.ts

@@ -3,6 +3,7 @@ declare namespace _default {
     export { logMessage as log };
     export { addStep as step };
     export { setKeyValue as keyValue };
+    export { setLabel as label };
 }
 export default _default;
 /**
@@ -32,3 +33,9 @@ declare function addStep(message: string): void;
 declare function setKeyValue(keyValue: {
     [key: string]: string;
 } | string, value?: string | null): void;
+/**
+ * Add a single label to the test report
+ * @param {string} key - label key (e.g. 'severity', 'feature', or just 'smoke' for labels without values)
+ * @param {string} [value] - optional label value (e.g. 'high', 'login')
+ */
+declare function setLabel(key: string, value?: string): void;

package/lib/reporter-functions.js

@@ -44,9 +44,45 @@ function setKeyValue(keyValue, value = null) {
     }
     index_js_1.services.keyValues.put(keyValue);
 }
+/**
+ * Add a single label to the test report
+ * @param {string} key - label key (e.g. 'severity', 'feature', or just 'smoke' for labels without values)
+ * @param {string} [value] - optional label value (e.g. 'high', 'login')
+ */
+function setLabel(key, value = null) {
+    if (!key || typeof key !== 'string') {
+        console.warn('Label key must be a non-empty string');
+        return;
+    }
+    // Limit key length to 255 characters
+    if (key.length > 255) {
+        console.warn('Label key is too long, trimmed to 255 characters:', key);
+        key = key.substring(0, 255);
+    }
+    let labelString = key;
+    if (value !== null && value !== undefined && value !== '') {
+        if (typeof value !== 'string') {
+            console.warn('Label value must be a string, converting:', value);
+            value = String(value);
+        }
+        // Limit value length to 255 characters
+        if (value.length > 255) {
+            console.warn('Label value is too long, trimmed to 255 characters:', value);
+            value = value.substring(0, 255);
+        }
+        labelString = `${key}:${value}`;
+    }
+    // Limit total label length to 255 characters
+    if (labelString.length > 255) {
+        console.warn('Label is too long, trimmed to 255 characters:', labelString);
+        labelString = labelString.substring(0, 255);
+    }
+    index_js_1.services.labels.put([labelString]);
+}
 module.exports = {
     artifact: saveArtifact,
     log: logMessage,
     step: addStep,
     keyValue: setKeyValue,
+    label: setLabel,
 };