Test System.out with JUnit

Edit: see also the follow up article on how to Test log4j with JUnit if you’re interested in specifically testing log output.

Just occasionally, it can be useful to verify output to System.out in a unit test. For example, if you’re testing application logging or if you’re using log output to sense some other behaviour. It can be tricky to properly mock behaviour of System.out but fortunately, it is possible to test System.out with JUnit.

Here’s a simple Spring MVC Controller:

private Logger log = Logger.getLogger(SignupController.class);
@Autowired private UserDetailsManager userDetailsManager;
@Autowired private PasswordEncoder passwordEncoder;

@RequestMapping(value = CONTROLLER_URL, method = RequestMethod.POST)
public String signup(@Valid @ModelAttribute SignupForm signupForm, Errors errors) {

    if (errors.hasErrors()) {
        log.warn("Oh no! Signup failed as there are validation errors.");
        return null;
    }

    // Hash the password
    String hashedPassword = passwordEncoder.encode(signupForm.getPassword());

    // Create the account
    UserDetails userDetails = new User(signupForm.getName(), hashedPassword, ENABLED);
    userDetailsManager.createUser(userDetails);

    log.info("Success! Created new user " + userDetails.getUsername());

    return VIEW_SUCCESS;
}

Ignoring tests for the obvious behaviours here (method return value, password hashing and account creation), lets focus instead on testing the log output. We want to verify the results of the log.warn and log.info calls. Our options are:

1. Replace the Logger instance with a mock. This would be easier if it were injected (@Autowired) into the class but it’s still possible – Powermock can do this.
2. Replace System.out with a mock. Logger writes to console via System.out by default so if we can mock System.out, we can verify logging. This technique is shown below.

Replacing System.out with a mock

By default, System.out is a PrintStream, typically connected to the console. It can however be replaced with any other instance of PrintStream using System.setOut(PrintStream out). If we replace it with a PrintStream backed by a byte array, we can verify all writes to System.out by inspecting the byte array. Here’s an example of a test that uses this technique:

@RunWith(MockitoJUnitRunner.class)
public class SignupControllerTest {

    private static final String NAME = "smith";
    private static final String PASSWORD = "password";

    @InjectMocks private SignupController controller = new SignupController();

    private PrintStream sysOut;
    private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();

    @Before
    public void setUpStreams() {
        sysOut = System.out;
        System.setOut(new PrintStream(outContent));
    }

    @After
    public void revertStreams() {
        System.setOut(sysOut);
    }

    @Test
    public void testSuccessIsLogged() {
        SignupForm form = populateForm(NAME, PASSWORD);
        Errors noErrors = new DirectFieldBindingResult(form, "form");

        controller.signup(form, noErrors);

        assertThat(outContent.toString(), containsString("Success!"));
    }
}

Note that we maintain the original instance of System.out and put it back after the test is finished. This is required so that subsequent tests properly log to console rather than our byte array.

Using a JUnit @Rule

This technique is fine for a one-off test but will require copy and pasting of the @Before (setup) and @After (teardown) methods if it’s to be used in other tests. To make this technique reusable in other tests, we can use a JUnit @Rule. System.out is an external resource that needs to be set up before a test and torn down afterward so let’s sublcass JUnit’s ExternalResource class:

public class SystemOutResource extends ExternalResource {

    private PrintStream sysOut;
    private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();

    @Override
    protected void before() throws Throwable {
        sysOut = System.out;
        System.setOut(new PrintStream(outContent));
    }

    @Override
    protected void after() {
        System.setOut(sysOut);
    }

    public String asString() {
        return outContent.toString();
    }
}

This simplifies our test class which now looks like this:

@RunWith(MockitoJUnitRunner.class)
public class SignupControllerTest {

    private static final String NAME = "smith";
    private static final String PASSWORD = "password";

    @InjectMocks private SignupController controller = new SignupController();

    @Rule public SystemOutResource sysOut = new SystemOutResource();

    @Test
    public void testSuccessIsLogged() {
        SignupForm form = populateForm(NAME, PASSWORD);
        Errors noErrors = new DirectFieldBindingResult(form, "form");

        controller.signup(form, noErrors);

        assertThat(sysOut.asString(), containsString("Success!"));
    }
}

The test code for these examples is in GitHub:

• SignupControllerTest showing redirect of System.out
• SystemOutResource rule
• SignupControllerTest showing use of the SystemOutRule