eslint-plugin-traceability 1.15.0 → 1.16.0

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

@@ -0,0 +1,158 @@
+"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 - Verify getNodeName resolves names for diverse AST node shapes
+ * @supports docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md REQ-ANNOTATION-REQUIRED
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_story_utils_1 = require("../../src/rules/helpers/require-story-utils");
+describe("Require Story Utils - getNodeName (Story 003.0)", () => {
+    it("[REQ-ANNOTATION-REQUIRED] returns identifier name for Identifier and JSXIdentifier", () => {
+        const idNode = { type: "Identifier", name: "foo" };
+        const jsxIdNode = { type: "JSXIdentifier", name: "Bar" };
+        expect((0, require_story_utils_1.getNodeName)(idNode)).toBe("foo");
+        expect((0, require_story_utils_1.getNodeName)(jsxIdNode)).toBe("Bar");
+    });
+    it("[REQ-ANNOTATION-REQUIRED] returns null for identifier-like nodes without string name", () => {
+        const badId = { type: "Identifier", name: 123 };
+        const badJsxId = { type: "JSXIdentifier", name: null };
+        expect((0, require_story_utils_1.getNodeName)(badId)).toBeNull();
+        expect((0, require_story_utils_1.getNodeName)(badJsxId)).toBeNull();
+    });
+    it("[REQ-ANNOTATION-REQUIRED] converts simple Literal values into string names", () => {
+        const stringLit = { type: "Literal", value: "name" };
+        const numberLit = { type: "Literal", value: 42 };
+        const boolLit = { type: "Literal", value: true };
+        const nullLit = { type: "Literal", value: null };
+        const objLit = { type: "Literal", value: { a: 1 } };
+        expect((0, require_story_utils_1.getNodeName)(stringLit)).toBe("name");
+        expect((0, require_story_utils_1.getNodeName)(numberLit)).toBe("42");
+        expect((0, require_story_utils_1.getNodeName)(boolLit)).toBe("true");
+        expect((0, require_story_utils_1.getNodeName)(nullLit)).toBeNull();
+        expect((0, require_story_utils_1.getNodeName)(objLit)).toBeNull();
+    });
+    it("[REQ-ANNOTATION-REQUIRED] resolves simple, expression-free TemplateLiteral names", () => {
+        const tplNode = {
+            type: "TemplateLiteral",
+            expressions: [],
+            quasis: [
+                { value: { cooked: "hello", raw: "hello" } },
+                { value: { cooked: "-world", raw: "-world" } },
+            ],
+        };
+        const withExpressions = {
+            type: "TemplateLiteral",
+            expressions: [{}],
+            quasis: [{ value: { cooked: "ignored", raw: "ignored" } }],
+        };
+        expect((0, require_story_utils_1.getNodeName)(tplNode)).toBe("hello-world");
+        expect((0, require_story_utils_1.getNodeName)(withExpressions)).toBeNull();
+    });
+    it("[REQ-ANNOTATION-REQUIRED] resolves non-computed member/qualified names and rejects computed", () => {
+        const memberExpr = {
+            type: "MemberExpression",
+            object: { type: "Identifier", name: "obj" },
+            property: { type: "Identifier", name: "prop" },
+            computed: false,
+        };
+        const computedMember = {
+            type: "MemberExpression",
+            object: { type: "Identifier", name: "obj" },
+            property: { type: "Literal", value: "dynamic" },
+            computed: true,
+        };
+        const tsQualified = {
+            type: "TSQualifiedName",
+            left: { type: "Identifier", name: "Ns" },
+            right: { type: "Identifier", name: "Type" },
+        };
+        const jsxMember = {
+            type: "JSXMemberExpression",
+            object: { type: "JSXIdentifier", name: "Ns" },
+            property: { type: "JSXIdentifier", name: "Component" },
+        };
+        expect((0, require_story_utils_1.getNodeName)(memberExpr)).toBe("prop");
+        expect((0, require_story_utils_1.getNodeName)(computedMember)).toBeNull();
+        expect((0, require_story_utils_1.getNodeName)(tsQualified)).toBe("Type");
+        expect((0, require_story_utils_1.getNodeName)(jsxMember)).toBe("Component");
+    });
+    it("[REQ-ANNOTATION-REQUIRED] extracts names from Property/ObjectProperty keys", () => {
+        const prop = {
+            type: "Property",
+            key: { type: "Identifier", name: "propName" },
+        };
+        const objProp = {
+            type: "ObjectProperty",
+            key: { type: "Literal", value: "literalKey" },
+        };
+        const notProp = { type: "MethodDefinition", key: { name: "method" } };
+        expect((0, require_story_utils_1.getNodeName)(prop)).toBe("propName");
+        expect((0, require_story_utils_1.getNodeName)(objProp)).toBe("literalKey");
+        expect((0, require_story_utils_1.getNodeName)(notProp)).toBe("method");
+    });
+    it("[REQ-ANNOTATION-REQUIRED] prefers direct id/key names before deeper inspection", () => {
+        const funcNode = {
+            type: "FunctionDeclaration",
+            id: { type: "Identifier", name: "directName" },
+            key: { type: "Identifier", name: "ignored" },
+        };
+        const keyNode = {
+            type: "MethodDefinition",
+            key: { type: "Identifier", name: "keyName" },
+        };
+        expect((0, require_story_utils_1.getNodeName)(funcNode)).toBe("directName");
+        expect((0, require_story_utils_1.getNodeName)(keyNode)).toBe("keyName");
+    });
+    it("[REQ-ANNOTATION-REQUIRED] unwraps TSLiteralType and JSXNamespacedName wrappers", () => {
+        const tsLiteral = {
+            type: "TSLiteralType",
+            literal: { type: "Literal", value: "wrapped" },
+        };
+        const jsxNamespaced = {
+            type: "JSXNamespacedName",
+            name: { type: "JSXIdentifier", name: "NsComponent" },
+        };
+        expect((0, require_story_utils_1.getNodeName)(tsLiteral)).toBe("wrapped");
+        expect((0, require_story_utils_1.getNodeName)(jsxNamespaced)).toBe("NsComponent");
+    });
+    it("[REQ-ANNOTATION-REQUIRED] returns null for non-TemplateLiteral nodes passed to templateLiteralToString via getNodeName", () => {
+        const fakeTemplate = {
+            type: "Literal",
+            value: "no-template",
+            quasis: [{ value: { cooked: "ignored", raw: "ignored" } }],
+        };
+        const realTemplateWithExpr = {
+            type: "TemplateLiteral",
+            expressions: [{ type: "Identifier", name: "expr" }],
+            quasis: [{ value: { cooked: "start", raw: "start" } }],
+        };
+        expect((0, require_story_utils_1.getNodeName)(fakeTemplate)).toBe("no-template");
+        expect((0, require_story_utils_1.getNodeName)(realTemplateWithExpr)).toBeNull();
+    });
+    it("[REQ-ANNOTATION-REQUIRED] handles nullish and missing .value in TemplateLiteral quasis defensively", () => {
+        const defensiveTemplate = {
+            type: "TemplateLiteral",
+            expressions: [],
+            quasis: [
+                null,
+                { value: null },
+                { value: { cooked: "part1", raw: "raw1" } },
+                { value: { raw: "-only-raw" } },
+                {},
+            ],
+        };
+        expect((0, require_story_utils_1.getNodeName)(defensiveTemplate)).toBe("part1-only-raw");
+    });
+    it("[REQ-ANNOTATION-REQUIRED] follows generic .key fallback for other shapes", () => {
+        const genericWithKey = {
+            type: "SomeNode",
+            key: { type: "Identifier", name: "viaKey" },
+        };
+        const genericWithoutKey = {
+            type: "SomeNode",
+        };
+        expect((0, require_story_utils_1.getNodeName)(genericWithKey)).toBe("viaKey");
+        expect((0, require_story_utils_1.getNodeName)(genericWithoutKey)).toBeNull();
+    });
+});

