Testing on foojay.io - Friends of OpenJDK

Foojay Podcast #99: Testing the Untestable: LLM Security for Java Developers with Tiberius

Mon, 22 Jun 2026 06:54:00 +0000

Your AI-powered Java application is live in production. But have you actually tested whether it can be jailbroken or manipulated into leaking data it should never reveal? In this episode, Iryna Dohndorf walks us through Tiberius, an open-source security testing library for LLM applications in Java, and explains why everything you know about unit testing needs a rethink when non-determinism is part of the design.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Tiberius: A Security Testing Framework for LLM Applications in Java

Thu, 04 Jun 2026 20:09:09 +0000

How do you write a regression test for a system that is non-deterministic by design?

The Problem {#h2-0-1-the-problem}

Large Language Models have moved from research artifacts to production infrastructure. Java applications are embedding them into customer-facing services via Spring Boot, and e.g. LangChain4J — for document summarization, customer support, healthcare assistance, and financial guidance, to name just a few. The deployment surface is growing faster than the security tooling.

The vulnerability landscape is empirically well-established. Horlacher, Vifian, and Zagidullina (2026) [4] red-teamed gpt-oss-20b and found that adversarial techniques achieved alarmingly high Attack Success Rates, while non-adversarial probing exposed pervasive stereotypical defaults — both consistent across English and Swiss German. Their conclusion: “current alignment mechanisms have not fully resolved jailbreaks and inherent bias, posing critical challenges for automated decision-making.”

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 BoxLings! An interactive teacher for BoxLang and TDD/BDD

Thu, 09 Apr 2026 08:48:57 +0000

We believe the best way to learn a programming language is by writing code — real code, with real feedback, and real tests. That’s exactly why we built BoxLings.

Inspired by the beloved rustlings project, BoxLings is an interactive CLI tool that teaches you BoxLang through hands-on exercises. You read failing tests, fix broken code, and level up — one exercise at a time.

Oh, and the whole thing is written in BoxLang itself. 🥊 Dogfooding at its finest.

TestBox 7: Real-Time Feedback, a Browser-Based IDE, and Modern Testing Workflows on the JVM

Tue, 24 Mar 2026 16:58:53 +0000

TestBox 7.x focuses on improving testing workflows for BoxLang and CFML applications. This release introduces improvements to the BoxLang CLI runner , real-time streaming test execution via SSE , dry run capabilities, a browser-based TestBox RUN interface, and several developer experience enhancements.

Check out the what’s new here: https://testbox.ortusbooks.com/readme/release-history/whats-new-with-7.0.0

TestBox RUN: A Browser IDE for Your Tests

The centerpiece of TestBox 7 is TestBox RUN : a self-hosted, single-page web app (bx/tests/index.bxm) that you drop into any BoxLang project and open in a browser. No build toolchain. No external service. Just BoxLang.

How to Customize JaCoCo Report Styling in Your Java Project

Fri, 13 Feb 2026 13:10:45 +0000

JaCoCo is the go-to code coverage tool for Java projects. It integrates seamlessly with Maven, generates detailed HTML reports, and works out of the box. But let’s be honest — the default reports look like they were designed in 2008, because they were.

If you’re publishing coverage reports as part of your project documentation (on GitHub Pages, for example), you probably want them to match your site’s look and feel. The good news: it’s entirely possible. The bad news: JaCoCo offers zero built-in support for CSS customization.

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.

Flaky Tests: a journey to beat them all

Tue, 13 Jan 2026 13:00:07 +0000

“Sleep is not a synchronization primitive.”

Every test engineer, eventually

What’s a flaky test?

A flaky test is a test that sometimes passes and sometimes fails without any code changes. They’re the by‑product of non‑determinism: timing, concurrency, eventual consistency, network hiccups, clock drift, resource contention, and (our favorite) tests leaking state across runs.

Kestra is an open-source declarative orchestration platform designed to run, coordinate, and monitor large-scale, event-driven workflows. It is built to handle parallelism, asynchronous execution, and distributed systems at scale, exactly the kind of environment where determinism is hard and flaky tests tend to emerge.

JC-AI Newsletter #7

Tue, 14 Oct 2025 05:35:01 +0000

Fourteen days have passed, and it is time to present a fresh collection of readings that could influence developments in the field of artificial intelligence.

Beyond focused tutorials that can enhance your understanding of AI applications, this newsletter concentrates on Hallucination, Java Code Generation, Testing, Agentic System Architecture and LLM benchmarking methodologies designed to ensure models accuracy and competency in handling complex contextual information.

The world influenced by LLM is changing very quickly, let’s start…

AI-Driven Testing Best Practices

Mon, 26 May 2025 08:06:15 +0000

So, AI Can Write Tests Now? Cool, But…

AI assisted coding tools are everywhere now, helping with autocomplete, suggesting fixes, and sometimes writing surprisingly large blocks of code. A hot topic is using generative AI to generate tests automatically – unit, integration, e2e, etc.

The idea’s definitely appealing. Who wouldn’t want an AI to help crank out tests, bump up those coverage numbers, and maybe save us from some of the testing grind? It sounds like a fast track to better feedback and tackling that mountain of untested code.

Mutation Testing in Rust

Wed, 09 Apr 2025 12:39:50 +0000

I’ve been a big fan of Mutation Testing since I discovered PIT . As I dive deeper into Rust, I wanted to check the state of mutation testing in Rust.

Starting with `cargo-mutants`

I found two crates for mutation testing in Rust:

cargo-mutants
and mutagen

mutagen hasn’t been maintained for three years, while cargo-mutants is still under active development.

I’ve ported the sample code from my previous Java code to Rust:

Pull request testing on Kubernetes: testing locally and on GitHub workflows

Sun, 16 Mar 2025 17:32:27 +0000

Imagine an organization with the following practices:

Commits code on GitHub
Runs its CI/CD pipelines with GitHub Actions
Runs its production workload on Kubernetes
Uses Google Cloud

A new engineer manager arrives and asks for the following:

On every PR, run integration tests in a Kubernetes cluster similar to the production one.

It sounds reasonable.

Engineering manager: I want #integrationtests to run on the app deployed on #Cloud infra for each #GitHub PR ✅

Pull Request testing on Kubernetes: Working with GitHub Actions and GKE

Sun, 16 Mar 2025 15:44:27 +0000

I’m continuing my series on running the test suite for each Pull Request on Kubernetes. In the previous post , I laid the groundwork for our learning journey: I developed a basic JVM-based CRUD app, tested it locally using Testcontainers, and tested it in a GitHub workflow with a GitHub service container.

This week, I will raise the ante to run the end-to-end test in the target Kubernetes environment. For this, I’ve identified gaps that I’ll implement in this blog post:

Thinking differently about testing

Mon, 27 Jan 2025 07:26:34 +0000

10x Insights on a different view of quality assurance

I’ve given a few talks about 10x developers, or rather 10x professionals and been involved in process (re)engineering for many teams and projects.

However much you learn about people and their roles - there’s always something new to discover.

In fact, it is amazing how often your worldview is blinkered, how often there’s a different way to do or think about some aspect of your life or your career.

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.

Browserless Testing of Vaadin Applications with Karibu Testing

Mon, 09 Sep 2024 06:27:41 +0000

In modern web development, testing is essential for ensuring the reliability and performance of applications. For developers working with Vaadin, one of the best testing tools is Karibu Testing. This testing framework stands out for its ability to run browserless testing, offering several advantages over traditional end-to-end testing approaches, such as Selenium, Playwright, or Cypress.

Introduction

This article will highlight the benefits of browserless testing with Karibu Testing and how it compares to the end-to-end testing approach (E2E).

How does it feel to test a compiler?

Thu, 08 Aug 2024 06:47:59 +0000

Hi, my name is Alex. I work as a QA engineer on the Kotlin/Native team. I’m often asked by friends and colleagues what it’s like to test a compiler, so I decided to write an article about it.

I’ll briefly talk about my path to compiler testing, the Kotlin/Native compiler, the specifics of the tasks, the tools I use, and the knowledge that helps me in my work.

I graduated with a bachelor’s and master’s degree in Software Engineering and then spent ten years in backend automation testing, including testing email backends (IMAP, POP3 protocols, email storage system, etc.), leading a testing team, and building test processes and test automation from scratch.

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:

Software Testing as a Debugging Tool

Wed, 15 May 2024 07:43:43 +0000

The Intersection of Debugging and Testing
The Debug-Fix Cycle
Composing Tests with Debuggers
Test-Driven Development
Final Word

Debugging is not just about identifying errors—it’s about instituting a reliable process for ensuring software health and longevity. In this post we discuss the role of software testing in debugging, including foundational concepts and how they converge to improve software quality.

As a side note, if you like the content of this and the other posts in this series check out my Debugging book that covers t his subject. If you have friends that are learning to code I’d appreciate a reference to my Java Basics book. If you want to get back to Java after a while check out my Java 8 to 21 book .

Tips for reading code

Tue, 26 Mar 2024 11:46:58 +0000

As developers, we read code more than we write it. When adding new features or fixing bugs, we first need to understand existing code, so we can make the right changes in the right place.

When reading code inside the IDE, IntelliJ IDEA helps us to read and understand code by providing helpful features like syntax highlighting and inlay hints. But there are more features to help us understand a piece of code.

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.

Java Flight Recording and Analysis with Azul Mission Control

Thu, 25 Jan 2024 07:59:42 +0000

Java Flight Recording (JFR) is a Java Virtual Machine (JVM) profiling and diagnostics tool. It enables you to collect and analyze data regarding the performance and behavior of a Java application. As JFR is included in the JVM, there is no need for additional tools or installations to make recordings of your applications.

By utilizing JFR, you gain valuable insights into the runtime behavior of your Java applications. It helps you to optimize performance, identify and troubleshoot issues, and ensure better overall reliability. JFR is designed with very low overhead, allowing its use in production environments with minimal impact on the performance of your application.

Soft Assertions - testing kindly

Fri, 19 Jan 2024 10:17:45 +0000

Given it’s the advent of a new year, I thought let’s start with something nice and fun that can make live more enjoyable for everyone.

As developers, we write testcases all the time to help us in our development process, and to help us detect potential regressions in the future.

Now ideally we want our testcases to be as efficient as possible, and ideally to require as few reruns as possible. And this is where Soft Assertions come into play.

[Unit] Testing Supabase in Kotlin using Test Containers - PART 2

Wed, 13 Dec 2023 08:37:47 +0000

TL;DR : You can run a full Supabase instance inside Test Containers quite easily. See this repository .

In my last article , I was listing a few attempts I had done at running tests against my Kotlin Supabase application. The way the Supabase-Kt library is built makes it hard to mock, and I ended up building a minimal Docker Compose setup that was mimicking a Supabase instance.

In this second part, we’re gonna push the madness further and actually run a FULL SUPABASE instance locally, still using Test Containers .

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.

[Unit] Testing Supabase in Kotlin using Test Containers

Wed, 15 Nov 2023 16:36:01 +0000

In this article, I’ll dive into several methods I’ve been looking into to unit test a Kotlin application using Supabase and why I finally decided to go for a Docker Compose / Test Containers solution.

TL;DR : The easiest way I found to test my database service is to mimick Supabase using Docker Compose and Test Containers. Here’s the code

In case you don’t know it, I’m a big fan of Supabase . I love that they’re a viable alternative to Firebase. I love that they’re built on top of Open-Source pieces. I love how innovative they are , and how much they give back to the community . And as you already know it, I love Kotlin as well.

OpenAPI Generator: From YAML to JetBrains HTTP Client

Fri, 10 Nov 2023 10:41:35 +0000

In this article, I’ll be implementing an OpenAPI generator from scratch so you can too! We’ll be creating a very simple generator for the Jetbrains HTTP Client.

This is the online version of the article with the same name I wrote for the Dutch Java Magazine.

In the previous edition of the magazine, we discussed how the JetBrains HTTP Client could be used to run HTTP Queries, automate them and even use them in your CI/CD pipelines. Just like Postman , but text based and can be part of your source code. Pretty cool.

Book Review: Get Your Hands Dirty on Clean Architecture

Sat, 23 Sep 2023 12:00:31 +0000

I recently completed reading “Get Your Hands Dirty on Clean Architecture” authored by Tom Hombergs and I deem it an indispensable resource for developers aspiring to produce clean code and implement the Hexagonal Architecture. Consequently, I have resolved to compose a review to aid numerous individuals who harbor a fervent interest in technology!

Title: Get Your Hands Dirty on Clean Architecture
Author: Tom Hombergs
Genre: Technical, Software Architecture

In the constantly changing realm of software development, architectural principles hold a crucial position in determining the triumph and sustainability of a project. The book authored by Tom Hombergs, titled “Get Your Hands Dirty on Clean Architecture: A hands-on guide to creating clean web applications with code examples in Java,” is an exceptional guide that illuminates the importance of clean architecture, while also offering practical perspectives on its implementation through the Java programming language.

ArchUnit - test your architecture

Thu, 14 Sep 2023 14:09:56 +0000

ArchUnit is a library that allows us to test our architecture (layering/slicing/(naming) conventions, and more).

Why does this matter? It’s all about leaving a legacy and safeguarding it. During the lifecycle of a project, people might shift roles, join the team, … And might not be aware of the conventions within the team/organization.

Testing your architecture is both an aid to ascertain that the architecture is being implemented consistently and also makes it easier for people onboarding to get a grasp of what that agreed architecture is.

Load testing - shoot your application with Gatling

Wed, 06 Sep 2023 09:32:29 +0000

What is load testing?

Load testing entails testing how our application performs under a significant load so we can be certain it behaves as expected when there’s an influx of users.

Or at least so we know what it can cope it, and at what point we might potentially need to take action.

After all, it might not (only) be the code that’s the issue.

This is a process that requires quite a bit of cooperation between testers, developers, and those using it to properly determine the scenarios, and a smooth & swift feedback loop is important to make sure our solutions work properly. And it will likely be some of the most expensive tests given both the people involved and the need for a testing environment that’s representative of the production configuration.

Testable Code: A Journey Through Consideration and Refactoring

Wed, 30 Aug 2023 06:47:47 +0000

In an ideal world, every piece of code we write would be easily testable, clearly understood, and perfectly maintainable. However, reality often presents us with complex problems and solutions that aren’t always straightforward. Writing testable code sometimes requires a thoughtful approach, deep consideration of the use cases, and even refactoring to ensure that the code is robust and fully tested.

The Challenge of Testing

Imagine a scenario where you need to create an Amazon S3 client based on different credential providers. At first glance, the implementation might seem simple. However, when it comes to writing unit tests for this code, challenges arise.

Three Key Elements for Your Flaky Test Remediation Approach

Tue, 29 Aug 2023 13:32:02 +0000

Flaky tests pose substantial challenges due to their unpredictable and inconsistent nature. Effectively addressing them requires a multi-faceted approach that involves the effective integration of strategy, process and resource alignment, and a deep understanding of flaky test causality. This post will walk you through this approach.

Note! This post is part of a three-part series. If you’re not sure it’s worth remediating flaky tests, read Part 1: Seven Reasons You Should Not Ignore Flaky Tests . Read Part 2 to understand the keys to identifying and tracking flaky tests, called 5 Ways to Use Gradle Enterprise to Identify and Manage Flaky Tests. Now, let’s explore my multi-faceted approach to fixing flaky tests.

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.

Pitest: Do You Test Your Tests?

Tue, 15 Aug 2023 14:32:55 +0000

What is Pitest?

Pitest is a library that helps us do mutation testing.

Mutation testing is a process in which random variations of the code under test are generated.

Hence, our tests will run against variants of the code that we’re intending to test.

If the test fails, the mutation is killed, if it still passes it lives. So in subsequent runs, you will see this mutation once again. Surviving mutations may indicate issues with our test set since application code changes should lead to different end results, and thus to failing tests. So to further reduce the survivors we will need to enhance our test cases and/or add extra.

Seven Reasons You Should Not Ignore Flaky Tests

Tue, 04 Jul 2023 07:02:44 +0000

Imagine the scenario: you have good automated test coverage of your application code; you run your tests locally; and you have a Continuous Integration (CI) environment which runs your tests regularly.

You’re doing everything right, right?

Except… sometimes tests fail, and you’re not sure why. When you run the test locally, or a second time in the same environment, they pass. Whether they pass or fail doesn’t seem to be related to any code changes.

Debugging OpenJDK Tests in VSCode (Without Losing Your Mind)

Mon, 26 Jun 2023 11:27:55 +0000

Consider you want to debug a test case of the JDK like serviceability/AsyncGetCallTrace . This test, and many others, are implemented using the Regression Test Harness for the JDK (jtreg):

jtreg is the test harness used by the JDK test framework. This framework is intended primarily for regression tests. It can also be used for unit tests, functional tests, and even simple product tests – in other words, just about any type of test except a conformance test, which belong in a TCK.

Time Zone and Currency Database in JDK

Sat, 08 Apr 2023 13:39:00 +0000

There is a saying that you aren’t a real developer until you have done programming involving dates, times, daylight savings, and time zones.

Luckily the JDK contains multiple methods to assist you.

Related to this topic, it is essential to understand that each new JDK release includes a new version of the time zone and currency database.

As we will discover, you can get correct output by just switching to the most up-to-date version of Java – without changing code!

Exhaustive JUnit5 Testing: Combinations, Permutations, Products

Wed, 08 Mar 2023 10:08:21 +0000

Unit testing constitutes an integral part of the process of providing high-quality software.

But, how can one write tests covering all variants of several operations?

Read this article and learn how to use JUnit5 in conjunction with combinations, permutations, and products.

Test Support Libraries

There are many libraries that make testing better in different aspects. Here are some of them:

Agitar One

Agitator automatically creates dynamic test cases, synthesizes sets of input data, and analyzes the results.

Foojay Podcast #14: Debugging Tools and Skills for Fun and Profit

Mon, 20 Feb 2023 08:29:01 +0000

Let’s talk about debugging and observability.

We work with debugging all the time, but how well do we know this common practice?

Observability, monitoring, and debugging at scale for your production…

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Spotify
Apple Podcasts
And most others…

Guests

A lot of rubber ducks
Johannes Bechberger
- JVM and profiler developer
- Worked on the JDWP protocol and profiling
- https://github.com/parttimenerd
- https://twitter.com/parttimen3rd
- https://mastodon.social/@parttimenerd
- AsyncGetStackTrace: A better Stack Trace API for the JVM
- A short primer on Java debugging internals
Marit van Dijk
- Developer Advocate at JetBrains
- https://maritvandijk.com/
- https://twitter.com/MaritvanDijk77
- https://mastodon.social/@maritvandijk
Ties van de Ven
- Software Engineer @ JDriven, Coach @ Jcore
- https://www.tiesvandeven.nl/
- https://twitter.com/ties_ven
- 6 Steps to help you debug your application

Host

Shai Almog
- Author of “Practical Debugging at Scale ”
- https://debugagent.com/
- https://mastodon.social/@debugagent
- https://twitter.com/debugagent

Producer

Frank Delporte
- https://foojay.social/@frankdelporte
- https://twitter.com/frankdelporte

Content

00'00 Intro and music
00'24 About the topic of this podcast
00'58 Introduction of the guests and host
05'14 Debugging with IntelliJ IDEA and discoverability of tools
- YouTube: Debugger playlist
- YouTube: Profiling tools
- YouTube: Profiling live stream
13'27 JDWP protocol
19'43 Exception breakpoints
- Foojay: Exception Breakpoint that Doesn’t Suck and a Real Use Case for Method Breakpoints
20'34 External debugging tools
- https://rubberduckdebugging.com/
26'55 Observability
37'58 What information should you look for while debugging
45'46 Be aware of tunnel vision while debugging
49'33 What to do if you don’t know where to search for the bug
- https://git-scm.com/docs/git-bisect
- Foojay: External Debugging Tools 2: git bisect
57'05 Outro

JTest: Roll Out Your Own JUnit-Like Testing Framework

Tue, 17 Jan 2023 16:11:50 +0000

In this interactive tutorial and educational project, you’ll be helped in your understanding of the following.

A basic insight into JUnit internals.
The usage of Java annotations and reflection.

You are given minimum starter code (~20 loc), and will have to develop a simple yet self-contained framework that can be used to write real-world unit tests.

Are you ready? Let’s go! 🚀

Task 0: The Big Picture

Before getting your hands dirty, it is a good idea to get a big picture of what you will code up.

Why I Don't do TDD

Fri, 02 Dec 2022 08:59:00 +0000

I recently gave a talk about debugging for the London Java Community. During the Q&A part of the talk, someone asked me about my approach to Test Driven Development. In the past I looked at that practice in a more positive light. Writing lots of tests. How can that be bad?

But as time moved on, I see it in a different light. I see it as a very limited tool that has very specific use cases. It doesn’t fit into the type of projects I build and often hinders the fluid processes it’s supposed to promote. But let’s backtrack for a second. I really liked this post that separates the types and problems in TDD. But let’s simplify it a bit, let’s clarify that every PR should have good coverage. This isn’t TDD. It’s just good programming.

API Mocking: Essential and Redundant

Fri, 11 Nov 2022 08:13:23 +0000

I love contradictions where both states of truth can work at the same time.

Case in point is this tweet about mocking from the other week:

If you use mocks, you are not testing

My answer was:

[Mocks help assert limited fixed functionality and they do it FAST.

Which is what unit tests are about. Mocks are an essential part of a wider quality strategy. Otherwise you will spend your time in integration test churn.

Comparative Evaluation Azul Zulu Prime vs. OpenJDK

Fri, 07 Oct 2022 08:51:00 +0000

In today’s Java ecosystem, you have a wide range of possible runtimes. Choosing between them can have a huge impact on the capabilities or performance of your environments and applications.

In this article, you will learn about best practices for comparative evaluations between JDK setups , whether they be different configurations in a single JDK or comparing Azul Zulu Prime Builds of OpenJDK (Azul Zulu Prime) to OpenJDK itself.

By following this guide, you will be able to establish credible evidence that Azul Zulu Prime improves aspects of application behavior to a degree that justifies using it within your organization.

Am I Testing the Right Way?

Tue, 04 Oct 2022 18:24:12 +0000

Two unit-testing approaches explained!

Pick any topic around testing and there will be at least two very contrary approaches that seem to be at odds.

One of the many points of discussion around unit testing, and in particular TDD, are the question around what good boundaries for tests are.

So the question is: Should you unit test each method on your classes or should you only unit test the public interfaces of a given feature or component?

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.

How to Develop and Test an Automated CI/CD Workflow with Cassandra

Fri, 03 Jun 2022 08:52:14 +0000

In this post, we’ll show you how to develop a CI/CD workflow using Apache Cassandra ™with a GitHub Actions runner. See for yourself how much time and effort you can save by deploying Cassandra cloud-natively while you test and deploy your cloud-native applications!{#6067}

If you have projects that depend on Apache Cassandra ™ and you want to develop an automated continuous integration and continuous delivery (CI/CD) flow, you’re going to need to create Cassandra clusters dynamically for your tests to make sure that your app works after each code change. DataStax does this every day — we run Cassandra in Kubernetes to power Astra DB . And, we use continuous testing of our Cassandra deployments to make sure Astra DB works reliably.{#8d10}

JUnit 5 Display Names

Fri, 10 Dec 2021 12:31:03 +0000

In Part 1 of this series, we looked at several annotations used in JUnit 5. We covered test methods as well as lifecycle methods.

In Part 2 , we looked at the basics of testing using JUnit 5. We covered test annotations such as marking a test method and asserting. We saw how a test method could be tagged and how assumptions can be used. We finally wrapped up with test execution ordering mechanisms.

JUnit 5 Testing Basics

Fri, 03 Dec 2021 12:29:06 +0000

In Part 1 of this series of articles, we looked at several annotations used in JUnit5. We covered test methods as well as lifecycle methods.

This article will share examples of a JUnit test which makes use of a few of these annotations.

Testing

Marking a method as a Test

Tests in JUnit5 are annotated with the @Test annotation. Unlike prior versions of JUnit, the JUnit5 @Test annotation does not have any attributes. Prior versions supported extensions via attributes, while JUnit5 fosters a custom annotation based extension (more on this in a future article).

JUnit 5 Introduction

Fri, 26 Nov 2021 15:22:59 +0000

Code Katas are a great way of teaching programming practices. The effectiveness of a code kata is to “solve” something repeatedly in order to gain a “muscle memory” of sorts on the subject matter.

Nothing stresses repeatability more than unit tests. Code Katas thus, in many cases can be associated with or run via unit tests.

Many of us have been long used to JUnit 4 as a formidable unit testing framework. This article is not going to be a comparison between JUnit 4 and JUnit 5, but you will notice some differences as italicized text.

Testing on foojay.io - Friends of OpenJDK

Foojay Podcast #99: Testing the Untestable: LLM Security for Java Developers with Tiberius

YouTube

Podcast Apps

Tiberius: A Security Testing Framework for LLM Applications in Java

Eliminating Flaky Tests to End World Hunger

Introducing BoxLings! An interactive teacher for BoxLang and TDD/BDD

TestBox 7: Real-Time Feedback, a Browser-Based IDE, and Modern Testing Workflows on the JVM

TestBox RUN: A Browser IDE for Your Tests

How to Customize JaCoCo Report Styling in Your Java Project

Testing Emails with Testcontainers and Mailpit

Flaky Tests: a journey to beat them all

What’s a flaky test?

JC-AI Newsletter #7

AI-Driven Testing Best Practices

So, AI Can Write Tests Now? Cool, But…

Mutation Testing in Rust

Starting with cargo-mutants

Pull request testing on Kubernetes: testing locally and on GitHub workflows

Pull Request testing on Kubernetes: Working with GitHub Actions and GKE

Thinking differently about testing

10x Insights on a different view of quality assurance

Run true-to-production tests on your Java applications

Browserless Testing of Vaadin Applications with Karibu Testing

Introduction

How does it feel to test a compiler?

Foojay Podcast #52 from JCON in Cologne!

Video

Podcast Apps

Software Testing as a Debugging Tool

Tips for reading code

Foojay Podcast #43: Modern Java Testing

Java Flight Recording and Analysis with Azul Mission Control

Soft Assertions - testing kindly

[Unit] Testing Supabase in Kotlin using Test Containers - PART 2

Testing Spring Boot JMS with ActiveMQ Artemis and Testcontainers

Testcontainers to the Rescue

[Unit] Testing Supabase in Kotlin using Test Containers

OpenAPI Generator: From YAML to JetBrains HTTP Client

In this article, I’ll be implementing an OpenAPI generator from scratch so you can too! We’ll be creating a very simple generator for the Jetbrains HTTP Client.

Book Review: Get Your Hands Dirty on Clean Architecture

ArchUnit - test your architecture

Load testing - shoot your application with Gatling

What is load testing?

Testable Code: A Journey Through Consideration and Refactoring

The Challenge of Testing

Three Key Elements for Your Flaky Test Remediation Approach

Local Development Made Simpler with Testcontainers Desktop app

Pitest: Do You Test Your Tests?

What is Pitest?

Seven Reasons You Should Not Ignore Flaky Tests

Debugging OpenJDK Tests in VSCode (Without Losing Your Mind)

Time Zone and Currency Database in JDK

Exhaustive JUnit5 Testing: Combinations, Permutations, Products

Test Support Libraries

Agitar One

Foojay Podcast #14: Debugging Tools and Skills for Fun and Profit

Podcast Apps

Guests

Host

Producer

Content

JTest: Roll Out Your Own JUnit-Like Testing Framework

Task 0: The Big Picture

Why I Don't do TDD

API Mocking: Essential and Redundant

Comparative Evaluation Azul Zulu Prime vs. OpenJDK

Am I Testing the Right Way?

Two unit-testing approaches explained!

Faster Integration Tests with Reusable Testcontainers

How to Develop and Test an Automated CI/CD Workflow with Cassandra

JUnit 5 Display Names

JUnit 5 Testing Basics

Testing

Marking a method as a Test

JUnit 5 Introduction

Starting with `cargo-mutants`