Is there any way to make a `spyk` intercept all calls to object AND make it relaxed at the same time...

# mockk

[Mark Allanson]

Is there any way to make a spyk intercept all calls to object AND make it relaxed at the same time?

[Mattia Tommasone]

Do you have a use case of what you would like to do?

[Mark Allanson]

I've got a class that wraps a generic type and am trying to write a spring test that sucks up all these "classes that need to be wrapped", wraps them and tests that the wrapping class does the right thing

So I have something like...

class Dispatcher(val wrapped: SomeClass<*>)

I essentially want to do (where toBeWrapped is injected via spring to the test)....

@SpringBootTest
class DispatcherTests {
    @Autowired
    lateinit var toBeWrapped: List<ProviderModule<*, *>>

    @Test
    fun testGetDataDispatchedForEachProvider() {
        for (dispatcher in this.toBeWrapped.map { Dispatcher(it) }) {
            val moduleSpy = spyk(dispatcher.provider)
            every { moduleSpy.getData(any()) }
            dispatcher.getData(someData)
            verify { moduleSpy.getData(any()) }
        }
    }
}

of course the call to getData on toBeWrapped could be anything, which is represented as Nothing by the compiler, so am having trouble spying on it

[Mark Allanson]

(I know this scenario is a nightmare, but I am working with a protobuf oneof which makes it messy)

[Mattia Tommasone]

ow, that’s a nightmare indeed 😄

[Mark Allanson]

Essentially I am trying to verify that when a new one of the toBeWrapped classes are added, that a mapping is also added into the Dispatcher component

[Mattia Tommasone]

i think the best shot you can have at making it better would be to somewhat constrain the generic types, i.e. making them * extends Something rather than just *

[Mattia Tommasone]

so that you can have your spied getData return something better than Nothing

[Mattia Tommasone]

does it make sense to you?

[Mark Allanson]

yeah unfortunately protobuf messages (hence classes generated) cannot inherit

[Mattia Tommasone]

oh, right 😞

[Mark Allanson]

Oh hang on - maybe they do actually, from a generic protobuf message class

[Mark Allanson]

oh great they do!

public final class SomeCalss extends GeneratedMessageV3

[Mark Allanson]

Good outside the box thinking :D

[Mattia Tommasone]

nice 🙂

[Mark Allanson]

So this doesn't work as one of the generic parameters is contravariant so convert to Nothing anyway even with an extends.

From the kotlin docs

For Foo<in T>, where T is a contravariant type parameter, Foo<*> is equivalent to Foo<in Nothing>. It means there is nothing you can write to Foo<*> in a safe way when T is unknown.

[Mattia Tommasone]

ouch

[Mark Allanson]

Ok I got success with dynamic calls mocking

every { 
  dispatcherSpy invoke "dispatch" withArguments listOf(a, b) 
} returns response

[Mattia Tommasone]

uh, nice!

[Mark Allanson]

Ah the discovery continues, creating a relaxed mock from a class is also possible, and nicer.

mockkClass(theClassInstance::class, relaxed = true)