package/lib/tests/utils/annotation-checker-branches.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Focused branch coverage tests for annotation-checker helper.
+ * @supports docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md REQ-ANNOTATION-AUTOFIX REQ-ANNOTATION-REPORTING
+ */
+export {};

package/lib/tests/utils/annotation-checker-branches.test.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Focused branch coverage tests for annotation-checker helper.
+ * @supports docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md REQ-ANNOTATION-AUTOFIX REQ-ANNOTATION-REPORTING
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock("../../src/utils/reqAnnotationDetection", () => ({
+    // Always report that no requirement annotation is present so we exercise
+    // the missing-annotation reporting and autofix paths in the helper.
+    hasReqAnnotation: jest.fn(() => false),
+}));
+jest.mock("../../src/rules/helpers/require-story-utils", () => ({
+    // Provide a stable, human-readable name so reporting paths are predictable
+    // without depending on the full real implementation.
+    getNodeName: jest.fn(() => "mockName"),
+}));
+const annotation_checker_1 = require("../../src/utils/annotation-checker");
+/**
+ * Build a minimal ESLint rule context stub that captures report() calls.
+ *
+ * @supports docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md REQ-ANNOTATION-REPORTING
+ */
+function createContextStub() {
+    const report = jest.fn();
+    const sourceCode = {
+        getJSDocComment: jest.fn(() => null),
+        getCommentsBefore: jest.fn(() => []),
+    };
+    const context = {
+        getSourceCode() {
+            return sourceCode;
+        },
+        report,
+    };
+    return { context, report };
+}
+describe("annotation-checker helper branch coverage (Story 003.0-DEV-FUNCTION-ANNOTATIONS)", () => {
+    it("[REQ-ANNOTATION-AUTOFIX] attaches fix directly to node when parent is missing", () => {
+        const { context, report } = createContextStub();
+        const node = { type: "FunctionDeclaration" }; // no parent property
+        (0, annotation_checker_1.checkReqAnnotation)(context, node, { enableFix: true });
+        expect(report).toHaveBeenCalledTimes(1);
+        const reportArg = report.mock.calls[0][0];
+        expect(reportArg).toHaveProperty("fix");
+        const fixer = { insertTextBefore: jest.fn() };
+        reportArg.fix(fixer);
+        expect(fixer.insertTextBefore).toHaveBeenCalledWith(node, "/** @req <REQ-ID> */\n");
+    });
+    it("[REQ-ANNOTATION-AUTOFIX] attaches fix to MethodDefinition wrapper when parent is a method", () => {
+        const { context, report } = createContextStub();
+        const methodParent = { type: "MethodDefinition" };
+        const node = {
+            type: "FunctionExpression",
+            parent: methodParent,
+            id: { type: "Identifier", name: "methodImpl" },
+        };
+        (0, annotation_checker_1.checkReqAnnotation)(context, node, { enableFix: true });
+        expect(report).toHaveBeenCalledTimes(1);
+        const reportArg = report.mock.calls[0][0];
+        const fixer = { insertTextBefore: jest.fn() };
+        reportArg.fix(fixer);
+        expect(fixer.insertTextBefore).toHaveBeenCalledWith(methodParent, "/** @req <REQ-ID> */\n");
+    });
+    it("[REQ-ANNOTATION-AUTOFIX] attaches fix to VariableDeclarator when node is its init", () => {
+        const { context, report } = createContextStub();
+        const declarator = { type: "VariableDeclarator" };
+        const node = { type: "FunctionExpression", parent: declarator };
+        declarator.init = node;
+        (0, annotation_checker_1.checkReqAnnotation)(context, node, { enableFix: true });
+        expect(report).toHaveBeenCalledTimes(1);
+        const reportArg = report.mock.calls[0][0];
+        const fixer = { insertTextBefore: jest.fn() };
+        reportArg.fix(fixer);
+        expect(fixer.insertTextBefore).toHaveBeenCalledWith(declarator, "/** @req <REQ-ID> */\n");
+    });
+    it("[REQ-ANNOTATION-AUTOFIX] attaches fix to ExpressionStatement wrapper when parent is an expression", () => {
+        const { context, report } = createContextStub();
+        const expressionParent = { type: "ExpressionStatement" };
+        const node = {
+            type: "FunctionExpression",
+            parent: expressionParent,
+            id: { type: "Identifier", name: "iife" },
+        };
+        (0, annotation_checker_1.checkReqAnnotation)(context, node, { enableFix: true });
+        expect(report).toHaveBeenCalledTimes(1);
+        const reportArg = report.mock.calls[0][0];
+        const fixer = { insertTextBefore: jest.fn() };
+        reportArg.fix(fixer);
+        expect(fixer.insertTextBefore).toHaveBeenCalledWith(expressionParent, "/** @req <REQ-ID> */\n");
+    });
+    it("[REQ-ANNOTATION-AUTOFIX] omits fix when enableFix is false", () => {
+        const { context, report } = createContextStub();
+        const node = {
+            type: "FunctionDeclaration",
+            parent: { type: "Program" },
+            id: { type: "Identifier", name: "noFix" },
+        };
+        (0, annotation_checker_1.checkReqAnnotation)(context, node, { enableFix: false });
+        expect(report).toHaveBeenCalledTimes(1);
+        const reportArg = report.mock.calls[0][0];
+        expect(reportArg.fix).toBeUndefined();
+    });
+});

