RESTful Day Eight: Unit Testing And Integration Testing in WebAPI Using NUnit And Moq framework: Part Two

Table of Contents

  • Introduction
  • Roadmap
  • Setup Solution
  • Testing WebAPI

      Step 1: Test Project
      Step 2: Install NUnit package
      Step 3: Install Moq framework
      Step 4: Install Entity Framework
      Step 5: Newtonsoft.Json
      Step 6: References

  • ProductController Tests

    • Tests Setup
    • Declare variables
    • Write Test Fixture Setup
    • Write Test Fixture Tear Down
    • Write Test Tear down
    • Mocking Repository
    • GetAllProductsTest ()
    • GetProductByIdTest ()
    • Testing Exceptions from WebAPI
    • GetProductByWrongIdTest ()
    • GetProductByInvalidIdTest ()
    • CreateProductTest ()
    • UpdateProductTest ()
    • DeleteProductTest ()
    • DeleteInvalidProductTest ()
    • DeleteProductWithWrongIdTest ()
    • Integration Tests
    • Difference between Unit tests and Integration tests
    • Conclusion


In my last article I explained how to write unit tests for business service layer. In this article we’ll learn  how to write unit tests for WebAPI controllers i.e. REST’s actual endpoints. I’ll use NUnit and Moq framework to write test cases for controller methods. I have already explained about installing NUnit and configuring unit tests. My last article also covered explaining about NUnit attributes used in writing unit tests. Please go through my last article of the series before following this article.


The following is the roadmap I have setup to learn WebAPI step by step,


I’ll purposely use Visual Studio 2010 and .net Framework 4.0 because there are few implementations that are very hard to find in .Net Framework 4.0, but I’ll make it easy by showing how we can do it.

Setup Solution

When you take the code base from my last article and open it in visual studio, you’ll see the project structure something like as shown in the below image,

Setup Solution

The solution contains the WebAPI application and related projects. There are two newly added projects namedBusinessServices.Tests and TestHelper.We’ll use TestHelper project and its classes for writing WebAPI unit tests in the same way we used it for writing business services unit tests.

Testing WebAPI

Step 1: Test Project

Add a simple class library in the existing visual studio and name it ApiController.Tests. Open Tools->Library Packet Manager->Packet manager Console to open the package manager console window. We need to install same packages as we did for business services before we proceed.

Library Packet Manager

Step 2: Install NUnit package.

In package manager console, select ApiController.Tests as default project and write command “Install-Package NUnit –Version 2.6.4”. When you run the command, it says NUnit is already installed, that’s because we installed this package for BusinessServices.Tests project, but doing this again for a new project (in our case it is ApiController.Tests) will not install it again but add a reference to nunitframework library and mark an entry in packages.config for ApiController. Tests project.

Install NUnit package

After it's  successfully installed, you can see the dll reference in project references i.e. nunit.framework,

Step 3: Install Moq framework

Install the framework on the same project in the similar way as explained in Step 2. Write command “Install-Package Moq”.

Install-Package Moq

Step 4: Install Entity Framework

Install-Package EntityFramework–Version 5.0.0

Install Entity Framework

Step 5: Newtonsoft.Json

Json.NET is a popular high-performance JSON framework for .NET. We’ll use it for serializing/de-serializing request and responses.

Install-Package Newtonsoft.Json -Version 4.5.11


Our packages.config i.e. automatically added in the project looks like,

  1. <?xmlversion="1.0"encoding="utf-8"?>  
  2.     <packages>  
  3.         <packageid="EntityFramework" version="5.0.0" targetFramework="net40" />  
  4.         <packageid="Moq" version="4.2.1510.2205" targetFramework="net40" />  
  5.         <packageid="Newtonsoft.Json" version="4.5.11" targetFramework="net40" />  
  6.         <packageid="NUnit" version="2.6.4" targetFramework="net40" />   
  7.     </packages>  
Step 6: References

Add references of BusinessEntities, BusinessServices, DataModel, TestsHelper, WebApi project to this project.



We’ll start with setting up the project and setting up the pre-requisites for tests and gradually move on to actual tests.

Tests Setup

Add a new class named ProductControllerTest.csin ApiController.Testsproject.

