Book Overview & Buying
Table Of Contents

C# and .NET Core Test-Driven Development

By : Ayobami Adewole

3 (7)

Buy this Book

C# and .NET Core Test-Driven Development

3 (7)

By: Ayobami Adewole

Buy this Book

Overview of this book

This book guides developers to create robust, production-ready C# 7 and .NET Core applications through the practice of test-driven development process. In C# and .NET Core Test-Driven Development, you will learn the different stages of the TDD life cycle, basics of TDD, best practices, and anti-patterns. It will teach you how to create an ASP.NET Core MVC sample application, write testable code with SOLID principles and set up a dependency injection for your sample application. Next, you will learn the xUnit testing framework and learn how to use its attributes and assertions. You’ll see how to create data-driven unit tests and mock dependencies in your code. You will understand the difference between running and debugging your tests on .NET Core on LINUX versus Windows and Visual Studio. As you move forward, you will be able to create a healthy continuous integration process for your sample application using GitHub, TeamCity, Cake, and Microsoft VSTS. By the end of this book, you will have learned how to write clean and robust code through the effective practice of TDD, set up CI build steps to test and build applications as well as how to package application for deployment on NuGet.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Exploring Test-Driven Development

Difficulty in maintaining code

How does bad code appear?

What we can do to prevent bad code

The principles of test-driven development

The TDD cycle

Summary

Getting Started with .NET Core

.NET Core framework

Structure of a .NET Core application

Tour of Microsoft's Visual Studio Code editor

A look at the new features of C# 7

Creating an ASP.NET MVC Core application

Summary

Writing Testable Code

Warning signs when writing untestable code

Law of Demeter

The SOLID architecture principles

Setting up a DI container for ASP.NET Core MVC

Summary

.NET Core Unit Testing

The attributes of a good unit test

Unit testing framework ecosystem for .NET Core and C#

Unit testing consideration for ASP.NET MVC Core

Structuring unit tests with xUnit

xUnit.net shared test context

Live unit testing with Visual Studio 2017 Enterprise

Proving unit test results with xUnit.net assertions

The test runners available on both .NET Core and Windows

Summary

Data-Driven Unit Tests

The benefits of data-driven unit testing

xUnit.net theory attribute for creating data-driven tests

Inline data-driven unit tests

Property data-driven unit tests

Integrating data from other sources

Summary

Mocking Dependencies

The benefits of mocking objects

The shortcomings of mocking frameworks

Hand-rolling mocks versus using a mocking framework

Mocking objects using Moq framework

Summary

Continuous Integration and Project Hosting

Continuous integration

Continuous delivery

GitHub online project hosting

Basic Git commands

Configuring GitHub WebHooks

TeamCity CI platform

Summary

Creating Continuous Integration Build Processes

Installing the Cake Bootstrapper

Writing build scripts in C#

Cake Extension for Visual Studio

Using Cake tasks to build steps

CI with Visual Studio Team Services

Summary

Testing and Packaging the Application

Executing xUnit.net tests with Cake

.NET Core versioning

.NET Core packages and metapackages

Packaging for NuGet distribution

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

The SOLID architecture principles

Software application development procedures and methodologies, from the first step to the last step, should be simple and easily understood by both novices and experts. These procedures, when used in combination with the right principles, make the process of developing and maintaining software applications easy and seamless.

Developers from time to time adopt and use different development principles and patterns in order to simplify complexities and make software applications code bases maintainable. One such principle is the SOLID principle. This principle has proven to be very useful and a must-know for every serious programmer of object-oriented systems.

SOLID is an acronym of the five basic principles of developing object-oriented systems. The five principles are for class design and are denoted as: