Architecting an ASP.NET Core MVC Application for Unit Testability

Want to quickly and easily know if your app is working? You'll need automated tests. This course will show you how to architect an ASP.NET Core app so that you can write great automated unit tests.
Course info
Rating
(40)
Level
Advanced
Updated
Dec 31, 2018
Duration
5h 48m
Table of contents
Course Overview
What Should I Test?
Using Abstraction to Test the User Interface
Overthrowing the Tyranny of the Database with Repository and Adapter Patterns
Leveraging the Strategy Pattern to Encapsulate Business Logic
Invoking the Right Logic and Loading the Correct Page
Testing Security: Authorization & Policies
Testing Security: Custom Logic & Middleware
Validating Your Web API Service Code
Description
Course info
Rating
(40)
Level
Advanced
Updated
Dec 31, 2018
Duration
5h 48m
Description

You need unit tests if you want to know if your app is really and truly working. The problem is that it's not always easy to do. In this course, Architecting an ASP.NET Core MVC Application for Unit Testability, you will gain the ability to design your apps for testability. First, you will learn about the architectural design patterns that help make your application easy to test, refactor, and maintain. Next, you will discover how to apply these architectural design patterns in order to implement testable ASP.NET Model-View-Controller code and testable database code using Entity Framework Core. Finally, you will explore how to apply these design patterns to create testable security code, validation code, and Web API code. When you are finished with this course, you will have the skills and knowledge of software architecture and unit testing needed to design your ASP.NET Core apps for testability.

About the author
About the author

Benjamin Day is a consultant and trainer specializing in software development best practices using Microsoft-based technology. He is a Microsoft Visual Studio ALM MVP, a certified Scrum trainer via Scrum.org, and a speaker at conferences such as TechEd, DevTeach, and VSLive. He can be contacted via http://www.benday.com.

More from the author
Azure DevOps: Getting Started
Beginner
5h 14m
Jul 19, 2019
More courses by Benjamin Day
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
(Music playing) Hey everyone, my name is Ben Day and welcome to my course, Architecting an ASP.NET Core MVC Application for Unit Testability. I'm a developer, trainer, coach, and I specialize in helping teams and companies get good at software delivery, whether that's helping them with scrum or software testing or software architecture, or just listening to them vent. It's all in the goal of helping them deliver great done working software. Which brings us to the topic of this course, Unit Testing in ASP.NET Core. So if you've watched my other courses on DevOps or Team Foundation Server, you might have noticed that there's kind of a big hole in them. I don't talk a lot about unit testing, although I always say that it's really important. It's essential for the success of projects, the maintenance of software, and for great automated DevOps pipelines. So while I've always said in my courses that unit testing is really important, I've never really showed you how to do it. Well, I'm finally doing it! And you can kind of think of this class as being the missing modules from all my other classes. So, unit tests. What are they? Unit tests are little chunks of code that exercise and validate chunks of code in your application. And while that sounds easy enough, when your application starts getting complicated, it oftentimes gets harder and harder and harder to write unit tests. This course is going to talk about how to design an ASP.NET Core MVC and Web API application for unit testability. Now, if you're not using .NET Core yet, don't despair, almost all the architectural techniques and designs I'm going to show in this course will work in regular .NET, too. Some of the things we're going to talk about, why unit test, and what should a unit test? How do you unit test the user interface? How do you unit test database code? What about unit testing validations and calculations, or testing security logic? We'll cover all that, and through it all, we're going to talk a lot about the design patterns you need in order to architect your application for testability and maintainability. By the end of this course, you'll know more than enough to architect and build a testable app using ASP.NET Core MVC and Web API. So, I hope you'll dive in on this course and learn to write great unit tests for your ASP.NET Core apps with my Architecting in ASP.NET Core MVC Application for Unit Testability course here at Pluralsight.