How to write unit test case for Dispose method - unit-testing

I want to cover my dispose method in unit test (using nunit framework), written inside repository
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
return;
if (disposing)
{
_bpRioCostCentreContext.Dispose();
}
_disposed = true;
}
~CostCentreRepository()
{
Dispose(false);
}

Related

Mock Method2 of Interface called in another method1

I am writing unit tests for Method1()
I want to mock Method2() that is called from Method1() of the same interface.
We can mock methods of another interface easily by taking that mocked implementation in the struct. But I'm not sure how to mock a method of the same interface.
type ISample interface {
Method1()
Method2()
}
type Sample struct {
}
func (s Sample) Method1() {
s.Method2()
}
func (s Sample) Method2() {
}

Can be solved by using an embedded interface.
type ISample interface {
Method1()
Method2()
}
type Sample struct {
ISample
}
func (s Sample) Method1() {
s.ISample.Method2()
}
func (s Sample) Method2() {
}
While creating an object of Sample, assign mocked ISample to ISample.

Google Test on a local function that calls another function

I have a class that I want to test.
class Myclass {
virtual int functionA (int x) {
if (x==1) {
functionB();
return 1;
}
else return 0;
}
virtual void functionB() {
// do some logic
functionC();
printf ("functionB \n"};
}
virtual void functionC() {
// do some logic
printf ("functionC \n"};
}
}
I setup a Mock class:
class MockMyClass : public Myclass {
MOCKMETHOD1(functionA, int(int x));
MOCKMETHOD0(functionB, void());
MOCKMETHOD0(functionC, void());
}
My test case in test class:
class MyTesting : public testing::Test {
virtual void SetUp(){
testObj = new MyClass();
testMock = new MockMyClass();
}
virtual void Teardown() {
delete testObj;
delete testMock;
}
}
MyClass * testObj;
MockMyClass * testMock;
TEST_F (MyClass, Test1){
EXPECT_CALL (testMock, functionB());
testObj->functionA()
}
TEST_F (MyClass, Test2){
EXPECT_CALL (testMock, functionC());
testObj->functionB()
}
TEST_F (MyClass, Test3){
EXPECT_CALL (testMock, functionC());
testObj->functionC()
}
Basically, I need to run the functionA -> functionB -> functionC.
How can write Test1 such that when have expect call of functionB, it doesn't "go further" into B and requires another expect call of function C.
In other words, how can write a Test1 such that whatever logic in functionB will be tested in Test2 and further in Test3 and Test1 just expect a call of functionB.

TEST_F (MyClass, Test1) {
InSequence seq;
EXPECT_CALL (MockMyClass, functionB());
EXPECT_CALL (MockMyClass, functionC());
testObj->functionA(1);
}
InSequence
Your example will not compile, functionA requires arg and missing semicolons.

Wrong use of inheritance is main problem here.
If your class under test is same as mock class then this should be obvious something wrong is here.
Note that here:
virtual void SetUp() {
testObj = new MyClass();
testMock = new MockMyClass();
}
there is no dependency between testObj and testMock. So Question is how testObje can impact state of testMock? It can't!
So basically problem is your code design of production code (code under test).
Since logic of this class has been obfuscated I have no clues how I could fix your code properly. I'm guessing it should be something like this:
class ISomeDependency {
public:
virtual int functionA(int x) = 0;
};
//---------
class Myclass {
public:
Myclass(ISomeDependency& dep)
: mDep { dep }
{
}
void functionB()
{
if (mDep.function(1) > 5) {
functionC();
}
}
void functionC()
{
}
private:
ISomeDependency& mDep;
};
class MyclassTest : public ::testing::Test {
void checkMyClassIsInStateX()
{
ASSERT_EQ(myClass.getX(), ...);
}
public:
MockSomeDependency mock;
Myclass myClass { mock };
};
TEST_F(MyclassTest, functionBCallsDependencyWithOneAndChangesStateToX)
{
EXPECT_CALL(mock, functionA(1)).WillOnce(Return(4));
myClass.functionB();
checkMyClassIsInStateX();
}

How to use Moq to Mock an internal class protected method?

