is moq open source?

The most popular and friendly mocking framework for .NET

CI package feed: https://pkg.kzu.io/index.json

Running tests:

You can either build from command line or explicitly Pack (from the context menu) the Moq.Package project.

Packages are generated in the bin folder in the repository root. To test these packages you can just add a package source pointing to it. You can also just place a NuGet.Config like the following anywhere above the directory with the test solution(s):

You can also do use project properties (or a Directory.Build.props to affect an entire folder hierarchy) with:

Every time the packages are produced, the local nuget cache is cleared, so that a subsequent restore in VS will automatically cause the updated version to be unpacked again. The locally built version will always have the version 42.42.42.

Special thanks to the following gold sponsors of this project:

And to all our sponsors!

The Moq framework is an open source unit testing framework that works very well with .

However, during Unit Testing, we must focus on testing the logic of only that unit and hence must control the impact of the dependencies.

To ensure this, we use a technique called “mocking”.

Mocking is a process where dependencies are replaced by controlled replacements that simulate the behavior of the real dependencies.

NUnit is a unit testing framework for .NET languages, and Moq is the most popular mocking framework for .NET.

I assume the reader is familiar with C# projects, Visual Studio IDE, and the Nuget package manager for managing dependencies.

I will cover creating Unit tests using NUnit and Moq.

We will create a sample .NET console project using Microsoft Visual Studio 2015 IDE. This sample project will calculate an employee’s tax amount. This will be a simple application. I will describe the step-by-step process of creating the test project, adding unit tests using NUnit, and mocking the dependencies using moq.

Using Moq, you can mock out dependencies and make sure that you are testing the code in isolation.

Moq is a mock object framework for .NET that greatly simplifies the creation of mock objects for unit testing. Mocking is a popular technique for unit testing that creates test double objects, which gives you the ability to control the behavior of those objects by setting their outcomes.

This article will show you how to unit test your C# code with Moq.

Test doubles are objects that mimic the behavior of real objects in controlled ways. The goal of test double objects is to allow for the concise development of tests that affect only one object in isolation. Mocking frameworks allow for the separation of a system under test from its dependencies to control the inputs and outputs of the system under test.

In a nutshell, a test double is a fake object used to ensure the behavior of some external system is the same as the original object.

For example, suppose you’re building a web application, which gets data from a database. If you want to write tests for that application, you would need to provide a clean, pre-populated database with real data for every test. This is where test double comes into play. It can substitute the concrete class that performs database fetch and return fake data. But the code you are testing won’t know the difference. This assumes you are using dependency injection in your code. So you can easily replace one implementation of an interface with another in tests.

Faking objects is a modern software engineering practice. By mocking objects, you ensure your unit test only covers the code you actually want to test. This also means your test code can be fast since your testable code is isolated from its environment.

Even though all these fake objects are often called mocks, when I’m talking about mocks, I distinguish them from stubs.

A stub object is a fake object used to test some unit of code without using a real object. The idea is that you can simulate an object’s behavior by setting up some test code that will throw errors, return incorrect data, or otherwise do what an object would do in certain situations. This allows you to run tests without connecting to a database or make any other calls to the outside world. This is important in tests because you don’t want to wait for a web call to run the test.

A mock object goes a bit further. When you use it in your unit test case, it checks that the system under test interacts with other objects as expected. It can check that a dependency was called with specific arguments or that a certain call didn’t happen.

The outcome of the unit test is then checked against the mock object.

You can learn a lot more about mock vs. stub difference and find out when to use each of them in my separate blog post.

The Moq framework is a set of interfaces that allow you to stub or mock your code for unit testing purposes. Clarius, Manas, and InSTEDD developed it to facilitate the writing of unit tests. Due to the framework’s ability to create test doubles, it is often used to develop automated tests.

The biggest benefit of using this mocking framework is that it can create those test doubles, dependencies on the fly. This greatly improves the speed of writing unit tests (since many developers don’t have time for testing). You can use it for testing code that interacts with web services, databases, or any other class that is likely to be used in a unit test.

The result is that you can verify that your code behaves the way it is supposed to and quickly discover when a bug occurs.

To install the Moq framework to your test project, you can easily add it as a NuGet package:

The other option is to select your unit test project and manage NuGet packages through UI.

There are many benefits of using the Moq testing framework:

Let’s see some examples of how to use Moq while writing unit tests in C#.

We have the following AccountService class that has dependencies on IBookService and IEmailSender.

We want to test these three methods, GetAllBooksForCategory, GetBookISBN, and SendEmail. The methods use the IBookService and IEmailSender dependency.

