RESTful Day #7: Unit Testing and Integration Testing in WebAPI using NUnit and Moq framework: Part 1

#region Using Namespaces...

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Diagnostics;
using System.Data.Entity.Validation;
using DataModel.GenericRepository;

#endregion

namespace DataModel.UnitOfWork
{
    /// <summary>
    /// Unit of Work class responsible for DB transactions
    /// </summary>
    public class UnitOfWork : IDisposable, IUnitOfWork
    {
        #region Private member variables...

        private readonly WebApiDbEntities _context = null;
        private GenericRepository<User> _userRepository;
        private GenericRepository<Product> _productRepository;
        private GenericRepository<Token> _tokenRepository;

        #endregion

        public UnitOfWork()
        {
            _context = new WebApiDbEntities();
        }

        #region Public Repository Creation properties...

        /// <summary>
        /// Get/Set Property for product repository.
        /// </summary>
        public GenericRepository<Product> ProductRepository
        {
            get
            {
                if (this._productRepository == null)
                    this._productRepository = new GenericRepository<Product>(_context);
                return _productRepository;
            }
        }

        /// <summary>
        /// Get/Set Property for user repository.
        /// </summary>
        public GenericRepository<User> UserRepository
        {
            get
            {
                if (this._userRepository == null)
                    this._userRepository = new GenericRepository<User>(_context);
                return _userRepository;
            }
        }

        /// <summary>
        /// Get/Set Property for token repository.
        /// </summary>
        public GenericRepository<Token> TokenRepository
        {
            get
            {
                if (this._tokenRepository == null)
                    this._tokenRepository = new GenericRepository<Token>(_context);
                return _tokenRepository;
            }
        }
        #endregion

        #region Public member methods...
        /// <summary>
        /// Save method.
        /// </summary>
        public void Save()
        {
            try
            {
                _context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {

                var outputLines = new List<string>();
                foreach (var eve in e.EntityValidationErrors)
                {
                    outputLines.Add(string.Format("{0}: Entity of type \"{1}\" in state \"{2}\" has the following validation errors:", DateTime.Now, eve.Entry.Entity.GetType().Name, eve.Entry.State));
                    foreach (var ve in eve.ValidationErrors)
                    {
                        outputLines.Add(string.Format("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage));
                    }
                }
                System.IO.File.AppendAllLines(@"C:\errors.txt", outputLines);

                throw e;
            }

        }

        #endregion

        #region Implementing IDisposable...

        #region private dispose variable declaration...
        private bool disposed = false;   
        #endregion

        /// <summary>
        /// Protected Virtual Dispose method
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    Debug.WriteLine("UnitOfWork is being disposed");
                    _context.Dispose();
                }
            }
            this.disposed = true;
        }

        /// <summary>
        /// Dispose method
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }   
        #endregion
    }
}

public interface IUnitOfWork
{
    #region Properties
    GenericRepository<Product> ProductRepository { get; }
    GenericRepository<User> UserRepository { get; }
    GenericRepository<Token> TokenRepository { get; }
    #endregion

    #region Public methods
    /// <summary>
    /// Save method.
    /// </summary>
    void Save();
    #endregion
}

private readonly IUnitOfWork _unitOfWork;

public ProductServices(IUnitOfWork unitOfWork)
{
    _unitOfWork = unitOfWork;
}

Install-Package EntityFramework -Version 5.0.0

Install-Package AutoMapper -Version 3.3.1

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="AutoMapper" version="3.3.1" targetFramework="net40" />
  <package id="EntityFramework" version="5.0.0" targetFramework="net40" />
  <package id="Moq" version="4.2.1510.2205" targetFramework="net40" />
  <package id="NUnit" version="2.6.4" targetFramework="net40" />
</packages>

using System;
using System.Collections.Generic;
using DataModel;

namespace TestsHelper {
    /// <summary>
    /// Data initializer for unit tests
    /// </summary>
    public class DataInitializer {
        /// <summary>
        /// Dummy products
        /// </summary>
        /// <returns></returns>
        public static List<Product> GetAllProducts() {
            var products = new List<Product> {
                new Product() {
                    ProductName = "Laptop"
                },
                new Product() {
                    ProductName = "Mobile"
                },
                new Product() {
                    ProductName = "HardDrive"
                },
                new Product() {
                    ProductName = "IPhone"
                },
                new Product() {
                    ProductName = "IPad"
                }
            };
            return products;
        }

        /// <summary>
        /// Dummy tokens
        /// </summary>
        /// <returns></returns>
        public static List<Token> GetAllTokens() {
            var tokens = new List<Token> {
                new Token() {
                    AuthToken = "9f907bdf-f6de-425d-be5b-b4852eb77761",
                    ExpiresOn = DateTime.Now.AddHours(2),
                    IssuedOn = DateTime.Now,
                    UserId = 1
                },
                new Token() {
                    AuthToken = "9f907bdf-f6de-425d-be5b-b4852eb77762",
                    ExpiresOn = DateTime.Now.AddHours(1),
                    IssuedOn = DateTime.Now,
                    UserId = 2
                }
            };

            return tokens;
        }

        /// <summary>
        /// Dummy users
        /// </summary>
        /// <returns></returns>
        public static List<User> GetAllUsers() {
            var users = new List<User> {
                new User() {
                    UserName = "akhil",
                    Password = "akhil",
                    Name = "Akhil Mittal",
                },
                new User() {
                    UserName = "arsh",
                    Password = "arsh",
                    Name = "Arsh Mittal",
                },
                new User() {
                    UserName = "divit",
                    Password = "divit",
                    Name = "Divit Agarwal",
                }
            };
            return users;
        }

    }
}

#region Variables
private IProductServices _productService;
private IUnitOfWork _unitOfWork;
private List<Product> _products;
private GenericRepository<Product> _productRepository;
private WebApiDbEntities _dbEntities;
#endregion

#region Test fixture setup

/// <summary>
/// Initial setup for tests
/// </summary>
[TestFixtureSetUp]
public void Setup()
{
    _products = SetUpProducts();
}
#endregion

private static List<Product> SetUpProducts()
{
    var prodId = new int();
    var products = DataInitializer.GetAllProducts();
    foreach (Product prod in products)
        prod.ProductId = ++prodId;
    return products;
}

#region TestFixture TearDown.
/// <summary>
/// TestFixture teardown
/// </summary>
[TestFixtureTearDown]
public void DisposeAllObjects()
{
    _products = null;
}
#endregion

#region Setup

/// <summary>
/// Re-initializes test.
/// </summary>
[SetUp]
public void ReInitializeTest()
{
    _dbEntities = new Mock<WebApiDbEntities>().Object;
    _productRepository = SetUpProductRepository();
    var unitOfWork = new Mock<IUnitOfWork>();
    unitOfWork.SetupGet(s => s.ProductRepository).Returns(_productRepository);
    _unitOfWork = unitOfWork.Object;
    _productService = new ProductServices(_unitOfWork);
}

#endregion

/// <summary>
/// Tears down each test data
/// </summary>
[TearDown]
public void DisposeTest()
{
    _productService = null;
    _unitOfWork = null;
    _productRepository = null;
    if (_dbEntities != null)
        _dbEntities.Dispose();
}

private GenericRepository<Product> SetUpProductRepository()
{


    // Initialise repository
    var mockRepo = new Mock<GenericRepository<Product>>(MockBehavior.Default, _dbEntities);

    // Setup mocking behavior
    mockRepo.Setup(p => p.GetAll()).Returns(_products);

    mockRepo.Setup(p => p.GetByID(It.IsAny<int>()))
    .Returns(new Func<int, Product>(
    id => _products.Find(p => p.ProductId.Equals(id))));

    mockRepo.Setup(p => p.Insert((It.IsAny<Product>())))
    .Callback(new Action<Product>(newProduct =>
    {
        dynamic maxProductID = _products.Last().ProductId;
        dynamic nextProductID = maxProductID + 1;
        newProduct.ProductId = nextProductID;
        _products.Add(newProduct);
    }));

    mockRepo.Setup(p => p.Update(It.IsAny<Product>()))
    .Callback(new Action<Product>(prod =>
    {
        var oldProduct = _products.Find(a => a.ProductId == prod.ProductId);
        oldProduct = prod;
    }));

    mockRepo.Setup(p => p.Delete(It.IsAny<Product>()))
    .Callback(new Action<Product>(prod =>
    {
        var productToRemove =
        _products.Find(a => a.ProductId == prod.ProductId);

        if (productToRemove != null)
        _products.Remove(productToRemove);
    }));

    // Return mock implementation object
    return mockRepo.Object;
}

var mockRepo = new Mock<GenericRepository<Product>>(MockBehavior.Default, _dbEntities);

var unitOfWork = new Mock<IUnitOfWork>();
unitOfWork.SetupGet(s => s.ProductRepository).Returns(_productRepository);
_unitOfWork = unitOfWork.Object;
_productService = new ProductServices(_unitOfWork);

public IEnumerable<BusinessEntities.ProductEntity> GetAllProducts()
{
    var products = _unitOfWork.ProductRepository.GetAll().ToList();
    if (products.Any())
    {
        Mapper.CreateMap<Product, ProductEntity>();
        var productsModel = Mapper.Map<List<Product>, List<ProductEntity>>(products);
        return productsModel;
    }
    return null;
}

We see here, that this method fetches all the available products from the database, and maps the database entity to our custom BusinessEntities.ProductEntity and returns the list of custom BusinessEntities.ProductEntity. It returns null if no products are found.

To start writing a test method, you need to decorate that test method with the [Test] attribute of the NUnit framework. This attribute specifies that a particular method is a Unit Test method.

The following is the unit test method I have written for the above-mentioned business service method.

[Test]
public void GetAllProductsTest()
{
    var products = _productService.GetAllProducts();
    var productList =
        products.Select(
            productEntity =>
                new Product { ProductId = productEntity.ProductId, ProductName = productEntity.ProductName }).ToList();
    var comparer = new ProductComparer();
    CollectionAssert.AreEqual(
        productList.OrderBy(product => product, comparer),
        _products.OrderBy(product => product, comparer), comparer);
}

We used an instance of _productService and called the GetAllProducts() method, which will ultimately execute on mocked UnitOfWork and Repository to fetch test data from _products list. The products returned from the method are of type business entities.ProductEntity and we need to compare the returned products with our existing _products list i.e. the list of DataModel.Product i.e. a mocked database entity, so we need to convert the returned business entities.ProductEntity list to DataModel.Product list. We do this with the following line of code.

var productList =
    products.Select(
        productEntity =>
            new Product { ProductId = productEntity.ProductId, ProductName = productEntity.ProductName }).ToList();

Now we got two lists to compare, one _products list i.e. the actual products and another productList i.e. the products returned from the service. I have written a helper class and compare method to convert the two Product list in TestHelper project. This method checks the list items and compares them for equality of values. You can add a class named ProductComparer to TestHelper project with the following implementations.

public class ProductComparer : IComparer, IComparer<Product>
{
    public int Compare(object expected, object actual)
    {
        var lhs = expected as Product;
        var rhs = actual as Product;
        if (lhs == null || rhs == null) throw new InvalidOperationException();
        return Compare(lhs, rhs);
    }

    public int Compare(Product expected, Product actual)
    {
        int temp;
        return (temp = expected.ProductId.CompareTo(actual.ProductId)) != 0 ? temp : expected.ProductName.CompareTo(actual.ProductName);
    }
}

To assert the result we use CollectionAssert.AreEqual of NUnit where we pass both the lists and comparer.

CollectionAssert.AreEqual(
    productList.OrderBy(product => product, comparer),
    _products.OrderBy(product => product, comparer), comparer);

Since I have the NUnit plugin in my visual studio provided by Resharper, let me debug the test method to see the actual result of Assert. We’ll run all the tests with NUnit UI at the end of the article.

product list

_products

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

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

GetAllProductsTestForNull ()

You can also write the test for null check for the same method where you nullify the _products list before you invoke the service method. We actually need to write tests that cover all the exit points of the invoked method.

The following test covers another exit point of the method that returns null in case no products are found.

/// <summary>
/// Service should return null
/// </summary>
[Test]
public void GetAllProductsTestForNull()
{
    _products.Clear();
    var products = _productService.GetAllProducts();
    Assert.Null(products);
    SetUpProducts();
}

In the above-mentioned test, we first clear the _products list and invoke the service method. Now assert the result as null because our expected result and actual result should be null. I called the SetUpProducts() method again to populate the _products list, but you can do this in the test setup method as well i.e. ReInitializeTest().

Now let’s move to other tests.

GetProductByRightIdTest ()

Here we test the GetProductById() method of ProductService. The ideal behavior is that if I invoke the method with a valid id, the method should return the valid product. Now let’s suppose I know the product id for my product named “Mobile” and I invoke the test using that ID, so ideally I should get a product with the product name mobile.

/// <summary>
/// Service should return product if correct id is supplied
/// </summary>
[Test]
public void GetProductByRightIdTest()
{
    var mobileProduct = _productService.GetProductById(2);
    if (mobileProduct != null)
    {
        Mapper.CreateMap<ProductEntity, Product>();
        var productModel = Mapper.Map<ProductEntity, Product>(mobileProduct);
        AssertObjects.PropertyValuesAreEquals(productModel, 
                                               _products.Find(a => a.ProductName.Contains("Mobile")));
    }
}

The above code is self-explanatory except the line AssertObjects.PropertyValuesAreEquals.

_productService.GetProductById(2); line fetches the product with product id 2.

Mapper.CreateMap<ProductEntity, Product>();
var productModel = Mapper.Map<ProductEntity, Product>(mobileProduct);

The above code maps the returned custom ProductEntity to DataModel.Product.

AssertObjectsis one more class I have added inside TestHelper class. The purpose of this class is to compare the properties of two objects. This is a common generic class applicable for all type of class objects having properties. Its method PropertyValuesAreEquals() checks for equality of the properties.

AssertObjects class

using System.Collections;
using System.Reflection;
using NUnit.Framework;

namespace TestsHelper
{
    public static class AssertObjects
    {
        public static void PropertyValuesAreEquals(object actual, object expected)
        {
            PropertyInfo[] properties = expected.GetType().GetProperties();
            foreach (PropertyInfo property in properties)
            {
                object expectedValue = property.GetValue(expected, null);
                object actualValue = property.GetValue(actual, null);

                if (actualValue is IList)
                    AssertListsAreEquals(property, (IList)actualValue, (IList)expectedValue);
                else if (!Equals(expectedValue, actualValue))
                    if (property.DeclaringType != null)
                        Assert.Fail("Property {0}.{1} does not match. Expected: {2} but was: {3}", property.DeclaringType.Name, property.Name, expectedValue, actualValue);
            }
        }

        private static void AssertListsAreEquals(PropertyInfo property, IList actualList, IList expectedList)
        {
            if (actualList.Count != expectedList.Count)
                Assert.Fail("Property {0}.{1} does not match. Expected IList containing {2} elements but was IList containing {3} elements",
                             property.PropertyType.Name,
                             property.Name, expectedList.Count, actualList.Count);

            for (int i = 0; i < actualList.Count; i++)
                if (!Equals(actualList[i], expectedList[i]))
                    Assert.Fail("Property {0}.{1} does not match. Expected IList with element {1} equals to {2} but was IList with element {1} equals to {3}", property.PropertyType.Name, property.Name, expectedList[i], actualList[i]);
        }
    }
}

Running the test.

GetProductByWrongIdTest ()

In this test, we test the service method with the wrong id and expect null in return.

/// <summary>
/// Service should return null
/// </summary>
[Test]
public void GetProductByWrongIdTest()
{
    var product = _productService.GetProductById(0);
    Assert.Null(product);
}

AddNewProductTest ()

In this unit test, we test the CreateProduct() method of ProductService. The following is the unit test written for creating a new product.

/// <summary>
/// Add new product test
/// </summary>
[Test]
public void AddNewProductTest()
{
    var newProduct = new ProductEntity()
    {
        ProductName = "Android Phone"
    };

    var maxProductIDBeforeAdd = _products.Max(a => a.ProductId);
    newProduct.ProductId = maxProductIDBeforeAdd + 1;
    _productService.CreateProduct(newProduct);
    var addedproduct = new Product() { ProductName = newProduct.ProductName, ProductId = newProduct.ProductId };
    AssertObjects.PropertyValuesAreEquals(addedproduct, _products.Last());
    Assert.That(maxProductIDBeforeAdd + 1, Is.EqualTo(_products.Last().ProductId));
}    

In above code I have created a dummy product with product name “Android Phone” and assigned the product id as the incremented id to the maximum value of productId of the product that lies in _products list. Ideally if my test is a success, the added product should reflect in _products list as last product with maximum product id. To verify the result, I have used two asserts, first one checks the properties of expected and actual product and the second one verifies the product id.

var addedproduct = new Product() { ProductName = newProduct.ProductName, ProductId = newProduct.ProductId };

added product is the custom product that is expected to be added in the _products list and _products.Last() gives us last product of the list. So.

AssertObjects.PropertyValuesAreEquals(added product, _products.Last()); checks for all the properties of dummy as well as last added product and.

Assert.That(maxProductIDBeforeAdd + 1, Is.EqualTo(_products.Last().ProductId)); checks if the last product added has the same product id as supplied while creating the product.

After full execution,

The test passes, that means the expected value that was product id 6 was equal to the product id of the last added product in _products list. And we can also see that, earlier we had only 5 products in _products list and now we have added a 6th one.

UpdateProductTest ()

This is the unit test to check if the product is updated or not. This test is for the UpdateProduct() method of ProductService.