I have classes below:
public class TestService
{
public void Upload()
{
var manager = new Manager();
var worker = manager.CreateWorker();
worker.DoWork();
}
}
public class Manager
{
public Worker CreateWork()
{
return new Worker();
}
}
public class Worker()
{
public void DoWork()
{
SetupEnvironment();
//some codes here...
}
protected virtual void SetupEnvironment()
{
//some codes here ...
}
}
I want to use Moq to create an unit test for Upload() method in TestService class, and SetupEnvironment() method of Worker should be mock up. I tried to the code below, but It doesnt' work:
[TestMethod]
public void Upload_Test()
{
var mockWorker = new Mock<Worker>();
mockWorker .Protected().Setup<string>("SetupEnvironment").Returns(() =>
{
//some dummy code here ...
});
var service = new TestService();
service.Upload();
Assert.IsTrue(true);
}
Anybody knows how to make the above unit test code work?

some things need to be changed. See the code of the class TestService and Worker below.
public class TestService
{
private readonly Manager _manager;
public TestService(Manager manager)
{
_manager = manager;
}
public void Upload()
{
var worker = _manager.CreateWorker();
worker.DoWork();
}
}
public class Manager
{
public virtual Worker CreateWorker()
{
return new Worker();
}
}
public class Worker
{
public void DoWork()
{
SetupEnvironment();
//some codes here...
}
protected virtual void SetupEnvironment()
{
//some codes here ...
}
}
Then the test could look like this. The method SetupEnvironment is void so the setup can't return any value and you need to mock the Manager as well and pass it to the TestService e.g. via constructor injection so you can inject your mock-object. HTH
[TestMethod]
public void Upload_Test()
{
bool setupEnvironmentWasCalled = false;
Mock<Worker> mockWorker = new Mock<Worker>();
mockWorker.Protected().Setup("SetupEnvironment")
.Callback(() =>
{
//some dummy code here ...
setupEnvironmentWasCalled = true;
});
Mock<Manager> mockManager = new Mock<Manager>();
mockManager.Setup(m => m.CreateWorker())
.Returns(mockWorker.Object);
var service = new TestService(mockManager.Object);
service.Upload();
Assert.IsTrue(setupEnvironmentWasCalled);
}

MOQ returning null. [mock concrete class method]

[using Moq]
I am trying to mock a concrete class and mock a virtual method "Get()" of that class. When testing a method "GetItemsNotNull()" I always get returned null, instead of the return of the mocked function.
Here is the code
//SomeClasses.cs
namespace MoQExamples
{
public abstract class Entity
{
}
public class Abc : Entity
{
}
public interface IRepository<T> where T : Entity
{
IQueryable<T> Get();
}
public class Repository<T> : IRepository<T> where T : Entity
{
private readonly ISession _session;
public Repository()
{
_session = null;
}
public Repository(ISession session)
{
_session = session;
}
protected ISession CurrentSession
{
get { return _session; }
}
public virtual IQueryable<T> Get()
{
return CurrentSession.Query<T>();
}
}
public interface IAbcRepository
{
Abc GetItemsNotNull();
}
public class AbcRepository : Repository<Abc>, IAbcRepository
{
public Abc GetItemsNotNull()
{
return Get().FirstOrDefault(abc => abc !=null);
}
}
}
and here are the test class
namespace MoQExamples
{
[TestFixture]
public class SomeClassesTest
{
private readonly Mock<AbcRepository> _abcRepositoryMock = new Mock<AbcRepository>(MockBehavior.Strict) { CallBase = true };
[SetUp]
public void SetupTest()
{
_abcRepositoryMock.Setup(x => x.Get()).Returns(Get);
}
public IQueryable<Abc> Get()
{
return (new List<Abc>() { new Abc() }) as IQueryable<Abc>;
}
[Test]
public void TestGetItemsNotNull()
{
Assert.IsNotNull(_abcRepositoryMock.Object.GetItemsNotNull());
}
}
}
the assert alays fails..instead of returning the SomeClassesTest.Get()
thanks for advance guys!

