@testream/dotnet-reporter 0.5.3 → 0.5.5

package/README.md

@@ -2,8 +2,6 @@
 
 Run .NET tests and send the results from your codebase to Jira via Testream.
 
-- **Docs:** https://testream.github.io/docs/reporters/dotnet
-
 ## Quick Start
 
 ```bash

package/dist/index.js

@@ -2275,7 +2275,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.uploadArtifacts = exports.uploadTestRun = exports.detectCIContext = void 0;
+exports.ensureReportId = exports.mapAttachmentsToTestResults = exports.uploadArtifacts = exports.uploadTestRun = exports.detectCIContext = void 0;
 // CTRF types
 __exportStar(__nccwpck_require__(827), exports);
 var ci_detection_1 = __nccwpck_require__(406);
@@ -2283,6 +2283,8 @@ Object.defineProperty(exports, "detectCIContext", ({ enumerable: true, get: func
 var upload_1 = __nccwpck_require__(969);
 Object.defineProperty(exports, "uploadTestRun", ({ enumerable: true, get: function () { return upload_1.uploadTestRun; } }));
 Object.defineProperty(exports, "uploadArtifacts", ({ enumerable: true, get: function () { return upload_1.uploadArtifacts; } }));
+Object.defineProperty(exports, "mapAttachmentsToTestResults", ({ enumerable: true, get: function () { return upload_1.mapAttachmentsToTestResults; } }));
+Object.defineProperty(exports, "ensureReportId", ({ enumerable: true, get: function () { return upload_1.ensureReportId; } }));
 //# sourceMappingURL=index.js.map
 
 /***/ }),
@@ -2293,22 +2295,57 @@ Object.defineProperty(exports, "uploadArtifacts", ({ enumerable: true, get: func
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ensureReportId = ensureReportId;
 exports.uploadTestRun = uploadTestRun;
+exports.mapAttachmentsToTestResults = mapAttachmentsToTestResults;
 exports.uploadArtifacts = uploadArtifacts;
 const DEFAULT_API_URL = 'https://test-manager-backend.fly.dev';
+function ensureReportId(report) {
+    if (typeof report.reportId === 'string' && report.reportId.trim().length > 0) {
+        return report.reportId;
+    }
+    const reportId = crypto.randomUUID();
+    report.reportId = reportId;
+    return reportId;
+}
+function resolveApiUrl(explicitApiUrl) {
+    const fromExplicit = normalizeApiUrl(explicitApiUrl);
+    if (fromExplicit) {
+        return fromExplicit;
+    }
+    const fromEnv = getEnvApiUrl();
+    if (fromEnv) {
+        return fromEnv;
+    }
+    return DEFAULT_API_URL;
+}
+function getEnvApiUrl() {
+    if (typeof process === 'undefined' || !process?.env) {
+        return undefined;
+    }
+    return normalizeApiUrl(process.env.TESTREAM_API_URL);
+}
+function normalizeApiUrl(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.replace(/\/+$/, '');
+}
 /**
  * Upload test run to Testream backend API
  */
 async function uploadTestRun(options) {
-    const { report, apiKey, apiUrl = DEFAULT_API_URL } = options;
-    // Ensure reportId exists
-    if (!report.reportId) {
-        report.reportId = crypto.randomUUID();
-    }
+    const { report, apiKey } = options;
+    const apiUrl = resolveApiUrl(options.apiUrl);
+    const reportId = ensureReportId(report);
     // Build type-safe IngestRequest payload
     const ingestPayload = {
         report,
-        reportId: report.reportId,
+        reportId,
         commitSha: options.commitSha,
         branch: options.branch,
         repositoryUrl: options.repositoryUrl,
@@ -2337,7 +2374,7 @@ async function uploadTestRun(options) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         return {
             success: false,
-            reportId: report.reportId,
+            reportId,
             error: `Connection failed: ${errorMessage}`,
         };
     }
@@ -2346,7 +2383,7 @@ async function uploadTestRun(options) {
         console.warn('Report already exists (workflow may have been re-run)');
         return {
             success: true,
-            reportId: report.reportId,
+            reportId,
             summary: {
                 passed: report.results.summary.passed,
                 failed: report.results.summary.failed,
@@ -2361,7 +2398,7 @@ async function uploadTestRun(options) {
         const errorText = await response.text();
         return {
             success: false,
-            reportId: report.reportId,
+            reportId,
             error: `Upload failed (HTTP ${response.status}): ${errorText}`,
         };
     }
@@ -2384,11 +2421,41 @@ async function uploadTestRun(options) {
         testResults: result.testResults,
     };
 }
+/**
+ * Maps CTRF tests to ingested test result IDs in a stable order.
+ * This avoids incorrect artifact linking when multiple tests share the same name.
+ */
+function mapAttachmentsToTestResults(tests, ingestedTestResults) {
+    const idsByName = new Map();
+    for (const result of ingestedTestResults) {
+        const queue = idsByName.get(result.name) ?? [];
+        queue.push(result.id);
+        idsByName.set(result.name, queue);
+    }
+    const targets = [];
+    for (const test of tests) {
+        const queue = idsByName.get(test.name);
+        const matchedTestResultId = queue?.shift();
+        if (!test.attachments || test.attachments.length === 0) {
+            continue;
+        }
+        if (!matchedTestResultId) {
+            console.warn(`Skipping artifact upload: could not match test result for "${test.name}"`);
+            continue;
+        }
+        targets.push({
+            testResultId: matchedTestResultId,
+            attachments: test.attachments,
+        });
+    }
+    return targets;
+}
 /**
  * Upload test artifacts (screenshots, videos, etc.) to Testream backend API
  */
 async function uploadArtifacts(options) {
-    const { reportId, apiKey, testResults, apiUrl = DEFAULT_API_URL } = options;
+    const { reportId, apiKey, testResults } = options;
+    const apiUrl = resolveApiUrl(options.apiUrl);
     let uploadedCount = 0;
     for (const testResult of testResults) {
         for (const attachment of testResult.attachments) {
@@ -2430,35 +2497,138 @@ async function uploadSingleArtifact(options) {
     }
     // Read file
     let fileBuffer;
+    let sizeBytes;
+    const fileName = path.basename(filePath);
+    const contentType = attachment.contentType || 'application/octet-stream';
     try {
         fileBuffer = await fs.readFile(filePath);
+        sizeBytes = fileBuffer.byteLength;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to read file: ${errorMessage}`);
     }