/// <summary>
/// Update product test
/// </summary>
[Test]
public void UpdateProductTest()
{
    var firstProduct = _products.First();
    firstProduct.ProductName = "Laptop updated";
    var updatedProduct = new ProductEntity()
    { ProductName = firstProduct.ProductName, ProductId = firstProduct.ProductId };
    _productService.UpdateProduct(firstProduct.ProductId, updatedProduct);
    Assert.That(firstProduct.ProductId, Is.EqualTo(1)); // hasn't changed
    Assert.That(firstProduct.ProductName, Is.EqualTo("Laptop updated")); // Product name changed
}

In this test I am trying to update first product from _products list. I have changed the product name to “Laptop Updated” and invoked the UpdateProduct() method of ProductService. I have made two asserts to check the updated product from _products list, one for productId and second for product name. We see that we get the updated product while we assert.

DeleteProductTest ()

The following is the test for the DeleteProduct() method in ProductService.

/// <summary>
/// Delete product test
/// </summary>
[Test]
public void DeleteProductTest()
{
    int maxID = _products.Max(a => a.ProductId); // Before removal
    var lastProduct = _products.Last();

    // Remove last Product
    _productService.DeleteProduct(lastProduct.ProductId);
    Assert.That(maxID, Is.GreaterThan(_products.Max(a => a.ProductId))); // Max id reduced by 1
}

I have written the test to verify the max id of product from the list of products. Get max id of the product, delete the last product and check the max id of the product from the list. The prior max id should be greater than the last product’s product id.

Max id before delete was 5 and after delete is 4 which means a product is deleted from _products list therefore statement: Assert.That(maxID, Is.GreaterThan(_products. Max(a => a.ProductId))); passes as 5 is greater than 4.

We have covered all the methods of ProductService under unit tests. The following is the final class that covers all the tests for this service.

#region using namespaces.

using System;
using System.Collections.Generic;
using System.Linq;
using AutoMapper;
using BusinessEntities;
using DataModel;
using DataModel.GenericRepository;
using DataModel.UnitOfWork;
using Moq;
using NUnit.Framework;
using TestsHelper;

#endregion

namespace BusinessServices.Tests
{
    /// <summary>
    /// Product Service Test
    /// </summary>
    public class ProductServicesTest
    {
        #region Variables

        private IProductServices _productService;
        private IUnitOfWork _unitOfWork;
        private List<Product> _products;
        private GenericRepository<Product> _productRepository;
        private WebApiDbEntities _dbEntities;

        #endregion

        #region Test fixture setup

        /// <summary>
        /// Initial setup for tests
        /// </summary>
        [TestFixtureSetUp]
        public void Setup()
        {
            _products = SetUpProducts();
        }

        #endregion

        #region Setup

        /// <summary>
        /// Re-initializes test.
        /// </summary>
        [SetUp]
        public void ReInitializeTest()
        {
            _dbEntities = new Mock<WebApiDbEntities>().Object;
            _productRepository = SetUpProductRepository();
            var unitOfWork = new Mock<IUnitOfWork>();
            unitOfWork.SetupGet(s => s.ProductRepository).Returns(_productRepository);
            _unitOfWork = unitOfWork.Object;
            _productService = new ProductServices(_unitOfWork);
        }

        #endregion

        #region Private member methods

        /// <summary>
        /// Setup dummy repository
        /// </summary>
        /// <returns></returns>
        private GenericRepository<Product> SetUpProductRepository()
        {
            // Initialise repository
            var mockRepo = new Mock<GenericRepository<Product>>(MockBehavior.Default, _dbEntities);

            // Setup mocking behavior
            mockRepo.Setup(p => p.GetAll()).Returns(_products);

            mockRepo.Setup(p => p.GetByID(It.IsAny<int>()))
                .Returns(new Func<int, Product>(
                    id => _products.Find(p => p.ProductId.Equals(id))));

            mockRepo.Setup(p => p.Insert((It.IsAny<Product>())))
                .Callback(new Action<Product>(newProduct =>
                {
                    dynamic maxProductID = _products.Last().ProductId;
                    dynamic nextProductID = maxProductID + 1;
                    newProduct.ProductId = nextProductID;
                    _products.Add(newProduct);
                }));

            mockRepo.Setup(p => p.Update(It.IsAny<Product>()))
                .Callback(new Action<Product>(prod =>
                {
                    var oldProduct = _products.Find(a => a.ProductId == prod.ProductId);
                    oldProduct = prod;
                }));

            mockRepo.Setup(p => p.Delete(It.IsAny<Product>()))
                .Callback(new Action<Product>(prod =>
                {
                    var productToRemove =
                        _products.Find(a => a.ProductId == prod.ProductId);

                    if (productToRemove != null)
                        _products.Remove(productToRemove);
                }));

            // Return mock implementation object
            return mockRepo.Object;
        }

        /// <summary>
        /// Setup dummy products data
        /// </summary>
        /// <returns></returns>
        private static List<Product> SetUpProducts()
        {
            var prodId = new int();
            var products = DataInitializer.GetAllProducts();
            foreach (Product prod in products)
                prod.ProductId = ++prodId;
            return products;

        }

        #endregion

        #region Unit Tests

        /// <summary>
        /// Service should return all the products
        /// </summary>
        [Test]
        public void GetAllProductsTest()
        {
            var products = _productService.GetAllProducts();
            if (products != null)
            {
                var productList =
                    products.Select(
                        productEntity =>
                            new Product { ProductId = productEntity.ProductId, ProductName = productEntity.ProductName })
                        .
                        ToList();
                var comparer = new ProductComparer();
                CollectionAssert.AreEqual(
                    productList.OrderBy(product => product, comparer),
                    _products.OrderBy(product => product, comparer), comparer);
            }
        }

        /// <summary>
        /// Service should return null
        /// </summary>
        [Test]
        public void GetAllProductsTestForNull()
        {
            _products.Clear();
            var products = _productService.GetAllProducts();
            Assert.Null(products);
            SetUpProducts();
        }

        /// <summary>
        /// Service should return product if correct id is supplied
        /// </summary>
        [Test]
        public void GetProductByRightIdTest()
        {
            var mobileProduct = _productService.GetProductById(2);
            if (mobileProduct != null)
            {
                Mapper.CreateMap<ProductEntity, Product>();
                var productModel = Mapper.Map<ProductEntity, Product>(mobileProduct);
                AssertObjects.PropertyValuesAreEquals(productModel,
                    _products.Find(a => a.ProductName.Contains("Mobile")));
            }
        }

        /// <summary>
        /// Service should return null
        /// </summary>
        [Test]
        public void GetProductByWrongIdTest()
        {
            var product = _productService.GetProductById(0);
            Assert.Null(product);
        }

        /// <summary>
        /// Add new product test
        /// </summary>
        [Test]
        public void AddNewProductTest()
        {
            var newProduct = new ProductEntity()
            {
                ProductName = "Android Phone"
            };

            var maxProductIDBeforeAdd = _products.Max(a => a.ProductId);
            newProduct.ProductId = maxProductIDBeforeAdd + 1;
            _productService.CreateProduct(newProduct);
            var addedproduct = new Product() { ProductName = newProduct.ProductName, ProductId = newProduct.ProductId };
            AssertObjects.PropertyValuesAreEquals(addedproduct, _products.Last());
            Assert.That(maxProductIDBeforeAdd + 1, Is.EqualTo(_products.Last().ProductId));
        }

