Test Driven Development (TDD) Using MVC Web Application

Introduction

Here we going to calculate Rating for Shop using various methods. For this we may need to try different methods over time to have validation against the test method.

Let’s start step by step:

Create ASP.NET Test Project - Test Project "TDDWithMVC.Tests".
Adding / testing default test methods.
Adding a Test class.
Working with Test class and test methods.
Adding Features classes.
Calling the Features classes and test unit test methods.
Refactoring Unit test and business class code.
Also how to use Strategy Design Pattern.

Create the project

Right click on Solution and add a new project.

new
project

Select a template Web API.

Add new folder Name as “Features”.

feature

Now add a Test Class to Test Project “TDDWithMVC.Tests” Names as “UnitTest1.cs”

unit

Replace code with following code

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
// Calculate Rating using various methods
// for this we may need to try diffrent methods over time to have validation againts test method
//
// 1. Values or reviews for 'n' number of values
// 2. Reviews for Weighted Rating
// 3. Reviews for top n no of reviews
//
// business senariao to discribe approch when to use TDD : when we do not know how to design any feature for this TDD is grate design tool we can say.
namespace TDDWithMVC.Tests.Features
{
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestMethod1()
{
var data = new CoffeeShop();
data.Reviews = new List < ShopReviews > ();
data.Reviews.Add(new ShopReviews()
{
ratings = 4
});
var rateIndicator = new ShopRater(data);
var result = rateIndicator.ComputeRating(10);
Assert.AreEqual(4, result.Rating);
}
}
}

Now we need to create classes and methods which we are using in Test class. Right now we are considering Namespace for classes,

Right click or Ctrl + . on CoffeeShop and add new class,
Add class ShopReviews as below,
Generate Property as below,
Add property for Rating,
In the same way add class ShopRater and add new method as ComputeRating. Now we can find the following classes added to Features folder,

Now we will find below code to the classes,
1. using System.Collections.Generic;
3. namespace TDDWithMVC.Tests.Features
4. {
5. public class CoffeeShop
6. {
7. public List < ShopReviews > Reviews
8. {
9. get;
10. set;
11. }
12. }
13. }
15. namespace TDDWithMVC.Tests.Features
16. {
17. public class ShopReviews
18. {
19. public int ratings
20. {
21. get;
22. set;
23. }
24. }
25. }
28. namespace TDDWithMVC.Tests.Features
29. {
30. class ShopRater
31. {
32. private CoffeeShop data;
34. public ShopRater(CoffeeShop data)
35. {
36. // TODO: Complete member initialization
37. this.data = data;
38. }
40. public RatingResult ComputeRating(int p)
41. {
42. return new RatingResult();
43. }
44. }
45. }
Now Build the project as it is stable to build the code.
It’s time to Run the Unit test as it is not going to pass but as it is our first step to create TDD .
Right click on Test method and Run test.
Test has failed; you can see result into Test Explorer.
Now we will add login to pass the Unit test to fulfill business logic,
1. public RatingResult ComputeRating(int p)
2. {
3. var result = new RatingResult();
4. result.Rating = 4;
5. return result;
6. }
Run the test and here we go,

Test has passed

But this is killing me as we have hard coding computation to just pass the Unit test. Every time we cannot ask to change values as input changes As tenant we can add more tests and test conditions and for that we need to change the ComputeRating code to work correctly. Going forward we need to insure that we are adding code, condition, and features and that we are not breaking the code; that is what is the real value of the test.

