@webship.co/workspace 1.0.0-beta1 → 1.0.0-beta2

package/core/workspace-app/tests/unit/ddev-mail.test.js

@@ -0,0 +1,135 @@
+/**
+ * Managing a project's captured mail, not just linking to it.
+ *
+ * DDEV captures outgoing email instead of delivering it, so Mailpit is where every password reset,
+ * webform notification and cron warning actually went. A link got you there; the things you do
+ * repeatedly — is the mail I just triggered there, who was it addressed to, clear this out before the
+ * next run — belong on the row.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const mail = require('../../ddev-mail');
+
+const APP = path.join(__dirname, '../..');
+const server = fs.readFileSync(path.join(APP, 'server.js'), 'utf8');
+const page = fs.readFileSync(path.join(APP, 'ddev-mail-page.js'), 'utf8');
+const actions = fs.readFileSync(path.join(APP, 'actions/ddev-mail.js'), 'utf8');
+const mod = fs.readFileSync(path.join(APP, 'ddev-mail.js'), 'utf8');
+
+test('a write answers `ok` in plain text, and that is a success', () => {
+  // Found by deleting a real message: Mailpit answers reads with JSON and writes with the word `ok`,
+  // so parsing everything as JSON reported "Unexpected token 'o'" for a delete that had WORKED — the
+  // message gone and an error on the screen, which is the worst of both.
+  assert.match(mod, /if \(!\/\^\[\[\{\]\/\.test\(text\)\) return \{ ok: true, data: text \};/);
+  assert.match(mod, /Mailpit sent something this could not read/, 'and malformed JSON is still a failure');
+});
+
+test('an unreachable Mailpit is not an empty mailbox', () => {
+  // The distinction the whole panel rests on: "no mail" would send somebody looking for a bug in
+  // their site, when the truth is the project is stopped. Verified live against a hostname that does
+  // not resolve.
+  assert.match(mod, /AbortError' \? 'Mailpit did not answer in time'/);
+  assert.match(page, /Mailpit is not answering/);
+  assert.match(page, /This is not the same as\s*\n?\s*an empty mailbox/);
+});
+
+test('every call is bounded', () => {
+  // A stopped project must not hang the panel: the fetch carries an abort signal, not a hope.
+  assert.match(mod, /const MAIL_TIMEOUT_MS = \d+;/);
+  assert.match(mod, /new AbortController\(\)/);
+  assert.match(mod, /signal: controller\.signal/);
+  assert.match(mod, /clearTimeout\(timer\)/);
+});
+
+test('a message id is checked before it is used', () => {
+  for (const good of ['6KkYd2wXXZBR9COLnVTj29', '3s1V4blfdr7oNTtblQ27qO']) {
+    assert.ok(mail.MAIL_ID_RE.test(good), good);
+  }
+  for (const bad of ['../../etc', 'a b', '', 'short', '<script>', 'x'.repeat(65)]) {
+    assert.equal(mail.MAIL_ID_RE.test(bad), false, bad);
+  }
+  assert.match(actions, /if \(!mail\.MAIL_ID_RE\.test\(id\)\)/);
+});
+
+test('the URL rides along with the status refresh, https first', () => {
+  // No extra call per row: the listing that answers "is it running" answers this too, and https is
+  // the same service on the other port with the certificate DDEV issued. (This and the two tests
+  // below were tests/unit/ddev-mailpit.test.js, which described the wiring before it moved into the
+  // module — the assertions kept, the file folded in.)
+  assert.match(page, /urlFromListing = \(row\) => String\(\(row && \(row\.mailpit_https_url \|\| row\.mailpit_url\)\) \|\| ''\)/);
+  assert.match(server, /mailpit: ddevMail\.urlFromListing\(p\)/);
+});
+
+test('it is only offered while the project is up', () => {
+  // DDEV reports a Mailpit URL for stopped projects too — 51 of them here — but the service only
+  // answers while the containers are running, so an entry on a stopped row leads nowhere.
+  assert.match(page, /if \(!running \|\| !mailpit\) return '';/);
+  assert.match(page, /entry && entry\.status === 'running'/);
+});
+
+test('the label says captured, not sent', () => {
+  // The distinction is the whole point: nothing left the machine, and that is why the mail is
+  // findable at all.
+  assert.match(page, /Every mail this project sends is captured rather than delivered/);
+  assert.match(page, /Mail it captured \(Mailpit\)…/);
+});
+
+test('the mailbox is found from the status listing, never from the request', () => {
+  // A URL in a form would let a request point this at anything; the row's own listing is the only
+  // source, and only while the project is running.
+  assert.match(page, /entry\.status === 'running' \? \(entry\.mailpit \|\| ''\) : ''/);
+  assert.match(actions, /const base = await deps\.mailpitFor\(workspace, projectName\);/);
+  assert.ok(!/form\.base|form\.mailpit|form\.url/.test(actions), 'no URL is ever read from the form');
+});
+
+test('the lookup awaits the status map rather than reading whatever is in memory', () => {
+  // Straight after a restart the cache is empty for a second or two, and a synchronous read answered
+  // "this project has no Mailpit — is it running?" about a project that was running perfectly well.
+  // Reproduced, then fixed by awaiting the dashboard's own getter, which refreshes a cold cache.
+  assert.match(page, /return async \(workspace, project\) => \{/);
+  assert.match(page, /const st = \(await statusMap\(\)\) \|\| \{\};/);
+  assert.match(server, /mailpitFor\(ddevStatusMap\)/, 'and the getter it is given is the refreshing one');
+});
+
+test('the feature owns its wiring: server.js holds four lines and no markup', () => {
+  // One module per area, and "area" includes the route and the menu entry — not just the rendering.
+  // Otherwise every new column or verb is another edit to a 7,000-line file.
+  const mailLines = server.split('\n')
+    .filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l))
+    .filter((l) => /ddevMail|mailpit/i.test(l));
+  assert.ok(mailLines.length <= 8, `server.js wires mail on ${mailLines.length} lines:\n${mailLines.join('\n')}`);
+  assert.ok(!mailLines.some((l) => /<li>|<a |hx-get="\/fragments\/projects\/mail/.test(l)),
+    'no mail markup in server.js');
+  // Each of the four is a call into the module.
+  assert.match(server, /const ddevMail = require\('\.\/ddev-mail-page'\);/);
+  assert.match(server, /mailpit: ddevMail\.urlFromListing\(p\)/);
+  assert.match(server, /\$\{ddevMail\.menuItemHtml\(\{ workspace: key, project: p, running, mailpit \}\)\}/);
+  assert.match(server, /if \(await ddevMail\.handleFragment\(\{/);
+  // And the module answers "not mine" rather than the server matching the path for it.
+  assert.match(page, /if \(!m \|\| !isValidWorkspace\(m\[1\]\) \|\| !NAME_RE\.test\(m\[2\]\)\) return false;/);
+});
+
+test('deleting and emptying are confirmed, and each answers with the panel', () => {
+  // A delete that leaves the list showing what it deleted is a control you have to refresh to
+  // believe — so every verb answers with the panel rather than a toast.
+  assert.match(actions, /if \(form\.confirm !== 'yes'\) return send\('<div class="msg error">Deleting a message needs confirmation/);
+  assert.match(actions, /Emptying the mailbox needs confirmation/);
+  assert.match(actions, /return send\(await panel\(workspace, c\.projectName, c\.base\)\);/);
+  assert.match(page, /hx-trigger="confirmed-remove"/);
+  assert.match(page, /hx-target="#editor-modal-body"/);
+});
+
+test('the panel says what a message is, and leaves reading it to Mailpit', () => {
+  // Subject, who it was really for, when and how big — then out to Mailpit, which renders HTML mail
+  // and attachments far better than this panel would.
+  assert.match(page, /mail-subject/);
+  assert.match(page, /mail\.messageUrl\(base, m\.id\)/);
+  assert.match(page, /Open Mailpit/);
+  assert.match(page, /Nothing here has left\s*\n?\s*the machine/);
+  // An empty mailbox is stated as a fact worth having, not as a shrug.
+  assert.match(page, /The mailbox is empty/);
+});

package/core/workspace-app/tests/unit/ddev-menu-and-create.test.js

@@ -0,0 +1,28 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const root = path.join(__dirname, '..', '..');
+const read = (...p) => fs.readFileSync(path.join(root, ...p), 'utf8');
+const ui = read('public', 'ui.js');
+const css = read('public', 'css', 'components', 'ddev-menu.css');
+const server = read('server.js');
+
+test('the DDEV menu folds its groups, keeps the first and this project open, and is one column', () => {
+  assert.match(ui, /function foldDdevMenus\(root\)/);
+  assert.match(ui, /\/this project\/i\.test/);
+  assert.match(ui, /setAttribute\('aria-expanded'/);
+  assert.match(css, /\.act-menu-ddev \.ddev-nav-columns \{ column-count: 1; \}/);
+  assert.match(css, /width: 18rem/);
+});
+
+test('a menu opened in the project list is drawn above the assistant and under the top bar', () => {
+  assert.match(css, /#webship-workspace-projects:has\(\.uk-dropdown\.uk-open\) \{ position: relative; z-index: 35; \}/);
+});
+
+test('each workspace offers its create actions in its card, from the same entries as the rail', () => {
+  assert.match(server, /What would you like to create\?/);
+  assert.match(server, /pageActionGroups\(`workspace:\$\{key\}`\)\.find\(\(g\) => g\.id === 'create'\)/);
+  assert.doesNotMatch(read('public', 'css', 'components', 'create-card.css'), /#[0-9a-fA-F]{3,8}\b/);
+});

package/core/workspace-app/tests/unit/ddev-mutagen.test.js

@@ -0,0 +1,37 @@
+/**
+ * Mutagen beyond `sync`.
+ *
+ * The menu could ask for a sync and nothing else — so a project that felt slow or stale left you with
+ * no way to ask whether the sync was BEHIND or BROKEN, and no way to repair it.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const APP = path.join(__dirname, '../..');
+const ddev = fs.readFileSync(path.join(APP, 'ddev.js'), 'utf8');
+const actions = fs.readFileSync(path.join(APP, 'actions/ddev.js'), 'utf8');
+const server = fs.readFileSync(path.join(APP, 'server.js'), 'utf8');
+
+test('status reads, and is not gated', () => {
+  assert.match(ddev, /'\/actions\/ddev-mutagen-status':[^\n]*args: \['mutagen', 'status'\]/);
+  const line = ddev.match(/'\/actions\/ddev-mutagen-status':[^\n]*/)[0];
+  assert.ok(!line.includes('destructive'));
+  // It answers "Mutagen is not enabled on project X" too, which is worth knowing before anybody
+  // blames the sync for something else.
+  assert.match(actions, /'\/actions\/ddev-mutagen-status': ddev_verb,/);
+});
+
+test('reset asks first, and says what it really does', () => {
+  // It STOPS THE PROJECT and removes the volume. That is not a thing to click while somebody is
+  // working, and "destroys data" would have been the wrong reason to give: the files on disk are the
+  // source, and the volume is rebuilt on the next start.
+  assert.match(ddev, /'\/actions\/ddev-mutagen-reset':[^\n]*destructive: true/);
+  assert.match(ddev, /confirmWhy: 'stops the project and removes its sync volume'/);
+  assert.match(server, /Reset the sync…/);
+  assert.match(server, /the volume is rebuilt on the next start/);
+  const item = server.slice(server.indexOf('/actions/ddev-mutagen-reset'));
+  assert.match(item.slice(0, 300), /hx-trigger="confirmed-remove"/);
+});

package/core/workspace-app/tests/unit/ddev-options.test.js

@@ -0,0 +1,51 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const o = require('../../ddev-options');
+
+test('every project type in the DDEV docs is offered, and nothing else', () => {
+  const docs = ['asterios', 'backdrop', 'cakephp', 'codeigniter', 'craftcms', 'drupal', 'drupal6', 'drupal7', 'drupal8', 'drupal9',
+    'drupal10', 'drupal11', 'drupal12', 'generic', 'joomla', 'laravel', 'magento', 'magento2', 'maho', 'modx', 'php',
+    'shopware6', 'silverstripe', 'symfony', 'typo3', 'wordpress', 'wp-bedrock'];
+  assert.deepEqual([...o.PROJECT_TYPES].sort(), [...docs].sort());
+});
+
+test('PHP 5.6 to 8.5, and the database versions the docs list', () => {
+  assert.ok(o.PHP_VERSIONS.includes('5.6') && o.PHP_VERSIONS.includes('8.5'));
+  for (const db of ['mariadb:11.8', 'mariadb:12.3', 'mariadb:10.11', 'mysql:8.4', 'mysql:9.7', 'postgres:9', 'postgres:18']) {
+    assert.ok(o.DATABASES.includes(db), db);
+  }
+  assert.ok(!o.DATABASES.includes('mariadb:11.0'));
+});
+
+test('a form becomes checked flags, and anything off the lists is dropped', () => {
+  assert.deepEqual(o.configArgs({ project_type: 'typo3', docroot: 'public', php_version: '8.3', database: 'postgres:16',
+    webserver_type: 'apache-fpm', nodejs_version: 'auto', composer_version: '2.2', omit_db: '1', python: '1' }), [
+    '--project-type=typo3', '--docroot=public', '--php-version=8.3', '--database=postgres:16', '--webserver-type=apache-fpm',
+    '--nodejs-version=auto', '--composer-version=2.2', '--omit-containers=db', '--webimage-extra-packages=python3-pip,python3-venv']);
+  assert.deepEqual(o.configArgs({ project_type: 'x; rm -rf', docroot: '../etc', php_version: '__default', database: 'oracle:1' }), []);
+  assert.equal(o.shellArgs(["--docroot=it's"]), "'--docroot=it'\\''s'");
+});
+
+test('the quickstart presets only use values DDEV accepts', () => {
+  for (const p of o.PRESETS) {
+    assert.ok(o.PROJECT_TYPES.includes(p.project_type), p.id);
+    if (p.php_version) assert.ok(o.PHP_VERSIONS.includes(p.php_version), p.id);
+    if (p.database) assert.ok(o.DATABASES.includes(p.database), p.id);
+    if (p.webserver_type) assert.ok(o.WEBSERVERS.includes(p.webserver_type), p.id);
+  }
+  for (const id of ['typo3', 'laravel', 'symfony', 'craftcms', 'wagtail', 'nodejs', 'shopware6', 'joomla']) {
+    assert.ok(o.PRESETS.some((p) => p.id === id), id);
+  }
+});
+
+test('the fields start on DDEV defaults, or on what the project already uses', () => {
+  const fresh = o.fieldsHtml({ prefix: 't' });
+  assert.match(fresh, /data-ddev-preset/);
+  assert.match(fresh, /<option value="php" selected>php<\/option>/);
+  assert.match(fresh, /name="php_version"><option value="__default" selected>/);
+  const now = o.fieldsHtml({ prefix: 't', current: { project_type: 'drupal11', php_version: '8.3', omit_db: true } });
+  assert.match(now, /<option value="drupal11" selected>/);
+  assert.match(now, /<option value="8.3" selected>/);
+  assert.match(now, /name="omit_db" value="1" checked/);
+});

