This document provides an overview and instructions for developing a real application called SportsStore using ASP.NET MVC. It discusses starting the domain model by adding a Product model class and creating an abstract IProductsRepository interface. It also covers setting up projects, installing packages, adding references between projects, and configuring the dependency injection container.

1. Developing in ASP.NET MVC
E03 Start A Real Application
Yu Guan | Microsoft MVP
2019-03

2. AGENDA
 Unit Testing with Visual Studio
 Using Moq
 SportsStore: A Real Application

3. Unit Testing with Visual Studio
 Creating the Unit Test Project
 Creating the Unit Tests
 Running the Unit Tests
 Implementing the Feature
 Testing and Fixing the Code

4. Unit Testing with Visual Studio
public interface IDiscountHelper
{
decimal ApplyDiscount(decimal totalParam);
}
public class MinimumDiscountHelper : IDiscountHelper
{
public decimal ApplyDiscount(decimal totalParam)
{
throw new NotImplementedException();
}
}
 If the total is greater than $100, the discount will be 10 percent.
 If the total is between $10 and $100 inclusive, the discount will be $5.
 No discount will be applied on totals less than $10.
 An ArgumentOutOfRangeException will be thrown for negative totals.

5. Creating the Unit Test Project
 Right-clicking the top-level item in the Solution Explorer and selecting Add ➤
New Project from the pop-up menu.
 You can choose to create a test project when you create a new MVC project:
there is an Add Unit Tests option on the dialog where you choose the initial
content for the project.

7. Creating the Unit Tests
[TestClass]
public class UnitTest1
{
private IDiscountHelper GetTestObject()
{
return new MinimumDiscountHelper();
}
[TestMethod]
public void Discount_Above_100()
{
// arrange
IDiscountHelper target = GetTestObject();
decimal total = 200;
// act
var discountedTotal = target.ApplyDiscount(total);
// assert
Assert.AreEqual(total * 0.9M, discountedTotal);
}
}

8. Creating the Unit Tests
Method Description
AreEqual<T>(T, T)
AreEqual<T>(T, T, string)
Asserts that two objects of type T have the same value.
AreNotEqual<T>(T, T)
AreNotEqual<T>(T, T, string)
Asserts that two objects of type T do not have the same value.
AreSame<T>(T, T)
AreSame<T>(T, T, string)
Asserts that two variables refer to the same object.
AreNotSame<T>(T, T)
AreNotSame<T>(T, T, string)
Asserts that two variables refer to different objects.
IsTrue(bool)
IsTrue(bool, string)
Asserts that a bool value is true. Most often used to evaluate
an expression that returns a bool result.
IsFalse(bool)
IsFalse(bool, string)
Asserts that a bool value is false.

9. Creating the Unit Tests
[TestMethod]
public void Discount_Between_10_And_100()
{
//arrange
IDiscountHelper target = GetTestObject();
// act
decimal TenDollarDiscount = target.ApplyDiscount(10);
decimal HundredDollarDiscount = target.ApplyDiscount(100);
decimal FiftyDollarDiscount = target.ApplyDiscount(50);
// assert
Assert.AreEqual(5, TenDollarDiscount, "$10 discount is wrong");
Assert.AreEqual(95, HundredDollarDiscount, "$100 discount is wrong");
Assert.AreEqual(45, FiftyDollarDiscount, "$50 discount is wrong");
}
[TestMethod]
public void Discount_Less_Than_10()
{
//arrange
IDiscountHelper target = GetTestObject();
// act
decimal discount5 = target.ApplyDiscount(5);
decimal discount0 = target.ApplyDiscount(0);
// assert
Assert.AreEqual(5, discount5);
Assert.AreEqual(0, discount0);
}
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void Discount_Negative_Total()
{
//arrange
IDiscountHelper target = GetTestObject();
// act
target.ApplyDiscount(-1);
}

