Writing Unit Test Using XUnit And Mocking Frameworks (NSubstitue/FakeItEasy)

Introduction

In this article, I will be explaining why unit testing is important and the challenges and problems that are faced during writing unit tests and how to use mocking frameworks like NSubstitue and FakeItEasy to Mock objects.

Why Unit Test?

In the programming world, unit testing is a software testing method by which individual units of source code are tested to determine whether they are suitable for use. A unit is the smallest testable software component. Usually, it performs a single organized function. A unit is small, so it is easier to design, execute, record, and analyze test results than for larger chunks of code. Defects revealed by a unit test are easy to find and relatively easy to fix. Unit testing is testing that is designed to verify individual modules (functions, classes, etc.) at a low level, to verify that module is behaving as specified.

Why is unit testing challenging?

Complex code
Code that is Coupled with Other classes
Code that accesses to External resource i.e. web service, data base object etc.

Good unit test characteristics

Atomic – Unit test must have small functionality to test.
Deterministic - Test should pass or fail not be inconclusive.
Repeatable – Test should pass consistently, if test fails without changing code then it is not repeatable.
Order Independent - Test should not run in any order to pass.
Fast - Unit test should be fast, if any test take ~1sec to run then it considers as too slow.
Easy to Set up.

Most common problem with UT

The most common problem of unit tests is dependency of objects to each other, method to test have dependency to first class and then first class has dependency to the other two classes as shown below, this is most common problem where you will end up creating mock classes for each dependent class. That is called hand rolled mocks.

Solution of this is to mock first and second class objects' return values.

Problems with Hand Rolled Mocking

You can still write unit tests without the need of any mocking framework; i.e. calling hand rolled mocking where you create mock classes of each dependent class to mock dependency, but it has its own disadvantages as mentioned below:

Fake Implementation of abstraction.
Create classes by hand.
Each Mock object adds more code and complexity.
Conditional check on Mock classes.
Interface changes.
Time/Maintenance of code.

What is FakeItEasy/NSubstitute?

A .NET dynamic framework for creating all types of fake objects which is designed for ease of use and compatibility with both C# and VB.NET.

Difference in Syntax of these two frameworks

What can be faked

Interfaces
Classes that

are not sealed,
are not static, and
have at least one public or protected constructor whose arguments FakeItEasy can construct or obtain

Delegates

Let's understand the syntax of both the framework and how to use it. I will be explaining one by one in detail. These are topics which are most commonly used during writing any unit test.

AAA Syntax
Verification/Asserts
Return Values
Parameters
Exceptions
Properties

To start with Unit test, I have created a small application for Addition and a max of two values which take two inputs and return the result, but the trick is this method also has some web service to post the data. Here, I will explain how to mock that web service and the result of it. Here is the sample code.

public interface IMathService
{
int Add(int a, int b);
void Add(int a, int b, out int c);
Task<int> Max(int a, int b);
}
public class MathInstance : IMathService
{
private readonly IWebService _webService;
public MathInstance() : this(null)
{
}
public MathInstance(IWebService webService)
{
_webService = webService;
}
public int Add(int a, int b)
{
return a + b;
}
public void Add(int a, int b, out int c) => c = a + b;
public async Task<int> Max(int a, int b)
{
var maxvalue = Math.Max(a, b);
await _webService.Post("https://unknowncaller.com", maxvalue, new CancellationToken());
return maxvalue;
}
}

public class WebService : IWebService
{
public async Task Post<T>(string uriString, T c, CancellationToken ct)
{
var client1 = new HttpClient();
var uri = new Uri(uriString);
client1.DefaultRequestHeaders.Accept.Clear();
var json = JsonConvert.SerializeObject(c);
var data = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client1.PostAsync(uri, data, ct);
ct.ThrowIfCancellationRequested();
response.EnsureSuccessStatusCode();
await response.Content.ReadAsStringAsync();
}
}

Lets start writing Unit tests of the above program.

Unit Tests Implementation using Xunit and Mocking Frameworks (FakeItEasy & NSubstitute)

I will be using xunit test framework to write unit tests, it uses Fact for a single test and Theory with (InlineData) to test multiple conditions in a single test.

AAA Syntax

A basic test of to demonstrate AAA Syntax.

[Fact]
public void AddTest()
{
// Arrange
var obj = new MathInstance();
// Act
var actualResult = obj.Add(3, 2);
// Assert
Assert.Equal(5, actualResult);
}

[Theory]
[InlineData(1, 2, 3)]
[InlineData(1, 13, 14)]
public void MultipleAddTest(int x, int y, int result)
{
}

Creation of Mock Object, passing parameters and faking return values.

Let's write a test for Max method where it uses web service to post the call of max value. We need mock web service here to post the fake value so that our test of max is executed without any interruption.

using FakeItEasy

