eslint-plugin-traceability 1.4.3 → 1.4.5

package/lib/tests/rules/require-story-helpers.test.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Tests for: docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQUIRED - Verify helper functions in require-story helpers produce correct fixes and reporting behavior
+ */
+const require_story_core_1 = require("../../src/rules/helpers/require-story-core");
+const require_story_helpers_1 = require("../../src/rules/helpers/require-story-helpers");
+describe("Require Story Helpers (Story 003.0)", () => {
+    test("createAddStoryFix uses parent range start when available", () => {
+        const target = {
+            type: "FunctionDeclaration",
+            range: [20, 40],
+            parent: { type: "ExportNamedDeclaration", range: [10, 50] },
+        };
+        const fixer = {
+            insertTextBeforeRange: jest.fn((r, t) => ({ r, t })),
+        };
+        const fixFn = (0, require_story_core_1.createAddStoryFix)(target);
+        const result = fixFn(fixer);
+        expect(fixer.insertTextBeforeRange).toHaveBeenCalledTimes(1);
+        const calledArgs = fixer.insertTextBeforeRange.mock.calls[0];
+        expect(calledArgs[0]).toEqual([10, 10]);
+        expect(calledArgs[1]).toBe(`${require_story_helpers_1.ANNOTATION}\n`);
+        expect(result).toEqual({ r: [10, 10], t: `${require_story_helpers_1.ANNOTATION}\n` });
+    });
+    test("createMethodFix falls back to node.range when parent not export", () => {
+        const node = {
+            type: "MethodDefinition",
+            range: [30, 60],
+            parent: { type: "ClassBody" },
+        };
+        const fixer = {
+            insertTextBeforeRange: jest.fn((r, t) => ({ r, t })),
+        };
+        const fixFn = (0, require_story_core_1.createMethodFix)(node);
+        const res = fixFn(fixer);
+        expect(fixer.insertTextBeforeRange.mock.calls[0][0]).toEqual([30, 30]);
+        expect(fixer.insertTextBeforeRange.mock.calls[0][1]).toBe(`${require_story_helpers_1.ANNOTATION}\n  `);
+        expect(res).toEqual({ r: [30, 30], t: `${require_story_helpers_1.ANNOTATION}\n  ` });
+    });
+    test("reportMissing does not call context.report if JSDoc contains @story", () => {
+        const node = {
+            type: "FunctionDeclaration",
+            id: { name: "fn" },
+            range: [0, 10],
+        };
+        const fakeSource = {
+            getJSDocComment: () => ({
+                value: "@story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md",
+            }),
+            getText: () => "",
+        };
+        const context = {
+            getSourceCode: () => fakeSource,
+            report: jest.fn(),
+        };
+        (0, require_story_core_1.reportMissing)(context, fakeSource, node, node);
+        expect(context.report).not.toHaveBeenCalled();
+    });
+    test("reportMissing calls context.report when no JSDoc story present", () => {
+        const node = {
+            type: "FunctionDeclaration",
+            id: { name: "fn2" },
+            range: [0, 10],
+        };
+        const fakeSource = {
+            getJSDocComment: () => null,
+            getText: () => "",
+        };
+        const context = {
+            getSourceCode: () => fakeSource,
+            report: jest.fn(),
+        };
+        (0, require_story_core_1.reportMissing)(context, fakeSource, node, node);
+        expect(context.report).toHaveBeenCalledTimes(1);
+        const call = context.report.mock.calls[0][0];
+        expect(call.node).toBe(node);
+        expect(call.messageId).toBe("missingStory");
+    });
+    /**
+     * Additional helper tests for story annotations and IO helpers
+     * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+     * @req REQ-ANNOTATION-REQUIRED - Verify resolveTargetNode/getNodeName/shouldProcessNode and IO helpers
+     */
+    test("resolveTargetNode prefers parent when parent is ExportNamedDeclaration", () => {
+        const fakeSource = { getText: () => "" };
+        const node = {
+            type: "FunctionExpression",
+            range: [5, 10],
+            parent: { type: "ExportNamedDeclaration", range: [1, 20] },
+        };
+        const resolved = (0, require_story_helpers_1.resolveTargetNode)(fakeSource, node);
+        expect(resolved).toBe(node.parent);
+    });
+    test("resolveTargetNode falls back to node when parent is not an export", () => {
+        const fakeSource = { getText: () => "" };
+        const node = {
+            type: "FunctionDeclaration",
+            range: [5, 10],
+            parent: { type: "ClassBody", range: [1, 20] },
+        };
+        const resolved = (0, require_story_helpers_1.resolveTargetNode)(fakeSource, node);
+        expect(resolved).toBe(node);
+    });
+    test("getNodeName extracts names from common node shapes", () => {
+        const funcNode = {
+            type: "FunctionDeclaration",
+            id: { name: "myFunc" },
+        };
+        const propNode = { type: "MethodDefinition", key: { name: "myProp" } };
+        expect((0, require_story_helpers_1.getNodeName)(funcNode)).toBe("myFunc");
+        expect((0, require_story_helpers_1.getNodeName)(propNode)).toBe("myProp");
+    });
+    test("shouldProcessNode returns booleans for typical node types", () => {
+        const funcDecl = { type: "FunctionDeclaration" };
+        const varDecl = { type: "VariableDeclaration" };
+        expect((0, require_story_helpers_1.shouldProcessNode)(funcDecl, require_story_helpers_1.DEFAULT_SCOPE)).toBeTruthy();
+        expect((0, require_story_helpers_1.shouldProcessNode)(varDecl, require_story_helpers_1.DEFAULT_SCOPE)).toBeFalsy();
+    });
+    test("linesBeforeHasStory detects preceding JSDoc story text", () => {
+        const jsdoc = "/**\n * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md\n */\n";
+        const rest = "function fn() {}\n";
+        const full = jsdoc + rest;
+        const fakeSource = {
+            getText: () => full,
+            getJSDocComment: () => ({
+                value: "@story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md",
+            }),
+            lines: full.split(/\r?\n/),
+        };
+        const nodeLine = fakeSource.lines.findIndex((l) => l.includes("function fn() {}")) + 1;
+        const node = {
+            type: "FunctionDeclaration",
+            range: [full.indexOf("function"), full.length],
+            loc: { start: { line: nodeLine } },
+        };
+        const has = (0, require_story_helpers_1.linesBeforeHasStory)(fakeSource, node);
+        expect(has).toBeTruthy();
+    });
+    test("fallbackTextBeforeHasStory returns boolean when called with source text and range", () => {
+        const jsdoc = "/**\n * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md\n */\n";
+        const rest = "function fnB() {}\n";
+        const full = jsdoc + rest;
+        const fakeSource = {
+            getText: () => full,
+        };
+        const node = {
+            type: "FunctionDeclaration",
+            range: [full.indexOf("function"), full.length],
+        };
+        const res = (0, require_story_helpers_1.fallbackTextBeforeHasStory)(fakeSource, node);
+        expect(typeof res).toBe("boolean");
+        expect(res).toBeTruthy();
+    });
+    test("parentChainHasStory returns true when ancestors have JSDoc story", () => {
+        const fakeSource = {
+            getCommentsBefore: () => [
+                {
+                    type: "Block",
+                    value: "@story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md",
+                },
+            ],
+        };
+        const node = {
+            type: "Identifier",
+            parent: { parent: { type: "ExportNamedDeclaration" } },
+        };
+        const res = (0, require_story_helpers_1.parentChainHasStory)(fakeSource, node);
+        expect(res).toBeTruthy();
+    });
+});

