mocking a singleton class

by

Of course, I could write something like don’t use singleton, they are evil, use Guice/Spring/whatever but first, this wouldn’t answer your question and second, you sometimes have to deal with singleton, when using legacy code for example.

So, let’s not discuss the good or bad about singleton (there is another question for this) but let’s see how to handle them during testing. First, let’s look at a common implementation of the singleton:

public class Singleton {
    private Singleton() { }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    public String getFoo() {
        return "bar";
    }
}

There are two testing problems here:

  1. The constructor is private so we can’t extend it (and we can’t control the creation of instances in tests but, well, that’s the point of singletons).

  2. The getInstance is static so it’s hard to inject a fake instead of the singleton object in the code using the singleton.

For mocking frameworks based on inheritance and polymorphism, both points are obviously big issues. If you have the control of the code, one option is to make your singleton “more testable” by adding a setter allowing to tweak the internal field as described in Learn to Stop Worrying and Love the Singleton (you don’t even need a mocking framework in that case). If you don’t, modern mocking frameworks based on interception and AOP concepts allow to overcome the previously mentioned problems.

For example, Mocking Static Method Calls shows how to mock a Singleton using JMockit Expectations.

Another option would be to use PowerMock, an extension to Mockito or JMock which allows to mock stuff normally not mock-able like static, final, private or constructor methods. Also you can access the internals of a class.

More Related Contents:

  1. Java new keyword
  2. What is the cardinality ratio between class and interface? [closed]
  3. Conditionally ignoring tests in JUnit 4
  4. Difference between @Mock and @InjectMocks
  5. When should I use “this” in a class?
  6. What is the difference between dynamic and static polymorphism in Java?
  7. What is the main difference between Inheritance and Polymorphism?
  8. Test class with a new() call in it with Mockito
  9. Uninitialized variables and members in Java
  10. Override default Spring-Boot application.properties settings in Junit Test
  11. Get name of currently executing test in JUnit 4
  12. “Non-static variable this cannot be referenced from a static context” when creating an object
  13. calling setters from a constructor
  14. Java: Static Class?
  15. When using Mokito, what is the difference between the actual object and the mocked object?
  16. Is it bad practice to make a setter return “this”?
  17. How to read a text-file resource into Java unit test?
  18. Is it bad practice to use Reflection in Unit testing? [duplicate]
  19. Multiple classes in single file
  20. How to verify that a specific method was not called using Mockito?
  21. Mock final class with Mockito 2
  22. How to do method overloading for null argument?
  23. Forming Mockito “grammars”
  24. What’s the difference between Mockito Matchers isA, any, eq, and same?
  25. Are Java classes objects?
  26. Should methods that throw RuntimeException indicate it in method signature?
  27. Anonymous vs named inner classes? – best practices?
  28. Why are interfaces preferred to abstract classes?
  29. TestNG: How to test for mandatory exceptions?
  30. Methods With Same Name as Constructor – Why?

Leave a Comment