Now change the clean code and do the necessary changes to follow coding conventions.
1. namespace TDDWithMVC.Tests.Features
2. {
3. class ShopRater
4. {
5. private CoffeeShop _coffeeShop;
7. public ShopRater(CoffeeShop coffeeShop)
8. {
9. // TODO: Complete member initialization
10. this._coffeeShop = coffeeShop;
11. }
13. public RatingResult ComputeRating(int numberOfReviews)
14. {
15. var result = new RatingResult();
16. result.Rating = 4;
17. return result;
18. }
19. }
20. }
Add a new method to check multiple rating,
1. [TestMethod]
2. public void Compute_ResultFor_OneReview()
3. {
4. // Arrange
5. var data = new CoffeeShop();
6. data.Reviews = new List < ShopReviews > ();
7. data.Reviews.Add(new ShopReviews()
8. {
9. ratings = 4
10. });
12. var rateIndicator = new ShopRater(data);
13. // Act
14. var result = rateIndicator.ComputeRating(10);
16. // Assert
17. Assert.AreEqual(4, result.Rating);
18. }
20. [TestMethod]
21. public void Compute_ResultFor_TwoReview()
22. {
23. // Arrange
24. var data = new CoffeeShop();
25. data.Reviews = new List < ShopReviews > ();
26. data.Reviews.Add(new ShopReviews()
27. {
28. ratings = 4
29. });
30. data.Reviews.Add(new ShopReviews()
31. {
32. ratings = 8
33. });
35. var rateIndicator = new ShopRater(data);
36. // Act
37. var result = rateIndicator.ComputeRating(10);
39. // Assert
40. Assert.AreEqual(4, result.Rating);
41. }
Now refector code the code in ShopRater.cs to pass both the Test,
1. public RatingResult ComputeRating(int numberOfReviews)
2. {
3. var result = new RatingResult();
4. result.Rating = (int) _coffeeShop.Reviews.Average(x => x.ratings);
5. return result;
6. }
Add Namespace using System.Linq;

Now it’s time to reactor the test code as test code is also as important as business code,
1. using System;
2. using Microsoft.VisualStudio.TestTools.UnitTesting;
3. using System.Collections.Generic;
4. using System.Linq;
7. // Calculate Rating using various methods
8. // for this we may need to try diffrent methods over time to have validation againts test method
9. //
10. // 1. Values or reviews for 'n' number of values
11. // 2. reviews for most larger values
12. //
13. // business senariao to discribe approch when to use TDD : i do not know how to design this feature.
14. // So, TDD is grate design tool we can say.
16. namespace TDDWithMVC.Tests.Features
17. {
18. [TestClass]
19. public class UnitTest1
20. {
21. [TestMethod]
22. public void Compute_ResultFor_OneReview()
23. {
24. // Arrange
25. //var data = new CoffeeShop();
26. //data.Reviews = new List<ShopReviews>();
27. //data.Reviews.Add(new ShopReviews() { ratings = 4 });
29. // Arrange
30. var data = BuildReview(rating: 4);
32. var rateIndicator = new ShopRater(data);
33. // Act
34. var result = rateIndicator.ComputeRating(10);
36. // Assert
37. Assert.AreEqual(4, result.Rating);
38. }
41. [TestMethod]
42. public void Compute_ResultFor_TwoReview()
43. {
44. // Arrange
45. //var data = new CoffeeShop();
46. //data.Reviews = new List<ShopReviews>();
47. //data.Reviews.Add(new ShopReviews() { ratings = 4 });
48. //data.Reviews.Add(new ShopReviews() { ratings = 8 });
50. // Arrange
51. var data = BuildReview(rating: new []
52. {
53. 4,
54. 8
55. });
57. var rateIndicator = new ShopRater(data);
58. // Act
59. var result = rateIndicator.ComputeRating(10);
61. // Assert
62. Assert.AreEqual(6, result.Rating);
63. }
65. private CoffeeShop BuildReview(params int[] rating)
66. {
67. var coffeeShop = new CoffeeShop();
68. coffeeShop.Reviews = rating.Select(x => new ShopReviews
69. {
70. ratings = x
71. })
72. .ToList();
73. return coffeeShop;
74. }
76. }
77. }

Now we can consider more test scenarios for negative reviews or how to deal with odd numbers, But we will mainly focus on Design (TDD is primarily).

Now add a new test to calculate weighted average of two reviews.

Add new test method as follows

[TestMethod]
public void Compute_ResultFor_WeightedReview()
{
// Arrange
var data = BuildReview(3, 9);
var rateIndicator = new ShopRater(data);
// Act
var result = rateIndicator.WeightedReviewRating(10);
// Assert
Assert.AreEqual(5, result.Rating)
}

Add do implementation to class “ShopRater” so that test passes code as follows,