Declare variables

Define the private variables that we’ll use in the class to write tests,
  1. #region Variables  
  2.     private IProductServices _productService;  
  3.     private ITokenServices _tokenService;  
  4.     private IUnitOfWork _unitOfWork;  
  5.     private List<Product> _products;  
  6.     private List<Token> _tokens;  
  7.     private GenericRepository<Product> _productRepository;  
  8.     private GenericRepository<Token> _tokenRepository;  
  9.     private WebApiDbEntities _dbEntities;  
  10.     private HttpClient _client;  
  11.     private HttpResponseMessage _response;  
  12.     private string _token;  
  13.     private const string ServiceBaseURL = "http://localhost:50875/";  
  14. #endregion 
Variable declarations are self-explanatory where _productService will hold mock for ProductServices, _tokenService will hold mock for TokenServices, _unitOfWork for UnitOfWork class, _products will hold dummy products from DataInitializer class of TestHelper project, __tokens will hold dummy tokens from DataInitializer class of TestHelper project ,_productRepository, tokenRepositoryand _dbEntities holds mock for Product Repository ,Token Repository and WebAPIDbEntities from DataModel project respectively.

Since WebAPI is supposed to return response in HttpResponse format so _response is declared to store the returned response against which we can assert._token holds the token value after successful authentication._client and ServiceBaseURL may not be required in this article’s context, but you can use them to write integration tests that purposely uses actual API URL’s and test on actual database.

Write Test Fixture Setup

Write test fixture setup method with [TestFixtureSetUp] attribute at the top, this method runs only one time when tests are executed.
  1. [TestFixtureSetUp]  
  2. public void Setup()  
  3. {  
  4.     _products = SetUpProducts();  
  5.     _tokens = SetUpTokens();  
  6.     _dbEntities = new Mock<WebApiDbEntities>().Object;  
  7.     _tokenRepository = SetUpTokenRepository();  
  8.     _productRepository = SetUpProductRepository();  
  9.     var unitOfWork = new Mock<IUnitOfWork>();  
  10.     unitOfWork.SetupGet(s => s.ProductRepository).Returns(_productRepository);  
  11.     unitOfWork.SetupGet(s => s.TokenRepository).Returns(_tokenRepository);  
  12.     _unitOfWork = unitOfWork.Object;  
  13.     _productService = new ProductServices(_unitOfWork);  
  14.     _tokenService = new TokenServices(_unitOfWork);  
  15.     _client = new HttpClient { BaseAddress = new Uri(ServiceBaseURL) };  
  16.     var tokenEntity = _tokenService.GenerateToken(1);  
  17.     _token = tokenEntity.AuthToken;  
  18.     _client.DefaultRequestHeaders.Add("Token", _token);  
  19. } 
The purpose of this method is similar to that of method we wrote for business services.hereSetupProducts() will fetch the list of dummy products and SetupTokens() will get the list of dummy tokens. We will try to setup mock for Token and Product repository as well, and after that mock UnitOfWork and set it up against already mocked token and product repository._prdouctService and _tokenService are the instances of ProductService and TokenService respectively, both initialized with mocked Unit of Work.

Following is the line of code that I would like to explain more,
  1. var tokenEntity = _tokenService.GenerateToken(1);  
  2. _token = tokenEntity.AuthToken;  
  3. _client.DefaultRequestHeaders.Add("Token", _token); 
In the above code we are initializing the _client i.e. HttpClient with Token value in request header. We are doing this because, if you remember about the security (Authentication and Authorization) we implemented in Product Controller, which says no request will be entertained unless it is authorized i.e. contains an authentication token in its header. So here we generate the token via TokenService’s GenerateToken() method, passing a default used id as “1”, and use that token for authorization. We require this only to perform integration testing as for unit tests we would directly be calling controller methods from our unit tests methods, but for actual integration tests you’ll have to mock all pre-conditions before calling an API endpoint.

  1. private static List<Product> SetUpProducts()  
  2. {  
  3.      var prodId = new int();  
  4.      var products = DataInitializer.GetAllProducts();  
  5.      foreach (Product prod in products)  
  6.          prod.ProductId = ++prodId;  
  7.      return products;  
  8. } 
  1. private static List<Token> SetUpTokens()  
  2. {  
  3.     var tokId = new int();  
  4.     var tokens = DataInitializer.GetAllTokens();  
  5.     foreach (Token tok in tokens)  
  6.         tok.TokenId = ++tokId;  
  7.     return tokens;  
  8. } 
