Gain insights into unit testing principles, and delve into configuring and using NUnit. Discover how to write effective tests, maximize coverage, and elevate your testing projects.

Dockerfile.tar.gz

Iteration1

Iteration2

AssertTrueExample

AssertTrueExercise

AssertNullExample

AssertNullExercise

GeneralJob

WebAppWithoutTest

MSTest

XUnit

ConsoleWithoutTest

GeneralJobFIX

WebAppWithoutTestFIX

WebAppWithoutTestNIAZ

NiazSolution

Industry, employers, startups, and amateur developers are increasingly looking towards unit testing their software. Unit testing is one of the most reliable ways to find and keep software bugs at bay, thus reducing costs and development pains. Developers working with the .NET framework are overwhelmingly turning to NUnit to meet their unit testing needs.

In this course, you’ll learn the principles of unit testing, and in the process, learn to configure and use the NUnit testing framework. Given that the course places an emphasis on principles, these skills are transferable to other unit testing frameworks. Alongside these, you’ll also get hands-on experience with projects and exercises that provide ample opportunities to learn how to design effective tests in the NUnit framework.

At the end of the course, you’ll be able to quickly write unit tests that maximize logical coverage, test complex applications, and better organize your testing projects—setting you up as a natural leader in your organization.

Mastering Unit Testing Principles with NUnit

# Introduction

This lesson presents the solution to the challenge to use mocks on loosely coupled code. The solution test code will be presented followed by a detailed walkthrough.

# Solution

The project solution is shown below. Run the test to confirm that all tests pass.

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

# Solution walkthrough

The test code is split across one `Setup` method and three test methods. One test method tests whether the controller returns `charged` when a card is charged. The two remaining test methods test whether the controller returns `not charged` when a card is not charged due to the payment service. Furthermore, it tests whether the controller returns `not charged` - you have selected too many special requests when there are too many special requests.

## The `Setup` method

In the `Setup` method, the controller has three dependencies, and all three dependencies are mocked. Thereafter, the `ICartItem` is set up to return a dummy value, which in this case is `10` when the `Price` property is invoked.  This cart item mock is inserted in a list of items. Before it is included in the list, an instance of the mock is created with the call to `Object`. The variable `items` is therefore a list that contains a single mock instance of `ICartItem`.

Next, the `ICartService` mock is set up to return this list containing one item when the `Items` method is invoked. Finally, the controller is instantiated with all three mock dependencies. Again, we use the `Object` method to create instances of these mocks. Since this whole process is common across both test methods, it is included in the `Setup` method.

These steps are included in **lines** **34-46** in the `CartControllerTest.cs` file.

## First test method

We first set the number of special requests to any number below `10` (**line** **67**).
The `ShouldReturnCharged()` method first sets up the payment service mock's `Charge` method to return `true` when any `double` value and card mock object is given (**line** **68**). The `IsCartCheckoutValid` method is set up to return `true` when the input parameter is any value below `10` (**line** **69**). The `CheckOut` method is called (**line** **70**) using instances of the card and address mocks. Next, we verify that the `Ship` method from `IShipmentService` is invoked once (**line** **71**). Finally, we assert that the controller returns `charged` (**line** **72**).

## Second test method

We first set the number of special requests to any number below `10` (**line** **82**).
The `ShouldReturnNotCharged()` method first sets up the payment service mock's `Charge` method to return `false` when any `double` value and card mock object is given (**line** **83**). The `IsCartCheckoutValid` method is set up to return `true` when the input parameter is any value below `10` (**line** **84**). The `CheckOut` method is called using instances of the card and address mocks (**line** **85**). Next, we verify that the `Ship` method (from `IShipmentService`) is not invoked (line **86**). Finally, we assert that the controller returns the `not charged` string (**line 87**).

## Third test method

We first set the number of special requests to any number above `10` (**line** **98**).
The `ShouldReturnNotCharged()` method first sets up the payment service mock's `Charge` method to return `false` when any `double` value and card mock object is given (**line** **99**). The `IsCartCheckoutValid` method is set up to return `true` when the input parameter is any value below `10` (**line** **100**). The `CheckOut` method is called using instances of the card and address mocks (line **101**). Next, we verify that the `Ship` method (from `IShipmentService`) is not invoked (**line** **102**). Finally, we assert that the controller returns `not charged` (**line** **103**).

# Conclusion

The content presented above contains the solution to the project in the previous lesson. Once you've compared your attempt to the solution above, ask yourself the following questions:
- Are there any areas of code that you missed?
- Between your code and the solution, which areas differed and why?
- If you could not complete some code lessons, look at the solution and then attempt those lessons of the project again.
- Could any of the code in the solution above be improved?

Learn the solution to the mocking challenge and learn from your mistakes.

Fundamentals of Unit Testing

Testing Conditions With Classic And Fluent Assertions

Making Unit Testing More Effective

Unit Testing Code with External Dependencies

Conclusion

Appendix - Unit Test Project Organization and Console Setup

Solution: Using Mocks on Loosely Coupled Code

Introduction

Solution

Solution walkthrough

The `Setup` method

Solution: Using Mocks on Loosely Coupled Code

Introduction

Solution

Solution walkthrough

The Setup method

The `Setup` method