SimplyMock 1.3.1

SimplyMock

A lightweight .NET method mocking library that allows you to dynamically replace methods and properties implementation in unit tests without creating full mock objects.

Features

• Mock any method's return value with a simple API
• Support for methods with various parameter counts (0-5 parameters)
• Parameter mapping mode to return predefined results based on input parameters
• Property getter mocking support
• Mock exception-throwing behavior
• Async method mocking support
• Static method and static async method mocking
• Generic method mocking support
• Automatic cleanup of all mocks (implements IDisposable)

Limitations

• Each method can only be mocked once, subsequent mocks will throw an error
• Methods with in, out, and ref parameter modifiers are not supported

Basic Usage

1. Create IMethodMocker instance

// Create an instance in your test class constructor
private readonly IMethodMocker _methodMocker;

public YourTestClass()
{
    _methodMocker = new MethodMocker();
}

// Release resources in the test class destructor
public void Dispose()
{
    _methodMocker.Dispose();
}

2. Mock method return values

// Mock a parameterless method
_methodMocker.MockMethodReturn<string>(
    typeof(YourClass),
    "GetMessage",
    () => "Mocked message"
);

// Mock a method with parameters
_methodMocker.MockMethodReturn<int, string>(
    typeof(YourClass),
    "GetById",
    (id) => $"Mocked item {id}"
);

// Mock a multi-parameter method
_methodMocker.MockMethodReturn<string, int, bool, string>(
    typeof(YourClass),
    "ProcessData",
    (name, code, isEnabled) => $"Processed: {name}"
);

3. Use parameter mapping

// Create input parameter to return value mapping
var resultMap = new Dictionary<string, int>
{
    { "apple", 10 },
    { "banana", 20 },
    { "orange", 15 }
};

// Apply the mapping
_methodMocker.MockMethodReturnMap<string, int>(
    typeof(FruitService),
    "GetPrice",
    resultMap
);

// Now FruitService.GetPrice will return values based on the parameter
// If parameter is not defined in the mapping, it will throw KeyNotFoundException

4. Mock properties

// Mock property getter
_methodMocker.MockPropertyGetter<bool>(
    typeof(User),
    "IsAdmin",
    () => true
);

5. Mock async methods

// Mock parameterless async method
_methodMocker.MockAsyncMethodReturn<string>(
    typeof(DataService),
    "GetDataAsync",
    async () => {
        // Real async logic can be performed here
        await Task.Delay(10);
        return "Mocked async data";
    }
);

// Mock async method with parameters
_methodMocker.MockAsyncMethodReturn<string, int>(
    typeof(OrderService),
    "ProcessOrderAsync",
    async (orderId) => {
        await Task.Delay(5);
        return orderId.Length * 10;
    }
);

6. Mock generic methods

// Mock a generic static method with no parameters
// Generic method: public static T Get<T>()
_methodMocker.MockGenericStaticMethodReturn<Person>(
    typeof(ServiceFactory),
    "Get",
    () => new Person { 
        Name = "John Doe", 
        Age = 30 
    }
);

// Mock a generic static method with one parameter
// Generic method: public static T Map<T>(object source)
_methodMocker.MockGenericStaticMethodReturn<UserDto, object>(
    typeof(Mapper),
    "Map",
    src => new UserDto {
        Id = 1001,
        Username = "johndoe",
        Email = "john@example.com"
    }
);

// Using the mocked generic methods
Person person = ServiceFactory.Get<Person>();
UserDto userDto = Mapper.Map<UserDto>(sourceObject);

Advanced Usage

Mock exceptions

// Mock method to throw exceptions
_methodMocker.MockMethodReturn<string, string>(
    typeof(UserService),
    "GetUserName",
    (userId) => {
        if (string.IsNullOrEmpty(userId))
            throw new ArgumentNullException(nameof(userId));
            
        if (userId == "invalid")
            throw new InvalidOperationException("User not found");
            
        return $"User {userId}";
    }
);

Notes

1. Ensure you call Dispose() after tests to release all mocks
2. When mocking methods, parameter types and count must match exactly
3. When using MockMethodReturnMap, undefined parameter combinations will throw KeyNotFoundException
4. Async method mocking supports real async operations, you can use await in replacement functions
5. SimplyMock supports methods with up to 5 parameters, for both sync and async methods
6. Static methods and static async methods are mocked the same way as instance methods
7. Generic static methods can be mocked by providing a Func delegate directly
8. Multiple mocks on the same method will override previous implementations
9. SimplyMock modifies method behavior at runtime, making it ideal for testing legacy code or third-party libraries

Complete Example

using System;
using Xunit;
using SimplyMock;

public class CalculatorService
{
    public int Add(int a, int b) => a + b;
}

public class CalculatorTests : IDisposable
{
    private readonly IMethodMocker _methodMocker;

    public CalculatorTests()
    {
        _methodMocker = new MethodMocker();
    }

    public void Dispose()
    {
        _methodMocker.Dispose();
    }

    [Fact]
    public void Add_ShouldReturnMockedResult()
    {
        // Replace the implementation of Add method
        _methodMocker.MockMethodReturn<int, int, int>(
            typeof(CalculatorService),
            "Add",
            (a, b) => a * b // Replace with multiplication
        );

        var calculator = new CalculatorService();
        int result = calculator.Add(5, 3);

        // Now Add method performs multiplication
        Assert.Equal(15, result);
    }
}