qase-report 1.0.0

package/dist/cli/generators/html-generator.js

@@ -0,0 +1,117 @@
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+// Strip UTF-8 BOM that some tools (e.g. .NET reporters) prepend to JSON files
+const stripBom = (s) => s.replace(/^\uFEFF/, '');
+/**
+ * Escape JSON string for safe embedding in HTML.
+ * Prevents XSS by replacing characters that could break out of script context.
+ *
+ * @param json - JSON string to escape
+ * @returns XSS-safe JSON string
+ */
+export function escapeJsonForHtml(json) {
+    return json
+        .replace(/</g, '\\u003c') // Prevent tag injection
+        .replace(/>/g, '\\u003e') // Consistency
+        .replace(/\//g, '\\/'); // Prevent </script> breaking
+}
+/**
+ * Inject data into HTML as window global variable.
+ *
+ * @param html - HTML template string
+ * @param dataKey - Global variable name (e.g., "__QASE_RUN_DATA__")
+ * @param data - Data to embed
+ * @returns Modified HTML with injected data
+ */
+export function injectData(html, dataKey, data) {
+    const json = JSON.stringify(data);
+    const escaped = escapeJsonForHtml(json);
+    const script = `<script>window.${dataKey}=${escaped};</script>`;
+    // Inject before closing </head> tag
+    return html.replace('</head>', `${script}\n</head>`);
+}
+/**
+ * Load report data from filesystem.
+ *
+ * @param reportPath - Path to report directory
+ * @returns Report data with run and results
+ * @throws If run.json is missing or invalid
+ */
+export function loadReportData(reportPath) {
+    const runJsonPath = join(reportPath, 'run.json');
+    // Read run.json
+    if (!existsSync(runJsonPath)) {
+        throw new Error(`run.json not found at ${runJsonPath}`);
+    }
+    const run = JSON.parse(stripBom(readFileSync(runJsonPath, 'utf-8')));
+    // Read all *.json files from results/ directory
+    const resultsDir = join(reportPath, 'results');
+    const results = [];
+    if (existsSync(resultsDir)) {
+        const resultFiles = readdirSync(resultsDir).filter((file) => file.endsWith('.json'));
+        for (const file of resultFiles) {
+            const resultPath = join(resultsDir, file);
+            const resultData = JSON.parse(stripBom(readFileSync(resultPath, 'utf-8')));
+            results.push(resultData);
+        }
+    }
+    return { run, results };
+}
+/**
+ * Load history data from filesystem.
+ * Returns null if file doesn't exist (graceful handling).
+ *
+ * @param reportPath - Path to report directory
+ * @param historyPath - Optional custom history file path
+ * @returns History data or null if not available
+ */
+export function loadHistoryData(reportPath, historyPath) {
+    // Default path: reportPath/qase-report-history.json
+    const path = historyPath || join(reportPath, 'qase-report-history.json');
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse(stripBom(readFileSync(path, 'utf-8')));
+    }
+    catch (error) {
+        console.warn(`Warning: Failed to load history from ${path}:`, error instanceof Error ? error.message : error);
+        return null;
+    }
+}
+/**
+ * Generate self-contained HTML report with embedded data.
+ *
+ * @param options - Generation options
+ * @returns HTML string with embedded report data
+ * @throws If template or report data cannot be loaded
+ */
+export function generateHtmlReport(options) {
+    const { reportPath, historyPath, templatePath } = options;
+    // Resolve report path
+    const resolvedReportPath = resolve(reportPath);
+    // Default template path: ../../../dist/index.html relative to this file
+    const defaultTemplatePath = fileURLToPath(new URL('../../../dist/index.html', import.meta.url));
+    const resolvedTemplatePath = templatePath
+        ? resolve(templatePath)
+        : defaultTemplatePath;
+    // Load template HTML
+    if (!existsSync(resolvedTemplatePath)) {
+        throw new Error(`HTML template not found at ${resolvedTemplatePath}`);
+    }
+    let html = readFileSync(resolvedTemplatePath, 'utf-8');
+    // Load report data
+    const { run, results } = loadReportData(resolvedReportPath);
+    // Load history (optional)
+    const history = loadHistoryData(resolvedReportPath, historyPath);
+    // Inject data into HTML
+    html = injectData(html, '__QASE_RUN_DATA__', run);
+    html = injectData(html, '__QASE_RESULTS_DATA__', results);
+    if (history !== null) {
+        html = injectData(html, '__QASE_HISTORY_DATA__', history);
+    }
+    // Set static mode flag
+    html = injectData(html, '__QASE_STATIC_MODE__', true);
+    return html;
+}