10. Running the Unit Tests
 Visual Studio provides the Test Explorer window for managing and running tests.
Select Windows ➤ Test Explorer from the Visual Studio Test menu to see the
window and click the Run All button near the top-left corner.

11. Implementing the Feature
public decimal ApplyDiscount(decimal totalParam)
{
if (totalParam < 0)
{
throw new ArgumentOutOfRangeException();
}
else if (totalParam > 100)
{
return totalParam * 0.9M;
}
else if (totalParam > 10 && totalParam <= 100)
{
return totalParam - 5;
}
else
{
return totalParam;
}
}

12. Testing and Fixing the Code

13. Using Moq
 Understanding the Problem
 Adding Moq to the Visual Studio Project
 Adding a Mock Object to a Unit Test
 Creating a More Complex Mock Object

14. Understanding the Problem
public class LinqValueCalculator : IValueCalculator
{
private IDiscountHelper discounter;
private static int counter = 0;
public LinqValueCalculator(IDiscountHelper discountParam)
{
discounter = discountParam;
System.Diagnostics.Debug.WriteLine(
string.Format("Instance {0} created", ++counter));
}
public decimal ValueProducts(IEnumerable<Product> products)
{
return discounter.ApplyDiscount(products.Sum(p => p.Price));
}
}

15. Understanding the Problem
private Product[] products =
{
new Product {Name = "Kayak", Category = "Watersports", Price = 275M},
new Product {Name = "Lifejacket", Category = "Watersports", Price = 48.95M},
new Product {Name = "Soccer ball", Category = "Soccer", Price = 19.50M},
new Product {Name = "Corner flag", Category = "Soccer", Price = 34.95M}
};
[TestMethod]
public void Sum_Products_Correctly()
{
// arrange
var discounter = new MinimumDiscountHelper();
var target = new LinqValueCalculator(discounter);
var goalTotal = products.Sum(e => e.Price);
// act
var result = target.ValueProducts(products);
// assert
Assert.AreEqual(goalTotal, result);
}

16. Adding Moq to the Visual Studio Project
 Install-Package Moq -version 4.1.1309.1617 -projectname xxxUnitTests

17. Adding a Mock Object to a Unit Test
[TestMethod]
public void Sum_Products_Correctly()
{
// arrange
Mock<IDiscountHelper> mock = new Mock<IDiscountHelper>();
mock
.Setup(m => m.ApplyDiscount(It.IsAny<decimal>()))
.Returns<decimal>(total => total);
var target = new LinqValueCalculator(mock.Object);
// act
var result = target.ValueProducts(products);
// assert
Assert.AreEqual(products.Sum(e => e.Price), result);
}

18. Creating a More Complex Mock Object
[TestMethod]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void Pass_Through_Variable_Discounts()
{
// arrange
Mock<IDiscountHelper> mock = new Mock<IDiscountHelper>();
mock
.Setup(m => m.ApplyDiscount(It.IsAny<decimal>()))
.Returns<decimal>(total => total);
mock
.Setup(m => m.ApplyDiscount(It.Is<decimal>(v => v == 0)))
.Throws<ArgumentOutOfRangeException>();
mock
.Setup(m => m.ApplyDiscount(It.Is<decimal>(v => v > 100)))
.Returns<decimal>(total => (total * 0.9M));
mock
.Setup(m => m.ApplyDiscount(It.IsInRange<decimal>(10, 100, Range.Inclusive)))
.Returns<decimal>(total => total - 5);
var target = new LinqValueCalculator(mock.Object);
// act
decimal FiveDollarDiscount = target.ValueProducts(CreateProduct(5));
decimal TenDollarDiscount = target.ValueProducts(CreateProduct(10));
decimal FiftyDollarDiscount = target.ValueProducts(CreateProduct(50));
decimal HundredDollarDiscount = target.ValueProducts(CreateProduct(100));
decimal FiveHundredDollarDiscount = target.ValueProducts(CreateProduct(500));
// assert
Assert.AreEqual(5, FiveDollarDiscount, "$5 Fail");
Assert.AreEqual(5, TenDollarDiscount, "$10 Fail");
Assert.AreEqual(45, FiftyDollarDiscount, "$50 Fail");
Assert.AreEqual(95, HundredDollarDiscount, "$100 Fail");
Assert.AreEqual(450, FiveHundredDollarDiscount, "$500 Fail");
target.ValueProducts(CreateProduct(0));
}

