AutoMock.Generator 1.0.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

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.0.0)

• Methods: synchronous, void, Task, and Task<T> returning, with any number of by-value parameters.
• Properties: get-only, set-only, and get/set.
• Inherited interface members (interfaces that extend other interfaces).

Not yet supported (v1.0.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.
• ref/out/in parameters.
• Indexers.
• Events.

Diagnostics

Roadmap

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

License

MIT