Enums not mocked when allopen plugin applied to class

[griffinsorrentino]

Hey @lupuuss thanks for your continued work!

Problem

Kotlin: 2.3.0
AGP: 9.0.0
Mokkery: 3.2.0

Similar to #122 and #78

When following the guide to mock a class, any enum fields on that class will not be mocked. When trying to access the field, a nullpointer is thrown.

Repro Steps

Take the given enum

enum class BrokenEnum {
   BROKEN
}

Take the given class (with your defined allopen annotation)

@Mockable
class BrokenMock(
   val someField: String,
   val enum: BrokenEnum
)

mock it, try to assert

val testMock = mock<BrokenMock>()
assertTrue {
    testMock.enum == BrokenEnum.BROKEN
}

I'm unsure if this is an issue with the allopen plugin or Mokkery. Removing the @Mockable (or similar) annotation and manually adding open to the class definition works without issue.

[lupuuss]

Hello! Thanks for the report! I think the reproduction steps are not showing exactly what happened, but I have a theory what could happened. First, I've tested this case and it works correctly:

val mock = mock<BrokenMock> {
    every { enum } returns BrokenEnum.BROKEN
}
assertEquals(BrokenEnum.BROKEN, mock.enum) // it succeeds

I think in your case, there are 2 things that are missing in the reproduction steps:

1. You use MockMode.autofill by default
2. You use ignoreFinalMembers

What it's important about your case is you don't specify what testMock.enum should return.

With @Mockable, all properties become open and Mokkery overrides them, so whatever was assigned to those properties using base constructor, won't be accessed. It's expected behavior. By default (in strict mock mode), you should get an error about a function that is not mocked, but I suspect you use autofill mode. Autofill mode is not super advanced and it returns null for all complex types. That's probably why you are getting NPE. You could extend what autofill is capable of using AutofillProvider.forMockMode - AutofillProvider.forMockMode.types.register<BrokenEnum> { BrokenEnum.BROKEN }. It's enough to register this provider once per all test, but as I remember Kotlin Test doesn't provide any mechanism to call something before all tests, so there might be a need to register it per test class.

With open, you only make the class open. Other properties are final and they are not overridden and that's why values passed to base constructor are returned. Normally it should cause an error, but you use flag to ignore it.

I'm not 100% sure if that's what happened in your case, so please confirm it or provide more details about your setup.

[griffinsorrentino]

Thanks for the response!

Here's some additional context -

Following the guide in the docs, specifically

Mokkery uses the following strategies to supply constructor arguments:
...
- The first declared entry for enum types
...

isn't it expected that when mocking enums it selects the first option? During this test there are no arguments being passed to the constructor outside of the standard mock<T>() call.

Here's a more clear example of the issue being encountered

enum class BrokenEnum {
    FIRST,
    SECOND
}

@Mockable
class BrokenMock(
    val someField: String,
    val enum: BrokenEnum
)

open class WorkingMock(
    val someField: String,
    val enum: BrokenEnum
)

@Test
fun `mocking test`() {
    val working = mock<WorkingMock>()
    // This will pass, expected to pass
    assertTrue {
        working.enum == BrokenEnum.FIRST
    }

    val broken = mock<BrokenMock>()
    // This will fail, expected to pass
    assertTrue {
        broken.enum == BrokenEnum.FIRST
    }
}

When using the allOpen plugin, the enum field is not properly being mocked with the first value in the enum class. When you manually set it as open and remove the allOpen plugin, it's mocked perfectly fine and properly uses the first value from the enum.

Here's the current mokkery config in the gradle script

mokkery {
    rule.set(ApplicationRule.All)
    ignoreFinalMembers.set(true)
    defaultMockMode.set(MockMode.autofill)
    stubs.allowConcreteClassInstantiation.set(true)
    stubs.allowClassInheritance.set(true)
}

[lupuuss]

When using the allOpen plugin, the enum field is not properly being mocked with the first value in the enum class. When you manually set it as open and remove the allOpen plugin, it's mocked perfectly fine and properly uses the first value from the enum.

What I'm trying to say is that actually it's the other way around. With @Mockable, the class is properly mocked but with open class it's not. The problem is that those are not equivalents:

@Mockable
class BrokenMock(
    val someField: String,      // <-- it's open, can be mocked
    val enum: BrokenEnum   // <-- it's open, can be mocked
)

open class WorkingMock(
    val someField: String,      // <-- it's final, cannot be mocked
    val enum: BrokenEnum   // <-- it's final, cannot be mocked
)

With ignoreFinalMembers, Mokkery allows you to create a mock of WorkingMock, but it's still unable to mock final members. They are ignored and their implementation remains unchanged.

open class case works for you, because the original implementation of the class returns the value of the enum backing field that was initialized in the constructor. Mokkery is only responsible for passing stub values to constructor here.

With @Mockable the properties are open and can be mocked. You don't specify what should be returned, so autofill kicks in. Autofill is not as smart as stubbing, because it works only at runtime, and stubbing happens mostly at compile time.

Mokkery uses the following strategies to supply constructor arguments:

• The first declared entry for enum types

This part of the documentation is true. Mokkery supplies constructor arguments using those strategies. It does not mention supplying properties.

[griffinsorrentino]

My mistake! I must've mistunderstood the documentation when I encountered this issue, thanks for clarifying! I'll close this issue