#SuppressStaticInitializationFor partial mocking - testing

Question

I have this weird case where I want to test "some" functionality without touching the other... it's very hard for me to choose a proper description and I hope that the code I will present below is pretty much self descriptive.
Suppose I have a class that keeps some strategies:
class TypeStrategy {
private static final CreateConsumer CREATE_CONSUMER = new CreateConsumer();
private static final ModifyConsumer MODIFY_CONSUMER = new ModifyConsumer();
private static final Map<Type, Consumer<ConsumerContext>> MAP = Map.of(
Type.CREATE, CREATE_CONSUMER,
Type.MODIFY, MODIFY_CONSUMER
);
public static void consume(Type type, ConsumerContext context) {
Optional.ofNullable(MAP.get(nodeActionType))
.orElseThrow(strategyMissing(type))
.accept(context);
}
}
The idea is very easy - there are some strategies that are registered for a certain Type; method consume will simply try to find a proper registered type and invoke consume on it with the supplied ConsumerContext.
And now the problem: I very much want to test that all the strategies I care about are registered and I can invoke accept on them - that is literally all I want to test.
Usually, I would use #SuppressStaticInitializationFor on the TypeStrategy and using WhiteBox::setInternalState would just put whatever I need for CREATE_CONSUMER and MODIFY_CONSUMER; but in this case I can't, because the MAP will be skipped also and I really don't want that, all I care about is those two strategies - I need the MAP to stay as it is.
Besides some nasty refactoring, that does get me where I sort of want to be, I am out of ideas how can I achieve this. In the best case scenario I hoped that #SuppressStaticInitializationFor would support some "partial" skipping, where you could specify some filter on what exactly you want skipped , but that is not an option, really.
I could also test "everything" else on the chain of calls - that is test everything that accept is supposed to do, but that adds close to 70 lines of mocking in this test and it becomes a nightmare to understand that it really wants to test a very small piece.

Answer 1

From your description it seems black-box testing is not an option, so perhaps we can rely on some white-box tests by mocking the constructors of your consumers, and verifying their interactions.
Below you can find a complete example extrapolated from your initial sample, including a possible option for .orElseThrow(strategyMissing(type)).
One important note/disclaimer: since we're leaving TypeStrategy intact, this means the static initialization block for the map will be executed. Thus, we need to pay special attention to the consumer mock instances. We need to make sure that the same mock instances added in the map during the initial mocking phase, are available in all the tests, otherwise the verification will fail. So instead of creating mocks for each test, we will create them once for all tests. While this is not recommended in unit testing (tests should be isolated and independent), I believe in this special case it's a decent trade-off one can live with.
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.util.AbstractMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.*;
import static org.powermock.api.mockito.PowerMockito.whenNew;
// enable powermock magic
#RunWith(PowerMockRunner.class)
#PrepareForTest({MockitoTest.TypeStrategy.class})
public class MockitoTest {
private static CreateConsumer createConsumerMock;
private static ModifyConsumer modifyConsumerMock;
// static initializer in TypeStrategy => mock everything once in the beginning to avoid having new mocks for each test (otherwise "verify" will fail)
#BeforeClass
public static void setup() throws Exception {
// mock the constructors to return mocks which we can later check for interactions
createConsumerMock = mock(CreateConsumer.class);
modifyConsumerMock = mock(ModifyConsumer.class);
whenNew(CreateConsumer.class).withAnyArguments().thenReturn(createConsumerMock);
whenNew(ModifyConsumer.class).withAnyArguments().thenReturn(modifyConsumerMock);
}
#Test
public void shouldDelegateToCreateConsumer() {
checkSpecificInteraction(Type.CREATE, createConsumerMock);
}
#Test
public void shouldDelegateToModifyConsumer() {
checkSpecificInteraction(Type.MODIFY, modifyConsumerMock);
}
private void checkSpecificInteraction(Type type, Consumer<ConsumerContext> consumer) {
ConsumerContext expectedContext = new ConsumerContext();
// invoke the object under test
TypeStrategy.consume(type, expectedContext);
// check interactions
verify(consumer).accept(expectedContext);
}
#Test
public void shouldThrowExceptionForUnsupportedConsumer() {
ConsumerContext expectedContext = new ConsumerContext();
// unsupported type mock
Type unsupportedType = PowerMockito.mock(Type.class);
when(unsupportedType.toString()).thenReturn("Unexpected");
// powermock does not play well with "#Rule ExpectedException", use plain old try-catch
try {
// invoke the object under test
TypeStrategy.consume(unsupportedType, expectedContext);
// if no exception was thrown to this point, the test is failed
fail("Should have thrown exception for unsupported consumers");
} catch (Exception e) {
assertThat(e.getMessage(), is("Type [" + unsupportedType + "] not supported"));
}
}
/* production classes below */
public static class TypeStrategy {
private static final CreateConsumer CREATE_CONSUMER = new CreateConsumer();
private static final ModifyConsumer MODIFY_CONSUMER = new ModifyConsumer();
private static final Map<Type, Consumer<ConsumerContext>> MAP = Stream.of(
new AbstractMap.SimpleEntry<>(Type.CREATE, CREATE_CONSUMER),
new AbstractMap.SimpleEntry<>(Type.MODIFY, MODIFY_CONSUMER)
).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
public static void consume(Type type, ConsumerContext context) {
Optional.ofNullable(MAP.get(type))
.orElseThrow(strategyMissing(type))
.accept(context);
}
private static Supplier<IllegalArgumentException> strategyMissing(Type type) {
return () -> new IllegalArgumentException("Type [" + type + "] not supported");
}
}
public static class CreateConsumer implements Consumer<ConsumerContext> {
#Override
public void accept(ConsumerContext consumerContext) {
throw new UnsupportedOperationException("Not implemented");
}
}
public static class ModifyConsumer implements Consumer<ConsumerContext> {
#Override
public void accept(ConsumerContext consumerContext) {
throw new UnsupportedOperationException("Not implemented");
}
}
public enum Type {
MODIFY, CREATE
}
public static class ConsumerContext {
}
}