@datadog/datadog-ci 0.17.6-alpha → 0.17.9

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

@@ -0,0 +1,95 @@
+import { BaseContext } from 'clipanion';
+import { InternalTest, LocationsMapping, PollResult, Reporter, Vitals } from '../interfaces';
+interface Stats {
+    allowfailures: number;
+    errors: number;
+    failures: number;
+    skipped: number;
+    tests: number;
+    warnings: number;
+}
+interface XMLTestCaseProperties extends Stats {
+    name: string;
+    time: number | undefined;
+    timestamp: string;
+}
+export interface XMLTestCase {
+    $: XMLTestCaseProperties;
+    allowed_error: XMLError[];
+    browser_error: XMLError[];
+    error: XMLError[];
+    properties: {
+        property: {
+            $: {
+                name: string;
+                value: any;
+            };
+        }[];
+    };
+    testcase: XMLStep[];
+    warning: XMLError[];
+}
+interface XMLStepProperties extends Stats {
+    allow_failure: boolean;
+    is_skipped: boolean;
+    name: string;
+    substep_public_id?: string;
+    time: number;
+    type: string;
+    url?: string;
+}
+interface XMLStep {
+    $: XMLStepProperties;
+    browser_error?: {
+        $: {
+            name: string;
+            type: string;
+        };
+        _: string;
+    }[];
+    error: {
+        $: {
+            type: 'assertion';
+        };
+        _: string;
+    }[];
+    vitals?: {
+        $: Vitals;
+    }[];
+    warning?: {
+        $: {
+            type: string;
+        };
+        _: string;
+    }[];
+}
+interface XMLError {
+    $: {
+        type: string;
+        [key: string]: string;
+    };
+    _: string;
+}
+interface Args {
+    context: BaseContext;
+    jUnitReport?: string;
+    runName?: string;
+}
+export declare const getDefaultStats: () => Stats;
+export declare class JUnitReporter implements Reporter {
+    private builder;
+    private destination;
+    private json;
+    private write;
+    constructor({ context, jUnitReport, runName }: Args);
+    runEnd(): Promise<void>;
+    testEnd(test: InternalTest, results: PollResult[], baseUrl: string, locations: LocationsMapping, failOnCriticalErrors: boolean, failOnTimeout: boolean): void;
+    private getApiStepStats;
+    private getApiTestStep;
+    private getBrowserStepStats;
+    private getBrowserTestStep;
+    private getResultStats;
+    private getSuiteStats;
+    private getTestCase;
+}
+export {};

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

@@ -0,0 +1,74 @@
+import { APIHelper, MainReporter, PollResult, Summary, SyntheticsCIConfig, Test, Trigger } from './interfaces';
+export declare const executeTests: (reporter: MainReporter, config: SyntheticsCIConfig) => Promise<{
+    results: {
+        [key: string]: PollResult[];
+    };
+    summary: Summary;
+    tests: Test[];
+    triggers: Trigger;
+}>;
+export declare const getTestsList: (api: APIHelper, config: SyntheticsCIConfig, reporter: MainReporter) => Promise<{
+    config: {
+        allowInsecureCertificates?: boolean | undefined;
+        basicAuth?: import("./interfaces").BasicAuthCredentials | undefined;
+        body?: string | undefined;
+        bodyType?: string | undefined;
+        cookies?: string | {
+            append?: boolean | undefined;
+            value: string;
+        } | undefined;
+        defaultStepTimeout?: number | undefined;
+        deviceIds?: string[] | undefined;
+        executionRule?: import("./interfaces").ExecutionRule | undefined;
+        followRedirects?: boolean | undefined;
+        headers?: {
+            [key: string]: string;
+        } | undefined;
+        locations: string[];
+        pollingTimeout?: number | undefined;
+        retry?: import("./interfaces").RetryConfig | undefined;
+        startUrl?: string | undefined;
+        tunnel?: import("./tunnel").TunnelInfo | undefined;
+        variables?: {
+            [key: string]: string;
+        } | undefined;
+    } | {
+        allowInsecureCertificates?: boolean | undefined;
+        basicAuth?: import("./interfaces").BasicAuthCredentials | undefined;
+        body?: string | undefined;
+        bodyType?: string | undefined;
+        cookies?: string | {
+            append?: boolean | undefined;
+            value: string;
+        } | undefined;
+        defaultStepTimeout?: number | undefined;
+        deviceIds?: string[] | undefined;
+        executionRule?: import("./interfaces").ExecutionRule | undefined;
+        followRedirects?: boolean | undefined;
+        headers?: {
+            [key: string]: string;
+        } | undefined;
+        locations?: string[] | undefined;
+        pollingTimeout?: number | undefined;
+        retry?: import("./interfaces").RetryConfig | undefined;
+        startUrl?: string | undefined;
+        tunnel?: import("./tunnel").TunnelInfo | undefined;
+        variables?: {
+            [key: string]: string;
+        } | undefined;
+    };
+    id: string;
+    suite: string | undefined;
+}[]>;
+export declare const getApiHelper: (config: SyntheticsCIConfig) => {
+    getPresignedURL: (testIds: string[]) => Promise<{
+        url: string;
+    }>;
+    getTest: (testId: string) => Promise<Test>;
+    pollResults: (resultIds: string[]) => Promise<{
+        results: PollResult[];
+    }>;
+    searchTests: (query: string) => Promise<import("./interfaces").TestSearchResult>;
+    triggerTests: (data: import("./interfaces").Payload) => Promise<Trigger>;
+};
+export declare const getDatadogHost: (useIntake: boolean | undefined, config: SyntheticsCIConfig) => string;

