Smock Plugin

🎯 SMock - Static & Instance Method Mocking for .NET

---

Why SMock?

SMock breaks down the barriers of testing legacy code, third-party dependencies, and static APIs. Built on MonoMod runtime modification technology, SMock gives you the power to mock what others can't.

• Mock Static Methods: The only .NET library that handles static methods seamlessly
• Two API Styles: Choose Hierarchical (with validation) or Sequential (disposable) patterns
• Zero Configuration: Works with your existing test frameworks (NUnit, xUnit, MSTest)
• Complete Feature Set: Async/await, parameter matching, callbacks, exceptions, unsafe code

---

Installation

Package Manager

Install-Package SMock

.NET CLI

dotnet add package SMock

💡 Pro Tip: SMock works great with any testing framework - NUnit, xUnit, MSTest, you name it!

---

🚀 Quick Start

// Mock a static method in just one line - Sequential API
using var mock = Mock.Setup(() => File.ReadAllText("config.json"))
    .Returns("{ \"setting\": \"test\" }");

// Your code now uses the mocked value!
var content = File.ReadAllText("config.json"); // Returns test JSON

// Or use the Hierarchical API with inline validation
Mock.Setup(() => DateTime.Now, () =>
{
    var result = DateTime.Now;
    Assert.AreEqual(new DateTime(2024, 1, 1), result);
}).Returns(new DateTime(2024, 1, 1));

---

Core Concepts

Hook-Based Runtime Modification

SMock uses MonoMod to create runtime hooks that intercept method calls:

• Non-Invasive: No source code changes required
• Isolated: Each test runs in isolation
• Fast: Minimal performance overhead
• Auto-Cleanup: Hooks automatically removed after test completion

Mock Lifecycle

// 1. Setup: Create a mock for the target method
var mock = Mock.Setup(() => DateTime.Now);

// 2. Configure: Define return values or behaviors
mock.Returns(new DateTime(2024, 1, 1));

// 3. Execute: Run your code - calls are intercepted
var now = DateTime.Now; // Returns mocked value

// 4. Cleanup: Dispose mock (Sequential) or automatic (Hierarchical)
mock.Dispose(); // Or automatic with 'using'

---

API Styles

SMock provides two distinct API patterns to fit different testing preferences:

Sequential API

Perfect for clean, scoped mocking with automatic cleanup:

[Test]
public void TestFileOperations()
{
    // Mock file existence check
    using var existsMock = Mock.Setup(() => File.Exists("test.txt"))
        .Returns(true);

    // Mock file content reading
    using var readMock = Mock.Setup(() => File.ReadAllText("test.txt"))
        .Returns("Hello World");

    // Your code under test
    var processor = new FileProcessor();
    var result = processor.ProcessFile("test.txt");

    Assert.AreEqual("HELLO WORLD", result);
} // Mocks automatically cleaned up here

Hierarchical API

Perfect for inline validation during mock execution:

[Test]
public void TestDatabaseConnection()
{
    var expectedConnectionString = "Server=localhost;Database=test;";

    Mock.Setup(context => DatabaseConnection.Connect(It.IsAny<string>()), () =>
    {
        // This validation runs DURING the mock execution
        var actualCall = DatabaseConnection.Connect(expectedConnectionString);
        Assert.IsNotNull(actualCall);
        Assert.IsTrue(actualCall.IsConnected);
    }).Returns(new MockConnection { IsConnected = true });

    // Test your service
    var service = new DatabaseService();
    service.InitializeConnection(expectedConnectionString);
}

---

⚡ Performance

SMock is designed for minimal performance impact:

• Runtime Hooks: Only active during tests
• Zero Production Overhead: No dependencies in production builds
• Efficient Interception: Built on MonoMod's optimized IL modification
• Benchmarked: Comprehensive performance testing with BenchmarkDotNet

Performance Characteristics

Operation	Overhead	Notes
Mock Setup	~1-2ms	One-time cost per mock
Method Interception	<0.1ms	Minimal runtime impact
Cleanup	<1ms	Automatic hook removal
Memory Usage	Minimal	Temporary IL modifications only

---

⚠️ Known Issues & Solutions

Compiler Optimization Issue

If your mocks are not being applied and you're getting the original method behavior instead of the mocked behavior, this is likely due to compiler optimizations. The compiler may inline or optimize method calls, preventing SMock from intercepting them.

Solutions:

1. Run tests in Debug configuration:

   dotnet test --configuration Debug
   

2. Disable compiler optimization in your test project by adding this to your .csproj:

   <PropertyGroup>
     <Optimize>false</Optimize>
   </PropertyGroup>
   

3. Disable optimization for specific methods using the MethodImpl attribute:

   [Test]
   [MethodImpl(MethodImplOptions.NoOptimization)]
   public void MyTestMethod()
   {
       using var mock = Mock.Setup(() => File.ReadAllText("config.json"))
           .Returns("{ \"setting\": \"test\" }");
   
       // Your test code here
   }
   

This issue typically occurs in Release builds where the compiler aggressively optimizes method calls. Using any of the above solutions will ensure your mocks work correctly.

---

Claude Code Plugin

This repository ships a Claude Code plugin that teaches Claude how to write and update .NET tests using SMock.

Install

From any project, run inside Claude Code:

/plugins install github:SvetlovA/static-mock

Or load for a single session:

claude --plugin-dir /path/to/static-mock/smock-plugin

Usage

/smock-plugin:smock-tests [sequential|hierarchical]

Argument	Effect
(omitted)	Sequential API (default)
sequential	using var mock = Mock.Setup(...).Returns(value)
hierarchical	Mock.Setup(..., () => { ... }).Returns(value) with inline validation

The skill will:

1. Check and update the SMock NuGet package to the latest version in all test .csproj files
2. Scan source projects for public methods and apply a mocking decision framework — SMock is only used where it genuinely adds value (non-deterministic statics, I/O, external services)
3. Discover the existing test structure, or create OriginalProject.Tests / OriginalClassNameTests from scratch
4. When everything already uses SMock: run a correctness & coverage audit — checks for missing using var, wrong It usage, and methods that should be mocked but aren't
5. Write or update tests in the selected API style
6. Update the project's CLAUDE.md so Claude always uses SMock going forward
7. Run dotnet build + dotnet test to verify all generated code compiles and passes

The skill also activates automatically when you ask Claude to "add tests", "check my tests", "update SMock version", "write unit tests using SMock", or "update tests to use the mocking library".

---

Additional Resources

• API Documentation
• More Examples
• Hierarchical API Examples
• Sequential API Examples

---

📄 License

This library is available under the MIT license.

---