feat(web-test): управление пулом контекстов/лицензий в раннере

Раннер регресса теперь держит пул 1С-сеансов сам, вместо накопления контекстов между тестами и ручного закрытия в хуках. Три необязательных поля webtest.config.mjs (без них поведение прежнее): - maxContexts — потолок одновременно живых сеансов (null = без лимита); - contextPolicy — 'reuse' (держать открытыми в пределах лимита) | 'strict' (закрывать non-pinned контексты теста сразу после него); - pinnedContexts — не вытесняются LRU (default = [defaultContext]; [] делает default вытесняемым на тесном стенде). Перед setup каждого теста LRU-вытеснение освобождает слот под нужды теста; уже открытые нужные контексты переиспользуются. Default больше не вечно-pinned. Исчерпание пула даёт внятную ошибку вместо маскирующего «Browser not connected». - new: cli/test-runner/context-pool.mjs — чистый планировщик planEviction + LRU. - cli/commands/test.mjs (v1.4): парсинг/валидация полей, вытеснение с фолбэк-парковкой на нужный контекст (нельзя закрыть единственный активный), strict-закрытие, LRU-трекинг. - Доки: regression-spec (§7/§8/глоссарий), regression-guide (рецепт), regress.md. - Регресс дай-фудит фичу: 14-multi-context-routing роутит в 3-й контекст c, 15-multi-context-handover проверяет вытеснение c на границе; конфиг maxContexts:2. Юнит-краёв планировщика — в debug/ (gitignored). Live-регресс: 25/25 зелёных. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-09-17 15:25:23 +03:00 · 2026-07-15 14:57:56 +03:00
parent 9e1341b80b
commit 3f1168b975
9 changed files with 262 additions and 16 deletions
@@ -1,4 +1,4 @@
-// web-test cli/commands/test v1.3 — regression test runner
+// web-test cli/commands/test v1.4 — regression test runner
 // Source: https://github.com/Nikolay-Shirokov/cc-1c-skills
 import { existsSync, writeFileSync, mkdirSync } from 'fs';
 import { resolve, dirname, basename, relative } from 'path';
@@ -9,6 +9,7 @@ import { createAssertions } from '../test-runner/assertions.mjs';
 import { buildSeverityIndex } from '../test-runner/severity.mjs';
 import { writeAllure, buildJUnit, syncAllureExtras } from '../test-runner/reporters.mjs';
 import { discoverTests, resetState } from '../test-runner/discover.mjs';
+import { planEviction, touchLru, dropLru } from '../test-runner/context-pool.mjs';

 export async function cmdTest(rawArgs) {
  // Split off everything after `--` — those args belong to user-defined hooks
@@ -87,6 +88,32 @@ export async function cmdTest(rawArgs) {
  }
  if (!url) url = contextSpecs[defaultContextName].url;

+  // Context-pool config (license management). All three optional; without them the runner keeps
+  // its legacy behavior: default stays open, contexts accumulate, no eviction.
+  //   maxContexts    — cap on simultaneous 1C sessions (null = unlimited).
+  //   contextPolicy  — 'reuse' (keep open within the cap) | 'strict' (close a test's non-pinned
+  //                    contexts right after it, to release licenses ASAP).
+  //   pinnedContexts — never evicted by LRU. Defaults to [defaultContext] so today's "default is
+  //                    never closed between tests" holds; set [] to make default evictable.
+  let maxContexts = null;
+  if (config.maxContexts != null) {
+    if (!Number.isInteger(config.maxContexts) || config.maxContexts < 1) {
+      die(`Invalid maxContexts=${config.maxContexts} (expected a positive integer or omit for unlimited)`);
+    }
+    maxContexts = config.maxContexts;
+  }
+  const contextPolicy = config.contextPolicy == null ? 'reuse' : config.contextPolicy;
+  if (!['reuse', 'strict'].includes(contextPolicy)) {
+    die(`Invalid contextPolicy="${contextPolicy}" (expected 'reuse' or 'strict')`);
+  }
+  const pinnedContexts = Array.isArray(config.pinnedContexts) ? config.pinnedContexts : [defaultContextName];
+  for (const n of pinnedContexts) {
+    if (!contextSpecs[n]) die(`pinnedContexts entry "${n}" not found in contexts: [${Object.keys(contextSpecs).join(', ')}]`);
+  }
+  const pinnedSet = new Set(pinnedContexts);
+  // LRU usage order — oldest first, freshest last. Drives eviction under a maxContexts cap.
+  const lruOrder = [];
+
  // Apply config defaults (CLI flags override)
  if (!tags && config.tags) tags = config.tags;
  opts.timeout = ownArgs.some(a => a.startsWith('--timeout=')) ? opts.timeout : (config.timeout || opts.timeout);
@@ -210,8 +237,11 @@ export async function cmdTest(rawArgs) {
  }

  try {
-    // Connect: create default context up front
+    // Connect: create default context up front (hosts beforeAll / hooks). It is NOT permanently
+    // pinned — under a maxContexts cap it becomes an LRU eviction candidate unless it is listed in
+    // pinnedContexts. Register it in the LRU order.
    await ensureContext(defaultContextName);
+    touchLru(lruOrder, defaultContextName);

    const ctx = buildContext({ noRecord: false });
    ctx.assert = createAssertions();
@@ -244,8 +274,45 @@ export async function cmdTest(rawArgs) {

      const testContextNames = declaredContexts;
      try {
+        // Make room in the license pool before opening this test's contexts. Already-open needed
+        // contexts are reused (ensureContext no-ops); LRU-oldest non-pinned contexts are evicted.
+        const plan = planEviction({
+          open: browser.listContexts(),
+          needed: testContextNames,
+          pinned: pinnedSet,
+          max: maxContexts,
+          lruOrder,
+        });
+        if (plan.error) throw new Error(plan.error);
+        // Needed-but-not-yet-open contexts — also serve as a parking fallback when eviction would
+        // close the sole open context (can't closeContext the active slot with no survivor).
+        const toOpenQueue = testContextNames.filter(n => !browser.hasContext(n));
+        for (const name of plan.toEvict) {
+          if (browser.getActiveContext() === name) {
+            let survivor = browser.listContexts().find(n => n !== name);
+            if (!survivor) {
+              // `name` is the only open context. Open a needed one first to park on — room is
+              // guaranteed because we free `name` right after and multi-context implies max>=2.
+              if (browser.listContexts().length < maxContexts && toOpenQueue.length) {
+                const parkName = toOpenQueue.shift();
+                await ensureContext(parkName);
+                survivor = parkName;
+              } else {
+                throw new Error(`cannot evict "${name}": it is the only open context and maxContexts=${maxContexts} leaves no room to switch. Use maxContexts>=2 when tests alternate contexts.`);
+              }
+            }
+            await browser.setActiveContext(survivor);
+          }
+          if (hooks.beforeCloseContext && hookCtx) {
+            try { await hooks.beforeCloseContext(hookCtx, name, contextSpecs[name]); }
+            catch (e) { hookLog(`beforeCloseContext("${name}") threw: ${e.message.split('\n')[0]}`); }
+          }
+          await browser.closeContext(name);
+          dropLru(lruOrder, name);
+        }
        for (const cn of testContextNames) await ensureContext(cn);
        await browser.setActiveContext(testContextNames[0]);
+        touchLru(lruOrder, testContextNames);
      } catch (e) {
        W.write(`  ✗ ${t.name} (context setup failed: ${e.message})\n`);
        results.push({ name: t.name, file: t.file, tags: t.tags, contexts: declaredContexts, status: 'failed', duration: 0, attempts: 0, steps: [], output: '', error: { message: e.message }, screenshot: null });
@@ -385,6 +452,26 @@ export async function cmdTest(rawArgs) {
        }
      }

+      // strict policy: release this test's non-pinned contexts right after it (all attempts done),
+      // instead of keeping them for reuse. Frees 1C licenses ASAP on shared/tight stands. Parks
+      // active on a survivor before closing; never closes the sole remaining context.
+      if (contextPolicy === 'strict') {
+        for (const name of testContextNames) {
+          if (pinnedSet.has(name) || !browser.hasContext(name)) continue;
+          if (browser.getActiveContext() === name) {
+            const survivor = browser.listContexts().find(n => n !== name);
+            if (!survivor) continue; // can't close the sole active context — leave it open
+            try { await browser.setActiveContext(survivor); } catch {}
+          }
+          if (hooks.beforeCloseContext && hookCtx) {
+            try { await hooks.beforeCloseContext(hookCtx, name, contextSpecs[name]); }
+            catch (e) { hookLog(`beforeCloseContext("${name}") threw: ${e.message.split('\n')[0]}`); }
+          }
+          try { await browser.closeContext(name); } catch {}
+          dropLru(lruOrder, name);
+        }
+      }
+
      results.push(testResult);

      if (testResult.status === 'passed') {
@@ -0,0 +1,87 @@
+// web-test cli/test-runner/context-pool v1.0 — pure context-pool planner (LRU eviction).
+// Source: https://github.com/Nikolay-Shirokov/cc-1c-skills
+//
+// Decides which already-open contexts (each = one live 1C session = one license) to evict
+// so the next test's declared contexts fit within `maxContexts` simultaneous sessions.
+// Pure functions, no browser — unit-tested in context-pool.test.mjs.
+
+/**
+ * @param {object} p
+ * @param {string[]} p.open      currently open context names (live 1C sessions)
+ * @param {string[]} p.needed    context names the next test declares
+ * @param {Set<string>|string[]} [p.pinned] never-evict context names
+ * @param {number|null} [p.max]  simultaneous-session cap; null/undefined = unlimited
+ * @param {string[]} [p.lruOrder] usage order, oldest first / freshest last
+ * @returns {{ toEvict: string[], error: string|null }}
+ */
+export function planEviction({ open = [], needed = [], pinned = [], max = null, lruOrder = [] }) {
+  const pinnedSet = pinned instanceof Set ? pinned : new Set(pinned);
+  const neededSet = new Set(needed);
+  const openSet = new Set(open);
+
+  // Unlimited pool → never evict (back-compat: behaves like the pre-pool runner).
+  if (max == null) return { toEvict: [], error: null };
+
+  // Lower bound that must stay live regardless of eviction: this test's needed contexts, plus
+  // pinned contexts that are ALREADY open (pinned = "don't evict while open", NOT "always open" —
+  // a pinned context that is currently closed does not count against this test's budget).
+  const mustStay = new Set(needed);
+  for (const p of pinnedSet) if (openSet.has(p)) mustStay.add(p);
+  if (mustStay.size > max) {
+    return {
+      toEvict: [],
+      error: `context pool exhausted: this test needs ${mustStay.size} simultaneous 1C sessions `
+        + `(declared contexts + already-open pinned) but maxContexts=${max}. `
+        + `Raise maxContexts, reduce declared contexts, or shrink pinnedContexts.`,
+    };
+  }
+
+  // projected = everything live once we open `needed`. If it already fits, nothing to evict.
+  const projected = new Set([...open, ...needed]);
+  if (projected.size <= max) return { toEvict: [], error: null };
+
+  // Evictable = open, not pinned, not needed — oldest first by lruOrder.
+  const evictable = [];
+  for (const name of lruOrder) {
+    if (openSet.has(name) && !pinnedSet.has(name) && !neededSet.has(name)) evictable.push(name);
+  }
+  // Any open evictable missing from lruOrder → treat as oldest (evict first).
+  for (const name of open) {
+    if (!lruOrder.includes(name) && !pinnedSet.has(name) && !neededSet.has(name)) {
+      evictable.unshift(name);
+    }
+  }
+
+  const toEvict = [];
+  let size = projected.size;
+  for (const name of evictable) {
+    if (size <= max) break;
+    toEvict.push(name);
+    size--;
+  }
+  // Guaranteed size <= max here: after removing all evictable, projected collapses to
+  // (open ∩ pinned) ∪ needed == mustStay, and mustStay.size <= max passed the guard above.
+  return { toEvict, error: null };
+}
+
+/**
+ * Move `names` to the fresh end of the LRU order (most-recently-used last). Mutates and returns
+ * `lruOrder`. Idempotent per name — existing entries are relocated, not duplicated.
+ */
+export function touchLru(lruOrder, names) {
+  for (const n of (Array.isArray(names) ? names : [names])) {
+    const i = lruOrder.indexOf(n);
+    if (i >= 0) lruOrder.splice(i, 1);
+    lruOrder.push(n);
+  }
+  return lruOrder;
+}
+
+/** Remove `names` from the LRU order (e.g. after a context is closed). Mutates and returns it. */
+export function dropLru(lruOrder, names) {
+  for (const n of (Array.isArray(names) ? names : [names])) {
+    const i = lruOrder.indexOf(n);
+    if (i >= 0) lruOrder.splice(i, 1);
+  }
+  return lruOrder;
+}