如何在 Java 中的另一个枚举中模拟一个枚举？

Question

I have two enums:

public enum X {
    INSTANCE;
    private final Y y = Y.INSTANCE;

    public boolean isfunc() {
        return y.someMethod();
    }
}

public enum Y {
    INSTANCE;

    public boolean someMethod() {
        return true;
    }
}

I have written a unit test class for Y by mocking using Whitebox. However, I need to get the following exception while writing the unit test case for X :

I am getting the following error message:

Cannot mock/spy class
Mockito cannot mock/spy following:
  - final classes
  - anonymous classes
  - primitive types

Here are the unit test cases:

public class XTest {
    @Mock private Y yMock;

    @Before
    public void setUp() throws Exception {
        Whitebox.setInternalState(Y.INSTANCE, "y", yMock);
    }

I understand that the issue is because I am trying to mock an enum which is a primitive type. I want to find a way around this.

Answer 1

Here's a bit from Mockito's Documentation:

39. Mocking final types, enums and final methods (Since 2.1.0)

Mockito now offers an Incubating, optional support for mocking final classes and methods. This is a fantastic improvement that demonstrates Mockito's everlasting quest for improving testing experience. Our ambition is that Mockito "just works" with final classes and methods. Previously they were considered unmockable, preventing the user from mocking. We already started discussing how to make this feature enabled by default. Currently, the feature is still optional as we wait for more feedback from the community.

This feature is turned off by default because it is based on completely different mocking mechanism that requires more feedback from the community.

However, I would rather recommend replacing the enum Singleton with a static member singleton in a singleton class, as it is often considered more readable, equally thread safe, and more configurable, as this test case shows.

Something like this:

public class Y {
    private Y() {}
    private final static Y y = new Y();
    public static Y getInstance() {
        return y;
    }

    public boolean someMethod() {
        return true;
    }
}

        enum X {
            INSTANCE;
            private final Y y = Y.getInstance();

            public boolean isfunc() {
                return y.someMethod();
            }
        }

        public class XTest {
            @Mock private Y yMock;

            @Before
            public void setUp() throws Exception {
                Whitebox.setInternalState(X.INSTANCE, "y", yMock);
            }

            @Test
            void test() {  // ...
            }
        }

I would add further, that I dislike using Whitebox during tests. I believe that anything the test can do, my code should be able to do, as the test is the first real client of my module, and an indicator of what future clients might want to do. For example, just like the test would like to replace Y with a mock Y, in the future someone might like to use X with a different production Y.

I would change Y to use an interface, and remove the final of the y variable in X, in order to make it settable, as follows:

interface IY
{
    public boolean someMethod();
}

public class Y implements IY {
    private Y() {}
    private final static IY y = new Y();
    public static IY getInstance() {
        return y;
    }

    public boolean someMethod() {
        return true;
    }
}    

        enum X {
            INSTANCE;
            private IY y = Y.getInstance();
            public void setY(IY y)
            {
                this.y = y;
            }

            public boolean isfunc() {
                return y.someMethod();
            }
        }

        public class XTest {
            @Mock private Y yMock;

            @Before
            public void setUp() throws Exception {
                X.INSTANCE.setY(yMock);
            }

            @Test
            void test() { // ...
            }
        }

I would sacrifice some safety ( for example the possiblity of X.INSTANCE.setY(null); ) for configurability and clean code.