@datadog/datadog-ci 0.17.4 → 0.17.7

package/dist/commands/sourcemaps/git.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import * as simpleGit from 'simple-git';
+import { Writable } from 'stream';
+export declare const newSimpleGit: () => Promise<simpleGit.SimpleGit>;
+export declare const gitRemote: (git: simpleGit.SimpleGit) => Promise<string>;
+export declare const stripCredentials: (remote: string) => string;
+export declare const gitTrackedFiles: (git: simpleGit.SimpleGit) => Promise<string[]>;
+export interface RepositoryData {
+    hash: string;
+    remote: string;
+    trackedFilesMatcher: TrackedFilesMatcher;
+}
+export declare const getRepositoryData: (git: simpleGit.SimpleGit, stdout: Writable, repositoryURL: string | undefined) => Promise<RepositoryData | undefined>;
+export declare class TrackedFilesMatcher {
+    private trackedFilenames;
+    constructor(trackedFiles: string[]);
+    matchSourcemap(stdout: Writable, srcmapPath: string): string[] | undefined;
+    matchSources(sources: string[]): string[];
+    private getFilename;
+}

package/dist/commands/sourcemaps/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/sourcemaps/interfaces.d.ts

@@ -0,0 +1,15 @@
+import { MultipartPayload } from '../../helpers/upload';
+export declare class Sourcemap {
+    gitData?: GitData;
+    minifiedFilePath: string;
+    minifiedUrl: string;
+    sourcemapPath: string;
+    constructor(minifiedFilePath: string, minifiedUrl: string, sourcemapPath: string);
+    addRepositoryData(gitData: GitData): void;
+    asMultipartPayload(cliVersion: string, service: string, version: string, projectPath: string): MultipartPayload;
+}
+export interface GitData {
+    gitCommitSha: string;
+    gitRepositoryPayload?: string;
+    gitRepositoryURL: string;
+}

package/dist/commands/sourcemaps/renderer.d.ts

@@ -0,0 +1,12 @@
+import { UploadStatus } from '../../helpers/upload';
+import { Sourcemap } from './interfaces';
+export declare const renderGitWarning: (errorMessage: string) => string;
+export declare const renderGitDataNotAttachedWarning: (sourcemap: string, errorMessage: string) => string;
+export declare const renderSourcesNotFoundWarning: (sourcemap: string) => string;
+export declare const renderConfigurationError: (error: Error) => string;
+export declare const renderInvalidPrefix: string;
+export declare const renderFailedUpload: (sourcemap: Sourcemap, errorMessage: string) => string;
+export declare const renderRetriedUpload: (payload: Sourcemap, errorMessage: string, attempt: number) => string;
+export declare const renderSuccessfulCommand: (statuses: UploadStatus[], duration: number, dryRun: boolean) => string;
+export declare const renderCommandInfo: (basePath: string, minifiedPathPrefix: string, projectPath: string, releaseVersion: string, service: string, poolLimit: number, dryRun: boolean) => string;
+export declare const renderUpload: (sourcemap: Sourcemap) => string;

package/dist/commands/sourcemaps/upload.d.ts

@@ -0,0 +1,25 @@
+import { Command } from 'clipanion';
+export declare class UploadCommand extends Command {
+    static usage: import("clipanion/lib/advanced").Usage;
+    private basePath?;
+    private cliVersion;
+    private config;
+    private disableGit?;
+    private dryRun;
+    private maxConcurrency;
+    private minifiedPathPrefix?;
+    private projectPath;
+    private releaseVersion?;
+    private repositoryURL?;
+    private service?;
+    constructor();
+    execute(): Promise<1 | 0>;
+    private addRepositoryDataToPayloads;
+    private getMatchingSourcemapFiles;
+    private getMinifiedURL;
+    private getPayloadsToUpload;
+    private getRepositoryPayload;
+    private getRequestBuilder;
+    private isMinifiedPathPrefixValid;
+    private upload;
+}

package/dist/commands/sourcemaps/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const getMinifiedFilePath: (sourcemapPath: string) => string;
+export declare const getBaseIntakeUrl: () => string;
+export declare const pluralize: (nb: number, singular: string, plural: string) => string;

package/dist/commands/sourcemaps/validation.d.ts

@@ -0,0 +1,6 @@
+import { Sourcemap } from './interfaces';
+export declare class InvalidPayload extends Error {
+    reason: string;
+    constructor(reason: string, message?: string);
+}
+export declare const validatePayload: (sourcemap: Sourcemap) => void;

package/dist/commands/synthetics/__tests__/api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/synthetics/__tests__/cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/synthetics/__tests__/cli.test.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ciUtils = __importStar(require("../../../helpers/utils"));
+const cli_1 = require("../cli");
+const interfaces_1 = require("../interfaces");
+const runTests = __importStar(require("../run-test"));
+const utils = __importStar(require("../utils"));
+const fixtures_1 = require("./fixtures");
+describe('run-test', () => {
+    beforeEach(() => {
+        jest.restoreAllMocks();
+        jest.spyOn(ciUtils, 'getConfig').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return ({}); }));
+        process.env = {};
+    });
+    describe('getAppBaseURL', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+        });
+        test('should default to datadog us', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env = {};
+            const command = new cli_1.RunTestCommand();
+            expect(command['getAppBaseURL']()).toBe('https://app.datadoghq.com/');
+        }));
+        test('subdomain should be overridable', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env = { DATADOG_SUBDOMAIN: 'custom' };
+            const command = new cli_1.RunTestCommand();
+            yield command['resolveConfig']();
+            expect(command['getAppBaseURL']()).toBe('https://custom.datadoghq.com/');
+        }));
+        test('should override subdomain and site', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env = {
+                DATADOG_SITE: 'datadoghq.eu',
+                DATADOG_SUBDOMAIN: 'custom',
+            };
+            const command = new cli_1.RunTestCommand();
+            yield command['resolveConfig']();
+            expect(command['getAppBaseURL']()).toBe('https://custom.datadoghq.eu/');
+        }));
+    });
+    describe('sortTestsByOutcome', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+        });
+        const test1 = { options: {}, public_id: 'test1' };
+        const test2 = { options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: 'test2' };
+        const test3 = { options: { ci: { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING } }, public_id: 'test3' };
+        const test4 = { options: { ci: { executionRule: interfaces_1.ExecutionRule.BLOCKING } }, public_id: 'test4' };
+        const test5 = { options: { ci: { executionRule: interfaces_1.ExecutionRule.NON_BLOCKING } }, public_id: 'test5' };
+        const tests = [test1, test2, test3, test4, test5];
+        const results = {
+            test1: [{ result: { passed: true } }],
+            test2: [{ result: { passed: true } }],
+            test3: [{ result: { passed: true } }],
+            test4: [{ result: { passed: false } }],
+            test5: [{ result: { passed: false } }],
+        };
+        test('should sort tests with success, non_blocking failures then failures', () => __awaiter(void 0, void 0, void 0, function* () {
+            const command = new cli_1.RunTestCommand();
+            tests.sort(command['sortTestsByOutcome'](results));
+            expect(tests).toStrictEqual([test3, test1, test2, test5, test4]);
+        }));
+    });
+    describe('resolveConfig', () => {
+        beforeEach(() => {
+            jest.restoreAllMocks();
+            process.env = {};
+            jest.spyOn(ciUtils, 'getConfig').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return ({}); }));
+        });
+        test('override from ENV', () => __awaiter(void 0, void 0, void 0, function* () {
+            const overrideEnv = {
+                DATADOG_API_KEY: 'fake_api_key',
+                DATADOG_APP_KEY: 'fake_app_key',
+                DATADOG_SITE: 'datadoghq.eu',
+                DATADOG_SUBDOMAIN: 'custom',
+            };
+            process.env = overrideEnv;
+            const command = new cli_1.RunTestCommand();
+            yield command['resolveConfig']();
+            expect(command['config']).toEqual(Object.assign(Object.assign({}, cli_1.DEFAULT_COMMAND_CONFIG), { apiKey: overrideEnv.DATADOG_API_KEY, appKey: overrideEnv.DATADOG_APP_KEY, datadogSite: overrideEnv.DATADOG_SITE, subdomain: overrideEnv.DATADOG_SUBDOMAIN }));
+        }));
+        test('override from config file', () => __awaiter(void 0, void 0, void 0, function* () {
+            const overrideConfigFile = {
+                apiKey: 'fake_api_key',
+                appKey: 'fake_app_key',
+                configPath: 'fake-datadog-ci.json',
+                datadogSite: 'datadoghq.eu',
+                failOnCriticalErrors: true,
+                failOnTimeout: false,
+                files: ['my-new-file'],
+                global: { locations: [] },
+                locations: [],
+                pollingTimeout: 1,
+                proxy: { protocol: 'https' },
+                publicIds: ['ran-dom-id'],
+                subdomain: 'ppa',
+                tunnel: true,
+            };
+            jest.spyOn(ciUtils, 'getConfig').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return overrideConfigFile; }));
+            const command = new cli_1.RunTestCommand();
+            yield command['resolveConfig']();
+            expect(command['config']).toEqual(overrideConfigFile);
+        }));
+        test('override from CLI', () => __awaiter(void 0, void 0, void 0, function* () {
+            const overrideCLI = {
+                apiKey: 'fake_api_key',
+                appKey: 'fake_app_key',
+                configPath: 'fake-datadog-ci.json',
+                datadogSite: 'datadoghq.eu',
+                failOnCriticalErrors: true,
+                failOnTimeout: false,
+                files: ['new-file'],
+                publicIds: ['ran-dom-id'],
+                subdomain: 'new-sub-domain',
+                testSearchQuery: 'a-search-query',
+                tunnel: true,
+            };
+            const command = new cli_1.RunTestCommand();
+            command['apiKey'] = overrideCLI.apiKey;
+            command['appKey'] = overrideCLI.appKey;
+            command['configPath'] = overrideCLI.configPath;
+            command['datadogSite'] = overrideCLI.datadogSite;
+            command['failOnCriticalErrors'] = overrideCLI.failOnCriticalErrors;
+            command['failOnTimeout'] = overrideCLI.failOnTimeout;
+            command['files'] = overrideCLI.files;
+            command['publicIds'] = overrideCLI.publicIds;
+            command['subdomain'] = overrideCLI.subdomain;
+            command['tunnel'] = overrideCLI.tunnel;
+            command['testSearchQuery'] = overrideCLI.testSearchQuery;
+            yield command['resolveConfig']();
+            expect(command['config']).toEqual(Object.assign(Object.assign({}, cli_1.DEFAULT_COMMAND_CONFIG), { apiKey: 'fake_api_key', appKey: 'fake_app_key', configPath: 'fake-datadog-ci.json', datadogSite: 'datadoghq.eu', failOnCriticalErrors: true, failOnTimeout: false, files: ['new-file'], publicIds: ['ran-dom-id'], subdomain: 'new-sub-domain', testSearchQuery: 'a-search-query', tunnel: true }));
+        }));
+        test('override from config file < ENV < CLI', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(ciUtils, 'getConfig').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+                return ({
+                    apiKey: 'api_key_config_file',
+                    appKey: 'app_key_config_file',
+                    datadogSite: 'datadog.config.file',
+                });
+            }));
+            process.env = {
+                DATADOG_API_KEY: 'api_key_env',
+                DATADOG_APP_KEY: 'app_key_env',
+            };
+            const command = new cli_1.RunTestCommand();
+            command['apiKey'] = 'api_key_cli';
+            yield command['resolveConfig']();
+            expect(command['config']).toEqual(Object.assign(Object.assign({}, cli_1.DEFAULT_COMMAND_CONFIG), { apiKey: 'api_key_cli', appKey: 'app_key_env', datadogSite: 'datadog.config.file' }));
+        }));
+        test('override locations with ENV variable', () => __awaiter(void 0, void 0, void 0, function* () {
+            const conf = {
+                content: { tests: [{ config: {}, id: 'publicId' }] },
+                name: 'Suite 1',
+            };
+            jest.spyOn(ciUtils, 'parseConfigFile').mockImplementation((config, _) => __awaiter(void 0, void 0, void 0, function* () { return config; }));
+            jest.spyOn(utils, 'getSuites').mockImplementation((() => [conf]));
+            // Throw to stop the test
+            const serverError = new Error('Server Error');
+            serverError.response = { data: { errors: ['Bad Gateway'] }, status: 502 };
+            serverError.config = { baseURL: 'baseURL', url: 'url' };
+            const triggerTests = jest.fn(() => {
+                throw serverError;
+            });
+            const apiHelper = {
+                getTest: jest.fn(() => (Object.assign({}, fixtures_1.getApiTest('publicId')))),
+                triggerTests,
+            };
+            const write = jest.fn();
+            const command = new cli_1.RunTestCommand();
+            command.context = { stdout: { write } };
+            command['config'].global = { locations: ['aws:us-east-2'] };
+            jest.spyOn(runTests, 'getApiHelper').mockImplementation(() => apiHelper);
+            expect(yield command.execute()).toBe(0);
+            expect(triggerTests).toHaveBeenCalledWith(expect.objectContaining({
+                tests: [{ executionRule: 'blocking', locations: ['aws:us-east-2'], public_id: 'publicId' }],
+            }));
+            // Env > global
+            process.env = {
+                DATADOG_SYNTHETICS_LOCATIONS: 'aws:us-east-3',
+            };
+            expect(yield command.execute()).toBe(0);
+            expect(triggerTests).toHaveBeenCalledTimes(2);
+            expect(triggerTests).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                tests: [{ executionRule: 'blocking', locations: ['aws:us-east-3'], public_id: 'publicId' }],
+            }));
+            process.env = {
+                DATADOG_SYNTHETICS_LOCATIONS: 'aws:us-east-3;aws:us-east-4',
+            };
+            expect(yield command.execute()).toBe(0);
+            expect(triggerTests).toHaveBeenCalledTimes(3);
+            expect(triggerTests).toHaveBeenNthCalledWith(3, expect.objectContaining({
+                tests: [{ executionRule: 'blocking', locations: ['aws:us-east-3', 'aws:us-east-4'], public_id: 'publicId' }],
+            }));
+            // Test > env
+            const confWithLocation = {
+                content: { tests: [{ config: { locations: ['aws:us-east-1'] }, id: 'publicId' }] },
+            };
+            jest.spyOn(utils, 'getSuites').mockImplementation((() => [confWithLocation]));
+            expect(yield command.execute()).toBe(0);
+            expect(triggerTests).toHaveBeenCalledWith(expect.objectContaining({
+                tests: [{ executionRule: 'blocking', locations: ['aws:us-east-1'], public_id: 'publicId' }],
+            }));
+        }));
+    });
+});

package/dist/commands/synthetics/__tests__/crypto.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/synthetics/__tests__/fixtures.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="jest" />
+/// <reference types="node" />
+import * as http from 'http';
+import { ProxyConfiguration } from '../../../helpers/utils';
+import { ApiTestResult, BrowserTestResult, CommandConfig, MainReporter, MultiStep, MultiStepsTestResult, PollResult, Step, Test } from '../interfaces';
+export declare const mockReporter: MainReporter;
+export declare const ciConfig: CommandConfig;
+export declare const getApiTest: (publicId: string) => Test;
+export declare const getStep: () => Step;
+export declare const getMultiStep: () => MultiStep;
+export declare const getBrowserPollResult: () => PollResult;
+export declare const getApiPollResult: () => PollResult;
+export declare const getBrowserResult: (opts?: any) => BrowserTestResult;
+export declare const getApiResult: () => ApiTestResult;
+export declare const getMultiStepsResult: () => MultiStepsTestResult;
+export declare const mockSearchResponse: {
+    tests: {
+        public_id: string;
+    }[];
+};
+export declare const mockTestTriggerResponse: {
+    locations: string[];
+    results: {
+        location: number;
+        public_id: string;
+        result: {
+            dc_id: number;
+            result: {
+                device: string;
+                passed: boolean;
+                public_id: string;
+            };
+            result_id: string;
+        };
+        result_id: string;
+    }[];
+    triggered_check_ids: string[];
+};
+export declare const mockPollResultResponse: {
+    results: {
+        dc_id: number;
+        result: {
+            location: number;
+            public_id: string;
+            result: {
+                dc_id: number;
+                result: {
+                    device: string;
+                    passed: boolean;
+                    public_id: string;
+                };
+                result_id: string;
+            };
+            result_id: string;
+        };
+        resultID: string;
+    }[];
+};
+export declare const getSyntheticsProxy: () => {
+    calls: {
+        get: jest.Mock<any, any>;
+        poll: jest.Mock<any, any>;
+        presignedUrl: jest.Mock<any, any>;
+        search: jest.Mock<any, any>;
+        trigger: jest.Mock<any, any>;
+        tunnel: jest.Mock<any, any>;
+    };
+    close: () => Promise<[unknown, unknown]>;
+    config: ProxyConfiguration;
+    server: http.Server;
+};

