---
title: AutoMoq
description: Moq integration — let AutoFixture create Moq mocks for interfaces and abstract types automatically.
---

[Moq](https://github.com/moq/moq) is a .NET mocking library. You create `Mock<T>` instances for interfaces and abstract types, then set up return values and verify calls.

**AutoFixture.AutoMoq** plugs Moq into AutoFixture. When AutoFixture builds an object graph and needs an interface or abstract dependency, AutoMoq supplies a Moq mock instead of failing — so you can `Freeze` mocks and assert on them with less manual setup.

## Prerequisites

- .NET 8+ test project
- [AutoFixture](/docs/get-started/installation) 5.0.0-rc.1
- Moq

## Install

Install **AutoFixture.AutoMoq** and add an explicit **Moq** package reference in the same test project.

AutoMoq depends on Moq, but that dependency version stays intentionally low so AutoMoq remains compatible with a wide range of Moq releases. If you rely only on the transitive Moq reference, you may get an older Moq without the latest features and fixes. Reference the **latest Moq** yourself alongside AutoMoq.

```xml
<PackageReference Include="AutoFixture" Version="5.0.0-rc.1" />
<PackageReference Include="AutoFixture.AutoMoq" Version="5.0.0-rc.1" />
<PackageReference Include="Moq" Version="4.20.72" />
```

Pin **matching versions** of AutoFixture and AutoFixture.AutoMoq. Do not mix v4 and v5 AutoFixture packages in the same project. Keep your explicit Moq reference on the newest available version when you update packages.

## Example scenario

You are testing `OrderService`, which depends on `IOrderRepository`. The test should verify that placing an order calls `Save` on the repository — without hand-writing a mock setup for every test. Other tests need mock methods to return fixture values, or Moq-backed delegates.

## Basic usage

```csharp
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var repository = fixture.Freeze<Mock<IOrderRepository>>();

var service = fixture.Create<OrderService>();

var order = fixture.Create<Order>();
service.PlaceOrder(order);

repository.Verify(r => r.Save(order), Times.Once);
```

`Create<OrderService>()` injects a mock `IOrderRepository`. `Freeze<Mock<IOrderRepository>>()` keeps one mock instance so you can verify calls.

Combine with [xUnit.net 3](/docs/integrations/xunit3) via a [custom AutoData attribute](/docs/integrations/xunit3#custom-autodata-attribute) when tests use `[AutoData]`.

## Mock wrappers and interface requests

AutoMoq registers builders for both `Mock<T>` and the mocked type `T` (interfaces and abstract classes). Prefer freezing the mock when you need `Setup` / `Verify`:

```csharp
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var repository = fixture.Freeze<Mock<IOrderRepository>>();

var service = fixture.Create<OrderService>();
```

Freezing the interface works too — the relay returns `mock.Object`, and you can recover the mock with `Mock.Get`:

```csharp
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var repository = fixture.Freeze<IOrderRepository>();

var service = fixture.Create<OrderService>();
var order = fixture.Create<Order>();
service.PlaceOrder(order);

Mock.Get(repository).Verify(r => r.Save(order), Times.Once);
```

`Create<Mock<T>>()` builds a configured `Mock<T>` when you want the wrapper without freezing.

## Configuration options

[`AutoMoqCustomization`](/api/automoq/5-0-0-rc-1/autofixture.automoq.automoqcustomization) exposes properties you set before calling `Customize`. Defaults are all off / default relay:

| Property | Default | Effect |
| --- | --- | --- |
| `ConfigureMembers` | `false` | When `true`, mock members return values from the fixture |
| `GenerateDelegates` | `false` | When `true`, Moq creates delegates (`Func`, `Action`, …) |
| `Relay` | `MockRelay` | Residue collector that turns interface/abstract requests into mocks |

```csharp
var fixture = new Fixture().Customize(new AutoMoqCustomization
{
    ConfigureMembers = true,
    GenerateDelegates = true
});
```

### ConfigureMembers

With the default (`ConfigureMembers = false`), Moq uses its usual loose defaults — methods return `default` unless you set them up:

```csharp
public interface IGreeter
{
    string Greet();
}
```

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

var greeter = fixture.Create<IGreeter>();

Assert.Null(greeter.Greet());
```

With `ConfigureMembers = true`, AutoFixture sets up mock members so calls return specimens from the fixture (and stubs overridable properties like real properties):

```csharp
var fixture = new Fixture().Customize(new AutoMoqCustomization
{
    ConfigureMembers = true
});
var order = fixture.Freeze<Order>();

var repository = fixture.Create<ICommerceOrderRepository>();

Assert.Same(order, repository.GetById(1));
```

Use `ConfigureMembers` when the SUT reads from collaborators and you want anonymous return values without writing `Setup` for every member. Prefer the default when you only care about verifying calls (as in the basic `Verify` example).

The older `AutoConfiguredMoqCustomization` type is obsolete — use `new AutoMoqCustomization { ConfigureMembers = true }` instead.

`ConfigureMembers` does **not** set up every member. AutoMoq skips:

- Generic methods (Moq cannot anticipate type arguments)
- Methods with `ref` parameters
- Sealed methods
- Void methods without `out` parameters

For those cases, set up the mock yourself — for example with [`ReturnsUsingFixture`](#returnsusingfixture).

### ReturnsUsingFixture

[`ReturnsUsingFixture`](/api/automoq/5-0-0-rc-1/autofixture.automoq.mocktype) is a Moq `Setup` extension that returns the next specimen of the member's return type from the fixture. Use it for members `ConfigureMembers` cannot cover (especially generics):

```csharp
public interface IConverter
{
    T Convert<T>(string value);
}
```

```csharp
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var converter = fixture.Freeze<Mock<IConverter>>();
var expected = fixture.Freeze<double>();

converter.Setup(c => c.Convert<double>("10.0")).ReturnsUsingFixture(fixture);

Assert.Equal(expected, converter.Object.Convert<double>("10.0"));
```

### GenerateDelegates

By default, AutoFixture's own kernel creates delegates. With `GenerateDelegates = true`, Moq creates them instead — useful when you want mockable or auto-configured delegates:

```csharp
var fixture = new Fixture().Customize(new AutoMoqCustomization
{
    GenerateDelegates = true,
    ConfigureMembers = true
});
var expected = fixture.Freeze<string>();

var format = fixture.Create<Func<int, string>>();

Assert.Equal(expected, format(42));
```

Without `ConfigureMembers`, the Moq delegate still exists but return values stay at Moq defaults unless you set them up.

### Relay

`Relay` is the specimen builder added to `fixture.ResidueCollectors`. The default [`MockRelay`](/api/automoq/5-0-0-rc-1/autofixture.automoq.mockrelay) answers requests for interfaces and abstract types with Moq mocks.

Most tests leave the default. Replace it only when you need a custom residue collector — for example a `MockRelay` with a different request specification:

```csharp
var fixture = new Fixture().Customize(new AutoMoqCustomization
{
    Relay = new MockRelay(new ExactTypeSpecification(typeof(IOrderRepository)))
});
```

That example would mock only `IOrderRepository` requests that match the specification you supply; other abstractions follow the rest of the fixture pipeline.

## How it works

- **`AutoMoqCustomization`** — registers Moq mock creation and a residue collector for abstractions
- **`ConfigureMembers`** — auto-setup mock members from the fixture (with known gaps — see above)
- **`ReturnsUsingFixture`** — manual Moq setup that pulls return values from the fixture
- **`GenerateDelegates`** — create delegates with Moq instead of the AutoFixture kernel
- **`Relay`** — residue collector (default `MockRelay`) for interface/abstract requests
- **`Freeze<Mock<T>>()` / `Freeze<T>()`** — one shared mock (or `mock.Object`) for setup and verification

## Next steps

- [Integrations overview](/docs/integrations)
- [AutoMoq](/docs/integrations/automoq)
- [AutoNSubstitute](/docs/integrations/autonsubstitute)
- [AutoFakeItEasy](/docs/integrations/autofakeiteasy)
- [Custom AutoData attribute](/docs/integrations/xunit3#custom-autodata-attribute)
- [Register, Freeze, and Inject](/docs/how-to/register-freeze-inject)
- [FAQ](/docs/reference/faq)

## API

- [AutoFixture.AutoMoq package](/api/automoq/5-0-0-rc-1)
- [`AutoMoqCustomization`](/api/automoq/5-0-0-rc-1/autofixture.automoq.automoqcustomization)
- [`MockRelay`](/api/automoq/5-0-0-rc-1/autofixture.automoq.mockrelay)
- [`MockType.ReturnsUsingFixture`](/api/automoq/5-0-0-rc-1/autofixture.automoq.mocktype)