I'm trying to spy on an Object and I want to stub a method that is called by the constructor before the constructor calls it.
My class looks like that:
public class MyClass {
public MyClass() {
setup();
}
public void setup() {
}
}
The setup method mustn't be called. Well, how do I spy on this method (and stub setup so that it does nothing)?
It works fine with mocking the method but I want to unit test MyClass
and so I will need very other method.
The reason why need to stub the setup method so that it does nothing:
I'm programing a Lego robot (lejos) and I put some code in setup that the robot needs to work. However, when I call it outside TinyVM (the VM that is installed on the robot), java crashes since it the VM hasn't been initialized properly (because the tests run on my PC). For unit-testing the setup isn't important.
I can't stub the classes/methods setup calls since some of them are public static final variables.
To answer your question directly, you cannot use Mockito to stub a method called from the constructor. Mockito needs an instance of the class before you can begin mocking, and you haven't given yourself a way to create an instance for testing.
More generally, as mentioned in Effective Java item 17, you should not call overridable methods from constructors. If you do so, for instance, you could provide an override in a subclass that refers to a final
field but that runs before the final
field is set. It probably won't get you in trouble here, but it's a bad habit in Java.
Luckily, you can restructure your code to do this very easily:
public class MyClass {
public MyClass() {
this(true);
}
/** For testing. */
MyClass(boolean runSetup) {
if (runSetup) {
setup();
}
}
/* ... */
}
To make it even more obvious, you can make the one-parameter MyClass
constructor private, and provide a public static
factory method:
/* ... */
public static MyClass createForTesting() {
return new MyClass(false);
}
private MyClass(boolean runSetup) {
/* ... */
Though some developers think it is a bad practice to write any code in methods that is used mostly for tests, remember that you are in charge of the design of your code, and tests are one of few consumers you absolutely know you will need to accommodate. Though it's still a good idea to avoid explicit test setup in "production" code, creating extra methods or overloads for the sake of testing will usually make your code cleaner overall and can drastically improve your test coverage and readability.