@remix-run/test 0.1.0 → 0.2.0

package/dist/lib/framework.test.e2e.js

@@ -1,29 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@remix-run/component/jsx-runtime";
-import assert from '@remix-run/assert';
-import { renderToString } from '@remix-run/component/server';
-import { createRouter } from '@remix-run/fetch-router';
-import { route } from '@remix-run/fetch-router/routes';
-import { describe, it } from "./framework.js";
-const html = async (n) => new Response(await renderToString(n), {
-    headers: { 'Content-Type': 'text/html' },
-});
-describe('e2e tests', () => {
-    it('runs playwright against a fetch-router instance', async (t) => {
-        function Doc() {
-            return ({ children }) => (_jsxs("html", { children: [
-                    _jsx("head", { children: _jsx("title", { children: "Test" }) }), _jsx("body", { children: children })
-                ] }));
-        }
-        let routes = route({ home: '/', about: '/about' });
-        let router = createRouter();
-        router.get(routes.home, async () => html(_jsxs(Doc, { children: [
-                _jsx("h1", { children: "Hello Remix" }), _jsx("a", { href: "/about", children: "About" })
-            ] })));
-        router.get(routes.about, async () => html(_jsx(Doc, { children: _jsx("h1", { children: "About Remix" }) })));
-        let page = await t.serve(router.fetch);
-        await page.goto('/');
-        assert.equal(await page.locator('h1').textContent(), 'Hello Remix');
-        await page.click('[href="/about"]');
-        assert.equal(await page.locator('h1').textContent(), 'About Remix');
-    });
-});

package/dist/lib/framework.test.js

@@ -1,283 +0,0 @@
-import * as assert from '@remix-run/assert';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, it, suite, test, } from "./framework.js";
-// During test execution, currentSuite is null so describe() can be called freely.
-// captureRegistration() splices any newly-registered suites back out of __testSuites
-// so the executor doesn't run them — we just inspect their shape.
-function captureRegistration(fn) {
-    let suites = globalThis.__testSuites;
-    let before = suites.length;
-    fn();
-    return suites.splice(before);
-}
-// ── describe ──────────────────────────────────────────────────────────────────
-describe('describe', () => {
-    it('has skip, only, and todo sub-functions', () => {
-        assert.equal(typeof describe.skip, 'function');
-        assert.equal(typeof describe.only, 'function');
-        assert.equal(typeof describe.todo, 'function');
-    });
-    it('registers a suite with the given name', () => {
-        let [s] = captureRegistration(() => describe('my suite', () => { }));
-        assert.equal(s.name, 'my suite');
-    });
-    it('calls fn to register tests', () => {
-        let called = false;
-        captureRegistration(() => describe('suite', () => {
-            called = true;
-        }));
-        assert.equal(called, true);
-    });
-    it('registers tests added inside fn', () => {
-        let [s] = captureRegistration(() => describe('suite', () => {
-            it('test one', () => { });
-            it('test two', () => { });
-        }));
-        assert.equal(s.tests.length, 2);
-        assert.equal(s.tests[0].name, 'test one');
-        assert.equal(s.tests[1].name, 'test two');
-    });
-    it('flattens nested describes into "Outer > Inner" names', () => {
-        let [outer, inner] = captureRegistration(() => {
-            describe('outer', () => {
-                describe('inner', () => { });
-            });
-        });
-        assert.equal(outer.name, 'outer');
-        assert.equal(inner.name, 'outer > inner');
-    });
-});
-describe('describe.skip', () => {
-    it('marks the suite as skipped', () => {
-        let [s] = captureRegistration(() => describe.skip('suite', () => { }));
-        assert.equal(s.skip, true);
-    });
-    it('still calls fn to register tests', () => {
-        let [s] = captureRegistration(() => describe.skip('suite', () => {
-            it('test', () => { });
-        }));
-        assert.equal(s.tests.length, 1);
-    });
-});
-describe('describe.only', () => {
-    it('marks the suite as only', () => {
-        let [s] = captureRegistration(() => describe.only('suite', () => { }));
-        assert.equal(s.only, true);
-    });
-});
-describe('describe.todo', () => {
-    it('marks the suite as todo', () => {
-        let [s] = captureRegistration(() => describe.todo('suite'));
-        assert.equal(s.todo, true);
-    });
-    it('registers with no tests', () => {
-        let [s] = captureRegistration(() => describe.todo('suite'));
-        assert.equal(s.tests.length, 0);
-    });
-});
-// ── it ────────────────────────────────────────────────────────────────────────
-describe('it', () => {
-    it('has skip, only, and todo sub-functions', () => {
-        assert.equal(typeof it.skip, 'function');
-        assert.equal(typeof it.only, 'function');
-        assert.equal(typeof it.todo, 'function');
-    });
-    it('can be called outside describe (registers on implicit root suite)', () => {
-        let fn = () => { };
-        let captured = captureRegistration(() => it('orphan', fn));
-        let root = captured.find((s) => s.name === '');
-        assert.equal(root?.tests.some((t) => t.fn === fn), true);
-    });
-    it('registers a test with the given name and fn', () => {
-        let fn = () => { };
-        let [s] = captureRegistration(() => describe('suite', () => {
-            it('my test', fn);
-        }));
-        assert.equal(s.tests[0].name, 'my test');
-        assert.equal(s.tests[0].fn, fn);
-    });
-});
-describe('it.skip', () => {
-    it('marks the test as skipped', () => {
-        let [s] = captureRegistration(() => describe('suite', () => {
-            it.skip('skipped test', () => { });
-        }));
-        assert.equal(s.tests[0].skip, true);
-    });
-    it('accepts an optional fn', () => {
-        let [s] = captureRegistration(() => describe('suite', () => {
-            it.skip('no fn');
-        }));
-        assert.equal(s.tests[0].skip, true);
-        assert.equal(typeof s.tests[0].fn, 'function');
-    });
-});
-describe('it.only', () => {
-    it('marks the test as only', () => {
-        let [s] = captureRegistration(() => describe('suite', () => {
-            it.only('only test', () => { });
-        }));
-        assert.equal(s.tests[0].only, true);
-    });
-});
-describe('it.todo', () => {
-    it('marks the test as todo', () => {
-        let [s] = captureRegistration(() => describe('suite', () => {
-            it.todo('todo test');
-        }));
-        assert.equal(s.tests[0].todo, true);
-        assert.equal(s.tests[0].name, 'todo test');
-    });
-    it('can be called outside describe (registers on implicit root suite)', () => {
-        let captured = captureRegistration(() => it.todo('orphan'));
-        let root = captured.find((s) => s.name === '');
-        assert.equal(root?.tests[0]?.name, 'orphan');
-        assert.equal(root?.tests[0]?.todo, true);
-    });
-});
-// ── Duplicate detection ───────────────────────────────────────────────────────
-describe('duplicate detection', () => {
-    it('throws on duplicate suite name', () => {
-        let suites = globalThis.__testSuites;
-        let before = suites.length;
-        try {
-            assert.throws(() => {
-                describe('__dup-suite__', () => { });
-                describe('__dup-suite__', () => { });
-            }, /Duplicate suite name: "__dup-suite__"/);
-        }
-        finally {
-            suites.splice(before);
-        }
-    });
-    it('throws on duplicate describe.todo name', () => {
-        let suites = globalThis.__testSuites;
-        let before = suites.length;
-        try {
-            assert.throws(() => {
-                describe.todo('__dup-todo-suite__');
-                describe.todo('__dup-todo-suite__');
-            }, /Duplicate suite name: "__dup-todo-suite__"/);
-        }
-        finally {
-            suites.splice(before);
-        }
-    });
-    it('throws on duplicate test name within a suite', () => {
-        assert.throws(() => captureRegistration(() => describe('suite', () => {
-            it('same name', () => { });
-            it('same name', () => { });
-        })), /Duplicate test name: "same name" in suite "suite"/);
-    });
-    it('throws on duplicate it.todo name within a suite', () => {
-        assert.throws(() => captureRegistration(() => describe('suite', () => {
-            it.todo('same name');
-            it.todo('same name');
-        })), /Duplicate test name: "same name" in suite "suite"/);
-    });
-});
-// ── Aliases ───────────────────────────────────────────────────────────────────
-describe('suite alias', () => {
-    it('is an alias for describe', () => {
-        assert.equal(suite, describe);
-    });
-});
-describe('test alias', () => {
-    it('is an alias for it', () => {
-        assert.equal(test, it);
-    });
-});
-// ── Lifecycle hooks ───────────────────────────────────────────────────────────
-describe('lifecycle hooks', () => {
-    it('beforeEach registers on the current suite', () => {
-        let fn = () => { };
-        let [s] = captureRegistration(() => describe('suite', () => {
-            beforeEach(fn);
-        }));
-        assert.equal(s.beforeEach, fn);
-    });
-    it('afterEach registers on the current suite', () => {
-        let fn = () => { };
-        let [s] = captureRegistration(() => describe('suite', () => {
-            afterEach(fn);
-        }));
-        assert.equal(s.afterEach, fn);
-    });
-    it('beforeAll registers on the current suite', () => {
-        let fn = () => { };
-        let [s] = captureRegistration(() => describe('suite', () => {
-            beforeAll(fn);
-        }));
-        assert.equal(s.beforeAll, fn);
-    });
-    it('afterAll registers on the current suite', () => {
-        let fn = () => { };
-        let [s] = captureRegistration(() => describe('suite', () => {
-            afterAll(fn);
-        }));
-        assert.equal(s.afterAll, fn);
-    });
-    it('beforeEach can be called outside describe (registers on root hooks)', () => {
-        // Just verify it doesn't throw — root-level hooks are tested via inheritance
-        assert.doesNotThrow(() => {
-            let [s] = captureRegistration(() => {
-                beforeEach(() => { });
-                describe('suite', () => { });
-            });
-            assert.equal(typeof s.beforeEach, 'function');
-        });
-    });
-    it('afterEach can be called outside describe (registers on root hooks)', () => {
-        assert.doesNotThrow(() => {
-            let [s] = captureRegistration(() => {
-                afterEach(() => { });
-                describe('suite', () => { });
-            });
-            assert.equal(typeof s.afterEach, 'function');
-        });
-    });
-    it('beforeAll can be called outside describe (registers on root hooks)', () => {
-        assert.doesNotThrow(() => {
-            let [s] = captureRegistration(() => {
-                beforeAll(() => { });
-                describe('suite', () => { });
-            });
-            assert.equal(typeof s.beforeAll, 'function');
-        });
-    });
-    it('afterAll can be called outside describe (registers on root hooks)', () => {
-        assert.doesNotThrow(() => {
-            let [s] = captureRegistration(() => {
-                afterAll(() => { });
-                describe('suite', () => { });
-            });
-            assert.equal(typeof s.afterAll, 'function');
-        });
-    });
-});
-describe('Example Test Suite', () => {
-    it('passes basic equality', () => {
-        assert.equal(1 + 1, 2);
-    });
-    it('passes deep equality', () => {
-        assert.deepEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
-    });
-    it('can test async code', async () => {
-        let result = await Promise.resolve(42);
-        assert.equal(result, 42);
-    });
-    it('can assert throws', () => {
-        assert.throws(() => {
-            throw new Error('test error');
-        }, /test error/);
-    });
-    it.skip('skip: can skip tests', () => {
-        assert.equal(true, false);
-    });
-    it.todo('todo: can mark tests as todo');
-});
-describe.skip('skip: Skipped Test Suite', () => {
-    it('would fail', () => {
-        assert.equal(true, false);
-    });
-});
-describe.todo('todo: Test Suite');

package/dist/lib/utils.d.ts

@@ -1,16 +0,0 @@
-export type Counts = {
-    passed: number;
-    failed: number;
-    skipped: number;
-    todo: number;
-};
-export declare const colors: {
-    reset: string;
-    dim: (s: string) => string;
-    green: (s: string) => string;
-    red: (s: string) => string;
-    cyan: (s: string) => string;
-    yellow: (s: string) => string;
-};
-export declare function normalizeLine(line: string): string;
-//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAID,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAA;AAcD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASlD"}

package/src/lib/e2e-server.ts

@@ -1,28 +0,0 @@
-import * as http from 'node:http'
-import { createRequestListener } from '@remix-run/node-fetch-server'
-
-export interface CreateServerFunction {
-  (handler: (req: Request) => Promise<Response>): Promise<{
-    baseUrl: string
-    close(): Promise<void>
-  }>
-}
-
-export function createServer(handler: (req: Request) => Promise<Response>): Promise<{
-  baseUrl: string
-  close(): Promise<void>
-}> {
-  return new Promise((resolve, reject) => {
-    let server = http.createServer(createRequestListener(handler))
-
-    server.listen(0, '127.0.0.1', () => {
-      let addr = server.address() as { port: number }
-      resolve({
-        baseUrl: `http://127.0.0.1:${addr.port}`,
-        close: () => new Promise((r, rj) => server.close((e) => (e ? rj(e) : r()))),
-      })
-    })
-
-    server.on('error', reject)
-  })
-}