@bongos/core 1.19.1081 → 1.20.2

package/tests/projects_hub_app_step.mjs

@@ -1,13 +1,19 @@
 // tests/projects_hub_app_step.mjs — the create wizard's "where your app runs" step,
-// EXECUTED (task 1004351, ADR 0345).
+// EXECUTED (task 1004351, ADR 0345), and its Render setup (task 1004352, ADR 0348).
 //
-// The step is a native radio group, so almost all of its behaviour is one rule: the
-// review may only ever name a place the owner could actually pick. Render is listed
-// but disabled until the connect flow lands (task 1004352), and "decide later" is the
-// owner's ruling for the default. A static regex cannot tell a guard that works from
-// one that is never consulted, so — as tests/projects_hub_module_picker.mjs does for
-// the picker — this slices the block out of projects.html by its own sentinels and
-// runs it in `vm` under a small DOM stub.
+// A static regex cannot tell a guard that works from one that is never consulted, so —
+// as tests/projects_hub_module_picker.mjs does for the picker — this slices the block out
+// of projects.html by its own sentinels and runs it in `vm` under a small DOM stub.
+//
+// The load-bearing assertions for Render, because the key reaches the owner's WHOLE
+// Render account:
+//   • the key never lands on `state` — the whole of state is the sessionStorage draft —
+//     and never in a URL; it is dropped once the setup request is sent
+//   • a key that reaches several workspaces lists them all and picks NONE: the owner
+//     must choose, and Next refuses until they do
+//   • a refused key says so at once, next to the field
+//   • a service building another repository cannot be linked
+//   • the review only ever names what the owner actually chose
 //
 // Run:  node --test --test-reporter=tap tests/projects_hub_app_step.mjs
 
@@ -28,44 +34,110 @@ const to = HUB.indexOf(END, from);
 assert.ok(from > -1, 'the app-step block opens with its sentinel comment');
 assert.ok(to > from, 'the app-step block ends where renderReview begins');
 const BLOCK = HUB.slice(from, to);
+// The Render flow itself is shared with an existing project's page (task 1004184), so it
+// lives outside the wizard; its fence and the page's own node helper come along.
+const CSTART = '  /* ── connecting Render (task 1004352';
+const CEND = '  /* end of connecting Render */';
+const cfrom = HUB.indexOf(CSTART), cto = HUB.indexOf(CEND, cfrom);
+assert.ok(cfrom > -1 && cto > cfrom, 'the shared Render flow is fenced by its sentinels');
+const CONNECT = HUB.slice(cfrom, cto);
+const APPEL = (HUB.match(/function appEl\(tag, cls, text\) \{[\s\S]*?\n  \}/) || [''])[0];
+assert.ok(APPEL, 'the page\'s own appEl() is lifted');
 
 const PANEL = (HUB.match(/<section class="panel" id="panel-app"[\s\S]*?<\/section>/) || [''])[0];
+const ESC = (HUB.match(/function esc\(s\) \{[\s\S]*?\n  \}/) || [''])[0];
+assert.ok(ESC, 'the page\'s own esc() is lifted, not re-implemented');
+
+const KEY = 'rnd_abcdefghijklmnopqrstuvwx';
+const TEA_A = 'tea-aaaaaaaa1111', TEA_B = 'tea-bbbbbbbb2222';
+const flush = async () => { for (let i = 0; i < 6; i++) await new Promise((r) => setTimeout(r, 0)); };
 
