@codeperfect/eslint-plugin 1.0.0 → 2.0.0

package/dist/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.js

@@ -0,0 +1,180 @@
+import { hasAssertion, hasAsyncLogic, hasAwait, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, } from "../aaa/index.js";
+import { getAssertReferencedIdentifiers, isActResultAsserted, } from "./phase-purity-identifiers.js";
+/**
+ * Collects the phase-purity state for one analyzed statement.
+ * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.
+ * @param statement Statement entry to classify.
+ * @returns Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * const state = getStatementPurityState(new Set<string>(), { node: { type: "ExpressionStatement" } as never, phases: [] });
+ * void state;
+ * ```
+ */
+function getStatementPurityState(assertReferencedIdentifiers, statement) {
+    const allowsArrange = statement.phases.includes("Arrange");
+    const allowsAct = statement.phases.includes("Act");
+    const allowsAssert = statement.phases.includes("Assert");
+    const containsAssertion = hasAssertion(statement.node);
+    const containsAsyncLogic = hasAsyncLogic(statement.node);
+    const containsAwait = hasAwait(statement.node);
+    const containsMutation = hasMutation(statement.node);
+    const isMeaningfulAct = isMeaningfulActStatement(statement.node);
+    const isMeaningfulActContent = isMeaningfulAct ||
+        hasCapturableActResult(statement.node) ||
+        isActResultAsserted(assertReferencedIdentifiers, statement.node);
+    return {
+        allowsAct,
+        allowsArrange,
+        allowsAssert,
+        containsAssertion,
+        containsAsyncLogic,
+        containsAwait,
+        containsMutation,
+        isMeaningfulAct,
+        isMeaningfulActContent,
+        isSetupLike: isSetupLikeStatement(statement.node),
+        isValidAssert: isValidAssertStatement(statement.node),
+    };
+}
+/**
+ * Checks whether the analyzed test block declares all AAA section comments.
+ * @param analysis Parsed test-block analysis.
+ * @returns True when Arrange, Act, and Assert are all present.
+ * @example
+ * ```typescript
+ * const complete = hasAllAaaSections({ sectionComments: [] } as never);
+ * void complete;
+ * ```
+ */
+function hasAllAaaSections(analysis) {
+    return ["Arrange", "Act", "Assert"].every((phase) => analysis.sectionComments.some((sectionComment) => sectionComment.phases.includes(phase)));
+}
+/**
+ * Reports Act-only phase violations for one statement.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportActOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportActOnlyStatement(context, statement, purityState) {
+    if (purityState.containsAssertion && !purityState.allowsAssert) {
+        context.report({
+            messageId: "assertionOutsideAssert",
+            node: statement.node,
+        });
+    }
+    if (purityState.allowsAssert &&
+        purityState.containsAssertion &&
+        !purityState.isValidAssert) {
+        context.report({ messageId: "nonAssertionInAssert", node: statement.node });
+    }
+    if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {
+        context.report({ messageId: "setupAfterAct", node: statement.node });
+    }
+}
+/**
+ * Reports Arrange-only phase violations for one statement.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportArrangeOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportArrangeOnlyStatement(context, statement, purityState) {
+    if (purityState.containsAssertion && !purityState.allowsAssert) {
+        context.report({
+            messageId: "assertionOutsideAssert",
+            node: statement.node,
+        });
+    }
+    if (purityState.containsAwait) {
+        context.report({ messageId: "awaitOutsideAct", node: statement.node });
+    }
+    if (purityState.containsAsyncLogic) {
+        context.report({ messageId: "asyncInArrange", node: statement.node });
+    }
+    if (purityState.isMeaningfulAct) {
+        context.report({ messageId: "actionInArrange", node: statement.node });
+    }
+}
+/**
+ * Reports Assert-only phase violations for one statement.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportAssertOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportAssertOnlyStatement(context, statement, purityState) {
+    if (purityState.containsAwait) {
+        context.report({ messageId: "awaitOutsideAct", node: statement.node });
+    }
+    if (purityState.containsMutation) {
+        context.report({ messageId: "mutationAfterAct", node: statement.node });
+        return;
+    }
+    if (!purityState.isValidAssert) {
+        context.report({ messageId: "nonAssertionInAssert", node: statement.node });
+    }
+}
+/**
+ * Reports all enforce-aaa-phase-purity violations for one test block.
+ * @param context ESLint rule context.
+ * @param analysis Parsed test-block analysis.
+ * @example
+ * ```typescript
+ * reportPhasePurityViolations({ report() {} } as never, { sectionComments: [], statements: [] } as never);
+ * ```
+ */
+function reportPhasePurityViolations(context, analysis) {
+    if (!hasAllAaaSections(analysis)) {
+        return;
+    }
+    let hasMeaningfulAct = false;
+    const assertReferencedIdentifiers = getAssertReferencedIdentifiers(analysis);
+    for (const statement of analysis.statements) {
+        const purityState = getStatementPurityState(assertReferencedIdentifiers, statement);
+        hasMeaningfulAct ||=
+            purityState.allowsAct && purityState.isMeaningfulActContent;
+        reportStatementViolations(context, statement, purityState);
+    }
+    if (!hasMeaningfulAct) {
+        context.report({
+            messageId: "missingMeaningfulAct",
+            node: analysis.callExpression,
+        });
+    }
+}
+/**
+ * Reports any phase-purity violations for one statement.
+ * @param context ESLint rule context.
+ * @param statement Statement entry to report against.
+ * @param purityState Phase-purity state for the statement.
+ * @example
+ * ```typescript
+ * reportStatementViolations({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);
+ * ```
+ */
+function reportStatementViolations(context, statement, purityState) {
+    if (purityState.allowsArrange && !purityState.allowsAct) {
+        reportArrangeOnlyStatement(context, statement, purityState);
+        return;
+    }
+    if (purityState.allowsAct && !purityState.allowsArrange) {
+        reportActOnlyStatement(context, statement, purityState);
+        return;
+    }
+    if (purityState.allowsAssert && !purityState.allowsAct) {
+        reportAssertOnlyStatement(context, statement, purityState);
+    }
+}
+export { reportPhasePurityViolations };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"phase-purity-reporting.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { TestBlockAnalysis } from \"../aaa\";\r\n\r\nimport {\r\n  hasAssertion,\r\n  hasAsyncLogic,\r\n  hasAwait,\r\n  hasCapturableActResult,\r\n  hasMutation,\r\n  isMeaningfulActStatement,\r\n  isSetupLikeStatement,\r\n  isValidAssertStatement,\r\n} from \"../aaa\";\r\nimport {\r\n  getAssertReferencedIdentifiers,\r\n  isActResultAsserted,\r\n} from \"./phase-purity-identifiers\";\r\n\r\n/** Type definition for rule data. */\r\ninterface StatementPurityState {\r\n  /** Whether the statement belongs to Act. */\r\n  allowsAct: boolean;\r\n\r\n  /** Whether the statement belongs to Arrange. */\r\n  allowsArrange: boolean;\r\n\r\n  /** Whether the statement belongs to Assert. */\r\n  allowsAssert: boolean;\r\n\r\n  /** Whether the statement contains an assertion. */\r\n  containsAssertion: boolean;\r\n\r\n  /** Whether the statement contains async logic. */\r\n  containsAsyncLogic: boolean;\r\n\r\n  /** Whether the statement contains an await expression. */\r\n  containsAwait: boolean;\r\n\r\n  /** Whether the statement mutates state. */\r\n  containsMutation: boolean;\r\n\r\n  /** Whether the statement performs meaningful Act work. */\r\n  isMeaningfulAct: boolean;\r\n\r\n  /** Whether the statement counts as meaningful Act content overall. */\r\n  isMeaningfulActContent: boolean;\r\n\r\n  /** Whether the statement looks like setup. */\r\n  isSetupLike: boolean;\r\n\r\n  /** Whether the statement is a valid assert-phase statement. */\r\n  isValidAssert: boolean;\r\n}\r\n\r\n/**\r\n * Collects the phase-purity state for one analyzed statement.\r\n * @param assertReferencedIdentifiers Referenced identifiers collected from Assert.\r\n * @param statement Statement entry to classify.\r\n * @returns Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * const state = getStatementPurityState(new Set<string>(), { node: { type: \"ExpressionStatement\" } as never, phases: [] });\r\n * void state;\r\n * ```\r\n */\r\nfunction getStatementPurityState(\r\n  assertReferencedIdentifiers: Set<string>,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n): StatementPurityState {\r\n  const allowsArrange = statement.phases.includes(\"Arrange\");\r\n  const allowsAct = statement.phases.includes(\"Act\");\r\n  const allowsAssert = statement.phases.includes(\"Assert\");\r\n  const containsAssertion = hasAssertion(statement.node);\r\n  const containsAsyncLogic = hasAsyncLogic(statement.node);\r\n  const containsAwait = hasAwait(statement.node);\r\n  const containsMutation = hasMutation(statement.node);\r\n  const isMeaningfulAct = isMeaningfulActStatement(statement.node);\r\n  const isMeaningfulActContent =\r\n    isMeaningfulAct ||\r\n    hasCapturableActResult(statement.node) ||\r\n    isActResultAsserted(assertReferencedIdentifiers, statement.node);\r\n\r\n  return {\r\n    allowsAct,\r\n    allowsArrange,\r\n    allowsAssert,\r\n    containsAssertion,\r\n    containsAsyncLogic,\r\n    containsAwait,\r\n    containsMutation,\r\n    isMeaningfulAct,\r\n    isMeaningfulActContent,\r\n    isSetupLike: isSetupLikeStatement(statement.node),\r\n    isValidAssert: isValidAssertStatement(statement.node),\r\n  };\r\n}\r\n\r\n/**\r\n * Checks whether the analyzed test block declares all AAA section comments.\r\n * @param analysis Parsed test-block analysis.\r\n * @returns True when Arrange, Act, and Assert are all present.\r\n * @example\r\n * ```typescript\r\n * const complete = hasAllAaaSections({ sectionComments: [] } as never);\r\n * void complete;\r\n * ```\r\n */\r\nfunction hasAllAaaSections(analysis: TestBlockAnalysis): boolean {\r\n  return [\"Arrange\", \"Act\", \"Assert\"].every((phase) =>\r\n    analysis.sectionComments.some((sectionComment) =>\r\n      sectionComment.phases.includes(phase as never),\r\n    ),\r\n  );\r\n}\r\n\r\n/**\r\n * Reports Act-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportActOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportActOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion && !purityState.allowsAssert) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n\r\n  if (\r\n    purityState.allowsAssert &&\r\n    purityState.containsAssertion &&\r\n    !purityState.isValidAssert\r\n  ) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.isSetupLike && !purityState.isMeaningfulActContent) {\r\n    context.report({ messageId: \"setupAfterAct\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Arrange-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportArrangeOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportArrangeOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAssertion && !purityState.allowsAssert) {\r\n    context.report({\r\n      messageId: \"assertionOutsideAssert\",\r\n      node: statement.node,\r\n    });\r\n  }\r\n\r\n  if (purityState.containsAwait) {\r\n    context.report({ messageId: \"awaitOutsideAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsAsyncLogic) {\r\n    context.report({ messageId: \"asyncInArrange\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.isMeaningfulAct) {\r\n    context.report({ messageId: \"actionInArrange\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports Assert-only phase violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportAssertOnlyStatement({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportAssertOnlyStatement(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.containsAwait) {\r\n    context.report({ messageId: \"awaitOutsideAct\", node: statement.node });\r\n  }\r\n\r\n  if (purityState.containsMutation) {\r\n    context.report({ messageId: \"mutationAfterAct\", node: statement.node });\r\n    return;\r\n  }\r\n\r\n  if (!purityState.isValidAssert) {\r\n    context.report({ messageId: \"nonAssertionInAssert\", node: statement.node });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports all enforce-aaa-phase-purity violations for one test block.\r\n * @param context ESLint rule context.\r\n * @param analysis Parsed test-block analysis.\r\n * @example\r\n * ```typescript\r\n * reportPhasePurityViolations({ report() {} } as never, { sectionComments: [], statements: [] } as never);\r\n * ```\r\n */\r\nfunction reportPhasePurityViolations(\r\n  context: Rule.RuleContext,\r\n  analysis: TestBlockAnalysis,\r\n): void {\r\n  if (!hasAllAaaSections(analysis)) {\r\n    return;\r\n  }\r\n\r\n  let hasMeaningfulAct = false;\r\n  const assertReferencedIdentifiers = getAssertReferencedIdentifiers(analysis);\r\n\r\n  for (const statement of analysis.statements) {\r\n    const purityState = getStatementPurityState(\r\n      assertReferencedIdentifiers,\r\n      statement,\r\n    );\r\n\r\n    hasMeaningfulAct ||=\r\n      purityState.allowsAct && purityState.isMeaningfulActContent;\r\n    reportStatementViolations(context, statement, purityState);\r\n  }\r\n\r\n  if (!hasMeaningfulAct) {\r\n    context.report({\r\n      messageId: \"missingMeaningfulAct\",\r\n      node: analysis.callExpression,\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Reports any phase-purity violations for one statement.\r\n * @param context ESLint rule context.\r\n * @param statement Statement entry to report against.\r\n * @param purityState Phase-purity state for the statement.\r\n * @example\r\n * ```typescript\r\n * reportStatementViolations({ report() {} } as never, { node: {} as never, phases: [] }, {} as never);\r\n * ```\r\n */\r\nfunction reportStatementViolations(\r\n  context: Rule.RuleContext,\r\n  statement: TestBlockAnalysis[\"statements\"][number],\r\n  purityState: StatementPurityState,\r\n): void {\r\n  if (purityState.allowsArrange && !purityState.allowsAct) {\r\n    reportArrangeOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (purityState.allowsAct && !purityState.allowsArrange) {\r\n    reportActOnlyStatement(context, statement, purityState);\r\n    return;\r\n  }\r\n\r\n  if (purityState.allowsAssert && !purityState.allowsAct) {\r\n    reportAssertOnlyStatement(context, statement, purityState);\r\n  }\r\n}\r\n\r\nexport { reportPhasePurityViolations };\r\n"]}