        /// <summary>
        /// Update product test
        /// </summary>
        [Test]
        public void UpdateProductTest()
        {
            var firstProduct = _products.First();
            firstProduct.ProductName = "Laptop updated";
            var updatedProduct = new ProductEntity() { ProductName = firstProduct.ProductName, ProductId = firstProduct.ProductId

TokenService Tests

Now that we have completed all the tests for ProductService, I am sure you must have got an idea on how to write unit tests for methods. Note that primarily unit tests are only written to publically exposed methods because the private methods automatically get tested through those public methods in the class. I’ll not explain too much theory for TokenService tests and only navigate through code. I’ll explain the details wherever necessary.

Tests Setup

Add a new class named TokenServicesTests.cs in BusinessServices.Tests project.

Declare variables

Define the private variable that we’ll use in the class to write tests.

#region Variables

private ITokenServices _tokenServices;
private IUnitOfWork _unitOfWork;
private List<Token> _tokens;
private GenericRepository<Token> _tokenRepository;
private WebApiDbEntities _dbEntities;
private const string SampleAuthToken = "9f907bdf-f6de-425d-be5b-b4852eb77761";

#endregion

Here _tokenService will hold mock for TokenServices, _unitOfWork for UnitOfWork class, __tokens will hold dummy tokens from the DataInitializer class of the TestHelper project, _tokenRepository and _dbEntities holds mock for Token Repository and WebAPIDbEntities from DataModel project respectively

Write Test Fixture Setup

#region Test fixture setup

/// <summary>
/// Initial setup for tests
/// </summary>
[TestFixtureSetUp]
public void Setup()
{
    _tokens = SetUpTokens();
}

#endregion

SetUpTokens() method fetches tokens from DataInitializer class and not from database and assigns a unique id to each token by iterating on them.

/// <summary>
/// Setup dummy tokens data
/// </summary>
/// <returns></returns>
private static List<Token> SetUpTokens()
{
    var tokId = new int();
    var tokens = DataInitializer.GetAllTokens();
    foreach (Token tok in tokens)
        tok.TokenId = ++tokId;
    return tokens;
}

The result data is assigned to __tokens list to be used in setting up mock repository and in every individual test for comparison of actual vs resultant output.

Write Test Fixture Tear Down

#region TestFixture TearDown

/// <summary>
/// TestFixture teardown
/// </summary>
[TestFixtureTearDown]
public void DisposeAllObjects()
{
    _tokens = null;
}

#endregion

Write Test Setup

#region Setup

/// <summary>
/// Re-initializes test.
/// </summary>
[SetUp]
public void ReInitializeTest()
{
    _dbEntities = new Mock<WebApiDbEntities>().Object;
    _tokenRepository = SetUpTokenRepository();
    var unitOfWork = new Mock<IUnitOfWork>();
    unitOfWork.SetupGet(s => s.TokenRepository).Returns(_tokenRepository);
    _unitOfWork = unitOfWork.Object;
    _tokenServices = new TokenServices(_unitOfWork);
}

#endregion

Write Test Teardown

#region Tear Down

/// <summary>
/// Tears down each test data
/// </summary>
[TearDown]
public void DisposeTest()
{
    _tokenServices = null;
    _unitOfWork = null;
    _tokenRepository = null;
    if (_dbEntities != null)
        _dbEntities.Dispose();
}

#endregion

Mocking Repository

private GenericRepository<Token> SetUpTokenRepository()
{
    // Initialise repository
    var mockRepo = new Mock<GenericRepository<Token>>(MockBehavior.Default, _dbEntities);

    // Setup mocking behavior
    mockRepo.Setup(p => p.GetAll()).Returns(_tokens);

    mockRepo.Setup(p => p.GetByID(It.IsAny<int>()))
        .Returns(new Func<int, Token>(
            id => _tokens.Find(p => p.TokenId.Equals(id))));

    mockRepo.Setup(p => p.GetByID(It.IsAny<string>()))
        .Returns(new Func<string, Token>(
            authToken => _tokens.Find(p => p.AuthToken.Equals(authToken))));

    mockRepo.Setup(p => p.Insert((It.IsAny<Token>())))
        .Callback(new Action<Token>(newToken =>
        {
            dynamic maxTokenID = _tokens.Last().TokenId;
            dynamic nextTokenID = maxTokenID + 1;
            newToken.TokenId = nextTokenID;
            _tokens.Add(newToken);
        }));

    mockRepo.Setup(p => p.Update(It.IsAny<Token>()))
        .Callback(new Action<Token>(token =>
        {
            var oldToken = _tokens.Find(a => a.TokenId == token.TokenId);
            oldToken = token;
        }));

    mockRepo.Setup(p => p.Delete(It.IsAny<Token>()))
        .Callback(new Action<Token>(prod =>
        {
            var tokenToRemove =
                _tokens.Find(a => a.TokenId == prod.TokenId);

            if (tokenToRemove != null)
                _tokens.Remove(tokenToRemove);
        }));

    // Create setup for other methods too. note non virtauls methods can not be set up

    // Return mock implementation object
    return mockRepo.Object;
}

Note, while mocking repository, I have setup two mocks for GetById(). There is a minor change I did in the database, I have marked AuthToken field as a primary key too. So it may be a situation where mock gets confused on calling the method that for which primary key the request has been made. So I have implemented the mock both for TokenId and AuthToken field.

mockRepo.Setup(p => p.GetByID(It.IsAny<int>())).Returns(new Func<int, Token>(
    id => _tokens.Find(p => p.TokenId.Equals(id))));

mockRepo.Setup(p => p.GetByID(It.IsAny<string>())).Returns(new Func<string, Token>(
    authToken => _tokens.Find(p => p.AuthToken.Equals(authToken))));

The overall setup is of same nature as we wrote for ProductService. Let us move on to unit tests.

GenerateTokenByUseridTest ()

This unit test is to test the GenerateToken method of TokenServices business service. In this method a new token is generated in the database against a user. We’ll use _tokens list for all these transactions. Currently we have only two token entries in _tokens list generated from DataInitializer. Now when the test executes it should expect one more token to be added to the list.

[Test]
public void GenerateTokenByUserIdTest()
{
    const int userId = 1;
    var maxTokenIdBeforeAdd = _tokens.Max(a => a.TokenId);
    var tokenEntity = _tokenServices.GenerateToken(userId);
    var newTokenDataModel = new Token()
    {
        AuthToken = tokenEntity.AuthToken,
        TokenId = maxTokenIdBeforeAdd + 1,
        ExpiresOn = tokenEntity.ExpiresOn,
        IssuedOn = tokenEntity.IssuedOn,
        UserId = tokenEntity.UserId
    };
    AssertObjects.PropertyValuesAreEquals(newTokenDataModel, _tokens.Last());
}

I have taken a default user id as 1, and stored the max token id from the list of tokens. Call the service method GenerateTokenEntity(). Since our service method returns BusinessEntities.TokenEntity, we need to map it to new DataModel.Token object for comparison. So expected result is that all the properties of this token should match the last token of the _token list assuming that list is updated through the test.

Now since all the properties of the resultant and actual object match, so our test passes.

ValidateTokenWithRightAuthToken ()

/// <summary>
/// Validate token test
/// </summary>
[Test]
public void ValidateTokenWithRightAuthToken()
{
    var authToken = Convert.ToString(SampleAuthToken);
    var validationResult = _tokenServices.ValidateToken(authToken);
    Assert.That(validationResult, Is.EqualTo(true));
}

This test validates AuthToken through the ValidateToken method of TokenService.Ideally, if the correct token is passed, the service should return true.

Here we get validationResult as true therefore test should pass.

ValidateTokenWithWrongAuthToken ()

Testing the same method for its alternate exit point, therefore with the wrong token, the service should return false.

[Test]
public void ValidateTokenWithWrongAuthToken()
{
    var authToken = Convert.ToString("xyz");
    var validationResult = _tokenServices.ValidateToken(authToken);
    Assert.That(validationResult, Is.EqualTo(false));
}

Here validationResult is false and is compared to the false value, so test should ideally pass.

UserService Tests

I have tried writing unit tests for UserService as per our service implementations, but encountered an error while mocking up our repositories Get () method that takes predicate or where condition as a parameter.

public TEntity Get(Func<TEntity, Boolean> where)
{
    return DbSet.Where(where).FirstOrDefault<TEntity>();
}

Since our service methods heavily depend on the Get method, so none of the methods could be tested, but apart from this you can search for any other mocking framework that takes care of these situations.I guess this is a bug in the mocking framework. Alternatively, refrain from using Get method with a predicate (I would not suggest this approach as it is against the testing strategy.Our tests should not be limited to the technical feasibility of methods). I got the following error while mocking the repository.

“Invalid setup on a non-virtual (overridable in VB)”. I have commented out all UserServiceUnit test code, you can find it in available source code.

Test through NUnit UI

We have completed almost all the BusinessServices tests, and now let us try to execute these tests on 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 name the project as WebAPI.nunit, and save it at any Windows location.

Step 3. Now, click on Project-> Add Assembly and browse for BusinessServices.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 get loaded in the UI and are visible on the interface.

Step 5. At the right-hand side panel of the interface, you’ll see a Run button that runs all the tests of business service. Just select the node BusinessServices in the tests tree on the left side and press the Run button on the right side.

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

But here, all of our tests are passed.

WebAPITests

Unit tests for WebAPI are not exactly like service methods, but vary in terms of testing HttpResponse, returned JSON, exception responses, etc. Note that we’ll mock the classes and repository in a similar way in WebAPI unit tests as we did for services. One way of testing a web api is through web client and testing the actual endpoint or hosted URL of the service, but that is not considered as a unit test, that is called integration testing. In the next part of the article I’ll explain step-by-step procedure to unit test a web API. We’ll write tests for Product Controller.

Conclusion

In this article, we learned how to write unit tests for core business logic and primarily on basic CURD 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. My next article which explains unit tests for WebAPI controllers will be the continuation of this part.I hope this was useful to you. You can download the complete source code of this article with packages from GitHub. Happy coding.

Read more

• C# and ASP.NET Questions (All in one)
• MVC Interview Questions
• C# and ASP.NET Interview Questions and Answers
• Web Services and Windows Services Interview Questions

For more technical articles you can reach out to CodeTeddy

My other series of articles,

• Learning MVC
• Learning OOP concepts with C#

Read more articles on ASP.NET.

• Displaying Google Maps in ASP.NET Application
• Paging, Sorting, And Filtering With Partial View In ASP.NET MVC 5