Faking constructors for unit testing

Question

Hi,

I have a set of classes that have dependencies at instantiation time, that is, when creating an object of type A, it also creates another of type B, which subsequently creates others of type C, etc.

For testing matters, I don't need the whole functionality of all the levels to test the upper ones, so I could use stubs or mocks, but as I have explicit new's in the constructors I cannot see a direct way other than changing the code to use an AbstractFactory and provide one that creates the fakes at testing time.

So, is there any "black magic" way to hack the Java class loader so the fake testing classes are created instead the normal ones when instantiating objects with new?

Thanks!

Answer 1

Why not add a constructor which takes those dependencies as parameters, instead of creating them yourself in the constructor? Personally I'd add that one and remove the other one :) Injecting the dependencies makes the code easier to test and more flexible in the future (as you can easily inject a different implementation later on, without changing the code.)

Answer 2

What do you want is to use mock classes. Consider using any framework for that. Here is a good one - https://jmockit.dev.java.net/

Answer 3

You can achieve the intended behaviour without modifying the original sources by modifying the classpath. Create dummy classes in a second source folder with the exact same names and packages. Then put the dummy classes to the classpath and remove the real ones.

This works best with classes that are on their own jar, such that you can just exchange the jars.

Answer 4

After some research, it seems that PowerMock can do it very well:

http://code.google.com/p/powermock/wiki/MockConstructor

Answer 5

JMockit fits the requirement perfectly. For example, you could write a test like this:

// In production code:
public final class ClassUnderTest
{
    private final SomeDependency dep;

    public ClassUnderTest(String someData)
    {
        dep = new SomeDependency(someData);
    }

    void methodToBeTested() { ... int i = dep.doSomething("xpto", true); ... }
}

final class SomeDependency
{
    int doSomething(String s, boolean b) { ... }
}

// In test code:
public final class MyTest
{
    @Test
    public void mockingInternalDependencies()
    {
        new Expectations()
        {
            SomeDependency mockedDep;

            {
                mockedDep.doSomething(anyString, anyBoolean); result = 123;
            }
        };

        new ClassUnderTest("blah blah").methodToBeTested();
    }
}

Answer 6

Another alternative, as I see you don't want to create a constructor, nor use DI, could be have the attribute you need to mock with default visibility and create factories for test (with the same package and in other source folder) that inject directly the mock objects.