DEV Community: Matheus Rodrigues

Integration Tests In ASP.NET Core Controllers

Matheus Rodrigues — Mon, 03 Sep 2018 11:30:48 +0000

Continuing the series of posts to explore different testing aspects in asp .net core. We’re going experiment with Test Server to create integration tests.

Test Server is a new features that asp .net core is bringing. It creates a browser abstraction, allowing us to simulate application’s behavior without opening a browser.

There are many ways to deal with the database in integration tests. The idea is to not affect the data that’s already in the database. We could use an entirely different database, creating and deleting it every time we run our tests.

Other approach is to use the same database as the application, but clean up data after each test. For example, if we add a register into the database and in the end of the test we remove it.

We can follow a transactional approach. Which means that we create a transaction scope within each unit test to not commit changes when we call .SaveChanges(). Then, when the test is over, this transaction is disposed and no changes are committed to the database.

Entity Framework Core In-Memory database could also be used. Following this approach we won’t have to worry about storing data. But, how can we call this an integration test if we aren’t using a real database? Yeah, that’s right, this approach will fall into the unit test category.

For this post, we’re going to use the transactional approach.

Unit Tests In ASP.NET Core Controllers

Matheus Rodrigues — Mon, 28 May 2018 12:00:15 +0000

In this new series of posts, I want to show different aspects of testing an ASP.NET core application.

I will start in this post showing how to create unit tests for controllers. Then I am going to talk integration test in the controller and explore ASP.NET core new feature, Test Host. After that, let’s see how we can test our application business logic.

Moving to the database realm. I’m going to show how we can create unit tests for code that deals with DbContext, using Entity Framework Core In-memory database feature. And them, how to do integration tests with a real database, with strategies to maintain a database for integration tests.

Let’s jump right into it!

Improving Unit Test Readability In .Net With Fluent Assertions

Matheus Rodrigues — Mon, 16 Apr 2018 12:00:45 +0000

The assertion in unit tests is the phase where we verify if the test result is what we expect. This phase is straightforward, usually it is just one line. But it is not very readable, because it looks something like this: Assert.Equal(“ExpectedResult”, “ActualResult”).

There is no logical order in expected result and actual result parameter, this always confuses me. Other aspect about readability is that it is not human readable. If you try to read a code like this out loud it is not sound that good.

To solve this problem, frameworks to improve readability in assertions were created, like, Fluent Assertions framework for .net. As the name say, this framework use a fluent interface to create readable assertions.

In this post, I’m going to show how Fluent Assertions can improve the unit test readability.

Continue Reading... Improving Unit Test Readability In .Net With Fluent Assertions

Mock Multiple Calls To The Same Method With FakeItEasy, Moq and NSubstitute

Matheus Rodrigues — Mon, 26 Mar 2018 12:00:32 +0000

You can download this article project on GitHub.

Sometimes when doing unit test, we encounter subsequent calls to the same method. When mocking a method the default behavior is to always return the same result.

In this post, I will show how you can mock multiple calls to the same method with the mocking frameworks FakeItEasy, Moq and NSubstitute.

How To: Use EntityFramework Core In-Memory Database For Unit Testing

Matheus Rodrigues — Mon, 19 Mar 2018 13:00:37 +0000

You can download this article project on GitHub.

In this post, I’ll show how to use the in-memory feature of Entity Framework core to create unit tests involving the database. Let’s jump right in!

Create unit tests using a real DbContext is a pain because we have to mock the entire context to achieve this. Entity Framework core makes unit tests easier to write by providing us with an in-memory database provider. It creates an in-memory representation of our DbContext, for this reason, we don’t have to worry about mocking the database.

Getting Started With MongoDB Using ASP.NET Core Web API

Matheus Rodrigues — Mon, 05 Mar 2018 13:00:47 +0000

You can download the code here

Recently, I’m trying to get into NoSQL databases, more specific into document databases.

After some research, MongoDB was my choice to start with. MongoDB is a well know and popular document database, which store JSON-like documents. It’s quite accessible, having drivers supporting major languages and frameworks. Have a great community support with a large number of unofficial drivers.

The goal is to show how to set up a MongoDB instance and how to consume it with a web API in asp.net core.

Softwares needed:

*I used windows 10 to create this tutorial.

Design Patterns and Practices in .Net: Fluent Builder Test Pattern

Matheus Rodrigues — Mon, 08 Jan 2018 11:00:24 +0000

The unit test’s arrange phase is where we write more code. Coding data creation can be cumbersome. The worst scenario happen when we have to fill all class’ properties, even though, we’re only using one property in the test. Besides being tedious, the data creation process can have a lot of code, resulting in less readable and maintainable tests.

To address this problem, we can use the Builder Pattern. The pattern is described in the book design patterns, and solve problems like:

