DEV Community: Claudio Higashi

Mocking Logger in Java with Mockito

Claudio Higashi — Tue, 31 Mar 2020 21:40:42 +0000

Yes, you read it correctly: "Mocking Logger in Java". That might sound very weird when you see this for the first time but there are some particular cases in which the only way to unit test some parts of your application is by checking whether some specific messages were logged or not.

For example, suppose that your application needs to make an asynchronous call to some other WebService. Then you have separate threads for making that call. For the main thread, it doesn't matter if the call to the service was successful or not because it won't wait for a response (otherwise it would be synchronous, right?). Suppose that this part of your application will just call the service and, after that, only log whether the call was successful or not (needless to say that in such a case, you need a monitoring tool in place to know when things are not going well in production).

Now, you have to create a JUnit test case to cover these scenarios. If you google it, you are going to find some people using PowerMock for this, but imagine that you are already using Mockito and, for some reason, you want to do this using Mockito only.

In this post I'm assuming that you are already familiar with Mockito, so I'll focus on the "mocking logger" part only. You can find lots of Mockito tutorials on the Internet if you want to learn it.

Okay. One way to accomplish this is to mock the Appender of your Logger object and use Mockito's ArgumentCaptor to capture all logging events in your test case:

    @Mock
    private Appender mockedAppender;

    @Captor
    private ArgumentCaptor<LoggingEvent> loggingEventCaptor;

Then you have to make sure that the mocked Appender is added to root Logger before the tests are executed:

    @Before
    public void setup() {
        Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        root.addAppender(mockedAppender);
        root.setLevel(Level.INFO);
    }

After this you are ready to call the tested class and do the assertions on the logged messages:

    @Test
    public void testSuccessCall() throws Exception {
        // mock all required response objects in here

        [...]

        // this is the call to the service being tested
        myService.execute(createRequestForSuccessResponse());

        // check how many times the ArgumentCaptor was called
        verify(mockAppender, times(1)).doAppend(loggingEventCaptor.capture());
        // get the reference to the LoggingEvent you want to inspect
        LoggingEvent loggingEvent = loggingEventCaptor.getAllValues().get(0);
        // check the logged message
        assertEquals("Webservice was successfully called", loggingEvent.getMessage());
        // check the log level
        assertEquals(Level.INFO, loggingEvent.getLevel());
    }

I hope this might be eventually helpful when you face such a particular scenario! ;-)

Agile for Kids, literally

Claudio Higashi — Mon, 30 Mar 2020 16:01:05 +0000

The word Kids in the title is literal: kids! I have kids at home and nowadays they are required to study from home due to the current circumstances (the pandemic, obviously), the same way as I am also forced to work from home. Initially, they were kind of very happy about having not to go to school, but after the first week, I noticed that things started to change. Things were getting out of their control. They started to become desperate for not knowing exactly what to do. Lots of homework, online tests, and other activities. Now, their responsibility is way bigger than before, when they were present at school and teachers usually say to you what to do and when.

That's where I came in. So I was aware that I had to wear the hat of "Scrum Master" at home. So I decided to apply some agile methodologies which we use in the company to facilitate their lives, to give them focus on what's really important. I bought one whiteboard per daughter and colored paper stickers. Each color represents a type of activity: yellow for tests, pink for homework, and blue for other activities, for example.

Then we created a board with all stories which we identified together in a sort of light planning session. We identified the important stories for the week and glued all of them to the TODO session.

These were the sessions of their Kanban boards:

Backlog: all remaining stories
To do: starts with all the important stories for the week
Doing: the story which she is working on (should be only one)
Done: all completed stories

Now they know exactly what to do and they are way more confident knowing that everything is there on the board and under control.

Locating jar files containing a given class in the command line

Claudio Higashi — Thu, 26 Mar 2020 22:12:28 +0000

Have you ever been in a situation where you need to check whether a given Java class is present or not in some jar library in a remote server's filesystem but all you have in your hands is just a *%@!# SSH terminal? You just feel like you have to cross the ocean with a spoon.

