app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

bootstrap.spec.ts (7958B)


      1 import { test, expect } from '@playwright/test';
      2 import { createRelayHarness } from '../integration/harness/relay.ts';
      3 import { createStaticHarness } from '../integration/harness/static.ts';
      4 import { installControlledProvider } from './harness/provider.ts';
      5 
      6 test('copied nested navigation and refresh boot the real shell without fabricating a product', async ({
      7   browser
      8 }) => {
      9   const server = await createStaticHarness();
     10   const context = await browser.newContext();
     11   const withoutJavaScript = await browser.newContext({
     12     javaScriptEnabled: false
     13   });
     14   try {
     15     for (const owned of [context, withoutJavaScript]) {
     16       await owned.route('**/*', (route) =>
     17         new URL(route.request().url()).origin === server.url
     18           ? route.continue()
     19           : route.abort()
     20       );
     21     }
     22     const copiedPath = '/products/unsupported-coordinate';
     23     const staticPage = await withoutJavaScript.newPage();
     24     await staticPage.goto(server.url);
     25     await expect(
     26       staticPage.getByRole('link', { name: 'HarvestCircle', exact: true })
     27     ).toBeVisible();
     28     await expect(staticPage).toHaveTitle('HarvestCircle');
     29     const fallback = await staticPage.goto(server.url + copiedPath);
     30     expect(fallback?.status()).toBe(200);
     31     // The separate SPA document has no prerendered product or browser state.
     32     await expect(
     33       staticPage.getByRole('link', { name: 'HarvestCircle', exact: true })
     34     ).toHaveCount(0);
     35 
     36     const page = await context.newPage();
     37     const failures: string[] = [];
     38     page.on('pageerror', (error) => failures.push(error.message));
     39     for (const navigate of [
     40       () => page.goto(server.url + copiedPath),
     41       () => page.reload()
     42     ]) {
     43       const result = await navigate();
     44       expect(result?.status()).toBe(200);
     45       await expect(
     46         page.getByRole('link', { name: 'HarvestCircle', exact: true })
     47       ).toBeVisible();
     48       // Future product route controllers remain unimplemented in this slice.
     49       await expect(
     50         page.getByRole('heading', { name: '404', exact: true })
     51       ).toBeVisible();
     52       await expect(page.getByText('Not Found', { exact: true })).toBeVisible();
     53       expect(new URL(page.url()).pathname).toBe(copiedPath);
     54       expect(await page.evaluate(() => 'nostr' in window)).toBe(false);
     55     }
     56     expect(failures).toEqual([]);
     57     for (const asset of ['/missing.js', '/missing.css', '/_app/missing.png']) {
     58       const response = await context.request.get(server.url + asset, {
     59         headers: { accept: 'text/html' }
     60       });
     61       expect(response.status()).toBe(404);
     62       expect(await response.text()).toBe('');
     63     }
     64   } finally {
     65     await context.close();
     66     await withoutJavaScript.close();
     67     await server.close();
     68   }
     69   expect(context.pages()).toHaveLength(0);
     70   expect(withoutJavaScript.pages()).toHaveLength(0);
     71   expect(server.state()).toEqual({ listening: false, childProcesses: 0 });
     72 });
     73 
     74 test('actual browser loads guest shell without an extension', async ({
     75   browser
     76 }) => {
     77   const server = await createStaticHarness();
     78   const context = await browser.newContext();
     79   try {
     80     await context.route('**/*', (route) =>
     81       new URL(route.request().url()).origin === server.url
     82         ? route.continue()
     83         : route.abort()
     84     );
     85     const page = await context.newPage();
     86     await page.goto(server.url);
     87     await expect(
     88       page.getByRole('link', { name: 'HarvestCircle', exact: true })
     89     ).toBeVisible();
     90     await expect(page).toHaveTitle('HarvestCircle');
     91     const query = page.getByRole('textbox', {
     92       name: 'What are you looking for?'
     93     });
     94     await expect(query).toHaveCount(1);
     95     await expect(query).toHaveAttribute('rows', '2');
     96     await expect(
     97       page.getByText('For example, carrots or carrots Victoria.')
     98     ).toBeVisible();
     99     await expect(
    100       page.getByRole('button', { name: 'Search', exact: true })
    101     ).toBeEnabled();
    102     await expect(
    103       page.getByText('Search is unavailable during development.')
    104     ).toHaveCount(0);
    105     await query.fill('carrots');
    106     await query.press('Enter');
    107     await expect(query).toHaveValue('carrots\n');
    108     await page.locator('form').evaluate((form) => {
    109       const event = new SubmitEvent('submit', {
    110         bubbles: true,
    111         cancelable: true
    112       });
    113       if (form.dispatchEvent(event))
    114         throw new Error('Native search submit was not prevented');
    115     });
    116     await expect(page).toHaveURL(server.url + '/search?q=carrots');
    117     await page.goto(server.url);
    118     // Start the existing skip-link keyboard check from the document again.
    119     await page.reload();
    120     await expect(page.getByRole('main')).toHaveCount(1);
    121     await expect(
    122       page.getByRole('navigation', { name: 'Primary', exact: true })
    123     ).toBeVisible();
    124     await expect(
    125       page.getByRole('button', { name: 'Connect extension' })
    126     ).toBeEnabled();
    127     await expect(
    128       page.getByText(
    129         'Unavailable during development: disabled navigation and actions.'
    130       )
    131     ).toHaveCount(0);
    132     await expect(
    133       page.getByRole('link', { name: 'Search', exact: true })
    134     ).toHaveCount(1);
    135     await expect(
    136       page.getByRole('link', { name: 'Messages', exact: true })
    137     ).toHaveAttribute('href', '/messages');
    138     await page.keyboard.press('Tab');
    139     await expect(
    140       page.getByRole('link', { name: 'Skip to main content' })
    141     ).toBeFocused();
    142     await page.keyboard.press('Enter');
    143     await expect(page.getByRole('main')).toBeFocused();
    144     expect(await page.evaluate(() => 'nostr' in window)).toBe(false);
    145     console.log(`Controlled browser version: ${browser.version()}`);
    146   } finally {
    147     await context.close();
    148     await server.close();
    149   }
    150   expect(context.pages()).toHaveLength(0);
    151   expect(server.state()).toEqual({ listening: false, childProcesses: 0 });
    152 });
    153 
    154 test('controlled provider and actual loopback socket are isolated and torn down', async ({
    155   browser
    156 }) => {
    157   const server = await createStaticHarness();
    158   const relay = await createRelayHarness();
    159   const context = await browser.newContext();
    160   try {
    161     await installControlledProvider(context);
    162     await context.route('**/*', (route) =>
    163       new URL(route.request().url()).origin === server.url
    164         ? route.continue()
    165         : route.abort()
    166     );
    167     const page = await context.newPage();
    168     await page.goto(server.url);
    169     await expect(
    170       page.getByRole('link', { name: 'HarvestCircle', exact: true })
    171     ).toBeVisible();
    172     const result = await page.evaluate(async (url) => {
    173       const provider = (
    174         window as unknown as {
    175           nostr: {
    176             fixture: string;
    177             getPublicKey(): Promise<string>;
    178             signEvent(): Promise<never>;
    179           };
    180         }
    181       ).nostr;
    182       let signingRejected = false;
    183       try {
    184         await provider.signEvent();
    185       } catch {
    186         signingRejected = true;
    187       }
    188       const reply = await new Promise<string>((resolve, reject) => {
    189         const socket = new WebSocket(url);
    190         socket.onopen = () =>
    191           socket.send(JSON.stringify(['REQ', 'browser', {}]));
    192         socket.onmessage = (event: MessageEvent<string>) => resolve(event.data);
    193         socket.onerror = () => reject(new Error('Loopback socket failed'));
    194       });
    195       return {
    196         fixture: provider.fixture,
    197         publicKey: await provider.getPublicKey(),
    198         signingRejected,
    199         reply
    200       };
    201     }, relay.url);
    202     expect(result).toEqual({
    203       fixture: 'HC_TEST_ONLY_PROVIDER',
    204       publicKey: '11'.repeat(32),
    205       signingRejected: true,
    206       reply: '["EOSE","browser"]'
    207     });
    208     expect(relay.state().subscriptions).toBe(1);
    209   } finally {
    210     await context.close();
    211     await relay.close();
    212     await server.close();
    213   }
    214   expect(context.pages()).toHaveLength(0);
    215   expect(relay.state()).toEqual({
    216     listening: false,
    217     connections: 0,
    218     subscriptions: 0,
    219     childProcesses: 0
    220   });
    221   expect(server.state()).toEqual({ listening: false, childProcesses: 0 });
    222 });