testcontainers | Selenide + TestContainers sample project | Continuous Deployment library

It is possible to use Podman with Testcontainers in Java projects, that use Gradle on Linux and MacOS (both x86_64 and Apple silicon).

• Podman Machine and Remote Client are installed on MacOS - https://podman.io/getting-started/installation#macos
• Podman is installed on Linux - https://podman.io/getting-started/installation#linux-distributions

Testcontainers library communicates with Podman using socket file.

Start Podman service for a regular user (rootless) and make it listen to a socket:

The @Sql will be executed, per default, BEFORE_TEST_METHOD. So this is run before each test method. In other words, before any test is run, that SQL is executed. But of course, by re-using the same database for multiple tests, this can run into an error, if the sql script isn't "idempotent", in other words, if the sql script cannot be applied safely twice to the same database.

To make it work, there are multiple possibilities, for example:

1. adding one for the AFTER_TEST_METHOD to cleanup. This then would basically remove all the stuff that was added by this test (including the things added by the @Sql before). This way, your db is "cleaned up" after each test run and every run can apply the same sql script again safely.

2. Or make it safe to be executed multiple times. This depends on the scripts, but if you can write the SQL in a way that allows you to run it twice without error, this would also work.

3. Without using @Sql, you could also configure a DatabasePopulator bean in your test config. This way, your SQL code would only run ONCE, when the whole application context is created.

4. You could also try using @Transactional on your test, which would make Spring wrap a transaction around your test execution and roll it back afterwards. Unfortunately I have currently no clue how nice this plays with @Sql, might work, might not, but I would give it a 75% chance of working. And of course, it has some implications (nothing is actually finally written to the DB and if you are using transactions inside your code, there might be complications).

All of these methods would solve your problem, probably.

Following Quarkus' official documentation,

If a profile does not define a value for a specific attribute, the default (no profile) value is used

This behaviour will be useful in many cases, but in yours might lead to the inability to override properties once defined in the default profile back to their empty state.

I would suggest you to swap your profiles around i.e. treat the null-valued dev configuration as a default and provide meaningful non-null prod values in an overriding profile.

If you are worried that dev values might be used this way accidentally in prod environment, remember that Quarkus is going to use prod profile by default if not told otherwise.

Best-case I would love to be able to trigger recording in a standard junit @AfterEach method, but the arguments required (TestDescription description, Optional throwable) aren't available...

This is what I would recommend for more advanced framework integrations that don't work OOTB. You should be able instatiate a TestDescription for your use case e.g., from an anonymous class (it is used to infer the recording's file name).

By accident stumbled accross here: I had the same issue when I was not running the docker engine and the service. Have you docker installed and is the service running?

There's no official support from GitHub Actions (yet) to support caching pulled Docker images (see this and this issue).

What you can do is to pull the Docker images, save them as a .tar archive and store them in a folder for the GitHub Actions cache action to pick it up.

A sample workflow can look like the following:

While running your setup with debug logs enabled, I've noticed that auto-configuration for Liquibase did not work, as some criteria was not met.

When you use Testcontainers' JDBC support, which you configure by adding tc in the jdbc url, the lifecycle of the container is managed automatically. Since you have two different urls instrumented like that, you get 2 containers.

Instead you can choose a different way to manage the lifecycle that gives you more control.

You can either do it yourself by creating a containers instances and calling start()/stop() or for example use JUnit integration which will correspond containers lifecycle with the tests lifecycle.

For example for JUnit5, you mark you class with @Testcontainers and the fields with @Container, something like:

That looks like what Christos Sotiriou described in "Your Private CI/CD using self-hosted GitLab and Docker" in 2020.

It involves a GitLab runner:

A GitLab runner has many modes it can operate, which represent how the build will be performed. Among other modes, there is support for spawning Kubernetes pods, or Docker containers to perform builds.

For the sake of simplicity, we will use the plain docker mode, which will spawn a new container with an image of your choice (determined by your Dockerfile)

Run the following to your terminal: