@aerokit/sdk 14.0.0 → 14.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerokit/sdk",
-  "version": "14.0.0",
+  "version": "14.1.1",
   "description": "Unified TypeScript SDK for modern cloud platforms.",
   "scripts": {
     "clean": "rm -rf dist",
@@ -29,6 +29,7 @@
   },
   "files": [
     "dist",
+    "test",
     "LICENSE",
     "README.md",
     "package.json"
@@ -42,6 +43,8 @@
       "require": "./dist/cjs/index.js",
       "types": "./dist/dts/index.d.ts"
     },
+    "./test": "./test/index.js",
+    "./test/fixtures": "./test/fixtures.js",
     "./*": {
       "import": "./dist/esm/*/index.mjs",
       "require": "./dist/cjs/*/index.js",
@@ -54,5 +57,13 @@
         "dist/dts/*/index.d.ts"
       ]
     }
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.45"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    }
   }
 }

package/test/api.js

@@ -0,0 +1,31 @@
+// Thin REST client over the generated Java controllers described by the manifest.
+export function makeApi(request, manifest) {
+  const url = (entity, suffix = '') => manifest.restBase + entity.api + suffix;
+
+  async function asJson(response) {
+    if (!response.ok()) {
+      // APIResponse has no request(); report url + status + body
+      throw new Error(`${response.url()} -> ${response.status()} ${await response.text()}`);
+    }
+    const text = await response.text();
+    return text ? JSON.parse(text) : undefined;
+  }
+
+  return {
+    list: (entity, limit = 20) => request.get(url(entity, `?$limit=${limit}`)).then(asJson),
+    // absolute controller path (a cross-model relation target owned by another module)
+    listPath: (path, limit = 20) => request.get(`${path}?$limit=${limit}`).then(asJson),
+    getPath: (path) => request.get(path).then(asJson),
+    count: (entity) => request.get(url(entity, '/count')).then(asJson).then((body) => (typeof body === 'number' ? body : body.count)),
+    get: (entity, id) => request.get(url(entity, '/' + id)).then(asJson),
+    getResponse: (entity, id) => request.get(url(entity, '/' + id)),
+    create: (entity, data) => request.post(url(entity), { data }).then(asJson),
+    update: (entity, id, data) => request.put(url(entity, '/' + id), { data }).then(asJson),
+    remove: async (entity, id) => {
+      const response = await request.delete(url(entity, '/' + id));
+      if (!response.ok()) {
+        throw new Error(`DELETE ${response.url()} -> ${response.status()} ${await response.text()}`);
+      }
+    },
+  };
+}

package/test/env.js

@@ -0,0 +1,3 @@
+export const BASE_URL = process.env.BASE_URL ?? 'http://localhost:8080';
+export const USERNAME = process.env.APPTEST_USERNAME ?? 'admin';
+export const PASSWORD = process.env.APPTEST_PASSWORD ?? 'admin';

package/test/fixtures.js

@@ -0,0 +1,29 @@
+import { expect, test as base } from '@playwright/test';
+import { BASE_URL } from './env.js';
+import { login } from './session.js';
+
+// Pre-authenticated Playwright test:
+// - authState: worker-scoped form login, one session per worker
+// - storageState: every page starts logged in
+// - api: an APIRequestContext carrying the same session, for REST-level checks
+export const test = base.extend({
+  authState: [
+    async ({ browser }, use) => {
+      await use(await login(browser));
+    },
+    { scope: 'worker' },
+  ],
+  storageState: async ({ authState }, use) => {
+    await use(authState);
+  },
+  api: async ({ playwright, authState }, use) => {
+    const request = await playwright.request.newContext({
+      baseURL: BASE_URL,
+      storageState: authState,
+    });
+    await use(request);
+    await request.dispose();
+  },
+});
+
+export { expect };

package/test/flows/crud.js

