public CreationResult CreateFake(
Type typeOfFake,
IProxyOptions proxyOptions,
IDummyValueResolver resolver,
LoopDetectingResolutionContext resolutionContext)
{
if (!CastleDynamicProxyGenerator.CanGenerateProxy(typeOfFake, out string?reasonCannotGenerate))
{
return(CreationResult.FailedToCreateFake(typeOfFake, reasonCannotGenerate));
}
if (proxyOptions.ArgumentsForConstructor is not null)
{
var proxyGeneratorResult = this.GenerateProxy(typeOfFake, proxyOptions, proxyOptions.ArgumentsForConstructor);
return(proxyGeneratorResult.ProxyWasSuccessfullyGenerated
? CreationResult.SuccessfullyCreated(proxyGeneratorResult.GeneratedProxy)
: CreationResult.FailedToCreateFake(typeOfFake, proxyGeneratorResult.ReasonForFailure !));
}
return(this.TryCreateFakeWithDummyArgumentsForConstructor(
typeOfFake,
proxyOptions,
resolver,
resolutionContext));
}
public void Should_return_proxy(Type typeOfProxy)
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(typeOfProxy, Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.GeneratedProxy.Should().NotBeNull();
}
public void Should_specify_that_no_default_constructor_was_found()
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(typeof(ClassWithPrivateConstructor), Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.ReasonForFailure.Should().StartWith("No usable default constructor was found on the type");
}
public void Should_specify_that_sealed_types_cannot_be_generated()
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(typeof(SealedType), A.Dummy <IEnumerable <Type> >(), A.Dummy <IEnumerable <object> >(), Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.ReasonForFailure.Should().Be("The type of proxy FakeItEasy.Tests.Creation.CastleDynamicProxy.CastleDynamicProxyGeneratorTests+SealedType is sealed.");
}
public void Should_specify_that_value_types_cannot_be_generated()
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(typeof(int), Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.ReasonForFailure.Should().Be("The type of proxy must be an interface or a class but it was System.Int32.");
}
public void Should_return_result_with_ProxyWasSuccessfullyGenerated_set_to_false_when_proxy_cannot_be_generated(Type typeOfProxy)
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(typeOfProxy, Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.ProxyWasSuccessfullyGenerated.Should().BeFalse();
}
public void Should_implement_additional_interfaces(Type typeOfProxy)
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(typeOfProxy, new[] { typeof(IFoo) }, null, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.GeneratedProxy.Should().NotBeNull().And.BeAssignableTo <IFoo>();
}
public void GenerateProxy_should_be_null_guarded()
{
// Arrange
// Act
// Assert
Expression <Action> call = () => CastleDynamicProxyGenerator.GenerateProxy(typeof(IInterfaceType), Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
call.Should().BeNullGuarded();
}
public void Should_return_proxy_that_is_of_the_specified_type(Type typeOfProxy)
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(typeOfProxy, Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.GeneratedProxy.Should().NotBeNull()
.And.Subject.Should().Match(p => typeOfProxy.IsInstanceOfType(p));
}
public void Should_specify_that_private_class_was_not_found()
{
// Arrange
// Act
var type = Type.GetType("FluentAssertions.Common.NullReflector, FluentAssertions.Core");
var result = CastleDynamicProxyGenerator.GenerateProxy(type, Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.ReasonForFailure.Should().StartWith("No usable default constructor was found on the type FluentAssertions.Common.NullReflector.\r\nAn exception of type Castle.DynamicProxy.Generators.GeneratorException was caught during this call. Its message was:\r\nCan not create proxy for type FluentAssertions.Common.NullReflector because it is not accessible. Make it public, or internal and mark your assembly with [assembly: InternalsVisibleTo(\"DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7\")] attribute, because assembly FluentAssertions.Core is strong-named.");
}
public void Should_fail_when_arguments_for_constructor_is_passed_with_interface_proxy()
{
// Arrange
var arguments = new object[] { "no constructor on interface " };
// Act
var ex = Record.Exception(() => CastleDynamicProxyGenerator.GenerateProxy(typeof(IInterfaceType), Enumerable.Empty <Type>(), arguments, Enumerable.Empty <Expression <Func <Attribute> > >(), A.Dummy <IFakeCallProcessorProvider>()));
// Assert
ex.Should().BeAnExceptionOfType <ArgumentException>()
.WithMessage("Arguments for constructor specified for interface type.");
}
public void Should_ensure_fake_call_processor_is_initialized_but_not_fetched_when_no_method_on_fake_is_called(Type typeThatImplementsInterfaceType)
{
// Arrange
var fakeCallProcessorProvider = A.Fake <IFakeCallProcessorProvider>();
// Act
CastleDynamicProxyGenerator.GenerateProxy(typeThatImplementsInterfaceType, Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), fakeCallProcessorProvider);
// Assert
A.CallTo(() => fakeCallProcessorProvider.Fetch(A <object> ._)).MustNotHaveHappened();
A.CallTo(() => fakeCallProcessorProvider.EnsureInitialized(A <object> ._)).MustHaveHappened();
}
public void Should_be_able_to_intercept_ToString(Type typeOfProxy)
{
// Arrange
var fakeCallProcessorProvider = CreateFakeCallProcessorProvider(c => c.SetReturnValue("interception return value"));
// Act
var proxy = CastleDynamicProxyGenerator.GenerateProxy(typeOfProxy, Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), fakeCallProcessorProvider);
var toStringResult = proxy.GeneratedProxy.ToString();
// Assert
toStringResult.Should().Be("interception return value");
}
public void Serialized_proxies_should_deserialize_to_an_object(Type typeOfProxy)
{
// Arrange
// Here we can't use A.Dummy<IFakeCallProcessorProvider>() because the EnsureInitialized() call within GenerateProxy()
// triggers the Castle issue #65 (https://github.com/castleproject/Core/issues/65)
var result = CastleDynamicProxyGenerator.GenerateProxy(typeOfProxy, Type.EmptyTypes, null, Enumerable.Empty <Expression <Func <Attribute> > >(), new SerializableFakeCallProcessorProvider());
var proxy = result.GeneratedProxy;
// Act
var deserializedProxy = BinarySerializationHelper.SerializeAndDeserialize(proxy);
// Assert
deserializedProxy.Should().NotBeNull();
}
public void Should_fail_with_correct_message_when_no_constructor_matches_the_passed_in_arguments()
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(
typeof(TypeWithArgumentsForConstructor),
Enumerable.Empty <Type>(),
new object[] { "no constructor takes a string" },
Enumerable.Empty <Expression <Func <Attribute> > >(),
A.Dummy <IFakeCallProcessorProvider>());
// Assert
result.ReasonForFailure.Should().StartWith("No constructor matches the passed arguments for constructor.\r\nAn exception of type Castle.DynamicProxy.InvalidProxyConstructorArgumentsException was caught during this call. Its message was:\r\nCan not instantiate proxy of class: FakeItEasy.Tests.Creation.CastleDynamicProxy.CastleDynamicProxyGeneratorTests+TypeWithArgumentsForConstructor.\r\nCould not find a constructor that would match given arguments:\r\nSystem.String\r\n");
}
public void GenerateClassProxy_should_be_null_guarded()
{
// Arrange
// Act
// Assert
Expression <Action> call = () => CastleDynamicProxyGenerator.GenerateClassProxy(
typeof(AbstractClass),
this.noAdditionalInterfaces,
Enumerable.Empty <object>(),
Enumerable.Empty <Expression <Func <Attribute> > >(),
A.Dummy <IFakeCallProcessorProvider>());
call.Should().BeNullGuarded();
}
public void Should_pass_arguments_for_constructor_to_constructed_instance()
{
// Arrange
// Act
var result = CastleDynamicProxyGenerator.GenerateProxy(
typeof(TypeWithArgumentsForConstructor),
Enumerable.Empty <Type>(),
new object[] { 10 },
Enumerable.Empty <Expression <Func <Attribute> > >(),
A.Dummy <IFakeCallProcessorProvider>());
var proxy = (TypeWithArgumentsForConstructor)result.GeneratedProxy;
// Assert
proxy.Argument.Should().Be(10);
}
public CreationResult CreateFakeInterface(Type typeOfFake, IProxyOptions proxyOptions)
{
if (proxyOptions.ArgumentsForConstructor is not null)
{
throw new ArgumentException(DynamicProxyMessages.ArgumentsForConstructorOnInterfaceType);
}
var fakeCallProcessorProvider = this.fakeCallProcessorProviderFactory(typeOfFake, proxyOptions);
var proxyGeneratorResult = CastleDynamicProxyGenerator.GenerateInterfaceProxy(
typeOfFake,
proxyOptions.AdditionalInterfacesToImplement,
proxyOptions.Attributes,
fakeCallProcessorProvider);
return(proxyGeneratorResult.ProxyWasSuccessfullyGenerated
? CreationResult.SuccessfullyCreated(proxyGeneratorResult.GeneratedProxy)
: CreationResult.FailedToCreateFake(typeOfFake, proxyGeneratorResult.ReasonForFailure !));
}
public void Should_delegate_to_fake_call_processor_when_method_on_fake_is_called(Type typeThatImplementsInterfaceType)
{
// Arrange
IInterceptedFakeObjectCall interceptedFakeObjectCall = null;
var fakeCallProcessorProvider = CreateFakeCallProcessorProvider(c => interceptedFakeObjectCall = c);
var result = CastleDynamicProxyGenerator.GenerateProxy(typeThatImplementsInterfaceType, Enumerable.Empty <Type>(), null, Enumerable.Empty <Expression <Func <Attribute> > >(), fakeCallProcessorProvider);
var proxy = (IInterfaceType)result.GeneratedProxy;
// Act
proxy.Foo(1, 2);
// Assert
interceptedFakeObjectCall.Should().NotBeNull();
interceptedFakeObjectCall.Arguments.Should().BeEquivalentTo(1, 2);
interceptedFakeObjectCall.Method.Name.Should().Be(
typeof(IInterfaceType).GetMethod(nameof(IInterfaceType.Foo)).Name);
interceptedFakeObjectCall.FakedObject.Should().BeSameAs(proxy);
}
public CastleDynamicProxyGeneratorTests()
{
this.interceptionValidator = A.Fake <CastleDynamicProxyInterceptionValidator>();
this.generator = new CastleDynamicProxyGenerator(this.interceptionValidator);
}