I suspect this is the problem:
return (new List<Abc>() { new Abc() }) as IQueryable<Abc>;
List<T> doesn't implement IQueryable<T>, so this will always return null. Call AsQueryable to convert it instead:
return new List<Abc>().AsQueryable();
As an aside, this is a reason to prefer casts over as in most situations: if you'd just cast to IQueryable<Abc>, you'd have received an exception at the line which was really causing the problem. You should only use as when it's not a bug for the conversion to "fail". An as operator should almost always be followed by a nullity test.
(Note that this behaviour in itself has nothing to do with mocking or Moq. It's just the behaviour of the as operator...)

What is the best way to unit-test SLF4J log messages?

I'm using slf4j and I want to unit test my code to make sure that warn/error log messages are generated under certain conditions. I'd rather these be strict unit tests, so I'd prefer not to have to pull up logging configuration from a file in order to test that the log messages are generated. The mocking framework I'm using is Mockito.

Create a test rule:
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.stream.Collectors;
public class LoggerRule implements TestRule {
private final ListAppender<ILoggingEvent> listAppender = new ListAppender<>();
private final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
#Override
public Statement apply(Statement base, Description description) {
return new Statement() {
#Override
public void evaluate() throws Throwable {
setup();
base.evaluate();
teardown();
}
};
}
private void setup() {
logger.addAppender(listAppender);
listAppender.start();
}
private void teardown() {
listAppender.stop();
listAppender.list.clear();
logger.detachAppender(listAppender);
}
public List<String> getMessages() {
return listAppender.list.stream().map(e -> e.getMessage()).collect(Collectors.toList());
}
public List<String> getFormattedMessages() {
return listAppender.list.stream().map(e -> e.getFormattedMessage()).collect(Collectors.toList());
}
}
Then use it:
#Rule
public final LoggerRule loggerRule = new LoggerRule();
#Test
public void yourTest() {
// ...
assertThat(loggerRule.getFormattedMessages().size()).isEqualTo(2);
}
----- JUnit 5 with Extension Oct 2021 -----
LogCapture:
public class LogCapture {
private ListAppender<ILoggingEvent> listAppender = new ListAppender<>();
LogCapture() {
}
public String getFirstFormattedMessage() {
return getFormattedMessageAt(0);
}
public String getLastFormattedMessage() {
return getFormattedMessageAt(listAppender.list.size() - 1);
}
public String getFormattedMessageAt(int index) {
return getLoggingEventAt(index).getFormattedMessage();
}
public LoggingEvent getLoggingEvent() {
return getLoggingEventAt(0);
}
public LoggingEvent getLoggingEventAt(int index) {
return (LoggingEvent) listAppender.list.get(index);
}
public List<LoggingEvent> getLoggingEvents() {
return listAppender.list.stream().map(e -> (LoggingEvent) e).collect(Collectors.toList());
}
public void setLogFilter(Level logLevel) {
listAppender.clearAllFilters();
listAppender.addFilter(buildLevelFilter(logLevel));
}
public void clear() {
listAppender.list.clear();
}
void start() {
setLogFilter(Level.INFO);
listAppender.start();
}
void stop() {
if (listAppender == null) {
return;
}
listAppender.stop();
listAppender.list.clear();
listAppender = null;
}
ListAppender<ILoggingEvent> getListAppender() {
return listAppender;
}
private Filter<ILoggingEvent> buildLevelFilter(Level logLevel) {
LevelFilter levelFilter = new LevelFilter();
levelFilter.setLevel(logLevel);
levelFilter.setOnMismatch(FilterReply.DENY);
levelFilter.start();
return levelFilter;
}
}
LogCaptureExtension:
public class LogCaptureExtension implements ParameterResolver, AfterTestExecutionCallback {
private Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
private LogCapture logCapture;
#Override
public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
return parameterContext.getParameter().getType() == LogCapture.class;
}
#Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
logCapture = new LogCapture();
setup();
return logCapture;
}
#Override
public void afterTestExecution(ExtensionContext context) {
teardown();
}
private void setup() {
logger.addAppender(logCapture.getListAppender());
logCapture.start();
}
private void teardown() {
if (logCapture == null || logger == null) {
return;
}
logger.detachAndStopAllAppenders();
logCapture.stop();
}
}
then use it:
#ExtendWith(LogCaptureExtension.class)
public class SomeTest {
#Test
public void sometest(LogCapture logCapture) {
// do test here
assertThat(logCapture.getLoggingEvents()).isEmpty();
}
// ...
}

For testing slf4j without relying on a specific implementation (such as log4j), you can provide your own slf4j logging implementation as described in this SLF4J FAQ. Your implementation can record the messages that were logged and then be interrogated by your unit tests for validation.
The slf4j-test package does exactly this. It's an in-memory slf4j logging implementation that provides methods for retrieving logged messages.