Write Test Fixture Tear Down

Unlike [TestFixtureTearDown]t ear down is used to de-allocate or dispose the objects.

Following is the code for teardown.
  1. [TestFixtureTearDown]  
  2. public void DisposeAllObjects()  
  3. {  
  4.     _tokenService = null;  
  5.     _productService = null;  
  6.     _unitOfWork = null;  
  7.     _tokenRepository = null;  
  8.     _productRepository = null;  
  9.     _tokens = null;  
  10.     _products = null;  
  11.     if (_response != null)  
  12.         _response.Dispose();  
  13.     if (_client != null)  
  14.         _client.Dispose();  
  15. } 
Write Test Setup

In this case Setup is only required if you write integration test. So you can choose to omit this.
  1. [SetUp]  
  2. public void ReInitializeTest()  
  3. {  
  4.      _client = new HttpClient { BaseAddress = new Uri(ServiceBaseURL) };  
  5.      _client.DefaultRequestHeaders.Add("Token", _token);  
  6. }  
Write Test Tear down

Test [TearDown] is invoked after every test execution is complete.
  1. [TearDown]  
  2. public void DisposeTest()  
  3. {  
  4.     if (_response != null)  
  5.         _response.Dispose();  
  6.     if (_client != null)  
  7.         _client.Dispose();  
  8. } 
Mocking Repository

I have created a method SetUpProductRepository() to mock Product Repository and assign it to _productrepository in ReInitializeTest() method and SetUpTokenRepository() to mock TokenRepository and assign that to _tokenRepository in ReInitializeTest() method.

  1. private GenericRepository<Product> SetUpProductRepository()  
  2. {  
  3.     // Initialise repository  
  4.     var mockRepo = new Mock<GenericRepository<Product>>(MockBehavior.Default, _dbEntities);  
  6.     // Setup mocking behavior  
  7.     mockRepo.Setup(p => p.GetAll()).Returns(_products);  
  9.     mockRepo.Setup(p => p.GetByID(It.IsAny<int>()))  
  10.     .Returns(new Func<int, Product>(  
  11.     id => _products.Find(p => p.ProductId.Equals(id))));  
  13.     mockRepo.Setup(p => p.Insert((It.IsAny<Product>())))  
  14.     .Callback(new Action<Product>(newProduct =>  
  15.     {  
  16.     dynamic maxProductID = _products.Last().ProductId;  
  17.     dynamic nextProductID = maxProductID + 1;  
  18.     newProduct.ProductId = nextProductID;  
  19.     _products.Add(newProduct);  
  20.     }));  
  22.     mockRepo.Setup(p => p.Update(It.IsAny<Product>()))  
  23.     .Callback(new Action<Product>(prod =>  
  24.     {  
  25.     var oldProduct = _products.Find(a => a.ProductId == prod.ProductId);  
  26.     oldProduct = prod;  
  27.     }));  
  29.     mockRepo.Setup(p => p.Delete(It.IsAny<Product>()))  
  30.     .Callback(new Action<Product>(prod =>  
  31.     {  
  32.     var productToRemove =  
  33.     _products.Find(a => a.ProductId == prod.ProductId);  
  35.     if (productToRemove != null)  
  36.     _products.Remove(productToRemove);  
  37.     }));  
  39.     // Return mock implementation object  
  40.     return mockRepo.Object;  
  41. } 
  1. private GenericRepository<Token> SetUpTokenRepository()  
  2. {  
  3.     // Initialise repository  
  4.     var mockRepo = new Mock<GenericRepository<Token>>(MockBehavior.Default, _dbEntities);  
  6.     // Setup mocking behavior  
  7.     mockRepo.Setup(p => p.GetAll()).Returns(_tokens);  
  9.     mockRepo.Setup(p => p.GetByID(It.IsAny<int>()))  
  10.     .Returns(new Func<int, Token>(  
  11.     id => _tokens.Find(p => p.TokenId.Equals(id))));  
  13.     mockRepo.Setup(p => p.Insert((It.IsAny<Token>())))  
  14.     .Callback(new Action<Token>(newToken =>  
  15.     {  
  16.     dynamic maxTokenID = _tokens.Last().TokenId;  
  17.     dynamic nextTokenID = maxTokenID + 1;  
  18.     newToken.TokenId = nextTokenID;  
  19.     _tokens.Add(newToken);  
  20.     }));  
  22.     mockRepo.Setup(p => p.Update(It.IsAny<Token>()))  
  23.     .Callback(new Action<Token>(token =>  
  24.     {  
  25.     var oldToken = _tokens.Find(a => a.TokenId == token.TokenId);  
  26.     oldToken = token;  
  27.     }));  
  29.     mockRepo.Setup(p => p.Delete(It.IsAny<Token>()))  
  30.     .Callback(new Action<Token>(prod =>  
  31.     {  
  32.     var tokenToRemove =  
  33.     _tokens.Find(a => a.TokenId == prod.TokenId);  
  35.     if (tokenToRemove != null)  
  36.     _tokens.Remove(tokenToRemove);  
  37.     }));  
  39.     // Return mock implementation object  
  40.     return mockRepo.Object;  
  41. }  
Unit Tests

Unit Tests

All set now, and we are ready to write unit tests for ProductController. We’ll write a test to perform all the CRUD operations and all the action exit points that are part of ProductController.

1. GetAllProductsTest ()

Our ProductService in BusinessServices project contains a method named GetAllProducts (), following is the implementation,
  1. [Test]  
  2. public void GetAllProductsTest()  
  3. {  
  4.     var productController = new ProductController(_productService)  
  5.         {  
  6.         Request = new HttpRequestMessage  
  7.             {  
  8.             Method = HttpMethod.Get,  
  9.             RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/all")  
  10.             }  
  11.         };  
  12.     productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  14.     _response = productController.Get();  
  16.     var responseResult = JsonConvert.DeserializeObject<List<Product>>(_response.Content.ReadAsStringAsync().Result);  
  17.     Assert.AreEqual(_response.StatusCode, HttpStatusCode.OK);  
  18.     Assert.AreEqual(responseResult.Any(), true);  
  19.     var comparer = new ProductComparer();  
  20.     CollectionAssert.AreEqual(  
  21.     responseResult.OrderBy(product => product, comparer),  
  22.     _products.OrderBy(product => product, comparer), comparer);  
  23. } 
Let me explain the code step by step. We start code by creating an instance of ProductController and initialize the Request property of controller with a   new request message stating calling http method as GET and initialize the RequestUri with base hosted service URL and appended with actual end point of the method. Initializing RequestUri is not necessary in this case but will help you if you test actual service end point. In this case we are not testing actual endpoint but the direct controller method.

HttpPropertyKeys.HttpConfigurationKey, newHttpConfiguration() line adds default httpconfiguration to HttpConfigurationKey necessary for controller instance instantiation.

_response = productController.Get();line calls the Get() method of controller that fetches all the products from dummy _products list. Since the return type of the method was an http response message, we need to parse it to get the JSON result sent from the method. All the transactions from API’s should ideally happen in form of JSON or XML only.This helps client to understand the response and its result set. We de-serialize the object we got from _response using NewtonSoft library into a list of products. That means the JSON response is converted to List<Product> for better accessibility and comparison. Once done with JSON to List object conversion, I have put three asserts to test the result.
Assert.AreEqual(_response.StatusCode, HttpStatusCode.OK); line checks the http status code of the response, the expected is HttpStatusCode.OK.

Second assert i.e. Assert.AreEqual(responseResult.Any(), true); checks that we have got the items in the list or not. Third assert is the actual confirmation assert for our test that compares each product from the actual product list to the returned product list.


We got both the list, and we need to check the comparison of the lists, I just pressed F5 and got the result on TestUI as,

result on TestUI

This shows our test is passed, i.e. the expected and returned result is same.

2. GetProductByIdTest()

This unit test verifies if the correct result is returned if we try to invoke GetProductById() method of product controller.
  1. [Test]  
  2. public void GetProductByIdTest()  
  3. {  
  4.     var productController = new ProductController(_productService)  
  5.     {  
  6.     Request = new HttpRequestMessage  
  7.     {  
  8.     Method = HttpMethod.Get,  
  9.     RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/productid/2")  
  10.     }  
  11.     };  
  12.     productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  14.     _response = productController.Get(2);  
  16.     var responseResult = JsonConvert.DeserializeObject<Product>(_response.Content.ReadAsStringAsync().Result);  
  17.     Assert.AreEqual(_response.StatusCode, HttpStatusCode.OK);  
  18.     AssertObjects.PropertyValuesAreEquals(responseResult,  
  19.     _products.Find(a => a.ProductName.Contains("Mobile")));  
I have used a sample product id “2” to test the method. Again we get the result in JSON format inside HttpResponse that we de-serialize. First assert compares for the status code and second assert makes use of AssertObject class to compare the properties of the returned product with the actual “mobile” named product having product id as 2 from the list of products.



Testing Exceptions from WebAPI

NUnit provides flexibility to even test the exceptions. Now if we want to unit test the alternate exit point for GetProductById() method i.e. an exception what should we do? Remember it was easy to test the alternate exit point for business services method because it returned null. Now in the case of exception, NUnit provides an attribute ExpectedException. We can define the type of exception expected to be returned from the method call. Like if I make a call to the same method with wrong id, the expectation is that it should return an exception with ErrorCode 1001 and an error description telling "No product found for this id.".

So in our case the expected exception type is ApiDataException(got it from controller method). Therefore we can define the Exception attribute as [ExpectedException("WebApi.ErrorHelper.ApiDataException")] and call the controller method with wrong id. But there is an alternate way to assert the exception. NUnit also provides us flexibility to assert the exception by Assert.Throws. This statement asserts the exception and returns that particular exception to the caller.Once we get that particular exception we can assert it with its ErrorCode and ErrorDescription or on whatever property you want to.

3. GetProductByWrongIdTest()
  1. [Test]  
  2. //[ExpectedException("WebApi.ErrorHelper.ApiDataException")]  
  3. public void GetProductByWrongIdTest()  
  4. {  
  5.     var productController = new ProductController(_productService)  
  6.     {  
  7.         Request = new HttpRequestMessage  
  8.         {  
  9.             Method = HttpMethod.Get,  
  10.             RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/productid/10")  
  11.         }  
  12.     };  
  13.     productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  15.     var ex = Assert.Throws<ApiDataException>(() => productController.Get(10));  
  16.     Assert.That(ex.ErrorCode,Is.EqualTo(1001));  
  17.     Assert.That(ex.ErrorDescription, Is.EqualTo("No product found for this id."));  
  19. } 
In the above code, I have commented out the Exception attribute approach and followed the alternate one.

I called the method with wrong id (that does not exist in our product list) in the statement,
  1. var ex = Assert.Throws<ApiDataException>(() =>productController.Get(10));  
The above statement expects ApiDataException and stores the returned exception in “ex”.

Now we can assert the “ex” exception properties like ErrorCode and ErrorDescription with the actual desired result.



4. GetProductByInvalidIdTest ()

Another exit point for the same method is that if request for a product comes with an invalid it then an exception is thrown. Let’s test that method for this scenario,
  1. [Test]  
  2. // [ExpectedException("WebApi.ErrorHelper.ApiException")]  
  3. public void GetProductByInvalidIdTest()  
  4. {  
  5.      var productController = new ProductController(_productService)  
  6.      {  
  7.          Request = new HttpRequestMessage  
  8.          {  
  9.              Method = HttpMethod.Get,  
  10.              RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/productid/-1")  
  11.          }  
  12.      };  
  13.      productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  15.      var ex = Assert.Throws<ApiException>(() => productController.Get(-1));  
  16.      Assert.That(ex.ErrorCode, Is.EqualTo((int)HttpStatusCode.BadRequest));  
  17.      Assert.That(ex.ErrorDescription, Is.EqualTo("Bad Request..."));  
  18. } 
I passed an invalid id i.e. -1 to the controller method and it throws an exception of type ApiException with ErrorCode equal to HttpStatusCode.BadRequest and ErrorDescription equal to “bad Request…”.

bad Request

Test result,

i.e. Passed. Other tests are very much of same kind like I explained.

5. CreateProductTest ()
  1. /// <summary>  
  2. /// Create product test  
  3. /// </summary>  
  4. [Test]  
  5. public void CreateProductTest()  
  6. {  
  7.     var productController = new ProductController(_productService)  
  8.     {  
  9.         Request = new HttpRequestMessage  
  10.         {  
  11.             Method = HttpMethod.Post,  
  12.             RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/Create")  
  13.         }  
  14.     };  
  15.     productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  17.     var newProduct = new ProductEntity()  
  18.     {  
  19.         ProductName = "Android Phone"  
  20.     };  
  22.     var maxProductIDBeforeAdd = _products.Max(a => a.ProductId);  
  23.     newProduct.ProductId = maxProductIDBeforeAdd + 1;  
  24.     productController.Post(newProduct);  
  25.     var addedproduct = new Product() { ProductName = newProduct.ProductName, ProductId = newProduct.ProductId };  
  26.     AssertObjects.PropertyValuesAreEquals(addedproduct, _products.Last());  
  27.     Assert.That(maxProductIDBeforeAdd + 1, Is.EqualTo(_products.Last().ProductId));  
  28. }  
6. UpdateProductTest ()
  1. /// <summary>  
  2. /// Update product test  
  3. /// </summary>  
  4. [Test]  
  5. public void UpdateProductTest()  
  6. {  
  7.     var productController = new ProductController(_productService)  
  8.     {  
  9.         Request = new HttpRequestMessage  
  10.         {  
  11.             Method = HttpMethod.Put,  
  12.             RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/Modify")  
  13.         }  
  14.     };  
  15.     productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  17.     var firstProduct = _products.First();  
  18.     firstProduct.ProductName = "Laptop updated";  
  19.     var updatedProduct = new ProductEntity() { ProductName = firstProduct.ProductName, ProductId = firstProduct.ProductId };  
  20.     productController.Put(firstProduct.ProductId, updatedProduct);  
  21.     Assert.That(firstProduct.ProductId, Is.EqualTo(1)); // hasn't changed  
  22. } 
7. DeleteProductTest ()
  1. /// <summary>  
  2. /// Delete product test  
  3. /// </summary>  
  4. [Test]  
  5. public void DeleteProductTest()  
  6. {  
  7.     var productController = new ProductController(_productService)  
  8.     {  
  9.         Request = new HttpRequestMessage  
  10.         {  
  11.             Method = HttpMethod.Put,  
  12.             RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/Remove")  
  13.         }  
  14.     };  
  15.     productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  17.     int maxID = _products.Max(a => a.ProductId); // Before removal  
  18.     var lastProduct = _products.Last();  
  20.     // Remove last Product  
  21.     productController.Delete(lastProduct.ProductId);  
  22.     Assert.That(maxID, Is.GreaterThan(_products.Max(a => a.ProductId))); // Max id reduced by 1  
  23. } 
8. DeleteInvalidProductTest ()
  1. /// <summary>  
  2. /// Delete product test with invalid id  
  3. /// </summary>  
  4. [Test]  
  5. public void DeleteProductInvalidIdTest()  
  6. {  
  7.     var productController = new ProductController(_productService)  
  8.     {  
  9.         Request = new HttpRequestMessage  
  10.         {  
  11.             Method = HttpMethod.Put,  
  12.             RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/remove")  
  13.         }  
  14.     };  
  15.     productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  17.     var ex = Assert.Throws<ApiException>(() => productController.Delete(-1));  
  18.     Assert.That(ex.ErrorCode, Is.EqualTo((int)HttpStatusCode.BadRequest));  
  19.     Assert.That(ex.ErrorDescription, Is.EqualTo("Bad Request..."));  
  20. } 
9. DeleteProductWithWrongIdTest ()
  1. /// <summary>  
  2. /// Delete product test with wrong id  
  3. /// </summary>  
  4. [Test]  
  5. public void DeleteProductWrongIdTest()  
  6. {  
  7.     var productController = new ProductController(_productService)  
  8.     {  
  9.         Request = new HttpRequestMessage  
  10.         {  
  11.             Method = HttpMethod.Put,  
  12.             RequestUri = new Uri(ServiceBaseURL + "v1/Products/Product/remove")  
  13.         }  
  14.     };  
  15.     productController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());  
  17.     int maxID = _products.Max(a => a.ProductId); // Before removal  
  19.     var ex = Assert.Throws<ApiDataException>(() => productController.Delete(maxID+1));  
  20.     Assert.That(ex.ErrorCode, Is.EqualTo(1002));  
  21.     Assert.That(ex.ErrorDescription, Is.EqualTo("Product is already deleted or not exist in system."));  
  22. } 