public RatingResult WeightedReviewRating(int numberOfReviews)
{
var review = _coffeeShop.Reviews.ToArray();
var result = new RatingResult();
var counter = 0;
var toatl = 0;
for (int i = 0; i < review.Count(); i++)
{
if (i < review.Count() / 2)
{
counter += 2;
toatl += review[i].ratings * 2;
} else
{
counter += 1;
toatl += review[i].ratings;
}
}
result.Rating = toatl / counter;
return result;
}

Now a new business change algorithm and anticipating those changes will make it difficult to do changes; for instance, if I add a new method to ShopRater, So let’s refractor code to make changes easier (it's easy to change algorithm and still I am able test if methods pass).

So now we are going to relay on ShopRater to compute actual rating.

So ComputeResult is relay on IShopRaterAlgorithm which is passed as a parameter which looks as follows,

using System;
using System.Collections.Generic;
using System.Linq;
namespace TDDWithMVC.Tests.Features
{
public interface IShopRaterAlgorithm
{
RatingResult Compute(IList < ShopReviews > shopReviews);
//RatingResult ComputeRating(int numberOfReviews);
//RatingResult WeightedReviewRating(int numberOfReviews);
}
public class SimpleRatingAlgorithm: IShopRaterAlgorithm
{
public RatingResult Compute(IList < ShopReviews > reviews)
{
var result = new RatingResult();
result.Rating = (int) reviews.Average(x => x.ratings);
return result;
}
}
public class WeightedRatingAlgorithm: IShopRaterAlgorithm
{
public RatingResult Compute(IList < ShopReviews > reviews)
{
var review = reviews.ToArray();
var result = new RatingResult();
var counter = 0;
var toatl = 0;
for (int i = 0; i < review.Count(); i++)
{
if (i < review.Count() / 2)
{
counter += 2;
toatl += review[i].ratings * 2;
} else
{
counter += 1;
toatl += review[i].ratings;
}
}
result.Rating = toatl / counter;
return result;
}
}
}
And ShopRater.cs like
using System.Collections.Generic;
using System.Linq;
namespace TDDWithMVC.Tests.Features
{
public class ShopRater
{
private CoffeeShop _coffeeShop;
public ShopRater(CoffeeShop coffeeShop)
{
// TODO: Complete member initialization
this._coffeeShop = coffeeShop;
}
public RatingResult ComputeResult(IShopRaterAlgorithm algorithm, int noOfReviewsToUse)
{
var filterReviews = _coffeeShop.Reviews.Take(noOfReviewsToUse);
return algorithm.Compute(filterReviews.ToList());
}
}
}

Now Unit test methods will always call method ComputeResult depending on Algorithm,

var result = rateIndicator.ComputeResult(new SimpleRatingAlgorithm(), 10);
Or
var result = rateIndicator.ComputeResult(new WeightedRatingAlgorithm(), 10);

And this is Strategy Design Pattern: a software design pattern that enables an algorithm's behavior to be selected at runtime. The strategy pattern defines a family of algorithms, encapsulates each algorithm, and makes the algorithms interchangeable within that family.

design

In short:

So I have moved code from ShopRater and to Algorithm classes which is assigning specific responsibility to specific classes. So I have algorithm which focuses on computing result.
ShopRater which has code needed to reproduce that result.
So Test class does not require us to determine which method to call; we always call CompteResult and we pass algorithm which requires to perform computation. Important thing is that we can introduce a new algorithm without changing code inside ShopRater or any of the existing algorithms so that we can extend.

Now add a method which will compute the average of the first few reviews,
1. [TestMethod]
2. public void Compute_ResultFor_Top_n_No_Of_Review()
3. {
4. // Arrange
5. var data = BuildReview(3, 3, 3, 5, 9, 9);
6. var rateIndicator = new ShopRater(data);
7. // Act
8. var result = rateIndicator.ComputeResult(new SimpleRatingAlgorithm(), 3);
9. // Assert
10. Assert.AreEqual(3, result.Rating);
11. }
Then got to ShopRater and change method as below,
1. public RatingResult ComputeResult(IShopRaterAlgorithm algorithm, int noOfReviewsToUse)
2. {
3. var filterReviews = _coffeeShop.Reviews.Take(noOfReviewsToUse);
4. return algorithm.Compute(filterReviews.ToList());
5. }
Run the test cases

We are through and also we can move classes and business code to specific projects and folder structures.