@bongos/core 1.19.929 → 1.19.931

package/tests/helpers.mjs

@@ -855,3 +855,124 @@ export function bootThinkingPage({ pages = [], viewer = { id: 95 }, meStatus = 2
     filter: (id) => { tabState.active = id; if (tabState.onChange) tabState.onChange(id); },
   };
 }
+
+// bootSkyPage — boot the REAL modules/hall-ui/public/sky.js in a vm against a
+// stub DOM, and hand back the field, the panel and the legend it wrote plus
+// every request it made.
+//
+// The fourth sibling of bootProfilePage / bootIdeaPage / bootThinkingPage, and
+// here for the reason the third one is: THE SKY (task 1004105 / BV2.R26) is a
+// DRAWING of facts that are all correct upstream, and the only place it can go
+// wrong is the last step. A glyph is geometry, so the questions this can ask
+// that no server test can are: does a remnant keep its diameter and lose its
+// fill, does an unreadable brightness leave a star lit, does the page draw a
+// second compression curve of its own, and does every thought carry its whole
+// sentence for a reader who cannot see the picture.
+//
+// THE REAL idea-objects.js IS LOADED INTO THE SAME SANDBOX, never stubbed —
+// the same rule bootThinkingPage keeps, and for the sharper reason here: the
+// pair exists so the sky and the room cannot call one object two names, and a
+// suite that stubbed the vocabulary would assert the sky says whatever the
+// suite told it to.
+const SKY_JS = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/sky.js'), 'utf8');
+export function bootSkyPage({
+  pages = [], viewer = { id: 95 }, meStatus = 200, trailStatus = 200,
+  goals = null, criteria = {},
+} = {}) {
+  const els = new Map();
+  const listeners = new Map();
+  const makeEl = (id) => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; },
+    addEventListener(type, fn) { listeners.set(`${id}:${type}`, fn); },
+    querySelector() { return null; }, querySelectorAll() { return []; }, appendChild() {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+  const documentObj = {
+    title: '',
+    body: { dataset: { page: 'sky' } },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl(id)); return els.get(id); },
+    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl('new'); },
+    addEventListener() {},
+  };
+
+  const requests = [];
+  const client = {
+    request: async (method, url) => {
+      requests.push(url);
+      if (/\/me$/.test(url)) {
+        return meStatus === 200
+          ? { status: 200, ok: true, data: { builder: viewer } }
+          : { status: meStatus, ok: false, data: null };
+      }
+      // The two well reads. `goals: null` is a route that could not be read at
+      // all, which must leave the wells named by their id rather than blank;
+      // `criteria` absent for a goal is "not read", which must leave that well
+      // with no rings rather than zero of them.
+      const one = /\/goals\/(\d+)$/.exec(url);
+      if (one) {
+        const list = criteria[one[1]];
+        return list === undefined
+          ? { status: 404, ok: false, data: null }
+          : { status: 200, ok: true, data: { goal: { id: one[1] }, criteria: list } };
+      }
+      if (/\/goals$/.test(url)) {
+        return goals === null
+          ? { status: 500, ok: false, data: null }
+          : { status: 200, ok: true, data: { goals } };
+      }
+      if (trailStatus !== 200) return { status: trailStatus, ok: false, data: null };
+      const offset = Number((/offset=(\d+)/.exec(url) || [])[1] || 0);
+      const page = pages.find((p) => Number(p.offset || 0) === offset) || { ideas: [], total: 0 };
+      return { status: 200, ok: true, data: page };
+    },
+  };
+
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => client },
+    CSS: { escape: (s) => String(s) },
+    OTB: {
+      escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+      $: (sel) => documentObj.querySelector(sel),
+      fmtDate: (iso) => String(iso ?? '').slice(0, 10),
+      toast() {},
+    },
+    location: { hostname: 'builders.cloudbongos.com', search: '', pathname: '/sky', hash: '', assign() {} },
+    localStorage: { getItem: () => null, setItem() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    console, setTimeout, clearTimeout, URLSearchParams, Math, Number,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(IDEA_OBJECTS_JS, sandbox, { filename: 'idea-objects.js' });
+  vm.runInContext(SKY_JS, sandbox, { filename: 'sky.js' });
+
+  return {
+    requests,
+    objects: () => windowObj.OTBIdeaObjects,
+    field: () => documentObj.getElementById('sky-map').innerHTML,
+    panel: () => documentObj.getElementById('sky-panel').innerHTML,
+    legend: () => documentObj.getElementById('sky-legend').innerHTML,
+    sub: () => documentObj.getElementById('sky-sub').textContent,
+    foot: () => documentObj.getElementById('sky-foot'),
+    // Picking is the page's only control, and it is DELEGATED — one listener on
+    // the field for a trail of 300 bodies — so the suite drives it the way a
+    // click does rather than by calling an internal the page does not export.
+    pick: (ideaId) => {
+      const fn = listeners.get('sky-map:click');
+      if (!fn) throw new Error('the field wired no click listener');
+      fn({ target: { closest: (sel) => (sel === '[data-idea]'
+        ? { getAttribute: () => String(ideaId) }
+        : null) } });
+    },
+  };
+}