package/lib/tests/utils/annotation-scope-analyzer.test.js

@@ -6,6 +6,12 @@ describe("annotation-scope-analyzer helpers (Story 027.0-DEV-REDUNDANT-ANNOTATIO
         const key = (0, annotation_scope_analyzer_1.toStoryReqKey)("docs/stories/001.story.md", "REQ-ONE");
         expect(key).toBe("docs/stories/001.story.md|REQ-ONE");
     });
+    it("[REQ-DUPLICATION-DETECTION] normalizes missing story or requirement to empty segments", () => {
+        const noStory = (0, annotation_scope_analyzer_1.toStoryReqKey)(null, "REQ-ONE");
+        const noReq = (0, annotation_scope_analyzer_1.toStoryReqKey)("docs/stories/001.story.md", undefined);
+        expect(noStory).toBe("|REQ-ONE");
+        expect(noReq).toBe("docs/stories/001.story.md|");
+    });
     it("[REQ-DUPLICATION-DETECTION] extracts pairs from @story/@req sequences", () => {
         const text = `// @story docs/stories/001.story.md\n// @req REQ-ONE`;
         const pairs = (0, annotation_scope_analyzer_1.extractStoryReqPairsFromText)(text);
@@ -13,6 +19,10 @@ describe("annotation-scope-analyzer helpers (Story 027.0-DEV-REDUNDANT-ANNOTATIO
             "docs/stories/001.story.md|REQ-ONE",
         ]);
     });
