@noctcore/eslint-plugin-code-quality 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -35,60 +45,22 @@ var recommended = {
   "noctcore-code-quality/no-narration-comments": "error",
   "noctcore-code-quality/no-pr-reference-comments": "error",
   "noctcore-code-quality/no-focused-tests": "error",
-  "noctcore-code-quality/skipped-tests-need-tracking": "error"
+  "noctcore-code-quality/skipped-tests-need-tracking": "error",
+  "noctcore-code-quality/no-vacuous-expect": "error",
+  "noctcore-code-quality/no-conditional-expect": "error",
+  "noctcore-code-quality/fake-timers-must-be-restored": "error",
+  "noctcore-code-quality/no-real-network-in-unit-tests": "error"
 };
 
-// src/rules/interface-prefix-i.ts
+// src/rules/fake-timers-must-be-restored.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
 var import_utils = require("@typescript-eslint/utils");
 
 // src/createRule.ts
 var import_eslint_utils = require("@noctcore/eslint-utils");
 var createRule = (0, import_eslint_utils.makeCreateRule)("code-quality");
 
-// src/rules/interface-prefix-i.ts
-var RULE_NAME = "interface-prefix-i";
-function isAlreadyPrefixed(name) {
-  return /^I[A-Z]/.test(name);
-}
-function isInsideAmbientModule(node) {
-  let current = node.parent;
-  while (current) {
-    if (current.type === import_utils.AST_NODE_TYPES.TSModuleDeclaration) {
-      return true;
-    }
-    current = current.parent;
-  }
-  return false;
-}
-var interfacePrefixIRule = createRule({
-  name: RULE_NAME,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Interface names must be prefixed with `I` followed by an uppercase letter. Module/global augmentations are exempt."
-    },
-    schema: [],
-    messages: {
-      missingPrefix: "Interface `{{name}}` must be prefixed with `I` (e.g. `I{{name}}`). Rename the declaration and its references."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    return {
-      TSInterfaceDeclaration(node) {
-        const name = node.id.name;
-        if (isAlreadyPrefixed(name) || isInsideAmbientModule(node)) {
-          return;
-        }
-        context.report({ node: node.id, messageId: "missingPrefix", data: { name } });
-      }
-    };
-  }
-});
-
-// src/rules/no-bare-date-now.ts
-var import_utils2 = require("@typescript-eslint/utils");
-
 // src/utils/allowMatch.ts
 var REGEX_METACHARACTERS = /[.*+?^${}()|[\]\\]/gu;
 function escapeLiteral(text) {
@@ -153,10 +125,216 @@ function matchesAny(filename, globs) {
   return globs.some((glob) => compile(glob).test(normalized));
 }
 
+// src/rules/fake-timers-must-be-restored.ts
+var RULE_NAME = "fake-timers-must-be-restored";
+var DEFAULT_FAKE_TIMER_METHODS = ["useFakeTimers"];
+var DEFAULT_RESTORE_TIMER_METHODS = ["useRealTimers"];
+var DEFAULT_FOLLOW_IMPORTED_SUITES = true;
+var DEFAULT_SHARED_SUITE_MODULES = [];
+var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var methodList = {
+  type: "array",
+  items: { type: "string", minLength: 1 },
+  uniqueItems: true,
+  minItems: 1
+};
+var optionSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    fakeTimerMethods: methodList,
+    restoreTimerMethods: methodList,
+    followImportedSuites: { type: "boolean" },
+    sharedSuiteModules: { type: "array", items: { type: "string", minLength: 1 }, uniqueItems: true }
+  }
+};
+var sourceCache = /* @__PURE__ */ new Map();
+function readSource(file) {
+  try {
+    const stat = import_node_fs.default.statSync(file);
+    if (!stat.isFile()) {
+      return null;
+    }
+    const cached = sourceCache.get(file);
+    if (cached !== void 0 && cached.mtimeMs === stat.mtimeMs) {
+      return cached.text;
+    }
+    const text = import_node_fs.default.readFileSync(file, "utf8");
+    sourceCache.set(file, { mtimeMs: stat.mtimeMs, text });
+    return text;
+  } catch (error) {
+    if (error instanceof Error && "code" in error) {
+      return null;
+    }
+    throw error;
+  }
+}
+function resolveRelative(fromFile, specifier) {
+  const base = import_node_path.default.resolve(import_node_path.default.dirname(fromFile), specifier);
+  const stem = base.replace(/\.(?:[cm]?js|jsx)$/u, "");
+  const candidates = [
+    base,
+    ...RESOLVE_EXTENSIONS.map((ext) => stem + ext),
+    ...RESOLVE_EXTENSIONS.map((ext) => import_node_path.default.join(base, `index${ext}`))
+  ];
+  for (const candidate of candidates) {
+    if (readSource(candidate) !== null) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function importIsCalled(sourceCode, declaration) {
+  return sourceCode.getDeclaredVariables(declaration).some(
+    (variable) => variable.references.some((reference) => {
+      const parent = reference.identifier.parent;
+      if (parent.type === import_utils.AST_NODE_TYPES.CallExpression && parent.callee === reference.identifier) {
+        return true;
+      }
+      return parent.type === import_utils.AST_NODE_TYPES.MemberExpression && parent.object === reference.identifier && parent.parent.type === import_utils.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent;
+    })
+  );
+}
+function calledMethodName(node) {
+  const callee = node.callee;
+  if (callee.type === import_utils.AST_NODE_TYPES.Identifier) {
+    return callee.name;
+  }
+  if (callee.type === import_utils.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils.AST_NODE_TYPES.Identifier) {
+    return callee.property.name;
+  }
+  return null;
+}
+var fakeTimersMustBeRestoredRule = createRule({
+  name: RULE_NAME,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A test file that calls `useFakeTimers()` must also call `useRealTimers()`, so fake timers do not leak into later tests."
+    },
+    schema: [optionSchema],
+    messages: {
+      timersNotRestored: "`{{method}}()` is called without a matching restore call, so fake timers leak into other tests. Call `useRealTimers()` in an `afterEach`, here or in the shared suite this file runs."
+    }
+  },
+  defaultOptions: [
+    {
+      fakeTimerMethods: [...DEFAULT_FAKE_TIMER_METHODS],
+      restoreTimerMethods: [...DEFAULT_RESTORE_TIMER_METHODS],
+      followImportedSuites: DEFAULT_FOLLOW_IMPORTED_SUITES,
+      sharedSuiteModules: [...DEFAULT_SHARED_SUITE_MODULES]
+    }
+  ],
+  create(context, [options]) {
+    const fakeMethods = new Set(options.fakeTimerMethods ?? DEFAULT_FAKE_TIMER_METHODS);
+    const restoreMethodList = options.restoreTimerMethods ?? DEFAULT_RESTORE_TIMER_METHODS;
+    const restoreMethods = new Set(restoreMethodList);
+    const followImportedSuites = options.followImportedSuites ?? DEFAULT_FOLLOW_IMPORTED_SUITES;
+    const sharedSuiteModules = options.sharedSuiteModules ?? DEFAULT_SHARED_SUITE_MODULES;
+    const restoreCallPattern = new RegExp(
+      `\\b(?:${restoreMethodList.map(escapeRegExp).join("|")})\\s*\\(`,
+      "u"
+    );
+    const fakeCalls = [];
+    const imports = [];
+    let hasRestore = false;
+    function restoredByImportedSuite() {
+      return imports.some((declaration) => {
+        const specifier = declaration.source.value;
+        if (!importIsCalled(context.sourceCode, declaration)) {
+          return false;
+        }
+        if (matchesAny(specifier, sharedSuiteModules)) {
+          return true;
+        }
+        if (!followImportedSuites || !specifier.startsWith(".")) {
+          return false;
+        }
+        const resolved = resolveRelative(context.filename, specifier);
+        const text = resolved === null ? null : readSource(resolved);
+        return text !== null && restoreCallPattern.test(text);
+      });
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind !== "type") {
+          imports.push(node);
+        }
+      },
+      CallExpression(node) {
+        const method = calledMethodName(node);
+        if (method === null) {
+          return;
+        }
+        if (fakeMethods.has(method)) {
+          fakeCalls.push({ node, method });
+        }
+        if (restoreMethods.has(method)) {
+          hasRestore = true;
+        }
+      },
+      "Program:exit"() {
+        if (fakeCalls.length === 0 || hasRestore || restoredByImportedSuite()) {
+          return;
+        }
+        for (const { node, method } of fakeCalls) {
+          context.report({ node, messageId: "timersNotRestored", data: { method } });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/interface-prefix-i.ts
+var import_utils2 = require("@typescript-eslint/utils");
+var RULE_NAME2 = "interface-prefix-i";
+function isAlreadyPrefixed(name) {
+  return /^I[A-Z]/.test(name);
+}
+function isInsideAmbientModule(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === import_utils2.AST_NODE_TYPES.TSModuleDeclaration) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+var interfacePrefixIRule = createRule({
+  name: RULE_NAME2,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Interface names must be prefixed with `I` followed by an uppercase letter. Module/global augmentations are exempt."
+    },
+    schema: [],
+    messages: {
+      missingPrefix: "Interface `{{name}}` must be prefixed with `I` (e.g. `I{{name}}`). Rename the declaration and its references."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        const name = node.id.name;
+        if (isAlreadyPrefixed(name) || isInsideAmbientModule(node)) {
+          return;
+        }
+        context.report({ node: node.id, messageId: "missingPrefix", data: { name } });
+      }
+    };
+  }
+});
+
 // src/rules/no-bare-date-now.ts
-var RULE_NAME2 = "no-bare-date-now";
+var import_utils3 = require("@typescript-eslint/utils");
+var RULE_NAME3 = "no-bare-date-now";
 var DEFAULT_ALLOW_IN = ["**/clock.ts", "**/clock/**"];
-var optionSchema = {
+var optionSchema2 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -169,19 +347,19 @@ var optionSchema = {
 };
 function isDateNowCall(node) {
   const callee = node.callee;
-  return callee.type === import_utils2.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils2.AST_NODE_TYPES.Identifier && callee.object.name === "Date" && callee.property.type === import_utils2.AST_NODE_TYPES.Identifier && callee.property.name === "now";
+  return callee.type === import_utils3.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils3.AST_NODE_TYPES.Identifier && callee.object.name === "Date" && callee.property.type === import_utils3.AST_NODE_TYPES.Identifier && callee.property.name === "now";
 }
 function isBareNewDate(node) {
-  return node.callee.type === import_utils2.AST_NODE_TYPES.Identifier && node.callee.name === "Date" && node.arguments.length === 0;
+  return node.callee.type === import_utils3.AST_NODE_TYPES.Identifier && node.callee.name === "Date" && node.arguments.length === 0;
 }
 var noBareDateNowRule = createRule({
-  name: RULE_NAME2,
+  name: RULE_NAME3,
   meta: {
     type: "problem",
     docs: {
       description: "Disallow bare `Date.now()` / `new Date()` in business logic. Read wall-clock time through a shared `clock` util (`nowMs()` / `now()`) so time is mockable."
     },
-    schema: [optionSchema],
+    schema: [optionSchema2],
     messages: {
       dateNow: "Use `nowMs()` from the shared `clock` util instead of bare `Date.now()`.",
       newDate: "Use `now()` from the shared `clock` util instead of bare `new Date()`."
@@ -208,20 +386,169 @@ var noBareDateNowRule = createRule({
   }
 });
 
+// src/rules/no-conditional-expect.ts
+var import_utils4 = require("@typescript-eslint/utils");
+var RULE_NAME4 = "no-conditional-expect";
+var DEFAULT_CHECK_LOOPS = false;
+var BRANCH_TYPES = /* @__PURE__ */ new Set([
+  import_utils4.AST_NODE_TYPES.IfStatement,
+  import_utils4.AST_NODE_TYPES.SwitchCase,
+  import_utils4.AST_NODE_TYPES.ConditionalExpression,
+  import_utils4.AST_NODE_TYPES.LogicalExpression,
+  import_utils4.AST_NODE_TYPES.CatchClause
+]);
+var LOOP_TYPES = /* @__PURE__ */ new Set([
+  import_utils4.AST_NODE_TYPES.ForStatement,
+  import_utils4.AST_NODE_TYPES.ForInStatement,
+  import_utils4.AST_NODE_TYPES.ForOfStatement,
+  import_utils4.AST_NODE_TYPES.WhileStatement,
+  import_utils4.AST_NODE_TYPES.DoWhileStatement
+]);
+var RUNNERS = /* @__PURE__ */ new Set(["it", "test", "describe", "suite"]);
+var ASSERTION_COUNT_GUARDS = /* @__PURE__ */ new Set(["assertions", "hasAssertions"]);
+var optionSchema3 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    checkLoops: { type: "boolean" }
+  }
+};
+function isExpectCall(node) {
+  const callee = node.callee;
+  if (callee.type === import_utils4.AST_NODE_TYPES.Identifier) {
+    return callee.name === "expect";
+  }
+  return callee.type === import_utils4.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils4.AST_NODE_TYPES.Identifier && callee.property.type === import_utils4.AST_NODE_TYPES.Identifier && callee.property.name === "expect";
+}
+function isAssertionCountGuard(node) {
+  const callee = node.callee;
+  return callee.type === import_utils4.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils4.AST_NODE_TYPES.Identifier && callee.object.name === "expect" && callee.property.type === import_utils4.AST_NODE_TYPES.Identifier && ASSERTION_COUNT_GUARDS.has(callee.property.name);
+}
+function runnerName(callee) {
+  let current = callee;
+  for (; ; ) {
+    if (current.type === import_utils4.AST_NODE_TYPES.MemberExpression) {
+      current = current.object;
+    } else if (current.type === import_utils4.AST_NODE_TYPES.CallExpression) {
+      current = current.callee;
+    } else if (current.type === import_utils4.AST_NODE_TYPES.TaggedTemplateExpression) {
+      current = current.tag;
+    } else {
+      break;
+    }
+  }
+  return current.type === import_utils4.AST_NODE_TYPES.Identifier ? current.name : null;
+}
+function isRunnerCallback(node) {
+  const parent = node.parent;
+  if (parent.type !== import_utils4.AST_NODE_TYPES.CallExpression || !parent.arguments.some((argument) => argument === node)) {
+    return false;
+  }
+  const name = runnerName(parent.callee);
+  return name !== null && RUNNERS.has(name);
+}
+function isFunctionNode(node) {
+  return node.type === import_utils4.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils4.AST_NODE_TYPES.FunctionExpression || node.type === import_utils4.AST_NODE_TYPES.FunctionDeclaration;
+}
+function isUnconditionalPart(node, child) {
+  switch (node.type) {
+    case import_utils4.AST_NODE_TYPES.IfStatement:
+    case import_utils4.AST_NODE_TYPES.ConditionalExpression:
+      return node.test === child;
+    case import_utils4.AST_NODE_TYPES.LogicalExpression:
+      return node.left === child;
+    case import_utils4.AST_NODE_TYPES.SwitchCase:
+      return node.test === child;
+    case import_utils4.AST_NODE_TYPES.ForStatement:
+      return node.init === child;
+    case import_utils4.AST_NODE_TYPES.ForInStatement:
+    case import_utils4.AST_NODE_TYPES.ForOfStatement:
+      return node.right === child;
+    default:
+      return false;
+  }
+}
+var noConditionalExpectRule = createRule({
+  name: RULE_NAME4,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `expect()` inside a branch, `catch` or loop that may not run: a skipped assertion lets a broken test pass."
+    },
+    schema: [optionSchema3],
+    messages: {
+      conditionalExpect: "This `expect()` sits inside a branch that may not run, so the test can pass without asserting anything. Assert unconditionally, or add `expect.assertions(n)` to the test."
+    }
+  },
+  defaultOptions: [{ checkLoops: DEFAULT_CHECK_LOOPS }],
+  create(context, [options]) {
+    const checkLoops = options.checkLoops ?? DEFAULT_CHECK_LOOPS;
+    const pending = /* @__PURE__ */ new Map();
+    const guarded = /* @__PURE__ */ new Set();
+    function isConditional(type) {
+      return BRANCH_TYPES.has(type) || checkLoops && LOOP_TYPES.has(type);
+    }
+    function scan(node) {
+      let conditional = false;
+      let child = node;
+      let current = node.parent;
+      while (current !== void 0 && current !== null) {
+        if (isFunctionNode(current) && isRunnerCallback(current)) {
+          return { boundary: current, conditional };
+        }
+        if (isConditional(current.type) && !isUnconditionalPart(current, child)) {
+          conditional = true;
+        }
+        child = current;
+        current = current.parent;
+      }
+      return { boundary: null, conditional };
+    }
+    return {
+      CallExpression(node) {
+        if (isAssertionCountGuard(node)) {
+          guarded.add(scan(node).boundary);
+          return;
+        }
+        if (!isExpectCall(node)) {
+          return;
+        }
+        const { boundary, conditional } = scan(node);
+        if (!conditional) {
+          return;
+        }
+        const list = pending.get(boundary) ?? [];
+        list.push(node);
+        pending.set(boundary, list);
+      },
+      "Program:exit"() {
+        for (const [boundary, calls] of pending) {
+          if (guarded.has(boundary)) {
+            continue;
+          }
+          for (const call of calls) {
+            context.report({ node: call, messageId: "conditionalExpect" });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/no-focused-tests.ts
-var import_utils3 = require("@typescript-eslint/utils");
-var RULE_NAME3 = "no-focused-tests";
+var import_utils5 = require("@typescript-eslint/utils");
+var RULE_NAME5 = "no-focused-tests";
 var FOCUSABLE_RUNNERS = /* @__PURE__ */ new Set(["it", "describe", "test"]);
 var FOCUSED_CALL_NAMES = /* @__PURE__ */ new Set(["fdescribe", "fit", "ddescribe"]);
 function rootRunnerName(node) {
   let current = node;
-  while (current.type === import_utils3.AST_NODE_TYPES.MemberExpression && !current.computed) {
+  while (current.type === import_utils5.AST_NODE_TYPES.MemberExpression && !current.computed) {
     current = current.object;
   }
-  return current.type === import_utils3.AST_NODE_TYPES.Identifier ? current.name : null;
+  return current.type === import_utils5.AST_NODE_TYPES.Identifier ? current.name : null;
 }
 var noFocusedTestsRule = createRule({
-  name: RULE_NAME3,
+  name: RULE_NAME5,
   meta: {
     type: "problem",
     docs: {
@@ -237,7 +564,7 @@ var noFocusedTestsRule = createRule({
   create(context) {
     return {
       MemberExpression(node) {
-        if (node.property.type !== import_utils3.AST_NODE_TYPES.Identifier || node.property.name !== "only") {
+        if (node.property.type !== import_utils5.AST_NODE_TYPES.Identifier || node.property.name !== "only") {
           return;
         }
         const runner = rootRunnerName(node.object);
@@ -250,7 +577,7 @@ var noFocusedTestsRule = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils3.AST_NODE_TYPES.Identifier && FOCUSED_CALL_NAMES.has(node.callee.name)) {
+        if (node.callee.type === import_utils5.AST_NODE_TYPES.Identifier && FOCUSED_CALL_NAMES.has(node.callee.name)) {
           const name = node.callee.name;
           context.report({
             node: node.callee,
@@ -275,7 +602,7 @@ function looksLikeJsDoc(comment) {
 }
 
 // src/rules/no-historical-comments.ts
-var RULE_NAME4 = "no-historical-comments";
+var RULE_NAME6 = "no-historical-comments";
 var HISTORICAL_PATTERNS = [
   /\bbefore\s+the\s+fix\b/iu,
   /\bafter\s+the\s+fix\b/iu,
@@ -290,7 +617,7 @@ var HISTORICAL_PATTERNS = [
   /\bhistorical(?:ly)?\b/iu
 ];
 var noHistoricalCommentsRule = createRule({
-  name: RULE_NAME4,
+  name: RULE_NAME6,
   meta: {
     type: "suggestion",
     docs: {
@@ -333,7 +660,7 @@ var noHistoricalCommentsRule = createRule({
 });
 
 // src/rules/no-narration-comments.ts
-var RULE_NAME5 = "no-narration-comments";
+var RULE_NAME7 = "no-narration-comments";
 var NARRATION_PATTERNS = [
   /^here\s+we\b/iu,
   /^now\s+we\b/iu,
@@ -345,7 +672,7 @@ var NARRATION_PATTERNS = [
   /^let\s+me\b/iu
 ];
 var noNarrationCommentsRule = createRule({
-  name: RULE_NAME5,
+  name: RULE_NAME7,
   meta: {
     type: "suggestion",
     docs: {
@@ -386,7 +713,7 @@ var noNarrationCommentsRule = createRule({
 });
 
 // src/rules/no-pr-reference-comments.ts
-var RULE_NAME6 = "no-pr-reference-comments";
+var RULE_NAME8 = "no-pr-reference-comments";
 var PR_PATTERNS = [
   {
     pattern: /https?:\/\/github\.com\/[^\s)]+\/(?:pull|issues)\/\d+/iu,
@@ -406,7 +733,7 @@ var PR_PATTERNS = [
   }
 ];
 var noPrReferenceCommentsRule = createRule({
-  name: RULE_NAME6,
+  name: RULE_NAME8,
   meta: {
     type: "suggestion",
     docs: {
@@ -447,32 +774,32 @@ var noPrReferenceCommentsRule = createRule({
 });
 
 // src/rules/no-process-exit.ts
-var import_utils5 = require("@typescript-eslint/utils");
+var import_utils7 = require("@typescript-eslint/utils");
 
 // src/utils/ast.ts
-var import_utils4 = require("@typescript-eslint/utils");
+var import_utils6 = require("@typescript-eslint/utils");
 function isEmptyStringLiteral(node) {
-  return node.type === import_utils4.AST_NODE_TYPES.Literal && node.value === "";
+  return node.type === import_utils6.AST_NODE_TYPES.Literal && node.value === "";
 }
 function isStaticMemberAccess(node, objectName, propertyName) {
-  if (node.type !== import_utils4.AST_NODE_TYPES.MemberExpression || node.object.type !== import_utils4.AST_NODE_TYPES.Identifier || node.object.name !== objectName) {
+  if (node.type !== import_utils6.AST_NODE_TYPES.MemberExpression || node.object.type !== import_utils6.AST_NODE_TYPES.Identifier || node.object.name !== objectName) {
     return false;
   }
   if (node.computed) {
-    return node.property.type === import_utils4.AST_NODE_TYPES.Literal && node.property.value === propertyName;
+    return node.property.type === import_utils6.AST_NODE_TYPES.Literal && node.property.value === propertyName;
   }
-  return node.property.type === import_utils4.AST_NODE_TYPES.Identifier && node.property.name === propertyName;
+  return node.property.type === import_utils6.AST_NODE_TYPES.Identifier && node.property.name === propertyName;
 }
 
 // src/rules/no-process-exit.ts
-var RULE_NAME7 = "no-process-exit";
+var RULE_NAME9 = "no-process-exit";
 var DEFAULT_ALLOW_IN2 = [
   "**/scripts/**",
   "**/bin/**",
   "**/cli/**",
   "**/*.config.{ts,js,mjs,cjs,cts,mts}"
 ];
-var optionSchema2 = {
+var optionSchema4 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -487,13 +814,13 @@ function isProcessExit(node) {
   return isStaticMemberAccess(node.callee, "process", "exit");
 }
 var noProcessExitRule = createRule({
-  name: RULE_NAME7,
+  name: RULE_NAME9,
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `process.exit()` outside bootstrap/shutdown paths and standalone CLIs. Application and service code must throw or reject so the lifecycle can shut down gracefully."
     },
-    schema: [optionSchema2],
+    schema: [optionSchema4],
     messages: {
       processExit: "`process.exit()` is reserved for bootstrap/shutdown and CLI entrypoints. Throw or reject and let the lifecycle handle teardown."
     }
@@ -514,14 +841,207 @@ var noProcessExitRule = createRule({
   }
 });
 
+// src/rules/no-real-network-in-unit-tests.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_utils8 = require("@typescript-eslint/utils");
+var RULE_NAME10 = "no-real-network-in-unit-tests";
+var DEFAULT_TEST_FILE_SUFFIXES = [
+  ".test.ts",
+  ".test.tsx",
+  ".spec.ts",
+  ".spec.tsx",
+  ".test.js",
+  ".test.jsx",
+  ".spec.js",
+  ".spec.jsx"
+];
+var DEFAULT_INTEGRATION_MARKERS = [
+  ".integration.test.",
+  ".integration.spec.",
+  ".e2e.test.",
+  ".e2e.spec.",
+  ".e2e-spec.",
+  "/integration/",
+  "/e2e/"
+];
+var DEFAULT_NETWORK_CALLEES = ["fetch"];
+var DEFAULT_HTTP_CLIENTS = ["axios"];
+var HTTP_CLIENT_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options",
+  "request"
+]);
+var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "window", "self", "global"]);
+var MODULE_MOCKERS = /* @__PURE__ */ new Set(["mock", "doMock", "unstable_mockModule"]);
+var GLOBAL_STUBBERS = /* @__PURE__ */ new Set(["stubGlobal", "spyOn", "replaceProperty"]);
+var stringList = {
+  type: "array",
+  items: { type: "string", minLength: 1 },
+  uniqueItems: true
+};
+var optionSchema5 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    testFileSuffixes: stringList,
+    integrationMarkers: stringList,
+    networkCallees: stringList,
+    httpClients: stringList
+  }
+};
+function toPosixRelative(filename, cwd) {
+  const relative = import_node_path2.default.isAbsolute(filename) ? import_node_path2.default.relative(cwd, filename) : filename;
+  return `/${relative.split(import_node_path2.default.sep).join("/")}`;
+}
+function staticPropertyName(member) {
+  if (!member.computed && member.property.type === import_utils8.AST_NODE_TYPES.Identifier) {
+    return member.property.name;
+  }
+  if (member.property.type === import_utils8.AST_NODE_TYPES.Literal && typeof member.property.value === "string") {
+    return member.property.value;
+  }
+  return null;
+}
+function stringArgument(node, index) {
+  const argument = node.arguments[index];
+  return argument?.type === import_utils8.AST_NODE_TYPES.Literal && typeof argument.value === "string" ? argument.value : null;
+}
+var noRealNetworkInUnitTestsRule = createRule({
+  name: RULE_NAME10,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Unit tests must not perform real network I/O: mock the HTTP client, or move the test to an integration suite."
+    },
+    schema: [optionSchema5],
+    messages: {
+      realNetworkInUnitTest: "Real network call `{{callee}}` in a unit test. Mock it, or move this test to an integration file."
+    }
+  },
+  defaultOptions: [
+    {
+      testFileSuffixes: [...DEFAULT_TEST_FILE_SUFFIXES],
+      integrationMarkers: [...DEFAULT_INTEGRATION_MARKERS],
+      networkCallees: [...DEFAULT_NETWORK_CALLEES],
+      httpClients: [...DEFAULT_HTTP_CLIENTS]
+    }
+  ],
+  create(context, [options]) {
+    const testSuffixes = options.testFileSuffixes ?? DEFAULT_TEST_FILE_SUFFIXES;
+    const integrationMarkers = options.integrationMarkers ?? DEFAULT_INTEGRATION_MARKERS;
+    const networkCallees = new Set(options.networkCallees ?? DEFAULT_NETWORK_CALLEES);
+    const httpClients = new Set(options.httpClients ?? DEFAULT_HTTP_CLIENTS);
+    const relPath = toPosixRelative(context.filename, context.cwd);
+    if (!testSuffixes.some((suffix) => relPath.endsWith(suffix))) {
+      return {};
+    }
+    if (integrationMarkers.some((marker) => relPath.includes(marker))) {
+      return {};
+    }
+    const findings = [];
+    const mocked = /* @__PURE__ */ new Set();
+    const importSources = /* @__PURE__ */ new Map();
+    function isLocalDouble(node, name) {
+      let scope = context.sourceCode.getScope(node);
+      while (scope !== null) {
+        const variable = scope.set.get(name);
+        if (variable !== void 0 && variable.defs.length > 0) {
+          return variable.defs.every((def) => def.type !== "ImportBinding");
+        }
+        scope = scope.upper;
+      }
+      return false;
+    }
+    function recordMock(node) {
+      const callee = node.callee;
+      if (callee.type !== import_utils8.AST_NODE_TYPES.MemberExpression) {
+        return;
+      }
+      const method = staticPropertyName(callee);
+      if (method !== null && MODULE_MOCKERS.has(method)) {
+        const moduleName = stringArgument(node, 0);
+        if (moduleName !== null) {
+          mocked.add(moduleName);
+        }
+      }
+      if (method !== null && GLOBAL_STUBBERS.has(method)) {
+        const name = method === "stubGlobal" ? stringArgument(node, 0) : stringArgument(node, 1);
+        if (name !== null) {
+          mocked.add(name);
+        }
+      }
+    }
+    function networkCallee(node) {
+      const callee = node.callee;
+      if (callee.type === import_utils8.AST_NODE_TYPES.Identifier) {
+        const isNetworkName = networkCallees.has(callee.name) || httpClients.has(callee.name);
+        return isNetworkName && !isLocalDouble(callee, callee.name) ? callee.name : null;
+      }
+      if (callee.type !== import_utils8.AST_NODE_TYPES.MemberExpression) {
+        return null;
+      }
+      const method = staticPropertyName(callee);
+      if (method === null || callee.object.type !== import_utils8.AST_NODE_TYPES.Identifier) {
+        return null;
+      }
+      const receiver = callee.object.name;
+      if (GLOBAL_RECEIVERS.has(receiver) && networkCallees.has(method)) {
+        return method;
+      }
+      if (httpClients.has(receiver) && HTTP_CLIENT_METHODS.has(method) && !isLocalDouble(callee.object, receiver)) {
+        return `${receiver}.${method}`;
+      }
+      return null;
+    }
+    return {
+      ImportDeclaration(node) {
+        for (const specifier of node.specifiers) {
+          importSources.set(specifier.local.name, node.source.value);
+        }
+      },
+      CallExpression(node) {
+        recordMock(node);
+        const callee = networkCallee(node);
+        if (callee !== null) {
+          findings.push({ node, callee });
+        }
+      },
+      AssignmentExpression(node) {
+        const target = node.left;
+        if (target.type === import_utils8.AST_NODE_TYPES.MemberExpression && target.object.type === import_utils8.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS.has(target.object.name)) {
+          const name = staticPropertyName(target);
+          if (name !== null) {
+            mocked.add(name);
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const { node, callee } of findings) {
+          const root = callee.split(".")[0] ?? callee;
+          const source = importSources.get(root);
+          if (mocked.has(root) || source !== void 0 && mocked.has(source)) {
+            continue;
+          }
+          context.report({ node, messageId: "realNetworkInUnitTest", data: { callee } });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/no-template-trim-empty-ternary.ts
-var import_utils6 = require("@typescript-eslint/utils");
-var RULE_NAME8 = "no-template-trim-empty-ternary";
+var import_utils9 = require("@typescript-eslint/utils");
+var RULE_NAME11 = "no-template-trim-empty-ternary";
 function isTrimCallOnTemplate(node) {
-  return node.type === import_utils6.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils6.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils6.AST_NODE_TYPES.Identifier && node.callee.property.name === "trim" && node.callee.object.type === import_utils6.AST_NODE_TYPES.TemplateLiteral;
+  return node.type === import_utils9.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils9.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils9.AST_NODE_TYPES.Identifier && node.callee.property.name === "trim" && node.callee.object.type === import_utils9.AST_NODE_TYPES.TemplateLiteral;
 }
 function matchesTemplateTrimEmptyTest(test) {
-  if (test.type !== import_utils6.AST_NODE_TYPES.BinaryExpression) {
+  if (test.type !== import_utils9.AST_NODE_TYPES.BinaryExpression) {
     return false;
   }
   if (test.operator !== "===" && test.operator !== "!==") {
@@ -530,7 +1050,7 @@ function matchesTemplateTrimEmptyTest(test) {
   return isTrimCallOnTemplate(test.left) && isEmptyStringLiteral(test.right) || isEmptyStringLiteral(test.left) && isTrimCallOnTemplate(test.right);
 }
 var noTemplateTrimEmptyTernaryRule = createRule({
-  name: RULE_NAME8,
+  name: RULE_NAME11,
   meta: {
     type: "suggestion",
     docs: {
@@ -554,10 +1074,10 @@ var noTemplateTrimEmptyTernaryRule = createRule({
 });
 
 // src/utils/preferEarlyReturn.ts
-var import_utils7 = require("@typescript-eslint/utils");
+var import_utils10 = require("@typescript-eslint/utils");
 var MIN_CONSEQUENT_STATEMENTS = 2;
 function getFunctionBlockBody(node) {
-  if (node.body.type !== import_utils7.AST_NODE_TYPES.BlockStatement) {
+  if (node.body.type !== import_utils10.AST_NODE_TYPES.BlockStatement) {
     return null;
   }
   return node.body;
@@ -567,13 +1087,13 @@ function findWrappedHappyPathIf(body) {
     return null;
   }
   const lastStatement = body.body[body.body.length - 1];
-  if (lastStatement === void 0 || lastStatement.type !== import_utils7.AST_NODE_TYPES.IfStatement) {
+  if (lastStatement === void 0 || lastStatement.type !== import_utils10.AST_NODE_TYPES.IfStatement) {
     return null;
   }
   if (lastStatement.alternate !== null) {
     return null;
   }
-  if (lastStatement.consequent.type !== import_utils7.AST_NODE_TYPES.BlockStatement) {
+  if (lastStatement.consequent.type !== import_utils10.AST_NODE_TYPES.BlockStatement) {
     return null;
   }
   if (lastStatement.consequent.body.length < MIN_CONSEQUENT_STATEMENTS) {
@@ -583,9 +1103,9 @@ function findWrappedHappyPathIf(body) {
 }
 
 // src/rules/prefer-early-return.ts
-var RULE_NAME9 = "prefer-early-return";
+var RULE_NAME12 = "prefer-early-return";
 var preferEarlyReturnRule = createRule({
-  name: RULE_NAME9,
+  name: RULE_NAME12,
   meta: {
     type: "problem",
     docs: {
@@ -616,8 +1136,189 @@ var preferEarlyReturnRule = createRule({
   }
 });
 
+// src/rules/no-vacuous-expect.ts
+var import_utils11 = require("@typescript-eslint/utils");
+var RULE_NAME13 = "no-vacuous-expect";
+var DEFAULT_WEAK_MATCHERS = [
+  "toBeDefined",
+  "toBeTruthy",
+  "toBeFalsy",
+  "not.toBeUndefined"
+];
+var DEFAULT_ASSERTION_CALLEES = ["^assert", "^expect\\w", "\\.expect$"];
+var TYPEOF_RESULTS = /* @__PURE__ */ new Set([
+  "undefined",
+  "object",
+  "boolean",
+  "number",
+  "bigint",
+  "string",
+  "symbol",
+  "function"
+]);
+var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+var TEST_RUNNERS = /* @__PURE__ */ new Set(["it", "test"]);
+var optionSchema6 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    weakMatchers: { type: "array", items: { type: "string", minLength: 1 }, uniqueItems: true },
+    assertionCallees: {
+      type: "array",
+      items: { type: "string", minLength: 1 },
+      uniqueItems: true
+    }
+  }
+};
+function isExpectCall2(node) {
+  return node.type === import_utils11.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils11.AST_NODE_TYPES.Identifier && node.callee.name === "expect";
+}
+function matcherCall(node) {
+  const callee = node.callee;
+  if (callee.type !== import_utils11.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils11.AST_NODE_TYPES.Identifier) {
+    return null;
+  }
+  let negated = false;
+  let current = callee.object;
+  while (current.type === import_utils11.AST_NODE_TYPES.MemberExpression) {
+    if (!current.computed && current.property.type === import_utils11.AST_NODE_TYPES.Identifier && current.property.name === "not") {
+      negated = !negated;
+    }
+    current = current.object;
+  }
+  if (!isExpectCall2(current)) {
+    return null;
+  }
+  const name = callee.property.name;
+  return { root: current, matcher: negated ? `not.${name}` : name };
+}
+function calleePath(callee) {
+  if (callee.type === import_utils11.AST_NODE_TYPES.Identifier) {
+    return callee.name;
+  }
+  if (callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils11.AST_NODE_TYPES.Identifier) {
+    const owner = callee.object.type === import_utils11.AST_NODE_TYPES.Identifier ? callee.object.name : "";
+    return `${owner}.${callee.property.name}`;
+  }
+  return null;
+}
+function runnerName2(callee) {
+  let current = callee;
+  for (; ; ) {
+    if (current.type === import_utils11.AST_NODE_TYPES.MemberExpression) {
+      current = current.object;
+    } else if (current.type === import_utils11.AST_NODE_TYPES.CallExpression) {
+      current = current.callee;
+    } else if (current.type === import_utils11.AST_NODE_TYPES.TaggedTemplateExpression) {
+      current = current.tag;
+    } else {
+      break;
+    }
+  }
+  return current.type === import_utils11.AST_NODE_TYPES.Identifier ? current.name : null;
+}
+function isTestCallback(node) {
+  const parent = node.parent;
+  if (parent.type !== import_utils11.AST_NODE_TYPES.CallExpression || parent.arguments[1] !== node) {
+    return false;
+  }
+  const name = runnerName2(parent.callee);
+  return name !== null && TEST_RUNNERS.has(name);
+}
+function isTypeofExpression(node) {
+  return node?.type === import_utils11.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof";
+}
+function isTypeofResult(node) {
+  return node?.type === import_utils11.AST_NODE_TYPES.Literal && typeof node.value === "string" && TYPEOF_RESULTS.has(node.value);
+}
+function isLiteralTautology(actual, expected) {
+  return actual?.type === import_utils11.AST_NODE_TYPES.Literal && expected?.type === import_utils11.AST_NODE_TYPES.Literal && !("regex" in actual) && actual.value === expected.value;
+}
+var noVacuousExpectRule = createRule({
+  name: RULE_NAME13,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow vacuous expects (`typeof` checks, literal tautologies, a sole `toBeDefined`/`toBeTruthy`): a test must assert behaviour that a real regression would break."
+    },
+    schema: [optionSchema6],
+    messages: {
+      typeofExpect: "Do not assert on `typeof`; that only proves a binding exists. Assert a result, a thrown error or an observable effect.",
+      tautologyExpect: "This expect compares a literal with itself and can never fail. Assert something a real regression would break.",
+      soleWeakExpect: "A sole `{{matcher}}` does not pin behaviour. Assert on the value or the outcome, or delete the test."
+    }
+  },
+  defaultOptions: [
+    {
+      weakMatchers: [...DEFAULT_WEAK_MATCHERS],
+      assertionCallees: [...DEFAULT_ASSERTION_CALLEES]
+    }
+  ],
+  create(context, [options]) {
+    const weakMatchers = new Set(options.weakMatchers ?? DEFAULT_WEAK_MATCHERS);
+    const assertionCallees = (options.assertionCallees ?? DEFAULT_ASSERTION_CALLEES).map(
+      (source) => new RegExp(source, "u")
+    );
+    const stack = [];
+    function enter(node) {
+      if (isTestCallback(node)) {
+        stack.push({ node, assertions: 0, weak: null });
+      }
+    }
+    function exit(node) {
+      const frame = stack.at(-1);
+      if (frame?.node !== node) {
+        return;
+      }
+      stack.pop();
+      if (frame.assertions === 1 && frame.weak !== null) {
+        context.report({
+          node: frame.weak.node,
+          messageId: "soleWeakExpect",
+          data: { matcher: frame.weak.matcher }
+        });
+      }
+    }
+    return {
+      ArrowFunctionExpression: enter,
+      FunctionExpression: enter,
+      "ArrowFunctionExpression:exit": exit,
+      "FunctionExpression:exit": exit,
+      CallExpression(node) {
+        const frame = stack.at(-1);
+        const call = matcherCall(node);
+        if (call === null) {
+          const path3 = calleePath(node.callee);
+          if (frame !== void 0 && path3 !== null && assertionCallees.some((re) => re.test(path3))) {
+            frame.assertions += 1;
+          }
+          return;
+        }
+        if (frame !== void 0) {
+          frame.assertions += 1;
+          if (weakMatchers.has(call.matcher)) {
+            frame.weak = { node, matcher: call.matcher };
+          }
+        }
+        const negated = call.matcher.startsWith("not.");
+        const base = negated ? call.matcher.slice("not.".length) : call.matcher;
+        if (!EQUALITY_MATCHERS.has(base)) {
+          return;
+        }
+        const actual = call.root.arguments[0];
+        const expected = node.arguments[0];
+        if (isTypeofExpression(actual) && isTypeofResult(expected)) {
+          context.report({ node, messageId: "typeofExpect" });
+        } else if (!negated && isLiteralTautology(actual, expected)) {
+          context.report({ node, messageId: "tautologyExpect" });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/skipped-tests-need-tracking.ts
-var RULE_NAME10 = "skipped-tests-need-tracking";
+var RULE_NAME14 = "skipped-tests-need-tracking";
 var SKIP_PATTERNS = [
   { pattern: /\b(?:it|test|describe)\.skip\s*\(/u, label: ".skip(" },
   { pattern: /\b(?:it|test|describe)\.fixme\s*\(/u, label: ".fixme(" },
@@ -627,7 +1328,7 @@ var SKIP_PATTERNS = [
 ];
 var DEFAULT_MARKERS = ["https?://\\S+", "TODO\\(@?\\S+\\)"];
 var DEFAULT_LOOKBACK = 30;
-var optionSchema3 = {
+var optionSchema7 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -641,13 +1342,13 @@ var optionSchema3 = {
   }
 };
 var skippedTestsNeedTrackingRule = createRule({
-  name: RULE_NAME10,
+  name: RULE_NAME14,
   meta: {
     type: "problem",
     docs: {
       description: "Skipped tests (`.skip` / `.fixme` / `xit` / `xdescribe`) must carry a tracking marker (an issue URL or `TODO(@owner)`) on or above the line, so the debt has an owner instead of rotting silently."
     },
-    schema: [optionSchema3],
+    schema: [optionSchema7],
     messages: {
       needsTracking: "Skipped test `{{label}}` has no tracking marker. Add an issue URL or `TODO(@owner)` on the same line or above so the skip has an owner."
     }
@@ -699,6 +1400,10 @@ var rules = {
   "no-pr-reference-comments": noPrReferenceCommentsRule,
   "no-focused-tests": noFocusedTestsRule,
   "skipped-tests-need-tracking": skippedTestsNeedTrackingRule,
+  "no-vacuous-expect": noVacuousExpectRule,
+  "no-conditional-expect": noConditionalExpectRule,
+  "fake-timers-must-be-restored": fakeTimersMustBeRestoredRule,
+  "no-real-network-in-unit-tests": noRealNetworkInUnitTestsRule,
   // Available but omitted from `recommended` (opinionated / niche).
   "interface-prefix-i": interfacePrefixIRule,
   "no-template-trim-empty-ternary": noTemplateTrimEmptyTernaryRule
@@ -706,7 +1411,7 @@ var rules = {
 
 // src/index.ts
 var NAMESPACE = "noctcore-code-quality";
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 var plugin = {
   meta: { name: "@noctcore/eslint-plugin-code-quality", version: VERSION },
   rules,