agentsclimarketplace

Integration test

Skill feimacode/feima-awesome-harness/skills/integration-test

Use when writing or reviewing tests that verify a real integration boundary such as database queries, message queue interactions, external service calls, or inter-module wiring where real infrastructure is intentional.From its SKILL.md

Install
npx -y skills add feimacode/feima-awesome-harness --skill integration-test

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

  • no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
  • 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

4.9 KB, as published. Nobody here has run it

Integration Test

Overview

An integration test verifies that two or more components work correctly when wired together through a real boundary — a database, queue, HTTP client, or file system. The use of real infrastructure is intentional; that is what distinguishes it from a unit test.

Required background: Apply auto-test universal principles first. This skill adds integration-scope specifics.

When to Use

  • Testing that a repository layer reads/writes to a real database correctly
  • Testing that an event producer puts the expected message on a queue
  • Testing that two modules integrate via their real interface
  • Diagnosing failures that only appear against real infrastructure

Not for: logic-only behaviour where a double would suffice (use unit-test). Not for full user flows (use e2e-test).

Core Principles

One Integration Boundary Per Test

Each test targets one integration point. A test that seeds a database, calls an HTTP endpoint, reads a queue, and asserts on a file is an e2e test in disguise — it becomes expensive to diagnose and brittle when any component changes.

Isolation Strategy

Real infrastructure introduces shared state. Each test must leave the world in the same state it found it.

StrategyWhen to use
Database transaction rollbackSame-process tests with a single DB connection
Container per test runTests that need a clean schema or different DB engines
Data namespacing (tenant/prefix)When rollback is not available; isolate by key prefix or test-run ID
Seed + teardown scriptsWhen declarative reset is simpler than transaction management

Never rely on test execution order to set up state for the next test.

Scope Boundary

The integration test asserts on the boundary output: the row in the database, the message on the queue, the HTTP response status and body. It does not re-test business logic that is already covered by unit tests.

AAA in Integration Tests

# Arrange: seed the database with known state
# Act: call the component under test (e.g. repository method, HTTP handler)
# Assert: query the real store for the expected outcome

def test_order_repository_persists_new_order(db_session):
    # Arrange
    customer = CustomerFactory.create(session=db_session)

    # Act
    repo = OrderRepository(db_session)
    order = repo.create(customer_id=customer.id, total=99.00)

    # Assert
    row = db_session.query(Order).get(order.id)
    assert row.total == Decimal("99.00")
    assert row.customer_id == customer.id

Quick Reference — Integration Smell Checklist

SmellSymptomFix
Too many hopsTest crosses DB + queue + HTTP in one caseSplit into separate tests per boundary
Shared DB stateTests pass alone but fail in suiteAdd teardown or use transaction rollback
No cleanup strategyRows accumulate across runsWrap in transaction or delete on teardown
Logic buried in testTest reproduces business rules to build expected valueExtract expected value as a constant; test only the integration
Slow suiteSuite takes minutes with no parallelismUse containers; parallelise by namespace
Mocking the integrationRepository test mocks the database it should be testingUse a real test database; that is the point

Slow vs Fast Integration Tests

Integration tests are inherently slower than unit tests. Optimise by:

  • Running the real store once per suite (container lifecycle), not once per test.
  • Sharing read-only seed data across tests; isolating only write paths.
  • Parallelising tests that use distinct namespaces.

Do not sacrifice isolation for speed. A fast test that produces false positives is worse than a slow reliable one.

Common Runners and Infrastructure Tools (No Prescription)

NeedCommon tools
Container lifecycleTestcontainers (Java, Go, Python, .NET, Node)
In-memory DBH2 (Java), SQLite, DynamoDB local
Real DB per runDocker Compose, GitHub Actions services
HTTP stubbing for third-partyWireMock, Nock, responses (Python)

Principles above apply to all. For runner-specific idioms consult your team's standards.

Common Mistakes

  • Unit-testing business logic inside integration tests — integration tests should be thin; fat test bodies indicate missing unit coverage.
  • Skipping teardown because "it will be reset anyway" — other tests in the same run will see the pollution.
  • Connecting to a shared staging DB — integration tests need their own isolated infrastructure.
  • Treating integration test failures as "environment flakiness" — if the test fails against a real DB, investigate the failure; do not skip or retry blindly.

Keep looking

Skills are one crate of 608,475. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.