Testcontainers on foojay.io - Friends of OpenJDK

Eliminating Flaky Tests to End World Hunger

Thu, 23 Apr 2026 09:02:34 +0000

Rita Mae Brown once said:

Insanity is doing the same thing over and over again and expecting different results.

However, everyone has at least once experienced a test that failed and then passed in the next run without changing the code or the environment. In software engineering, we don’t call it insanity; we call such unpredictable failures flaky tests. At first, they may seem like minor problems, but like clutter in a junk drawer, they become worse over time if you never take care of them.

Introducing Floci: A High-Performance, GraalVM-Powered AWS Emulator

Fri, 03 Apr 2026 19:00:53 +0000

The Motivation: Why Another AWS Emulator?

As Java developers, we are used to local-first development. Tools that emulate the cloud environment have become essential for keeping feedback loops tight and costs at zero. However, the ecosystem has shifted. Many of us have felt the friction of:

Mandatory Authentication: Needing to log in or use tokens just to run local tests.
Heavy Resource Footprint: Docker containers that consume a lot of resources.
Slow Startup: Waiting several seconds for the environment to be ready.

I created Floci (from the floccus cloud formation) to solve these specific pain points. It is a 100% open-source, MIT-licensed alternative designed for speed, privacy, and simplicity.

Testing Emails with Testcontainers and Mailpit

Thu, 29 Jan 2026 08:38:10 +0000

Testing email functionality is often painful. SMTP servers are external, tests become slow or flaky, and local setups differ from CI environments. As a result, many teams either mock the mail sender or skip proper email tests completely.

Both approaches are unsatisfying. Mocking does not test real behavior, and shared SMTP servers introduce hidden dependencies. What we really want is a real SMTP server that runs locally and in CI, is fully isolated per test run, and allows us to inspect sent emails easily.

Testing MongoDB Atlas Search Java Apps Using TestContainers

Thu, 29 May 2025 18:07:27 +0000

This will be an exploration of testing MongoDB Atlas Search solutions written in Java using TestContainers and JUnit5. We’ll start simple and build up to more advanced uses which load seed data and provide an environment for consistent and easy to maintain tests.

TLDR; if (like me!) you want to get straight to the code rather than reading lots of tedious words:

git clone https://github.com/luketn/mongodb-atlas-local-testcontainers.git
cd mongodb-atlas-local-testcontainers
mvn test

What is MongoDB Atlas Search, anyway?

MongoDB Atlas Search is an extension to the built-in indexing capabilities that are part of MongoDB itself, using the awesome open source indexing and query library Lucene . MongoDB has built a wrapper around Lucene called mongot .

Build local LLM applications with Quarkus, Ollama, Testcontainers

Thu, 27 Feb 2025 10:13:19 +0000

Traditionally, many AI-powered applications rely on cloud-based APIs or centralized services for model hosting and execution. While this approach has its advantages, such as scalability and ease of use, it also introduces challenges around latency, data privacy, and dependency on third-party providers.

This is where local AI models shine. By running models directly within your application’s infrastructure, you gain greater control over performance, data security, and deployment flexibility. However, building such systems requires the right tools and frameworks to bridge the gap between traditional software development and AI model integration.

Run true-to-production tests on your Java applications

Tue, 24 Sep 2024 11:48:46 +0000

As supported by the 12 factor and 15 factor app methodologies, in application development, we’ve come to realize just how important it is to test our applications in a true-to-production environment before releasing them to consumers. This helps us to mitigate potential failures and spot bugs that could appear in production but be missed in testing due to environmental differences and ensure we have high confidence in our applications being deployed to production environments. But, traditionally, developers have struggled with replicating an application’s production environment locally.

Foojay Podcast #52 from JCON in Cologne!

Mon, 10 Jun 2024 09:32:12 +0000

This is part 4 of the JCON interviews!

In this episode, we have 5 new guests for you.

We start with garbage collectors and Intelligence Cloud, a tool created by Azul to find out which of your code is actually used in production and which dependencies are known to have vulnerabilities. My colleague Gerrit Grunwald was at JCON to give a talk about these subjects.
With Balkrishna Rawool we dove into Virtual Threads, a very interesting topic as concurrency and threads can be challenging…
Piotr Przybyl came to JCON to give a talk about Test Containers and how to test your application in an environment that is similar to your production environment. Another important topic related to testing is Flaky Tests. How do you handle tests that only fail from time to time and make your whole test report unreliable?
François Martin had a talk about this subject, and he came to the conference together with Annelore Egger, who was one of the many volunteers.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Foojay Podcast #43: Modern Java Testing

