DEV Community: Chuen Lee

How to save time writing unit and integration tests with AutoFixture

Chuen Lee — Thu, 05 Sep 2019 10:03:33 +0000

Writing Unit and integration tests are generally composed of setting up relevant test data, carrying the actual execution of the test, and finally making assertions. All this can be summarised as the AAA syntax. That is, Arrange, Act, and Assert.

With AutoFixture, it can significantly save you time by taking away the tedious part of stubbing and arranging test data.

The best way to describe this is to show a traditional test example followed by how it can be replaced with AutoFixture.

A Regular Test

Let's start with a traditional test. In the example below, it demonstrates setting up a customer with fake dummy data. Then the CustomerService is used to save this customer to some data store. This may be a contrived example, but it demonstrates how much time it can take to stub fake data such as this.

Also, note that a Customer in this example has an Address which is another entity that needs to be stubbed.

Libraries do exist to assist in generating fake data such as Bogus. But still one has to write a few lines of code.

public class CustomerTests
{
    [Fact]
    public void AddCustomer_When_valid_customer_should_save_successfully()
    {
        // arrange
        var customer = new Customer
        {
            FirstName = "Paula",
            LastName = "McKinney",
            EmailAddress = "paula_mckinney@fakeemail.org",
            DateOfBirth = DateTime.UtcNow.AddYears(-30),
            Address =
                new Address {
                    AddressLine1 = "4989 Wayside Lane",
                    AddressLine2 = "Hayward",
                    ZipOrPostcode = "94541",
                    Country = "United States"
                }
        };

        // act
        var customerService = new CustomerService();
        customerService.AddCustomer(customer);

        // assert
        // make assertions here.

    }
}

Using Autofixture

Let's take the example above and replace it with AutoFixture. To start using AutoFixture, simply add the nuget package

via package manager in Visual Studio

Install-Package AutoFixture

via dotnet CLI

dotnet add package AutoFixture

 [Fact]
public void AddCustomer_When_valid_customer_should_save_successfully_with_autofixture()
{
    // arrange
    var fixture = new Fixture();
    var customer = fixture.Create<Customer>();

    // act
    var customerService = new CustomerService();
    customerService.AddCustomer(customer);

    // assert
    // make assertions here.
}

Hopefully, you can see that it just takes two lines of code from AutoFixture. Wait. What!? For real? Yes, for real. Just two lines of code. Here are the two lines again:

var fixture = new Fixture();
var customer = fixture.Create<Customer>();

AutoFixture does all the work and just to prove it, here's a screenshot of debugging the test and inspecting the customer object.

You will see that AutoFixture has pre-populated all the fields with dummy data. It has also taken the initiative of stubbing the Address entity as well.

Autofixture Customisations

What if we want to control some of the behaviour of AutoFixture? Take, for example, the customer's date of birth. What if we wanted to set a specific date of birth for the customer as I may want to test some business logic around the date of birth?

To achieve this, you can use the With method to override a particular property.

var fixture = new Fixture();
var customer = fixture.Build<Customer>()
    .With(c => c.DateOfBirth, DateTime.UtcNow.AddYears(-30))
    .Create();

This will set the DateOfBirth to 10 years in the past.

You can also ignore or disable some properties that you do not want AutoFixture to populate. For instance, the example below will ignore the Address property.

var customer = fixture.Build<Customer>()
                .Without(c => c.Address)
                .Create();

Using AutoData

You can take it one step further and use the AutoData attribute.

Be sure to add the nuget package.

via package manager in Visual Studio

Install-Package AutoFixture.Xunit2

via dotnet CLI

dotnet add package AutoFixture.Xunit2

XUnit example

 [Theory, AutoData]
public void AddCustomer_When_valid_customer_should_save_successfully_with_autofixture(Customer customer)
{
    // act
    var customerService = new CustomerService();
    customerService.AddCustomer(customer);

    // assert
    // make assertions here.
}

NUnit example

 [Test, AutoData]
public void AddCustomer_When_valid_customer_should_save_successfully_with_autofixture(Customer customer)
{
    // act
    var customerService = new CustomerService();
    customerService.AddCustomer(customer);

    // assert
    // make assertions here.

}

As you can see from both XUnit and NUnit examples above, the Customer is passed as a parameter in the method. There was no need to use the var fixture = new Fixture(); as you have seen from the earlier examples.

This way of testing can be very useful, as well as saving considerable amount of time coding stub and fake data.

Summary

As you can see, with the introduction of AutoFixture, it can significantly reduce writing test data for the arrangement part of tests and also reduce the amount of code. With less code, less maintenance.

For further examples, checkout AutoFixture's cheat sheet and also the AutoFixture GitHub page.

Docker for beginners - docker file, docker build, docker run, docker compose, what does it all mean?

Chuen Lee — Tue, 27 Aug 2019 10:52:51 +0000

In my previous post, I talked about my learnings of getting started with Docker in Visual studio and a brief intro into the Docker ecosystem.

Visual Studio can get you up and running very fast with Docker, without having to create Docker files and using the Docker command lines. However, I am going to try and explain what a Docker file is, Docker build, Docker run and also Docker Compose and how it all comes together.

Tl;dr:

Docker files describe how to build a Docker image.
The Docker build command builds images based on Docker files
The Docker run command starts a Docker image
Docker compose files combine docker building and running in a single file.

So...What is a Docker file?

A Docker file is in the form of a YAML file that contains a set of instructions that describes what the application needs in order to build it. If you are new to YAML, here's a nice intro.

Taking the sample docker file from this sample which was generated by Visual Studio, it can be broken into 4 stages.

Let's try and break it down.

Stage 1: Specify the runtime

FROM microsoft/dotnet:2.1-aspnetcore-runtime AS base
WORKDIR /app
EXPOSE 80

The first line uses the FROM syntax to define what base docker image to use. In this case, it specifies the dotnet 2.1 runtime.

The next line uses the WORKDIR command which sets the working directory.

The final line of the first step uses the EXPOSE feature which exposes port 80.

Stage 2: Building

The next stage is more involved.

FROM microsoft/dotnet:2.1-sdk AS build
WORKDIR /src
COPY DockerAspNetCoreDemo/DockerAspNetCoreDemo.csproj DockerAspNetCoreDemo/
RUN dotnet restore DockerAspNetCoreDemo/DockerAspNetCoreDemo.csproj
COPY . .
WORKDIR /src/DockerAspNetCoreDemo
RUN dotnet build DockerAspNetCoreDemo.csproj -c Release -o /app

Similar to the first stage, it again uses the FROM syntax to define an image. Notice this time it specifies the dotnet 2.1 sdk rather than the runtime. This is so that it can build the app.

The next line sets the working directory to src. It then uses the copy syntax to copy the csproj file into a new folder within docker called DockerAspNetCoreDemo.

It runs dotnet restore using the copied proj file. It then copies everything and from the current source folder to the docker folder of src. Finally, it runs dotnet build with the release parameter and outputs the files into the app directory which was created in stage 1.

Stage 3: Publishing

The penultimate step below executes the dotnet publish command and has a parameter that specifies the output to the app folder.

FROM build AS publish
RUN dotnet publish DockerAspNetCoreDemo.csproj -c Release -o /app

Stage 4: Setting the entry point

Finally, these steps instruct Docker where the entry point of how to start the application. I suppose it's equivalent to the dotnet-run command.

FROM base AS final
WORKDIR /app
COPY --from=publish /app .
ENTRYPOINT ["dotnet", "DockerAspNetCoreDemo.dll"]

Docker build

Now that we have a Docker file, one can run the docker build command to build a docker image.

Now, if navigate to the root directory of the demo application and run:

docker build DockerAspNetCoreDemo -f DockerAspNetCoreDemo/Dockerfile -t aspnetdemo

You may get an error like this:

C:\Users\chlee\Documents\Github\DockerAspNetCoreDemo>docker build DockerAspNetCoreDemo -f DockerAspNetCoreDemo/Dockerfile -t aspnetdemo
Sending build context to Docker daemon  4.209MB
Step 1/16 : FROM microsoft/dotnet:2.1-aspnetcore-runtime AS base
 ---> f8297fe48f0c
Step 2/16 : WORKDIR /app
 ---> Using cache
 ---> c16c3d21ce14
Step 3/16 : EXPOSE 80
 ---> Using cache
 ---> 6fd93b472bcc
Step 4/16 : FROM microsoft/dotnet:2.1-sdk AS build
 ---> f4bc69f831aa
Step 5/16 : WORKDIR /src
 ---> Using cache
 ---> 782546a1fbc5
Step 6/16 : COPY DockerAspNetCoreDemo/DockerAspNetCoreDemo.csproj DockerAspNetCoreDemo/
COPY failed: GetFileAttributesEx \\?\C:\WINDOWS\TEMP\docker-builder185318480\DockerAspNetCoreDemo\DockerAspNetCoreDemo.csproj: The system cannot find the path specified.

Not great. Why? Well after some research and discovering this git issue comment it turns out that its the way Visual Studio generates the docker file. However, running this in Visual Studio will have no issues.

A Simpler Docker file

With the above docker file specific to Visual Studio, below is a simpler version. This was taken and modified from the docker site

FROM microsoft/dotnet:2.1-sdk AS build-env
WORKDIR /app
EXPOSE 80

# Copy csproj and restore as distinct layers
COPY *.csproj ./
RUN dotnet restore

# Copy everything else and build
COPY . ./
RUN dotnet publish -c Release -o out

# Build runtime image
FROM microsoft/dotnet:2.1-aspnetcore-runtime
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "DockerAspNetCoreDemo.dll"]

Now if you run:

docker build DockerAspNetCoreDemo -f DockerAspNetCoreDemo/Dockerfile-alternative -t aspnetdemo

-f is the filename of the new simpler docker file.
-t specifies a tag for the image, in our case its aspnetdemo.

Then the output will be:

C:\Users\chlee\Documents\Github\DockerAspNetCoreDemo>docker build DockerAspNetCoreDemo -f DockerAspNetCoreDemo/Dockerfile-alternative -t aspnetdemo
Sending build context to Docker daemon  4.209MB
Step 1/11 : FROM microsoft/dotnet:2.1-sdk AS build-env
 ---> f4bc69f831aa
Step 2/11 : WORKDIR /app
 ---> Using cache
 ---> 9025461ed217
Step 3/11 : EXPOSE 80
 ---> Using cache
 ---> 0e3c072cc161
Step 4/11 : COPY *.csproj ./
 ---> Using cache
 ---> 3eadd1126142
Step 5/11 : RUN dotnet restore
 ---> Using cache
 ---> 481f505ae094
Step 6/11 : COPY . ./
 ---> Using cache
 ---> 570fb6690fb4
Step 7/11 : RUN dotnet publish -c Release -o out
 ---> Using cache
 ---> 382bad5ea05e
Step 8/11 : FROM microsoft/dotnet:2.1-aspnetcore-runtime
 ---> f8297fe48f0c
Step 9/11 : WORKDIR /app
 ---> Using cache
 ---> c16c3d21ce14
Step 10/11 : COPY --from=build-env /app/out .
 ---> Using cache
 ---> 07c15508103a
Step 11/11 : ENTRYPOINT dotnet DockerAspNetCoreDemo.dll
 ---> Using cache
 ---> 0eeff78b4f71
Successfully built 0eeff78b4f71
Successfully tagged aspnetdemo:latest

This should have created a docker image, and to confirm this, you can run docker images to list all the images.

You should get something like this:

REPOSITORY          TAG                      IMAGE ID            CREATED             SIZE
aspnetdemo          latest                   0eeff78b4f71        18 minutes ago      506MB
microsoft/dotnet    2.1-aspnetcore-runtime   f8297fe48f0c        45 hours ago        503MB

Docker run

Now that we have an image, we can run the docker run command to start the image and load it into a container.

docker run -d -p 8080:80 --name aspnetapp aspnetdemo

The docker run parameters used can be described below:

-d specifies it's in detach mode, which means it will run in the background.
-p specifies the external port 8080 and the internal port of the image which is 80
--name specifies the name of the container
last parameter, aspnetdemo is the image name that we want to run.

Run the command docker ps to verify it is running. You should see something like this:

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
5a04e20efb39        aspnetdemo          "dotnet DockerAspN..."   38 seconds ago      Up 34 seconds       0.0.0.0:8080->80/tcp   aspnetapp

Finally, if you load in a browser https://localhost:8080 you should see something like this:

What is Docker Compose?

Docker compose is another command where it can be used in conjunction with Docker files. A Docker compose file will tend to have instructions on how to start the application. In general, it will just refer to the Docker file or an existing docker image and also include any app-specific parameters. For instance, in a web app, we can specify ports and any environment variables.

Here is an example of a docker-compose file:

version: '3.4'

services:
  dockeraspnetcoredemo:
    build:
      context: .
      dockerfile: DockerAspNetCoreDemo/Dockerfile
    ports:
        - "8080:80"

Notice that it specifies the docker file DockerAspNetCoreDemo/Dockerfile. If we wanted to specify an image, the compose file will look something like this:

version: '3.4'

services:
  dockeraspnetcoredemo:
    image: aspnetdemo
    ports:
        - "8080:80"

Now, if we run:

docker-compose -f docker-compose.yml up -d

-f specifies the filename
up is the command to "start" the image
-d is the detach mode which runs it in the background

You should see the demo site again if you navigate to https://localhost:8080

Summary

I talked about what is a Docker file is, how to build a docker image from a docker file. Then I walked through how to start a docker image either via the docker run command or via a docker compose file.

I hope this has been helpful and some insight into the Docker world.

You can grab the code from https://github.com/ch-lee/DockerAspNetCoreDemo

Getting started with Docker for C# developers

Chuen Lee — Tue, 06 Aug 2019 10:45:55 +0000

Docker has come a long way since I first came across it in 2015, and now that Microsoft have lot's of support and with the addition of in-built docker tools in Visual Studio, I thought it was time for me to pick up it up.

What is Docker in simple terms?

My interpretation of Docker in a nutshell is:

Docker is a tool that allows you to build, package and deploy your applications.

The statement can be rather vague as there are many tools out there that can achieve the same thing. The difference is that Docker provides a platform where you can package an application such as WordPress, MySQL, Redis, or almost any application (within reason and depending on the application) into whats called an image. You can kind of think it like an iso image, or a zip file as an analogy. You can then transfer this image to another machine, which also is running Docker. Then you can use the host machine to execute or start the image which will in turn start the application, and Docker will run it in whats called a container. That's the gist of it really.

You do not necessarily have to create a Docker image. There are many Docker images that exist and have been packaged already, many which are hosted on Docker hub.

I suppose Docker can be broken down into two areas:

The packaging of an application into a docker image. This is referred to as "dockerizing an application".
Deploying and running the dockerized application, that is, running the docker image in a container.

The easiest way to absorb this is to perhaps start with demonstration.

Install Docker for Windows

Prerequisite:

You will need Windows 10 Pro, Enterprise or Education - As stated in the what you need to know before you install Docker, it requires Microsoft Hyper-V to run. Fortunately, Windows 10 Pro, Enterprise and Education have this enabled. If you have Windows 10 Home, you will unfortunately have to find alternatives.

To check if you have Hyper-V installed, Windows Task Manager will have this:

Side note: I have a Macbook Pro (2015 model) running Boot Camp with Windows, and upon installing Docker, I ran into an issue where it was complaining about virtualization. The error message was "Hardware assisted virtualization and data execution protection must be enabled in the BIOS." What the biscuit?

A bit of Googling I discovered that you need to boot back into Mac OS, and then restart back into Windows, and tada, it's virtualization is enabled.👍

For any troubleshooting, you can visit the Docker For Windows Github Issues

Download and Install

Download Docker from the Docker Store for free. At the time of writing there are two versions, Docker CE (Community Edition) and Docker EE (Enterprise Edition). Docker EE provides commercial support and certified containers. Docker CE is the free version 🙂 and the one we need.

Once installed, Docker will be running in the background and can be found in the Windows task tray and you should have something like this:

Make sure the C: drive is enabled as shown:

Also, in the Advanced menu, you can tailor the desired computing resources:

Dockerize an ASP.NET Core application

I'm using Visual Studio 2017 Community Edition 15.3, but all you need is a Visual Studio version where Docker Tools is installed.

Make sure you are running in Administrator mode.

Create a new ASP.NET Core project

Create a new ASP.NET Core project in Visual Studio, and give it a suitable name.

On the next screen, make sure you..

Select "Enable Docker support"
Select the relevant OS where Docker containers have been set to. I have selected "Linux".
Do not select "Configure HTTPS" - it keeps things simple for now.

Visual Studio will then create two projects:

An ASP.NET Core web project, which includes a Docker file.
A Docker Compose project which instructs Visual Studio how to start the project in a docker container.

Make sure the docker-compose project is marked as the startup project. To do this, just right-click on the project and select "Set as Startup Project".

Start the project by pressing F5 or Debug > Start Debugging.

Side-note
You may get an error such as:
'The DOCKER_REGISTRY variable is not set. Defaulting to a blank string.'

If so, restart Visual Studio in Administrator mode.

Great! You now have a standard sample ASP.NET Core web site running in a docker container.

Note You can run your application in docker mode or standard IIS mode. Simply set the web project as the start-up project in order to run in IIS mode, and set the docker-compose project as the startup project in order to run in docker mode.

How can I tell if Docker is actually running?

You can verify this by launching command prompt or terminal of your choice, and typing:

docker ps

The result will be something like:

CONTAINER ID        IMAGE                      COMMAND               CREATED             STATUS              PORTS                   NAMES
8b49df34dd03        dockeraspnetcoredemo:dev   "tail -f /dev/null"   4 hours ago         Up 4 hours          0.0.0.0:32769->80/tcp   dockercompose8900117491649835616_dockeraspnetcoredemo_1

This command lists running containers and verifies that the ASP.NET application is running in a docker container.

The amazing thing is that breakpoints work as usual in Visual Studio and you can step into your code just like before!

You can checkout the code sample in github:
https://github.com/ch-lee/DockerAspNetCoreDemo