Basit Bir Mock Framework Geliştirelim 6
2023-05-11
Şimdiye kadar, mock nesnesinin belirli bir metodu çağırıldığında belirli bir sonuç döndürmesini, bir dizi sonuç döndürmesini veya bir hata fırlatmasını ayarlayabiliyoruz. Ancak, bazen bir metodu çağırıldığında belirli bir eylemi gerçekleştirmesini isteyebiliriz. Bu, genellikle “Callback” olarak adlandırılır.
Bu özellik, bir metot çağrıldığında gerçekleşecek bir eylemi ayarlamak için kullanılabilir. Bu eylem, bir metot çağrıldığında herhangi bir işlemi gerçekleştirebilir. Örneğin, bir metot çağrıldığında belirli bir değişkenin değerini artırabiliriz, ya da belirli bir başka metodu çağırabiliriz.
Ayrıca, bir metot çağrıldığında belirli bir durumda bir hata fırlatmasını isteyebiliriz. Bu, genellikle “ThrowsIf” olarak adlandırılır.
using System;
using System.Collections.Concurrent;
using System.Linq.Expressions;
using System.Reflection;
using System.Collections.Generic;
public class Mock<T> : DispatchProxy
{
private ConcurrentDictionary<string, object> _methodResponses = new();
private ConcurrentDictionary<string, Queue<object>> _methodSequences = new();
private ConcurrentDictionary<string, Exception> _methodExceptions = new();
private ConcurrentDictionary<string, Action> _methodCallbacks = new();
private ConcurrentDictionary<string, int> _methodCalls = new();
protected override object Invoke(MethodInfo targetMethod, object[] args)
{
var key = GetKey(targetMethod, args);
var wildcardKey = $"{targetMethod.Name}_*";
if (_methodCallbacks.TryGetValue(key, out var callback))
{
_methodCalls[key]++;
callback.Invoke();
}
else if (_methodCallbacks.TryGetValue(wildcardKey, out callback))
{
_methodCalls[wildcardKey]++;
callback.Invoke();
}
else if (_methodExceptions.TryGetValue(key, out var exception))
{
_methodCalls[key]++;
throw exception;
}
else if (_methodExceptions.TryGetValue(wildcardKey, out exception))
{
_methodCalls[wildcardKey]++;
throw exception;
}
else if (_methodSequences.TryGetValue(key, out var sequence) && sequence.Count > 0)
{
_methodCalls[key]++;
return sequence.Dequeue();
}
else if (_methodSequences.TryGetValue(wildcardKey, out sequence) && sequence.Count > 0)
{
_methodCalls[wildcardKey]++;
return sequence.Dequeue();
}
else if (_methodResponses.TryGetValue(key, out var value))
{
_methodCalls[key]++;
return value;
}
else if (_methodResponses.TryGetValue(wildcardKey, out value))
{
_methodCalls[wildcardKey]++;
return value;
}
throw new Exception($"No response set up for method {targetMethod.Name}");
}
private string GetKey(MethodInfo methodInfo, object[] args)
{
return $"{methodInfo.Name}_{string.Join("_", args)}";
}
public void Setup(Expression<Action<T>> expression, object response)
{
SetupMethod(expression, response, _methodResponses);
}
public void SetupThrows(Expression<Action<T>> expression, Exception exception)
{
SetupMethod(expression, exception, _methodExceptions);
}
public void SetupCallback(Expression<Action<T>> expression, Action callback)
{
SetupMethod(expression, callback, _methodCallbacks);
}
public void SetupSequence(Expression<Action<T>> expression, params object[] responses)
{
var queue = new Queue<object>(responses);
SetupMethod(expression, queue, _methodSequences);
}
private void SetupMethod(Expression<Action<T>> expression, object response, ConcurrentDictionary<string, object> dictionary)
{
var methodCall = expression.Body as MethodCallExpression;
var methodName = methodCall.Method.Name;
var arguments = new object[methodCall.Arguments.Count];
for (int i = 0; i < methodCall.Arguments.Count; i++)
{
var arg = methodCall.Arguments[i];
if (arg.NodeType == ExpressionType.Constant)
{
arguments[i] = ((ConstantExpression)arg).Value;
}
else if (arg.NodeType == ExpressionType.Call && ((MethodCallExpression)arg).Method.Name == "IsAny" && ((MethodCallExpression)arg).Object.Type.Name == "It")
{
arguments[i] = "*";
}
}
var key = GetKey(methodCall.Method, arguments);
dictionary.TryAdd(key, response);
}
public void Verify(Expression<Action<T>> expression, int expectedInvocationCount = 1)
{
var methodCall = expression.Body as MethodCallExpression;
var methodName = methodCall.Method.Name;
var arguments = new object[methodCall.Arguments.Count];
for (int i = 0; i < methodCall.Arguments.Count; i++)
{
var arg = methodCall.Arguments[i];
if (arg.NodeType == ExpressionType.Constant)
{
arguments[i] = ((ConstantExpression)arg).Value;
}
}
var key = GetKey(methodCall.Method, arguments);
if (_methodCalls.TryGetValue(key, out var actualInvocationCount))
{
if (actualInvocationCount != expectedInvocationCount)
{
throw new Exception($"Method {methodName} was expected to be called {expectedInvocationCount} times but was called {actualInvocationCount} times.");
}
}
else
{
throw new Exception($"Method {methodName} was expected to be called {expectedInvocationCount} times but was not called.");
}
}
public static T Create()
{
return Create<T, Mock<T>>();
}
}
public static class It
{
public static T IsAny<T>()
{
return default;
}
}
Bu geliştirilmiş mock sınıfını şu şekilde kullanabiliriz:
public interface ITestInterface
{
string TestMethod(int parameter);
}
public class Test
{
public void TestMethod()
{
var mock = Mock<ITestInterface>.Create();
int counter = 0;
(mock as Mock<ITestInterface>).SetupCallback(x => x.TestMethod(It.IsAny<int>()), () => counter++);
mock.TestMethod(5);
mock.TestMethod(10);
Console.WriteLine(counter); // Outputs: 2
(mock as Mock<ITestInterface>).Verify(x => x.TestMethod(5)); // Throws no exception
(mock as Mock<ITestInterface>).Verify(x => x
(mock as Mock<ITestInterface>).Verify(x => x.TestMethod(10)); // Throws no exception
}
}
Bu örnekte, ITestInterface arayüzünün TestMethod metodunu mockluyoruz. TestMethod çağrıldığında, hangi parametre kullanılırsa kullanılsın bir geri çağırma (callback) işlemi gerçekleştiriliyor. Bu geri çağırma işlemi, her çağrıldığında counter adlı değişkenin değerini artırıyor.