AutoMock.Generator 1.1.0

AutoMock.Generator

Compile-time mocking for .NET using Roslyn source generators. Add [Mock(typeof(IFoo))] to a partial class — AutoMock generates a plain, debuggable test double implementing IFoo at build time, with a settable *_Handler delegate and a *_Calls argument log for every member. No reflection, no Castle.Core dynamic proxies — a compile-time alternative to Moq / NSubstitute for interfaces, fully AOT/trim-safe.

Why

Moq and NSubstitute build mocks at runtime via System.Reflection.Emit / Castle.DynamicProxy. That:

• Doesn't work (or needs extra configuration) under Native AOT / trimming.
• Adds startup cost building proxy types.
• Produces an implementation you can't set a breakpoint in or read.

AutoMock generates a normal, debuggable partial class per [Mock] usage, at build time. You can read it, step into it, and it fails the build (not the test run) if the interface has a member AutoMock can't yet generate.

Usage

using AutoMock;

public interface ICalculator
{
    int Add(int a, int b);
    Task<int> AddAsync(int a, int b);
    void Reset();
    string Name { get; set; }
}

[Mock(typeof(ICalculator))]
public partial class CalculatorMock
{
}

Generates a CalculatorMock implementing ICalculator:

var mock = new CalculatorMock
{
    Add_Handler = (a, b) => a + b,          // configure return behavior
};

mock.Add(2, 3);                              // 5
mock.Add_CallCount;                          // 1
mock.Add_Calls[0];                           // object?[] { 2, 3 }

ICalculator asInterface = mock;              // implements the interface directly

ref/out/in parameters

public interface IParser
{
    bool TryParse(string input, out int value);
}

[Mock(typeof(IParser))]
public partial class ParserMock { }

var mock = new ParserMock
{
    TryParse_Handler = (string input, out int value) =>
    {
        value = int.Parse(input);
        return true;
    },
};

mock.TryParse("42", out var result); // result == 42

Every generated member gets:

Properties additionally get {Name}_GetCallCount / {Name}_SetCallCount counters; the getter/setter themselves just round-trip a private backing field.

Requirements

• The target class must be partial.
• The [Mock] constructor argument must be an interface type ([Mock(typeof(IFoo))]).
• A class can implement multiple interfaces via multiple [Mock] attributes.

Supported members (v1.1.0)

• Methods: synchronous, void, Task, and Task<T> returning, with any number of ref/out/in or by-value parameters. Methods with ref/out/in parameters get a dedicated per-method delegate type ({Method}Delegate) since Func<>/Action<> can't express those signatures.
• Properties: get-only, set-only, and get/set.
• Inherited interface members (interfaces that extend other interfaces).
• AutoMock_Reset() — clears every generated *_Handler, *_Calls log, and property backing field, so a single mock instance can be reused across tests (e.g. a shared xunit fixture).
• {Member}_WasCalled — shorthand for {Member}_CallCount > 0.

Not yet supported (v1.1.0 — see Roadmap)

Skipped with an AM003 info diagnostic (build still succeeds — implement these manually in the partial class if you need them):

• Generic methods.
• Indexers.
• Events.

Diagnostics

Roadmap

• Generic method support.
• Verify-style assertion helpers (e.g. mock.Verify(x => x.Add_CallCount == 1)).
• Abstract class mocking (in addition to interfaces).

License

MIT