In such a case, and if luckily the remote server is running some sort of Linux, then you can use the find command in combination with grep.

The example below will try to locate which jar files contain the class com.ibm.db2.jcc.Db2Driver, starting from the current directory. Notice that we have to replace dots by slashes.

$ find . -name '*.jar' -exec grep -Hs com/ibm/db2/jcc/DB2Driver {} \;

And this is what I got after running the above command:

Binary file ./WEB-INF/lib/db2jcc4-10.5.2.jar matches

I hope this may eventually help you to cross your ocean. But take care. Sometimes there are lots of sharks out there! :-o

SSH Tunneling via a Jump Host

Claudio Higashi — Wed, 25 Mar 2020 21:50:12 +0000

Many large companies use to implement strict rules for accessing servers hosting their applications. One of the security measures some of them implement is to place a gateway between "you" and the server you need to access. This gateway is also known as Jump server, Jump host, or Jump box.

A typical implementation of this requires you to, firstly, open an SSH connection to the Jump host with your own credential and, secondly, from the inside of the Jump host, open a second SSH connection to the actual server you need to access with another account (usually a non-personal account which can be the user used to deploy and run your application).

Let's suppose that you work in a company like this and that you want to create an SSH tunnel to port 1521 of an Oracle Database Server which is only accessible from your application server. What you need to do is to create an SSH tunnel like this:

The following command creates this SSH tunnel via the Jump host (you will be prompted for the users' password):



$ ssh -v -N appusr@appserver -J myusr@jumphost -L 1521:dbserver:1521

With this command, you are tunneling the port 1521 of localhost to the port 1521 of dbserver.

In other words, you are firstly doing an SSH connection to jumphost with user myusr, then another SSH connection to appserver with user appusr, and finally forwarding port 1521 from localhost to dbserver.

This command is being executed in verbose mode (-v), which is useful for debugging, and not returning the shell prompt of the appserver but just forwarding the port (-N).

After this, you can then use your preferred SQL client tool to connect to the remote database server as if it was running on localhost:1521.

Changing a constant in Java at runtime (WHAT?!)

Claudio Higashi — Tue, 24 Mar 2020 20:08:55 +0000

When learning Java, you were told that constants can be created by using the final keyword and that the value (or the object reference) they hold can never be changed, otherwise, they wouldn't be known as constants, right?

That's almost true. In fact, you can change the value of a constant with the use of a technique called Reflection. With reflection, you are able to programmatically access and change information about fields, methods, and constructors of loaded classes at runtime.

In this example, we are changing the private constant AGE from 50 to 15:

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class ModifyConstant {
    public static void main(String[] args) throws Exception {
        OldPerson fakeYoungPerson = new OldPerson();
        changePrivateConstant(fakeYoungPerson, "AGE", 15);
        fakeYoungPerson.sayYourAge();
    }

    public static void changePrivateConstant(Object instance, String constantName, Object newValue) throws Exception {
        // gets the Field object which represents the constant
        Field field = instance.getClass().getDeclaredField(constantName);

        // need this because AGE is 'private'
        field.setAccessible(true);

        Field modifiers = field.getClass().getDeclaredField("modifiers");

        // need this because modifiers of any Field are 'private'
        modifiers.setAccessible(true);

        // this kind of removes the 'final' keyword.
        // it actually turns off the bit representing the 'final' modifier
        modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);

        // and now we are able to set the new value to the constant
        field.set(instance, newValue);
    }

}

class OldPerson {
    private static final Integer AGE = 50;

    public void sayYourAge() {
        System.out.println("I'm " + AGE + " yo only!");
    }
}

The resulting output after compiling and running this class is:

I'm 15 yo only!

Of course that changing a constant is a completely weird use case, although I think that might have caught your attention to this (right?). Nevertheless, reflection is a powerful technique that helps developers to create dynamically configurable components. You also need to be aware that reflection costs a lot in terms of performance, so use it wisely and only when really needed.

The last thing that I would like to mention, is that this particular example wouldn't work if the constant is of type String because of the Java String Constant Pool, but this is a different story which I will leave for later...