Mockolate.Migration 0.5.0

Mockolate.Migration

A Roslyn analyzer and code-fix provider that migrates Moq and NSubstitute usage to Mockolate. Drop the package into a project that uses one of those libraries and the analyzer flags each mock it can migrate; the accompanying code fix rewrites the setup, verification, and event APIs to their Mockolate equivalents.

Installation

Install the NuGet package into the project you want to migrate:

dotnet add package Mockolate.Migration

The package only needs to be referenced while you are migrating — it ships the analyzer and code fixer, not runtime code. Once the source library is gone from a project you can remove the reference again.

How it works

After installing the package, every supported construct is reported as a warning. Apply the relevant code fix from your IDE (Visual Studio, Rider, VS Code with C# Dev Kit) or via dotnet format analyzers to rewrite the call site.

The fixer rewrites the whole mock — the construction call, all setup calls on that mock, the corresponding verification calls, event wiring, and trailing .Object accesses (Moq) — in a single step.

Migrating from Moq

The Moq fixer rewrites new Mock<T>(...) to T.CreateMock(...), drops every trailing .Object access, and moves setups and verifications onto the strongly-typed Mock.Setup / Mock.Verify chains. Strict mocks are mapped to MockBehavior.Default.ThrowingWhenNotSetup(), It.Is<T>(predicate) becomes It.Satisfies<T>(...), and event raising / verification are routed through Mock.Raise and event-specific Mock.Verify.<Event>.Subscribed() / Unsubscribed() calls.

// Before (Moq)
var mock = new Mock<IFoo>();
mock.Setup(m => m.Compute(It.IsAny<int>())).Returns(42);
var sut = new Service(mock.Object);
sut.Run();
mock.Verify(m => m.Compute(It.IsAny<int>()), Times.Once());

// After (Mockolate)
var mock = IFoo.CreateMock();
mock.Mock.Setup.Compute(It.IsAny<int>()).Returns(42);
var sut = new Service(mock);
sut.Run();
mock.Mock.Verify.Compute(It.IsAny<int>()).Once();

// Before (Moq) — properties and events
var mock = new Mock<IFoo>(MockBehavior.Strict);
mock.SetupProperty(m => m.Name, "initial");
mock.Raise(m => m.Changed += null, EventArgs.Empty);
mock.VerifyAdd(m => m.Changed += It.IsAny<EventHandler>(), Times.Once());

// After (Mockolate)
var mock = IFoo.CreateMock(MockBehavior.Default.ThrowingWhenNotSetup());
mock.Mock.Setup.Name.InitializeWith("initial");
mock.Mock.Raise.Changed(null, EventArgs.Empty);
mock.Mock.Verify.Changed.Subscribed().Once();

Supported Moq migrations

Migrating from NSubstitute

The NSubstitute fixer rewrites Substitute.For<T>(...) to T.CreateMock(...) and reroutes the implicit setup/verify calls (sub.Method(args).Returns(...), sub.Received().Method(...)) through the strongly-typed Mock.Setup / Mock.Verify chains. Arg.Any<T>() becomes It.IsAny<T>(), Arg.Is<T>(predicate) becomes It.Satisfies<T>(...), and Raise.Event(...) is rewritten to the corresponding sub.Mock.Raise.<Event>(...) call. Nested-mock setups (sub.Child.M(args).Returns(...)) are migrated with a // TODO comment because the parent must be wired up to return the child mock manually.

// Before (NSubstitute)
var sub = Substitute.For<IFoo>();
sub.Compute(Arg.Any<int>()).Returns(42);
var sut = new Service(sub);
sut.Run();
sub.Received(1).Compute(Arg.Any<int>());

// After (Mockolate)
var sub = IFoo.CreateMock();
sub.Mock.Setup.Compute(It.IsAny<int>()).Returns(42);
var sut = new Service(sub);
sut.Run();
sub.Mock.Verify.Compute(It.IsAny<int>()).Once();

// Before (NSubstitute) — sequential returns, When/Do, events
var sub = Substitute.For<IFoo>();
sub.Compute(0).Returns(1, 2, 3);
sub.When(x => x.Reset()).Do(_ => counter++);
sub.Changed += Raise.EventWith(EventArgs.Empty);

// After (Mockolate)
var sub = IFoo.CreateMock();
sub.Mock.Setup.Compute(0).Returns(1).Returns(2).Returns(3);
sub.Mock.Setup.Reset().Do(() => counter++);
sub.Mock.Raise.Changed(null, EventArgs.Empty);

CallInfo callbacks

NSubstitute's Returns(call => …), When(...).Do(call => …), and AndDoes(call => …) callbacks receive a CallInfo parameter that exposes the invocation arguments. Mockolate's equivalent overloads instead take the method's parameters directly, so the migration rewrites the lambda:

• Body never reads the parameter — drop it: Do(call => x++) → Do(() => x++).
• Body uses statically resolvable accesses (call.ArgAt<T>(literalIndex), call[literalIndex], or type-unique call.Arg<T>()) — rewrite the lambda's parameter list to match the receiver method and replace each access with the matching parameter name: Returns(call => call.ArgAt<int>(0) + 1) → Returns((int x) => x + 1).
• Anything else — bare call, dynamic indices, indexer-write for out/ref, ambiguous call.Arg<T>(), or local variables that would shadow the injected parameter names — preserve the original lambda and emit a // TODO comment so the rewrite can be done by hand.

Supported NSubstitute migrations