JustMock allows you to easily isolate your testing scenario and lets you focus on the logic you want to verify. It integrates seamlessly with your favorite unit testing framework and makes unit testing and mocking simple and fast. JustMock utilizes a AAA pattern that helps you keep your unit tests well structured, clean and readable. It comes with one intuitive, fluent and easy-to-use API with better discoverability.

Mock everything like non-virtual methods, sealed classes, static methods and classes, as well as non-public members and types everywhere even members of MsCorLib. JustMock makes testing legacy code easier and saves time and effort by implicitly creating each individual dependency as a unique mock and further ensures stable unit tests. JustMock works seamlessly in your continuous build configuration like TFS, Jenkins, TeamCity and other build servers.

JustMock integrates perfectly with Visual Studio 2010 - 2019, as well as with other tools such as DotCover, OpenCover, NCrunch, PostSharp and more.

Mock Everything
JustMock lets you mock anything with ease. It provides support for mocking of: Interfaces, Virtual Methods, Abstract Methods, Events, Properties, Generics, Strict and Loose Mocking, Asserting Behavior, Argument Matching and Ignoring, Sequential Mocking, Recursive Mocking, Sealed classes, Structs, Static classes, Static Methods and Static Properties, Non-virtual methods and Properties, Non-public members and types, LINQ queries, SharePoint Mocking, Local Functions, Ref Return Values and Ref Locals and more.

Mocking MsCorLib Members
Mocking .NET framework members (a.k.a. MsCorLib) can be a daunting task. But with JustMock you can arrange against any MsCorLib member or function including DateTime.Now without any additional set-up.



Testing Legacy Code – Automocking
JustMock makes testing legacy code easier with its intelligent, fully profiled automocking feature, which makes your unit tests more stable. Fully profiled automocking saves you time and effort by creating an instance of a class (the system under test) without having to explicitly create each individual dependency as a unique mock.

Makes Tests More Stable
By isolating the tested logic from the implementation of its dependencies JustMock allows you to create more stable tests independent from outer conditions.

TFS (including Web based builds)
The JustMock TFS extension is designed to deploy your JustMock test projects by wrapping VSTest tasks and setting all required environment variables. In this way JustMock free you from tedious configuration of environmental variables, providing you simple options that can get you on the move in no time.

Jenkins
You can integrate JustMock with Jenkins CI process by using JustMock MSBuild Tasks. This could be appropriate if you have predefined XML for your build process to follow. Another approach for integrating TelerikJustMock with Jenkins is provided by the Execute Windows batch command build step in the Jenkins job configuration. To see how to execute JustMock test DLLs via the Command Prompt, refer to Windows Batch Command.

TeamCity
Similar to Jenkins integration you can integrate JustMock with TeamCity by using JustMock MSBuild Tasks. Another approach for integrating TelerikJustMock with TeamCity is provided by the "Command Line" runner type build step in the project build configuration. To see how to execute JustMock test DLLs via the Command Prompt, refer to Windows Batch Command.

Installation Free Elevated Mocking
With a bit more effort you could use the JustMock profiler without installing it on the build machine or registering it to the build machine registry.

Visual Studio Integration
Through its own extension JustMock integrates seamlessly with Visual Studio 2019, 2017, 2015, 2013, 2012 and 2010. It also integrates with Visual Studio profiler and code coverage tools. Visual Studio is not required by JustMock on the build machine.

Other Tools
JustMock integrates seamlessly with other tools such as dotCover, OpenCover, NCover, NCrunch, PostSharp and even test runners like TestDriven.Net. Supported testing frameworks include MsTest, MSTest 2, NUnit, xUnit, MSpec.

What is Mocking?
Mocking is a process used in unit testing when the unit being tested has external dependencies. The purpose of mocking is to isolate and focus on the code being tested and not on the behavior or state of external dependencies. In mocking, the dependencies are replaced by closely controlled replacements objects that simulate the behavior of the real ones. There are three main possible types of replacement objects - fakes, stubs and mocks.

Fakes: A Fake is an object that will replace the actual code by implementing the same interface but without interacting with other objects. Usually the Fake is hard-coded to return fixed results. To test for different use cases, a lot of Fakes must be introduced. The problem introduced by using Fakes is that when an interface has been modified, all fakes implementing this interface should be modified as well.

Stubs: A Stub is an object that will return a specific result based on a specific set of inputs and usually won’t respond to anything outside of what is programed for the test. With JustMock you can create a Stub in a test with a minimal amount of code, making it clear how the dependency will respond and how the tested system should behave.

Mocks: A Mock is a much more sophisticated version of a Stub. It will still return values like a Stub, but it can also be programmed with expectations in terms of how many times each method should be called, in which order and with what data. With JustMock you can create a Mock with just one line of code, which makes the test more understandable.

As Simple as AAA
This simple pattern, Arrange, Act, Assert (AAA) makes it easy to quickly and intuitively mock objects in unit tests.

Arrange: Initializes objects, creates mocks with arguments that are passed to the method under test and adds expectations.
Act: Invokes the method or property under test with the arranged parameters.
Assert: Verifies that the action of the method under test behaves as expected.
With AAA, there is always a single starting point and options are contextually valid. The AAA pattern helps you keep your unit tests well structured, clean and readable. This pattern stays the same, regardless of what you are mocking.



Only for V.I.P