public MockingProxy(MarshalByRefObject wrappedInstance, IInterceptor interceptor, IMockMixin mockMixin) : base(wrappedInstance.GetType()) { this.WrappedInstance = wrappedInstance; this.interceptor = interceptor; this.mockMixin = mockMixin; }
public InOrderBehavior(MocksRepository originalRepository, IMockMixin mock, string message) { this.originalRepository = originalRepository; this.mock = mock; this.arrangementId = InOrderArrangementCount++; this.message = message; }
public object Create(Type type, MocksRepository repository, IMockMixin mockMixinImpl, MockCreationSettings settings, bool createTransparentProxy) { var baseType = type.IsGenericType ? type.GetGenericTypeDefinition() : type; RuntimeTypeHandle proxyTypeHandle; var key = new ProxySourceRegistry.ProxyKey( baseType.TypeHandle, GetAdditionalInterfaceHandles(type, settings.AdditionalMockedInterfaces)); if (!ProxySourceRegistry.ProxyTypes.TryGetValue(key, out proxyTypeHandle)) { ThrowNoProxyException(baseType, settings.AdditionalMockedInterfaces); } var interceptor = new DynamicProxyInterceptor(repository); var proxyType = Type.GetTypeFromHandle(proxyTypeHandle); if (proxyType.IsGenericTypeDefinition) { proxyType = proxyType.MakeGenericType(type.GetGenericArguments()); } var mockConstructorCall = settings.MockConstructorCall && proxyType.BaseType != typeof(object) && UninitializedObjectFactory.IsSupported; ConstructorInfo proxyCtor = null; if (!mockConstructorCall && settings.Args == null) { proxyCtor = proxyType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) .First(ctor => ctor.IsPublic || ctor.IsFamily || ctor.IsFamilyOrAssembly); settings.Args = proxyCtor.GetParameters() .TakeWhile(p => p.ParameterType != typeof(IInterceptor)) .Select(p => (p.Attributes & ParameterAttributes.HasDefault) != 0 ? p.DefaultValue : p.ParameterType.GetDefaultValue()) .ToArray(); } var ctorArgs = (settings.Args ?? Enumerable.Empty <object>()) .Concat(new object[] { interceptor, mockMixinImpl }) .Concat(settings.Mixins).ToArray(); if (!mockConstructorCall) { if (proxyCtor != null) { return(ProfilerInterceptor.GuardExternal(() => proxyCtor.Invoke(ctorArgs))); } else { return(ProfilerInterceptor.GuardExternal(() => Activator.CreateInstance(proxyType, ctorArgs))); } } else { var result = UninitializedObjectFactory.Create(proxyType); proxyType.GetMethod(".init").Invoke(result, ctorArgs); return(result); } }
internal Invocation(object instance, MethodBase method, object[] args) { this.Instance = instance; this.Method = method; this.Args = args; this.MockMixin = method.IsExtensionMethod() && args.Length >= 1 ? MocksRepository.GetMockMixin(args[0], null) : MocksRepository.GetMockMixin(instance, method.DeclaringType); }
public object Create(Type type, MocksRepository repository, IMockMixin mockMixinImpl, MockCreationSettings settings, bool createTransparentProxy) { var baseType = type.IsGenericType ? type.GetGenericTypeDefinition() : type; RuntimeTypeHandle proxyTypeHandle; var key = new ProxySourceRegistry.ProxyKey( baseType.TypeHandle, GetAdditionalInterfaceHandles(type, settings.AdditionalMockedInterfaces)); if (!ProxySourceRegistry.ProxyTypes.TryGetValue(key, out proxyTypeHandle)) { ThrowNoProxyException(baseType, settings.AdditionalMockedInterfaces); } var interceptor = new DynamicProxyInterceptor(repository); var proxyType = Type.GetTypeFromHandle(proxyTypeHandle); if (proxyType.IsGenericTypeDefinition) proxyType = proxyType.MakeGenericType(type.GetGenericArguments()); var mockConstructorCall = settings.MockConstructorCall && proxyType.BaseType != typeof(object) && UninitializedObjectFactory.IsSupported; ConstructorInfo proxyCtor = null; if (!mockConstructorCall && settings.Args == null) { proxyCtor = proxyType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) .First(ctor => ctor.IsPublic || ctor.IsFamily || ctor.IsFamilyOrAssembly); settings.Args = proxyCtor.GetParameters() .TakeWhile(p => p.ParameterType != typeof(IInterceptor)) .Select(p => (p.Attributes & ParameterAttributes.HasDefault) != 0 ? p.DefaultValue : p.ParameterType.GetDefaultValue()) .ToArray(); } var ctorArgs = (settings.Args ?? Enumerable.Empty<object>()) .Concat(new object[] { interceptor, mockMixinImpl }) .Concat(settings.Mixins).ToArray(); if (!mockConstructorCall) { if (proxyCtor != null) { return ProfilerInterceptor.GuardExternal(() => proxyCtor.Invoke(ctorArgs)); } else { return ProfilerInterceptor.GuardExternal(() => Activator.CreateInstance(proxyType, ctorArgs)); } } else { var result = UninitializedObjectFactory.Create(proxyType); proxyType.GetMethod(".init").Invoke(result, ctorArgs); return result; } }
public IMockMixin CreateExternalMockMixin(IMockMixin mockMixin, IEnumerable <object> mixins) { var options = new ProxyGenerationOptions(); options.AddMixinInstance(mockMixin); foreach (var mixin in mixins) { options.AddMixinInstance(mixin); } var compoundMockMixin = (IMockMixin)generator.CreateClassProxy(typeof(MocksRepository.ExternalMockMixin), options); return(compoundMockMixin); }
public object Create(Type type, MocksRepository repository, IMockMixin mockMixinImpl, MockCreationSettings settings, bool createTransparentProxy) { var options = new ProxyGenerationOptions(); options.AddMixinInstance(mockMixinImpl); foreach (var mixin in settings.Mixins) options.AddMixinInstance(mixin); if (settings.AdditionalProxyTypeAttributes != null) { foreach (var attr in settings.AdditionalProxyTypeAttributes) { options.AdditionalAttributes.Add(attr); } } var interceptor = repository.Interceptor; #if SILVERLIGHT options.Hook = new ProxyGenerationHook(false, settings.InterceptorFilter); #else options.Hook = new ProxyGenerationHook(settings.MockConstructorCall, settings.InterceptorFilter); #endif object instance = null; Exception proxyFailure = null; if (type.IsInterface) { if (settings.Args != null && settings.Args.Length > 0) throw new ArgumentException("Do not supply contructor arguments when mocking an interface or delegate."); try { instance = generator.CreateInterfaceProxyWithoutTarget(type, settings.AdditionalMockedInterfaces, options, interceptor); } catch (TypeLoadException ex) { proxyFailure = ex; } catch (GeneratorException ex) { proxyFailure = ex; } } else { try { #if SILVERLIGHT if (settings.Args == null || settings.Args.Length == 0) { ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); if (!constructors.Any(constr => constr.GetParameters().Length == 0)) { var constructorToCall = constructors.FirstOrDefault(); if (constructorToCall != null) { var @params = constructorToCall.GetParameters(); settings.Args = new object[@params.Length]; for (int i = 0; i < @params.Length; ++i) { var p = @params[i]; settings.Args[i] = Convert.IsDBNull(p.DefaultValue) ? p.ParameterType.GetDefaultValue() : p.DefaultValue; } } } } #endif instance = generator.CreateClassProxy(type, settings.AdditionalMockedInterfaces, options, settings.Args, interceptor); } catch (TypeLoadException ex) { proxyFailure = ex; } catch (GeneratorException ex) { proxyFailure = ex; } catch (InvalidProxyConstructorArgumentsException ex) { proxyFailure = ex; if (!settings.MockConstructorCall) throw new MockException(ex.Message); } } if (proxyFailure != null) { throw new ProxyFailureException(proxyFailure); } return instance; }
public IMockMixin CreateExternalMockMixin(IMockMixin mockMixin, IEnumerable<object> mixins) { var options = new ProxyGenerationOptions(); options.AddMixinInstance(mockMixin); foreach (var mixin in mixins) options.AddMixinInstance(mixin); var compoundMockMixin = (IMockMixin)generator.CreateClassProxy(typeof(MocksRepository.ExternalMockMixin), options); return compoundMockMixin; }
public static object CreateProxy(object wrappedInstance, MocksRepository repository, IMockMixin mockMixin) { throw new NotSupportedException(); }
public IMockMixin CreateExternalMockMixin(IMockMixin mockMixin, IEnumerable <object> mixins) { return(new MockMixin()); }
public IMockMixin CreateExternalMockMixin(IMockMixin mockMixin, IEnumerable<object> mixins) { return new MockMixin(); }
public static object CreateProxy(object wrappedInstance, MocksRepository repository, IMockMixin mockMixin) { var interceptor = new DynamicProxyInterceptor(repository); var realProxy = new MockingProxy((MarshalByRefObject)wrappedInstance, interceptor, mockMixin); return realProxy.GetTransparentProxy(); }
public object Create(Type type, MocksRepository repository, IMockMixin mockMixinImpl, MockCreationSettings settings, bool createTransparentProxy) { var options = new ProxyGenerationOptions(); options.AddMixinInstance(mockMixinImpl); foreach (var mixin in settings.Mixins) { options.AddMixinInstance(mixin); } if (settings.AdditionalProxyTypeAttributes != null) { foreach (var attr in settings.AdditionalProxyTypeAttributes) { options.AdditionalAttributes.Add(attr); } } var interceptor = createTransparentProxy ? (IInterceptor) new StandardInterceptor() : new DynamicProxyInterceptor(repository); #if SILVERLIGHT options.Hook = new ProxyGenerationHook(false, settings.InterceptorFilter); #else options.Hook = new ProxyGenerationHook(settings.MockConstructorCall, settings.InterceptorFilter); #endif object instance = null; Exception proxyFailure = null; if (type.IsInterface) { if (settings.Args != null && settings.Args.Length > 0) { throw new ArgumentException("Do not supply contructor arguments when mocking an interface or delegate."); } try { instance = generator.CreateInterfaceProxyWithoutTarget(type, settings.AdditionalMockedInterfaces, options, interceptor); } catch (TypeLoadException ex) { proxyFailure = ex; } catch (GeneratorException ex) { proxyFailure = ex; } } else { try { #if SILVERLIGHT if (settings.Args == null || settings.Args.Length == 0) { ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); if (!constructors.Any(constr => constr.GetParameters().Length == 0)) { var constructorToCall = constructors.FirstOrDefault(); if (constructorToCall != null) { var @params = constructorToCall.GetParameters(); settings.Args = new object[@params.Length]; for (int i = 0; i < @params.Length; ++i) { var p = @params[i]; settings.Args[i] = Convert.IsDBNull(p.DefaultValue) ? p.ParameterType.GetDefaultValue() : p.DefaultValue; } } } } #endif instance = generator.CreateClassProxy(type, settings.AdditionalMockedInterfaces, options, settings.Args, interceptor); } catch (TypeLoadException ex) { proxyFailure = ex; } catch (GeneratorException ex) { proxyFailure = ex; } catch (InvalidProxyConstructorArgumentsException ex) { proxyFailure = ex; if (!settings.MockConstructorCall) { throw new MockException(ex.Message); } } } if (proxyFailure != null) { throw new ProxyFailureException(proxyFailure); } return(instance); }
public InOrderBehavior(IMockMixin mock) { this.mock = mock; this.arrangementId = InOrderArrangementCount++; }
public InOrderBehavior(IMockMixin mock, string message) { this.mock = mock; this.arrangementId = InOrderArrangementCount++; this.message = message; }
public static object CreateProxy(object wrappedInstance, MocksRepository repository, IMockMixin mockMixin) { var interceptor = new DynamicProxyInterceptor(repository); var realProxy = new MockingProxy((MarshalByRefObject)wrappedInstance, interceptor, mockMixin); return(realProxy.GetTransparentProxy()); }
public static object Create(Type resultCollectionType, MocksRepository repo, IMockReplicator replicator, IEnumerable collection) { if (resultCollectionType == typeof(string)) { return(null); } Type sourceType = collection.GetType(); if (resultCollectionType.IsAssignableFrom(sourceType)) { return(collection); } var enumerableType = resultCollectionType.GetImplementationOfGenericInterface(typeof(IEnumerable <>)) ?? typeof(IEnumerable); if (!enumerableType.IsAssignableFrom(resultCollectionType)) { throw new MockException("Return value is not an enumerable type."); } var elementType = enumerableType.IsGenericType ? enumerableType.GetGenericArguments()[0] : typeof(object); var ilistType = typeof(IList <>).MakeGenericType(elementType); var iqueryableType = typeof(IQueryable <>).MakeGenericType(elementType); IEnumerable list; if (typeof(ICollection).IsAssignableFrom(sourceType)) { list = collection; } else { var listType = typeof(List <>).MakeGenericType(elementType); var castMethod = typeof(Enumerable).GetMethod("Cast").MakeGenericMethod(elementType); var castCollection = castMethod.Invoke(null, new[] { collection }); list = (IEnumerable)MockingUtil.CreateInstance(listType, castCollection); } var listBehavior = new DelegatedImplementationBehavior(list, new[] { ilistType, typeof(IList), }); var queryable = list.AsQueryable(); var queryableType = queryable.GetType(); var queryableBehavior = new DelegatedImplementationBehavior(queryable, new[] { queryableType.GetImplementationOfGenericInterface(typeof(IQueryable <>)) }); if (replicator != null) { var mock = replicator.CreateSimilarMock(repo, resultCollectionType, null, true, null); IMockMixin mockMixin = MocksRepository.GetMockMixin(mock, null); mockMixin.FallbackBehaviors.Insert(0, queryableBehavior); mockMixin.FallbackBehaviors.Insert(0, listBehavior); return(mock); } else { MockCreationSettings settings = MockCreationSettings.GetSettings(constructorArgs: null, behavior: Behavior.Loose, additionalMockedInterfaces: MockingUtil.EmptyTypes, mockConstructorCall: null, additionalProxyTypeAttributes: null, supplementaryBehaviors: null, fallbackBehaviors: new List <IBehavior> { listBehavior, queryableBehavior }); return(repo.Create(resultCollectionType, settings)); } }