19. SportsStore: A Real Application
 Getting Started
 Starting the Domain Model
 Displaying a List of Products
 Preparing a Database

20. Getting Started
 Creating the Visual Studio Solution and Projects
 Installing the Tool Packages
 Adding References Between Projects
 Setting Up the DI Container
 Running the Application

21. Creating the Visual Studio Solution and
Projects
 Create a Visual Studio solution that contains three projects. One project will
contain the domain model, one will be the MVC application, and the third will
contain the unit tests. To get started, created a new Visual Studio solution called
SportsStore using the Blank Solution template.

22. Creating the Visual Studio Solution and
Projects
Project Name Visual Studio Project Template Purpose
Vic.SportsStore.Domain Class Library Holds the domain entities and
logic; set up
for persistence via a repository
created with
the Entity Framework.
Vic.SportsStore.WebApp ASP.NET MVC Web Application (choose
Empty when prompted to choose a project
template and check the MVC option)
Holds the controllers and views;
acts as the
UI for the SportsStore application.
Vic.SportsStore.UnitTests Unit Test Project Holds the unit tests for the other
two projects

25. Installing the Tool Packages
Install-Package Moq -version 4.1.1309.1617 -projectname Vic.SportsStore.WebApp
Install-Package Moq -version 4.1.1309.1617 -projectname Vic.SportsStore.UnitTests
Install-Package Microsoft.Aspnet.Mvc -version 5.0.0 -projectname Vic.SportsStore.Domain
Install-Package Microsoft.Aspnet.Mvc -version 5.0.0 -projectname Vic.SportsStore.UnitTests

26. Adding References Between Projects
 Right-click each project in the Solution Explorer window, select Add Reference,
and add the references from the Assemblies ➤ Framework, Assemblies ➤
Extensions or Solution sections.
Project Name Solution Dependencies Assemblies References
Vic.SportsStore.Domain System.ComponentModel.DataAnnotations
Vic.SportsStore.WebApp Vic.SportsStore.Domain
Vic.SportsStore.UnitTests Vic.SportsStore.Domain
Vic.SportsStore.WebApp
System.Web
Microsoft.CSharp

27. Setting Up the DI Container

28. Running the Application

29. Starting the Domain Model
 Add Model
 Creating an Abstract Repository
 Making a Mock Repository

30. Add Model
 Create a new folder called Entities inside the Vic.SportsStore.Domain project and
then a new C# class file called Product.cs within it
public class Product
{
public int ProductId { get; set; }
public string Name { get; set; }
public string Description { get; set; }
public decimal Price { get; set; }
public string Category { get; set; }
}

31. Creating an Abstract Repository
 Create a new top-level folder inside the Vic.SportsStore.Domain project called
Abstract and, within the new folder, a new interface file called
IProductsRepository.cs You can add a new interface by right-clicking the Abstract
folder, selecting Add ➤ New Item, and selecting the Interface template.

32. Creating an Abstract Repository
public interface IProductsRepository
{
IEnumerable<Product> Products { get; }
}

33. Making a Mock Repository
private void AddBindings()
{
Mock<IProductsRepository> mock = new Mock<IProductsRepository>();
mock.Setup(m => m.Products).Returns(new List<Product>
{
new Product { Name = "Football", Price = 25 },
new Product { Name = "Surf board", Price = 179 },
new Product { Name = "Running shoes", Price = 95 }
});
kernel.Bind<IProductsRepository>().ToConstant(mock.Object);
}