I think you could solve your problem with a custom appender. Create a test appender which implements the org.apache.log4j.Appender, and set your appender in the log4j.properties and load it when you execute test cases.
If you call back to the test harness from that appender you can check the logged messages

For JUnit 5, create an extension that implements the solution provided by andrew-feng above in Create a test rule:
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.slf4j.LoggerFactory;
import java.util.List;
import java.util.stream.Collectors;
public class LoggerExtension implements BeforeEachCallback, AfterEachCallback {
private final ListAppender<ILoggingEvent> listAppender = new ListAppender<>();
private final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
#Override
public void afterEach(ExtensionContext extensionContext) throws Exception {
listAppender.stop();
listAppender.list.clear();
logger.detachAppender(listAppender);
}
#Override
public void beforeEach(ExtensionContext extensionContext) throws Exception {
logger.addAppender(listAppender);
listAppender.start();
}
public List<String> getMessages() {
return listAppender.list.stream().map(e -> e.getMessage()).collect(Collectors.toList());
}
public List<String> getFormattedMessages() {
return listAppender.list.stream().map(e -> e.getFormattedMessage()).collect(Collectors.toList());
}
}
Then use it:
#RegisterExtension
public LoggerExtension loggerExtension = new LoggerExtension();
#Test
public void yourTest() {
// ...
assertThat(loggerExtension.getFormattedMessages().size()).isEqualTo(2);
}

A better test implementation of SLF4J that works really well in an environment with concurrent test execution is https://github.com/portingle/slf4jtesting
I've chimed in on a few discussion on slf4j log testing and the limitations of existing test approaches when it comes to concurrent test execution.
I decided to put my words into code and that git repo is the result.

Instead of mocking SLF4J you could place the important logging calls you need to test inside their own methods which you can mock more easily.
If you really want to mock SLF4J, I would bet you could create your own provider for it that would allow you to supply a mock logger from the SLF4J side instead of injecting one in your service objects.

Using slf4j-test can remove lot of workarounds discussed above
pom.xml
<dependency>
<groupId>uk.org.lidalia</groupId>
<artifactId>slf4j-test</artifactId>
<version>1.2.0</version>
</dependency>
Sample class
#Slf4j
public class SampleClass {
public void logDetails(){
log.info("Logging");
}
}
TestClass
import org.junit.Test;
import uk.org.lidalia.slf4jtest.TestLogger;
import uk.org.lidalia.slf4jtest.TestLoggerFactory;
import static java.util.Arrays.asList;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import static uk.org.lidalia.slf4jtest.LoggingEvent.info;
public class SampleClassTest {
TestLogger logger = TestLoggerFactory.getTestLogger(SampleClass.class);
#Test
public void testLogging(){
SampleClass sampleClass = new SampleClass();
//Invoke slf4j logger
sampleClass.logDetails();
assertThat(logger.getLoggingEvents(), is(asList(info("Logging"))));
}
}
Refer http://projects.lidalia.org.uk/slf4j-test/ for more details

Similar to #Zsolt, you can mock log4j Appender and set it on the Logger, then verify calls to Appender.doAppend(). This allows you to test without having to modify the real code.

Just use plain Mockito and some reflection logic to mock it:
// Mock the Logger
Logger mock = Mockito.mock(Logger.class);
// Set the Logger to the class you want to test.
// Since this is often a private static field you have to
// hack a little bit: (Solution taken from https://stackoverflow.com/a/3301720/812093)
setFinalStatic(ClassBeeingTested.class.getDeclaredField("log"), mock);
with setFinalStatic method beeing
public static void setFinalStatic(Field field, Object newValue) throws Exception {
field.setAccessible(true);
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
field.set(null, newValue);
}
Then just execute the to be tested code and verify - e.g. the following verifies that the Logger.warn method was called twice:
ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
Mockito.verify(mock,Mockito.atLeastOnce()).warn(argumentCaptor.capture());
List<String> allValues = argumentCaptor.getAllValues();
assertEquals(2, allValues.size());
assertEquals("myFirstExpectedMessage", allValues.get(0));
assertEquals("mySecondExpectedMessage", allValues.get(1));
Please note that setting the final fields via reflection does not work in all cases. I was for example not able to get it working if multiple testcases were trying to modify it.

