# Quick glance at Moq

Moq is a mocking framework built to facilitate the testing of components with dependencies.

As shown earlier, [dealing with dependencies](https://docs.educationsmediagroup.com/unit-testing-csharp/unit-testing/dealing-with-dependencies) could be cumbersome because it requires the creation of test doubles like fakes.

Moq makes the creation of fakes redundant by using dynamically generated types. Its API is built around lambda constructs to ensure tests are strongly typed, easy to read and quick to write. It also provides a string-based API to mock protected methods.

There is an exhaustive Quickstart page available [here](https://github.com/Moq/moq4/wiki/Quickstart) for quick reference.

Note: at the time of writing the latest version of Moq is the 4.14 but a 5.0 is in the writing.

## Example

Let's take as an example the class below. It accepts a dependency of type `IFoo` via its constructor and it uses it in its `Ping` method.

```csharp
public class Service
{
    private readonly IFoo _foo;

    public Service(IFoo foo)
    {
        _foo = foo ?? throw new ArgumentNullException(nameof(foo));
    }

    public void Ping()
    {
        _foo.DoSomething("PING");
    }
}

public interface IFoo
{
    bool DoSomething(string command);
}
```

Let's write a test that uses Moq to verify that the method `Ping` uses the `IFoo.DoSomething` method by passing it a well-known string.

```csharp
[Test]
public void Ping_invokes_DoSomething()
{
    // ARRANGE
    var mock = new Mock<IFoo>();
    mock.Setup(p => p.DoSomething(It.IsAny<string>())).Returns(true);
    var sut = new Service(mock.Object);

    // ACT
    sut.Ping();

    // ASSERT
    mock.Verify(p => p.DoSomething("PING"), Times.Once());
}
```

The unit test in the snippet is quite condensed and few things are happening. Let's look at it line by line.

```csharp
var mock = new Mock<IFoo>();
```

Initially, a new mock is created by specifying the mocked type. In this example, the created object is of type \`Mock´.

```csharp
mock.Setup(p => p.DoSomething(It.IsAny<string>())).Returns(true);
```

Next, the mock is configured by using the method `Setup` to specify incoming parameters and return values.

* The `Setup` construct is used to configure expectations on the invocations of a method of the mocked type. At this time developers can set expectations on the incoming parameters too. In this case, Moq is instructed using the `It.IsAny<string>()` method to accept any string.
* The `Returns` construct is used to specify the return values of the mocked method.

In this case, Moq is instructed so that any invocation (i.e. any `string`) of the method `DoSomething` returns `true`. Thanks to Moq's strongly-typed API, it's impossible to configure a method with wrong types.

```csharp
var sut = new Service(mock.Object);
```

Once the mock is configured, the mocked object can be accessed or fed to the system under test's constructor using the `Object` property.

This concludes the *Arrange* phase of the test.

```csharp
sut.Ping();
```

This line represents the *Act* phase of the test: the system under test is exerted by invoking its `Ping` method.

```csharp
mock.Verify(p => p.DoSomething("PING"), Times.Once());
```

Finally, we can use the `Verify` method to verify that the expected call had actually happened. In this example, we verify that `DoSomething` was invoked exactly once with the string `"PING"` as parameter.

Once created, a mock keeps track of every invocation on the mocked object and gives developers the possibility to verify that a specific call has occurred.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.educationsmediagroup.com/unit-testing-csharp/moq/quick-glance-at-moq.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.