@datadog/datadog-ci 0.17.4 → 0.17.7

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/reporters/junit.js

@@ -64,7 +64,7 @@ class JUnitReporter {
             }
         });
     }
-    testEnd(test, results, baseUrl, locations) {
+    testEnd(test, results, baseUrl, locations, failOnCriticalErrors, failOnTimeout) {
         const suiteRunName = test.suite || 'Undefined suite';
         let suiteRun = this.json.testsuites.testsuite.find((suite) => suite.$.name === suiteRunName);
         if (!suiteRun) {
@@ -77,7 +77,7 @@ class JUnitReporter {
         // Update stats for the suite.
         suiteRun.$ = Object.assign(Object.assign({}, suiteRun.$), this.getSuiteStats(results, getStats(suiteRun.$)));
         for (const result of results) {
-            const testCase = this.getTestCase(test, result, locations);
+            const testCase = this.getTestCase(test, result, locations, failOnCriticalErrors, failOnTimeout);
             // Timeout errors are only reported at the top level.
             if (result.result.error === interfaces_1.ERRORS.TIMEOUT) {
                 testCase.error.push({
@@ -88,7 +88,8 @@ class JUnitReporter {
             if ('stepDetails' in result.result) {
                 // It's a browser test.
                 for (const stepDetail of result.result.stepDetails) {
-                    const { browser_error, error, warning } = this.getBrowserTestStep(stepDetail);
+                    const { allowed_error, browser_error, error, warning } = this.getBrowserTestStep(stepDetail);
+                    testCase.allowed_error.push(...allowed_error);
                     testCase.browser_error.push(...browser_error);
                     testCase.error.push(...error);
                     testCase.warning.push(...warning);
@@ -97,7 +98,8 @@ class JUnitReporter {
             else if ('steps' in result.result) {
                 // It's a multistep test.
                 for (const step of result.result.steps) {
-                    const { error } = this.getApiTestStep(step);
+                    const { allowed_error, error } = this.getApiTestStep(step);
+                    testCase.allowed_error.push(...allowed_error);
                     testCase.error.push(...error);
                 }
             }
@@ -124,11 +126,22 @@ class JUnitReporter {
         };
     }
     getApiTestStep(step) {
+        const allowedError = [];
         const error = [];
         if (step.failure) {
-            error.push({ $: { type: step.failure.code, step: step.name }, _: step.failure.message });
+            const xmlError = {
+                $: { type: step.failure.code, step: step.name, allowFailure: `${step.allowFailure}` },
+                _: step.failure.message,
+            };
+            if (step.allowFailure) {
+                allowedError.push(xmlError);
+            }
+            else {
+                error.push(xmlError);
+            }
         }
         return {
+            allowed_error: allowedError,
             error,
         };
     }
@@ -145,6 +158,7 @@ class JUnitReporter {
     }
     getBrowserTestStep(stepDetail) {
         var _a, _b;
+        const allowedError = [];
         const browserError = [];
         const error = [];
         const warning = [];
@@ -155,10 +169,16 @@ class JUnitReporter {
             })));
         }
         if (stepDetail.error) {
-            error.push({
-                $: { type: 'assertion', step: stepDetail.description },
+            const xmlError = {
+                $: { type: 'assertion', step: stepDetail.description, allowFailure: `${stepDetail.allowFailure}` },
                 _: stepDetail.error,
-            });
+            };
+            if (stepDetail.allowFailure) {
+                allowedError.push(xmlError);
+            }
+            else {
+                error.push(xmlError);
+            }
         }
         if ((_b = stepDetail.warnings) === null || _b === void 0 ? void 0 : _b.length) {
             warning.push(...stepDetail.warnings.map((w) => ({
@@ -167,6 +187,7 @@ class JUnitReporter {
             })));
         }
         return {
+            allowed_error: allowedError,
             browser_error: browserError,
             error,
             warning,
@@ -209,25 +230,18 @@ class JUnitReporter {
         }
         return stats;
     }
-    getTestCase(test, result, locations) {
+    getTestCase(test, result, locations, failOnCriticalErrors, failOnTimeout) {
         var _a;
+        const timeout = result.result.error === interfaces_1.ERRORS.TIMEOUT;
+        const passed = utils_1.hasTestSucceeded([result], failOnCriticalErrors, failOnTimeout);
         return {
             $: Object.assign({ name: test.name, time: utils_1.getResultDuration(result.result) / 1000, timestamp: new Date(result.timestamp).toISOString() }, this.getResultStats(result)),
+            allowed_error: [],
             browser_error: [],
             error: [],
             properties: {
                 property: [
-                    { $: { name: 'status', value: test.status } },
-                    { $: { name: 'public_id', value: test.public_id } },
                     { $: { name: 'check_id', value: result.check_id } },
-                    { $: { name: 'result_id', value: result.resultID } },
-                    { $: { name: 'type', value: test.type } },
-                    { $: { name: 'message', value: test.message } },
-                    { $: { name: 'monitor_id', value: test.monitor_id } },
-                    { $: { name: 'tags', value: test.tags.join(',') } },
-                    { $: { name: 'location', value: locations[result.dc_id] } },
-                    { $: { name: 'execution_rule', value: (_a = test.options.ci) === null || _a === void 0 ? void 0 : _a.executionRule } },
-                    ...('startUrl' in result.result ? [{ $: { name: 'start_url', value: result.result.startUrl } }] : []),
                     ...('device' in result.result
                         ? [
                             { $: { name: 'device', value: result.result.device.id } },
@@ -235,6 +249,18 @@ class JUnitReporter {
                             { $: { name: 'height', value: result.result.device.height } },
                         ]
                         : []),
+                    { $: { name: 'execution_rule', value: (_a = test.options.ci) === null || _a === void 0 ? void 0 : _a.executionRule } },
+                    { $: { name: 'location', value: locations[result.dc_id] } },
+                    { $: { name: 'message', value: test.message } },
+                    { $: { name: 'monitor_id', value: test.monitor_id } },
+                    { $: { name: 'passed', value: `${passed}` } },
+                    { $: { name: 'public_id', value: test.public_id } },
+                    { $: { name: 'result_id', value: result.resultID } },
+                    ...('startUrl' in result.result ? [{ $: { name: 'start_url', value: result.result.startUrl } }] : []),
+                    { $: { name: 'status', value: test.status } },
+                    { $: { name: 'tags', value: test.tags.join(',') } },
+                    { $: { name: 'timeout', value: `${timeout}` } },
+                    { $: { name: 'type', value: test.type } },
                 ].filter((prop) => prop.$.value),
             },
             testcase: [],

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;