package/core/workspace-app/tests/unit/ddev-share.test.js

@@ -0,0 +1,40 @@
+/**
+ * Publishing a project on the internet, on purpose.
+ *
+ * `ddev share` opens a tunnel (ngrok by default) to a local project so somebody else can look at it.
+ * It is the only verb on this menu whose effect reaches people who are not on this machine — the
+ * whole site, including its admin, at an address anyone with it can use — and it runs until it is
+ * stopped rather than finishing.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const APP = path.join(__dirname, '../..');
+const ddev = fs.readFileSync(path.join(APP, 'ddev.js'), 'utf8');
+const actions = fs.readFileSync(path.join(APP, 'actions/ddev.js'), 'utf8');
+const server = fs.readFileSync(path.join(APP, 'server.js'), 'utf8');
+
+test('it asks first, and for the right reason', () => {
+  assert.match(ddev, /'\/actions\/ddev-share':[^\n]*destructive: true/);
+  assert.match(ddev, /confirmWhy: 'puts this project on the open internet'/);
+  // The gate used to say "destroys data" for everything behind it. Share destroys nothing, and a
+  // gate that misstates why it is a gate teaches people to click through it.
+  assert.match(actions, /\$\{esc\(act\.confirmWhy \|\| 'destroys data'\)\}/);
+  assert.match(server, /hx-trigger="confirmed-remove"[\s\S]{0,400}Share on the internet/);
+});
+
+test('it runs in a screen, because it does not finish', () => {
+  // The address is printed in that session, and closing a browser tab must not take somebody's demo
+  // down with it.
+  assert.match(ddev, /'\/actions\/ddev-share':[^\n]*inScreen: true/);
+  assert.match(ddev, /'\/actions\/ddev-share':[^\n]*needsRunning: true/, 'a tunnel to a stopped project shows nothing');
+  assert.match(actions, /'\/actions\/ddev-share': ddev_verb,/);
+});
+
+test('the item says what it exposes', () => {
+  assert.match(server, /Anyone with the address can reach the site, including its admin/);
+  assert.match(server, /until the session is stopped/);
+});

package/core/workspace-app/tests/unit/ddev-shim.test.js

@@ -0,0 +1,57 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const APP = path.join(__dirname, '..', '..');
+const SOURCE = path.join(APP, '..', 'scripts', 'ddev-shim', 'ddev');
+const IN_CONTEXT = path.join(APP, '.ddev', 'web-build', 'ddev-shim-ddev');
+
+test('the build-context copy is byte-identical to the source', () => {
+  // Docker cannot COPY from outside its build context, so the shim exists twice. This is
+  // the only thing stopping them drifting: edit core/scripts/ddev-shim/ddev, then
+  //   cp core/scripts/ddev-shim/ddev core/workspace-app/.ddev/web-build/ddev-shim-ddev
+  assert.equal(fs.readFileSync(IN_CONTEXT, 'utf8'), fs.readFileSync(SOURCE, 'utf8'),
+    'the shim in .ddev/web-build differs from core/scripts/ddev-shim/ddev — copy it across');
+});
+
+test('the shim is valid bash', () => {
+  // A broken shim breaks EVERY ddev call in the container, the dashboard's own status
+  // reads included, and it is not exercised by any other test.
+  execFileSync('bash', ['-n', SOURCE]);
+});
+
+test('it never resolves the real ddev through PATH', () => {
+  // Resolving by PATH would find the shim again and fork until the machine gives up.
+  const src = fs.readFileSync(SOURCE, 'utf8');
+  assert.ok(!/command -v ddev|which ddev/.test(src), 'resolves ddev through PATH — that recurses');
+  assert.match(src, /for candidate in \/usr\/local\/bin\/ddev/, 'no absolute-path candidate list');
+  assert.match(src, /== "\$\{SELF\}" \]\] |== "\$\{SELF\}" \] && continue/, 'does not exclude itself from the candidates');
+});
+
+test('exactly the router-mutating verbs are locked', () => {
+  const src = fs.readFileSync(SOURCE, 'utf8');
+  assert.match(src, /^\s*start\|stop\|restart\|poweroff\|delete\)/m,
+    'the locked verb list changed — every one of these recreates the shared router');
+  // Everything else must exec straight through: `ddev list --json-output` runs every 20s.
+  assert.match(src, /\*\)\s+exec "\$\{REAL_DDEV\}" "\$@" ;;/);
+});
+
+test('a lock already held is not taken again', () => {
+  // The dashboard wraps its own calls in flock; re-locking from inside deadlocks for the
+  // full timeout. Verified by experiment before this interlock existed.
+  const src = fs.readFileSync(SOURCE, 'utf8');
+  assert.match(src, /DDEV_ROUTER_LOCK_HELD/);
+  const ddevjs = fs.readFileSync(path.join(APP, 'ddev.js'), 'utf8');
+  assert.ok(ddevjs.includes('env DDEV_ROUTER_LOCK_HELD=1'),
+    'the dashboard no longer announces that it holds the lock — its flock will deadlock the shim');
+});
+
+test('nothing about a missing flock or lock file is fatal', () => {
+  // Refusing to run ddev because a lock could not be taken is a worse failure than the
+  // one being prevented.
+  const src = fs.readFileSync(SOURCE, 'utf8');
+  const fallbacks = (src.match(/exec "\$\{REAL_DDEV\}" "\$@"/g) || []).length;
+  assert.ok(fallbacks >= 4, `expected pass-through fallbacks, found ${fallbacks}`);
+});

package/core/workspace-app/tests/unit/ddev-snapshots.test.js

@@ -0,0 +1,142 @@
+/**
+ * Database snapshots: taking one was all the row could do.
+ *
+ * There was a "Take a snapshot" item and nothing else — no list, no restore, no way to remove one. A
+ * backup nobody can restore is a file, and restoring is the whole point of a snapshot: it is a
+ * physical copy of the database's own files, so it goes back in seconds where a SQL dump is replayed
+ * statement by statement. Measured through the dashboard on a real project: restored in 41s.
+ *
+ * Two facts shape the whole feature, both from DDEV's own behaviour:
+ *   - a snapshot belongs to a database engine AND version, and will not restore into another;
+ *   - restoring REPLACES the database — no merge, no undo.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const snaps = require('../../ddev-snapshots');
+
+const APP = path.join(__dirname, '../..');
+const server = fs.readFileSync(path.join(APP, 'server.js'), 'utf8');
+const actions = fs.readFileSync(path.join(APP, 'actions/ddev.js'), 'utf8');
+const ddev = fs.readFileSync(path.join(APP, 'ddev.js'), 'utf8');
+
+/** A project with snapshots of the shape DDEV writes: `<name>-<engine>_<version>.<ext>`. */
+function project({ dbType = 'mariadb', dbVersion = '11.8' } = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-snap-'));
+  fs.mkdirSync(path.join(dir, '.ddev', 'db_snapshots'), { recursive: true });
+  fs.writeFileSync(path.join(dir, '.ddev', 'config.yaml'),
+    `name: demo\ntype: drupal\ndatabase:\n  type: ${dbType}\n  version: "${dbVersion}"\nwebserver_type: nginx-fpm\n`);
+  return dir;
+}
+const put = (dir, file, bytes = 10) =>
+  fs.writeFileSync(path.join(dir, '.ddev', 'db_snapshots', file), Buffer.alloc(bytes));
+
+test('a snapshot is read off disk, engine and version and all', () => {
+  // From a real one taken on a real project: `zz-claude-probe-mariadb_11.8.zst`.
+  const dir = project();
+  put(dir, 'before-updb-mariadb_11.8.zst', 1024);
+  const [one] = snaps.listSnapshots(dir);
+  assert.equal(one.name, 'before-updb');
+  assert.equal(one.dbVersion, 'mariadb_11.8');
+  assert.equal(one.compression, 'zstd');
+  assert.equal(one.size, 1024);
+  assert.ok(one.mtime instanceof Date);
+});
+
+test('a name with dashes in it survives the parse', () => {
+  // The engine and version are the LAST two pieces, so a name that has its own dashes — which is most
+  // of them — must not be cut at the first one.
+  const dir = project();
+  put(dir, 'before-the-2026-09-22-config-import-mariadb_11.8.zst');
+  assert.equal(snaps.listSnapshots(dir)[0].name, 'before-the-2026-09-22-config-import');
+});
+
+test('an uncompressed snapshot is a folder, and it is still a snapshot', () => {
+  const dir = project();
+  const folder = path.join(dir, '.ddev', 'db_snapshots', 'plain-mariadb_11.8');
+  fs.mkdirSync(folder);
+  fs.writeFileSync(path.join(folder, 'ibdata1'), Buffer.alloc(2048));
+  const [one] = snaps.listSnapshots(dir);
+  assert.equal(one.name, 'plain');
+  assert.equal(one.compression, 'none');
+  assert.equal(one.size, 2048, 'its size is what is inside it');
+});
+
+test('newest first, and nothing that is not a snapshot', () => {
+  const dir = project();
+  put(dir, 'old-mariadb_11.8.zst');
+  put(dir, 'new-mariadb_11.8.zst');
+  fs.utimesSync(path.join(dir, '.ddev', 'db_snapshots', 'old-mariadb_11.8.zst'), new Date(0), new Date(0));
+  put(dir, 'README.txt');
+  put(dir, '.keep');
+  assert.deepEqual(snaps.listSnapshots(dir).map((s) => s.name), ['new', 'old']);
+  assert.deepEqual(snaps.listSnapshots(project()).map((s) => s.name), [], 'a project with none says none');
+});
+
+test('a snapshot from another engine or version cannot restore here, and says both', () => {
+  // DDEV refuses it; the row says so first, because its refusal otherwise arrives inside a screen
+  // session somebody has to open to read.
+  const dir = project({ dbVersion: '11.8' });
+  put(dir, 'ours-mariadb_11.8.zst');
+  put(dir, 'theirs-mariadb_10.11.zst');
+  put(dir, 'postgres-postgres_16.zst');
+  const version = snaps.projectDbVersion(dir);
+  assert.equal(version, 'mariadb_11.8');
+  assert.equal(snaps.restorable(snaps.findSnapshot(dir, 'ours'), version).ok, true);
+  const no = snaps.restorable(snaps.findSnapshot(dir, 'theirs'), version);
+  assert.equal(no.ok, false);
+  assert.match(no.why, /mariadb_10\.11/);
+  assert.match(no.why, /mariadb_11\.8/, 'and what the project actually runs');
+  assert.equal(snaps.restorable(snaps.findSnapshot(dir, 'postgres'), version).ok, false);
+  // An unknown project version is not a reason to refuse: DDEV is the judge then.
+  assert.equal(snaps.restorable(snaps.findSnapshot(dir, 'theirs'), '').ok, true);
+});
+
+test('a name from the browser is checked against what is on disk', () => {
+  const dir = project();
+  put(dir, 'real-mariadb_11.8.zst');
+  assert.ok(snaps.findSnapshot(dir, 'real'));
+  assert.equal(snaps.findSnapshot(dir, 'invented'), null);
+  // And the pattern refuses a path before the lookup ever runs.
+  for (const bad of ['../../etc/passwd', 'a/b', '.hidden', '']) {
+    assert.equal(snaps.SNAPSHOT_NAME_RE.test(bad), false, bad);
+  }
+  for (const good of ['before-updb', 'v11.8_check', 'X']) assert.ok(snaps.SNAPSHOT_NAME_RE.test(good), good);
+});
+
+test('restore takes the name positionally; taking and cleaning take --name', () => {
+  // Given `--name`, `ddev snapshot restore` prints its help and the screen log reads like a crash.
+  // Found by running it.
+  const named = actions.slice(actions.indexOf('if (act.named)'), actions.indexOf('const removed', actions.indexOf('if (act.named)')) || undefined);
+  assert.match(named, /args = \[\.\.\.args, raw\];/);
+  assert.match(named, /args = \[\.\.\.args, '--name', raw\];/);
+  assert.match(ddev, /'\/actions\/ddev-snapshot-restore':[^\n]*args: \['snapshot', 'restore'\]/);
+  assert.match(ddev, /'\/actions\/ddev-snapshot-delete':[^\n]*args: \['snapshot', '--cleanup', '-y'\]/);
+});
+
+test('restoring and deleting are destructive, and are treated as such', () => {
+  // The guard is in the handler, not only in the markup: the dashboard is not the only door.
+  assert.match(ddev, /'\/actions\/ddev-snapshot-restore':[^\n]*destructive: true/);
+  assert.match(ddev, /'\/actions\/ddev-snapshot-delete':[^\n]*destructive: true/);
+  // A restore of a large database takes minutes, so it runs in a screen and can be watched.
+  assert.match(ddev, /'\/actions\/ddev-snapshot-restore':[^\n]*inScreen: true/);
+  // And the buttons go through the confirm dialog. The rows are built above the heading, so the
+  // slice starts where the fragment does.
+  const frag = server.slice(server.indexOf("const sn = pathname.match(/^\\/fragments\\/projects\\/snapshots"));
+  const rows = frag.slice(0, frag.indexOf('Snapshots of'));
+  assert.equal((rows.match(/hx-trigger="confirmed-remove"/g) || []).length, 2, 'restore and delete both ask');
+  assert.match(rows, /arm-step/);
+});
+
+test('the modal says what a snapshot is, and what restoring costs', () => {
+  const modal = server.slice(server.indexOf('<h3 class="uk-margin-small-bottom">Snapshots of'), server.indexOf('} }', server.indexOf('Snapshots of')));
+  assert.match(modal, /physical copy of the database's own files/);
+  assert.match(modal, /Restoring <strong>replaces<\/strong>/);
+  assert.match(modal, /will not restore into it/, 'the engine-and-version rule, before it bites');
+  assert.match(modal, /\.ddev\/db_snapshots\//, 'and where they live');
+  assert.match(modal, /Taking one of a stopped\n                project starts it first/, 'observed, and worth not springing on anyone');
+});

package/core/workspace-app/tests/unit/ddev-start-daemons.test.js

@@ -0,0 +1,62 @@
+/**
+ * A start that says it worked, and a dashboard that answers 502.
+ *
+ * DDEV starts `web_extra_daemons` itself at the end of `ddev start`, and that step races supervisord
+ * coming up. When it loses, ddev prints
+ *
+ *   Unable to start web_extra_daemons using supervisorctl,
+ *   stdout=error: <class 'http.client.RemoteDisconnected'>, Remote end closed connection …
+ *
+ * and then reports **Successfully started workspace** anyway. The daemons are left "Not started", so
+ * nginx answers **502 Bad Gateway**: the proxy is up and the app behind it never came up.
+ *
+ * That is the worst shape a failure can take. The command said it worked, so nothing points at the
+ * start; the browser says 502, which reads as "the dashboard is broken". Reproduced on this machine
+ * by stopping the daemons and running `ddev start`: the warning appeared, the start "succeeded", and
+ * the site stayed 502 until the daemons were started by hand.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const config = fs.readFileSync(path.join(__dirname, '../../.ddev/config.yaml'), 'utf8');
+
+test('every start ends by making sure the daemons are actually up', () => {
+  const post = config.slice(config.indexOf('post-start:'), config.indexOf('\ndatabase:'));
+  assert.match(post, /supervisorctl status webextradaemons:\*/);
+  assert.match(post, /xargs -r supervisorctl start/);
+});
+
+test('it asks which are down rather than starting everything', () => {
+  // A healthy start must do nothing here: restarting a daemon that is already serving would drop
+  // whatever it was doing — and this runs on every single `ddev start`.
+  const post = config.slice(config.indexOf('post-start:'), config.indexOf('\ndatabase:'));
+  assert.match(post, /grep -v RUNNING/);
+  assert.ok(!/supervisorctl restart/.test(post), 'nothing is restarted, only started');
+});
+
+test('it covers every daemon, not just the dashboard', () => {
+  // The Web IDE loses the same race, and a dashboard that comes back while the IDE stays down is
+  // half a fix that nobody would think to check.
+  const post = config.slice(config.indexOf('post-start:'), config.indexOf('\ndatabase:'));
+  assert.match(post, /webextradaemons:\*/);
+  assert.ok(!/webextradaemons:workspace-app\b(?!\*)/.test(post.replace(/#.*/g, '')),
+    'not scoped to one daemon by name');
+});
+
+test('a daemon that will not start does not fail the project start', () => {
+  // The 502 says the rest. A `ddev start` that exits non-zero because one daemon is unhappy would
+  // stop the other projects in the autostart chain behind it.
+  const post = config.slice(config.indexOf('post-start:'), config.indexOf('\ndatabase:'));
+  assert.match(post, /\|\| true/);
+});
+
+test('the reason is recorded where the line is', () => {
+  // Whoever removes this line as "belt and braces" should see, in the same place, that it is the
+  // difference between a working dashboard and a 502 after a reboot.
+  const post = config.slice(config.indexOf('post-start:'), config.indexOf('\ndatabase:'));
+  assert.match(post, /RemoteDisconnected/);
+  assert.match(post, /502 Bad Gateway/);
+});

package/core/workspace-app/tests/unit/ddev-xdebug.test.js

@@ -0,0 +1,41 @@
+/**
+ * Step debugging, on and off, from the row.
+ *
+ * `ddev xdebug on` is a toggle inside the web container — no config change, no restart — which is
+ * exactly why it belongs on a menu rather than in somebody's shell history. And Xdebug costs about
+ * 3x the PHP runtime while it is on, so turning it OFF is the half people forget.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const APP = path.join(__dirname, '../..');
+const ddev = fs.readFileSync(path.join(APP, 'ddev.js'), 'utf8');
+const actions = fs.readFileSync(path.join(APP, 'actions/ddev.js'), 'utf8');
+const server = fs.readFileSync(path.join(APP, 'server.js'), 'utf8');
+
+test('all three verbs are the CLI\'s own', () => {
+  // `ddev xdebug on|off|status`, as `ddev xdebug --help` documents them.
+  assert.match(ddev, /'\/actions\/ddev-xdebug-on':[^\n]*args: \['xdebug', 'on'\]/);
+  assert.match(ddev, /'\/actions\/ddev-xdebug-off':[^\n]*args: \['xdebug', 'off'\]/);
+  assert.match(ddev, /'\/actions\/ddev-xdebug-status':[^\n]*args: \['xdebug', 'status'\]/);
+  for (const a of ['on', 'off', 'status']) {
+    assert.match(actions, new RegExp(`'/actions/ddev-xdebug-${a}': ddev_verb,`), a);
+    // The container has to be up for a toggle inside it to mean anything.
+    assert.match(ddev, new RegExp(`'/actions/ddev-xdebug-${a}':[^\\n]*needsRunning: true`), a);
+  }
+});
+
+test('the menu offers both states rather than a toggle', () => {
+  // `ddev describe --json-output` carries no xdebug field — checked — so a row cannot show the
+  // current state without a subprocess of its own. Both are offered, and asking is a click.
+  const menu = server.slice(server.indexOf('<li class="uk-nav-header">debugging</li>'));
+  assert.match(menu.slice(0, 1200), /Xdebug on/);
+  assert.match(menu.slice(0, 1200), /Xdebug off/);
+  assert.match(menu.slice(0, 1200), /Which is it now\?/);
+  assert.ok(!/xdebug-toggle/.test(server), 'no toggle, because the state is not known');
+  // And the cost of leaving it on is on the item itself, not in a doc nobody opens.
+  assert.match(menu.slice(0, 1200), /3&times; slower/);
+});

package/core/workspace-app/tests/unit/deep-chat-origin.test.js

@@ -0,0 +1,38 @@
+/**
+ * The assistant's route is an action like any other: a request from another site is refused before anything reads its
+ * body, and only JSON is taken. It used to be handled above the same-origin check and return before reaching it, and
+ * the assistant it starts can use Bash — so a page on any site could hand it a prompt.
+ */
+
+const assert = require('node:assert');
+const { test } = require('node:test');
+const fs = require('fs');
+const path = require('path');
+
+const src = fs.readFileSync(path.join(__dirname, '..', '..', 'server.js'), 'utf8');
+
+test('the assistant route refuses another site before it reads the body, and takes only JSON', () => {
+  const at = src.indexOf("pathname === '/actions/deep-chat'");
+  assert.ok(at > 0, 'no assistant route');
+  const beforeBody = src.slice(at, src.indexOf("req.on('data'", at));
+  assert.match(beforeBody, /if \(foreignOrigin\(req\)\) \{[\s\S]*?writeHead\(403/);
+  assert.match(beforeBody, /application\\\/json[\s\S]*?writeHead\(415/);
+});
+
+test('foreignOrigin: another host is foreign; the same host, and no Origin at all, are not', () => {
+  const start = src.indexOf('function foreignOrigin(req) {');
+  const fn = src.slice(start, src.indexOf('\n}\n', start) + 2);
+  const foreignOrigin = new Function(`${fn}; return foreignOrigin;`)();
+  const req = (origin, host = 'workspace.ddev.site') => ({ headers: { origin, host } });
+  assert.strictEqual(foreignOrigin(req('https://evil.example')), true);
+  assert.strictEqual(foreignOrigin(req('https://workspace.ddev.site.evil.example')), true);
+  assert.strictEqual(foreignOrigin(req('not a url')), true);
+  assert.strictEqual(foreignOrigin(req('https://workspace.ddev.site')), false);
+  assert.strictEqual(foreignOrigin(req(undefined)), false);
+});
+
+test('every other action keeps the same check', () => {
+  const at = src.indexOf("req.method === 'POST' && pathname.startsWith('/actions/')");
+  assert.ok(at > 0);
+  assert.match(src.slice(at, at + 900), /if \(foreignOrigin\(req\)\) \{/);
+});