@react-native-harness/cli 1.1.0 → 1.2.0

package/dist/reporters/live-reporter.d.ts

@@ -0,0 +1,20 @@
+import type { SuiteResult, LiveReportingEvent } from '@react-native-harness/bridge';
+import { Reporter } from '@react-native-harness/config';
+export declare class LiveReporter {
+    private state;
+    private progressSpinner;
+    constructor();
+    start(): void;
+    handleLiveEvent(event: LiveReportingEvent): void;
+    private getStatusSymbol;
+    private updateProgress;
+    private formatDuration;
+    stop(message: string): void;
+    countTests(suite: SuiteResult): number;
+    setTotalTests(results: SuiteResult[]): void;
+}
+export declare const createLiveReporter: () => {
+    reporter: Reporter;
+    liveReporter: LiveReporter;
+};
+//# sourceMappingURL=live-reporter.d.ts.map

package/dist/reporters/live-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-reporter.d.ts","sourceRoot":"","sources":["../../src/reporters/live-reporter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EAEX,kBAAkB,EACnB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAcxD,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,eAAe,CAA6B;;IAiBpD,KAAK;IAKL,eAAe,CAAC,KAAK,EAAE,kBAAkB;IA4DzC,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,cAAc;IA6BtB,OAAO,CAAC,cAAc;IAMtB,IAAI,CAAC,OAAO,EAAE,MAAM;IAKpB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM;IAQtC,aAAa,CAAC,OAAO,EAAE,WAAW,EAAE;CAMrC;AAED,eAAO,MAAM,kBAAkB,QAAO;IACpC,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;CA0C5B,CAAC"}

package/dist/reporters/live-reporter.js

@@ -0,0 +1,176 @@
+import { color, spinner } from '@react-native-harness/tools';
+export class LiveReporter {
+    state;
+    progressSpinner;
+    constructor() {
+        this.state = {
+            totalTests: 0,
+            completedTests: 0,
+            passedTests: 0,
+            failedTests: 0,
+            skippedTests: 0,
+            todoTests: 0,
+            currentTest: null,
+            currentSuite: null,
+            startTime: Date.now(),
+        };
+        this.progressSpinner = spinner();
+    }
+    start() {
+        this.state.startTime = Date.now();
+        this.progressSpinner.start('Initializing tests...');
+    }
+    handleLiveEvent(event) {
+        switch (event.type) {
+            case 'suite_started':
+                this.state.currentSuite = event.suiteHierarchy.join(' > ');
+                this.updateProgress(`Starting suite: ${this.state.currentSuite}`);
+                break;
+            case 'test_started':
+                this.state.currentTest = `${event.suiteHierarchy.join(' > ')} > ${event.testName}`;
+                this.updateProgress(`Running: ${event.testName}`);
+                break;
+            case 'test_completed':
+                this.state.completedTests++;
+                switch (event.result.status) {
+                    case 'passed':
+                        this.state.passedTests++;
+                        break;
+                    case 'failed':
+                        this.state.failedTests++;
+                        break;
+                    case 'skipped':
+                        this.state.skippedTests++;
+                        break;
+                    case 'todo':
+                        this.state.todoTests++;
+                        break;
+                }
+                const statusSymbol = this.getStatusSymbol(event.result.status);
+                const duration = event.result.duration
+                    ? ` (${event.result.duration}ms)`
+                    : '';
+                this.updateProgress(`${statusSymbol} ${event.testName}${duration}`, event.result.status === 'failed'
+                    ? event.result.error?.message
+                    : undefined);
+                break;
+            case 'suite_completed':
+                const suiteStatusSymbol = this.getStatusSymbol(event.result.status);
+                const suiteDuration = event.result.duration
+                    ? ` (${event.result.duration}ms)`
+                    : '';
+                this.updateProgress(`${suiteStatusSymbol} Suite completed: ${event.suiteHierarchy.join(' > ')}${suiteDuration}`);
+                break;
+        }
+    }
+    getStatusSymbol(status) {
+        switch (status) {
+            case 'passed':
+                return color.green('✓');
+            case 'failed':
+                return color.red('✗');
+            case 'skipped':
+                return color.yellow('-');
+            case 'todo':
+                return color.blue('○');
+            default:
+                return '?';
+        }
+    }
+    updateProgress(message, error) {
+        const elapsed = Date.now() - this.state.startTime;
+        const elapsedFormatted = this.formatDuration(elapsed);
+        const progress = this.state.totalTests > 0
+            ? ` [${this.state.completedTests}/${this.state.totalTests}]`
+            : ` [${this.state.completedTests} completed]`;
+        const summary = [
+            color.green(`${this.state.passedTests} passed`),
+            ...(this.state.failedTests > 0
+                ? [color.red(`${this.state.failedTests} failed`)]
+                : []),
+            ...(this.state.skippedTests > 0
+                ? [color.yellow(`${this.state.skippedTests} skipped`)]
+                : []),
+            ...(this.state.todoTests > 0
+                ? [color.blue(`${this.state.todoTests} todo`)]
+                : []),
+        ].join(', ');
+        this.progressSpinner.message(`${message}${progress} | ${summary} | ${elapsedFormatted}${error ? `\n  ${color.red('Error:')} ${error}` : ''}`);
+    }
+    formatDuration(ms) {
+        if (ms < 1000)
+            return `${ms}ms`;
+        if (ms < 60000)
+            return `${(ms / 1000).toFixed(1)}s`;
+        return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+    }
+    stop(message) {
+        this.progressSpinner.stop(message);
+    }
+    // Count total tests in suite hierarchy
+    countTests(suite) {
+        let count = suite.tests.length;
+        for (const childSuite of suite.suites) {
+            count += this.countTests(childSuite);
+        }
+        return count;
+    }
+    setTotalTests(results) {
+        this.state.totalTests = results.reduce((sum, suite) => sum + this.countTests(suite), 0);
+    }
+}
+export const createLiveReporter = () => {
+    const liveReporter = new LiveReporter();
+    const reporter = {
+        report: async (results) => {
+            // Final summary is handled by the existing default reporter logic
+            const totalPassed = results.reduce((sum, suite) => sum + getTestSummary(suite).passed, 0);
+            const totalFailed = results.reduce((sum, suite) => sum + getTestSummary(suite).failed, 0);
+            const totalSkipped = results.reduce((sum, suite) => sum + getTestSummary(suite).skipped, 0);
+            const totalTodo = results.reduce((sum, suite) => sum + getTestSummary(suite).todo, 0);
+            const totalDuration = results.reduce((sum, suite) => sum + (suite.duration || 0), 0);
+            const summaryText = [
+                color.green(`${totalPassed} passed`),
+                color.red(`${totalFailed} failed`),
+                color.yellow(`${totalSkipped} skipped`),
+                color.blue(`${totalTodo} todo`),
+            ].join(', ');
+            liveReporter.stop(`Summary: ${summaryText} | Total time: ${formatDuration(totalDuration)}`);
+        },
+    };
+    return { reporter, liveReporter };
+};
+const getTestSummary = (suite) => {
+    let passed = 0, failed = 0, skipped = 0, todo = 0;
+    // Count tests in current suite
+    for (const test of suite.tests) {
+        switch (test.status) {
+            case 'passed':
+                passed++;
+                break;
+            case 'failed':
+                failed++;
+                break;
+            case 'skipped':
+                skipped++;
+                break;
+            case 'todo':
+                todo++;
+                break;
+        }
+    }
+    // Count tests in nested suites
+    for (const childSuite of suite.suites) {
+        const childSummary = getTestSummary(childSuite);
+        passed += childSummary.passed;
+        failed += childSummary.failed;
+        skipped += childSummary.skipped;
+        todo += childSummary.todo;
+    }
+    return { passed, failed, skipped, todo };
+};
+const formatDuration = (duration) => duration
+    ? duration < 1000
+        ? `${duration}ms`
+        : `${(duration / 1000).toFixed(2)}s`
+    : '0ms';

package/dist/src/reporters/default-reporter.js

@@ -0,0 +1,135 @@
+import { color, logger } from '@react-native-harness/tools';
+export const defaultReporter = {
+    report: async (results) => {
+        logger.log('\n📋 Test Results');
+        console.log(color.dim('━'.repeat(60)));
+        for (const suite of results) {
+            console.log(formatSuiteResult(suite));
+        }
+        console.log(color.dim('━'.repeat(60)));
+        // Summary
+        let totalPassed = 0, totalFailed = 0, totalSkipped = 0, totalTodo = 0;
+        let totalDuration = 0;
+        for (const suite of results) {
+            const summary = getTestSummary(suite);
+            totalPassed += summary.passed;
+            totalFailed += summary.failed;
+            totalSkipped += summary.skipped;
+            totalTodo += summary.todo;
+            totalDuration += suite.duration || 0;
+        }
+        // Create summary with modern styling
+        const summaryParts = [];
+        if (totalPassed > 0) {
+            summaryParts.push(color.green(`${totalPassed} passed`));
+        }
+        if (totalFailed > 0) {
+            summaryParts.push(color.red(`${totalFailed} failed`));
+        }
+        if (totalSkipped > 0) {
+            summaryParts.push(color.yellow(`${totalSkipped} skipped`));
+        }
+        if (totalTodo > 0) {
+            summaryParts.push(color.blue(`${totalTodo} todo`));
+        }
+        const summaryText = summaryParts.join(color.dim(' • '));
+        const durationText = formatDuration(totalDuration);
+        logger.info(`📊 Summary: ${summaryText}${durationText}`);
+        // Show appropriate final message
+        if (totalFailed === 0 && totalPassed > 0) {
+            logger.success('All tests passed! 🎉');
+        }
+        else if (totalFailed > 0) {
+            logger.error(`${totalFailed} test${totalFailed === 1 ? '' : 's'} failed`);
+        }
+    },
+};
+const formatDuration = (duration) => {
+    if (!duration)
+        return '';
+    return color.dim(` (${duration}ms)`);
+};
+const getStatusIcon = (status) => {
+    switch (status) {
+        case 'passed':
+            return color.green('✓');
+        case 'failed':
+            return color.red('✗');
+        case 'skipped':
+            return color.yellow('○');
+        case 'todo':
+            return color.blue('◐');
+        default:
+            return '?';
+    }
+};
+const formatTestResult = (test, indent = '') => {
+    const icon = getStatusIcon(test.status);
+    const name = test.status === 'failed' ? color.red(test.name) : test.name;
+    const duration = formatDuration(test.duration);
+    let result = `${indent}${icon} ${name}${duration}`;
+    if (test.error) {
+        const errorLines = test.error.message?.split('\n') || [];
+        result +=
+            '\n' +
+                errorLines
+                    .map((line) => `${indent}  ${color.red(line)}`)
+                    .join('\n');
+    }
+    return result;
+};
+const formatSuiteResult = (suite, indent = '') => {
+    const icon = getStatusIcon(suite.status);
+    const name = suite.status === 'failed'
+        ? color.red(color.bold(suite.name))
+        : color.bold(color.cyan(suite.name));
+    const duration = formatDuration(suite.duration);
+    let result = `${indent}${icon} ${name}${duration}`;
+    if (suite.error) {
+        const errorLines = suite.error.message.split('\n');
+        result +=
+            '\n' +
+                errorLines
+                    .map((line) => `${indent}  ${color.red(line)}`)
+                    .join('\n');
+    }
+    const childIndent = indent + '  ';
+    // Format tests
+    for (const test of suite.tests) {
+        result += '\n' + formatTestResult(test, childIndent);
+    }
+    // Format nested suites
+    for (const childSuite of suite.suites) {
+        result += '\n' + formatSuiteResult(childSuite, childIndent);
+    }
+    return result;
+};
+const getTestSummary = (suite) => {
+    let passed = 0, failed = 0, skipped = 0, todo = 0;
+    // Count tests in current suite
+    for (const test of suite.tests) {
+        switch (test.status) {
+            case 'passed':
+                passed++;
+                break;
+            case 'failed':
+                failed++;
+                break;
+            case 'skipped':
+                skipped++;
+                break;
+            case 'todo':
+                todo++;
+                break;
+        }
+    }
+    // Count tests in nested suites
+    for (const childSuite of suite.suites) {
+        const childSummary = getTestSummary(childSuite);
+        passed += childSummary.passed;
+        failed += childSummary.failed;
+        skipped += childSummary.skipped;
+        todo += childSummary.todo;
+    }
+    return { passed, failed, skipped, todo };
+};