package/dist/commands/synthetics/run-test.js

@@ -8,336 +8,152 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeUndefinedValues = exports.RunTestCommand = exports.DEFAULT_COMMAND_CONFIG = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const clipanion_1 = require("clipanion");
-const deep_extend_1 = __importDefault(require("deep-extend"));
-const utils_1 = require("../../helpers/utils");
+exports.getDatadogHost = exports.getApiHelper = exports.getTestsList = exports.executeTests = void 0;
 const api_1 = require("./api");
-const interfaces_1 = require("./interfaces");
-const default_1 = require("./reporters/default");
-const junit_1 = require("./reporters/junit");
+const errors_1 = require("./errors");
 const tunnel_1 = require("./tunnel");
-const utils_2 = require("./utils");
-exports.DEFAULT_COMMAND_CONFIG = {
-    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,
-};
-class RunTestCommand extends clipanion_1.Command {
-    constructor() {
-        super(...arguments);
-        this.config = JSON.parse(JSON.stringify(exports.DEFAULT_COMMAND_CONFIG)); // Deep copy to avoid mutation during unit tests
-    }
-    execute() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const reporters = [new default_1.DefaultReporter(this)];
-            if (this.jUnitReport) {
-                reporters.push(new junit_1.JUnitReporter(this));
-            }
-            this.reporter = utils_2.getReporter(reporters);
-            yield this.resolveConfig();
-            const startTime = Date.now();
-            const api = this.getApiHelper();
-            const publicIdsFromCli = this.config.publicIds.map((id) => ({ suite: 'CLI Suite', config: this.config.global, id }));
-            let testsToTrigger;
-            let tunnel;
-            const safeExit = (exitCode) => __awaiter(this, void 0, void 0, function* () {
-                if (tunnel) {
-                    yield tunnel.stop();
-                }
-                return exitCode;
-            });
-            if (publicIdsFromCli.length) {
-                testsToTrigger = publicIdsFromCli;
-            }
-            else {
-                try {
-                    testsToTrigger = yield this.getTestsList(api);
-                }
-                catch (error) {
-                    this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to obtain test configurations with search query ')}\n${error.message}\n\n`);
-                    if (api_1.is5xxError(error) && !this.config.failOnCriticalErrors) {
-                        return safeExit(0);
-                    }
-                    return safeExit(1);
-                }
-            }
-            if (!testsToTrigger.length) {
-                this.reporter.log('No test suites to run.\n');
-                return safeExit(0);
-            }
-            let testsToTriggerResult;
-            try {
-                testsToTriggerResult = yield utils_2.getTestsToTrigger(api, testsToTrigger, this.reporter);
-            }
-            catch (error) {
-                this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to obtain test configurations ')}\n${error.message}\n\n`);
-                if (api_1.is5xxError(error) && !this.config.failOnCriticalErrors) {
-                    return safeExit(0);
-                }
-                return safeExit(1);
-            }
-            const { tests, overriddenTestsToTrigger, summary } = testsToTriggerResult;
-            // All tests have been skipped or are missing.
-            if (!tests.length) {
-                this.reporter.log('No test to run.\n');
-                return safeExit(0);
-            }
-            const publicIdsToTrigger = tests.map(({ public_id }) => public_id);
-            if (this.config.tunnel) {
-                this.reporter.log('You are using tunnel option, the chosen location(s) will be overridden by a location in your account region.\n');
-                let presignedURL;
-                try {
-                    // Get the pre-signed URL to connect to the tunnel service
-                    presignedURL = (yield api.getPresignedURL(publicIdsToTrigger)).url;
-                }
-                catch (e) {
-                    this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to get tunnel configuration')}\n${e.message}\n\n`);
-                    if (api_1.is5xxError(e) && !this.config.failOnCriticalErrors) {
-                        return safeExit(0);
-                    }
-                    return safeExit(1);
-                }
-                // Open a tunnel to Datadog
-                try {
-                    tunnel = new tunnel_1.Tunnel(presignedURL, publicIdsToTrigger, this.config.proxy, this.reporter);
-                    const tunnelInfo = yield tunnel.start();
-                    overriddenTestsToTrigger.forEach((testToTrigger) => {
-                        testToTrigger.tunnel = tunnelInfo;
-                    });
-                }
-                catch (e) {
-                    this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to start tunnel ')}\n${e.message}\n\n`);
-                    if (api_1.is5xxError(e) && !this.config.failOnCriticalErrors) {
-                        return safeExit(0);
-                    }
-                    return safeExit(1);
-                }
-            }
-            let triggers;
-            try {
-                triggers = yield utils_2.runTests(api, overriddenTestsToTrigger);
-            }
-            catch (e) {
-                this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to trigger tests ')}\n${e.message}\n\n`);
-                if (api_1.is5xxError(e) && !this.config.failOnCriticalErrors) {
-                    return safeExit(0);
-                }
-                return safeExit(1);
-            }
-            if (!triggers.results) {
-                throw new Error('No result to poll.');
-            }
-            const results = {};
-            try {
-                // Poll the results.
-                const resultPolled = yield utils_2.waitForResults(api, triggers.results, this.config.pollingTimeout, testsToTrigger, tunnel, this.config.failOnCriticalErrors);
-                Object.assign(results, resultPolled);
-            }
-            catch (error) {
-                this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to poll test results ')}\n${error.message}\n\n`);
-                if (api_1.is5xxError(error) && !this.config.failOnCriticalErrors) {
-                    return safeExit(0);
-                }
-                return safeExit(1);
-            }
-            // Sort tests to show success first then non blocking failures and finally blocking failures.
-            tests.sort(this.sortTestsByOutcome(results));
-            // Rendering the results.
-            this.reporter.reportStart({ startTime });
-            const locationNames = triggers.locations.reduce((mapping, location) => {
-                mapping[location.id] = location.display_name;
-                return mapping;
-            }, {});
-            let hasSucceeded = true; // Determine if all the tests have succeeded
-            for (const test of tests) {
-                const testResults = results[test.public_id];
-                if (!this.config.failOnTimeout) {
-                    if (!summary.timedOut) {
-                        summary.timedOut = 0;
-                    }
-                    const hasTimeout = testResults.some((pollResult) => pollResult.result.error === interfaces_1.ERRORS.TIMEOUT);
-                    if (hasTimeout) {
-                        summary.timedOut++;
-                    }
-                }
-                if (!this.config.failOnCriticalErrors) {
-                    if (!summary.criticalErrors) {
-                        summary.criticalErrors = 0;
-                    }
-                    const hasCriticalErrors = testResults.some((pollResult) => utils_2.isCriticalError(pollResult.result));
-                    if (hasCriticalErrors) {
-                        summary.criticalErrors++;
-                    }
-                }
-                const passed = utils_2.hasTestSucceeded(testResults, this.config.failOnCriticalErrors, this.config.failOnTimeout);
-                if (passed) {
-                    summary.passed++;
-                }
-                else {
-                    summary.failed++;
-                    if (((_a = test.options.ci) === null || _a === void 0 ? void 0 : _a.executionRule) !== interfaces_1.ExecutionRule.NON_BLOCKING) {
-                        hasSucceeded = false;
-                    }
-                }
-                this.reporter.testEnd(test, testResults, this.getAppBaseURL(), locationNames, this.config.failOnCriticalErrors, this.config.failOnTimeout);
-            }
-            this.reporter.runEnd(summary);
-            return safeExit(hasSucceeded ? 0 : 1);
-        });
+const utils_1 = require("./utils");
+const executeTests = (reporter, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const api = exports.getApiHelper(config);
+    const publicIdsFromCli = config.publicIds.map((id) => ({ config: config.global, id }));
+    let testsToTrigger;
+    let tunnel;
+    const stopTunnel = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (tunnel) {
+            yield tunnel.stop();
+        }
+    });
+    if (publicIdsFromCli.length) {
+        testsToTrigger = publicIdsFromCli;
     }