You can try another library to support easy mocking slf4j loggers - slf4j-mock, your code cen be look as:
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.slf4j.Logger;
#RunWith(MockitoJUnitRunner.class)
public class JUnit4ExampleTest {
private static final String INFO_TEST_MESSAGE = "info log test message from JUnit4";
#Mock
Logger logger;
#InjectMocks
Example sut;
#Test
public void logInfoShouldBeLogged() {
// when
sut.methodWithLogInfo(INFO_TEST_MESSAGE);
// then
Mockito.verify(logger).info(INFO_TEST_MESSAGE);
Mockito.verifyNoMoreInteractions(logger);
}
}
As you see you don't need any special steps, in test code. You need only add dependency to library in your project.
More examples and instructions at:
https://www.simplify4u.org/slf4j-mock/

This solution has been mentioned already before in this groovy answer as well as in this comment, but as I don't see it as an answer itself, adding it here as a community wiki answer.
So JUnit5 solution using logback listappender:
import static org.assertj.core.api.Assertions.assertThat;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
public class LoggingTest {
private final ClassToTest sut = new ClassToTest();
private ListAppender<ILoggingEvent> listAppender;
#BeforeEach
void init() {
final var log = (Logger) LoggerFactory.getLogger(ClassToTest.class);
listAppender = new ListAppender<>();
listAppender.start();
log.addAppender(listAppender);
}
#Test
public void testLogging() {
sut.doSomethingThatLogs()
String message = listAppender.list.get(0).getFormattedMessage();
assertThat(message).contains("this message should be logged");
}
}

