# Integration with Moq

Like for NUnit, AutoFixture offers a glue library for Moq.

By using this library, AutoFixture can use Moq to handle the requests for non-concrete types like abstract classes and interfaces. Optionally, AutoFixture can delegate to Moq the creation of [fake delegates](https://docs.insightarchitectures.com/unit-testing-csharp/moq/delegates).

The library is contained in the [`AutoFixture.AutoMoq`](https://www.nuget.org/packages/AutoFixture.AutoMoq/) NuGet package.

The `AutoMoqCustomization` is the core of the integration of AutoFixture with Moq. By adding an instance of this class to the fixture, requests for non-concrete types will be handled by Moq.

```csharp
var fixture = new Fixture();
fixture.Customize(new AutoMoqCustomization());
```

The snippets below are based on the following types

```csharp
public class Service
{
    public Service(IDependency dependency, AbstractType innerObject)
    {
        Dependency = dependency ?? throw new ArgumentNullException(nameof(dependency));
        InnerObject = innerObject ?? throw new ArgumentNullException(nameof(innerObject));
    }

    public IDependency Dependency { get; }

    public AbstractType InnerObject { get; }
}

public interface IDependency
{
    void DoSomething(Action<string> action) { action("Hello world"); }
}

public abstract class AbstractType
{
    public int IntValue { get; set; }

    public string StringValue { get; set; }
}
```

## Requesting objects

Once a fixture is enriched with `AutoMoqCustomization`, developers can use it to request anonymous instances of non-concrete types.

This can be done in these ways.

* By requesting directly the type to be mocked. In this case an [implicit mock](https://docs.insightarchitectures.com/unit-testing-csharp/moq/implicit-mocks) will be returned.
* By requesting for a mock of the type. In this case an instance of `Mock<T>` will be returned.

It is important to note that [*freezing*](https://docs.insightarchitectures.com/unit-testing-csharp/type-customization#freeze) is supported in both cases.

```csharp
[Test]
public void Freezing_is_supported_when_requesting_type()
{
    // ARRANGE
    fixture.Customize(new AutoMoqCustomization());
    var dependency = fixture.Freeze<IDependency>(); // freezing the type directly

    // ACT
    var sut = fixture.Create<Service>();

    // ASSERT
    Assert.That(sut.Dependency, Is.SameAs(dependency));
}

[Test]
public void Freezing_is_supported_when_requesting_Mock_of_type()
{
    // ARRANGE
    fixture.Customize(new AutoMoqCustomization());
    var mockDependency = fixture.Freeze<Mock<IDependency>>(); // freezing a mock of the type

    // ACT
    var sut = fixture.Create<Service>();

    // ASSERT
    Assert.That(sut.Dependency, Is.SameAs(mockDependency.Object));
}
```

## Mock configuration

Mocks requested by AutoFixture via AutoMoq have their configuration that differs from the normal defaults of Moq.

Specifically, here is the list of the properties of the mocks

* The [`CallBase` property](https://docs.insightarchitectures.com/unit-testing-csharp/moq/base-class) is set to `true`
* The [`MockBehavior` property](https://docs.insightarchitectures.com/unit-testing-csharp/moq/mock-customization#mock-behavior) is set to `Loose`
* The [`DefaultValue` property](https://docs.insightarchitectures.com/unit-testing-csharp/moq/mock-customization#default-value) is set to `Mock`

## `ConfigureMembers`

By default, AutoMoq only provides values for non-concrete types.

```csharp
[Test]
public void AutoMoq_does_not_provide_values_by_default()
{
    // ARRANGE
    fixture.Customize(new AutoMoqCustomization());

    // ACT
    var sut = fixture.Create<Service>();

    // ASSERT
    Assert.That(sut.Dependency, Is.Not.Null);
    Assert.That(sut.InnerObject, Is.Not.Null);
    Assert.That(sut.InnerObject.StringValue, Is.Null);
}
```

This can be overridden by setting the property `ConfigureMembers` to `true`.

```csharp
[Test]
public void AutoMoq_provides_values_if_configured()
{
    // ARRANGE
    fixture.Customize(new AutoMoqCustomization { ConfigureMembers = true });

    // ACT
    var sut = fixture.Create<Service>();

    // ASSERT
    Assert.That(sut.Dependency, Is.Not.Null);
    Assert.That(sut.InnerObject, Is.Not.Null);
    Assert.That(sut.InnerObject.StringValue, Is.Not.Null);
}
```

## `GenerateDelegates`

By setting the property `GenerateDelegates` to `true`, developers can instruct AutoFixture to delegate the creation of delegates to AutoMoq.

```csharp
[Test]
public void DoSomething_uses_given_action()
{
    // ARRANGE
    fixture.Customize(new AutoMoqCustomization { GenerateDelegates = true });
    var action = fixture.Create<Action<string>>();
    var sut = fixture.Create<Service>();

    // ACT
    sut.Dependency.DoSomething(action);

    // ASSERT
    Mock.Get(action).Verify(p => p("Hello world"));
}
```

Like non-concrete types, delegates can be requested directly by their type or by requesting a mock of the type.


---

# 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.insightarchitectures.com/unit-testing-csharp/autofixture/moq-glue-library.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.