All the above mentioned tests are self-explanatory and are more like how we tested BusinessServices. The idea was to explain how we write tests in WebAPI.Let’s run all the tests through NUnit UI.

Test through NUnit UI

NUnit UI

Step 1: Launch NUnit UI. I have already explained how to install NUnit on the windows machine. Just launch the NUnit interface with its launch icon,


Step 2: Once the interface opens, click on File -> New Project and name the project as WebAPI.nunit and save it at any windows location.

New Project



Step 3: Now, click on Project-> Add Assembly and browse for ApiController.Tests.dll (The library created for your unit test project when compiled)



Step 4: Once the assembly is browsed, you’ll see all the unit tests for that test project gets loaded in the UI and are visible on the interface.

tests of Api controller

At the right hand side panel of the interface, you’ll see a Run button that runs all the tests of Api controller. Just select the node ApiController in the tests tree on left side and press Run button on the right side.


Once you run the tests, you’ll get green progress bar on right side and tick mark on all the tests on left side. That means all the tests are passed.In case any test fails, you’ll get cross mark on the test and red progress bar on right side.


But here, all of our tests are passed.


Integration Tests

I’ll give just an idea of what integration tests are and how can we write it. Integration test doesn’t run in memory. For WebAPI’s the best practice to write integration test is when the WebAPI is self hosted.You can try writing an integration test when you host an API, so that you you get an actual URL or endpoint of the service you want to test.The test is performed on actual data and actual services. Let’s proceed with an example. I have hosted my web api and I want to test GetAllProducts() method of WebAPI.My hosted URL for the particular controller action is: http://localhost:50875/v1/Products/Product/allproducts.