You will see how to use Moq to have a fake instance of IBookService.

What about IEmailSender? Should you also create a fake instance of it in your tests? Well, you don’t need to if you test GetAllBooksForCategory and GetBookISBN methods. They don’t use the email sending module, and that’s why feel free to pass null in those tests to the AccountService constructor.

You can use Moq to provide fake instances of the dependencies, but if the test will pass with null, use the null value instead. This will decrease the logic in your unit test and make it simpler to understand.

Later, when we test the SendEmail method of the AccountService, we will use Moq to create a mock instance of the IEmailSender.

I will create a new test class AccountServiceTests, to write tests for these methods. If you want to learn how to name your methods, classes, and unit test project properly, I suggest you read the post about unit testing naming conventions.

The first method, GetAllBooksForCategory, is simple. It queries the IBookService and returns the result. To write a unit test that will check that the method works as expected, we need to write a stub for the IBookService.

What does the code mean in the GetAllBooksForCategory_returns_list_of_available_books unit test:

You can see in the test runner output window that the test passes if you run the test. This means that the fake service has returned 3 books when called.

The next method of AccountService we want to test is the GetBookISBN. It uses two methods of the IBookService, GetBooksForCategory and GetISBNFor.

If you run the test, it should pass.

Before we move to implement mocks with the Moq, let me show you some common usage examples.

In the last example, I have used the parameter matching to set up the fake object. This expects that the method is called with the “UnitTesting” paremeter.

However, you can simplify this. If you don’t care about the input parameter of the mocked method, you can use It.IsAny.

Example:

Sometimes, you want to check your code’s robustness and resistance to failure by throwing an exception. To throw an exception, use the Throws mock function:

Often, you need to set up properties of an interface to return a specific value:

If you want to stub all properties, you can use the StubAllProperties setup method:

Moq support various event’s setup options:

The Callback method is a nice way to capture the parameter that was passed to a method. Let’s take a look at the following test.

In this example, the passedParameter variable will get the value “UnitTesting”. That’s the value that was passed to the GetBooksForCategory method.

There are also times when you will call a single method multiple times during a single test. In that case, you can choose what value will be returned on every call.

Creating mocks and verifying expectations in unit tests using can be a tricky and frustrating process. Especially if you don’t use a mocking framework. Then you need to implement your mocks manually and track which method was called and when.

If you use a Moq and know how to set up mocks, this doesn’t have to be difficult. You just need to follow a few simple steps, and you can create effective mocks and verifying code that works for you.

The easiest way to understand how mocks works is by writing a test.

We want to test that the SendEmail method calls IEmailSender with correct arguments. We can’t test the actual email sending, since that wouldn’t be a unit test anymore.

The test does the following:

Modern applications are typically made up of large microservices with many different moving parts. When you’re writing these sorts of applications, the applications need to talk asynchronously. But it also important to test your code.

Unit testing asynchronous code is the black sheep of the software testing world. For some reason, it’s often thought to be so difficult that people avoid it altogether.

This can be a huge mistake because testing asynchronous code is not only possible but also relatively straightforward.

So, how can you tell Moq to return a Task or Task?

Well, you can use ReturnsAsync:

Starting with Moq 4.16, you can also use the Returns method by combining it with the Result property of your task:

Modern applications use exceptions to signalize that the error has occurred or something unexpected has happened. When you get an exception in your code, there is a whole chain of events that occur. The exception usually propagates through the call stack until it is handled properly.

While writing unit tests, you want to cover cases where an exception will happen if the input is invalid.

Luckily, Moq also covers this.

Can you have more than one mock instance in a single test method? The answer is an absolute yes.

Should you have more than one mock instance? The answer is absolutely no.

You can have several stubs and one mock, but avoid having more then one mock in a single test case.

What’s the problem if you have more than one mock in a single unit test?

If you have two or more mocks that you are asserting against in your test, this means you are probably checking more than one scenario. Remember, a single unit test should only cover one scenario of your system under test. By checking more scenarios, you are making the test more unstable and less maintainable. Once the test fails, you need to go and check every object you have mocked to see what’s the issue. And this will take more time if you have multiple mocks.

The best thing you can do for your unit test is to make it as simple as possible.

You should write unit tests to test the smallest possible piece of functionality in an application. By isolating the unit tests from any external influence, you can be sure that the test is testing the functionality and not some other part of the application that may change in the future.

While mocking a class is not recommended, it is possible to do so. To make a class mockable, it needs to be a public class, and the method you want to mock has to be virtual.

Yes, you can use Moq with MSTest. Moq should support every popular unit testing framework, including xUnit, NUnit, and MSTest.