[Fact]
public async void MaxTest()
{
// Arrange
var webservice = A.Fake<IWebService>(); // fake web service by using A.Fake<T>
var obj = new MathInstance(webservice);
A.CallTo(() => webservice.Post(A<string>._, A<int>._, A<CancellationToken>._)).Returns(Task.Delay(1)); // Params are passed A<T>._ or A<T>.Ignored
// Act
var actualResult = await obj.Max(2, 5);
// Assert
Assert.Equal(5, actualResult);
A.CallTo(() => webservice.Post(A<string>._, A<int>._, A<CancellationToken>._)).MustHaveHappened(); // Assert/verification of Mock object call
}

using NSubstitue

[Fact]
public async void MaxTest()
{
// Arrange
var webservice = Substitute.For<IWebService>(); // fake web service by using Substitute.For<T>()
var obj = new MathInstance(webservice);
webservice.Post(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<CancellationToken>()).Returns(Task.Delay(1)); // Params are passed Arg.Any<T>() or Arg.Is<T>()
// Act
var actualResult = await obj.Max(2, 5);
// Assert
Assert.Equal(5, actualResult);
await webservice.Received().Post(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<CancellationToken>()); // Assert/verification of Mock object call
}

Out Parameters

Using FakeItEasy

[Fact]
public void FakeAdd_OutPrams_Test()
{
// Arrange
int c = 0;
var obj = A.Fake<IMathService>();
A.CallTo(() => obj.Add(A<int>._, A<int>._, out c)).Invokes(() => c = 7); // faking Void method call and assign out params
// Act
obj.Add(3, 2, out _);
// Assert
Assert.Equal(7, c);
A.CallTo(() => obj.Add(A<int>._, A<int>._, out c)).MustHaveHappened();
A.CallTo(() => obj.Add(A<int>._, A<int>._)).MustNotHaveHappened();
}

Using NSubstitue

[Fact]
public void FakeAdd_OutPrams_Test()
{
// Arrange
var obj = Substitute.For<IMathService>();
obj.When(s => s.Add(Arg.Any<int>(), Arg.Any<int>(), out _)).Do(s => { s[2] = 7; }); // faking Void method call and assign out params
// Act
obj.Add(3, 2, out int result);
// Assert
Assert.Equal(7, result);
obj.ReceivedWithAnyArgs().Add(0, 0, out _);
obj.DidNotReceive().Add(Arg.Any<int>(), Arg.Any<int>());
}

Exception And Events

Let's add a new event in the IMathService interface to test this functionality.

event EventHandler<EventArgs> AddDone;

Using FakeItEasy

[Fact]
public void FakeAddTest_Exception()
{
// Arrange
var obj = A.Fake<IMathService>();
A.CallTo(() => obj.Add(A<int>._, A<int>._)).Throws<InvalidOperationException>();
// Act
Action actualResult = () => obj.Add(3, 2);
// Assert
Assert.Throws<InvalidOperationException>(actualResult);
}
[Fact]
public void FakeAddTest_Event()
{
// Arrange
var obj = A.Fake<IMathService>();
obj.AddDone += Raise.With(this, new EventArgs());
// Act
var actualResult = obj.Add(3, 2);
// Assert
Assert.Equal(5, actualResult);
}

using NSubstitute

[Fact]
public void FakeAddTest_Exception()
{
// Arrange
var obj = Substitute.For<IMathService>();
obj.Add(Arg.Any<int>(), Arg.Any<int>()).Throws<InvalidOperationException>();
// Act
Action actualResult = () => obj.Add(3, 2);
// Assert
Assert.Throws<InvalidOperationException>(actualResult);
}
[Fact]
public void FakeAddTest_Event()
{
// Arrange
var obj = Substitute.For<IMathService>();
obj.AddDone += Raise.EventWith(new EventArgs());
// Act
var actualResult = obj.Add(3, 2);
// Assert
Assert.Equal(5, actualResult);
}

Conclusion

Here, we learned the importance of Unit test and the challenges that are faced during UT and the disadvantage of the hand rolled model, we also learned how to mock objects using FakeItEasy and NSubstitue framework and mock return values, event and exceptions. Both frameworks are good in mocking generation with different syntax and work in a similar fashion. NSubstitute looks much cleaner in terms of lines of code. I hope you liked the article and learned something today. Happy learning. :)

3 Comments

Join the conversation! Your thoughts help the community grow.

Deepika6y ago
Nice Article Ashutosh, very well demonstrated, we are also looking for good mocking framework for our project and i will ask my team to refer this and decide on mocking framework if one of them suits of our project need.
- Ashutosh Gupta6y ago
  Thanks Deepika, good t hear that your team is looking something similar to this.. post me if you have any query.
Anand6y ago
Nice Article Ashutosh, very much useful for .net developer to write UT to use these mocking framework and follow TDD.