-// Two radios, built from the real markup so the harness cannot drift from the page.
-function radiosFromMarkup(renderEnabled) {
+// The radios, built from the real markup so the harness cannot drift from the page.
+function radiosFromMarkup() {
   return [...PANEL.matchAll(/<input type="radio" name="appPlatform" value="([a-z-]+)"([^>]*)>/g)].map((m) => ({
-    name: 'appPlatform',
-    value: m[1],
-    disabled: m[1] === 'render' ? !renderEnabled && /\sdisabled/.test(m[2]) : /\sdisabled/.test(m[2]),
-    checked: /\schecked/.test(m[2]),
+    name: 'appPlatform', value: m[1], disabled: /\sdisabled/.test(m[2]), checked: /\schecked/.test(m[2]),
   }));
 }
 
-function load({ draft = {}, renderEnabled = false } = {}) {
-  const inputs = radiosFromMarkup(renderEnabled);
+// A fake DOM node: the flow builds its lists node by node, never from an HTML string,
+// so a node records its children and serialises them for the assertions.
+const escText = (x) => String(x).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+class Text { constructor(t) { this.text = String(t); } html() { return escText(this.text); } get textContent() { return this.text; } }
+class El {
+  constructor(tag, id) { this.tagName = tag; this.id = id || ''; this.children = []; this.attrs = {}; this.listeners = {};
+    this.hidden = false; this.value = ''; this.className = ''; this.checked = false; this.disabled = false; this.selected = false; this.type = ''; this.name = ''; }
+  appendChild(c) { this.children.push(c); return c; }
+  setAttribute(k, v) { this.attrs[k] = String(v); }
+  getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; }
+  set textContent(v) { this.children = v === '' || v == null ? [] : [new Text(v)]; }
+  get textContent() { return this.children.map((c) => c.textContent).join(''); }
+  addEventListener(ev, fn) { (this.listeners[ev] = this.listeners[ev] || []).push(fn); }
+  fire(ev, event) { (this.listeners[ev] || []).forEach((fn) => fn.call(this, event || { target: this })); }
+  html() {
+    const a = [this.className ? ` class="${this.className}"` : '', this.type ? ` type="${this.type}"` : '', this.name ? ` name="${this.name}"` : '',
+      ...Object.entries(this.attrs).map(([k, v]) => ` ${k}="${v}"`), this.checked ? ' checked' : '', this.disabled ? ' disabled' : '', this.selected ? ' selected' : ''].join('');
+    return `<${this.tagName}${a}>${this.children.map((c) => c.html()).join('')}</${this.tagName}>`;
+  }
+}
+const document = { createElement: (t) => new El(t), createTextNode: (t) => new Text(t) };
+function el(id) { return new El('div', id); }
+
+// fetch answers by URL; every call is recorded, body parsed.
+function load({ draft = {}, answers = {} } = {}) {
+  const inputs = radiosFromMarkup();
+  const els = {};
+  const $ = (id) => (els[id] = els[id] || el(id));
   let changeHandler = null;
   const saves = [];
+  const calls = [];
   const root = {
     querySelector(sel) {
       if (sel === '#appOpts') return { addEventListener: (ev, fn) => { if (ev === 'change') changeHandler = fn; } };
       throw new Error('unexpected selector ' + sel);
     },
-    querySelectorAll(sel) {
-      assert.equal(sel, '#appOpts input[name=appPlatform]');
-      return inputs;
-    },
+    querySelectorAll(sel) { assert.equal(sel, '#appOpts input[name=appPlatform]'); return inputs; },
   };
-  const state = Object.assign({ appPlatform: 'later' }, draft);
-  const ctx = { root, state, saveDraft: () => saves.push(state.appPlatform) };
+  const state = Object.assign({ appPlatform: 'later', owner: 'example-owner', repo: 'spike' }, draft);
+  const fetch = async (url, init) => {
+    const body = init && init.body ? JSON.parse(init.body) : null;
+    calls.push({ url, method: init && init.method, body });
+    const key = url + (body && body.owner_id ? '#' + body.owner_id : '');
+    const a = answers[key] !== undefined ? answers[key] : answers[url];
+    if (a === undefined) return { ok: false, status: 404, json: async () => ({ error: { message: 'not found' } }) };
+    if (a.status) return { ok: false, status: a.status, json: async () => ({ error: { message: a.message } }) };
+    return { ok: true, status: 200, json: async () => a };
+  };
+  const watches = [];
+  const ctx = { root, state, $, document, Object, API: '/api/bongos', fetch, JSON, String, Number, encodeURIComponent, Array, saveDraft: () => saves.push(JSON.stringify(state)),
+    // the shared status watch (task 1004353) lives outside this block; record that it is started
+    watchApp: (id, box) => { watches.push({ id, box }); return () => {}; } };
   vm.createContext(ctx);
-  vm.runInContext(BLOCK + '\nthis.api = { appPlatformChoice, syncAppStep, appRow };', ctx);
-  return { ...ctx.api, inputs, state, saves, change: (value) => changeHandler({ target: inputs.find((i) => i.value === value) }) };
+  vm.runInContext(ESC + '\n' + APPEL + '\n' + CONNECT + '\n' + BLOCK + '\nthis.api = { appPlatformChoice, syncAppStep, appRow, syncRenderSetup, validateRender, renderRequestBody, sendRenderSetup, planLabel };', ctx);
+  const api = ctx.api;
+  return {
+    ...api, inputs, state, saves, calls, $, watches,
+    change: (value) => changeHandler({ target: inputs.find((i) => i.value === value) }),
+    typeKey: (v) => { $('f-renderKey').value = v; $('f-renderKey').fire('input', { target: $('f-renderKey') }); },
+    check: async () => { $('renderCheck').fire('click', { target: $('renderCheck') }); await flush(); },
+    pickWorkspace: async (i) => { $('renderWsList').fire('change', { target: { getAttribute: () => String(i) } }); await flush(); },
+    pickService: (t) => $('renderSvcList').fire('change', { target: { name: 'renderSvc', disabled: false, ...t } }),
+  };
 }
 
-test('the panel is real markup: Render listed but not pickable yet, Decide later the default', () => {
+const LOOKUP = '/api/bongos/provisioning/render/lookup';
+const TWO = { workspaces: [{ id: TEA_A, name: 'Mine', type: 'team' }, { id: TEA_B, name: 'A friend’s team', type: 'team' }] };
+const SERVICES = { services: [
+  { id: 'srv-aaaaaaaa1111', name: 'shop', repo: 'https://github.com/example-owner/spike', url: 'https://shop.onrender.com' },
+  { id: 'srv-bbbbbbbb2222', name: 'other', repo: 'https://github.com/example-owner/other-app', url: null },
+] };
+const ANSWERS = { [LOOKUP]: TWO, [LOOKUP + '#' + TEA_A]: SERVICES };
+
+// ── the step itself (task 1004351) ──────────────────────────────────────────
+
+test('the panel is real markup: Render and Decide later, Decide later the default', () => {
   assert.ok(PANEL, '#panel-app exists');
-  assert.match(PANEL, /<input type="radio" name="appPlatform" value="render" disabled/, 'Render cannot be picked until task 1004352');
-  assert.match(PANEL, /<span class="soonTag">Coming soon<\/span>/, 'and says so in words, not by colour alone');
+  assert.match(PANEL, /<input type="radio" name="appPlatform" value="render" aria-describedby="appRenderWhat">/, 'Render can be picked (task 1004352)');
+  assert.doesNotMatch(PANEL, /Coming soon/, 'and is no longer marked soon');
   assert.match(PANEL, /<input type="radio" name="appPlatform" value="later" checked>/, 'Decide later is the default');
   assert.match(PANEL, /We host your Builders' hall/, 'the step says the hall is ours to host (ADR 0345 D1), in the page\'s one spelling of it');
   assert.match(PANEL, /<form data-next="8">/, 'Next leads to the review');
@@ -77,39 +149,28 @@ test('the step sits between Address and Review in the panels map and on the rail
   assert.match(HUB, /<li data-step="7"><span class="snum">7<\/span><span class="slbl">App<\/span><\/li>/);
   assert.match(HUB, /<li data-step="8"><span class="snum">8<\/span><span class="slbl">Create<\/span><\/li>/);
   assert.match(HUB, /data-back="7">← Back<\/button>\n\s*<button type="button" class="btn big" id="doCreate">/, "the review's Back returns to the app step");
-  assert.match(HUB, /if \(step === 7\) syncAppStep\(\);\n\s*if \(step === 8\) renderReview\(\);/, 'entering the step repaints it from the draft');
+  assert.match(HUB, /if \(step === 7\) \{ syncAppStep\(\); syncRenderSetup\(\); \}\n\s*if \(step === 8\) renderReview\(\);/, 'entering the step repaints it, Render setup included');
+  assert.match(HUB, /if \(step === 7\) return validateRender\(\);/, 'Next on the step runs the Render check');
 });
 
-test('a fresh draft reads "decide later"', () => {
+test('a fresh draft reads "decide later", and the Render setup stays hidden', () => {
   const w = load();
   assert.equal(w.appPlatformChoice(), 'later');
   assert.equal(w.appRow(), 'Not chosen yet — you can decide later');
+  w.syncRenderSetup();
+  assert.equal(w.$('renderSetup').hidden, true);
+  assert.equal(w.validateRender(), true, 'decide later never blocks Next');
 });
 
-test('a draft that names Render while Render is not pickable still reads "decide later"', () => {
-  // The rule: the review never names a place the owner could not actually pick.
-  const w = load({ draft: { appPlatform: 'render' } });
-  assert.equal(w.appPlatformChoice(), 'later');
-  assert.equal(w.appRow(), 'Not chosen yet — you can decide later');
-  w.syncAppStep();
-  assert.deepEqual(w.inputs.filter((i) => i.checked).map((i) => i.value), ['later'], 'and the step shows Decide later checked');
-});
-
-test('once Render is pickable, choosing it is what the review names', () => {
-  const w = load({ renderEnabled: true });
+test('choosing Render saves the choice and opens its setup', () => {
+  const w = load();
   w.change('render');
   assert.equal(w.state.appPlatform, 'render');
-  assert.deepEqual(w.saves, ['render'], 'the choice is saved to the draft');
-  assert.equal(w.appRow(), 'Render, on your own account');
-  w.syncAppStep();
-  assert.deepEqual(w.inputs.filter((i) => i.checked).map((i) => i.value), ['render']);
+  assert.equal(JSON.parse(w.saves[0]).appPlatform, 'render');
+  assert.equal(w.$('renderSetup').hidden, false);
 });
 
-test('a change on a disabled radio is ignored, and an unknown or missing value reads "decide later"', () => {
-  const w = load();
-  w.change('render');
-  assert.equal(w.state.appPlatform, 'later', 'a disabled option never reaches the draft');
-  assert.deepEqual(w.saves, []);
+test('an unknown or missing value reads "decide later"', () => {
   for (const v of [undefined, '', 'vercel', 'x"]']) {
     assert.equal(load({ draft: { appPlatform: v } }).appPlatformChoice(), 'later', `appPlatform=${JSON.stringify(v)}`);
   }
@@ -124,9 +185,6 @@ test('the review carries the hall row and the app row in place of the old Shape
 });
 
 test('the rail grid has one column per step, so adding a step never wraps the rail', () => {
-  // Adding the app step made the rail eight beats in a seven-column grid: at 1440 the
-  // Create beat wrapped onto a second row. The count lives in the shared sheet, so the
-  // two must be checked against each other, not each on its own.
   const css = fs.readFileSync(path.join(ROOT, 'modules', 'public-landing', 'public', 'assets', 'cosmos.css'), 'utf8');
   const cols = Number((css.match(/#view-new \.steps\{display:grid;grid-template-columns:repeat\((\d+),1fr\)/) || [])[1]);
   const beats = [...HUB.matchAll(/<li[^>]*data-step="\d+"/g)].length;
@@ -136,3 +194,175 @@ test('the rail grid has one column per step, so adding a step never wraps the ra
 test('the hall is spelled one way on this page', () => {
   assert.doesNotMatch(HUB, /Builders Hall/, 'no "Builders Hall" beside the page\'s own "Builders\' hall"');
 });
+
+// ── Render (task 1004352) ───────────────────────────────────────────────────
+
+test('the key field says what the key is used for, and claims no protection it lacks', () => {
+  const setup = (PANEL.match(/<div class="renderSetup"[\s\S]*?<div class="hint" id="h-render"/) || [''])[0];
+  assert.match(setup, /<input type="password" id="f-renderKey" autocomplete="off"/, 'masked, and never autofilled');
+  assert.match(setup, /used once, to create your app on your own Render account, and then thrown away/);
+  assert.match(setup, /Render bills you directly/);
+  assert.match(setup, /href="https:\/\/dashboard\.render\.com\/u\/settings#api-keys"/, 'links to where Render issues keys');
+  assert.doesNotMatch(setup, /encrypt|secure|safe|protected/i, 'no protection claim the design does not give (ADR 0327 §2)');
+});
+
+test('the key never lands on the draft, and never in a URL', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  w.pickService({ value: 'new' });
+  w.state.renderStart = 'npm start';
+  assert.ok(w.saves.length > 0);
+  for (const snap of w.saves) assert.ok(!snap.includes(KEY), 'no draft snapshot carries the key');
+  assert.ok(!JSON.stringify(w.state).includes(KEY), 'and neither does state');
+  for (const c of w.calls) {
+    assert.ok(!c.url.includes(KEY), 'no URL carries it');
+    assert.equal(c.method, 'POST', 'it only ever travels in a POST body');
+  }
+});
+
+test('a key that reaches several workspaces lists them all and picks none', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  assert.deepEqual(w.calls.map((c) => [c.url, c.body]), [[LOOKUP, { key: KEY }]]);
+  assert.equal(w.$('renderWs').hidden, false);
+  const list = w.$('renderWsList').html();
+  assert.equal((list.match(/name="renderWs"/g) || []).length, 2, 'both workspaces are offered');
+  assert.doesNotMatch(list, /checked/, 'and neither is chosen for the owner');
+  assert.match(w.$('h-renderKey').textContent, /reaches 2 workspaces — choose/);
+  assert.equal(w.validateRender(), false, 'Next refuses until one is chosen');
+  assert.match(w.$('h-render').textContent, /Choose the Render workspace/);
+});
+
+test('a refused key says so beside the field, and nothing is listed', async () => {
+  const w = load({ answers: { [LOOKUP]: { status: 422, message: 'Render refused that key. Check you copied all of it.' } }, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  assert.match(w.$('h-renderKey').textContent, /Render refused that key/);
+  assert.match(w.$('h-renderKey').className, /err/);
+  assert.equal(w.$('renderWs').hidden, true);
+  assert.equal(w.validateRender(), false);
+});
+
+test('a malformed key is caught before Render is asked', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey('ghp_notrender');
+  await w.check();
+  assert.equal(w.calls.length, 0);
+  assert.match(w.$('h-renderKey').textContent, /starts with “rnd_”/);
+});
+
+test('the chosen workspace lists its apps; one building another repository cannot be linked', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  assert.deepEqual(w.calls[1].body, { key: KEY, owner_id: TEA_A });
+  assert.equal(w.state.renderOwnerId, TEA_A);
+  const list = w.$('renderSvcList').html();
+  assert.match(list, /value="new"/, 'a new app is always an option');
+  assert.match(list, /data-i="0">[\s\S]*Link shop/, 'this project\'s own app can be linked');
+  assert.match(list, /data-i="1" disabled>[\s\S]*Builds example-owner\/other-app, not this project/, 'another repository\'s cannot');
+});
+
+test('Next needs a complete answer: a mode, then a start command for a native runtime', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  assert.equal(w.validateRender(), false);
+  assert.match(w.$('h-render').textContent, /new app or link/);
+  w.pickService({ value: 'new' });
+  assert.equal(w.validateRender(), false);
+  assert.match(w.$('h-render').textContent, /how your app starts/);
+  w.state.renderStart = 'npm start';
+  assert.equal(w.validateRender(), true);
+  w.state.renderRuntime = 'docker'; w.state.renderStart = '';
+  assert.equal(w.validateRender(), true, 'docker needs no commands');
+});
+
+test('what Create sends: greenfield carries the build and the plans, a link only the service', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  w.pickService({ value: 'new' });
+  Object.assign(w.state, { renderRuntime: 'python', renderBuild: ' pip install -r requirements.txt ', renderStart: 'gunicorn app:app', renderPlan: 'standard', renderDb: true, renderDbPlan: 'basic_1gb' });
+  assert.deepEqual({ ...w.renderRequestBody() }, {
+    key: KEY, owner_id: TEA_A, mode: 'greenfield', runtime: 'python',
+    start_command: 'gunicorn app:app', build_command: 'pip install -r requirements.txt',
+    web_plan: 'standard', database: true, db_plan: 'basic_1gb',
+  });
+  w.state.renderRuntime = 'docker';
+  const d = w.renderRequestBody();
+  assert.equal(d.start_command, undefined); assert.equal(d.build_command, undefined);
+  w.state.renderDb = false;
+  assert.equal(w.renderRequestBody().db_plan, undefined, 'no database plan without a database');
+  w.pickService({ value: 'x', getAttribute: () => '0' });
+  assert.deepEqual({ ...w.renderRequestBody() }, { key: KEY, owner_id: TEA_A, mode: 'adopt', service_id: 'srv-aaaaaaaa1111' });
+});
+
+test('after Create the key is sent once, to the new project, and then dropped', async () => {
+  const w = load({ answers: { ...ANSWERS, '/api/bongos/provisioning/instances/42/render': { ok: true } }, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  w.pickService({ value: 'new' });
+  w.state.renderStart = 'npm start';
+  w.sendRenderSetup(42);
+  await flush();
+  const sent = w.calls.filter((c) => c.url === '/api/bongos/provisioning/instances/42/render');
+  assert.equal(sent.length, 1);
+  assert.equal(sent[0].body.key, KEY);
+  assert.equal(w.$('f-renderKey').value, '', 'the field is emptied');
+  assert.equal(w.validateRender(), false, 'the key is gone from the page too');
+  assert.match(w.$('doneRender').textContent, /used once, then thrown away/);
+  assert.deepEqual(w.watches.map((x) => x.id), [42], 'and the app’s own progress is watched from there (task 1004353)');
+  assert.equal(w.watches[0].box, w.$('doneApp'));
+  w.sendRenderSetup(42);
+  assert.equal(w.calls.filter((c) => c.url.endsWith('/render')).length, 1, 'a second send has nothing to send');
+});
+
+test('a refused setup request says the project is still being created', async () => {
+  const w = load({ answers: { ...ANSWERS, '/api/bongos/provisioning/instances/42/render': { status: 409, message: 'This project has no GitHub repository linked.' } }, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  w.pickService({ value: 'new' });
+  w.state.renderStart = 'npm start';
+  w.sendRenderSetup(42);
+  await flush();
+  assert.match(w.$('doneRender').textContent, /Your project is being created, but your app was not handed to Render: This project has no GitHub/);
+  assert.match(w.$('doneRender').className, /err/);
+});
+
+test('changing the key forgets what the old key could see', async () => {
+  const w = load({ answers: ANSWERS, draft: { appPlatform: 'render' } });
+  w.typeKey(KEY);
+  await w.check();
+  await w.pickWorkspace(0);
+  w.typeKey(KEY + 'x');
+  assert.equal(w.$('renderWs').hidden, true);
+  assert.equal(w.$('renderSvc').hidden, true);
+  assert.equal(w.validateRender(), false, 'the new key has to be checked before Next');
+});
+
+test('a resumed draft asks for the key again, and says why', () => {
+  const w = load({ draft: { appPlatform: 'render', renderOwnerId: TEA_A, renderOwnerName: 'Mine', renderMode: 'greenfield' } });
+  w.syncRenderSetup();
+  assert.match(w.$('h-renderKey').textContent, /Enter your Render key again — it is not kept, not even in this browser/);
+  assert.equal(w.validateRender(), false);
+});
+
+test('the review names exactly what was chosen, prices included', () => {
+  const g = load({ draft: { appPlatform: 'render', renderOwnerName: 'Mine', renderMode: 'greenfield', renderRuntime: 'node', renderPlan: 'starter', renderDb: true, renderDbPlan: 'basic_256mb' } });
+  assert.equal(g.appRow(), 'Render, workspace Mine — a new app (Node.js, Starter, about $7/month), with a database (Basic 256 MB, about $6/month). Render bills you directly.');
+  const a = load({ draft: { appPlatform: 'render', renderOwnerName: 'Mine', renderMode: 'adopt', renderServiceName: '<shop>' } });
+  assert.equal(a.appRow(), 'Render, workspace Mine — link <code>&lt;shop&gt;</code>, changing nothing on it', 'a name from Render is escaped');
+});
+
+test('Create hands the app to Render straight after the project is filed', () => {
+  assert.match(HUB, /show\(9, true\);\n\s*sendRenderSetup\(data\.instance && data\.instance\.id\);/);
+});