I was writing a component test in Kotlin for a scenario where we publish an event to a Kafka topic whenever we receive a request from an upstream system. It offered a good opportunity to learn how to write a custom matcher for comparing two different types of objects!

For demonstration purposes let's imagine I'm a middleman between a customer wanting a cake and a baker. The cucumber scenario looked a bit like this:

Scenario: Tell the baker that the customer wants some cake
    Given the customer has a cake request
    When the request is submitted
    Then a cake requested event is published to the baker

At some point in my test, I wanted to make sure that certain fields in the outgoing cake requested event matched the ones received in the incoming cake request. Because I was intercepting the outgoing event using a Kafka listener, it was in JsonNode format.

So imagine this incoming CakeRequest:

data class CakeRequest(
    val requestId: String,
    val flavour: String,
    val colour: String,
    val wantsSprinkles: Boolean,
)

And an outgoing JsonNode that looks like this:

{
    "flavour":"chocolate",
    "colour":"red",
    "wantsSprinkles":"true"
}

What is the best way to make sure they have the same values (minus the requestId)?

Simple private method

I started with this simple assertion:

assertTrue { hasSameEssentialValues(cakeRequest, resultingEvent) }

private fun hasSameEssentialValues(cakeRequest: CakeRequest, resultingEvent: JsonNode) =
        cakeRequest.flavour == resultingEvent["flavour"].asText()
                && cakeRequest.colour == resultingEvent["colour"].asText()
                && cakeRequest.wantsSprinkles == resultingEvent["wantsSprinkles"].asBoolean()

While this worked fine, there were a few downsides:

• The assertion didn't read fantastically

• It polluted my test file with ugly private methods

• Most importantly, the truth about how to match fields between a CakeRequest and a JsonNode was being mixed in with everything else.

In steps a Hamcrest matcher!

By the power of Hamcrest, I created an assertion that looks like this:

assertThat(resultingEvent, hasSameEssentialValuesAs(cakeRequest))

And a matcher in a separate file that looked like this:

fun hasSameEssentialValuesAs(cakeRequest: CakeRequest) = CakeRequestMatcher(cakeRequest)

class CakeRequestMatcher(private val cakeRequest: CakeRequest) : BaseMatcher<JsonNode>() {

    override fun describeTo(description: Description) {
        description.appendText("The important fields must match")
    }

    override fun matches(resultingEvent: Any?): Boolean {
        if (resultingEvent !is JsonNode)
            return false

        return cakeRequest.flavour == resultingEvent["flavour"].asText()
                && cakeRequest.colour == resultingEvent["colour"].asText()
                && cakeRequest.wantsSprinkles == resultingEvent["wantsSprinkles"].asBoolean()
    }
}

This makes the assertion read brilliantly and follows the single responsibility principle much better.

But there are some downsides:

• The mandatory implementation describeTo() - not useful in my situation

• matches() takes the Any? type as its input, requiring manual type-checking

• The whole thing is complex - it will be harder to read and maintain

Final Takeaways: Reflections and Next Steps

While this was a good exercise where I learned a lot about matchers (and ended up writing this article), in my specific use case I ultimately decided to check the fields in a simple package-level function in its own file. This kept the responsibility in the correct place and made the whole thing less complex.

It means when someone else (or me in 6 months) reads this test, they'll take less time to understand it, and less time to modify it. Which surely is the ultimate goal when writing code, right?

Update:

5 minutes after I published this article I sent the link to my esteemed work colleague who I worked with on this problem, and he replied straight away with a solution that blows mine out of the water. It solves the problem of readability and allows you to abstract the comparison logic away from both the test and the CakeRequest object:

assertTrue { cakeRequest.hasSameEssentialValuesAs(resultingEvent)

Kotlin has extension functions, duh!!