34. Displaying a List of Products
 Adding a Controller
 Adding the Layout, View Start File and View
 Rendering the View Data
 Setting the Default Route
 Running the Application

35. Adding a Controller
 Right-click the Controllers folder in the Vic.SportsStore.WebApp project and
select Add ➤ Controller from the pop-up menu. Select the MVC 5 Controller –
Empty option, click the Add button and set the name to ProductController. Click
the Add button and Visual Studio will create a new class file called
ProductController.cs
public class ProductController : Controller
{
private IProductsRepository repository;
public ProductController(IProductsRepository productsRepository)
{
this.repository = productsRepository;
}
}

36. Adding a Controller
 Calling the View method like this (without specifying a view name) tells the
framework to render the default view for the action method. Passing a List of
Product objects to the View method, provides the framework with the data with
which to populate the Model object in a strongly typed view.
public ViewResult List()
{
return View(repository.Products);
}

37. Adding the Layout, View Start File and View
 Right-click on the List action method in the HomeController class and select Add
View from the pop-up menu. Set View Name to List, set Template to Empty, and
select Product for the Model Class. Ensure that the Use A Layout Page box is
checked and click the Add button to create the view.

38. Adding the Layout, View Start File and View
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>@ViewBag.Title</title>
</head>
<body>
<div>
@RenderBody()
</div>
</body>
</html>

39. Adding the Layout, View Start File and View
@using Vic.SportsStore.Domain.Entities
@model IEnumerable<Product>
@{
ViewBag.Title = "Products";
}
@foreach (var p in Model)
{
<div>
<h3>@p.Name</h3>
@p.Description
<h4>@p.Price.ToString("c")</h4>
</div>
}

40. Setting the Default Route
public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Product", action = "List", id = UrlParameter.Optional }
);
}

41. Running the Application

42. Preparing a Database
 Setup Development Environment for EF Code-First
 Creating the Entity Framework Context
 Adding Data to the Database
 Creating the Product Repository

43. Creating the Entity Framework Context
Install-Package EntityFramework -projectname Vic.SportsStore.Domain
Install-Package EntityFramework -projectname Vic.SportsStore.WebApp

44. Creating the Database
 The first step is to create the database connection in Visual Studio. Open the
Server Explorer window from the View menu and click the Connect to Database
button.

45. Creating the Entity Framework Context
 Create a context class that will associate the model with the database. Create a
new folder in the Vic.SportsStore.Domain project called Concrete and add a new
class file called EFDbContext.cs within it.
public class EFDbContext : DbContext
{
public DbSet<Product> Products { get; set; }
}

46. Creating the Entity Framework Context
<connectionStrings>
<add name="EFDbContext" connectionString="Data Source=.;Initial Catalog=SportsStore;Persist Security
Info=True;User ID=sa;Password=sa" providerName="System.Data.SqlClient"/>
</connectionStrings>

47. Creating the Entity Framework Context
 Create a context class that will associate the model with the database. Create a
new folder in the Vic.SportsStore.Domain project called Concrete and add a new
class file called EFDbContext.cs within it.
using (var ctx = new EFDbContext())
{
var product = new Product() { };
ctx.Products.Add(product);
ctx.SaveChanges();
}

48. Adding Data to the Database
 In the Server Explorer window, expand the Tables item of the SportsStore
database, right-click the Products table, and select Show Table Data.

49. Creating the Product Repository
 Add a class file to the Concrete folder of the Vic.SportsStore.Domain project
called EFProductRepository.cs
public class EFProductRepository : IProductsRepository
{
private EFDbContext context = new EFDbContext();
public IEnumerable<Product> Products
{
get { return context.Products; }
}
}

50. Creating the Product Repository
 Edit the NinjectDependencyResolver.cs class file
kernel.Bind<IProductsRepository>().To<EFProductRepository>();

51. THANK YOU!
Q&A