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);
}
}
public MockingProxy(MarshalByRefObject wrappedInstance, IInterceptor interceptor, IMockMixin mockMixin)
: base(wrappedInstance.GetType())
{
this.WrappedInstance = wrappedInstance;
this.interceptor = interceptor;
this.mockMixin = mockMixin;
}
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);
}
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 static object CreateProxy(object wrappedInstance, MocksRepository repository, IMockMixin mockMixin)
{
throw new NotSupportedException();
}
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));
}
}
public InOrderBehavior(IMockMixin mock)
{
this.mock = mock;
this.arrangementId = InOrderArrangementCount++;
}
