Data & Transactions

Inspect the contract and its failure cases.

1. 1Spring JdbcTemplate: bound values and visible database constraints
2. 2Spring TransactionTemplate: roll back a failed multi-row change
3. 3Spring transactional methods: call paths and rollback assumptions

Inspect the state boundary and run its checked fixture.

1. 1Spring JPA entity lifecycle: managed changes and detached objects
2. 2Spring JPA fetch plans: measure N+1 queries before changing mappings
3. 3Spring JPA optimistic locking: reject a stale stock update
4. 4Spring transaction propagation: joined rollback and independent commit

Follow the input contract, inspect failures and run the checked source.

1. 1Spring Data JPA repositories: derive a query from mapped properties
2. 2Spring Data JPA projections: return selected fields without a full entity
3. 3Spring Data keyset pagination: continue after the last stable identifier

Run the checked fixture, then inspect its ownership and failure boundary.

1. 1Spring transaction rollback: checked failures commit unless a rule says otherwise

Run the source-kit fixture and inspect its rejected boundary.

1. 1Spring transactional outbox: commit a receipt and event row together
2. 2Spring outbox claims: move pending work once per database state

Run the source-kit test and inspect the rejected case.

1. 1Spring nested transactions: roll back one step to a JDBC savepoint
2. 2Spring NESTED versus REQUIRES_NEW: savepoint or independent commit

Run the local fixture and inspect the retained state.

1. 1Spring outbox claims: allow recovery after a worker lease expires
2. 2Outbox acknowledgements: require the current lease token
3. 3Spring consumer deduplication: commit the event ID with the mutation

Trace a tenant-scoped command from token to committed rows.

1. 1Spring tenant command transaction: keep state, event and replay record together
2. 2Spring JDBC versioned tenant update: inspect the affected row count
3. 3Spring receipt outbox command: record intent without claiming delivery

Trace ownership, retry and duplicate delivery boundaries.

1. 1Spring outbox relay: claim, deliver, and acknowledge one event
2. 2Spring outbox claims: lease expiry and token-fenced acknowledgement
3. 3Spring consumer idempotency: reserve an event ID with the stock mutation
4. 4Spring outbox transaction boundaries: where atomicity ends

Trace scheduled claims, retries and duplicate-safe completion.

1. 1Spring scheduled relay: recover when the consumer commits before acknowledgement

Check current ownership before claiming or extending a lease.

1. 1Spring outbox claim race: one conditional UPDATE wins
2. 2Spring outbox lease renewal: extend only the current owner

Check effective settings and staged database writes.

1. 1Spring database rollout: add a nullable column before changing every writer
2. 2Spring database backfill: assign historical rows before enforcing ownership
3. 3Spring database contract phase: reject old writers only after backfill
4. 4Spring Boot migrations: what a versioned runner must add to the SQL test

Check loaded settings and the receipt migration sequence.

1. 1Flyway SQL migrations: record ordered schema changes against a real database
2. 2Flyway expand and contract: show exactly when an old writer breaks
3. 3Flyway validation: detect a changed applied migration before another write

Check selected settings and the staged database startup path.

1. 1Spring Boot Flyway startup: apply versioned SQL before querying a receipt
2. 2Spring Boot migration target: test an old writer before closing the schema
3. 3Spring Boot migration history failure: stop context startup on a mismatch

Read the operation contract, then test its failure and capacity boundaries.

1. 1Spring Boot JDBC pool capacity: size connections across replicas
2. 2Spring transaction isolation: state the anomaly you need to prevent

Run the source-kit test, then inspect the failure and ownership rule.

1. 1Spring NamedParameterJdbcTemplate: expand an ID list without dropping tenant scope
2. 2Spring SimpleJdbcInsert: read the generated key after one insert

Trace producer, consumer and recovery cut points without treating local tests as broker evidence.

1. 1Spring Kafka duplicate delivery: let a unique event ID decide the second debit
2. 2Spring outbox to Kafka: name the crash window between send and relay acknowledgement

Check schema execution, authorization, costs and verification scope.

1. 1Spring GraphQL list bounds: reject large arguments before reading rows
2. 2Spring GraphQL mutation versions: reject a stale stock reservation

Check subscription, binding, rollback and fixture dependency scope.

1. 1Spring R2DBC subscription boundary: constructing SQL does not execute it
2. 2Spring R2DBC named binds: keep a receipt identifier out of SQL syntax
3. 3Spring R2DBC reactive transaction: roll back the event marker with a rejected debit
4. 4Spring R2DBC conditional update: test tenant, version and stock floor in one statement

Read the application contract and its unverified integration boundary.

1. 1Spring AI retrieval: apply the tenant filter before prompt assembly
2. 2Spring AI conversation memory: partition by verified tenant and caller

Inspect the local proof and the remaining deployment boundary.

1. 1Spring Batch chunks: a later failure does not erase an earlier commit
2. 2Spring Batch writers: use a stable source key when a chunk is replayed

Run the checked local boundaries, then identify the production failure windows still open.

1. 1Spring Batch restart input: pin the manifest before resuming a cursor
2. 2Spring Batch SkipListener: persist a rejection key with the skipped row

Check the actual repository, input snapshot and recovery decision.

1. 1Spring Batch source digest: reject changed rows before a restart

Trace the failure path, test the rejected case and follow the connected lesson.

1. 1Spring Data JPA bulk update: the managed entity can still hold the old value
2. 2Spring Data JPA derived delete versus bulk delete: callbacks and memory cost
3. 3Spring Data JPA pessimistic lock: hold it only through the stock decision
4. 4Spring REQUIRES_NEW: budget the second database connection
5. 5Spring imperative transaction: a worker thread does not inherit it
6. 6Spring reactive transaction: subscription owns the context, not a thread

Store-level invariants, search visibility and service authorization.

1. 1Spring Data MongoDB optimistic locking: save the version you read
2. 2Spring Data MongoDB tenant uniqueness: enforce it in an index
3. 3Spring Data MongoDB transaction: keep every write in one client session
4. 4Spring Data MongoDB bulk writes: fewer round trips, different lifecycle behavior
5. 5Spring Data MongoDB change stream: resume token and idempotent projection
6. 6Spring Data Elasticsearch write versus search: refresh is the visibility boundary
7. 7Spring Data Elasticsearch sequence conflict: do not overwrite a newer projection
8. 8Spring Data Elasticsearch mapping rollout: build a new index, then move the read alias

Store and platform contracts with failure cases and verification.

1. 1Spring Data Cassandra partition keys: model the read before the row
2. 2Spring Data Cassandra TTL: expiry is a storage and query cost
3. 3Spring Data Cassandra paging state: continue the same bounded query
4. 4Spring Data Neo4j relationships: save only the graph you own
5. 5Spring Data Neo4j transaction: keep the command inside one managed unit
6. 6Spring Data Neo4j version conflicts: reject a stale graph update

Practical operating contracts, costs and failure drills.

1. 1Spring Data Cassandra conditional insert: reserve one key once
2. 2Spring Data Cassandra consistency: budget availability and staleness per operation
3. 3Spring Data Cassandra @Version: a conflict is not a merge
4. 4Spring Data Neo4j custom query: return one coherent root record
5. 5Spring Data Neo4j tenant lookup: constrain before traversing
6. 6Spring Data Neo4j relationship properties: preserve edge identity