+    it("[REQ-DUPLICATION-DETECTION] returns empty set when text has no annotations", () => {
+        const pairs = (0, annotation_scope_analyzer_1.extractStoryReqPairsFromText)("");
+        expect(pairs.size).toBe(0);
+    });
     it("[REQ-SCOPE-ANALYSIS] extracts pairs from @supports lines", () => {
         const text = `// @supports docs/stories/002.story.md REQ-A REQ-B OTHER`;
         const pairs = (0, annotation_scope_analyzer_1.extractStoryReqPairsFromText)(text);
@@ -27,6 +37,10 @@ describe("annotation-scope-analyzer helpers (Story 027.0-DEV-REDUNDANT-ANNOTATIO
         const pairs = (0, annotation_scope_analyzer_1.extractStoryReqPairsFromComments)(comments);
         expect(pairs.size).toBe(2);
     });
+    it("[REQ-DUPLICATION-DETECTION] returns empty set for empty comments list", () => {
+        const pairs = (0, annotation_scope_analyzer_1.extractStoryReqPairsFromComments)([]);
+        expect(pairs.size).toBe(0);
+    });
     it("[REQ-DUPLICATION-DETECTION] determines full coverage correctly", () => {
         const parent = new Set([
             "story|REQ-ONE",
@@ -37,6 +51,11 @@ describe("annotation-scope-analyzer helpers (Story 027.0-DEV-REDUNDANT-ANNOTATIO
         expect((0, annotation_scope_analyzer_1.arePairsFullyCovered)(childCovered, parent)).toBe(true);
         expect((0, annotation_scope_analyzer_1.arePairsFullyCovered)(childNotCovered, parent)).toBe(false);
     });
+    it("[REQ-DUPLICATION-DETECTION] treats empty child or parent as not covered", () => {
+        const nonEmpty = new Set(["story|REQ-ONE"]);
+        expect((0, annotation_scope_analyzer_1.arePairsFullyCovered)(new Set(), nonEmpty)).toBe(false);
+        expect((0, annotation_scope_analyzer_1.arePairsFullyCovered)(nonEmpty, new Set())).toBe(false);
+    });
     it("[REQ-STATEMENT-SIGNIFICANCE] respects alwaysCovered and strictness levels", () => {
         const base = {
             strictness: "moderate",
@@ -49,6 +68,39 @@ describe("annotation-scope-analyzer helpers (Story 027.0-DEV-REDUNDANT-ANNOTATIO
         expect((0, annotation_scope_analyzer_1.isStatementEligibleForRedundancy)({ type: "ExpressionStatement" }, base, branchTypes)).toBe(true);
         expect((0, annotation_scope_analyzer_1.isStatementEligibleForRedundancy)({ type: "IfStatement" }, base, branchTypes)).toBe(false);
     });
+    it("[REQ-CONFIGURABLE-STRICTNESS] treats permissive mode as only honoring alwaysCovered list", () => {
+        const options = {
+            strictness: "permissive",
+            allowEmphasisDuplication: false,
+            maxScopeDepth: 3,
+            alwaysCovered: ["ReturnStatement"],
+        };
+        const branchTypes = ["IfStatement"];
+        expect((0, annotation_scope_analyzer_1.isStatementEligibleForRedundancy)({ type: "ReturnStatement" }, options, branchTypes)).toBe(true);
+        expect((0, annotation_scope_analyzer_1.isStatementEligibleForRedundancy)({ type: "ExpressionStatement" }, options, branchTypes)).toBe(false);
+    });
+    it("[REQ-CONFIGURABLE-STRICTNESS] treats strict mode as allowing any non-branch statement", () => {
+        const options = {
+            strictness: "strict",
+            allowEmphasisDuplication: false,
+            maxScopeDepth: 3,
+            alwaysCovered: [],
+        };
+        const branchTypes = ["IfStatement"];
+        expect((0, annotation_scope_analyzer_1.isStatementEligibleForRedundancy)({ type: "ExpressionStatement" }, options, branchTypes)).toBe(true);
+        expect((0, annotation_scope_analyzer_1.isStatementEligibleForRedundancy)({ type: "IfStatement" }, options, branchTypes)).toBe(false);
+    });
+    it("[REQ-STATEMENT-SIGNIFICANCE] returns false for null or non-node values", () => {
+        const options = {
+            strictness: "moderate",
+            allowEmphasisDuplication: false,
+            maxScopeDepth: 3,
+            alwaysCovered: [],
+        };
+        const branchTypes = [];
+        expect((0, annotation_scope_analyzer_1.isStatementEligibleForRedundancy)(null, options, branchTypes)).toBe(false);
+        expect((0, annotation_scope_analyzer_1.isStatementEligibleForRedundancy)({}, options, branchTypes)).toBe(false);
+    });
     it("[REQ-SAFE-REMOVAL] computes removal range for full-line comment", () => {
         const source = `const x = 1;\n// @story docs/stories/001.story.md\nconst y = 2;\n`;
         const sourceCode = {
@@ -63,6 +115,77 @@ describe("annotation-scope-analyzer helpers (Story 027.0-DEV-REDUNDANT-ANNOTATIO
         const removed = source.slice(0, removalStart) + source.slice(removalEnd);
         expect(removed).toBe("const x = 1;\nconst y = 2;\n");
     });
+    it("[REQ-SAFE-REMOVAL] computes removal range for full-line comment with Windows newlines", () => {
+        const source = "const x = 1;\r\n// @story docs/stories/001.story.md\r\nconst y = 2;\r\n";
+        const sourceCode = {
+            getText() {
+                return source;
+            },
+        };
+        const start = source.indexOf("// @story");
+        const end = start + "// @story docs/stories/001.story.md".length;
+        const comment = { range: [start, end] };
+        const [removalStart, removalEnd] = (0, annotation_scope_analyzer_1.getCommentRemovalRange)(comment, sourceCode);
+        const removed = source.slice(0, removalStart) + source.slice(removalEnd);
+        expect(removed).toBe("const x = 1;\r\nconst y = 2;\r\n");
+    });
+    it("[REQ-SAFE-REMOVAL] computes removal range for full-line comment with standalone CR newline", () => {
+        const source = "const x = 1;\r// @story docs/stories/001.story.md\rconst y = 2;\r";
+        const sourceCode = {
+            getText() {
+                return source;
+            },
+        };
+        const start = source.indexOf("// @story");
+        const end = start + "// @story docs/stories/001.story.md".length;
+        const comment = { range: [start, end] };
+        const [removalStart, removalEnd] = (0, annotation_scope_analyzer_1.getCommentRemovalRange)(comment, sourceCode);
+        const removed = source.slice(0, removalStart) + source.slice(removalEnd);
+        expect(removed).toBe("const x = 1;\rconst y = 2;\r");
+    });
+    it("[REQ-SAFE-REMOVAL] computes removal range for inline comment", () => {
+        const source = "const x = 1; // @story docs/stories/001.story.md\nconst y = 2;\n";
+        const sourceCode = {
+            getText() {
+                return source;
+            },
+        };
+        const start = source.indexOf("// @story");
+        const end = start + "// @story docs/stories/001.story.md".length;
+        const comment = { range: [start, end] };
+        const [removalStart, removalEnd] = (0, annotation_scope_analyzer_1.getCommentRemovalRange)(comment, sourceCode);
+        const removed = source.slice(0, removalStart) + source.slice(removalEnd);
+        expect(removed).toBe("const x = 1; \nconst y = 2;\n");
+    });
+    it("[REQ-SAFE-REMOVAL] consumes trailing spaces and tabs following a full-line comment", () => {
+        const source = "const x = 1;\n// @story docs/stories/001.story.md   	  \nconst y = 2;\n";
+        const sourceCode = {
+            getText() {
+                return source;
+            },
+        };
+        const start = source.indexOf("// @story");
+        const end = start + "// @story docs/stories/001.story.md".length;
+        const comment = { range: [start, end] };
+        const [removalStart, removalEnd] = (0, annotation_scope_analyzer_1.getCommentRemovalRange)(comment, sourceCode);
+        const removed = source.slice(0, removalStart) + source.slice(removalEnd);
+        expect(removed).toBe("const x = 1;\nconst y = 2;\n");
+    });
+    it("[REQ-SAFE-REMOVAL] handles full-line comment at end of file without trailing newline", () => {
+        const source = "const x = 1;\n// @story docs/stories/001.story.md";
+        const sourceCode = {
+            getText() {
+                return source;
+            },
+        };
+        const start = source.indexOf("// @story");
+        const end = start + "// @story docs/stories/001.story.md".length;
+        const comment = { range: [start, end] };
+        const [removalStart, removalEnd] = (0, annotation_scope_analyzer_1.getCommentRemovalRange)(comment, sourceCode);
+        const removed = source.slice(0, removalStart) + source.slice(removalEnd);
+        expect(removed).toBe("const x = 1;\n");
+        expect(removalEnd).toBe(source.length);
+    });
     it("[REQ-SAFE-REMOVAL] returns [0, 0] for comments with invalid range length (EXPECTS EXPECTED_RANGE_LENGTH usage)", () => {
         const source = "const x = 1;";
         const sourceCode = {
@@ -74,4 +197,15 @@ describe("annotation-scope-analyzer helpers (Story 027.0-DEV-REDUNDANT-ANNOTATIO
         const range = (0, annotation_scope_analyzer_1.getCommentRemovalRange)(comment, sourceCode);
         expect(range).toEqual([0, 0]);
     });
+    it("[REQ-SAFE-REMOVAL] returns [0, 0] when comment range is not an array", () => {
+        const source = "const x = 1;";
+        const sourceCode = {
+            getText() {
+                return source;
+            },
+        };
+        const comment = { range: null };
+        const range = (0, annotation_scope_analyzer_1.getCommentRemovalRange)(comment, sourceCode);
+        expect(range).toEqual([0, 0]);
+    });
 });

package/lib/tests/utils/branch-annotation-helpers.test.js

@@ -44,4 +44,70 @@ describe("validateBranchTypes helper (Story 004.0-DEV-BRANCH-ANNOTATIONS)", () =
             }));
         });
     });
+    it("should gather SwitchCase comment text via gatherBranchCommentText (Story 004.0-DEV-BRANCH-ANNOTATIONS)", () => {
+        // Fake SourceCode-like object with lines aligned to PRE_COMMENT_OFFSET logic
+        const sourceCode = {
+            lines: [
+                "// @story first part",
+                "// continuation second part",
+                "case 1:",
+            ],
+            getCommentsBefore: () => [],
+            getText: jest.fn(),
+        };
+        // SwitchCase-like node with loc.start.line corresponding to "case 1:" line (line 3)
+        const switchCaseNode = {
+            type: "SwitchCase",
+            loc: {
+                start: { line: 3, column: 0 },
+                end: { line: 3, column: 7 },
+            },
+        };
+        const text = (0, branch_annotation_helpers_1.gatherBranchCommentText)(sourceCode, switchCaseNode);
+        // Expect combined text using space separator and preserving leading //
+        expect(text).toBe("// @story first part // continuation second part");
+    });
+    it("should gather comment text for CatchClause and loop nodes via gatherBranchCommentText (Story 004.0-DEV-BRANCH-ANNOTATIONS)", () => {
+        // CatchClause: comments come from getCommentsBefore when beforeText already contains @story
+        const catchComments = [
+            { type: "Line", value: "@story catch branch story" },
+            { type: "Line", value: "additional info" },
+        ];
+        const sourceCodeCatch = {
+            getCommentsBefore: jest.fn().mockReturnValue(catchComments),
+            getText: jest.fn().mockReturnValue("@story existing beforeText"),
+            lines: [],
+        };
+        const catchNode = {
+            type: "CatchClause",
+            loc: {
+                start: { line: 10, column: 0 },
+                end: { line: 12, column: 1 },
+            },
+        };
+        const catchText = (0, branch_annotation_helpers_1.gatherBranchCommentText)(sourceCodeCatch, catchNode);
+        expect(sourceCodeCatch.getCommentsBefore).toHaveBeenCalledWith(catchNode);
+        expect(catchText).toContain("@story catch branch story");
+        expect(catchText).toContain("additional info");
+        // Loop node: ForStatement currently uses beforeComments.map(extractCommentValue).join(" ")
+        const loopComments = [
+            { type: "Line", value: "@story loop branch story" },
+            { type: "Block", value: "loop details" },
+        ];
+        const sourceCodeLoop = {
+            getCommentsBefore: jest.fn().mockReturnValue(loopComments),
+            getText: jest.fn().mockReturnValue("@story loop beforeText"),
+            lines: [],
+        };
+        const forNode = {
+            type: "ForStatement",
+            loc: {
+                start: { line: 20, column: 0 },
+                end: { line: 25, column: 1 },
+            },
+        };
+        const loopText = (0, branch_annotation_helpers_1.gatherBranchCommentText)(sourceCodeLoop, forNode);
+        expect(sourceCodeLoop.getCommentsBefore).toHaveBeenCalledWith(forNode);
+        expect(loopText).toBe("@story loop branch story loop details");
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-traceability",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "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",
@@ -90,7 +90,7 @@
     "lint-staged": "^16.2.7",
     "prettier": "^3.6.2",
     "semantic-release": "25.0.2",
-    "ts-jest": "^29.4.5",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3",
     "secretlint": "11.2.5",
     "@secretlint/secretlint-rule-preset-recommend": "11.2.5"