/// <inheritdoc cref="IMockedDependencyFactory" />
public IMockedDependency <T> CreateMockedDependency <T>(MockBehavior behavior)
where T : notnull
{
Ensures.IsInterface <T>();
var arrangements = new ArrangementCollection();
var interceptor = InterceptorFactory.CreateInterceptorFor(behavior, arrangements);
var proxy = DynamicProxyFactory.CreateForInterface <T>(interceptor);
return(new MockedDependency <T>(arrangements, interceptor, proxy));
}
public void CreateEmptyArrangementCollection()
{
// Given
// When
var arrangmentCollection = new ArrangementCollection();
// Then
Assert.Empty(arrangmentCollection);
Assert.Equal(0u, arrangmentCollection.Count);
}
/// <inheritdoc cref="IMockedDependencyFactory" />
public IMockedDependency <T> CreateDecoratedDependency <T>(T decoratee)
where T : notnull
{
Ensures.IsInterface <T>();
var arrangements = new ArrangementCollection();
var interceptor = InterceptorFactory.CreateInterceptorFor(MockBehavior.Partial, arrangements);
var proxy = DynamicProxyFactory.CreateDecorator <T>(decoratee, interceptor);
return(new MockedDependency <T>(arrangements, interceptor, proxy));
}
public void SetupBehaviorOfValueTypeFuncWithOneParameter()
{
// Given
var arrangements = new ArrangementCollection();
var mockArrangements = new MockBehavior <IFooFuncValueTypeParameterIn <int> >(arrangements);
// When
var callArrangements = mockArrangements.That(f => f.MethodWithOneParameter(0));
// Then
Assert.NotNull(callArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooFuncValueTypeParameterIn <int>, int> >(callArrangements);
}
public void SetupBehaviorOfReferenceTypePropertySetter()
{
// Given
var arrangements = new ArrangementCollection();
var mockArrangements = new MockBehavior <IFooReferenceTypeSetter <object> >(arrangements);
// When
var callArrangements = mockArrangements.ThatAssigning(b => b.Setter = 0);
// Then
Assert.NotNull(callArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooReferenceTypeSetter <object> > >(callArrangements);
}
public void SetupBehaviorOfValueTypeActionWithoutParameter()
{
// Given
var arrangements = new ArrangementCollection();
var mockArrangements = new MockBehavior <IFooActionParameterless>(arrangements);
// When
var callArrangements = mockArrangements.That(b => b.MethodWithoutParameter());
// Then
Assert.NotNull(callArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooActionParameterless> >(callArrangements);
}
public void SetupBehaviorOfReferenceTypeFuncWithoutParameter()
{
// Given
var arrangements = new ArrangementCollection();
var mockArrangements = new MockBehavior <IFooFuncReferenceTypeParameterless <object> >(arrangements);
// When
var callArrangements = mockArrangements.That(b => b.MethodWithoutParameter());
// Then
Assert.NotNull(callArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooFuncReferenceTypeParameterless <object>, object?> >(callArrangements);
}
public void SetupBehaviorOfValueTypePropertyGetter()
{
// Given
var arrangements = new ArrangementCollection();
var mockArrangements = new MockBehavior <IFooValueTypeGetter <int> >(arrangements);
// When
var callArrangements = mockArrangements.That(f => f.Getter);
// Then
Assert.NotNull(callArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooValueTypeGetter <int>, int> >(callArrangements);
}
public void CreateNewArrangementCollection()
{
// Given
var signature = typeof(IFooFuncValueTypeParameterless <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterless <int> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var arrangment = new ReturnValueArrangement <int>(signature, 42);
// When
var arrangmentCollection = new ArrangementCollection(arrangment);
// Then
Assert.Single(arrangmentCollection);
Assert.Equal(1u, arrangmentCollection.Count);
}
public void SetupBehaviorOfReferenceTypePropertyGetterSetter()
{
// Given
var arrangements = new ArrangementCollection();
var mockArrangements = new MockBehavior <IFooReferenceTypeProperty <object> >(arrangements);
// When
var getterArrangements = mockArrangements.That(b => b.GetterSetter);
var setterArrangements = mockArrangements.ThatAssigning(b => b.GetterSetter = 0);
// Then
Assert.NotNull(getterArrangements);
Assert.NotNull(setterArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooReferenceTypeProperty <object>, object?> >(getterArrangements);
Assert.IsAssignableFrom <ICallBehavior <IFooReferenceTypeProperty <object> > >(setterArrangements);
}
public void SuccessfullInvocationWithoutArrangement()
{
// Given
var type = typeof(object);
var methodName = nameof(object.GetHashCode);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var methodInvocation = new Invocation(signature, new ReturnValueInvocation <int>());
var emptyArrangements = new ArrangementCollection();
var interceptor = new PartialMockInterceptor(emptyArrangements);
// When
var wasIntercepted = interceptor.Intercept(methodInvocation);
// Then
Assert.False(wasIntercepted);
}
/// <inheritdoc cref="IMockedDependencyFactory" />
public IMockedDependency CreateMockedDependency(Type dependency, MockBehavior behavior)
{
Ensures.NotNull(dependency, nameof(dependency));
Ensures.IsInterface(dependency);
var arrangements = new ArrangementCollection();
var interceptor = InterceptorFactory.CreateInterceptorFor(behavior, arrangements);
var proxy = DynamicProxyFactory.CreateForInterface(dependency, interceptor);
var mockedDependencyType = typeof(MockedDependency <>).MakeGenericType(dependency);
var instance = Activator.CreateInstance(mockedDependencyType, new[] { arrangements, interceptor, proxy });
if (instance is IMockedDependency mockedDependency)
{
return(mockedDependency);
}
throw new InvalidOperationException("Invalid mocked dependency instance");
}
public void ExcpetionIsThrownForUnarrangePropertySetterInvocation()
{
// Given
var type = typeof(Stream);
var propertyName = nameof(Stream.Position);
var signature = type.GetProperty(propertyName)?.GetSetMethod() ?? throw new PropertyInfoException(type, propertyName);
var setterInvocation = new Invocation(signature);
var emptyArrangements = new ArrangementCollection();
var interceptor = new StrictMockInterceptor(emptyArrangements);
// When
var exception = Assert.Throws <MissingArrangementException>(() => interceptor.Intercept(setterInvocation));
// Then
Assert.Contains(type.Name, exception.Message);
Assert.Contains(propertyName, exception.Message);
Assert.Contains("setter", exception.Message);
}
public void SetupThrowExceptionArrangement()
{
// Given
var type = typeof(IFooActionParameterless);
var methodName = nameof(IFooActionParameterless.MethodWithoutParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var arrangements = new ArrangementCollection();
var mockBehavior = new MockBehavior <IFooActionParameterless>(arrangements);
var callBehavior = new CallBehavior <IFooActionParameterless>(arrangements, signature, mockBehavior);
// When
callBehavior.Throws <ArgumentException>();
// Then
Assert.Single(arrangements);
var arrangement = arrangements.First() as ExceptionArrangement;
Assert.NotNull(arrangement);
}
public void CheckIfAMatchingArrangmentExists()
{
// Given
var signature = typeof(IFooFuncValueTypeParameterless <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterless <int> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var otherSignature = typeof(IFooFuncValueTypeParameterIn <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterIn <int> .MethodWithOneParameter)) ?? throw new InvalidOperationException();
var returnValueFeature = new ReturnValueInvocation <int>();
var invocation = new Invocation(signature, returnValueFeature);
var arrangment = new ReturnValueArrangement <int>(signature, 42);
var otherArrangment = new ReturnValueArrangement <int>(otherSignature, 13);
var arrangmentCollection = new ArrangementCollection(arrangment, otherArrangment);
// When
var hasMatchingArrangment = arrangmentCollection.CanApplyAtLeasOneArrangmentTo(invocation);
// Then
Assert.True(hasMatchingArrangment);
}
public void ExcpetionIsThrownForUnarrangeMethodInvocation()
{
// Given
var type = typeof(object);
var methodName = nameof(object.GetHashCode);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var methodInvocation = new Invocation(signature);
var emptyArrangements = new ArrangementCollection();
var interceptor = new StrictMockInterceptor(emptyArrangements);
// When
var exception = Assert.Throws <MissingArrangementException>(() => interceptor.Intercept(methodInvocation));
// Then
Assert.Contains(type.Name, exception.Message);
Assert.Contains(methodName, exception.Message);
Assert.Contains("method", exception.Message);
}
public void SetupRethrowExceptionInstanceArrangement()
{
// Given
var type = typeof(IFooFuncValueTypeParameterless <int>);
var methodName = nameof(IFooFuncValueTypeParameterless <int> .MethodWithoutParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var arrangements = new ArrangementCollection();
var mockBehavior = new MockBehavior <IFooFuncValueTypeParameterIn <int> >(arrangements);
var callBehavior = new CallBehavior <IFooFuncValueTypeParameterIn <int>, int>(arrangements, signature, mockBehavior);
// When
callBehavior.Throws(new Exception());
// Then
Assert.Single(arrangements);
var arrangement = arrangements.First() as ExceptionArrangement;
Assert.NotNull(arrangement);
}
public void SetupReturnSequenceArrangement()
{
// Given
var type = typeof(IFooFuncValueTypeParameterIn <int>);
var methodName = nameof(IFooFuncValueTypeParameterIn <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var arrangements = new ArrangementCollection();
var mockBehavior = new MockBehavior <IFooFuncValueTypeParameterIn <int> >(arrangements);
var callBehavior = new CallBehavior <IFooFuncValueTypeParameterIn <int>, int>(arrangements, signature, mockBehavior);
// When
callBehavior.ReturnsSequence(13, 42);
// Then
Assert.Single(arrangements);
var arrangement = arrangements.First() as ReturnValueSequenceArrangement <int>;
Assert.NotNull(arrangement);
}
public void SetupRecordFourParametersArrangement()
{
// Given
var type = typeof(IFooFuncValueTypeParameterIn <int>);
var methodName = nameof(IFooFuncValueTypeParameterIn <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var arrangements = new ArrangementCollection();
var mockBehavior = new MockBehavior <IFooFuncValueTypeParameterIn <int> >(arrangements);
var callBehavior = new CallBehavior <IFooFuncValueTypeParameterIn <int> >(arrangements, signature, mockBehavior);
// When
callBehavior.Records <int, int, int, int>(out var recordedCalls);
// Then
Assert.Single(arrangements);
Assert.Empty(recordedCalls);
var arrangement = arrangements.First() as RecordParameterArrangement <(int, int, int, int)>;
Assert.NotNull(arrangement);
}
public void SuccessfullInvocationWithoutArrangement()
{
// Given
var type = typeof(object);
var methodName = nameof(object.GetHashCode);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var methodInvocation = new Invocation(signature, new ReturnValueInvocation <int>());
var emptyArrangements = new ArrangementCollection();
var interceptor = new LooseMockInterceptor(emptyArrangements);
// When
var wasIntercepted = interceptor.Intercept(methodInvocation);
// Then
Assert.True(wasIntercepted);
var hasFeature = methodInvocation.TryGetFeature <IReturnValue <int> >(out var feature);
Assert.True(hasFeature);
Assert.Equal(default(int), feature?.ReturnValue);
}
public void OnlyApplyMatchingArrangement()
{
// Given
var signature = typeof(IFooFuncValueTypeParameterless <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterless <int> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var otherSignature = typeof(IFooFuncValueTypeParameterIn <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterIn <int> .MethodWithOneParameter)) ?? throw new InvalidOperationException();
var returnValueFeature = new ReturnValueInvocation <int>();
var invocation = new Invocation(signature, returnValueFeature);
var arrangment = new ReturnValueArrangement <int>(signature, 42);
var otherArrangment = new ReturnValueArrangement <int>(otherSignature, 13);
var arrangmentCollection = new ArrangementCollection(arrangment, otherArrangment);
// When
arrangmentCollection.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IReturnValue <int> >());
var feature = invocation.GetFeature <IReturnValue <int> >();
Assert.Equal(42, feature.ReturnValue);
}