@@ -0,0 +1,82 @@
+import { expect, test } from '../fixtures.js';
+import { fillField, fillForm, resolveRelationSamples } from '../form.js';
+import { handleField, sampleRecord } from '../sample-values.js';
+
+// Server-side row lookup via the toolbar "Search <Entity>..." box - present on every list
+// layout (manage-list, master-detail, document) and searching the string columns server-side.
+// The per-column filter row is NOT used: its first input can belong to an FK or date column
+// (hidden or non-text), which made a blind fill hang.
+async function filterBy(page, value) {
+  await page.getByPlaceholder(/^Search /).first().fill(value);
+}
+
+function dataRow(page, text) {
+  return page.locator('tbody tr', { hasText: text });
+}
+
+export function crudFlow(manifest, entity, opts = {}) {
+  const cfg = opts.extend?.entities?.[entity.name] ?? {};
+  const skip = new Set(cfg.skip ?? []);
+  if (skip.has('crud')) return;
+  // A hierarchy entity lists as a tree, and a calendar/slots entity replaces the table page
+  // entirely - no filter row / data rows to drive the walk below; create/read/update/delete
+  // stays covered by the REST flow. Same for an entity without a string handle field (nothing
+  // searchable identifies the created row in the table).
+  if (entity.hierarchy || entity.layout === 'calendar' || entity.layout === 'slots') return;
+  if (!handleField(entity)) return;
+
+  test(`${entity.name}: create, edit and delete through the UI`, async ({ page, api }) => {
+    const record = sampleRecord(entity);
+    const handle = handleField(entity);
+    const relationSamples = await resolveRelationSamples(api, manifest, entity);
+
+    // create
+    await page.goto(manifest.standaloneShell + entity.route);
+    // exact: the empty state adds a second "New <Entity>" button that a substring match also hits
+    await page.getByRole('button', { name: 'New', exact: true }).click();
+    await expect(page).toHaveURL(/\/create$/);
+    await cfg.beforeCreate?.(page, record);
+    await fillForm(page, manifest, entity, record, relationSamples, opts);
+    await page.getByRole('button', { name: 'Create', exact: true }).click();
+    if (entity.layout === 'document') {
+      // a document create lands on the NEW record's page (line-item editing continues there);
+      // saving an edit is what returns to the list
+      await expect(page).toHaveURL(/\/edit$/);
+      await page.goto(manifest.standaloneShell + entity.route);
+    } else {
+      await expect(page).toHaveURL(new RegExp(entity.route.replace(/[#/]/g, '\\$&') + '$'));
+    }
+    await filterBy(page, record[handle.name]);
+    await expect(dataRow(page, record[handle.name])).toHaveCount(1);
+    await cfg.afterCreate?.(page, record);
+
+    // edit (via the detail pane the row selection reveals)
+    if (!skip.has('edit')) {
+      const updated = record[handle.name] + '-UPD';
+      await dataRow(page, record[handle.name]).click();
+      // exact: substring name matching would also hit e.g. a "Credit Notes" sidebar item
+      await page.getByRole('button', { name: 'Edit', exact: true }).first().click();
+      await expect(page).toHaveURL(/\/edit$/);
+      // the record loads async after the form renders - filling before the fetch completes
+      // gets overwritten by the load and Save persists the OLD value
+      await expect(page.locator('#f_' + handle.name)).toHaveValue(record[handle.name]);
+      await fillField(page, handle, updated, opts);
+      await page.getByRole('button', { name: 'Save', exact: true }).click();
+      await expect(page).toHaveURL(new RegExp(entity.route.replace(/[#/]/g, '\\$&') + '$'));
+      await filterBy(page, updated);
+      await expect(dataRow(page, updated)).toHaveCount(1);
+      record[handle.name] = updated;
+    }
+
+    // delete (detail pane trash button, then the confirm dialog)
+    if (!skip.has('delete')) {
+      await dataRow(page, record[handle.name]).click();
+      await page.getByRole('button', { name: 'Delete', exact: true }).first().click();
+      const dialog = page.locator('[x-h-dialog-overlay][data-open]');
+      await dialog.getByRole('button', { name: 'Delete', exact: true }).click();
+      await expect(dialog).toHaveCount(0);
+      await filterBy(page, record[handle.name]);
+      await expect(dataRow(page, record[handle.name])).toHaveCount(0);
+    }
+  });
+}

package/test/flows/list.js

@@ -0,0 +1,35 @@
+import { expect, test } from '../fixtures.js';
+import { labelOf } from '../sample-values.js';
+
+// The list page renders: plural title in the toolbar, then one of three bodies -
+// a tree (hierarchy entities render role=treeitem nodes, no table), the table with one
+// column header per major field, or (when the entity has no rows yet) the empty state.
+// When seed data is expected, rows/nodes must actually be there.
+export function listFlow(manifest, entity) {
+  test(`${entity.name}: list page renders the declared columns`, async ({ page }) => {
+    await page.goto(manifest.standaloneShell + entity.route);
+    await expect(page.locator('[x-h-toolbar-title]', { hasText: entity.labelPlural }).first()).toBeVisible();
+    if (entity.hierarchy) {
+      if (entity.expectSeedData) {
+        await expect(page.getByRole('treeitem').first()).toBeVisible();
+      }
+      return;
+    }
+    if (entity.layout === 'calendar' || entity.layout === 'slots') {
+      // the view family renders a calendar / slot picker instead of the table
+      await expect(page.locator('[x-h-calendar], [x-h-slot-picker]').first()).toBeVisible();
+      return;
+    }
+    // filter({ visible: true }): the empty-state markup stays in the DOM (x-show) above the
+    // table, so an unfiltered union's .first() would pick the hidden element and always fail
+    const firstHeader = page.getByRole('columnheader').filter({ visible: true }).first();
+    const emptyState = page.getByText('Get started by creating the first record').filter({ visible: true }).first();
+    await expect(firstHeader.or(emptyState).first()).toBeVisible();
+    if (entity.expectSeedData || (await firstHeader.isVisible())) {
+      for (const field of (entity.fields ?? []).filter((f) => f.major !== false && !f.primaryKey)) {
+        await expect(page.getByRole('columnheader').filter({ hasText: labelOf(field) }).first()).toBeVisible();
+      }
+      await expect(page.locator('tbody tr:visible').first()).toBeVisible();
+    }
+  });
+}

package/test/flows/multilingual.js

@@ -0,0 +1,20 @@
+import { expect, test } from '../fixtures.js';
+
+// The read-time translation overlay: switch the shared language key (what the Region &
+// Language setting writes), reload, and a known seed row shows its translated name.
+// Needs a concrete sample in the manifest: { language, base, translated }.
+export function multilingualFlow(manifest, entity) {
+  const sample = entity.multilingualSample;
+  if (!entity.multilingual || !sample) return;
+
+  test(`${entity.name}: ${sample.language} translation overlays on read`, async ({ page }) => {
+    await page.goto(manifest.standaloneShell + entity.route);
+    await expect(page.locator('[x-h-toolbar-title]', { hasText: entity.labelPlural }).first()).toBeVisible();
+    await page.evaluate((lang) => localStorage.setItem('codbex.harmonia.language', lang), sample.language);
+    await page.reload();
+    await expect(page.locator('tbody tr', { hasText: sample.translated }).first()).toBeVisible();
+    await page.evaluate(() => localStorage.setItem('codbex.harmonia.language', 'en'));
+    await page.reload();
+    await expect(page.locator('tbody tr', { hasText: sample.base }).first()).toBeVisible();
+  });
+}

package/test/flows/rest.js

@@ -0,0 +1,44 @@
+import { makeApi } from '../api.js';
+import { expect, test } from '../fixtures.js';
+import { resolveRelationSamples } from '../form.js';
+import { handleField, sampleRecord } from '../sample-values.js';
+
+// The same contract over the generated REST controllers, no browser: isolates backend
+// failures from UI failures and verifies the manifest's field names bind.
+export function restFlow(manifest, entity, opts = {}) {
+  const cfg = opts.extend?.entities?.[entity.name] ?? {};
+  if (new Set(cfg.skip ?? []).has('rest')) return;
+  const idProperty = manifest.idProperty ?? 'Id';
+
+  test(`${entity.name}: REST create, read, update and delete`, async ({ api }) => {
+    const client = makeApi(api, manifest);
+    const payload = sampleRecord(entity);
+    const handle = handleField(entity);
+    // same resolution the UI flow uses: cross-model targets via apiAbsolute, entityStatus
+    // relations left to their init: DB default
+    for (const sample of await resolveRelationSamples(api, manifest, entity)) {
+      payload[sample.relation.name] = sample.id;
+    }
+
+    const created = await client.create(entity, payload);
+    const id = created?.[idProperty];
+    expect(id, 'create response carries the generated id').toBeTruthy();
+    try {
+      const read = await client.get(entity, id);
+      expect(read[idProperty]).toBe(id);
+      // the update round-trip needs a writable string field to flip; skip it when there is none
+      if (handle) {
+        expect(read[handle.name]).toBe(payload[handle.name]);
+
+        const updatedValue = payload[handle.name] + '-UPD';
+        await client.update(entity, id, { ...read, [handle.name]: updatedValue });
+        const reread = await client.get(entity, id);
+        expect(reread[handle.name]).toBe(updatedValue);
+      }
+    } finally {
+      await client.remove(entity, id);
+    }
+    const gone = await client.getResponse(entity, id);
+    expect(gone.status()).toBe(404);
+  });
+}

package/test/flows/shell.js

@@ -0,0 +1,16 @@
+import { expect, test } from '../fixtures.js';
+
+// Shared application shell (/services/web/application/): the entity's menu item exists
+// under its nav group and opens the module SPA in the embedded iframe. Requires the
+// navigation module that defines the groups, so it is opt-in: APPTEST_SHELL=1.
+export function shellFlow(manifest, entity) {
+  test(`${entity.name}: shared shell menu item opens the module`, async ({ page }) => {
+    test.skip(!process.env.APPTEST_SHELL, 'APPTEST_SHELL=1 enables the shared shell flow');
+    await page.goto('/services/web/application/');
+    const item = page.getByText(entity.labelPlural, { exact: true }).first();
+    await expect(item).toBeVisible();
+    await item.click();
+    const app = page.frameLocator('iframe').first();
+    await expect(app.getByText(entity.labelPlural, { exact: true }).first()).toBeVisible();
+  });
+}

package/test/form.js

@@ -0,0 +1,120 @@
+import { makeApi } from './api.js';
+import { editableFields, handleField } from './sample-values.js';
+
+// Generated form controls: every field input has id="f_<Name>"; a to-one relation is a
+// Harmonia x-h-select whose input holds the value and whose options carry the label.
+export async function fillField(page, field, value, opts = {}) {
+  const custom = opts.extend?.widgets?.[field.widget];
+  if (custom) return custom(page, field, value);
+  const input = page.locator('#f_' + field.name);
+  if (field.type === 'boolean') return input.setChecked(!!value);
+  if (field.type === 'timestamp' || field.type === 'datetime') {
+    // the sample is a full ISO instant (what the REST layer binds); a datetime-local input
+    // takes the zone-less YYYY-MM-DDTHH:mm prefix
+    return input.fill(String(value).slice(0, 16));
+  }
+  await input.fill(String(value));
+}
+
+// The x-h-select directive hides its input and builds a span[role=combobox] trigger
+// labelled by the field label; options carry role=option.
+export async function pickDropdown(page, relation, optionText) {
+  // Anchored prefix match: the combobox accessible name is the label plus the placeholder or
+  // selected value ("Country Select a Country..."), so exact matching finds nothing - while a
+  // bare substring match collides with longer sibling labels ("Type" also hits "Chart Type").
+  const label = relation.label ?? relation.name;
+  const anchored = new RegExp('^' + label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
+  await page.getByRole('combobox', { name: anchored }).first().click();
+  const option = page.getByRole('option', { name: optionText }).first();
+  try {
+    await option.click({ timeout: 10_000 });
+  } catch {
+    // the option list re-rendered mid-click (async option load reflow) - reopen and retry
+    await page.getByRole('combobox', { name: anchored }).first().click();
+    await option.click({ force: true });
+  }
+}
+
+// Resolve a live option for each to-one relation: take the first suitable row of the
+// target entity and use its label field's value as the visible option text.
+// - an entityStatus relation is skipped: it renders as a status pill (not an editable
+//   input in any form) and its value comes from the init: DB default;
+// - a cross-model relation's rows come from its apiAbsolute controller URL (the target
+//   lives in another module and is not in this manifest);
+// - a where: option filter narrows the candidate rows to matching ones;
+// - a dependsOn cascade forces CONSISTENT samples: the dependent row is chosen first and
+//   its filterBy FK becomes the trigger sibling's sample (independent first rows would
+//   pick e.g. Country=Afghanistan + City=Sofia, and the cascade then offers no options).
+export async function resolveRelationSamples(request, manifest, entity) {
+  const api = makeApi(request, manifest);
+  const idProperty = manifest.idProperty ?? 'Id';
+
+  async function fetchRows(relation, limit) {
+    if (relation.apiAbsolute) return { rows: await api.listPath(relation.apiAbsolute, limit), labelFrom: relation.labelFrom ?? 'Name' };
+    if (relation.api) return { rows: await api.listPath(manifest.restBase + relation.api, limit), labelFrom: relation.labelFrom ?? 'Name' };
+    const target = manifest.entities.find((e) => e.name === relation.to);
+    if (!target) throw new Error(`Relation ${entity.name}.${relation.name}: target ${relation.to} not in manifest`);
+    return { rows: await api.list(target, limit), labelFrom: relation.labelFrom ?? handleField(target)?.name ?? 'Name' };
+  }
+
+  const samples = [];
+  for (const relation of entity.relations ?? []) {
+    if (relation.entityStatus) continue;
+    // a filtered picker needs a matching candidate, so fetch a page and filter client-side
+    const wide = relation.where || relation.leafOnly;
+    const { rows: fetched, labelFrom } = await fetchRows(relation, wide ? 200 : 1);
+    let rows = relation.where ? fetched?.filter((r) => String(r[relation.where.by]) === String(relation.where.value)) : fetched;
+    if (relation.leafOnly && rows?.length) {
+      // the generated validation rejects a non-leaf target - pick a row no other row parents
+      const prop = relation.leafOnly.hierarchyProperty;
+      const idProp = manifest.idProperty ?? 'Id';
+      rows = rows.filter((row) => !fetched.some((other) => other[prop] === row[idProp]));
+    }
+    if (!rows?.length) {
+      // a required FK cannot be satisfied - fail loudly; an optional one is simply left unset
+      if (relation.required) throw new Error(`Relation ${entity.name}.${relation.name}: no ${relation.to} rows to pick from`);
+      continue;
+    }
+    const label = rows[0][labelFrom];
+    if (label == null && !relation.required) {
+      // no display label to pick by (the target has no name-like field) - leave the optional
+      // relation unset rather than clicking blind
+      continue;
+    }
+    samples.push({
+      relation,
+      row: rows[0],
+      id: rows[0][idProperty],
+      label: label ?? String(rows[0][idProperty]),
+    });
+  }
+
+  // cascade consistency: re-point each dependsOn trigger at the row the dependent's choice implies
+  for (const sample of samples) {
+    const dependsOn = sample.relation.dependsOn;
+    if (!dependsOn?.filterBy) continue;
+    const trigger = samples.find((s) => s.relation.name === dependsOn.relation);
+    const impliedId = sample.row[dependsOn.filterBy];
+    if (!trigger || impliedId == null || trigger.id === impliedId) continue;
+    const path = trigger.relation.apiAbsolute ?? (trigger.relation.api ? manifest.restBase + trigger.relation.api : null);
+    if (!path) continue;
+    const row = await api.getPath(`${path}/${impliedId}`);
+    if (!row) continue;
+    trigger.row = row;
+    trigger.id = impliedId;
+    trigger.label = row[trigger.relation.labelFrom ?? 'Name'];
+  }
+  return samples;
+}
+
+export async function fillForm(page, manifest, entity, record, relationSamples, opts = {}) {
+  for (const field of editableFields(entity)) {
+    if (record[field.name] === undefined) continue;
+    await fillField(page, field, record[field.name], opts);
+  }
+  // cascade order: a dependsOn trigger must be picked BEFORE its dependent, so the narrowed
+  // option list is the one the dependent's sample was chosen from
+  const triggers = relationSamples.filter((s) => !s.relation.dependsOn);
+  const dependents = relationSamples.filter((s) => s.relation.dependsOn);
+  for (const sample of [...triggers, ...dependents]) await pickDropdown(page, sample.relation, sample.label);
+}

package/test/index.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import { test } from './fixtures.js';
+import { crudFlow } from './flows/crud.js';
+import { listFlow } from './flows/list.js';
+import { multilingualFlow } from './flows/multilingual.js';
+import { restFlow } from './flows/rest.js';
+import { shellFlow } from './flows/shell.js';
+
+// Entry point: execute a module's generated <name>.test manifest. Accepts the parsed
+// manifest object or a path to the file. opts.extend hosts the custom-UI hooks (widget
+// fillers, per-entity skip lists, before/afterCreate).
+export function runTest(manifestRef, opts = {}) {
+  const manifest = typeof manifestRef === 'string' ? JSON.parse(fs.readFileSync(manifestRef, 'utf8')) : manifestRef;
+  for (const entity of manifest.entities ?? []) {
+    test.describe(`${manifest.module} / ${entity.name}`, () => {
+      listFlow(manifest, entity, opts);
+      crudFlow(manifest, entity, opts);
+      restFlow(manifest, entity, opts);
+      multilingualFlow(manifest, entity, opts);
+      shellFlow(manifest, entity, opts);
+    });
+  }
+}
+
+// Deprecated alias - the pre-subpath name; use runTest.
+export const runAppTest = runTest;

package/test/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/test/sample-values.js

@@ -0,0 +1,67 @@
+const ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const DIGITS = '0123456789';
+
+function rand(chars, n) {
+  let out = '';
+  for (let i = 0; i < n; i++) out += chars[Math.floor(Math.random() * chars.length)];
+  return out;
+}
+
+// Type-aware sample value for one field. Long strings carry the APPTEST- prefix (the
+// cleanup marker and the searchable handle); short strings always contain a digit so
+// they can never collide with letter-only nomenclature seeds (ISO codes etc.).
+export function sampleValue(field) {
+  switch (field.type) {
+    case 'string': {
+      const len = field.length ?? 64;
+      if (len >= 16) return 'APPTEST-' + rand(ALPHA + DIGITS, 6);
+      return rand(ALPHA, Math.max(1, len - 1)) + rand(DIGITS, 1);
+    }
+    case 'integer':
+    case 'bigint':
+      return 7;
+    case 'decimal':
+    case 'double':
+      return 3.14;
+    case 'boolean':
+      return true;
+    case 'date':
+      return '2026-07-08';
+    case 'timestamp':
+    case 'datetime':
+      // full ISO instant: the generated Java entities bind java.time.Instant, which rejects a
+      // zone-less value; the UI fill slices this to the datetime-local shape
+      return '2026-07-08T10:00:00Z';
+    default:
+      return 'APPTEST-' + rand(ALPHA + DIGITS, 6);
+  }
+}
+
+export function editableFields(entity) {
+  return (entity.fields ?? []).filter((f) => !f.readOnly && !f.primaryKey && !f.generated);
+}
+
+// One sample record for the entity's own fields (relations are resolved separately,
+// against live target rows).
+export function sampleRecord(entity) {
+  const record = {};
+  for (const field of editableFields(entity)) record[field.name] = sampleValue(field);
+  // an exactlyOne check rejects a record where more than one of the named fields is set -
+  // keep only the first of each declared set
+  for (const set of entity.exactlyOne ?? []) {
+    for (const name of set.slice(1)) delete record[name];
+  }
+  return record;
+}
+
+// The searchable "handle" field: the first long string field shown in the list. Its
+// value identifies the record in the table across the create/edit/delete flow.
+// Null when the entity has no such field (all-numeric/date entities) - flows degrade:
+// the UI walk is skipped and the REST flow drops its update-value assertion.
+export function handleField(entity) {
+  return editableFields(entity).find((f) => f.type === 'string' && (f.length ?? 64) >= 16 && f.major !== false) ?? null;
+}
+
+export function labelOf(field) {
+  return field.label ?? field.name;
+}

package/test/session.js

@@ -0,0 +1,19 @@
+import { BASE_URL, PASSWORD, USERNAME } from './env.js';
+
+// Dirigible uses form login (basic auth is not accepted by the login flow). Logs in once
+// per worker and returns a storageState (session cookie) reused by every test and by the
+// REST client.
+export async function login(browser) {
+  const context = await browser.newContext({ baseURL: BASE_URL });
+  const page = await context.newPage();
+  await page.goto('/login');
+  await page.fill('input[name="username"]', USERNAME);
+  await page.fill('input[name="password"]', PASSWORD);
+  await Promise.all([
+    page.waitForURL((url) => !url.pathname.includes('/login')),
+    page.click('button[type="submit"]'),
+  ]);
+  const state = await context.storageState();
+  await context.close();
+  return state;
+}