Question

I have two interfaces called ITweetReq and ITweetResp.

An outside service sends Requests to send tweets when they come in, which is implemented by the interface ITweetReq and our system in return sends the reply back which is implemented in ITweetResp interface.

Both the incoming and outgoing messages are logged in a file. I have to unit test the log file to make sure it is logging the correct number of message received and replied.

I am wondering if I should mock both the interfaces then do a test on the log file, but not sure how to go about it. Any help or suggestion will be appreciated.

I am using NUnit and Moq Framework.

   var TweetReq = new Mock<ITweetReq>();
   var TweetRes = new Mock<ITweetRes>();

Answer 1

You seem a little confused as to what mocking/unit testing is.
Mocks are typically created for anything ‘outside’ of the class being tested.
Unit tests are run on your code (typically a method, or part of it).

You should write unit tests for the class which does the logging, by calling the methods which receive/reply to tweets with the mocked objects, and testing for the expected result.

It might be better if you mocked your logging class too, as testing files directly can become complicated and is not recommended.

For example, you might have these methods on your class.

public class TweetHandler
{
    public void Main()
    {
        ILogger logger = GetLogger();

        while (true)
        {
            ITweetReq request = GetNextRequest();

            ITweetRes response = HandleRequest(request, logger);

            SendResponse(response, logger);
        }
    }

    public ITweetRes HandleRequest(ITweetReq request, ILogger logger)
    {
        int id = request.Id;
        string text = request.Text;

        logger.Log("Received tweet " + id + " with text: " + text);

        return new TweetResponse(id, text);
    }

    public void SendResponse(ITweetRes response, ILogger logger)
    {
        logger.Log("Sending response to tweet: " + response.Id);
        Response(reponse);
    }
}

You can then write unit tests like this:

[TestMethod]
public void HandleRequest_ShouldLogIdAndText()
{
    // Arrange
    var handler = new TweetHandler();
    var mockRequest = new Mock<ITweetReq>();
    var mockLogger = new Mock<ILogger>();

    mockRequest.Setup(x => x.Id).Returns(10);
    mockRequest.Setup(x => x.Text).Returns("some text");

    // Act
    handler.HandleRequest(mockRequest, mockLogger);

    // Assert
    mockLogger.Verify(x => x.Log("Received tweet 10 with text: some text"));
}

[TestMethod]
public void SendResponse_ShouldLogId()
{
    // Arrange
    var handler = new TweetHandler();
    var mockResponse = new Mock<ITweetRes>();
    var mockLogger = new Mock<ILogger>();

    mockResponse.Setup(x => x.Id).Returns(20);

    // Act
    handler.SendReponse(mockResponse, mockLogger);

    // Assert
    mockLogger.Verify(x => x.Log("Sending response to tweet: 20"));
}