itee-validators 5.6.0 → 6.0.0

package/.tasks/itee-benchmarks-framework.js

@@ -0,0 +1,186 @@
+import {
+    getConfig,
+    sessionFailed,
+    sessionFinished,
+    sessionStarted,
+} from '@web/test-runner-core/browser/session.js'
+
+///////
+
+class TestResultError {
+
+    /**
+     * @param {string} message
+     * @param {string|null} name
+     * @param {string|null} stack
+     * @param {string|null} expected
+     * @param {string|null} actual
+     */
+    constructor(
+        message,
+        name     = null,
+        stack    = null,
+        expected = null,
+        actual   = null,
+    ) {
+        this.message  = message
+        this.name     = name
+        this.stack    = stack
+        this.expected = expected
+        this.actual   = actual
+    }
+
+}
+
+class TestSuiteResult {
+
+    /**
+     *
+     * @param {string} name
+     * @param {Array.<TestSuiteResult>} suites
+     * @param {Array.<TestResult>} tests
+     */
+    constructor( name, suites = [], tests = [] ) {
+        this.name   = name
+        this.suites = suites
+        this.tests  = tests
+    }
+
+}
+
+class TestResult {
+
+    /**
+     * @param {string} name
+     * @param {boolean} passed
+     * @param {boolean} skipped
+     * @param {number|null} duration
+     * @param {TestResultError|null} error
+     */
+    constructor( name, passed, skipped = false, duration = null, error = null, stats = null ) {
+        this.name     = name
+        this.passed   = passed
+        this.skipped  = skipped
+        this.duration = duration
+        this.error    = error
+        this.stats    = stats
+    }
+
+}
+
+class TestSession {
+
+    // BasicTestSession //
+    // id: string;
+    // group: TestSessionGroup;
+    // browser: BrowserLauncher;
+    // testFile: string;
+
+    // TestSession //
+    // debug: false;
+    // testRun: number;
+    // status: TestSessionStatus;
+    // passed?: boolean;
+    // errors: TestResultError[];
+    // testResults?: TestSuiteResult;
+    // logs: any[][];
+    // request404s: string[];
+    // testCoverage?: CoverageMapData;
+
+    /**
+     * @param {boolean|null} passed
+     * @param {Array.<TestResultError>} errors
+     * @param {TestSuiteResult|null} testResults
+     */
+    constructor( passed, errors = [], testResults = null ) {
+        this.passed      = passed
+        this.errors      = errors
+        this.testResults = testResults
+    }
+
+}
+
+///////
+
+async function runTests( testData ) {
+
+    let suiteResults = []
+    for ( const exportKey in testData ) {
+        const suite       = testData[ exportKey ]
+        const suiteResult = await new Promise( ( resolve ) => {
+
+            // suite.on( 'start', event => console.log )
+            // suite.on( 'cycle', event => console.log )
+
+            suite.on( 'complete', ( event ) => {
+                // console.log(event.currentTarget)
+                const testResults = event.currentTarget.map( target => new TestResult( target.name, true, false, target.hz, undefined, target.times ) )
+                const suiteResult = new TestSuiteResult( suite.name, undefined, testResults )
+
+                resolve( suiteResult )
+            } )
+
+            suite.run()
+
+        } )
+
+        suiteResults.push( suiteResult )
+    }
+
+    return {
+        name:   'Benchmark',
+        suites: suiteResults, // TestSuiteResult
+        tests:  [], // TestResult
+        passed: true
+    }
+
+}
+
+( async () => {
+    // notify the test runner that we're alive
+    await sessionStarted()
+
+    // fetch the config for this test run, this will tell you which file we're testing
+    const {
+              testFile,
+              watch,
+              debug,
+              testFrameworkConfig
+          } = await getConfig()
+
+    // load the test file as an es module
+    const failedImports = []
+    let testData        = null
+    try {
+        const testFileURL = new URL( testFile, document.baseURI )
+        testData          = await import(testFileURL.href)
+    } catch ( error ) {
+        failedImports.push( {
+            file:  testFile,
+            error: {
+                message: error.message,
+                stack:   error.stack
+            }
+        } )
+    }
+
+    try {
+        // run the actual tests, this is what you need to implement
+        const testResults   = await runTests( testData )
+        // console.log( 'After runTests, testResults:', testResults )
+        const passed        = failedImports.length === 0 && testResults.passed
+        const sessionResult = new TestSession( passed, failedImports, testResults )
+
+        // notify tests run finished
+        await sessionFinished( sessionResult )
+    } catch ( error ) {
+        // notify an error occurred
+        const sessionError = new TestResultError(
+            error.message,
+            error.name,
+            error.stack
+        )
+        await sessionFailed( sessionError )
+    }
+
+} )()

package/.tasks/itee-reporter.mjs

@@ -0,0 +1,217 @@
+import { SESSION_STATUS } from '@web/test-runner'
+import colors             from 'ansi-colors'
+import {
+    existsSync,
+    mkdirSync,
+    writeFileSync
+}                         from 'node:fs'
+import {
+    dirname,
+    relative,
+    resolve
+}                         from 'node:path'
+
+const yellow = colors.yellow
+const green  = colors.green
+
+export function iteeReporter( {
+    reportResults = true,
+    reportProgress = true,
+    outputFilePath = '.reports/web_test_runner_report.json'
+} = {} ) {
+
+    const _reportResults  = reportResults
+    const _reportProgress = reportProgress
+    const _reportFilePath = resolve( outputFilePath )
+    const _report         = {
+        config:          {},
+        sessions:        {},
+        testCoverage:    {},
+        testFiles:       [],
+        browserNames:    [],
+        focusedTestFile: null,
+        startTime:       null,
+        endTime:         null,
+    }
+    let _logger           = null
+    let _debug            = null
+
+    return {
+        /**
+         * Called once when the test runner starts.
+         */
+        start( {
+            config,
+            browserNames,
+            testFiles,
+            startTime
+        } ) {
+            _logger = config.logger
+            _debug  = config.debug
+
+            _report.config       = {
+                browsers:            config.browsers.map( browser => ( {
+                    name:        browser.name,
+                    type:        browser.type,
+                    concurrency: browser.concurrency,
+                } ) ),
+                browserLogs:         config.browserLogs,
+                browserStartTimeout: config.browserStartTimeout,
+                concurrency:         config.concurrency,
+                concurrentBrowsers:  config.concurrentBrowsers,
+                coverage:            config.coverage ?? false,
+                coverageConfig:      config.coverageConfig,
+                debug:               config.debug ?? false,
+                files:               config.files,
+                hostname:            config.hostname,
+                logger:              config.logger.constructor.name,
+                middleware:          [],
+                nodeResolve:         config.nodeResolve,
+                plugins:             config.plugins.map( plugin => ( {
+                    name:            plugin.name,
+                    injectWebSocket: plugin.injectWebSocket ?? false
+                } ) ),
+                port:                config.port,
+                protocol:            config.protocol,
+                reporters:           config.reporters.length,
+                rootDir:             config.rootDir,
+                testFramework:       ( config.testFramework ) ? relative( config.rootDir, config.testFramework.path ) : null,
+                testRunnerHtml:      config.testRunnerHtml?.name,
+                testsFinishTimeout:  config.testsFinishTimeout,
+                testsStartTimeout:   config.testsStartTimeout,
+                watch:               config.watch,
+                http2:               config.http2 ?? null,
+                sslKey:              config.sslKey ?? null,
+                sslCert:             config.sslCert ?? null,
+                manual:              config.manual ?? false,
+                open:                config.open ?? false,
+                mimeTypes:           config.mimeTypes ?? null,
+            }
+            _report.testFiles    = testFiles.map( testFile => relative( config.rootDir, testFile ) )
+            _report.browserNames = browserNames
+            _report.startTime    = startTime
+        },
+
+        /**
+         * Called once when the test runner stops. This can be used to write a test
+         * report to disk for regular test runs.
+         */
+        stop( {
+            sessions,
+            testCoverage,
+            /*focusedTestFile*/
+        } ) {
+            if ( !_reportResults && _debug ) {
+                _logger.warn( yellow( 'Do not report global results.' ) )
+                return
+            }
+
+
+            // Update globals
+            _report.endTime = ( new Date() ).getTime()
+
+            // apply session map results
+            for ( const session of sessions ) {
+                _report.sessions[ session.id ] = {
+                    id:    session.id,
+                    group: {
+                        name:           session.group.name,
+                        testFiles:      session.group.testFiles,
+                        browsers:       session.group.browsers.map( browser => ( {
+                            name:        browser.name,
+                            type:        browser.type,
+                            concurrency: browser.concurrency,
+                        } ) ),
+                        sessionIds:     session.group.sessionIds,
+                        testRunnerHtml: session.group.testRunnerHtml?.name,
+                    },
+                    // debug:   false, // Ignore because always false
+                    browser:     {
+                        name:        session.browser.name,
+                        type:        session.browser.type,
+                        concurrency: session.browser.concurrency,
+                    },
+                    testFile:    session.testFile,
+                    testRun:     session.testRun,
+                    status:      session.status,
+                    passed:      session.passed,
+                    errors:      session.errors,
+                    testResults: session.testResults,
+                    logs:        session.logs,
+                    request404s: session.request404s,
+                    // testCoverage: session.testCoverage,
+                }
+            }
+
+            _report.testCoverage = ( testCoverage ) ? {
+                passed:      testCoverage.passed,
+                coverageMap: testCoverage.coverageMap.toJSON(),
+                summary:     testCoverage.summary.toJSON(),
+            } : null
+
+            const outputDirectory = dirname( _reportFilePath )
+            if ( !existsSync( outputDirectory ) ) {
+                if ( _debug ) _logger.log( 'Creating', green( outputDirectory ) )
+                mkdirSync( outputDirectory, { recursive: true } )
+            }
+
+            _logger.log( 'Generate', green( _reportFilePath ) )
+            writeFileSync( _reportFilePath, JSON.stringify( _report, null, 2 ) )
+        },
+
+        onTestRunStarted( testRun ) {
+            if ( _debug ) _logger.log( `onTestRunStarted: ${ testRun }` )
+        },
+        onTestRunFinished( testRun, sessions, testCoverage, focusedTestFile ) {
+            if ( _debug ) _logger.log( `onTestRunFinished: ${ focusedTestFile }` )
+        },
+        reportTestFileResults( {
+            logger,
+            sessionsForTestFile,
+            testFile,
+            testRun
+        } ) {
+            if ( _debug ) _logger.log( `reportTestFileResults: ${ testFile }` )
+        },
+
+        /**
+         * Called when test progress should be rendered to the terminal. This is called
+         * any time there is a change in the test runner to display the latest status.
+         *
+         * This function should return the test report as a string. Previous results from this
+         * function are overwritten each time it is called, they are rendered "dynamically"
+         * to the terminal so that the progress bar is live updating.
+         */
+        getTestProgress( {
+            config,
+            sessions,
+            testFiles,
+            startTime,
+            testRun,
+            focusedTestFile,
+            testCoverage,
+        } ) {
+            if ( !_reportProgress ) {
+                return
+            }
+
+            const numberOfSessions = sessions.length
+            const numberOfFinished = sessions.filter( session => session.status === SESSION_STATUS.FINISHED ).length
+
+            let progress
+            if ( numberOfFinished === numberOfSessions ) {
+                progress = null
+            } else {
+                const advancementPercent = Math.round( ( numberOfFinished / numberOfSessions ) * 100 )
+                progress                 = [
+                    `Progress: ${ numberOfFinished }/${ numberOfSessions } (${ advancementPercent }%)`
+                ]
+            }
+
+            return progress
+
+        }
+
+    }
+
+}

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [v6.0.0](https://github.com/Itee/itee-validators/compare/v5.6.0...v6.0.0) (2025-11-05)
+
+## ✨ New Features
+- [`6e706ed`](https://github.com/Itee/itee-validators/commit/6e706ed)  (benchmarks) re-introduce benchmarks frontend with web test runner, configs and new code 
+
+## 🐛 Bug Fixes
+- [`31c3572`](https://github.com/Itee/itee-validators/commit/31c3572)  (gulpfile) fix broken import links 
+- [`876ba94`](https://github.com/Itee/itee-validators/commit/876ba94)  (run-tests) fix task displayName 
+
+## 💥 Breaking Changes
+- [`a6f1255`](https://github.com/Itee/itee-validators/commit/a6f1255)  (node) drop nodejs v18 support and add nodejs v24
+
 # [v5.6.0](https://github.com/Itee/itee-validators/compare/v5.5.1...v5.6.0) (2025-10-18)
 
 ## ✨ New Features