How can a class create different representation of a complex object?
How to simplify a class which creates a complex object?

The Builder Pattern brings more flexibility in a complex object’s creation, by delegating the construction of the complex object to a builder object. The builder object can create different representations of the same complex object.

In this post I’m focus on the unit test side, and I’m gonna show you a different version of the Builder Pattern, the Fluent Builder Test Pattern.

The main goal of the Fluent Builder Test Pattern is to facilitate the test data creation. Joining the Builder Pattern and the Fluent Interface Pattern makes the complex object’s creation straight forward.

How To: Create a Simple Alert System Using Tag Helpers In Asp.Net Core Mvc

Matheus Rodrigues — Mon, 18 Dec 2017 11:00:45 +0000

In this post I’m gonna show you how to create an alert system using the tag helpers feature from the asp.net core mvc.

During this tutorial, I’ll be using a simple to do list project that I build, in order to experiment new stuff, you can download or clone this git repository.

The Problem

Feedback is important for the user, usually, is in form of messages on the screen. We could follow the client-side approach, by, creating an ajax request and showing a message after the response, or instead, follow the server-side approach, storing a message on a view bag, or even return a model with the message.

The asp.net core mvc has a new feature called tag helper, enabling us to create an alert system on the server-side.

Design Patterns and Practices in .Net: Option Functional Type in C#

Matheus Rodrigues — Wed, 27 Sep 2017 00:29:37 +0000

In the functional programming the option type is very used, in languages such as Haskell, F#, Scala and a lot more. In this language it’s a convention to return a value when the function fails. The following example is a function written in F#, to show how the option type works:

(* This function uses pattern matching to deconstruct Options *)
let compute = function
  | None -> "No value"
  | Some x -> sprintf "The value is: %d" x

printfn "%s" (compute <| Some 42)(* The value is: 42 *)
printfn "%s" (compute None) (* No value *)

We have no equivalent of the option type in the C# language , but we can try to emulate it.

In my last post, I discussed two design patterns, Null Object and the Special Case Object, the goal of these patterns are to return a special object instead of return null. If you didn’t read that post, go check it and come back to this post.

The idea in this post is to show the implementation of the option type in C#.

Problem

The problem is very similar to my last post, in fact it’s the continuation of that same problem.

public IProduct GetProductById(int productId)
{
    Product product = _productRepository.GetProductById(productId);

    if(product == null)
        return new ProductNotFound();

    return product;
}

Design Patterns and Practices in .Net: Null Object and Special Case Object

Matheus Rodrigues — Mon, 25 Sep 2017 23:41:02 +0000

In programming null is an awkward thing to deal with, when you return a variable and it’s possible to be a null, you have to remember to make null checks all around your code.

The null object and the special case object are patterns that try to reduce this type of boiler plate code.

A null object is an object that doesn’t have a referenced value, is an object with a default behavior. A behavior which represents a missing object.

Special case object is very similar to the null object, but it’s an improvement over the null object, because instead of creating a generic “missing object”, you are creating a more specialized object that can suit better your needs.

The goal of these two pattern is to return a null or a special case version of an object, instead of return a null reference.

Problem

Many times we caught ourselves making this type of check:

public Product GetProductById(int productId)
{
    Product product = _productRepository.GetProductById(productId);
    if(product == null)
        throw new Exception("Product Not Found");
    return product;
}

How To Get appsettings.json Data In Asp.Net Core MVC

Matheus Rodrigues — Mon, 25 Sep 2017 23:17:48 +0000

You can download this sample from this git repository.

In this tutorial I’ll show you how to get the data from appsettings.json using the built-in dependency injection in Asp.Net Core MVC.

Let’s start right away \o/

First, you need to create a project in visual studio. I’m using visual studio 2017 community with .net core version 1.1.

New ASP.NET Core Web App Project

I’m creating an ASP.NET Core Web Application, that’s the new version of the mvc framework.

Unit Test And Time Dependency

Matheus Rodrigues — Mon, 25 Sep 2017 01:27:50 +0000

When you start to write unit tests, inevitably you’ll encounter a hard time when a functionality depends on time. Depend on DateTime.Now doesn’t work well for unit testing, your tests will pass on certain time of day and fail in others.

To resolve this problem we need to isolate the time dependency of system, to be able to make our unit test reliable.

Example

So, we have a shop that gives some discount based on the hour of the day, and we have a method that return how much the discount will be:

public class Shop
{
    //Constructor
    //public Shop(.....

    //Other Implementations
    //.....

    public int GetCurrentDiscount()
    {
        switch (DateTime.Now.Hour)
        {
            case 9:
                return 30;
            case 12:
                return 20;
            case 18:
                return 40;
            default:
                return 0;
        }
    }
}