Issues With Mocking

[JasonBock]

I'm trying to use this library, and I cannot mock static members, sealed types, or non-virtual members. According to the docs, it sounds like this should be possible, but with 1.0.0, I can't get these to work

For example, the docs state this should work:

var fixedDate = DateTime.UtcNow;

var staticMock = Mock.Static<DateTime>()
    .Returns(d => d.Now, fixedDate)
    .Build();

However, I get this compilation error when I try that:

The type 'DateTime' must be a reference type in order to use it as parameter 'T' in the generic type or method 'Mock.Static<T>()'

So then I tried to create my own type:

public sealed class MyDateTime
{
    public static DateTime UtcNow => DateTime.UtcNow;
}

But when I do this:

var staticMock = Mock.Static<MyDateTime>()
    .Returns(d => d.UtcNow, fixedDate)
    .Build();

This doesn't work either, because you can't reference UtcNow this way.

I tried a sealed type with a non-virtual member:

public sealed class Target
{
    public int MockThis(string value) => value.Length;
}

var staticMock = Mock.Static<Target>()
    .Returns(d => d.MockThis("value"), 1)
    .Build();

var mock = staticMock.Wrapped;
Console.WriteLine(mock.MockThis("value"));

Then I get a run-time error:

System.InvalidOperationException: Static types cannot be accessed directly. Use the wrapper methods instead.

OK, fine:

var staticMock = Mock.Of<Target>()
    .Setup(d => d.MockThis("value"), 1)
    .Build();

var mock = staticMock.Object;
Console.WriteLine(mock.MockThis("value"));

But this doesn't work either:

System.InvalidOperationException: Mock proxy for Target not found. Ensure NimbleMock.SourceGenerator is referenced and the type is mocked.

So, if it is possible to handle static members, sealed types, and non-virtual members, I can't get it to work. What am I missing?

[guinhx]

Thank you for opening this issue and sharing such detailed examples. Your feedback was exactly what we needed to spot and fix these problems properly.

You're spot on: the original Mock.Static<T>() in v1.0.0 had serious flaws, especially with structs like DateTime, sealed types, and non-virtual members. It simply wasn't reliable. After a lot of thought and testing, we've removed that approach entirely and moved to something much more solid and predictable: the classic wrapper interface pattern for static-like dependencies.

The new Shim.For<T>() is just a friendly alias for Mock.Of<T>() — it's designed to make the intent clearer when you're mocking these kinds of dependencies. There are no more generated shims like DateTimeShim, no global overrides, and no runtime surprises. Instead, we encourage wrapping static behavior behind an interface and injecting it — this works perfectly with sealed types, structs, static members, and non-virtual methods.

Here's the correct and current way to handle something like DateTime.UtcNow:

using NimbleMock;

var fixedDate = new DateTime(2025, 12, 27, 0, 0, 0, DateTimeKind.Utc);

var mock = Shim.For<IDateTimeProvider>()
    .Replace(d => d.Now, fixedDate)
    .Replace(d => d.UtcNow, fixedDate)
    .Build();

var service = new MyService(mock.Object);

Console.WriteLine(service.GetCurrentTime()); // → 2025-12-27 00:00:00

mock.Verify(d => d.UtcNow).Once(); // Passes
mock.Verify(d => d.Now).Never();   // Passes if not called

With these supporting types:

public interface IDateTimeProvider
{
    DateTime Now { get; }
    DateTime UtcNow { get; }
}

public class SystemDateTimeProvider : IDateTimeProvider
{
    public DateTime Now => DateTime.Now;
    public DateTime UtcNow => DateTime.UtcNow;
}

public class MyService(IDateTimeProvider dateTimeProvider = null)
{
    private readonly IDateTimeProvider _dateTimeProvider = dateTimeProvider ?? new SystemDateTimeProvider();

    public DateTime GetCurrentTime() => _dateTimeProvider.UtcNow;
}

This pattern applies equally to your sealed Target class or any other static/sealed/non-virtual scenario — just extract the behavior you need to control into an interface and mock that.

All of this is fully implemented, tested, and documented on the develop branch right now. We're still doing some final polishing and incorporating Reddit feedback before publishing the next NuGet package.

If you'd like to try it today:

1. Clone the repo:

   git clone https://github.com/guinhx/NimbleMock.git
   cd NimbleMock
   git checkout develop
   dotnet clean
   dotnet build
   

2. In your test project's .csproj, add these local references:

   <ItemGroup>
     <ProjectReference Include="..\NimbleMock\src\NimbleMock\NimbleMock.csproj" />
   
     <ProjectReference Include="..\NimbleMock\src\NimbleMock.SourceGenerator\NimbleMock.SourceGenerator.csproj"
                       OutputItemType="Analyzer"
                       ReferenceOutputAssembly="false" />
   </ItemGroup>

   (Adjust the relative path if needed.)

This ensures the latest source generator runs in your project.

We'll have the next proper release out soon. In the meantime, if you give the develop branch a spin and anything feels off or confusing, just let me know — I'm here to help.

Thanks again for the detailed report and for your patience. Feedback like yours has made the library significantly better and more trustworthy.

Let me know how it goes!

[JasonBock]

So, just to be clear, NimbleMock doesn't support mocking static members, correct? You have to use a wrapping technique instead?