package/dist/cli/history.js

@@ -0,0 +1,150 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+/**
+ * Maximum number of runs to store in history file.
+ * Per requirements HIST-04.
+ */
+const MAX_HISTORY_RUNS = 30;
+/**
+ * Default filename for history file.
+ */
+export const DEFAULT_HISTORY_FILENAME = 'qase-report-history.json';
+/**
+ * Loads history data from file.
+ * Returns null if file doesn't exist (not an error).
+ * Returns null and logs warning if JSON parse fails (corrupted file).
+ *
+ * @param historyPath - Path to history file
+ * @returns Parsed history data or null
+ */
+export function loadHistory(historyPath) {
+    try {
+        if (!existsSync(historyPath)) {
+            return null;
+        }
+        const data = readFileSync(historyPath, 'utf-8').replace(/^\uFEFF/, '');
+        const parsed = JSON.parse(data);
+        return parsed;
+    }
+    catch (error) {
+        console.warn(`Warning: Failed to load history from ${historyPath}:`, error instanceof Error ? error.message : error);
+        return null;
+    }
+}
+/**
+ * Saves history data to file.
+ * Creates parent directory if needed.
+ *
+ * @param historyPath - Path to history file
+ * @param history - History data to save
+ */
+export function saveHistory(historyPath, history) {
+    const dir = dirname(historyPath);
+    // Create parent directory if needed
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(historyPath, JSON.stringify(history, null, 2), 'utf-8');
+}
+/**
+ * Adds current run to history file.
+ * Creates new history if file doesn't exist.
+ * Enforces MAX_HISTORY_RUNS limit by removing oldest runs.
+ * Skips if run already exists (idempotent).
+ *
+ * @param options - Configuration object
+ * @param options.historyPath - Path to history file
+ * @param options.run - Current run metadata
+ * @param options.results - Array of test results
+ */
+export function addRunToHistory(options) {
+    const { historyPath, run, results } = options;
+    // Load existing history or create new
+    let history = loadHistory(historyPath);
+    if (!history) {
+        history = {
+            schema_version: '1.0.0',
+            runs: [],
+            tests: [],
+        };
+    }
+    // Generate runId from timestamp
+    const runId = run.execution.start_time
+        ? new Date(run.execution.start_time).getTime().toString()
+        : Date.now().toString();
+    // Check for duplicate and skip if exists
+    if (history.runs.some((r) => r.run_id === runId)) {
+        return;
+    }
+    // Create HistoricalRun object
+    const historicalRun = {
+        run_id: runId,
+        title: run.title ?? null,
+        environment: run.environment ?? null,
+        start_time: run.execution.start_time
+            ? new Date(run.execution.start_time).getTime()
+            : Date.now(),
+        end_time: run.execution.end_time
+            ? new Date(run.execution.end_time).getTime()
+            : Date.now(),
+        duration: run.execution.duration,
+        stats: {
+            total: run.stats.total,
+            passed: run.stats.passed,
+            failed: run.stats.failed,
+            skipped: run.stats.skipped,
+            blocked: run.stats.blocked,
+            invalid: run.stats.invalid,
+            muted: run.stats.muted,
+        },
+    };
+    // Add run to history
+    history.runs.push(historicalRun);
+    // Update per-test history
+    for (const testResult of results) {
+        const signature = testResult.signature;
+        if (!signature)
+            continue;
+        // Find or create test entry
+        let testEntry = history.tests.find((t) => t.signature === signature);
+        if (!testEntry) {
+            testEntry = {
+                signature,
+                title: testResult.title,
+                runs: [],
+            };
+            history.tests.push(testEntry);
+        }
+        // Extract first line of error message for flakiness detection
+        let errorMessage = null;
+        if (testResult.execution.stacktrace) {
+            const firstLine = testResult.execution.stacktrace.split('\n')[0];
+            errorMessage = firstLine?.trim() || null;
+        }
+        // Add run data for this test
+        const testRunData = {
+            run_id: runId,
+            status: testResult.execution.status,
+            duration: testResult.execution.duration,
+            start_time: testResult.execution.start_time
+                ? new Date(testResult.execution.start_time).getTime()
+                : Date.now(),
+            error_message: errorMessage,
+        };
+        testEntry.runs.push(testRunData);
+    }
+    // Enforce MAX_HISTORY_RUNS limit
+    while (history.runs.length > MAX_HISTORY_RUNS) {
+        const oldestRun = history.runs.shift();
+        if (oldestRun) {
+            // Remove run data from per-test history
+            for (const testEntry of history.tests) {
+                testEntry.runs = testEntry.runs.filter((r) => r.run_id !== oldestRun.run_id);
+            }
+            // Remove tests with no remaining run data (orphaned tests)
+            history.tests = history.tests.filter((t) => t.runs.length > 0);
+        }
+    }
+    // Save updated history
+    saveHistory(historyPath, history);
+}

