We love unit testing! Seriously, it makes sense if you consider how many times a simple test had saved us from having to revisit that long forgotten project we’ve already moved on from. Not fun and not good for business.<\/p>\n\n\n\n
To be able to only test the code we want, we need to isolate it. Of course, there’s heaps libraries for that already. Moq<\/a> is just one of them. It allows of to create objects based on given interfaces and set up the expected behaviour in a way that we can abstract away all code we don’t currently test. Extremely powerful tool<\/p>\n\n\n\n Sometimes you just need a bit more of that<\/p>\n\n\n\n Suppose we’re testing a object that depends on internal state that’s tricky to abstract away. We’d however like to use Mock to replace one operation without changing the others:<\/p>\n\n\n\n The code above illustrates the problem quite nicely. You’ll know if this is your case when you see it.<\/p>\n\n\n\n “It can’t be done, use something else”, they say. Some people on StackOverflow suggest to ditch Moq completely and go for it’s underlying technology Castle DynamicProxy<\/a>. And it is a valid idea – create a proxy class around yours and intercept calls to the method under test. Easy!<\/p>\n\n\n\n One advantage or Moq (which is by the way built on top of Castle DynamicProxy) is that it’s not just creating mock objects, but also tracks invocations and allows us to verify those later. Of course, we could opt to write the reuiqred bits ourselves, but why reinvent the wheel and introduce so much code that no one will maintain?<\/p>\n\n\n\n We know that Moq internally leverages Castle DynamicProxy and it actually allows us to generate proxies for instances (they call it Class proxy with target<\/a>). Therefore the question is – how do we get Moq to make one for us. It seems there’s no such option out of the box, and simply injecting the override didn’t quite go well as there’s not much inversion of control inside the library and most of the types and properties are marked as internal<\/strong>, making inheritance virtually impossible.<\/p>\n\n\n\n Castle Proxy<\/strong> is however much more user firendly and has quite a few methods exposed and available for overriding. So let us define a ProxyGenerator<\/strong> class that would take the method Moq <\/strong>calls and add required functionality to it (just compare CreateClassProxyWithTarget<\/strong><\/a> and CreateClassProxy<\/strong><\/a> implementations – they are almost identical!)<\/p>\n\n\n\n if all of the above was relativaly straightforward, actually feeding it into Moq <\/strong>is going to be somewhat of a hack. As I mentioned, most of the structures are marked internal <\/strong>so we’ll have to use reflection to get through:<\/p>\n\n\n\n Then, given we’ve got the above working, the actual solution would look like so:<\/p>\n\n\n\n <\/p>\n","protected":false},"excerpt":{"rendered":"public class A\n{\n public string Test {get;set;}\n public virtual string ReturnTest() => Test;\n}\n\/\/and some code below:\nvoid Main()\n{\n var config = new A() {\n Test = \"TEST\"\n } ;\n\n var mockedConfig = new Mock<A>(); \/\/ first we run a stock standard mock\n mockedConfig.CallBase = true; \/\/ we will enable CallBase just to point out that it makes no difference \n var o = mockedConfig.Object;\n Console.WriteLine(o.ReturnTest()); \/\/ this will be null because Test has not been initialised from constructor\n mockedConfig.Setup(c => c.ReturnTest()).Returns(\"mocked\"); \/\/ of course if you set up your mocks - you will get the value\n Console.WriteLine(o.ReturnTest()); \/\/ this will be \"mocked\" now, no surprises\n}<\/code><\/pre>\n\n\n\nGeneral sentiment towards these problems<\/h2>\n\n\n\n
Kinda easy<\/h2>\n\n\n\n
How about we mix and match?<\/h2>\n\n\n\n
MyProxyGenerator.cs<\/h3>\n\n\n\n
class MyProxyGenerator : ProxyGenerator\n{\n object _target;\n\n public MyProxyGenerator(object target) {\n _target = target; \/\/ this is the missing piece, we'll have to pass it on to Castle proxy\n }\n \/\/ this method is 90% taken from the library source. I only had to tweak two lines (see below)\n public override object CreateClassProxy(Type classToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options, object[] constructorArguments, params IInterceptor[] interceptors)\n {\n if (classToProxy == null)\n {\n throw new ArgumentNullException(\"classToProxy\");\n }\n if (options == null)\n {\n throw new ArgumentNullException(\"options\");\n }\n if (!classToProxy.GetTypeInfo().IsClass)\n {\n throw new ArgumentException(\"'classToProxy' must be a class\", \"classToProxy\");\n }\n CheckNotGenericTypeDefinition(classToProxy, \"classToProxy\");\n CheckNotGenericTypeDefinitions(additionalInterfacesToProxy, \"additionalInterfacesToProxy\");\n Type proxyType = CreateClassProxyTypeWithTarget(classToProxy, additionalInterfacesToProxy, options); \/\/ these really are the two lines that matter\n List<object> list = BuildArgumentListForClassProxyWithTarget(_target, options, interceptors); \/\/ these really are the two lines that matter\n if (constructorArguments != null && constructorArguments.Length != 0)\n {\n list.AddRange(constructorArguments);\n }\n return CreateClassProxyInstance(proxyType, list, classToProxy, constructorArguments);\n }\n}<\/code><\/pre>\n\n\n\nMyMock.cs<\/h3>\n\n\n\n
public class MyMock<T> : Mock<T>, IDisposable where T : class\n{\n void PopulateFactoryReferences()\n {\n \/\/ Moq tries ridiculously hard to protect their internal structures - pretty much every class that could be of interest to us is marked internal\n \/\/ All below code is basically serving one simple purpose = to swap a `ProxyGenerator` field on the `ProxyFactory.Instance` singleton\n \/\/ all types are internal so reflection it is\n \/\/ I will invite you to make this a bit cleaner by obtaining the `_generatorFieldInfo` value once and caching it for later\n var moqAssembly = Assembly.Load(nameof(Moq));\n var proxyFactoryType = moqAssembly.GetType(\"Moq.ProxyFactory\");\n var castleProxyFactoryType = moqAssembly.GetType(\"Moq.CastleProxyFactory\"); \n var proxyFactoryInstanceProperty = proxyFactoryType.GetProperty(\"Instance\");\n _generatorFieldInfo = castleProxyFactoryType.GetField(\"generator\", BindingFlags.NonPublic | BindingFlags.Instance); \n _castleProxyFactoryInstance = proxyFactoryInstanceProperty.GetValue(null);\n _originalProxyFactory = _generatorFieldInfo.GetValue(_castleProxyFactoryInstance);\/\/save default value to restore it later\n }\n\n public MyMock(T targetInstance) { \n PopulateFactoryReferences();\n \/\/ this is where we do the trick!\n _generatorFieldInfo.SetValue(_castleProxyFactoryInstance, new MyProxyGenerator(targetInstance));\n }\n\n private FieldInfo _generatorFieldInfo;\n private object _castleProxyFactoryInstance;\n private object _originalProxyFactory;\n\n public void Dispose()\n {\n \/\/ you will notice I opted to implement IDisposable here. \n \/\/ My goal is to ensure I restore the original value on Moq's internal static class property in case you will want to mix up this class with stock standard implementation\n \/\/ there are probably other ways to ensure reference is restored reliably, but I'll leave that as another challenge for you to tackle\n _generatorFieldInfo.SetValue(_castleProxyFactoryInstance, _originalProxyFactory);\n }\n}<\/code><\/pre>\n\n\n\n var config = new A()\n {\n Test = \"TEST\"\n };\n using (var superMock = new MyMock<A>(config)) \/\/ now we can pass instances!\n {\n superMock.CallBase = true; \/\/ you still need this, because as far as Moq is oncerned it passes control over to CastleDynamicProxy \n var o1 = superMock.Object;\n Console.WriteLine(o1.ReturnTest()); \/\/ but this should return TEST\n }<\/code><\/pre>\n\n\n\n