Mon, 26 Feb 2024 08:03:08 +0000

As developers, we all want to write bug free and high quality code. Writing tests is a crucial part to achieve this.

Let’s explore the art of ensuring robust and bug-free code in the Java ecosystem.

Whether you’re a seasoned developer or just starting out, there’s a lot you can learn from the experts in this podcast about testing methodologies, tools, and best practices, empowering you to write reliable Java applications.

Video: Spring Boot Testcontainers Support for Local Development

Fri, 16 Feb 2024 09:07:33 +0000

Spring Boot has supported TestsContainers for running services during tests for quite a while.

With Spring Boot 3.1, Testcontainers support for local development was added. This video will show you how this works and how to use it.

Foojay Podcast #38: Java in the Cloud

Mon, 25 Dec 2023 12:02:46 +0000

Java was born in 1995, when the internet as we know it today didn’t exist yet.

Cloud servers, Docker, Kubernetes, distributed systems, scaling up and down… these things are now part of our daily job, but Java wasn’t originally designed for it.

In this episode, we want to learn if the recent evolutions in OpenJDK, and ongoing related projects, will make Java a full Cloud member.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Testing Spring Boot JMS with ActiveMQ Artemis and Testcontainers

Tue, 12 Dec 2023 07:55:03 +0000

Currently, I’m teaching JMS with Spring Boot at the University of Applied Science in Bern, Switzerland. We use Apache ActiveMQ Artemis as the JMS message broker. But how can we test our Spring Boot application?

Testcontainers to the Rescue

Currently, there is no Testcontainers Java module for ActiveMQ Artemis. As you can see in the Testcontainers GitHub repository , there is an active activemq branch that may be released soon. But in the meantime, we need another solution.

Spring's new JdbcClient API for performing database operations

Fri, 08 Sep 2023 06:45:44 +0000

Spring framework 6.1 introduced a new JdbcClient API, which is a wrapper on top of JdbcTemplate, for performing database operations using a fluent API.

Spring Boot 3.2 is going to include Spring framework 6.1, so let’s take a quick look at

how we can use JdbcClient to implement various database operations in a simplified manner.

First, let’s go to https://start.spring.io/ and create a Spring Boot application by selecting
Spring JDBC , PostgreSQL Driver , Flyway Migration , and Testcontainers starters.

Spring Boot: local development enhancements, let's compose!

Fri, 25 Aug 2023 11:16:05 +0000

Quite often when we are developing an application we need external services such as rabbitMQ, Kafka, etc.

When you are developing locally, you are quite likely using a docker-compose file to start these up, and I am certainly (hopefully) not the only one that has forgotten at least once to start these instances up.

And maybe you are even already using Testcontainers for your testing.

Luckily, Spring Boot 3.1 introduced some nice improvements to make our lives a bit easier.

Local Development Made Simpler with Testcontainers Desktop app

Mon, 21 Aug 2023 07:52:45 +0000

Being able to release new features quickly is a must-have capability in today’s competitive world. In order to release your software quickly and often you should have CI/CD infrastructure that can automatically build, test, and release our software with minimal to no human intervention. A comprehensive automated test suite is the key to release your software with confidence.

Testcontainers libraries help you to write integration tests using the real dependencies with the ease of writing unit tests. Let us take a quick look at how Testcontainers enables you to write tests that give confidence in your software.

Faster Integration Tests with Reusable Testcontainers

Wed, 17 Aug 2022 11:05:05 +0000

In my job, I often need integration tests against a Neo4j database. My software is written in Java, and so is Neo4j. Neo4j is embeddable, too. So, in theory, I could just depend on the embedded version, open a connection, test my stuff and call it a day. It would not be a different engine, it would be - at least from a query-engine and planer perspective - the same thing, in contrast to using an embedded SQL database as a drop-in for PostgresQL for example.

Easy Jakarta EE Integration Testing

Wed, 04 May 2022 14:41:49 +0000

One major issue when developing modern enterprise applications is the “works on my machine” problem: when an application works well on your machine but is not functional in production or even on a colleague’s machine.

An even more prevalent problem is to maintain the quality of ever-changing applications during development and maintenance.

This is especially prevalent when Jakarta EE applications are developed and not properly tested in an isolated and cohesive manner.