@matware/e2e-runner 1.2.1 → 1.3.1

package/src/learner.js

@@ -17,8 +17,12 @@ const ERROR_CATEGORIES = [
   { pattern: /waitForSelector/i, category: 'selector-not-found' },
   { pattern: /not visible/i, category: 'selector-not-found' },
   { pattern: /navigation/i, category: 'navigation-error' },
-  { pattern: /net::ERR_/i, category: 'connection-refused' },
+  { pattern: /ERR_NAME_NOT_RESOLVED/i, category: 'dns-resolution' },
   { pattern: /ERR_CONNECTION_REFUSED/i, category: 'connection-refused' },
+  { pattern: /ECONNREFUSED/i, category: 'connection-refused' },
+  { pattern: /Chrome Pool unavailable/i, category: 'pool-unavailable' },
+  { pattern: /Failed to connect to pool/i, category: 'pool-connect-failed' },
+  { pattern: /net::ERR_/i, category: 'network-error' },
   { pattern: /assert_text/i, category: 'assert-text-failed' },
   { pattern: /assert_url/i, category: 'assert-url-failed' },
   { pattern: /assert_visible/i, category: 'assert-visible-failed' },
@@ -35,6 +39,18 @@ const ERROR_CATEGORIES = [
   { pattern: /evaluate.*ERROR/i, category: 'evaluate-error' },
 ];
 
+/** Categories that indicate infrastructure failures — not test/app issues. */
+export const INFRA_CATEGORIES = new Set([
+  'connection-refused', 'dns-resolution', 'pool-unavailable', 'pool-connect-failed', 'network-error',
+]);
+
+/** Returns true if the error is an infrastructure issue (pool down, DNS, connection refused). */
+export function isInfraError(errorMsg) {
+  if (!errorMsg) return false;
+  const { category } = categorizeError(errorMsg);
+  return INFRA_CATEGORIES.has(category);
+}
+
 export function categorizeError(errorMsg) {
   if (!errorMsg) return { category: 'unknown', pattern: 'unknown' };
 
@@ -204,6 +220,11 @@ export function learnFromRun(projectId, runDbId, report, config, suiteName) {
     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
+  const insertActionHealth = d.prepare(`
+    INSERT INTO action_health (project_id, run_id, test_name, action_index, action_type, selector, success, duration_ms, console_errors_after, network_errors_after, page_url)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
   const upsertErrorPattern = d.prepare(`
     INSERT INTO error_patterns (project_id, pattern, category, occurrence_count, first_seen, last_seen, example_error, example_test)
     VALUES (?, ?, ?, 1, datetime('now'), datetime('now'), ?, ?)
@@ -214,23 +235,40 @@ export function learnFromRun(projectId, runDbId, report, config, suiteName) {
       example_test = excluded.example_test
   `);
 
+  let infraCount = 0;
+
   const tx = d.transaction(() => {
     for (const result of results) {
       const durationMs = (result.endTime && result.startTime)
         ? new Date(result.endTime) - new Date(result.startTime)
         : null;
-      const isFlaky = result.success && (result.attempt || 1) > 1 ? 1 : 0;
+      const isFlaky = result.flaky ? 1 : (result.success && (result.attempt || 1) > 1 ? 1 : 0);
 
       // Categorize error
       let errorPattern = null;
+      let infraFailure = false;
       if (result.error) {
         const { category, pattern } = categorizeError(result.error);
         errorPattern = category;
+        infraFailure = INFRA_CATEGORIES.has(category);
 
-        // Track error pattern
+        // Always track error patterns (even infra) for awareness
         upsertErrorPattern.run(projectId, pattern, category, result.error, result.name);
       }
 
+      if (infraFailure) {
+        infraCount++;
+        // Still write test_learnings so run counts are accurate,
+        // but skip selector/page/api learnings to avoid polluting metrics
+        insertTestLearning.run(
+          projectId, runDbId, result.name,
+          result.success ? 1 : 0, durationMs, isFlaky,
+          result.attempt || 1, result.maxAttempts || 1,
+          errorPattern
+        );
+        continue;
+      }
+
       // Test-level learning
       insertTestLearning.run(
         projectId, runDbId, result.name,
@@ -275,6 +313,33 @@ export function learnFromRun(projectId, runDbId, report, config, suiteName) {
           api.isError, result.name
         );
       }
+
+      // Action health — per-action metrics with collateral error estimation
+      if (result.actions?.length) {
+        const totalConsoleErrors = (result.consoleLogs || []).filter(l => l.type === 'error').length;
+        const totalNetworkErrors = (result.networkErrors || []).length;
+        const actionCount = result.actions.length;
+        let currentPage = '/';
+
+        for (let i = 0; i < actionCount; i++) {
+          const action = result.actions[i];
+          if (action.type === 'goto' || action.type === 'navigate') {
+            try { currentPage = new URL(action.value, 'http://placeholder').pathname; } catch { currentPage = action.value || '/'; }
+          }
+          // Estimate collateral errors: later actions inherit more errors (weighted distribution)
+          const weight = (i + 1) / actionCount;
+          const consoleAfter = action.success === false ? Math.round(totalConsoleErrors * weight) : 0;
+          const networkAfter = action.success === false ? Math.round(totalNetworkErrors * weight) : 0;
+
+          insertActionHealth.run(
+            projectId, runDbId, result.name, i,
+            action.type || 'unknown', action.selector || null,
+            action.success === false ? 0 : 1,
+            action.duration || null,
+            consoleAfter, networkAfter, currentPage
+          );
+        }
+      }
     }
   });
 
@@ -287,6 +352,8 @@ export function learnFromRun(projectId, runDbId, report, config, suiteName) {
   if (config?.learningsNeo4j) {
     writeToGraph(projectId, runDbId, report, config, suiteName).catch(() => {});
   }
+
+  return { infraCount };
 }
 
 // ── Summary cache ─────────────────────────────────────────────────────────────
@@ -335,8 +402,11 @@ function updateLearningSummary(projectId, config) {
   // Unstable selectors
   const unstableSelectors = d.prepare(`
     SELECT selector,
+           MAX(action_type) AS action_type,
            ROUND(AVG(CASE WHEN success = 0 THEN 100.0 ELSE 0.0 END), 1) AS fail_rate,
-           COUNT(*) AS total_uses
+           COUNT(*) AS total_uses,
+           COUNT(DISTINCT test_name) AS used_by_tests,
+           MAX(page_url) AS page_url
     FROM selector_learnings
     WHERE project_id = ? AND created_at >= ${cutoff}
     GROUP BY selector
@@ -349,6 +419,7 @@ function updateLearningSummary(projectId, config) {
   const failingPages = d.prepare(`
     SELECT url_path,
            ROUND(AVG(CASE WHEN success = 0 THEN 100.0 ELSE 0.0 END), 1) AS fail_rate,
+           COUNT(*) AS total_visits,
            SUM(console_errors) AS console_errors,
            SUM(network_errors) AS network_errors
     FROM page_learnings
@@ -364,7 +435,8 @@ function updateLearningSummary(projectId, config) {
     SELECT endpoint,
            ROUND(AVG(CASE WHEN is_error = 1 THEN 100.0 ELSE 0.0 END), 1) AS error_rate,
            ROUND(AVG(duration_ms)) AS avg_duration_ms,
-           COUNT(*) AS total_calls
+           COUNT(*) AS total_calls,
+           GROUP_CONCAT(DISTINCT status) AS status_codes
     FROM api_learnings
     WHERE project_id = ? AND created_at >= ${cutoff}
     GROUP BY endpoint
@@ -375,7 +447,7 @@ function updateLearningSummary(projectId, config) {
 
   // Top errors
   const topErrors = d.prepare(`
-    SELECT pattern, category, occurrence_count, last_seen, example_error
+    SELECT pattern, category, occurrence_count, first_seen, last_seen, example_error AS example_test
     FROM error_patterns
     WHERE project_id = ?
     ORDER BY occurrence_count DESC