package/dist/cli/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { registerOpenCommand } from './commands/open.js';
+import { registerGenerateCommand } from './commands/generate.js';
+// Get version from package.json dynamically
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '..', '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+program
+    .name('qase-report')
+    .description('Visualize Qase test reports in an interactive UI')
+    .version(packageJson.version, '-v, --version', 'Output the current version')
+    .showHelpAfterError();
+// Register commands
+registerOpenCommand(program);
+registerGenerateCommand(program);
+program.parse(process.argv);
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/cli/qase-api.js

@@ -0,0 +1,275 @@
+/**
+ * Qase API client for interacting with Qase TMS API.
+ * Handles run creation, result submission, and run completion.
+ */
+/**
+ * Custom error class for Qase API errors
+ */
+export class QaseApiError extends Error {
+    statusCode;
+    qaseMessage;
+    constructor(message, statusCode, qaseMessage) {
+        super(message);
+        this.statusCode = statusCode;
+        this.qaseMessage = qaseMessage;
+        this.name = 'QaseApiError';
+    }
+}
+/**
+ * Format Date object as "YYYY-MM-DD HH:mm:ss" in UTC
+ */
+function formatDateTime(date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+    const seconds = String(date.getUTCSeconds()).padStart(2, '0');
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+/**
+ * Create a new test run in Qase TMS
+ * @returns Run ID
+ */
+export async function createQaseRun(options) {
+    const { apiToken, projectCode, title, startTime } = options;
+    const url = `https://api.qase.io/v1/run/${projectCode}`;
+    const runStartTime = startTime
+        ? formatDateTime(new Date(startTime * 1000))
+        : formatDateTime(new Date());
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Token: apiToken,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                title,
+                is_autotest: true,
+                start_time: runStartTime,
+            }),
+        });
+        const responseText = await response.text();
+        let data;
+        try {
+            data = JSON.parse(responseText);
+        }
+        catch {
+            data = { raw: responseText };
+        }
+        if (!response.ok) {
+            const errorMessage = data.errorMessage || data.message || response.statusText;
+            if (response.status === 401) {
+                throw new QaseApiError('Invalid API token', 401, String(errorMessage));
+            }
+            else if (response.status === 404) {
+                throw new QaseApiError(`Project not found: ${projectCode}`, 404, String(errorMessage));
+            }
+            else {
+                throw new QaseApiError(`Qase API error: ${response.statusText}`, response.status, String(errorMessage));
+            }
+        }
+        if (!data.status || !data.result?.id) {
+            throw new QaseApiError('Invalid response from Qase API', response.status, 'Missing run ID in response');
+        }
+        return data.result.id;
+    }
+    catch (err) {
+        if (err instanceof QaseApiError) {
+            throw err;
+        }
+        // Network or other error
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        throw new QaseApiError(`Network error: ${message}`, 0, message);
+    }
+}
+/**
+ * Send test results to a Qase run
+ */
+export async function sendQaseResults(options) {
+    const { apiToken, projectCode, runId, results } = options;
+    const url = `https://api.qase.io/v2/${projectCode}/run/${runId}/results`;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Token: apiToken,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ results }),
+        });
+        if (!response.ok) {
+            const responseText = await response.text();
+            let data;
+            try {
+                data = JSON.parse(responseText);
+            }
+            catch {
+                data = { raw: responseText };
+            }
+            const errorMessage = data.errorMessage || data.message || response.statusText;
+            if (response.status === 401) {
+                throw new QaseApiError('Invalid API token', 401, String(errorMessage));
+            }
+            else if (response.status === 404) {
+                throw new QaseApiError(`Run not found: ${runId}`, 404, String(errorMessage));
+            }
+            else {
+                throw new QaseApiError(`Qase API error: ${response.statusText}`, response.status, String(errorMessage));
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof QaseApiError) {
+            throw err;
+        }
+        // Network or other error
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        throw new QaseApiError(`Network error: ${message}`, 0, message);
+    }
+}
+/**
+ * Mark a test run as complete in Qase TMS
+ */
+export async function completeQaseRun(options) {
+    const { apiToken, projectCode, runId } = options;
+    const url = `https://api.qase.io/v1/run/${projectCode}/${runId}/complete`;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Token: apiToken,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const data = await response.json();
+            const errorMessage = data.errorMessage || data.message || response.statusText;
+            if (response.status === 401) {
+                throw new QaseApiError('Invalid API token', 401, errorMessage);
+            }
+            else if (response.status === 404) {
+                throw new QaseApiError(`Run not found: ${runId}`, 404, errorMessage);
+            }
+            else {
+                throw new QaseApiError(`Qase API error: ${response.statusText}`, response.status, errorMessage);
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof QaseApiError) {
+            throw err;
+        }
+        // Network or other error
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        throw new QaseApiError(`Network error: ${message}`, 0, message);
+    }
+}
+/**
+ * Upload attachments to Qase TMS and return a map of attachment id → hash
+ *
+ * Batching: max 20 files per request, max 128 MB per request
+ * Skips files larger than 32 MB
+ */
+export async function uploadAttachments(options) {
+    const { apiToken, projectCode, files } = options;
+    const url = `https://api.qase.io/v1/attachment/${projectCode}`;
+    const idToHash = new Map();
+    const MAX_FILES_PER_BATCH = 20;
+    const MAX_BATCH_SIZE = 128 * 1024 * 1024; // 128 MB
+    const MAX_FILE_SIZE = 32 * 1024 * 1024; // 32 MB
+    // Build batches respecting file count and size limits
+    const batches = [];
+    let currentBatch = [];
+    let currentBatchSize = 0;
+    for (const file of files) {
+        const { readFileSync, statSync } = await import('fs');
+        let fileSize;
+        try {
+            fileSize = statSync(file.path).size;
+        }
+        catch {
+            console.warn(`Skipping attachment ${file.name}: cannot stat file`);
+            continue;
+        }
+        if (fileSize > MAX_FILE_SIZE) {
+            console.warn(`Skipping attachment ${file.name}: file size ${(fileSize / 1024 / 1024).toFixed(1)} MB exceeds 32 MB limit`);
+            continue;
+        }
+        if (currentBatch.length >= MAX_FILES_PER_BATCH ||
+            currentBatchSize + fileSize > MAX_BATCH_SIZE) {
+            if (currentBatch.length > 0) {
+                batches.push(currentBatch);
+            }
+            currentBatch = [];
+            currentBatchSize = 0;
+        }
+        currentBatch.push(file);
+        currentBatchSize += fileSize;
+    }
+    if (currentBatch.length > 0) {
+        batches.push(currentBatch);
+    }
+    // Upload each batch
+    for (const batch of batches) {
+        const { readFileSync } = await import('fs');
+        const formData = new FormData();
+        for (const file of batch) {
+            const fileBuffer = readFileSync(file.path);
+            const blob = new Blob([fileBuffer], { type: file.mimeType });
+            formData.append('file[]', blob, file.name);
+        }
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Token: apiToken,
+                },
+                body: formData,
+            });
+            const responseText = await response.text();
+            let data;
+            try {
+                data = JSON.parse(responseText);
+            }
+            catch {
+                data = { raw: responseText };
+            }
+            if (!response.ok) {
+                const errorMessage = data.errorMessage || data.message || response.statusText;
+                console.warn(`Warning: Failed to upload attachment batch: ${errorMessage}`);
+                continue;
+            }
+            // Map uploaded files back to their IDs by matching filenames
+            const resultItems = data.result;
+            if (Array.isArray(resultItems)) {
+                // Build a filename→id lookup from current batch
+                const nameToIds = new Map();
+                for (const file of batch) {
+                    const ids = nameToIds.get(file.name) || [];
+                    ids.push(file.id);
+                    nameToIds.set(file.name, ids);
+                }
+                for (const item of resultItems) {
+                    const ids = nameToIds.get(item.filename);
+                    if (ids && ids.length > 0) {
+                        const id = ids.shift();
+                        idToHash.set(id, item.hash);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            console.warn(`Warning: Failed to upload attachment batch: ${message}`);
+        }
+    }
+    return idToHash;
+}
+/**
+ * Build URL to view a run in Qase TMS web interface
+ */
+export function buildRunUrl(projectCode, runId) {
+    return `https://app.qase.io/run/${projectCode}/dashboard/${runId}`;
+}

package/dist/cli/qase-transform.js

@@ -0,0 +1,119 @@
+/**
+ * Result transformer - converts internal QaseTestResult format to Qase API v2 ResultCreate format
+ */
+/**
+ * Map internal test status to Qase API status
+ */
+function mapStatus(status) {
+    switch (status) {
+        case 'passed':
+            return 'passed';
+        case 'failed':
+            return 'failed';
+        case 'skipped':
+            return 'skipped';
+        case 'broken':
+            return 'failed'; // Qase API has no 'broken' status
+        case 'blocked':
+            return 'blocked';
+        case 'invalid':
+            return 'invalid';
+        case 'muted':
+            return 'passed'; // Muted tests are treated as passed
+        default:
+            return 'failed'; // Safe fallback
+    }
+}
+/**
+ * Map internal step status to Qase API step status
+ */
+function mapStepStatus(status) {
+    switch (status) {
+        case 'passed':
+            return 'passed';
+        case 'failed':
+            return 'failed';
+        case 'blocked':
+            return 'blocked';
+        case 'skipped':
+            return 'skipped';
+        case 'broken':
+            return 'failed'; // Qase API has no 'broken' status
+        default:
+            return 'failed'; // Safe fallback
+    }
+}
+/**
+ * Resolve attachment hashes from attachment map
+ */
+function resolveAttachmentHashes(attachments, attachmentMap) {
+    if (!attachmentMap || attachments.length === 0)
+        return [];
+    const hashes = [];
+    for (const att of attachments) {
+        const hash = attachmentMap.get(att.id);
+        if (hash)
+            hashes.push(hash);
+    }
+    return hashes;
+}
+/**
+ * Transform a single step to Qase API v2 format (recursive)
+ */
+function transformStep(step, attachmentMap) {
+    const resultStep = {
+        step_type: 'text',
+        data: {
+            action: step.data.action || step.step_type,
+            expected_result: step.data.expected_result !== null && step.data.expected_result !== undefined
+                ? step.data.expected_result
+                : undefined,
+        },
+        execution: {
+            status: mapStepStatus(step.execution.status),
+            attachments: resolveAttachmentHashes(step.execution.attachments, attachmentMap),
+        },
+    };
+    // Add nested steps if they exist
+    if (step.steps && step.steps.length > 0) {
+        resultStep.steps = step.steps.map((s) => transformStep(s, attachmentMap));
+    }
+    return resultStep;
+}
+/**
+ * Transform a single test result to Qase API v2 format
+ */
+export function transformResult(result, attachmentMap) {
+    return {
+        title: result.title,
+        execution: {
+            status: mapStatus(result.execution.status),
+            start_time: result.execution.start_time,
+            end_time: result.execution.end_time ??
+                result.execution.start_time + result.execution.duration,
+            duration: result.execution.duration,
+            stacktrace: result.execution.stacktrace !== null
+                ? result.execution.stacktrace
+                : undefined,
+            thread: result.execution.thread !== null ? result.execution.thread : undefined,
+        },
+        testops_ids: result.testops_ids !== null && result.testops_ids !== undefined
+            ? result.testops_ids
+            : undefined,
+        attachments: resolveAttachmentHashes(result.attachments, attachmentMap),
+        steps: result.steps.map(s => transformStep(s, attachmentMap)),
+        params: result.params,
+        param_groups: result.param_groups,
+        relations: result.relations ?? {},
+        message: result.message !== null ? result.message : undefined,
+        fields: Object.fromEntries(Object.entries(result.fields).filter(([, v]) => v !== null)),
+        defect: false, // No defect tracking in report format
+        signature: result.signature,
+    };
+}
+/**
+ * Transform multiple test results to Qase API v2 format
+ */
+export function transformResults(results, attachmentMap) {
+    return results.map(r => transformResult(r, attachmentMap));
+}