@cdmx/wappler_ag_grid 2.1.3 → 2.1.5

package/tests/run-all-puppeteer.cjs

@@ -0,0 +1,180 @@
+// Alternative runner using puppeteer-core against the system Chrome.
+// More reliable than the agent-browser CLI driver for long sequential runs.
+// Works on Windows/Linux/macOS — set PUPPETEER_EXECUTABLE_PATH to override the
+// browser auto-detection.
+const fs = require('fs');
+const path = require('path');
+const puppeteer = require('puppeteer-core');
+
+const BASE = process.env.AG_TEST_BASE || 'http://localhost:8765/tests';
+const OUT_FILE = path.join(__dirname, 'findings.json');
+
+const PAGES = [
+  { file: '01-basic-render.html',     grids: ['basicGrid'] },
+  { file: '02-themes-locale.html',    grids: ['g_alpine','g_balham','g_material','g_quartz','g_custom','g_dark','g_he','g_ru','g_es'] },
+  { file: '03-editing.html',          grids: ['cellEdit','rowEdit','selectEdit'] },
+  { file: '04-selection.html',        grids: ['selGrid','singleSel'] },
+  { file: '05-action-buttons.html',   grids: ['actGrid'] },
+  { file: '06-export.html',           grids: ['expGrid','noExp'] },
+  { file: '07-import.html',           grids: ['importGrid'], expectEmpty: true },
+  { file: '08-formatting.html',       grids: ['fmtGrid','ctypeGrid','hdrGrid'] },
+  { file: '09-grouping.html',         grids: ['grpGrid','aggGrid'] },
+  { file: '10-state-persistence.html',grids: ['stateGrid'] },
+  { file: '11-layout.html',           grids: ['autoH','fixedH','scrollH'] },
+  { file: '12-methods.html',          grids: ['m'] },
+  { file: '13-flags-styles.html',     grids: ['flagsGrid','rsFn','rsOp','rsCompound','rsShort','rsFirst','rsLegacy','csCell','transformGrid','tipGrid'], pageAssertion: '__rsCheck' },
+  { file: '14-compact-view.html',     grids: ['compactGrid','extButtons','cellEvtGrid'] }
+];
+
+function findChrome() {
+  if (process.env.PUPPETEER_EXECUTABLE_PATH) return process.env.PUPPETEER_EXECUTABLE_PATH;
+  const candidates = process.platform === 'win32' ? [
+    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+    'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+    'C:\\Users\\Roney\\.agent-browser\\browsers\\chrome-148.0.7778.97\\chrome.exe'
+  ] : process.platform === 'darwin' ? [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium'
+  ] : [
+    '/usr/bin/google-chrome',
+    '/usr/bin/chromium',
+    '/usr/bin/chromium-browser',
+    '/snap/bin/chromium'
+  ];
+  return candidates.find(p => fs.existsSync(p));
+}
+
+(async () => {
+  const exe = findChrome();
+  if (!exe) {
+    console.error('No Chrome executable found — set PUPPETEER_EXECUTABLE_PATH');
+    process.exit(2);
+  }
+  console.log('chrome:', exe);
+
+  const browser = await puppeteer.launch({
+    executablePath: exe,
+    headless: 'new',
+    args: ['--no-sandbox', '--disable-dev-shm-usage']
+  });
+  const page = await browser.newPage();
+  page.setDefaultTimeout(30000);
+
+  const findings = { startedAt: new Date().toISOString(), base: BASE, pages: [] };
+  const pageErrors = [];
+  page.on('pageerror', e => pageErrors.push({ msg: e.message }));
+  page.on('console', msg => {
+    if (msg.type() === 'error') pageErrors.push({ msg: msg.text() });
+  });
+
+  for (const spec of PAGES) {
+    pageErrors.length = 0;
+    const url = BASE + '/' + spec.file;
+    console.log('\n--- ' + spec.file);
+    try {
+      await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+    } catch (e) {
+      console.log('  navigation failed:', e.message);
+      findings.pages.push({ file: spec.file, status: 'NAV_FAIL', error: e.message });
+      continue;
+    }
+
+    // Wait for gridsReady or 8s, whichever comes first.
+    try {
+      await page.waitForFunction(
+        () => document.body.dataset.gridsReady === 'true',
+        { timeout: spec.expectEmpty ? 2000 : 8000 }
+      );
+    } catch (_) { /* fine for expectEmpty pages */ }
+    // Settle render
+    await new Promise(r => setTimeout(r, 600));
+
+    const data = await page.evaluate(() => {
+      try {
+        if (!window.TestKit) return { fatal: 'no-testkit' };
+        const grids = TestKit.list();
+        const out = { url: location.href, appConnect: window.dmx && dmx.version, ready: document.body.dataset.gridsReady === 'true', grids: {} };
+        grids.forEach(id => {
+          const c = TestKit.grid(id);
+          if (!c) return;
+          out.grids[id] = {
+            count: c.count,
+            state: c.state,
+            dataLen: Array.isArray(c.data) ? c.data.length : null,
+            selectedRowsLen: (c.selectedRows || []).length,
+            filterStateKeys: c.filterState && typeof c.filterState === 'object' ? Object.keys(c.filterState) : [],
+            columnStateLen: (c.columnState || []).length,
+            domRows: document.querySelectorAll('#' + id + '-grid .ag-row').length
+          };
+        });
+        return out;
+      } catch (e) { return { fatal: e.message }; }
+    });
+
+    const expectedGrids = spec.grids;
+    const actualGrids = data.grids ? Object.keys(data.grids) : [];
+    const missing = expectedGrids.filter(g => !actualGrids.includes(g));
+    const judgeReady = g => {
+      const s = data.grids && data.grids[g] && data.grids[g].state;
+      if (!s) return false;
+      if (spec.expectEmpty) return true;
+      // Any of the three event flags counts. The module overwrites state on each
+      // event (so only the last-fired flag is observable), but any of them
+      // appearing proves the grid mounted and at least one onGrid* event fired.
+      return !!(s.gridReady || s.firstDataRendered || s.rowDataUpdated);
+    };
+    const judgeRows = g => spec.expectEmpty ? true : (data.grids && data.grids[g] && data.grids[g].domRows > 0);
+    const allReady = data.grids && expectedGrids.every(judgeReady);
+    const allHaveRows = data.grids && expectedGrids.every(judgeRows);
+    // Run a page-defined assertion (e.g. scenario 13 verifies rstyles actually applied).
+    let assertion = null;
+    if (spec.pageAssertion) {
+      try {
+        assertion = await page.evaluate((key) => window[key] || null, spec.pageAssertion);
+      } catch (e) { assertion = { error: e.message }; }
+    }
+    const assertionFailed = assertion && assertion.ok === false;
+
+    const status = data.fatal ? 'ERROR'
+                 : missing.length ? 'MISSING'
+                 : !allReady ? 'NOT_READY'
+                 : !allHaveRows ? 'NO_DOM_ROWS'
+                 : assertionFailed ? 'ASSERTION_FAIL'
+                 : 'PASS';
+    console.log('  status:', status);
+    if (data.fatal) console.log('  fatal:', data.fatal);
+    if (missing.length) console.log('  missing:', missing.join(','));
+    if (data.grids) {
+      for (const g of expectedGrids) {
+        const x = data.grids[g];
+        if (!x) continue;
+        console.log('  ' + g + ': count=' + x.count + ' domRows=' + x.domRows + ' state=' + JSON.stringify(x.state));
+      }
+    }
+    if (pageErrors.length) {
+      console.log('  page errors:', pageErrors.length);
+      pageErrors.slice(0, 3).forEach(e => console.log('   ', e.msg.slice(0, 200)));
+    }
+    if (assertion) {
+      if (assertionFailed) {
+        console.log('  assertion FAILED — checks that did not match:');
+        (assertion.failed || []).forEach(k => {
+          const c = assertion.checks && assertion.checks[k];
+          console.log('   ' + k + ' expected ' + (c && c.expect) + ' got ' + (c && c.actual));
+        });
+      } else if (assertion.ok) {
+        const n = Object.keys(assertion.checks || {}).length;
+        console.log('  page assertions passed (' + n + ' checks)');
+      }
+    }
+    findings.pages.push({ file: spec.file, status, expectedGrids, missing, result: data, pageErrors: pageErrors.slice(), assertion });
+  }
+
+  await browser.close();
+  findings.finishedAt = new Date().toISOString();
+  fs.writeFileSync(OUT_FILE, JSON.stringify(findings, null, 2));
+  console.log('\n=== summary ===');
+  console.table(findings.pages.map(p => ({ file: p.file, status: p.status })));
+  console.log('wrote ' + OUT_FILE);
+})().catch(e => { console.error(e); process.exit(1); });