-    getApiHelper() {
-        if (!this.config.appKey || !this.config.apiKey) {
-            if (!this.config.appKey) {
-                this.reporter.error(`Missing ${chalk_1.default.red.bold('DATADOG_APP_KEY')} in your environment.\n`);
-            }
-            if (!this.config.apiKey) {
-                this.reporter.error(`Missing ${chalk_1.default.red.bold('DATADOG_API_KEY')} in your environment.\n`);
-            }
-            throw new Error('API and/or Application keys are missing');
+    else {
+        try {
+            testsToTrigger = yield exports.getTestsList(api, config, reporter);
         }
-        return api_1.apiConstructor({
-            apiKey: this.config.apiKey,
-            appKey: this.config.appKey,
-            baseIntakeUrl: this.getDatadogHost(true),
-            baseUrl: this.getDatadogHost(),
-            proxyOpts: this.config.proxy,
-        });
+        catch (error) {
+            const isCriticalError = api_1.is5xxError(error);
+            throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('UNAVAILABLE_TEST_CONFIG');
+        }
+    }
+    if (!testsToTrigger.length) {
+        throw new errors_1.CiError('NO_TESTS_TO_RUN');
+    }
+    let testsToTriggerResult;
+    try {
+        testsToTriggerResult = yield utils_1.getTestsToTrigger(api, testsToTrigger, reporter);
     }
-    getAppBaseURL() {
-        return `https://${this.config.subdomain}.${this.config.datadogSite}/`;
+    catch (error) {
+        const isCriticalError = api_1.is5xxError(error);
+        throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('UNAVAILABLE_TEST_CONFIG');
     }
-    getDatadogHost(useIntake = false) {
-        const apiPath = 'api/v1';
-        let host = `https://api.${this.config.datadogSite}`;
-        const hostOverride = process.env.DD_API_HOST_OVERRIDE;
-        if (hostOverride) {
-            host = hostOverride;
+    const { tests, overriddenTestsToTrigger, summary } = testsToTriggerResult;
+    // All tests have been skipped or are missing.
+    if (!tests.length) {
+        throw new errors_1.CiError('NO_TESTS_TO_RUN');
+    }
+    const publicIdsToTrigger = tests.map(({ public_id }) => public_id);
+    if (config.tunnel) {
+        let presignedURL;
+        try {
+            // Get the pre-signed URL to connect to the tunnel service
+            presignedURL = (yield api.getPresignedURL(publicIdsToTrigger)).url;
+        }
+        catch (error) {
+            const isCriticalError = api_1.is5xxError(error);
+            throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('UNAVAILABLE_TUNNEL_CONFIG');
         }
-        else if (useIntake &&
-            (this.config.datadogSite === 'datadoghq.com' || this.config.datadogSite === 'datad0g.com')) {
-            host = `https://intake.synthetics.${this.config.datadogSite}`;
+        // Open a tunnel to Datadog
+        try {
+            tunnel = new tunnel_1.Tunnel(presignedURL, publicIdsToTrigger, config.proxy, reporter);
+            const tunnelInfo = yield tunnel.start();
+            overriddenTestsToTrigger.forEach((testToTrigger) => {
+                testToTrigger.tunnel = tunnelInfo;
+            });
+        }
+        catch (error) {
+            const isCriticalError = api_1.is5xxError(error);
+            yield stopTunnel();
+            throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('TUNNEL_START_FAILED');
         }
-        return `${host}/${apiPath}`;
     }
-    getTestsList(api) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.config.testSearchQuery) {
-                const testSearchResults = yield api.searchTests(this.config.testSearchQuery);
-                return testSearchResults.tests.map((test) => ({
-                    config: this.config.global,
-                    id: test.public_id,
-                    suite: `Query: ${this.testSearchQuery}`,
-                }));
-            }
-            const suites = (yield Promise.all(this.config.files.map((glob) => utils_2.getSuites(glob, this.reporter))))
-                .reduce((acc, val) => acc.concat(val), [])
-                .filter((suite) => !!suite.content.tests);
-            const configFromEnvironment = ((_a = this.config.locations) === null || _a === void 0 ? void 0 : _a.length) ? { locations: this.config.locations } : {};
-            const testsToTrigger = suites
-                .map((suite) => suite.content.tests.map((test) => ({
-                config: Object.assign(Object.assign(Object.assign({}, this.config.global), configFromEnvironment), test.config),
-                id: test.id,
-                suite: suite.name,
-            })))
-                .reduce((acc, suiteTests) => acc.concat(suiteTests), []);
-            return testsToTrigger;
-        });
+    let triggers;
+    try {
+        triggers = yield utils_1.runTests(api, overriddenTestsToTrigger);
+    }
+    catch (error) {
+        const isCriticalError = api_1.is5xxError(error);
+        yield stopTunnel();
+        throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('TRIGGER_TESTS_FAILED');
+    }
+    if (!triggers.results) {
+        yield stopTunnel();
+        throw new errors_1.CriticalError('NO_RESULTS_TO_POLL');
+    }
+    const results = {};
+    try {
+        // Poll the results.
+        const resultPolled = yield utils_1.waitForResults(api, triggers.results, config.pollingTimeout, testsToTrigger, tunnel, config.failOnCriticalErrors);
+        Object.assign(results, resultPolled);
+    }
+    catch (error) {
+        const isCriticalError = api_1.is5xxError(error);
+        yield stopTunnel();
+        throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('POLL_RESULTS_FAILED');
     }
-    resolveConfig() {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            // Default < file < ENV < CLI
-            // Override with file config variables
-            try {
-                this.config = yield utils_1.parseConfigFile(this.config, (_a = this.configPath) !== null && _a !== void 0 ? _a : this.config.configPath);
-            }
-            catch (error) {
-                if (this.configPath) {
-                    throw error;
-                }
-            }
-            // Override with ENV variables
-            this.config = deep_extend_1.default(this.config, exports.removeUndefinedValues({
-                apiKey: process.env.DATADOG_API_KEY,
-                appKey: process.env.DATADOG_APP_KEY,
-                datadogSite: process.env.DATADOG_SITE,
-                locations: (_b = process.env.DATADOG_SYNTHETICS_LOCATIONS) === null || _b === void 0 ? void 0 : _b.split(';'),
-                subdomain: process.env.DATADOG_SUBDOMAIN,
-            }));
-            // Override with CLI parameters
-            this.config = deep_extend_1.default(this.config, exports.removeUndefinedValues({
-                apiKey: this.apiKey,
-                appKey: this.appKey,
-                configPath: this.configPath,
-                datadogSite: this.datadogSite,
-                failOnCriticalErrors: this.failOnCriticalErrors,
-                failOnTimeout: this.failOnTimeout,
-                files: this.files,
-                publicIds: this.publicIds,
-                subdomain: this.subdomain,
-                testSearchQuery: this.testSearchQuery,
-                tunnel: this.tunnel,
-            }));
-            if (typeof this.config.files === 'string') {
-                this.reporter.log('[DEPRECATED] "files" should be an array of string instead of a string.\n');
-                this.config.files = [this.config.files];
-            }
-        });
+    return { results, summary, tests, triggers };
+});
+exports.executeTests = executeTests;
+const getTestsList = (api, config, reporter) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (config.testSearchQuery) {
+        const testSearchResults = yield api.searchTests(config.testSearchQuery);
+        return testSearchResults.tests.map((test) => ({
+            config: config.global,
+            id: test.public_id,
+            suite: `Query: ${config.testSearchQuery}`,
+        }));
+    }
+    const suites = (yield Promise.all(config.files.map((glob) => utils_1.getSuites(glob, reporter))))
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter((suite) => !!suite.content.tests);
+    const configFromEnvironment = ((_a = config.locations) === null || _a === void 0 ? void 0 : _a.length) ? { locations: config.locations } : {};
+    const testsToTrigger = suites
+        .map((suite) => suite.content.tests.map((test) => ({
+        config: Object.assign(Object.assign(Object.assign({}, config.global), configFromEnvironment), test.config),
+        id: test.id,
+        suite: suite.name,
+    })))
+        .reduce((acc, suiteTests) => acc.concat(suiteTests), []);
+    return testsToTrigger;
+});
+exports.getTestsList = getTestsList;
+const getApiHelper = (config) => {
+    if (!config.appKey) {
+        throw new errors_1.CiError('MISSING_APP_KEY');
+    }
+    if (!config.apiKey) {
+        throw new errors_1.CiError('MISSING_API_KEY');
+    }
+    return api_1.apiConstructor({
+        apiKey: config.apiKey,
+        appKey: config.appKey,
+        baseIntakeUrl: exports.getDatadogHost(true, config),
+        baseUrl: exports.getDatadogHost(false, config),
+        proxyOpts: config.proxy,
+    });
+};
+exports.getApiHelper = getApiHelper;
+const getDatadogHost = (useIntake = false, config) => {
+    const apiPath = 'api/v1';
+    let host = `https://api.${config.datadogSite}`;
+    const hostOverride = process.env.DD_API_HOST_OVERRIDE;
+    if (hostOverride) {
+        host = hostOverride;
     }
-    sortTestsByOutcome(results) {
-        return (t1, t2) => {
-            var _a, _b;
-            const success1 = utils_2.hasTestSucceeded(results[t1.public_id], this.config.failOnCriticalErrors, this.config.failOnTimeout);
-            const success2 = utils_2.hasTestSucceeded(results[t2.public_id], this.config.failOnCriticalErrors, this.config.failOnTimeout);
-            const isNonBlockingTest1 = ((_a = t1.options.ci) === null || _a === void 0 ? void 0 : _a.executionRule) === interfaces_1.ExecutionRule.NON_BLOCKING;
-            const isNonBlockingTest2 = ((_b = t2.options.ci) === null || _b === void 0 ? void 0 : _b.executionRule) === interfaces_1.ExecutionRule.NON_BLOCKING;
-            if (success1 === success2) {
-                if (isNonBlockingTest1 === isNonBlockingTest2) {
-                    return 0;
-                }
-                return isNonBlockingTest1 ? -1 : 1;
-            }
-            return success1 ? -1 : 1;
-        };
+    else if (useIntake && (config.datadogSite === 'datadoghq.com' || config.datadogSite === 'datad0g.com')) {
+        host = `https://intake.synthetics.${config.datadogSite}`;
     }
-}
-exports.RunTestCommand = RunTestCommand;
-const removeUndefinedValues = (object) => {
-    const newObject = Object.assign({}, object);
-    Object.keys(newObject).forEach((k) => newObject[k] === undefined && delete newObject[k]);
-    return newObject;
+    return `${host}/${apiPath}`;
 };
-exports.removeUndefinedValues = removeUndefinedValues;
-RunTestCommand.addPath('synthetics', 'run-tests');
-RunTestCommand.addOption('apiKey', clipanion_1.Command.String('--apiKey'));
-RunTestCommand.addOption('appKey', clipanion_1.Command.String('--appKey'));
-RunTestCommand.addOption('failOnCriticalErrors', clipanion_1.Command.Boolean('--failOnCriticalErrors'));
-RunTestCommand.addOption('configPath', clipanion_1.Command.String('--config'));
-RunTestCommand.addOption('datadogSite', clipanion_1.Command.String('--datadogSite'));
-RunTestCommand.addOption('files', clipanion_1.Command.Array('-f,--files'));
-RunTestCommand.addOption('failOnTimeout', clipanion_1.Command.Boolean('--failOnTimeout'));
-RunTestCommand.addOption('publicIds', clipanion_1.Command.Array('-p,--public-id'));
-RunTestCommand.addOption('testSearchQuery', clipanion_1.Command.String('-s,--search'));
-RunTestCommand.addOption('subdomain', clipanion_1.Command.Boolean('--subdomain'));
-RunTestCommand.addOption('tunnel', clipanion_1.Command.Boolean('-t,--tunnel'));
-RunTestCommand.addOption('jUnitReport', clipanion_1.Command.String('-j,--jUnitReport'));
-RunTestCommand.addOption('runName', clipanion_1.Command.String('-n,--runName'));
+exports.getDatadogHost = getDatadogHost;