I have a new answer that I will post at the top in this post (My "old" answer is still at the bottom of this post) (At the time of writing my "old" answer was a "0", so no harm, no foul! )
Newer answer:
Here is the Gradle Package:
testImplementation 'com.portingle:slf4jtesting:1.1.3'
Maven Link:
https://mvnrepository.com/artifact/com.portingle/slf4jtesting
Germane Code:
(below imports and private method would go in MyTestClass(.java))
import static org.junit.Assert.assertNotNull;
import slf4jtest.LogLevel;
import slf4jtest.Settings;
import slf4jtest.TestLogger;
import slf4jtest.TestLoggerFactory;
#Test
public void myFirstTest() {
org.slf4j.Logger unitTestLogger = this.getUnitTestLogger();
ISomethingToTestObject testItem = new SomethingToTestObject (unitTestLogger);
SomeReturnObject obj = testItem.myMethod("arg1");
assertNotNull(wrapper);
/* now here you would find items in the unitTestLogger */
assertContains(unitTestLogger, LogLevel.DebugLevel, "myMethod was started");
}
// render nicer errors
private void assertContains(TestLogger unitTestLogger, LogLevel logLev, String expected) throws Error {
if (!unitTestLogger.contains(logLev, expected)) {
throw new AssertionError("expected '" + expected + "' but got '" + unitTestLogger.lines() + "'");
}
}
// render nicer errors
private void assertNotContains(TestLogger unitTestLogger, LogLevel logLev, String expected) throws Error {
if (unitTestLogger.contains(logLev, expected)) {
throw new AssertionError("expected absence of '" + expected + "' but got '" + unitTestLogger.lines() + "'");
}
}
private TestLogger getUnitTestLogger() {
TestLoggerFactory loggerFactory = Settings.instance()
.enableAll() // necessary as by default only ErrorLevel is enabled
.buildLogging();
TestLogger returnItem = loggerFactory.getLogger(MyTestClasss.class.getName());
assertNotNull(returnItem);
return returnItem;
}
============================= OLD ANSWER BELOW .. DO NOT USE================
Below is my previous answer. I changed my below code ... to use the above package after I discovered it (the above package).
So here is my method.
First, I allow the logger to be injected. But I provide a default as well:
```java
package com.mycompany.myproject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyCoolClass { //implements IMyCoolClass {
private static final String PROCESS_STARTED = "Process started. (key='%1$s')";
private final Logger logger;
public MyCoolClass() {
this(LoggerFactory.getLogger(MyCoolClass.class));
}
public MyCoolClass(Logger lgr) {
this.logger = lgr;
}
public doSomething(int key)
{
logger.info(String.format(PROCESS_STARTED, key));
/*now go do something */
}
}
Then I wrote a very basic in memory logger
```java
import org.slf4j.Marker;
import java.util.ArrayList;
import java.util.Collection;
public class InMemoryUnitTestLogger implements org.slf4j.Logger {
public Collection<String> informations = new ArrayList<String>();
public Collection<String> errors = new ArrayList<String>();
public Collection<String> traces = new ArrayList<String>();
public Collection<String> debugs = new ArrayList<>();
public Collection<String> warns = new ArrayList<>();
public Collection<String> getInformations() {
return informations;
}
public Collection<String> getErrors() {
return errors;
}
public Collection<String> getTraces() {
return traces;
}
public Collection<String> getDebugs() {
return debugs;
}
public Collection<String> getWarns() {
return warns;
}
#Override
public String getName() {
return "FakeLoggerName";
}
#Override
public boolean isTraceEnabled() {
return false;
}
#Override
public boolean isTraceEnabled(Marker marker) {
return false;
}
#Override
public boolean isDebugEnabled() {
return false;
}
#Override
public boolean isDebugEnabled(Marker marker) {
return false;
}
#Override
public boolean isWarnEnabled(Marker marker) {
return false;
}
#Override
public boolean isInfoEnabled(Marker marker) {
return false;
}
#Override
public boolean isWarnEnabled() {
return false;
}
#Override
public boolean isErrorEnabled(Marker marker) {
return false;
}
#Override
public boolean isInfoEnabled() {
return false;
}
#Override
public boolean isErrorEnabled() {
return false;
}
#Override
public void trace(String s) {
this.internalTrace(s);
}
#Override
public void trace(String s, Object o) {
this.internalTrace(s);
}
#Override
public void trace(String s, Object o, Object o1) {
this.internalTrace(s);
}
#Override
public void trace(String s, Object... objects) {
this.internalTrace(s);
}
#Override
public void trace(String s, Throwable throwable) {
this.internalTrace(s);
}
#Override
public void trace(Marker marker, String s) {
this.internalTrace(s);
}
#Override
public void trace(Marker marker, String s, Object o) {
this.internalTrace(s);
}
#Override
public void trace(Marker marker, String s, Object o, Object o1) {
this.internalTrace(s);
}
#Override
public void trace(Marker marker, String s, Object... objects) {
this.internalTrace(s);
}
#Override
public void trace(Marker marker, String s, Throwable throwable) {
this.internalTrace(s);
}
#Override
public void debug(String s) {
this.internalDebug(s);
}
#Override
public void debug(String s, Object o) {
this.internalDebug(s);
}
#Override
public void debug(String s, Object o, Object o1) {
this.internalDebug(s);
}
#Override
public void debug(String s, Object... objects) {
this.internalDebug(s);
}
#Override
public void debug(String s, Throwable throwable) {
this.internalDebug(s);
}
#Override
public void debug(Marker marker, String s) {
this.internalDebug(s);
}
#Override
public void debug(Marker marker, String s, Object o) {
this.internalDebug(s);
}
#Override
public void debug(Marker marker, String s, Object o, Object o1) {
this.internalDebug(s);
}
#Override
public void debug(Marker marker, String s, Object... objects) {
this.internalDebug(s);
}
#Override
public void debug(Marker marker, String s, Throwable throwable) {
this.internalDebug(s);
}
public void info(String s) {
this.internalInfo(s);
}
#Override
public void info(String s, Object o) {
this.internalInfo(s);
}
#Override
public void info(String s, Object o, Object o1) {
this.internalInfo(s);
}
#Override
public void info(String s, Object... objects) {
this.internalInfo(s);
}
#Override
public void info(String s, Throwable throwable) {
this.internalInfo(s);
}
#Override
public void info(Marker marker, String s) {
this.internalInfo(s);
}
#Override
public void info(Marker marker, String s, Object o) {
this.internalInfo(s);
}
#Override
public void info(Marker marker, String s, Object o, Object o1) {
this.internalInfo(s);
}
#Override
public void info(Marker marker, String s, Object... objects) {
this.internalInfo(s);
}
#Override
public void info(Marker marker, String s, Throwable throwable) {
this.internalInfo(s);
}
public void error(String s) {
this.internalError(s);
}
#Override
public void error(String s, Object o) {
this.internalError(s);
}
#Override
public void error(String s, Object o, Object o1) {
this.internalError(s);
}
#Override
public void error(String s, Object... objects) {
this.internalError(s);
}
#Override
public void error(String s, Throwable throwable) {
this.internalError(s);
}
#Override
public void error(Marker marker, String s) {
this.internalError(s);
}
#Override
public void error(Marker marker, String s, Object o) {
this.internalError(s);
}
#Override
public void error(Marker marker, String s, Object o, Object o1) {
this.internalError(s);
}
#Override
public void error(Marker marker, String s, Object... objects) {
this.internalError(s);
}
#Override
public void error(Marker marker, String s, Throwable throwable) {
this.internalError(s);
}
public void warn(String s) {
this.internalWarn(s);
}
#Override
public void warn(String s, Object o) {
this.internalWarn(s);
}
#Override
public void warn(String s, Object... objects) {
this.internalWarn(s);
}
#Override
public void warn(String s, Object o, Object o1) {
this.internalWarn(s);
}
#Override
public void warn(String s, Throwable throwable) {
this.internalWarn(s);
}
#Override
public void warn(Marker marker, String s) {
this.internalWarn(s);
}
#Override
public void warn(Marker marker, String s, Object o) {
this.internalWarn(s);
}
#Override
public void warn(Marker marker, String s, Object o, Object o1) {
this.internalWarn(s);
}
#Override
public void warn(Marker marker, String s, Object... objects) {
this.internalWarn(s);
}
#Override
public void warn(Marker marker, String s, Throwable throwable) {
this.internalWarn(s);
}
private void internalDebug(String s) {
System.out.println(s);
this.debugs.add(s);
}
private void internalInfo(String msg) {
System.out.println(msg);
this.informations.add(msg);
}
private void internalTrace(String msg) {
//??System.out.println(msg);
this.traces.add(msg);
}
private void internalWarn(String msg) {
System.err.println(msg);
this.warns.add(msg);
}
private void internalError(String msg) {
System.err.println(msg);
this.errors.add(msg);
}
Then in my unit tests, I can do one of two things:
private ByteArrayOutputStream setupSimpleLog(Logger lgr) {
ByteArrayOutputStream pipeOut = new ByteArrayOutputStream();
PrintStream pipeIn = new PrintStream(pipeOut);
System.setErr(pipeIn);
return pipeOut;
}
private Logger getSimpleLog() {
Logger lgr = new InMemoryUnitTestLogger();
return lgr;
}
private void myTest() {
Logger lgr = getSimpleLog();
ByteArrayOutputStream pipeOut = this.setupSimpleLog(lgr);
MyCoolClass testClass = new MyCoolClass(lgr);
int myValue = 333;
testClass.doSomething(myValue);
String findMessage = String.format(MyCoolClass.PROCESS_STARTED, myValue);
String output = new String(pipeOut.toByteArray());
assertTrue(output.contains(findMessage));
}
or similar to the above, but do a cast on the custom Logger
private void myTest() {
Logger lgr = getSimpleLog();
MyCoolClass testClass = new MyCoolClass(lgr);
int myValue = 333;
testClass.doSomething(myValue);
String findMessage = String.format(MyCoolClass.PROCESS_STARTED, myValue);
InMemoryUnitTestLogger castLogger = (InMemoryUnitTestLogger)lgr;
/* now check the exact subcollection for the message) */
assertTrue(castLogger.getInfos().contains(findMessage));
}
Take the code with a grain of salt, the ideas are there. I didn't compile the code.

I know it's been a while since this question was posted but I just came across a similar issue and my solution may help. Along the lines of the solution proposed by #Zsolt, we use an appender, more specifically Logback's ListAppender. Showing the code and configurations here (Groovy code but can be easily ported to Java):
Groovy class for log access:
import ch.qos.logback.classic.Logger
import ch.qos.logback.classic.spi.LoggingEvent
import ch.qos.logback.core.read.ListAppender
import org.slf4j.LoggerFactory
class LogAccess {
final static String DEFAULT_PACKAGE_DOMAIN = Logger.ROOT_LOGGER_NAME
final static String DEFAULT_APPENDER_NAME = 'LIST'
final List<LoggingEvent> list
LogAccess(String packageDomain = DEFAULT_PACKAGE_DOMAIN, String appenderName = DEFAULT_APPENDER_NAME) {
Logger logger = (Logger) LoggerFactory.getLogger(packageDomain)
ListAppender<LoggingEvent> appender = logger.getAppender(appenderName) as ListAppender<LoggingEvent>
if (appender == null) {
throw new IllegalStateException("'$DEFAULT_APPENDER_NAME' appender not found. Did you forget to add 'logback.xml' to the resources folder?")
}
this.list = appender.list
this.clear()
}
void clear() {
list.clear()
}
boolean contains(String logMessage) {
return list.reverse().any { it.getFormattedMessage() == logMessage }
}
#Override
String toString() {
list.collect { it. getFormattedMessage() }
}
}
Sample logback.xml config:
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- These 2 'includes' tags ensure regular springboot console logging works as usual -->
<!-- See https://docs.spring.io/spring-boot/docs/current/reference/html/howto.html#howto-configure-logback-for-logging -->
<include resource="org/springframework/boot/logging/logback/defaults.xml"/>
<include resource="org/springframework/boot/logging/logback/console-appender.xml" />
<appender name="LIST" class="ch.qos.logback.core.read.ListAppender"/>
<root level="INFO">
<appender-ref ref="CONSOLE" />
<appender-ref ref="LIST" />
</root>
</configuration>
Test:
LogAccess log = new LogAccess()
def expectedLogEntry = 'Expected Log Entry'
assert !log.contains(expectedLogEntry)
methodUnderTest()
assert log.contains(expectedLogEntry)
I use this in a SpringBoot project with Groovy+Spock, though I can't see why this wouldn't work in any Java project with Logback.

I tried using slf4j-test, but found, when running the test in eclipse, that I had several implementations of slf4j on the classpath, blocking slf4j-test. Their documentation (https://www.slf4j.org/codes.html#multiple_bindings) suggests some maven config that would sort out the test classpath when running tests via maven, but this didn't help me when running tests via eclipse.
In the end I implemented my own LogAppender (backed by a StringBuffer), attached that to my slf4j logger (provided by logback), and was able to write my test.
#Before
public void setUp() {
...
ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger) (LoggerFactory
.getLogger(AdviserDashboardExceptionHandler.class));
appender = new StringBufferAppender();
logger.addAppender(appender);
}
#After
public void clearLogger() {
appender.clear();
}
#Test
public void loggingTest() {
...
assertThat(appender.getOutput(), containsString("some expected text"));
}

I needed to get this to work without using ch.qos.logback because that was conflicting with the usage of log4j2 in my main classes.
Hat tip to https://codingcraftsman.wordpress.com/2015/04/28/log4j2-mocking-with-mockito-and-junit/ for showing how to do it.
The thing that made a difference for me was casting the logger in the mocks to the logger from org.apache.logging.log4j.core.Logger, I was able to add an appender to it and it didn't break the rest of my code.
Pasting his code here for answer completeness.
import java.io.IOException;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
#RunWith(MockitoJUnitRunner.class)
public class ExceptionLoggerTest {
#Mock
private Appender mockAppender;
private List<LogEvent> capturedEvents = new ArrayList<>();
private Logger logger;
#Before
public void setup() {
// prepare the appender so Log4j likes it
when(mockAppender.getName()).thenReturn("MockAppender");
when(mockAppender.isStarted()).thenReturn(true);
when(mockAppender.isStopped()).thenReturn(false);
// when append is called, convert the event to
// immutable and add it to the event list
doAnswer(answerVoid((LogEvent event) ->
capturedEvents.add(event.toImmutable()))
.when(mockAppender).append(any());
logger = (Logger)LogManager.getLogger(ExceptionLogger.class);
logger.addAppender(mockAppender);
logger.setLevel(Level.INFO);
}
#After /** as before */
#Test
public void loggingIsCaptured() {
logger.error("What an error");
verifyErrorMessages("What an error");
}
// inspecting messages involves just using the list of captured events
private void verifyErrorMessages(String ... messages) {
assertThat(capturedEvents.size(), is(messages.length));
int i=0;
for(LogEvent loggingEvent:capturedEvents) {
assertEquals(messages[i++],
loggingEvent.getMessage().getFormattedMessage());
}
}
}