Now I know that I am not going to test my controller method through dll reference but I want to actually test its endpoint for which I need to pass an authentication token because that end point is secured and can not be authorized until I add a secure token to the Request header.Following is the integration test for GetAllProducts(). 
  1. [Test]  
  2. public void GetAllProductsIntegrationTest()  
  3. {  
  4.     #region To be written inside Setup method specifically for integration tests  
  5.         var client = new HttpClient { BaseAddress = new Uri(ServiceBaseURL) };  
  6.         client.DefaultRequestHeaders.Add("Authorization""Basic YWtoaWw6YWtoaWw=");  
  7.         MediaTypeFormatter jsonFormatter = new JsonMediaTypeFormatter();  
  8.         _response = client.PostAsync("login"null).Result;  
  10.         if (_response != null && _response.Headers != null && _response.Headers.Contains("Token") && _response.Headers.GetValues("Token") != null)  
  11.         {  
  12.         client.DefaultRequestHeaders.Clear();  
  13.         _token = ((string[])(_response.Headers.GetValues("Token")))[0];  
  14.         client.DefaultRequestHeaders.Add("Token", _token);  
  15.         }  
  16.     #endregion  
  18.     _response = client.GetAsync("v1/Products/Product/allproducts/").Result;  
  19.     var responseResult =  
  20.     JsonConvert.DeserializeObject<List<ProductEntity>>(_response.Content.ReadAsStringAsync().Result);  
  21.     Assert.AreEqual(_response.StatusCode, HttpStatusCode.OK);  
  22.     Assert.AreEqual(responseResult.Any(), true);  
  23. } 
