What is integration testing, and how do I keep the interface true in CI?

IBM, Wikipedia, CircleCI, and the testing glossaries define the same act: join the modules and check they work together. That sits between unit testing and system testing on the V-model. Proof does not replace that act. It asks a narrower question: if you wrote an interface requirement, is there a real integration test on that requirement, or only unit tests on the children?

Decomposition is not that witness. A nominal-covered derived SW-REQ verifies its own shall. It does not verify the assembled interface. That gap is how an INT-REQ that says two components honor stdio ships with green children and no test that actually wires them.

The command is deterministic. It does not call a model. It does not start Testcontainers. It refuses a silent pass when an active INT-REQ has no integration test and no honest deferral.

proof audit --check integration_evidence_witnessed
proof audit --check interface_staleness_clean

The first command is the V-model floor for INT-REQ. The second is the fingerprint check on the interface record itself. Green children after a copy-paste INT-REQ is how the wired boundary stayed untested.

The witness looks like this on a test file:

// INT-REQ-005:integration:integration
func TestMCPServerHonorsStdioProtocol(t *testing.T) {
    // wire agent to mcp_server over stdio
    // assert the interface contract holds across the boundary
}

If no integration test exists yet, stage the INT-REQ with an obligation_deferrals entry: class integration, a reason of at least 32 characters, and a tracking ref. The check reports N deferred (tracked) and a counted WARNING. It never reads as a clean pass. Only a real integration test clears it.

We have not run Testcontainers, Pact, and Proof on the same frozen corpus, and we have not scored this witness as a proof of the Go. The loss is named, not scored.

go test still owns the execution. Testcontainers still owns the stack. Pact still owns consumer-driven contracts. IBM and Wikipedia still own the glossary. Jama still authors the shall. Proof stores the INT-REQ in the repo and fails a silent pass when that shall has no integration test. It does not independently prove the interface is the right interface. It does not execute the integration test unless you wrote one. Default-on is a warning. Debt staged with obligation_deferrals stays a warning even under evidence_strict.

Proof is not Testcontainers. It is not Pact. It is not Selenium. Jama still authors. VectorCAST or LDRA still win at a qualified C toolchain.

The interface document still lives on interface control document. The stakeholder criterion still lives on acceptance criteria. Two implementations on the same input still live on differential testing.

What is software integration testing? Same URL. The typed head is integration testing. The software qualifier is this page, not a twin.

What is the difference between unit testing and integration testing? Unit tests pin one function. Integration tests pin the wired boundary. CircleCI and IBM still win that glossary. proof audit --check integration_evidence_witnessed is the INT-REQ floor after the tests exist.

Is Proof an alternative to Testcontainers or Pact? No. Keep the runner. Proof checks that the claimed INT-REQ sits on a real integration test. Jama still authors.

Do unit tests on derived requirements count? No. A child's unit test witnesses the child. The INT-REQ needs its own integration test across the assembled interface.

What is an interface control document? That H1 lives on interface control document. The fingerprint of the record is not this witness.

What are acceptance criteria? That H1 lives on acceptance criteria. Stakeholder criteria want an acceptance test. INT-REQs want an integration test. Same V-model, different level.