eslint-plugin-unslop 0.5.2 → 0.5.3

package/README.md

@@ -42,11 +42,12 @@ export default [
 ]
 ```
 
-Architecture rules (`import-control`, `export-control`, `no-false-sharing`, `no-single-use-constants`) require a reachable `tsconfig.json`. Set `compilerOptions.rootDir`, and if you use aliases, configure `compilerOptions.paths`.
+Architecture rules (`import-control`, `no-whitebox-testing`, `export-control`, `no-false-sharing`, `no-single-use-constants`) require a reachable `tsconfig.json`. Set `compilerOptions.rootDir`, and if you use aliases, configure `compilerOptions.paths`.
 
 | Rule                             | What it does                                                           |
 | -------------------------------- | ---------------------------------------------------------------------- |
 | `unslop/import-control`          | Enforces module boundaries and forbids local namespace imports         |
+| `unslop/no-whitebox-testing`     | Keeps tests on module entrypoints instead of same-folder internals     |
 | `unslop/export-control`          | Restricts export patterns and forbids `export *` in module entrypoints |
 | `unslop/no-false-sharing`        | Flags shared entrypoint symbols with fewer than two consumer groups    |
 | `unslop/no-single-use-constants` | Flags module-scope constants used once or never across the project     |
@@ -71,6 +72,7 @@ All architecture rules read from `settings.unslop.architecture`. Each key is a m
 {
   imports?: string[]  // module matchers this module may import from; '*' allows all
   exports?: string[]  // regex patterns symbols exported from index.ts/types.ts must match
+  entrypoints?: string[] // public files allowed for external and test imports
   shared?: boolean    // marks module as shared; enables no-false-sharing
 }
 ```
@@ -92,6 +94,12 @@ Deny-by-default for cross-module imports, so forgetting to declare a dependency
 
 Alias imports are resolved via `compilerOptions.paths` from `tsconfig.json`.
 
+### `unslop/no-whitebox-testing`
+
+Keeps test files black-boxed. When a recognized test file lives beside a module's implementation, it must import that module through its public entrypoint (`.`, `./index`, or a configured `entrypoints` file) instead of reaching into sibling files like `./model.ts`.
+
+This rule only checks recognized test filenames (`*.test.*`, `*.spec.*`, `*.*-test.*`, `*.*-spec.*`). Child submodule imports and cross-module imports are left to `unslop/import-control`.
+
 ### `unslop/export-control`
 
 The customs declaration form for the other direction: what are you actually exporting from your module's public entrypoints?

package/dist/index.cjs

@@ -37,7 +37,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-unslop",
-  version: "0.5.2",
+  version: "0.5.3",
   description: "ESLint plugin with rules for reducing AI-generated code smells",
   repository: {
     type: "git",
@@ -721,7 +721,7 @@ function reportUnsharedSymbols(context, node, options) {
   for (const symbol of exportedSymbols) {
     const consumerGroups = consumerGroupsBySymbol.get(symbol.exportedName);
     if (consumerGroups === void 0) continue;
-    if (consumerGroups.size >= MIN_CONSUMER_GROUPS) continue;
+    if (consumerGroups.size >= 2) continue;
     context.report({
       node,
       messageId: "notTrulyShared",
@@ -929,7 +929,6 @@ function getSingleConsumerGroup(groups) {
   const [single] = [...groups];
   return ` (group: ${single})`;
 }
-var MIN_CONSUMER_GROUPS = 2;
 
 // src/rules/read-friendly-order/ast-utils.ts
 function getDeclName(node) {
@@ -1753,6 +1752,70 @@ function importPatternMatches(pattern, target) {
   return patternSegs.every((seg, i) => seg === "*" || seg === targetSegs[i]);
 }
 
+// src/rules/no-whitebox-testing/index.ts
+var import_node_path6 = __toESM(require("path"), 1);
+var no_whitebox_testing_default = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require tests to import a module through its public entrypoint",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      usePublicEntrypoint: "White-box test import denied: tests must import this module through its public entrypoint (offending import: {{specifier}})."
+    }
+  },
+  create(context) {
+    if (!isRecognizedTestFile(context.filename)) return {};
+    const state = getArchitectureRuleState(context);
+    if (state === void 0) return {};
+    return {
+      ImportDeclaration(node) {
+        checkImportDeclaration(context, node, state);
+      }
+    };
+  }
+};
+function checkImportDeclaration(context, node, state) {
+  const resolvedImport = resolveImport(node, state);
+  if (resolvedImport === void 0) return;
+  if (resolvedImport.targetModule.instance !== state.moduleMatch.instance) return;
+  if (!isSameDirectoryImport(state.filename, resolvedImport.targetFile)) return;
+  if (isAllowedModuleEntrypoint2(resolvedImport.targetFile, state.moduleMatch.policy.entrypoints))
+    return;
+  context.report({
+    node,
+    messageId: "usePublicEntrypoint",
+    data: { specifier: resolvedImport.specifier }
+  });
+}
+function resolveImport(node, state) {
+  const specifier = getSpecifier2(node);
+  if (specifier === void 0) return void 0;
+  const resolvedTarget = resolveImportTarget(state.filename, state.policy.projectContext, specifier);
+  if (resolvedTarget === void 0) return void 0;
+  const targetFile = normalizeResolvedPath2(resolvedTarget);
+  const targetModule = matchFileToArchitectureModule(targetFile, state.policy);
+  if (targetModule === void 0) return void 0;
+  return { specifier, targetFile, targetModule };
+}
+function getSpecifier2(node) {
+  const value = node.source.value;
+  return typeof value === "string" ? value : void 0;
+}
+function isRecognizedTestFile(filename) {
+  if (filename.length === 0) return false;
+  const basename = import_node_path6.default.basename(filename);
+  return /^.+\.test\..+$/.test(basename) || /^.+\.spec\..+$/.test(basename) || /^.+\.[^.]+-test\..+$/.test(basename) || /^.+\.[^.]+-spec\..+$/.test(basename);
+}
+function isSameDirectoryImport(importerFile, targetFile) {
+  return isSamePath(import_node_path6.default.dirname(importerFile), import_node_path6.default.dirname(targetFile));
+}
+function isAllowedModuleEntrypoint2(targetFile, entrypoints) {
+  return entrypoints.includes(import_node_path6.default.basename(targetFile));
+}
+
 // src/rules/export-control/index.ts
 var export_control_default = {
   meta: {
@@ -2043,6 +2106,7 @@ var rules_default = {
   "no-false-sharing": no_false_sharing_default,
   "read-friendly-order": read_friendly_order_default,
   "import-control": import_control_default,
+  "no-whitebox-testing": no_whitebox_testing_default,
   "export-control": export_control_default,
   "no-single-use-constants": no_single_use_constants_default
 };
@@ -2071,6 +2135,7 @@ var full = {
     "unslop/no-special-unicode": "error",
     "unslop/no-unicode-escape": "error",
     "unslop/import-control": "error",
+    "unslop/no-whitebox-testing": "error",
     "unslop/export-control": "error",
     "unslop/no-false-sharing": "error",
     "unslop/no-single-use-constants": "error",