Assert on object at time of call

[PeterAttardo]

I've gone down a bit of a rabbit hole chasing this, so I think the easiest thing would be to describe my situation and what I'm hoping to accomplish.

Setup:

I have a class method with the signature push(seq: Sequence<Data>) where Data is a data class that I control. Inside that method, the following occurs:

1. The sequence is chunked
2. For each chunk, a Batch object is created. Batch is a 3rd party class outside of my control.
3. For each Data in the chunk, a number of setters are called on the Batch object, with parameters derived from the properties of the Data object.
4. A send() method is called on each Batch exactly once. This method sends the batch to an external resource.

Because this push method sends data to an external resource, it doesn't return anything or alter any local state.

Test:

I would like to verify the following:

1. For a given Sequence<Data>, Batch#send() was called the correct number of times (equivalent to the length of the sequence divided by the chunk size, rounded up). send() should also be mocked to a no-op, for obvious reasons.
2. For each invocation of send() the Batch object it was called on is in the expected state.

using mockkConstructor(Batch::class) and verify(exactly = numOfChunks){ anyConstructed<Batch>.send() } would seem to be the path to satisfy 1, but I don't know how to satisfy 2. I don't know if there's a functionality to run assertions on objects as Mockk tracks calls being made on them.

I suppose I could extract the List<Data> -> Batch functionality into a separate method, and test that through traditional means, but now that I've gone down this rabbit hole I'm curious if Mockk can achieve it all in one go as written.

Thanks

[Raibaz]

1. For a given Sequence<Data>, Batch#send() was called the correct number of times (equivalent to the length of the sequence divided by the chunk size, rounded up). send() should also be mocked to a no-op, for obvious reasons.

This, as you have guessed, is the easy part and can be achieved the way you explained using mockkConstructor and verifying on anyConstructed<Batch>.

2. For each invocation of send() the Batch object it was called on is in the expected state.

This is what gets me a bit puzzled: who is in charge of setting the state of Batch objects?

If it is up to the client code (i.e., your code), you should have a setState, or equivalent, method, that you can verify was called; if it is being set by the Batch class internally, I'd argue it's not up to you to verify it was called, since it is part of an external library and it's not part of the responsibilities of the class you are testing.

You could test that batch states are being set correctly in a different test, but then again, one could say that it is not up to you to test the internal behaviors of a third party library.

Does this make sense to you?

[PeterAttardo]

The code is mostly under my control, it looks something like this:

seq.chunked(chunkSize).forEach{ chunk ->
    val batch = Batch()
    chunk.forEach{ data ->
        batch.addItem {
            setProp1(data.prop1)
            setProp2(data.prop2)
            [etc...]
        }
    }
    batch.send()
}

The Batch class is third party, but everything interacting with it is me. I could rework the code to be:

seq.chunked(chunkSize).forEach{
    chunkToBatch(it).send()
}

with

fun chunkToBatch(chunk: List<Data>): Batch {
    [...]
}

And then test chunkToBatch with an independent test and standard assertions.

I am curious if mockk is capable of testing this without the refactor, because the code isn't that complicated, and I'm interested to learn the limits of the complexity mockk is capable of handling.