package/dist/test-reporter-demo.js

@@ -0,0 +1,95 @@
+import { defaultReporter } from './src/reporters/default-reporter.js';
+// Sample test results to demonstrate the new styling
+const sampleResults = [
+    {
+        name: 'User Authentication Tests',
+        status: 'passed',
+        duration: 1250,
+        tests: [
+            {
+                name: 'should login with valid credentials',
+                status: 'passed',
+                duration: 450,
+            },
+            {
+                name: 'should show error with invalid credentials',
+                status: 'passed',
+                duration: 320,
+            },
+            {
+                name: 'should handle network errors gracefully',
+                status: 'failed',
+                duration: 180,
+                error: {
+                    name: 'NetworkError',
+                    message: 'Connection timeout after 30 seconds',
+                    stack: 'NetworkError: Connection timeout after 30 seconds\n    at fetch (native)\n    at login (auth.js:15:10)',
+                },
+            },
+        ],
+        suites: [],
+    },
+    {
+        name: 'Navigation Tests',
+        status: 'passed',
+        duration: 890,
+        tests: [
+            {
+                name: 'should navigate to home screen',
+                status: 'passed',
+                duration: 210,
+            },
+            {
+                name: 'should navigate to profile screen',
+                status: 'skipped',
+                duration: 0,
+            },
+            {
+                name: 'should handle deep linking',
+                status: 'todo',
+                duration: 0,
+            },
+        ],
+        suites: [],
+    },
+    {
+        name: 'Component Tests',
+        status: 'failed',
+        duration: 650,
+        tests: [
+            {
+                name: 'should render button correctly',
+                status: 'passed',
+                duration: 120,
+            },
+            {
+                name: 'should handle button press',
+                status: 'failed',
+                duration: 95,
+                error: {
+                    name: 'AssertionError',
+                    message: 'Expected element to be visible but it was not found',
+                    stack: 'AssertionError: Expected element to be visible but it was not found\n    at expect (test-utils.js:25:10)',
+                },
+            },
+        ],
+        suites: [
+            {
+                name: 'Nested Component Tests',
+                status: 'passed',
+                duration: 280,
+                tests: [
+                    {
+                        name: 'should render nested component',
+                        status: 'passed',
+                        duration: 150,
+                    },
+                ],
+                suites: [],
+            },
+        ],
+    },
+];
+// Run the demo
+console.log('🧪 Testing Updated Default Reporter\n');
+await defaultReporter.report(sampleResults);