I have used same class to write this test, but you should always keep your unit tests segregated from integration tests, so use another test project to write integration tests for web api. First we have to request a token and add it to client request,
  1. var client = new HttpClient { BaseAddress = new Uri(ServiceBaseURL) };  
  2. client.DefaultRequestHeaders.Add("Authorization""Basic YWtoaWw6YWtoaWw=");  
  3. MediaTypeFormatter jsonFormatter = new JsonMediaTypeFormatter();  
  4. _response = client.PostAsync("login"null).Result;  
  6. if (_response != null && _response.Headers != null && _response.Headers.Contains("Token") && _response.Headers.GetValues("Token") != null)  
  7. {  
  8. client.DefaultRequestHeaders.Clear();  
  9. _token = ((string[])(_response.Headers.GetValues("Token")))[0];  
  10. client.DefaultRequestHeaders.Add("Token", _token);  
  11. } 
In the above code I have initialized the client with running service’s base URL i.e. http://localhost:50875. After initialization I am setting a default request header to call my login endpoint of Authentication controller to fetch valid token. Once the user logs in with his credentials he gets a valid token. To read in detail about security refer my article on security in web api. I have passed base 64 string of my credentials username: Akhil and password:Akhil for basic authentication.Once request gets authenticated, I get a valid token in _response.Headers that I fetch and assign to _token variable and add to client’s default header with this line of code,
  1. _token = ((string[])(_response.Headers.GetValues("Token")))[0];
  2. client.DefaultRequestHeaders.Add("Token", _token);  
Then I am calling the actual service URL from the same client,
  1. _response = client.GetAsync("v1/Products/Product/allproducts/").Result;  
And we get the result as success. Follow the screen shots.

Step 1: Get Token,

Get Token

We got the token: 4bffc06f-d8b1-4eda-b4e6-df9568dd53b1. Now since this is a real time test.This token should get saved in database. Let’s check.

Step 2: Check database,

Check database

We got the same token in database. It proves we are testing on real live URL.

Step 3: Check Response Result,


Here we got the response result with 6 products where first product id is 1 and product name is “Laptop”. Check the database for complete product list,


We get the same data. This proves our test is a success.


Likewise you can write more integration tests.

Difference between Unit tests and Integration tests

I’ll not write much, but wanted to share one of my good readings on this from this reference link.

Unit Testing

Integration Testing

Unit testing is a type of testing to check if the small piece of code is doing what it is supposed to do. Integration testing is a type of testing to check if different pieces of the modules are working together.
Unit testing checks a single component of an application. The behavior of integration modules is considered in the Integration testing.
The scope of Unit testing is narrow, it covers the Unit or small piece of code under test. Therefore while writing a unit test shorter codes are used that target just a single class. The scope of Integration testing is wide, it covers the whole application under test and it requires much more effort to put together.
Unit tests should have no dependencies on code outside the unit tested. Integration testing is dependent on other outside systems like databases, hardware allocated for them etc.
This is first type of testing is to be carried out in Software testing life cycle and generally executed by developer. This type of testing is carried out after Unit testing and before System testing and executed by the testing team.
Unit testing is not further sub divided into different types. Integration testing is further divided into different types as follows:
  Top-down Integration, Bottom-Up Integration and so on.
Unit testing is starts with the module specification. Integration testing is starts with the interface specification.
The detailed visibility of the code is comes under Unit testing. The visibility of the integration structure is comes under Integration testing.
Unit testing mainly focus on the testing the functionality of individual units only and does not uncover the issues arises when different modules are interacting with each other. Integration testing is to be carried out to discover the the issues arise when different modules are interacting with each other to build overall system.
The goal of Unit testing is to test the each unit separately and ensure that each unit is working as expected. The goal of Integration testing is to test the combined modules together and ensure that every combined moduleis working as expected.
Unit testing comes under White box testing type. Integration testing is comes under both Black box and White box type of testing.

Table reference.



In this article we learned how to write unit tests for Web API controller and primarily on basic CRUD operations. The purpose was to get a basic idea on how unit tests are written and executed. You can add your own flavor to this that helps you in your real time project. We also learned about how to write integration tests for WebAPI endpoints. I hope this was useful to you. You can download the complete source code of this article with packages from GitHub.

Read more:

For more technical articles you can reach out to CodeTeddy

My other series of articles: