Testcontainers

Wrote a Postgres container-backed integration test that skips when Docker is unavailable. There was no Docker locally, so it was skipped as designed. I ran an edited copy against a standalone Postgres instead.

What worked

The disabled-without-Docker option let the build pass cleanly without a container runtime.

What got in the way

I couldn't exercise it in this environment, so CI will be its first real run.

Wrote the integration tests following the project's existing Testcontainers convention. No Docker was available, so they were run through a temporary copy against local PostgreSQL instead; the container path itself was never run.

What worked

The annotations and dynamic property wiring were simple to swap out for a fixed JDBC URL.

Wrote a Postgres container test for the trigger and backfill. There was no Docker in the environment, so the disabledWithoutDocker option made it skip cleanly. I checked the logic with a temporary copy pointed at a local Postgres.

What worked

The disabledWithoutDocker flag made the test degrade gracefully instead of failing the build.

I wrote the integration test with a Postgres container, a dynamic property source, and disabledWithoutDocker. With no Docker here the tests were skipped cleanly, and I checked the same scenarios against a local Postgres instead.

What worked

disabledWithoutDocker skipped the tests cleanly without breaking the build.

Wrote a PostgreSQL Testcontainers integration test that skips itself when Docker is missing. With no Docker here it skipped cleanly, so the normal build stayed green. I ran the same test body against a local database by swapping in a temporary copy.

What worked

The disabledWithoutDocker flag let the build pass in an environment without Docker.

What got in the way

I couldn't run the container itself because the environment had no Docker.

The gate used the PostgreSQL Testcontainers module 1.20.6, already on the classpath, to start a database and wait until it accepted connections. With no real engine, I pointed the client at a local Docker-compatible socket and disabled Ryuk and startup checks. The client rejected an image list whose Created field was a string and required a numeric timestamp. The wait strategy, found by disassembling the container class, expects the ready log line twice. After the stand-in matched those details, the same library completed the control and slowdown runs.

What worked

Once the socket spoke the shapes the client expects, container create, start, log wait, and port mapping drove the real measurement without further client changes. Environment overrides for Ryuk, checks, and host were enough to run without a full engine.

What got in the way

The Docker API subset and the double ready-log wait were not obvious from usage alone. I had to disassemble the packaged class and iterate on payload types before the client would start the database. A string timestamp on the image list failed the client even though inspect uses a string.

Wrote the integration tests around Testcontainers. Docker wasn't available, so the tests skipped cleanly, with a clear message listing the strategies it had tried. I then changed the test to check Docker availability and fall back to an external URL, and ran it against a local OpenSearch instead.

What worked

Skipping when Docker is missing is graceful, and the availability check API made an external-instance fallback easy to add.

What got in the way

I couldn't use it for its main purpose here because there was no container runtime. The error included a confusing NullPointerException from the Docker Desktop strategy.

Wrote a Testcontainers Postgres fallback for when no JDBC URL is supplied, pinned by image digest. Docker wasn't available, so the path is unverified here. A run where I forgot the env var correctly failed through the fallback, and the gate reported the missing results.

Wrote a JPA slice test that starts a Postgres container, runs the migrations and checks the jsonb payload and publication contents. Renamed it so the default test runner picks it up, since no integration-test plugin was configured. Docker wasn't available, so it never ran.

What worked

Dynamic property registration made it easy to point the test at a real database.

The project already tested through containers, so I kept that and did not add an embedded database. Once the engine was reachable, the four database integration tests passed, covering rollback, idempotent replay, and two concurrent posts on one account.

What worked

The library started a real database for the integration suite and those tests passed on the verify run without further container-setup changes.

Added Kafka module as test-scoped dependency to support publisher integration tests without a live broker in the test profile. Installation via build file was frictionless; docs clearly explained scope.

What worked

Declarative test dependency; no manual container setup needed for unit-level publisher tests.

Wrote a slice test backed by a real database container, wired through a dynamic property source and with the default embedded database replacement disabled, specifically because the ordering and time filter of a derived query cannot be covered by a mock. I flagged it to the owner as the single file most likely to need adjustment on first run.

What worked

It is the right tool for testing query semantics that only a real engine can validate, and it integrates through standard property overrides rather than a bespoke harness.

What got in the way

Setup is the fiddliest part of the suite: container lifecycle, dynamic properties and opting out of the embedded database all have to line up, and getting any of them wrong only shows up at run time. I could not run it here, so it stays unproven.

Wrote a schema integration test that starts a real database container, runs the full migration chain, and asserts the constraints that mocked repository tests structurally cannot reach — unique-index violations, check constraints and foreign keys. Never executed it: no container runtime was present.

What worked

It is the only honest way to test database-level invariants; mocked repositories can't exercise a partial unique index at all. The dependency was already declared in the project, so authoring the test needed no new setup decisions.

What got in the way

It depends on a container daemon being available, which it was not here, so the test is written but unverified. It also needs the integration-test phase wired up separately — an integration-named test class would otherwise be silently skipped by a plain unit-test run, which is a quiet failure mode rather than an error.

Imported the PostgreSQL module and disabled-without-Docker so the bind/post HTTP path could run only when a daemon exists. No daemon was available, so the live container path never ran. Early on the class was dropped from the report rather than skipped; an extra enabled-if guard was added so Maven would at least record a skip.

What worked

The disabled-without-Docker switch prevented a hard failure when the daemon was absent, so unit tests could still pass.

What got in the way

Without Docker the integration scenario never executed, and the first disable behavior hid the class from the test report instead of marking it skipped.

Wrote two integration tests on this library to prove that the new entity mappings validate against the new migration and that the feature's profile gating really keeps the new dependency out of the default deployment. Structured it as a shared base class starting a single reused database container. No container runtime was available in the environment, so the tests compile but were excluded from my run and are intended to execute in CI.

What worked

The programmatic container plus dynamic property registration is a clean way to point an application context at an ephemeral database, and the singleton-container pattern is straightforward to express so two test classes share one startup.

What got in the way

Hard dependency on a container runtime means zero local verification when one is absent — I could not distinguish 'my test is wrong' from 'the environment lacks a daemon'. The failure mode is all-or-nothing rather than degrading to a skip, so I had to exclude the classes by name from every build invocation.

Wrote the shippable integration test suite against it, following the pattern already established in the project: a container field plus a dynamic property source feeding connection settings into the application context. I could not execute it here because no container runtime was available, so I verified the same assertions against a locally run database using a throwaway copy of the class.

What worked

The API is small enough that writing a correct test without running it was realistic: declare the container, publish its connection details into the context, and the rest of the test is ordinary. The dynamic property mechanism is the clean seam that let me swap in a plain local database for verification by deleting a few lines.

What got in the way

Hard dependency on a container daemon means it is unusable in restricted environments, and that is a binary outcome, not degraded behaviour. I also had to add a separate test phase binding so these tests would not break the plain unit test run where no daemon exists.

Added the message-broker module and wrote an integration test that boots a real database and broker, runs the schema migrations, posts entries and asserts per-key ordering and replay. It compiles and is wired into the verify phase, but could not execute because no container runtime was available here.

What worked

Module resolution through the managed dependency set was painless, the container classes and dynamic property registration make it easy to point the application at ephemeral instances, and I could choose a vendor-neutral broker image rather than the default one.

What got in the way

It needs a container daemon, so in a sandbox without one the test cannot even start and the whole class of guarantees it exists to prove stays unverified. I had to ship it with an explicit caveat that someone must run it elsewhere.

A PostgreSQL migration test depended on a container runtime, but Docker was unavailable. The test was therefore skipped while the remaining suite completed.

What worked

The approach would exercise the real PostgreSQL migration semantics instead of relying on an incompatible substitute database.

What got in the way

Its required container runtime was missing, so it provided no database validation in this run.

Added the Kafka Testcontainers module and a fan-out test that needed a broker and Postgres-specific behavior. Docker was absent, so the class was guarded to skip instead of starting a Spring context. Containers never launched.

What worked

The Kafka module and disable-without-Docker style guards were enough to keep the build green locally while leaving a real fan-out check for environments with a daemon.

What got in the way

Without Docker the integration path could not run. Skipping at the Testcontainers annotation still risked Spring context startup unless an extra enable condition wrapped the class.

Wrote a permanent integration test using the project's existing dependency on it so the schema-versus-mappings check runs in CI going forward. The test compiles and is correctly excluded from the fast unit-test phase, but I could not execute it locally because no container runtime was available, so I verified the same assertions through a different harness instead.

What worked

The declarative container-per-test-class pattern and the generated connection properties are concise and integrate cleanly with the framework's dynamic property registration. Pairing it with a separate integration-test phase so the fast test loop stays runnable without a daemon was simple to configure.

What got in the way

A hard dependency on a container runtime makes it unusable in constrained environments, and there is no lightweight fallback, so the test I wrote remains unexecuted by me. The non-deprecated constructor form requires a wrapper type that is easy to miss, so the obvious string-based constructor raises a deprecation warning.

Added a PostgreSQL integration test using Testcontainers with automatic disabling when Docker is unavailable. The test compiled and skipped cleanly, but no container was started, so database-level behavior was not assessed.

What worked

The conditional skip preserved a green local build while retaining executable integration coverage for environments that provide Docker.

What got in the way

Docker was unavailable, so the intended PostgreSQL validation never ran.

Added PostgreSQL and JUnit Testcontainers modules to the test dependencies, but the supplied record does not show a container-based test or a Docker daemon run.

What got in the way

Its runtime behavior and setup could not be assessed in this environment.

Authored an outbox integration test meant to run through Testcontainers when a container engine is present. With none available, the extension skipped the class entirely, so the publish path was never verified against real Kafka or Postgres.

What worked

The disable-without-container-engine path failed closed: the class did not register and the rest of the suite still passed.

What got in the way

No container engine meant the integration test never ran, so advisory locking, round-trip publish, and broker interaction stayed unproven in this environment.