package/dist/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.d.ts

@@ -0,0 +1,42 @@
+import type * as ESTree from "estree";
+import { Linter } from "eslint";
+import type { TestBlockAnalysis } from "../aaa/index.js";
+/** Minimal analysis input accepted by the mocked AAA helper. */
+interface MockedAnalysisInput {
+    /** Section comments relevant to the rule under test. */
+    sectionComments: {
+        /** Phase names declared by the synthetic comment. */
+        phases: TestBlockAnalysis["sectionComments"][number]["phases"];
+    }[];
+    /** Statement metadata relevant to the rule under test. */
+    statements: {
+        /** Synthetic statement node provided to the rule. */
+        node: ESTree.Statement;
+        /** Active phases assigned to the statement. */
+        phases: TestBlockAnalysis["statements"][number]["phases"];
+    }[];
+}
+/**
+ * Runs the rule against one source snippet.
+ * @param code Source code passed to the linter.
+ * @returns Lint messages produced by the rule.
+ * @example
+ * ```typescript
+ * const messages = runRule('it("works", () => {});');
+ * void messages;
+ * ```
+ */
+declare function runRule(code: string): Linter.LintMessage[];
+/**
+ * Runs the rule with a mocked AAA analysis result.
+ * @param analysis Mocked analysis returned from `analyzeTestBlock`.
+ * @returns Captured report calls issued by the rule.
+ * @example
+ * ```typescript
+ * const calls = await runRuleWithMockedAnalysis({ sectionComments: [], statements: [] });
+ * void calls;
+ * ```
+ */
+declare function runRuleWithMockedAnalysis(analysis: MockedAnalysisInput): Promise<unknown[][]>;
+export { runRule, runRuleWithMockedAnalysis };
+//# sourceMappingURL=rule-test-helpers.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-test-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAIhD,gEAAgE;AAChE,UAAU,mBAAmB;IAC3B,wDAAwD;IACxD,eAAe,EAAE;QACf,qDAAqD;QACrD,MAAM,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC;KAChE,EAAE,CAAC;IACJ,0DAA0D;IAC1D,UAAU,EAAE;QACV,qDAAqD;QACrD,IAAI,EAAE,MAAM,CAAC,SAAS,CAAC;QAEvB,+CAA+C;QAC/C,MAAM,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC;KAC3D,EAAE,CAAC;CACL;AAyJD;;;;;;;;;GASG;AACH,iBAAS,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,WAAW,EAAE,CA2BnD;AAED;;;;;;;;;GASG;AACH,iBAAe,yBAAyB,CACtC,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAUtB;AAED,OAAO,EAAE,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.js

@@ -0,0 +1,188 @@
+import { Linter } from "eslint";
+import { parser } from "typescript-eslint";
+import { vi } from "vitest";
+import { enforceAaaPhasePurityRule } from "./rule.js";
+/**
+ * Creates the mocked AAA module used by the rule test helper.
+ * @param mockedAnalysis Mocked analysis returned by the helper.
+ * @returns Partial AAA module used for Vitest mocking.
+ * @example
+ * ```typescript
+ * const module = createMockedAaaModule(createMockedAnalysis({ sectionComments: [], statements: [] }));
+ * void module;
+ * ```
+ */
+function createMockedAaaModule(mockedAnalysis) {
+    return {
+        analyzeTestBlock: () => mockedAnalysis,
+        hasAssertion: () => false,
+        hasAsyncLogic: () => false,
+        hasAwait: () => false,
+        hasCapturableActResult: () => false,
+        hasMutation: () => false,
+        isMeaningfulActStatement: () => false,
+        isSetupLikeStatement: () => false,
+        isValidAssertStatement: () => false,
+    };
+}
+/**
+ * Creates a full analysis object from the minimal fields used in tests.
+ * @param analysis Minimal analysis input used by tests.
+ * @returns Complete analysis object consumed by the rule.
+ * @example
+ * ```typescript
+ * const result = createMockedAnalysis({ sectionComments: [], statements: [] });
+ * void result;
+ * ```
+ */
+function createMockedAnalysis(analysis) {
+    return {
+        body: createMockedBody(),
+        bodyLineCount: 0,
+        callExpression: createMockedCallExpression(),
+        newline: "\n",
+        sectionComments: analysis.sectionComments.map((sectionComment) => ({
+            comment: {
+                loc: {
+                    end: { column: 0, line: 1 },
+                    start: { column: 0, line: 1 },
+                },
+                range: [0, 0],
+                type: "Line",
+                value: ` ${sectionComment.phases.join(" / ")}`,
+            },
+            phases: sectionComment.phases,
+        })),
+        sourceText: "",
+        statements: analysis.statements.map((statement) => ({
+            node: statement.node,
+            phase: statement.phases.at(-1),
+            phases: statement.phases,
+        })),
+    };
+}
+/**
+ * Creates a minimal located block statement for mocked AAA analysis.
+ * @returns Minimal located block statement.
+ * @example
+ * ```typescript
+ * const body = createMockedBody();
+ * ```
+ */
+function createMockedBody() {
+    return {
+        body: [],
+        loc: {
+            end: { column: 0, line: 1 },
+            start: { column: 0, line: 1 },
+        },
+        range: [0, 0],
+        type: "BlockStatement",
+    };
+}
+/**
+ * Creates a minimal located call expression for mocked AAA analysis.
+ * @returns Minimal located call expression.
+ * @example
+ * ```typescript
+ * const callExpression = createMockedCallExpression();
+ * ```
+ */
+function createMockedCallExpression() {
+    return {
+        arguments: [],
+        callee: { name: "it", type: "Identifier" },
+        loc: {
+            end: { column: 0, line: 1 },
+            start: { column: 0, line: 1 },
+        },
+        optional: false,
+        range: [0, 0],
+        type: "CallExpression",
+    };
+}
+/**
+ * Creates the mocked rule listener used by the helper.
+ * @param analysis Mocked analysis returned from `analyzeTestBlock`.
+ * @param report Report spy passed into the mocked rule context.
+ * @returns Call-expression listener produced by the mocked rule.
+ * @example
+ * ```typescript
+ * const listener = await loadMockedListener({ sectionComments: [], statements: [] }, vi.fn());
+ * void listener;
+ * ```
+ */
+async function loadMockedListener(analysis, report) {
+    vi.resetModules();
+    vi.doMock("../aaa", () => createMockedAaaModule(createMockedAnalysis(analysis)));
+    const ruleModule = await import("./rule.js");
+    return ruleModule.enforceAaaPhasePurityRule.create({ report })
+        .CallExpression;
+}
+/**
+ * Resets the mocked AAA module state between test runs.
+ * @example
+ * ```typescript
+ * resetMockedAaaModule();
+ * ```
+ */
+function resetMockedAaaModule() {
+    vi.doUnmock("../aaa");
+    vi.resetModules();
+}
+/**
+ * Runs the rule against one source snippet.
+ * @param code Source code passed to the linter.
+ * @returns Lint messages produced by the rule.
+ * @example
+ * ```typescript
+ * const messages = runRule('it("works", () => {});');
+ * void messages;
+ * ```
+ */
+function runRule(code) {
+    const linter = new Linter({ configType: "flat" });
+    return linter.verify(code, [
+        {
+            files: ["**/*.ts"],
+            languageOptions: {
+                ecmaVersion: 2022,
+                parser,
+                sourceType: "module",
+            },
+            plugins: {
+                codeperfect: {
+                    rules: {
+                        "enforce-aaa-phase-purity": enforceAaaPhasePurityRule,
+                    },
+                },
+            },
+            rules: {
+                "codeperfect/enforce-aaa-phase-purity": "error",
+            },
+        },
+    ], "example.spec.ts");
+}
+/**
+ * Runs the rule with a mocked AAA analysis result.
+ * @param analysis Mocked analysis returned from `analyzeTestBlock`.
+ * @returns Captured report calls issued by the rule.
+ * @example
+ * ```typescript
+ * const calls = await runRuleWithMockedAnalysis({ sectionComments: [], statements: [] });
+ * void calls;
+ * ```
+ */
+async function runRuleWithMockedAnalysis(analysis) {
+    const report = vi.fn();
+    const listener = await loadMockedListener(analysis, report);
+    try {
+        listener?.({ type: "CallExpression" });
+        return report.mock.calls;
+    }
+    finally {
+        resetMockedAaaModule();
+    }
+}
+export { runRule, runRuleWithMockedAnalysis };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-test-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\nimport { Linter } from \"eslint\";\r\nimport { parser } from \"typescript-eslint\";\r\nimport { vi } from \"vitest\";\r\n\r\nimport type * as AaaModule from \"../aaa\";\r\nimport type { TestBlockAnalysis } from \"../aaa\";\r\n\r\nimport { enforceAaaPhasePurityRule } from \"./rule\";\r\n\r\n/** Minimal analysis input accepted by the mocked AAA helper. */\r\ninterface MockedAnalysisInput {\r\n  /** Section comments relevant to the rule under test. */\r\n  sectionComments: {\r\n    /** Phase names declared by the synthetic comment. */\r\n    phases: TestBlockAnalysis[\"sectionComments\"][number][\"phases\"];\r\n  }[];\r\n  /** Statement metadata relevant to the rule under test. */\r\n  statements: {\r\n    /** Synthetic statement node provided to the rule. */\r\n    node: ESTree.Statement;\r\n\r\n    /** Active phases assigned to the statement. */\r\n    phases: TestBlockAnalysis[\"statements\"][number][\"phases\"];\r\n  }[];\r\n}\r\n\r\n/** Module shape returned when the rule is loaded after mocking the AAA helpers. */\r\ninterface MockedRuleModule {\r\n  /** Rule implementation under test. */\r\n  enforceAaaPhasePurityRule: typeof enforceAaaPhasePurityRule;\r\n}\r\n\r\n/**\r\n * Creates the mocked AAA module used by the rule test helper.\r\n * @param mockedAnalysis Mocked analysis returned by the helper.\r\n * @returns Partial AAA module used for Vitest mocking.\r\n * @example\r\n * ```typescript\r\n * const module = createMockedAaaModule(createMockedAnalysis({ sectionComments: [], statements: [] }));\r\n * void module;\r\n * ```\r\n */\r\nfunction createMockedAaaModule(\r\n  mockedAnalysis: TestBlockAnalysis,\r\n): Partial<typeof AaaModule> {\r\n  return {\r\n    analyzeTestBlock: (): TestBlockAnalysis => mockedAnalysis,\r\n    hasAssertion: (): boolean => false,\r\n    hasAsyncLogic: (): boolean => false,\r\n    hasAwait: (): boolean => false,\r\n    hasCapturableActResult: (): boolean => false,\r\n    hasMutation: (): boolean => false,\r\n    isMeaningfulActStatement: (): boolean => false,\r\n    isSetupLikeStatement: (): boolean => false,\r\n    isValidAssertStatement: (): boolean => false,\r\n  };\r\n}\r\n\r\n/**\r\n * Creates a full analysis object from the minimal fields used in tests.\r\n * @param analysis Minimal analysis input used by tests.\r\n * @returns Complete analysis object consumed by the rule.\r\n * @example\r\n * ```typescript\r\n * const result = createMockedAnalysis({ sectionComments: [], statements: [] });\r\n * void result;\r\n * ```\r\n */\r\nfunction createMockedAnalysis(\r\n  analysis: MockedAnalysisInput,\r\n): TestBlockAnalysis {\r\n  return {\r\n    body: createMockedBody(),\r\n    bodyLineCount: 0,\r\n    callExpression: createMockedCallExpression(),\r\n    newline: \"\\n\",\r\n    sectionComments: analysis.sectionComments.map((sectionComment) => ({\r\n      comment: {\r\n        loc: {\r\n          end: { column: 0, line: 1 },\r\n          start: { column: 0, line: 1 },\r\n        },\r\n        range: [0, 0],\r\n        type: \"Line\",\r\n        value: ` ${sectionComment.phases.join(\" / \")}`,\r\n      },\r\n      phases: sectionComment.phases,\r\n    })),\r\n    sourceText: \"\",\r\n    statements: analysis.statements.map((statement) => ({\r\n      node: statement.node as TestBlockAnalysis[\"statements\"][number][\"node\"],\r\n      phase: statement.phases.at(-1),\r\n      phases: statement.phases,\r\n    })),\r\n  };\r\n}\r\n\r\n/**\r\n * Creates a minimal located block statement for mocked AAA analysis.\r\n * @returns Minimal located block statement.\r\n * @example\r\n * ```typescript\r\n * const body = createMockedBody();\r\n * ```\r\n */\r\nfunction createMockedBody(): TestBlockAnalysis[\"body\"] {\r\n  return {\r\n    body: [],\r\n    loc: {\r\n      end: { column: 0, line: 1 },\r\n      start: { column: 0, line: 1 },\r\n    },\r\n    range: [0, 0],\r\n    type: \"BlockStatement\",\r\n  } as TestBlockAnalysis[\"body\"];\r\n}\r\n\r\n/**\r\n * Creates a minimal located call expression for mocked AAA analysis.\r\n * @returns Minimal located call expression.\r\n * @example\r\n * ```typescript\r\n * const callExpression = createMockedCallExpression();\r\n * ```\r\n */\r\nfunction createMockedCallExpression(): TestBlockAnalysis[\"callExpression\"] {\r\n  return {\r\n    arguments: [],\r\n    callee: { name: \"it\", type: \"Identifier\" } as ESTree.Identifier,\r\n    loc: {\r\n      end: { column: 0, line: 1 },\r\n      start: { column: 0, line: 1 },\r\n    },\r\n    optional: false,\r\n    range: [0, 0],\r\n    type: \"CallExpression\",\r\n  } as TestBlockAnalysis[\"callExpression\"];\r\n}\r\n\r\n/**\r\n * Creates the mocked rule listener used by the helper.\r\n * @param analysis Mocked analysis returned from `analyzeTestBlock`.\r\n * @param report Report spy passed into the mocked rule context.\r\n * @returns Call-expression listener produced by the mocked rule.\r\n * @example\r\n * ```typescript\r\n * const listener = await loadMockedListener({ sectionComments: [], statements: [] }, vi.fn());\r\n * void listener;\r\n * ```\r\n */\r\nasync function loadMockedListener(\r\n  analysis: MockedAnalysisInput,\r\n  report: ReturnType<typeof vi.fn>,\r\n): Promise<((node: ESTree.CallExpression) => void) | undefined> {\r\n  vi.resetModules();\r\n  vi.doMock(\"../aaa\", () =>\r\n    createMockedAaaModule(createMockedAnalysis(analysis)),\r\n  );\r\n\r\n  const ruleModule: MockedRuleModule = await import(\"./rule\");\r\n\r\n  return ruleModule.enforceAaaPhasePurityRule.create({ report } as never)\r\n    .CallExpression as ((node: ESTree.CallExpression) => void) | undefined;\r\n}\r\n\r\n/**\r\n * Resets the mocked AAA module state between test runs.\r\n * @example\r\n * ```typescript\r\n * resetMockedAaaModule();\r\n * ```\r\n */\r\nfunction resetMockedAaaModule(): void {\r\n  vi.doUnmock(\"../aaa\");\r\n  vi.resetModules();\r\n}\r\n\r\n/**\r\n * Runs the rule against one source snippet.\r\n * @param code Source code passed to the linter.\r\n * @returns Lint messages produced by the rule.\r\n * @example\r\n * ```typescript\r\n * const messages = runRule('it(\"works\", () => {});');\r\n * void messages;\r\n * ```\r\n */\r\nfunction runRule(code: string): Linter.LintMessage[] {\r\n  const linter = new Linter({ configType: \"flat\" });\r\n\r\n  return linter.verify(\r\n    code,\r\n    [\r\n      {\r\n        files: [\"**/*.ts\"],\r\n        languageOptions: {\r\n          ecmaVersion: 2022,\r\n          parser,\r\n          sourceType: \"module\",\r\n        },\r\n        plugins: {\r\n          codeperfect: {\r\n            rules: {\r\n              \"enforce-aaa-phase-purity\": enforceAaaPhasePurityRule,\r\n            },\r\n          },\r\n        },\r\n        rules: {\r\n          \"codeperfect/enforce-aaa-phase-purity\": \"error\",\r\n        },\r\n      },\r\n    ],\r\n    \"example.spec.ts\",\r\n  );\r\n}\r\n\r\n/**\r\n * Runs the rule with a mocked AAA analysis result.\r\n * @param analysis Mocked analysis returned from `analyzeTestBlock`.\r\n * @returns Captured report calls issued by the rule.\r\n * @example\r\n * ```typescript\r\n * const calls = await runRuleWithMockedAnalysis({ sectionComments: [], statements: [] });\r\n * void calls;\r\n * ```\r\n */\r\nasync function runRuleWithMockedAnalysis(\r\n  analysis: MockedAnalysisInput,\r\n): Promise<unknown[][]> {\r\n  const report = vi.fn();\r\n  const listener = await loadMockedListener(analysis, report);\r\n\r\n  try {\r\n    listener?.({ type: \"CallExpression\" } as ESTree.CallExpression);\r\n    return report.mock.calls as unknown[][];\r\n  } finally {\r\n    resetMockedAaaModule();\r\n  }\r\n}\r\n\r\nexport { runRule, runRuleWithMockedAnalysis };\r\n"]}