package/dist/commands/synthetics/__tests__/fixtures.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSyntheticsProxy = exports.mockPollResultResponse = exports.mockTestTriggerResponse = exports.mockSearchResponse = exports.getMultiStepsResult = exports.getApiResult = exports.getBrowserResult = exports.getApiPollResult = exports.getBrowserPollResult = exports.getMultiStep = exports.getStep = exports.getApiTest = exports.mockReporter = void 0;
+exports.getSyntheticsProxy = exports.mockPollResultResponse = exports.mockTestTriggerResponse = exports.mockSearchResponse = exports.getMultiStepsResult = exports.getApiResult = exports.getBrowserResult = exports.getApiPollResult = exports.getBrowserPollResult = exports.getMultiStep = exports.getStep = exports.getApiTest = exports.ciConfig = exports.mockReporter = void 0;
 const http = __importStar(require("http"));
 const url_1 = require("url");
 const ws_1 = require("ws");
@@ -39,6 +39,22 @@ exports.mockReporter = {
     testTrigger: jest.fn(),
     testWait: jest.fn(),
 };
+exports.ciConfig = {
+    apiKey: '',
+    appKey: '',
+    configPath: 'datadog-ci.json',
+    datadogSite: 'datadoghq.com',
+    failOnCriticalErrors: false,
+    failOnTimeout: true,
+    files: ['{,!(node_modules)/**/}*.synthetics.json'],
+    global: {},
+    locations: [],
+    pollingTimeout: 2 * 60 * 1000,
+    proxy: { protocol: 'http' },
+    publicIds: [],
+    subdomain: 'app',
+    tunnel: false,
+};
 const getApiTest = (publicId) => ({
     config: {
         assertions: [],

package/dist/commands/synthetics/__tests__/reporters/default.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/synthetics/__tests__/reporters/default.test.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const default_1 = require("../../reporters/default");
 describe('Default reporter', () => {
     const writeMock = jest.fn();
-    const commandMock = {
+    const mockContext = {
         context: {
             stdout: {
                 write: writeMock,
             },
         },
     };
-    const reporter = new default_1.DefaultReporter(commandMock);
+    const reporter = new default_1.DefaultReporter(mockContext);
     it('should log for each hook', () => {
         const calls = [
             ['error', ['error']],

package/dist/commands/synthetics/__tests__/reporters/junit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/synthetics/__tests__/reporters/junit.test.js

@@ -80,28 +80,29 @@ describe('Junit reporter', () => {
         }));
     });
     describe('testEnd', () => {
+        const rest = [[], '', {}, true, true];
         beforeEach(() => {
             reporter = new junit_1.JUnitReporter(commandMock);
         });
         it('should give a default suite name', () => {
-            reporter.testEnd(globalTestMock, [], '', {});
+            reporter.testEnd(globalTestMock, ...rest);
             const testsuite = reporter['json'].testsuites.testsuite[0];
             expect(testsuite.$.name).toBe('Undefined suite');
         });
         it('should use the same report for tests from same suite', () => {
             const testMock = Object.assign({ suite: 'Suite 1' }, globalTestMock);
-            reporter.testEnd(testMock, [], '', {});
-            reporter.testEnd(testMock, [], '', {});
+            reporter.testEnd(testMock, ...rest);
+            reporter.testEnd(testMock, ...rest);
             expect(reporter['json'].testsuites.testsuite.length).toBe(1);
         });
         it('should add stats to the run', () => {
-            reporter.testEnd(globalTestMock, [], '', {});
+            reporter.testEnd(globalTestMock, ...rest);
             const testsuite = reporter['json'].testsuites.testsuite[0];
             expect(testsuite.$).toMatchObject(junit_1.getDefaultStats());
         });
         it('should report errors', () => {
             const browserResult1 = Object.assign(Object.assign({}, globalResultMock), { result: Object.assign(Object.assign({}, fixtures_1.getBrowserResult()), { stepDetails: [
-                        Object.assign(Object.assign({}, fixtures_1.getStep()), { browserErrors: [
+                        Object.assign(Object.assign({}, fixtures_1.getStep()), { allowFailure: true, browserErrors: [
                                 {
                                     description: 'error description',
                                     name: 'error name',
@@ -128,20 +129,21 @@ describe('Junit reporter', () => {
                                 message: 'message',
                             } }),
                     ] }) });
-            reporter.testEnd(globalTestMock, [browserResult1, browserResult2, browserResult3, apiResult], '', {});
+            reporter.testEnd(globalTestMock, [browserResult1, browserResult2, browserResult3, apiResult], '', {}, true, true);
             const testsuite = reporter['json'].testsuites.testsuite[0];
             const results = [
-                [2, 1, 1],
-                [0, 0, 0],
-                [0, 1, 0],
-                [0, 1, 0],
+                [1, 2, 0, 1],
+                [0, 0, 0, 0],
+                [0, 0, 1, 0],
+                [0, 0, 1, 0],
             ];
             const entries = Object.entries(testsuite.testcase);
             for (const [i, testcase] of entries) {
                 const result = results[i];
-                expect(testcase.browser_error.length).toBe(result[0]);
-                expect(testcase.error.length).toBe(result[1]);
-                expect(testcase.warning.length).toBe(result[2]);
+                expect(testcase.allowed_error.length).toBe(result[0]);
+                expect(testcase.browser_error.length).toBe(result[1]);
+                expect(testcase.error.length).toBe(result[2]);
+                expect(testcase.warning.length).toBe(result[3]);
             }
         });
     });
@@ -158,7 +160,7 @@ describe('Junit reporter', () => {
                         }),
                     ] }),
             });
-            const suite = reporter['getTestCase'](fixtures_1.getApiTest('123'), resultMock, {});
+            const suite = reporter['getTestCase'](fixtures_1.getApiTest('123'), resultMock, {}, true, true);
             expect(suite.$).toMatchObject(Object.assign(Object.assign({}, junit_1.getDefaultStats()), { errors: 2, failures: 1, tests: 3, warnings: 1 }));
         });
     });

package/dist/commands/synthetics/__tests__/run-test.test.d.ts

@@ -0,0 +1 @@
+export {};