@starci/eslint-canon-be 3.3.1 → 3.4.0

package/unit-spec.mjs

@@ -1,12 +1,12 @@
 /**
- * The rules that hold the FORM of a unit spec (catalog R48 `BE_SPEC_QUALITY`, the unit-test standard of 2026-09-30).
+ * The rules that hold the FORM of a unit spec (R48 `BE_SPEC_QUALITY`, extended by R281 `BE_SPEC_FORM_ALL_ROLES`).
  *
- * A unit spec is `<name>.service.spec.ts` beside `<name>.service.ts` (R47). It builds the service the way Nest builds it
+ * A unit spec is `<name>.<role>.spec.ts` beside its logic-role subject (R47). It builds the subject the way Nest builds it
  * and takes every double from the one shared kit, `@starci/jest-preset`:
  *
  *   - `spec-builds-with-testing-module`: the spec calls `Test.createTestingModule(...)` from `@nestjs/testing`, awaits
  *     `.compile()` and reads the subject with `.get(...)` on the resulting `TestingModule`.
- *   - `spec-no-new-subject`: the service under test (the class of the sibling `<name>.service.ts`) is never built with `new`.
+ *   - `spec-no-new-subject`: the subject (the class of the sibling `<name>.<role>.ts`) is never built with `new`.
  *   - `spec-module-definition-only-providers`: the module definition has a `providers` list and nothing else: no `imports` key
  *     and no `override*` call (`overrideProvider`, `overrideGuard`, `overrideModule`, `overrideFilter`, `overridePipe`,
  *     `overrideInterceptor`).
@@ -20,27 +20,37 @@
  *   - `spec-exact-values`: no `expect.any(String)`, `expect.any(Number)` or `expect.any(Date)` (`expect` being the jest global
  *     or the `@jest/globals` import): ids and clocks come from the kit's deterministic doubles (`fakeIds()`, `FakeClock`), so a
  *     unit spec asserts the exact value.
+ *   - `spec-behavior-assertion`: every `it`/`test` asserts a result or effect; a spec with only presence/truthiness
+ *     assertions must assert an exact result or effect.
  *
  * Paths are asked of the slot manifest (`lib/unit-spec.mjs`), a name is judged by the import that binds it, never by its spelling.
  */
 import { hfsOf } from "./lib/hfs.mjs"
-import { walk } from "./lib/ast.mjs"
-import { importOf } from "./lib/import-source.mjs"
+import { keyName, walk } from "./lib/ast.mjs"
+import { importOf, isImportedFrom } from "./lib/import-source.mjs"
 import { isPackageType, typeOrigins } from "./lib/types.mjs"
-import { baseOf, isServiceSpecFile, isUnitSpecFile, serviceNameOfSpec } from "./lib/unit-spec.mjs"
+import { baseOf, isServiceSpecFile, isUnitSpecFile, unitRoleOfSpec } from "./lib/unit-spec.mjs"
+import { isRealSubjectValue, valueObjectsOfSibling } from "./lib/subject-values.mjs"
 
 const TESTING_PACKAGE = "@nestjs/testing"
 
+/** Existing service specs and every other unit-tested logic role declared by the manifest. */
+const isFormSpecFile = (hfs, filename) => isServiceSpecFile(hfs, filename) || unitRoleOfSpec(hfs, filename) !== null
+
+/** Whether this callee creates a Nest testing module through its actual import. */
+const isTestingFactory = (context, callee) => {
+    if (callee.type !== "MemberExpression" || callee.computed || keyName(callee.property) !== "createTestingModule") return false
+    const found = importOf(context, callee.object)
+    return found?.source === TESTING_PACKAGE && found.imported === "Test"
+}
+
 /** The last call in a chain `Test.createTestingModule(...).<a>().<b>()`: the `createTestingModule` call at its root, or null. */
 const testingModuleRoot = (context, node) => {
     let cursor = node
     while (cursor) {
         if (cursor.type === "CallExpression") {
             const callee = cursor.callee
-            if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && callee.property.name === "createTestingModule" && callee.object.type === "Identifier") {
-                const found = importOf(context, callee.object)
-                return found && found.source === TESTING_PACKAGE && found.imported === "Test" ? cursor : null
-            }
+            if (isTestingFactory(context, callee)) return cursor
             cursor = callee.type === "MemberExpression" ? callee.object : null
         } else if (cursor.type === "MemberExpression") cursor = cursor.object
         else if (cursor.type === "AwaitExpression") cursor = cursor.argument
@@ -54,20 +64,22 @@ const isCreateTestingModule = (context, node) => node.type === "CallExpression"
 
 // -- spec-builds-with-testing-module ---------------------------------------------------------------------------
 
-/** A service spec builds its subject through the Nest testing module. */
+/** A logic-role spec builds its subject through the Nest testing module. */
 export const specBuildsWithTestingModule = {
     meta: {
         type: "problem",
-        docs: { description: "A `<name>.service.spec.ts` calls `Test.createTestingModule(...)` from `@nestjs/testing`, awaits `.compile()` and reads the subject with `.get(...)`." },
+        docs: { description: "A logic-role unit spec calls `Test.createTestingModule(...)` from `@nestjs/testing`, awaits `.compile()` and reads the subject with `.get(...)`." },
         schema: [],
         messages: {
-            noModule: "This service spec never calls `Test.createTestingModule(...)` from `@nestjs/testing`. Build the subject the way Nest does, so its constructor injectors are exercised: `const moduleRef = await Test.createTestingModule({ providers: [Subject, { provide: TOKEN, useValue: double }] }).compile()`.",
-            noCompile: "`Test.createTestingModule(...)` is never followed by `.compile()`, so no module exists to read the subject from.",
-            noGet: "The subject is never read with `moduleRef.get(Subject)` from the compiled `TestingModule`. Read it from the module, do not hold a second construction path.",
+            noModule: "[BE_SPEC_FORM_ALL_ROLES] This logic-role spec never calls `Test.createTestingModule(...)` from `@nestjs/testing`. Build the subject the way Nest does, so its constructor injectors are exercised: `const moduleRef = await Test.createTestingModule({ providers: [Subject, { provide: TOKEN, useValue: double }] }).compile()`.",
+            noCompile: "[BE_SPEC_FORM_ALL_ROLES] `Test.createTestingModule(...)` is never followed by `.compile()`, so no module exists to read the subject from.",
+            noGet: "[BE_SPEC_FORM_ALL_ROLES] The subject is never read with `moduleRef.get(Subject)` from the compiled `TestingModule`. Read it from the module, do not hold a second construction path.",
         },
     },
     create(context) {
-        if (!isServiceSpecFile(hfsOf(context), context.filename || context.getFilename())) return {}
+        if (!isFormSpecFile(hfsOf(context), context.filename || context.getFilename())) return {}
+        // a value-object subject (undecorated, no constructor injection token) is built with `new`: Nest never constructs it
+        const valueObjectSpec = valueObjectsOfSibling(context).length > 0
         let created = null
         let compiled = false
         let read = false
@@ -80,6 +92,7 @@ export const specBuildsWithTestingModule = {
                 if (callee.property.name === "get" && isPackageType(context, callee.object, "TestingModule", TESTING_PACKAGE)) read = true
             },
             "Program:exit"(node) {
+                if (created === null && valueObjectSpec) return
                 if (created === null) context.report({ node, messageId: "noModule" })
                 else if (!compiled) context.report({ node: created, messageId: "noCompile" })
                 else if (!read) context.report({ node: created, messageId: "noGet" })
@@ -93,26 +106,30 @@ export const specBuildsWithTestingModule = {
 /** The last path segment of a module specifier, without an extension. */
 const moduleStem = (specifier) => String(specifier).replace(/\\/g, "/").split("/").pop().replace(/\.[cm]?[jt]s$/, "")
 
-/** The service under test is never constructed by hand. */
+/** The logic-role subject is never constructed by hand. */
 export const specNoNewSubject = {
     meta: {
         type: "problem",
-        docs: { description: "A service spec never builds the service under test with `new`." },
+        docs: { description: "A logic-role unit spec never builds its subject with `new`." },
         schema: [],
         messages: {
-            construct: "`new {{name}}(...)` builds the service under test by hand, so its injectors are never exercised and a constructor change goes unnoticed. Provide it in `Test.createTestingModule({ providers: [{{name}}, ...] })` and read it with `moduleRef.get({{name}})`.",
+            construct: "[BE_SPEC_FORM_ALL_ROLES] `new {{name}}(...)` builds the subject by hand, so its injectors are never exercised and a constructor change goes unnoticed. Provide it in `Test.createTestingModule({ providers: [{{name}}, ...] })` and read it with `moduleRef.get({{name}})`.",
         },
     },
     create(context) {
         const filename = context.filename || context.getFilename()
-        if (!isServiceSpecFile(hfsOf(context), filename)) return {}
-        const stem = `${serviceNameOfSpec(filename)}.service`
+        if (!isFormSpecFile(hfsOf(context), filename)) return {}
+        const stem = baseOf(filename).replace(/\.spec\.ts$/, "")
         const locals = new Set()
         const namespaces = new Set()
+        const valueObjects = new Set(valueObjectsOfSibling(context))
         return {
             ImportDeclaration(node) {
                 if (moduleStem(node.source.value) !== stem) return
-                for (const specifier of node.specifiers) (specifier.type === "ImportNamespaceSpecifier" ? namespaces : locals).add(specifier.local.name)
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === "ImportSpecifier" && valueObjects.has(specifier.imported.name ?? specifier.imported.value)) continue
+                    (specifier.type === "ImportNamespaceSpecifier" ? namespaces : locals).add(specifier.local.name)
+                }
             },
             NewExpression(node) {
                 const callee = node.callee
@@ -133,15 +150,15 @@ const OVERRIDES = new Set(["overrideProvider", "overrideGuard", "overrideModule"
 export const specModuleDefinitionOnlyProviders = {
     meta: {
         type: "problem",
-        docs: { description: "A service spec's testing module has no `imports` key and no `override*` call." },
+        docs: { description: "A logic-role unit spec's testing module has no `imports` key and no `override*` call." },
         schema: [],
         messages: {
-            imports: "`imports` pulls a real module into a unit spec, so the test runs the module's providers instead of the doubles you list. Provide exactly the service's constructor dependencies in `providers`.",
-            override: "`{{method}}` swaps a provider after the module was declared. A unit spec provides its double up front: `providers: [Subject, { provide: TOKEN, useValue: double }]`.",
+            imports: "[BE_SPEC_FORM_ALL_ROLES] `imports` pulls a real module into a unit spec, so the test runs the module's providers instead of the doubles you list. Provide exactly the subject's constructor dependencies in `providers`.",
+            override: "[BE_SPEC_FORM_ALL_ROLES] `{{method}}` swaps a provider after the module was declared. A unit spec provides its double up front: `providers: [Subject, { provide: TOKEN, useValue: double }]`.",
         },
     },
     create(context) {
-        if (!isServiceSpecFile(hfsOf(context), context.filename || context.getFilename())) return {}
+        if (!isFormSpecFile(hfsOf(context), context.filename || context.getFilename())) return {}
         return {
             CallExpression(node) {
                 if (isCreateTestingModule(context, node)) {
@@ -186,7 +203,7 @@ export const specNoModuleMock = {
         docs: { description: "A unit spec never calls `jest.mock`, `jest.doMock`, `jest.unstable_mockModule` or `jest.requireMock`." },
         schema: [],
         messages: {
-            moduleMock: "`jest.{{method}}(...)` replaces a whole module, so the subject runs against a stand-in the production wiring never has. Provide a collaborator through its injection token (`{ provide: TOKEN, useValue: mock<Port>() }`); a third-party library is reached through the wrapper that owns it, and the wrapper is the double.",
+            moduleMock: "[BE_SPEC_FORM_ALL_ROLES] `jest.{{method}}(...)` replaces a whole module, so the subject runs against a stand-in the production wiring never has. Provide a collaborator through its injection token (`{ provide: TOKEN, useValue: mock<Port>() }`); a third-party library is reached through the wrapper that owns it, and the wrapper is the double.",
         },
     },
     create(context) {
@@ -239,6 +256,71 @@ const assignedClassOf = (node) => {
     return target?.type === "NewExpression" && target.callee.type === "Identifier" ? target.callee.name : null
 }
 
+/** The declared name of a function or the property that holds it. */
+const functionNameOf = (fn) => {
+    if (fn.id?.name) return fn.id.name
+    const parent = fn.parent
+    if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name
+    if (parent?.type === "Property" || parent?.type === "MethodDefinition") return parent.key.name ?? parent.key.value
+    return "this function"
+}
+
+/** Names that the parameter types mention. */
+const parameterTypeNames = (fn) => {
+    const names = new Set()
+    for (const param of fn.params) {
+        for (const spelled of typeNamesIn(param.typeAnnotation ?? param.left?.typeAnnotation)) names.add(spelled)
+    }
+    return names
+}
+
+/** Report type parameters chosen only by the caller's expected return type. */
+const reportReturnOnlyParameters = (context, fn, name) => {
+    const declared = fn.typeParameters?.params ?? []
+    const returned = fn.returnType?.typeAnnotation
+    if (declared.length === 0 || !returned) return false
+    const inReturn = typeNamesIn(returned)
+    const inParams = parameterTypeNames(fn)
+    let generic = false
+    for (const param of declared) {
+        const spelled = param.name.name
+        // A parameter mentioned by another parameter's bound is driven by the caller's arguments.
+        const inBounds = declared.some((other) => other !== param && (typeNamesIn(other.constraint).has(spelled) || typeNamesIn(other.default).has(spelled)))
+        if (inReturn.has(spelled) && !inParams.has(spelled) && !inBounds) {
+            generic = true
+            context.report({ node: param, messageId: "returnOnly", data: { name, param: spelled } })
+        }
+    }
+    return generic
+}
+
+/** Untyped parameters handed back by a spec helper. */
+const looseParameters = (fn) => {
+    const loose = new Map()
+    for (const param of fn.params) {
+        const target = param.type === "AssignmentPattern" ? param.left : param
+        const kind = target.type === "Identifier" ? target.typeAnnotation?.typeAnnotation?.type : undefined
+        if (kind === "TSUnknownKeyword" || kind === "TSAnyKeyword") loose.set(target.name, kind === "TSAnyKeyword" ? "any" : "unknown")
+    }
+    return loose
+}
+
+/** Report a helper return that launders an untyped value or a different class. */
+const reportHelperReturn = (context, expression, { name, generic, loose, returned }) => {
+    const value = peel(expression)
+    const returnedType = returned?.type
+    const concrete = returnedType !== undefined && returnedType !== "TSUnknownKeyword" && returnedType !== "TSAnyKeyword"
+    if (!generic && value.type === "Identifier" && loose.has(value.name) && (concrete || value !== expression)) {
+        context.report({ node: expression, messageId: "launder", data: { name, kind: loose.get(value.name) } })
+        return true
+    }
+    const klass = assignedClassOf(value)
+    if (klass !== null && returned?.type === "TSTypeReference" && returned.typeName.type === "Identifier" && returned.typeName.name !== klass) {
+        context.report({ node: expression, messageId: "assign", data: { klass, returned: returned.typeName.name } })
+    }
+    return false
+}
+
 /** A helper of a spec or of the fixtures is not a cast with a name. */
 export const noReturnOnlyGeneric = {
     meta: {
@@ -256,44 +338,14 @@ export const noReturnOnlyGeneric = {
         const hfs = hfsOf(context)
         const filename = context.filename || context.getFilename()
         if (!/\.(?:e2e-|integration-|contract-)?spec\.[cm]?ts$/.test(baseOf(filename)) && hfs.slotOf(filename) !== "be.tests.fixtures") return {}
-        const nameOf = (fn) => fn.id?.name ?? (fn.parent?.type === "VariableDeclarator" && fn.parent.id.type === "Identifier" ? fn.parent.id.name : fn.parent?.type === "Property" || fn.parent?.type === "MethodDefinition" ? (fn.parent.key.name ?? fn.parent.key.value) : "this function")
         const check = (fn) => {
-            const name = nameOf(fn)
-            const declared = fn.typeParameters?.params ?? []
-            let generic = false
+            const name = functionNameOf(fn)
+            const generic = reportReturnOnlyParameters(context, fn, name)
             const returned = fn.returnType?.typeAnnotation
-            if (declared.length > 0 && returned) {
-                const inReturn = typeNamesIn(returned)
-                const inParams = new Set()
-                for (const param of fn.params) for (const spelled of typeNamesIn(param.typeAnnotation ?? param.left?.typeAnnotation)) inParams.add(spelled)
-                for (const param of declared) {
-                    const spelled = param.name.name
-                    // a parameter that another parameter's constraint or default mentions is still driven by the caller's arguments
-                    const inBounds = declared.some((other) => other !== param && (typeNamesIn(other.constraint).has(spelled) || typeNamesIn(other.default).has(spelled)))
-                    if (inReturn.has(spelled) && !inParams.has(spelled) && !inBounds) {
-                        generic = true
-                        context.report({ node: param, messageId: "returnOnly", data: { name, param: spelled } })
-                    }
-                }
-            }
             if (fn.body === null || fn.body === undefined) return
-            const loose = new Map()
-            for (const param of fn.params) {
-                const target = param.type === "AssignmentPattern" ? param.left : param
-                const kind = target.type === "Identifier" ? target.typeAnnotation?.typeAnnotation?.type : undefined
-                if (kind === "TSUnknownKeyword" || kind === "TSAnyKeyword") loose.set(target.name, kind === "TSAnyKeyword" ? "any" : "unknown")
-            }
-            const concrete = returned !== undefined && returned.type !== "TSUnknownKeyword" && returned.type !== "TSAnyKeyword"
+            const loose = looseParameters(fn)
             for (const expression of returnedExpressions(fn)) {
-                const value = peel(expression)
-                if (!generic && value.type === "Identifier" && loose.has(value.name) && (concrete || value !== expression)) {
-                    context.report({ node: expression, messageId: "launder", data: { name, kind: loose.get(value.name) } })
-                    return
-                }
-                const klass = assignedClassOf(value)
-                if (klass !== null && returned?.type === "TSTypeReference" && returned.typeName.type === "Identifier" && returned.typeName.name !== klass) {
-                    context.report({ node: expression, messageId: "assign", data: { klass, returned: returned.typeName.name } })
-                }
+                if (reportHelperReturn(context, expression, { name, generic, loose, returned })) return
             }
         }
         return {
@@ -316,7 +368,7 @@ export const noReturnOnlyGeneric = {
 // -- spec-infra-double-from-kit --------------------------------------------------------------------------------
 
 /** `EntityManager` -> `ENTITY_MANAGER`, `redis-cache` -> `REDIS_CACHE`. */
-const screamingSnake = (name) => String(name).replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase().replace(/[^A-Z0-9]+/g, "_")
+const screamingSnake = (name) => String(name).replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase().replace(/[^A-Z0-9]+/g, "_")
 
 /** The name a provider token spells: an identifier, the last member of `Tokens.CLOCK`, a string, a called token factory's name. */
 const tokenName = (node) => {
@@ -339,6 +391,18 @@ const tableOf = (specDoubles) => {
     return compiled
 }
 
+/** A const identifier's initializer, or null when its value cannot be followed. */
+const constantInitializer = (context, value) => {
+    for (let scope = context.sourceCode.getScope(value); scope; scope = scope.upper) {
+        const variable = scope.set.get(value.name)
+        if (!variable) continue
+        const definition = variable.defs[0]
+        if (definition?.type === "Variable" && definition.node.id.type === "Identifier" && definition.node.init && definition.parent.kind === "const") return definition.node.init
+        return null
+    }
+    return null
+}
+
 /** A value's form and the double it names: `{ form, name }`, or null when it is not a form the table knows. */
 const formOf = (context, node, depth = 0) => {
     const value = peel(node)
@@ -349,6 +413,12 @@ const formOf = (context, node, depth = 0) => {
             return null
         case "NewExpression":
             return value.callee.type === "Identifier" ? { form: "new", name: value.callee.name, node: value.callee } : null
+        case "MemberExpression": {
+            // a member of a kit `mock<T>()` object is that mock's double (`mock<{ open: F }>().open`)
+            if (value.computed || depth >= 3) return null
+            const owner = formOf(context, value.object, depth + 1)
+            return owner?.form === "call" && owner.name === "mock" ? owner : null
+        }
         case "ObjectExpression":
             return { form: "object" }
         case "ArrayExpression":
@@ -359,14 +429,8 @@ const formOf = (context, node, depth = 0) => {
             return value.expressions.length === 0 ? { form: "primitive" } : null
         case "Identifier": {
             if (depth >= 3) return null
-            for (let scope = context.sourceCode.getScope(value); scope; scope = scope.upper) {
-                const variable = scope.set.get(value.name)
-                if (!variable) continue
-                const definition = variable.defs[0]
-                if (definition?.type === "Variable" && definition.node.id.type === "Identifier" && definition.node.init && definition.parent.kind === "const") return formOf(context, definition.node.init, depth + 1)
-                return null
-            }
-            return null
+            const initializer = constantInitializer(context, value)
+            return initializer === null ? null : formOf(context, initializer, depth + 1)
         }
         default:
             return null
@@ -382,21 +446,36 @@ const kitDoubleOfType = (context, node, kit) => {
     return found ? KIT_TYPES[found.name] : null
 }
 
+/** How an actual double value is written in a diagnostic. */
+const describeDoubleValue = (found) => {
+    if (found.name === undefined) return `a ${found.form} value`
+    const prefix = found.form === "new" ? "new " : ""
+    return `\`${prefix}${found.name}(...)\``
+}
+
+/** Judge a provider that is traced by its declared type instead of its initializer. */
+const checkTypedDouble = (context, node, table, entry, data) => {
+    const typedAs = kitDoubleOfType(context, node.value, table.kit)
+    if (typedAs === null) return context.report({ node: node.value, messageId: "unknown", data })
+    if (typedAs !== entry.double) return context.report({ node: node.value, messageId: "wrong", data: { ...data, got: `a \`${typedAs}\` double` } })
+    return undefined
+}
+
 /** The double a token's provider value must come from. */
 export const specInfraDoubleFromKit = {
     meta: {
         type: "problem",
-        docs: { description: "In a service spec a provider `{ provide: TOKEN, useValue: X }` takes X from the `@starci/jest-preset` double the token calls for (`ruleParams.be.specDoubles`)." },
+        docs: { description: "In a logic-role unit spec a provider `{ provide: TOKEN, useValue: X }` takes X from the `@starci/jest-preset` double the token calls for (`ruleParams.be.specDoubles`)." },
         schema: [],
         messages: {
-            wrong: "`{{token}}` is provided with {{got}}, but a token of this kind takes {{want}} from `{{kit}}`. The kit double is behavioural (or, for `mock`, typed against the port), a hand-built value drifts from the thing it stands for.",
-            notKit: "`{{name}}` is not imported from `{{kit}}`. A double for `{{token}}` is {{want}} of the kit, never a local helper or a lookalike of the same name.",
-            unknown: "The value provided for `{{token}}` cannot be traced to a kit double. Bind it to a `const` initialised with {{want}} from `{{kit}}` (or write the call in place).",
+            wrong: "[BE_SPEC_FORM_ALL_ROLES] `{{token}}` is provided with {{got}}, but a token of this kind takes {{want}} from `{{kit}}`. The kit double is behavioural (or, for `mock`, typed against the port), a hand-built value drifts from the thing it stands for.",
+            notKit: "[BE_SPEC_FORM_ALL_ROLES] `{{name}}` is not imported from `{{kit}}`. A double for `{{token}}` is {{want}} of the kit, never a local helper or a lookalike of the same name.",
+            unknown: "[BE_SPEC_FORM_ALL_ROLES] The value provided for `{{token}}` cannot be traced to a kit double. Bind it to a `const` initialised with {{want}} from `{{kit}}` (or write the call in place).",
         },
     },
     create(context) {
         const hfs = hfsOf(context)
-        if (!isServiceSpecFile(hfs, context.filename || context.getFilename())) return {}
+        if (!isFormSpecFile(hfs, context.filename || context.getFilename())) return {}
         const table = tableOf(hfs.ruleParams.specDoubles)
         const describe = (entry) => {
             const forms = entry.forms.map((form) => ({ call: `\`${entry.double}(...)\``, new: `\`new ${entry.double}(...)\``, curried: `\`${entry.double}(...)(...)\``, object: "a plain object literal of real values", primitive: "a real value", array: "an array" })[form])
@@ -405,6 +484,7 @@ export const specInfraDoubleFromKit = {
         return {
             Property(node) {
                 if (node.parent.type !== "ObjectExpression" || (node.key.name ?? node.key.value) !== "useValue") return
+                if (isRealSubjectValue(context, node.value)) return
                 const provide = node.parent.properties.find((property) => property.type === "Property" && (property.key.name ?? property.key.value) === "provide")
                 const spelled = tokenName(provide?.value)
                 if (spelled === null) return
@@ -415,18 +495,15 @@ export const specInfraDoubleFromKit = {
                 const data = { token: spelled, want, kit: table.kit }
                 if (found === null) {
                     // not a call, a literal or a traceable const: the declared type of the value decides (a helper parameter, `tx.em`)
-                    const typedAs = kitDoubleOfType(context, node.value, table.kit)
-                    if (typedAs === null) return context.report({ node: node.value, messageId: "unknown", data })
-                    if (typedAs !== entry.double) return context.report({ node: node.value, messageId: "wrong", data: { ...data, got: `a \`${typedAs}\` double` } })
-                    return undefined
+                    return checkTypedDouble(context, node, table, entry, data)
                 }
                 if (!entry.forms.includes(found.form)) {
-                    const got = found.name ? `\`${found.form === "new" ? "new " : ""}${found.name}(...)\`` : `a ${found.form} value`
+                    const got = describeDoubleValue(found)
                     return context.report({ node: node.value, messageId: "wrong", data: { ...data, got } })
                 }
                 if (found.name === undefined) return undefined
                 const imported = importOf(context, found.node)
-                if (found.name !== entry.double) return context.report({ node: node.value, messageId: "wrong", data: { ...data, got: `\`${found.form === "new" ? "new " : ""}${found.name}(...)\`` } })
+                if (found.name !== entry.double) return context.report({ node: node.value, messageId: "wrong", data: { ...data, got: describeDoubleValue(found) } })
                 if (!imported || !(imported.source === table.kit || imported.source.startsWith(`${table.kit}/`)) || imported.imported !== entry.double) return context.report({ node: node.value, messageId: "notKit", data: { ...data, name: found.name } })
                 return undefined
             },
@@ -443,14 +520,14 @@ const LOOSE_KINDS = new Set(["String", "Number", "Date"])
 export const specExactValues = {
     meta: {
         type: "problem",
-        docs: { description: "A service spec never asserts `expect.any(String)`, `expect.any(Number)` or `expect.any(Date)`: ids and clocks come from `fakeIds()` and `FakeClock`, so the exact value is asserted." },
+        docs: { description: "A logic-role unit spec never asserts `expect.any(String)`, `expect.any(Number)` or `expect.any(Date)`: ids and clocks come from `fakeIds()` and `FakeClock`, so the exact value is asserted." },
         schema: [],
         messages: {
-            loose: "`expect.any({{kind}})` accepts every {{what}}, so the assertion proves nothing about the value the service generated. The service takes its ids and its clock from tokens and the spec provides the kit's deterministic doubles: `{ provide: ID_GENERATOR, useValue: fakeIds() }` and `{ provide: CLOCK, useValue: new FakeClock(...) }` from `@starci/jest-preset`. Assert the exact value ({{exact}}).",
+            loose: "[BE_SPEC_FORM_ALL_ROLES] `expect.any({{kind}})` accepts every {{what}}, so the assertion proves nothing about the value the subject generated. The subject takes its ids and its clock from tokens and the spec provides the kit's deterministic doubles: `{ provide: ID_GENERATOR, useValue: fakeIds() }` and `{ provide: CLOCK, useValue: new FakeClock(...) }` from `@starci/jest-preset`. Assert the exact value ({{exact}}).",
         },
     },
     create(context) {
-        if (!isServiceSpecFile(hfsOf(context), context.filename || context.getFilename())) return {}
+        if (!isFormSpecFile(hfsOf(context), context.filename || context.getFilename())) return {}
         return {
             CallExpression(node) {
                 const callee = node.callee
@@ -466,6 +543,113 @@ export const specExactValues = {
     },
 }
 
+// -- spec-behavior-assertion -----------------------------------------------------------------------------------
+
+const PRESENCE_MATCHERS = new Set(["toBeDefined", "toBeTruthy"])
+
+/** The matcher in `expect(value).not.resolves.toEqual(...)`, or null for another receiver. */
+const matcherOf = (context, node) => {
+    const callee = node.callee
+    if (callee.type !== "MemberExpression") return null
+    const matcher = callee.computed ? callee.property.value : callee.property.name
+    if (typeof matcher !== "string" || !matcher.startsWith("to")) return null
+    let receiver = callee.object
+    while (receiver.type === "MemberExpression") receiver = receiver.object
+    if (receiver.type !== "CallExpression") return null
+    if (!isImportedFrom(context, receiver.callee, "@jest/globals", "expect") && !isAmbientOrImported(context, receiver.callee, "expect", "@jest/globals")) return null
+    return matcher
+}
+
+const TEST_MODIFIERS = new Set(["only", "skip", "concurrent", "failing", "each"])
+
+/** A Jest test registration, including modifiers and both forms of `each`. */
+const isTestFunction = (context, node) => {
+    if (!node) return false
+    if (isImportedFrom(context, node, "@jest/globals", ["it", "test"])) return true
+    if (isAmbientOrImported(context, node, "it", "@jest/globals") || isAmbientOrImported(context, node, "test", "@jest/globals")) return true
+    if (node.type === "MemberExpression" && TEST_MODIFIERS.has(keyName(node.property))) return isTestFunction(context, node.object)
+    if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && keyName(node.callee.property) === "each") return isTestFunction(context, node.callee.object)
+    if (node.type === "TaggedTemplateExpression" && node.tag.type === "MemberExpression" && keyName(node.tag.property) === "each") return isTestFunction(context, node.tag.object)
+    return false
+}
+
+/** The local value an identifier binds, when it can name a callback or assertion helper. */
+const functionBinding = (context, node) => {
+    for (let scope = context.sourceCode.getScope(node); scope; scope = scope.upper) {
+        const variable = scope.set.get(node.name)
+        if (!variable) continue
+        const definition = variable.defs[0]
+        if (definition?.type === "FunctionName") return definition.node
+        if (definition?.type === "Variable") return definition.node.init
+        return null
+    }
+    return null
+}
+
+/** An inline function or a locally bound function, following aliases without cycles. */
+const functionOf = (context, expression) => {
+    let node = peel(expression)
+    const seen = new Set()
+    while (node?.type === "Identifier") {
+        if (seen.has(node)) return null
+        seen.add(node)
+        node = peel(functionBinding(context, node))
+    }
+    if (!node) return null
+    return ["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"].includes(node.type) ? node : null
+}
+
+/** Assertions in the callback's executed syntax, including local helpers and passed callbacks. */
+const hasAssertion = (context, fn, seen = new Set()) => {
+    if (seen.has(fn)) return false
+    seen.add(fn)
+    let found = false
+    walk(fn.body, (node) => {
+        if (found || node.type !== "CallExpression") return
+        if (matcherOf(context, node) !== null) {
+            found = true
+            return
+        }
+        if (isTestFunction(context, node.callee)) return
+        const functions = [node.callee, ...node.arguments].map((expression) => functionOf(context, expression)).filter(Boolean)
+        found = functions.some((helper) => hasAssertion(context, helper, seen))
+    }, { intoFunctions: false })
+    return found
+}
+
+/** Presence alone does not prove the behavior of a logic-role subject. */
+export const specBehaviorAssertion = {
+    meta: {
+        type: "problem",
+        docs: { description: "Every logic-role unit test has an assertion, and its spec asserts behavior beyond presence or truthiness (R281 BE_SPEC_FORM_ALL_ROLES)." },
+        schema: [],
+        messages: {
+            presenceOnly: "[BE_SPEC_FORM_ALL_ROLES] Every assertion in this spec checks only presence or truthiness. Assert an exact result, error or observable effect of the subject's behavior.",
+            zeroAssertions: "[BE_SPEC_FORM_ALL_ROLES] This unit test has no assertion. Assert an exact result, error or observable effect of the subject's behavior in every `it`/`test` callback.",
+        },
+    },
+    create(context) {
+        if (!isFormSpecFile(hfsOf(context), context.filename || context.getFilename())) return {}
+        let firstPresence = null
+        let behavior = false
+        return {
+            CallExpression(node) {
+                if (isTestFunction(context, node.callee)) {
+                    const callback = functionOf(context, node.arguments[1])
+                    if (callback !== null && !hasAssertion(context, callback)) context.report({ node, messageId: "zeroAssertions" })
+                }
+                const matcher = matcherOf(context, node)
+                if (matcher === null) return
+                if (PRESENCE_MATCHERS.has(matcher)) firstPresence ??= node
+                else behavior = true
+            },
+            "Program:exit"() {
+                if (firstPresence !== null && !behavior) context.report({ node: firstPresence, messageId: "presenceOnly" })
+            },
+        }
+    },
+}
+
 /** The rules this law contributes to the plugin. */
 export const rules = {
     "spec-builds-with-testing-module": specBuildsWithTestingModule,
@@ -475,6 +659,7 @@ export const rules = {
     "no-return-only-generic": noReturnOnlyGeneric,
     "spec-infra-double-from-kit": specInfraDoubleFromKit,
     "spec-exact-values": specExactValues,
+    "spec-behavior-assertion": specBehaviorAssertion,
 }
 
 /** Every rule of this law ships at `error`. */
@@ -486,4 +671,5 @@ export const recommended = {
     "starci-be/no-return-only-generic": "error",
     "starci-be/spec-infra-double-from-kit": "error",
     "starci-be/spec-exact-values": "error",
+    "starci-be/spec-behavior-assertion": "error",
 }