package/dist/{testing → domain/testing}/enforce-aaa-phase-purity/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** Enforces pure Arrange, Act, and Assert behavior inside AAA-marked tests. */
 declare const enforceAaaPhasePurityRule: Rule.RuleModule;
 export { enforceAaaPhasePurityRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAMnC,+EAA+E;AAC/E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAoCrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/rule.js

@@ -0,0 +1,34 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation.js";
+import { analyzeTestBlock } from "../aaa/index.js";
+import { reportPhasePurityViolations } from "./phase-purity-reporting.js";
+/** Enforces pure Arrange, Act, and Assert behavior inside AAA-marked tests. */
+const enforceAaaPhasePurityRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                reportPhasePurityViolations(context, analysis);
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("enforce-aaa-phase-purity", "Keep setup, action, and assertions inside their intended AAA phases."),
+        messages: {
+            actionInArrange: "Keep the function under test out of Arrange; reserve Arrange for setup only.",
+            assertionOutsideAssert: "Move assertions into the // Assert section so test logic does not leak earlier.",
+            asyncInArrange: "Do not trigger async behavior in Arrange.",
+            awaitOutsideAct: "Use await only inside the // Act section.",
+            missingMeaningfulAct: "The // Act section must contain a meaningful SUT interaction, not only utility or setup calls.",
+            mutationAfterAct: "Do not mutate test data after the // Act section has run.",
+            nonAssertionInAssert: "Keep the // Assert section focused on assertions and assertion-local values.",
+            setupAfterAct: "Do not continue arranging test data after the // Act section has started.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { enforceAaaPhasePurityRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/enforce-aaa-structure/index.d.ts

@@ -0,0 +1,2 @@
+export { enforceAaaStructureRule } from "./rule.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/enforce-aaa-structure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/enforce-aaa-structure/index.js

@@ -0,0 +1,2 @@
+export { enforceAaaStructureRule } from "./rule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvZW5mb3JjZS1hYWEtc3RydWN0dXJlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlIH0gZnJvbSBcIi4vcnVsZVwiO1xuIl19

package/dist/{testing → domain/testing}/enforce-aaa-structure/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** Enforces a single Arrange/Act/Assert sequence inside supported test blocks. */
 declare const enforceAaaStructureRule: Rule.RuleModule;
 export { enforceAaaStructureRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/enforce-aaa-structure/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAsFnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAsCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}