Currently, I make some efforts to improve tests in my Java EE Application. At this time there are only some simple JUnit-Tests which doesn’t truly fulfill the requirements of testing. So I decide to look deeper into the new embedded container (Arquillian) which is provided by Netbeans 7.0 out-of-the-box and a testing framework.
After a short research on the Internet and some own made positive experience previously, I selected mockito as the testing framework.

For the first steps I created a simple class inside my Java EE Application which I want to test it. It looks like:

@Stateful
@LocalBean
public class SomeCase {
 
    @Inject transient private Logger logger;
    @Inject private UseCase useCase;
 
    /**
     * Default empty constructor.
     */
    public SomeCase() {
    }
 
    /**
     * Create a string representation of a digit.
     * Convert a digit between 0 and 5 to the written digit like "zero",
     * "one", etc.
     * @param digit between 0 and 5
     * @return string representation of a digit
     */
    public String digitToString(int digit){
        String response = "";
 
        switch (digit){
            case 0: response = "zero"; break;
            case 1: response = "one"; break;
            case 2: response = "two"; break;
            case 3: response = "three"; break;
            case 4: response = "four"; break;
            case 5: response = "five"; break;
            case 99: response = useCase.sayHello(digit + ""); break;  //easter egg ;-)  
            default: response = "undefined"; break;                
        }
        logger.log(Level.INFO, "digit={0};respone={1}",
                new Object[]{digit, response});
        return response;
    }
}

The only container based functionality I use, is to inject the UseCase Bean and my log Factory (@Produces public Logger createLogger(InjectionPoint ip)).

Embedded Container

I started with the embedded container. A year ago, I have already tried to use the embedded container, but I gave up after I investigate hours in finding solution to my occurring exceptions. But now, one year and a new version of Netbeans later, it has to be better – I hoped!

According to the well documented tutorial on netbeans.org. I tried to integrate the embedded test container in my project. But I messed-up with a lot of exceptions and warnings. After some additional hours trying to get the test inside my application up and running, I gave up (again) and decide to go over to the testing framework. The embedded container is maybe better than it was a year ago, but still not enough good for me (according to my knowledge and skills).
Test should be created as simply as possible. Else I don’t use it reasonable. There is also another reason why I stopped investigating more time into the embedded container approach. I think it isn’t unit testing as the website of arquillian tells me, it is a kind of integration testing. So let’s try mockito.

Mockito

Because of the plain text java object of EJBs it is possible to create fast and isolated EJB unit tests with Mockito. You have to add some extra code to the productive source code to test it. That is the only change on it.
But now, step -by-step:
My Class SomeCase uses two injections: @Inject transient private Logger logger;
and @Inject private UseCase useCase;. Therefore I create these two Classes as a field in my Test Class (SomeCaseTest). I created also a field for the testing class itself:

@Mock UseCase useCase;
@Mock Logger logger;
private SomeCase someCase;

In the setUp method i initialize this fields

@Before
public void setUp() {
    MockitoAnnotations.initMocks( this );
    someCase = new SomeCase(logger, useCase);
}

MockitoAnnotations.initMocks( this ); create a mock object for all fields annotated with @Mock. For the initialize of SomeCase, I need a new constructor. This is the only change in the origin source code which has to be done (as I already told). This new constructor looks like

//...
public SomeCase(Logger loggerMock, SomeCase useCaseMock) {
    this.logger = loggerMock;
    this.useCase = useCaseMock;
}
//...

Now all preparation for the unit testing are done and I can start with writing tests. First I will test some different test inputs on the digitToString method.

    @Test
    public void testDigitToString() throws Exception {
        int i = 1;
        String expectResult = "one";
        String response = someCase.digitToString(i);
        assertEquals(response, expectResult);
 
        i = 6; expectResult = "undefined";
        response = someCase.digitToString(i);
        assertEquals(response, expectResult);
 
        i = -1; expectResult = "undefined";
        response = someCase.digitToString(i);
        assertEquals(response, expectResult);        
    }

As you can see, there is nothing special in this test. Without the mocking part in the setup-method, it would throw a nullpointer-exception. Because of the logger which has no instance (in the container it is injected). In this test I don’t really use the power of Mockito. So let’s create another one.

    @Test
    public void testEasterEggOne() throws Exception {
        int i = 99;
        String expectResult = "Hello 99";
        when(useCase.sayHello(i + "")).thenReturn("Hello 99");        
        String response = someCase.digitToString(i);
        assertEquals(response, expectResult);        
    }

Here I used the useCase mock object as a stub. It returns fix the value of “Hello 99″, when it is called with 99. In the next example I capture the parameter of the useCase.sayHello method call and verify it.

    @Test
    public void testEasterEggTwo() throws Exception {
        int i = 99;
        someCase.digitToString(i);
 
        ArgumentCaptor arg = ArgumentCaptor.forClass(String.class);
        verify(useCase).sayHello(arg.capture());
 
        assertTrue(arg.getValue().equals("99"));
    }

It should be self-explained and straightforward. There are a lot of other options, how you can use mockito as a ejb unit test framework. Be creative!