public void Should_be_successful_with_delegate_types(Type delegateType)
{
// Arrange
// Act
var result = DelegateProxyGenerator.GenerateProxy(delegateType, A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.ProxyWasSuccessfullyGenerated.Should().BeTrue();
}
public void Should_create_proxy_of_the_specified_type(Type delegateType)
{
// Arrange
// Act
var result = DelegateProxyGenerator.GenerateProxy(delegateType, A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.GeneratedProxy.GetType().Should().Be(delegateType);
}
private Type GenerateProxyType <TDelegate>()
{
var scope = generator.ProxyBuilder.ModuleScope;
var proxyGenerator = new DelegateProxyGenerator(scope, typeof(TDelegate))
{
Logger = generator.ProxyBuilder.Logger
};
return(proxyGenerator.GetProxyType());
}
public void Should_fail_for_non_delegate_types(Type nonDelegateType)
{
// Arrange
// Act
var result = DelegateProxyGenerator.GenerateProxy(nonDelegateType, A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.ProxyWasSuccessfullyGenerated.Should().BeFalse();
result.ReasonForFailure.Should().Be("The delegate proxy generator can only create proxies for delegate types.");
}
private Type GetProxyType(IProxyBuilder builder, Type targetDelegateType)
{
var scope = builder.ModuleScope;
var logger = builder.Logger;
var generator = new DelegateProxyGenerator(scope, targetDelegateType)
{
Logger = logger
};
return(generator.GetProxyType());
}
public void Should_ensure_fake_call_processor_is_initialized_but_not_fetched_when_no_method_on_fake_is_called()
{
// Arrange
var fakeCallProcessorProvider = A.Fake <IFakeCallProcessorProvider>();
// Act
var proxyGeneratorResult = DelegateProxyGenerator.GenerateProxy(typeof(Action), fakeCallProcessorProvider);
// Assert
A.CallTo(() => fakeCallProcessorProvider.Fetch(A <object> ._)).MustNotHaveHappened();
A.CallTo(() => fakeCallProcessorProvider.EnsureInitialized(proxyGeneratorResult.GeneratedProxy)).MustHaveHappened();
}
private T GenerateProxy <T>(Action <IInterceptedFakeObjectCall> fakeCallProcessorAction)
{
var fakeCallProcessor = A.Fake <IFakeCallProcessor>();
A.CallTo(() => fakeCallProcessor.Process(A <IInterceptedFakeObjectCall> ._)).Invokes(fakeCallProcessorAction);
var fakeCallProcessorProvider = A.Fake <IFakeCallProcessorProvider>();
A.CallTo(() => fakeCallProcessorProvider.Fetch(A <object> ._)).Returns(fakeCallProcessor);
return((T)DelegateProxyGenerator.GenerateProxy(typeof(T), fakeCallProcessorProvider).GeneratedProxy);
}
public CreationResult CreateFake(Type typeOfFake, IProxyOptions proxyOptions, DummyCreationSession session, IDummyValueResolver resolver)
{
if (proxyOptions.Attributes.Any())
{
return(CreationResult.FailedToCreateFake(typeOfFake, "Faked delegates cannot have custom attributes applied to them."));
}
if (proxyOptions.ArgumentsForConstructor != null && proxyOptions.ArgumentsForConstructor.Any())
{
return(CreationResult.FailedToCreateFake(typeOfFake, "Faked delegates cannot be made using explicit constructor arguments."));
}
if (proxyOptions.AdditionalInterfacesToImplement.Any())
{
return(CreationResult.FailedToCreateFake(typeOfFake, "Faked delegates cannot be made to implement additional interfaces."));
}
var fakeCallProcessorProvider = this.fakeCallProcessorProviderFactory(typeOfFake, proxyOptions);
var proxyGeneratorResult = DelegateProxyGenerator.GenerateProxy(typeOfFake, fakeCallProcessorProvider);
return(proxyGeneratorResult.ProxyWasSuccessfullyGenerated
? CreationResult.SuccessfullyCreated(proxyGeneratorResult.GeneratedProxy)
: CreationResult.FailedToCreateFake(typeOfFake, proxyGeneratorResult.ReasonForFailure));
}
public ProxyGeneratorSelector(DelegateProxyGenerator delegateProxyGenerator, IProxyGenerator defaultProxyGenerator)
{
this.delegateProxyGenerator = delegateProxyGenerator;
this.defaultProxyGenerator = defaultProxyGenerator;
}
public ProxyGeneratorSelectorTests()
{
this.delegateProxyGenerator = A.Fake <DelegateProxyGenerator>();
this.defaultProxyGenerator = A.Fake <IProxyGenerator>();
this.selector = new ProxyGeneratorSelector(this.delegateProxyGenerator, this.defaultProxyGenerator);
}
public bool IsResponsibleForCreating(Type typeOfFake) => DelegateProxyGenerator.CanGenerateProxy(typeOfFake, out _);
public DelegateProxyGeneratorTests()
{
this.generator = new DelegateProxyGenerator();
}