package/tests/run-all.cjs

@@ -0,0 +1,144 @@
+// Drives agent-browser through every scenario and writes
+// tests/findings.json + a console summary. One comprehensive eval per page
+// keeps the WS connection short-lived and immune to daemon timeouts.
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Use the npm shim (`agent-browser` / `agent-browser.cmd`) with shell:true on both
+// platforms. The native .exe entry point hangs when stdout is captured, but the
+// shim wraps it properly. Override via AGENT_BROWSER_BIN if needed.
+const AB = process.env.AGENT_BROWSER_BIN || 'agent-browser';
+
+const BASE = process.env.AG_TEST_BASE || 'http://localhost:8765/tests';
+const OUT_FILE = path.join(__dirname, 'findings.json');
+const PAGES = [
+  { file: '01-basic-render.html',     grids: ['basicGrid'] },
+  { file: '02-themes-locale.html',    grids: ['g_alpine','g_balham','g_material','g_quartz','g_custom','g_dark','g_he','g_ru','g_es'] },
+  { file: '03-editing.html',          grids: ['cellEdit','rowEdit','selectEdit'] },
+  { file: '04-selection.html',        grids: ['selGrid','singleSel'] },
+  { file: '05-action-buttons.html',   grids: ['actGrid'] },
+  { file: '06-export.html',           grids: ['expGrid','noExp'] },
+  { file: '07-import.html',           grids: ['importGrid'], expectEmpty: true },
+  { file: '08-formatting.html',       grids: ['fmtGrid','ctypeGrid','hdrGrid'] },
+  { file: '09-grouping.html',         grids: ['grpGrid','aggGrid'] },
+  { file: '10-state-persistence.html',grids: ['stateGrid'] },
+  { file: '11-layout.html',           grids: ['autoH','fixedH','scrollH'] },
+  { file: '12-methods.html',          grids: ['m'] },
+  { file: '13-flags-styles.html',     grids: ['flagsGrid','stylesGrid','transformGrid','tipGrid'] },
+  { file: '14-compact-view.html',     grids: ['compactGrid','extButtons','cellEvtGrid'] }
+];
+
+function ab(args, { allowFail = false, timeout = 60000 } = {}) {
+  if (process.env.AB_DEBUG) console.error('[ab] ' + AB + ' ' + args.join(' '));
+  try {
+    return execFileSync(AB, args, { encoding: 'utf8', timeout, shell: true });
+  } catch (e) {
+    if (allowFail) return '__ERR__ ' + (e.stderr || e.message || e.stdout || '');
+    throw e;
+  }
+}
+
+// agent-browser --json wraps the result as
+//   {"success":true,"data":{"origin":"…","result":"<stringified JS>"},"error":null}
+// Pull out data.result and parse it again if it's a stringified JSON.
+function decodeEval(raw) {
+  let outer;
+  try { outer = JSON.parse(raw); } catch (_) { return { parseError: 'outer JSON', raw: raw.slice(0,400) }; }
+  if (!outer || outer.error) return { parseError: 'agent-browser error', detail: outer && outer.error };
+  const r = outer.data && outer.data.result;
+  if (typeof r === 'string') {
+    try { return JSON.parse(r); } catch (_) { return { result: r }; }
+  }
+  return outer;
+}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+// The actual collector lives in tests/lib/run-collector.js and is injected via
+// --init-script. Each eval call here is tiny so shell quoting stays trivial.
+// Use forward slashes — Windows cmd handles them fine and avoids backslash escaping.
+const COLLECTOR_SCRIPT = path.join(__dirname, 'lib', 'run-collector.js').replace(/\\/g, '/');
+const COLLECT_EXPR = '__abCollect()';
+
+(async () => {
+  console.log('=== AG Grid test suite run ===');
+  console.log('base:', BASE);
+
+  // Reuse the existing session — closing forces a slow daemon restart, and
+  // the same Chrome tab can navigate between scenarios just fine.
+
+  const findings = { startedAt: new Date().toISOString(), base: BASE, pages: [] };
+
+  function runOne(page) {
+    const url = BASE + '/' + page.file;
+    let opened = ab(['open', '"' + url + '"', '--init-script', '"' + COLLECTOR_SCRIPT + '"'], { allowFail: true, timeout: 45000 });
+    // Disconnect → restart daemon and try once more.
+    if (opened.startsWith('__ERR__') || /Failed to read|10060|timed out/i.test(opened)) {
+      ab(['close', '--all'], { allowFail: true, timeout: 20000 });
+      opened = ab(['open', '"' + url + '"', '--init-script', '"' + COLLECTOR_SCRIPT + '"'], { allowFail: true, timeout: 60000 });
+    }
+    // Page-template.js sets document.body.dataset.gridsReady once all grids are up.
+    // Sleep first instead of polling — fewer round-trips means fewer chances for
+    // the WS connection to time out.
+    return new Promise(resolve => setTimeout(() => resolve(), Math.max(3000, page.grids.length * 800)));
+  }
+
+  for (const page of PAGES) {
+    console.log('\n--- ' + page.file);
+    await runOne(page);
+    let raw = ab(['eval', '"' + COLLECT_EXPR + '"', '--json'], { allowFail: true, timeout: 30000 });
+    let parsed = decodeEval(raw);
+    if (parsed.parseError || raw.startsWith('__ERR__')) {
+      ab(['close', '--all'], { allowFail: true, timeout: 20000 });
+      await sleep(1500);
+      await runOne(page);
+      raw = ab(['eval', '"' + COLLECT_EXPR + '"', '--json'], { allowFail: true, timeout: 30000 });
+      parsed = decodeEval(raw);
+    }
+
+    const expectedGrids = page.grids;
+    const actualGrids = parsed.grids ? Object.keys(parsed.grids) : [];
+    const missing = expectedGrids.filter(g => !actualGrids.includes(g));
+    // Scenarios marked `expectEmpty` start with no data — the grid mounts but never
+    // renders rows. Treat presence + empty data as a PASS for those.
+    const judgeReady = (g) => {
+      const s = parsed.grids && parsed.grids[g] && parsed.grids[g].state;
+      if (!s) return false;
+      if (page.expectEmpty) return true; // mounted, intentionally empty
+      return !!(s.gridReady || s.firstDataRendered);
+    };
+    const judgeRows = (g) => {
+      if (page.expectEmpty) return true;
+      const r = parsed.grids && parsed.grids[g];
+      return r && r.domRows > 0;
+    };
+    const allReady = parsed.grids && expectedGrids.every(judgeReady);
+    const allHaveRows = parsed.grids && expectedGrids.every(judgeRows);
+
+    const status = parsed.fatal ? 'ERROR' :
+                   (missing.length ? 'MISSING' :
+                   (!allReady ? 'NOT_READY' :
+                   (!allHaveRows ? 'NO_DOM_ROWS' : 'PASS')));
+
+    console.log('  status:', status);
+    if (missing.length) console.log('  missing grids:', missing.join(','));
+    if (parsed.grids) {
+      for (const g of expectedGrids) {
+        const x = parsed.grids[g];
+        if (!x) continue;
+        console.log('  ' + g + ': count=' + x.count + ' domRows=' + x.domRows + ' state=' + JSON.stringify(x.state));
+      }
+    }
+    if (parsed.fatal) console.log('  fatal:', parsed.fatal);
+
+    findings.pages.push({ file: page.file, status, expectedGrids, missing, result: parsed });
+  }
+
+  findings.finishedAt = new Date().toISOString();
+  fs.writeFileSync(OUT_FILE, JSON.stringify(findings, null, 2));
+  const summary = findings.pages.map(p => ({ file: p.file, status: p.status, missing: p.missing }));
+  console.log('\\n=== summary ===');
+  console.table(summary);
+  console.log('wrote ' + OUT_FILE);
+})().catch(e => { console.error(e); process.exit(1); });