-    // Create native FormData with Blob
-    const blob = new Blob([new Uint8Array(fileBuffer)], { type: attachment.contentType });
+    try {
+        return await uploadWithPresignedUrl({
+            testResultId,
+            reportId,
+            apiKey,
+            apiUrl,
+            attachmentName: attachment.name,
+            fileName,
+            contentType,
+            sizeBytes,
+            fileBuffer,
+        });
+    }
+    catch (error) {
+        if (!(error instanceof LegacyUploadRequiredError)) {
+            throw error;
+        }
+        return await uploadWithLegacyEndpoint({
+            testResultId,
+            attachmentName: attachment.name,
+            reportId,
+            apiKey,
+            apiUrl,
+            fileName,
+            contentType,
+            fileBuffer,
+        });
+    }
+}
+class LegacyUploadRequiredError extends Error {
+    constructor() {
+        super('Legacy upload endpoint required');
+    }
+}
+async function uploadWithPresignedUrl(options) {
+    const { testResultId, reportId, apiKey, apiUrl, attachmentName, fileName, contentType, sizeBytes, fileBuffer, } = options;
+    const initPayload = {
+        testResultId,
+        ctrfAttachmentName: attachmentName,
+        fileName,
+        contentType,
+        sizeBytes,
+    };
+    const initResponse = await fetch(`${apiUrl}/api/v1/artifacts/${reportId}/upload-url`, {
+        method: 'POST',
+        headers: {
+            'X-API-KEY': apiKey,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(initPayload),
+    });
+    if (shouldFallbackToLegacyUpload(initResponse.status)) {
+        throw new LegacyUploadRequiredError();
+    }
+    if (!initResponse.ok) {
+        const errorText = await initResponse.text();
+        throw new Error(`Failed to create direct upload URL (HTTP ${initResponse.status}): ${errorText}`);
+    }
+    const uploadInitResult = (await initResponse.json());
+    const uploadHeaders = { ...(uploadInitResult.requiredHeaders ?? {}) };
+    if (!hasHeaderIgnoreCase(uploadHeaders, 'Content-Type')) {
+        uploadHeaders['Content-Type'] = contentType;
+    }
+    const directUploadResponse = await fetch(uploadInitResult.uploadUrl, {
+        method: 'PUT',
+        headers: uploadHeaders,
+        body: fileBuffer,
+    });
+    if (!directUploadResponse.ok) {
+        const errorText = await directUploadResponse.text();
+        throw new Error(`Direct artifact upload failed (HTTP ${directUploadResponse.status}): ${errorText}`);
+    }
+    const completePayload = {
+        testResultId,
+        ctrfAttachmentName: attachmentName,
+        fileName,
+        contentType,
+        sizeBytes,
+        storageKey: uploadInitResult.storageKey,
+    };
+    const completeResponse = await fetch(`${apiUrl}/api/v1/artifacts/${reportId}/complete`, {
+        method: 'POST',
+        headers: {
+            'X-API-KEY': apiKey,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(completePayload),
+    });
+    if (!completeResponse.ok) {
+        const errorText = await completeResponse.text();
+        throw new Error(`Failed to finalize artifact upload (HTTP ${completeResponse.status}): ${errorText}`);
+    }
+    return true;
+}
+async function uploadWithLegacyEndpoint(options) {
+    const { testResultId, attachmentName, reportId, apiKey, apiUrl, fileName, contentType, fileBuffer } = options;
+    const blob = new Blob([new Uint8Array(fileBuffer)], { type: contentType });
     const formData = new FormData();
     formData.append('testResultId', testResultId);
-    formData.append('ctrfAttachmentName', attachment.name);
-    formData.append('file', blob, path.basename(filePath));
-    // Upload to API
-    const uploadUrl = `${apiUrl}/api/v1/artifacts/${reportId}`;
-    const response = await fetch(uploadUrl, {
+    formData.append('ctrfAttachmentName', attachmentName);
+    formData.append('file', blob, fileName);
+    const response = await fetch(`${apiUrl}/api/v1/artifacts/${reportId}`, {
         method: 'POST',
         headers: {
             'X-API-KEY': apiKey,
-            // Don't set Content-Type - fetch sets it with boundary
         },
         body: formData,
     });
     if (!response.ok) {
         const errorText = await response.text();
-        throw new Error(`HTTP ${response.status}: ${errorText}`);
+        throw new Error(`Legacy artifact upload failed (HTTP ${response.status}): ${errorText}`);
     }
     return true;
 }
+function shouldFallbackToLegacyUpload(statusCode) {
+    return statusCode === 404 || statusCode === 405 || statusCode === 501;
+}
+function hasHeaderIgnoreCase(headers, headerName) {
+    const expected = headerName.toLowerCase();
+    return Object.keys(headers).some((key) => key.toLowerCase() === expected);
+}
 //# sourceMappingURL=upload.js.map
 
 /***/ }),
@@ -3157,6 +3327,7 @@ async function uploadToApi(options) {
     return (0, shared_types_1.uploadTestRun)({
         report: options.report,
         apiKey: options.apiKey,
+        apiUrl: options.apiUrl,
         commitSha: options.commitSha,
         branch: options.branch,
         repositoryUrl: options.repositoryUrl,