package/lib/tests/rules/require-story-io.edgecases.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests for: docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQUIRED - Edge case tests for IO helpers (linesBeforeHasStory/fallbackTextBeforeHasStory/parentChainHasStory)
+ */
+export {};

package/lib/tests/rules/require-story-io.edgecases.test.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Tests for: docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+ * @req REQ-ANNOTATION-REQUIRED - Edge case tests for IO helpers (linesBeforeHasStory/fallbackTextBeforeHasStory/parentChainHasStory)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_story_io_1 = require("../../src/rules/helpers/require-story-io");
+describe("Require Story IO helpers - edge cases (Story 003.0)", () => {
+    test("linesBeforeHasStory returns false when source.lines missing or node.loc missing", () => {
+        const fakeSource = {};
+        const node = { loc: null };
+        expect((0, require_story_io_1.linesBeforeHasStory)(fakeSource, node)).toBe(false);
+        const fakeSource2 = { lines: ["line1", "line2"] };
+        const node2 = { loc: { start: { line: 100 } } };
+        expect((0, require_story_io_1.linesBeforeHasStory)(fakeSource2, node2)).toBe(false);
+    });
+    test("fallbackTextBeforeHasStory returns false when getText missing or node.range missing", () => {
+        const fakeSource = {};
+        const node = { range: null };
+        expect((0, require_story_io_1.fallbackTextBeforeHasStory)(fakeSource, node)).toBe(false);
+        const fakeSource2 = { getText: () => "no story here" };
+        const node2 = { range: [] };
+        expect((0, require_story_io_1.fallbackTextBeforeHasStory)(fakeSource2, node2)).toBe(false);
+    });
+    test("fallbackTextBeforeHasStory detects @story in text before node.range", () => {
+        const story = "@story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md";
+        const pre = `/* ${story} */\\n`;
+        const rest = "function x() {}";
+        const full = pre + rest;
+        const fakeSource = { getText: () => full };
+        const node = { range: [full.indexOf("function"), full.length] };
+        expect((0, require_story_io_1.fallbackTextBeforeHasStory)(fakeSource, node)).toBe(true);
+    });
+    test("parentChainHasStory returns true when ancestor comments contain @story", () => {
+        const fakeSource = {
+            getCommentsBefore: () => [
+                {
+                    type: "Block",
+                    value: "@story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md",
+                },
+            ],
+        };
+        const node = { parent: { parent: { type: "SomeParent" } } };
+        expect((0, require_story_io_1.parentChainHasStory)(fakeSource, node)).toBe(true);
+        const fakeSource2 = { getCommentsBefore: () => [] };
+        const node2 = { parent: null };
+        expect((0, require_story_io_1.parentChainHasStory)(fakeSource2, node2)).toBe(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-traceability",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "A customizable ESLint plugin that enforces traceability annotations in your code, ensuring each implementation is linked to its requirement or test case.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -22,6 +22,8 @@
     "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
     "duplication": "jscpd src tests --reporters console --threshold 3 --ignore tests/utils/**",
     "audit:dev-high": "node scripts/generate-dev-deps-audit.js",
+    "safety:deps": "node scripts/ci-safety-deps.js",
+    "audit:ci": "node scripts/ci-audit.js",
     "smoke-test": "./scripts/smoke-test.sh",
     "prepare": "husky install"
   },