package/tests/serve.cjs

@@ -0,0 +1,66 @@
+// Minimal static server for the AG Grid test suite.
+// Serves the repo root on http://localhost:8765 with no caching.
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const url = require('url');
+
+const ROOT = path.resolve(__dirname, '..');
+const PORT = Number(process.env.AG_TEST_PORT || 8765);
+
+const MIME = {
+  '.html': 'text/html; charset=utf-8',
+  '.js':   'application/javascript; charset=utf-8',
+  '.cjs':  'application/javascript; charset=utf-8',
+  '.mjs':  'application/javascript; charset=utf-8',
+  '.css':  'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map':  'application/json; charset=utf-8',
+  '.svg':  'image/svg+xml',
+  '.png':  'image/png',
+  '.jpg':  'image/jpeg',
+  '.gif':  'image/gif',
+  '.ico':  'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2':'font/woff2',
+  '.ttf':  'font/ttf',
+  '.eot':  'application/vnd.ms-fontobject',
+  '.csv':  'text/csv; charset=utf-8'
+};
+
+const server = http.createServer((req, res) => {
+  const parsed = url.parse(req.url);
+  let rel = decodeURIComponent(parsed.pathname || '/');
+  if (rel === '/' || rel === '') rel = '/tests/index.html';
+  const abs = path.join(ROOT, rel);
+  if (!abs.startsWith(ROOT)) {
+    res.writeHead(403); res.end('forbidden'); return;
+  }
+  fs.stat(abs, (err, st) => {
+    if (err) { res.writeHead(404); res.end('not found: ' + rel); return; }
+    if (st.isDirectory()) {
+      const idx = path.join(abs, 'index.html');
+      if (fs.existsSync(idx)) {
+        sendFile(idx, res);
+      } else {
+        res.writeHead(404); res.end('directory listing disabled');
+      }
+      return;
+    }
+    sendFile(abs, res);
+  });
+});
+
+function sendFile(abs, res) {
+  const ext = path.extname(abs).toLowerCase();
+  res.writeHead(200, {
+    'content-type': MIME[ext] || 'application/octet-stream',
+    'cache-control': 'no-store',
+    'access-control-allow-origin': '*'
+  });
+  fs.createReadStream(abs).pipe(res);
+}
+
+server.listen(PORT, '127.0.0.1', () => {
+  console.log('ag-grid test suite serving on http://localhost:' + PORT + '/tests/index.html');
+});