public override void Participate(object id, IProxyTypeAssemblyContext proxyTypeAssemblyContext)
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new ModifiedAssembledTypeAttribute());
var attribute = new CustomAttributeDeclaration(constructor, new object[0]);
proxyTypeAssemblyContext.ProxyType.AddCustomAttribute(attribute);
}
public void Participate(object id, IProxyTypeAssemblyContext proxyTypeAssemblyContext)
{
ArgumentUtility.CheckNotNull("proxyTypeAssemblyContext", proxyTypeAssemblyContext);
if (!s_domainObjectBaseType.IsTypePipeAssignableFrom(proxyTypeAssemblyContext.RequestedType))
{
return;
}
var proxyType = proxyTypeAssemblyContext.ProxyType;
var domainObjectType = proxyTypeAssemblyContext.RequestedType;
var classDefinition = _typeDefinitionProvider.GetTypeDefinition(domainObjectType);
if (classDefinition == null || classDefinition.IsAbstract)
{
return;
}
// Add marker interface.
proxyType.AddInterface(typeof(IInterceptedDomainObject));
// Override infrastructure hooks on DomainObject.
OverridePerformConstructorCheck(proxyType);
OverrideGetPublicDomainObjectType(proxyType, domainObjectType);
// Intercept properties.
InterceptProperties(proxyType, domainObjectType, classDefinition);
}
public IMixinInfo GetMixinInfo(IProxyTypeAssemblyContext context, MixinDefinition mixin)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("mixin", mixin);
if (!mixin.NeedsDerivedMixinType())
{
return(new RegularMixinInfo(mixin.Type));
}
var concreteMixinTypeIdentifier = mixin.GetConcreteMixinTypeIdentifier();
return(GetOrGenerateConcreteMixinType(context, concreteMixinTypeIdentifier));
}
public void Participate(object id, IProxyTypeAssemblyContext proxyTypeAssemblyContext)
{
ArgumentUtility.CheckNotNull("proxyTypeAssemblyContext", proxyTypeAssemblyContext);
var targetClassDefinition = _configurationProvider.GetTargetClassDefinition((ClassContext)id);
if (targetClassDefinition == null)
{
return;
}
var concreteTarget = proxyTypeAssemblyContext.ProxyType;
var mixinInfos = targetClassDefinition.Mixins.Select(m => _mixinTypeProvider.GetMixinInfo(proxyTypeAssemblyContext, m)).ToList();
var interfacesToImplement = _configurationProvider.GetInterfacesToImplement(targetClassDefinition, mixinInfos);
_targetTypeModifier.ModifyTargetType(concreteTarget, targetClassDefinition, interfacesToImplement, mixinInfos);
}
public void AssembleType()
{
var participantMock1 = new Mock <IParticipant> (MockBehavior.Strict);
var participantMock2 = new Mock <IParticipant> (MockBehavior.Strict);
var mutableTypeFactoryMock = new Mock <IMutableTypeFactory> (MockBehavior.Strict);
var assembledTypeIdentifierProviderMock = new Mock <IAssembledTypeIdentifierProvider> (MockBehavior.Strict);
var complexSerializationEnablerMock = new Mock <IComplexSerializationEnabler> (MockBehavior.Strict);
var codeGeneratorMock = new Mock <IMutableTypeBatchCodeGenerator> (MockBehavior.Strict);
var participantConfigurationID = "participant configuration id";
var typeID = AssembledTypeIDObjectMother.Create(_requestedType, new object[] { "type id part" });
var additionalTypeID = new object();
var generationCompletedEventRaised = false;
var fakeGeneratedType = ReflectionObjectMother.GetSomeType();
var fakeGeneratedAdditionalType = ReflectionObjectMother.GetSomeType();
var sequence = new MockSequence();
var typeIdentifierProviderMock = new Mock <ITypeIdentifierProvider> (MockBehavior.Strict);
participantMock1
.InSequence(sequence)
.SetupGet(mock => mock.PartialTypeIdentifierProvider)
.Returns(typeIdentifierProviderMock.Object);
participantMock2
.InSequence(sequence)
.SetupGet(mock => mock.PartialTypeIdentifierProvider)
.Returns((ITypeIdentifierProvider)null);
var proxyType = MutableTypeObjectMother.Create();
var typeModificationTrackerMock = new Mock <ITypeModificationTracker> (MockBehavior.Strict);
mutableTypeFactoryMock
.InSequence(sequence)
.Setup(mock => mock.CreateProxy(_requestedType, ProxyKind.AssembledType))
.Returns(typeModificationTrackerMock.Object);
typeModificationTrackerMock
.InSequence(sequence)
.SetupGet(stub => stub.Type)
.Returns(proxyType);
var idPart = new object();
assembledTypeIdentifierProviderMock
.InSequence(sequence)
.Setup(mock => mock.GetPart(It.Is <AssembledTypeID> (id => id.Equals(typeID)), participantMock1.Object))
.Returns(idPart);
IProxyTypeAssemblyContext proxyTypeAssemblyContextPassedToParticipant1 = null;
participantMock1
.InSequence(sequence)
.Setup(mock => mock.Participate(idPart, It.IsAny <IProxyTypeAssemblyContext>()))
.Callback(
(object id, IProxyTypeAssemblyContext proxyTypeAssemblyContextArg) =>
{
proxyTypeAssemblyContextPassedToParticipant1 = proxyTypeAssemblyContextArg;
Assert.That(proxyTypeAssemblyContextPassedToParticipant1.ParticipantConfigurationID, Is.EqualTo(participantConfigurationID));
Assert.That(proxyTypeAssemblyContextPassedToParticipant1.ParticipantState, Is.SameAs(_participantStateMock.Object));
Assert.That(proxyTypeAssemblyContextPassedToParticipant1.RequestedType, Is.SameAs(_requestedType));
Assert.That(proxyTypeAssemblyContextPassedToParticipant1.ProxyType, Is.SameAs(proxyType));
proxyTypeAssemblyContextPassedToParticipant1.CreateAdditionalType(additionalTypeID, "AdditionalType", null, 0, typeof(int));
proxyTypeAssemblyContextPassedToParticipant1.GenerationCompleted += ctx =>
{
Assert.That(ctx.GetGeneratedType(proxyType), Is.SameAs(fakeGeneratedType));
generationCompletedEventRaised = true;
};
});
var additionalType = MutableTypeObjectMother.Create();
mutableTypeFactoryMock
.InSequence(sequence)
.Setup(mock => mock.CreateType("AdditionalType", null, 0, typeof(int), null)).Returns(additionalType);
assembledTypeIdentifierProviderMock
.InSequence(sequence)
.Setup(mock => mock.GetPart(It.Is <AssembledTypeID> (id => id.Equals(typeID)), participantMock2.Object))
.Returns((object)null);
participantMock2
.InSequence(sequence)
.Setup(mock => mock.Participate(null, It.IsAny <IProxyTypeAssemblyContext>()))
.Callback(
(object _, IProxyTypeAssemblyContext proxyTypeAssemblyContext) =>
{
Assert.That(proxyTypeAssemblyContext, Is.EqualTo(proxyTypeAssemblyContextPassedToParticipant1));
});
typeModificationTrackerMock
.InSequence(sequence)
.Setup(mock => mock.IsModified()).Returns(true);
assembledTypeIdentifierProviderMock
.InSequence(sequence)
.Setup(mock => mock.AddTypeID(proxyType, It.Is <AssembledTypeID> (id => id.Equals(typeID))));
complexSerializationEnablerMock
.InSequence(sequence)
.Setup(
mock => mock.MakeSerializable(
proxyType,
participantConfigurationID,
assembledTypeIdentifierProviderMock.Object,
It.Is <AssembledTypeID> (id => id.Equals(typeID))));
codeGeneratorMock
.InSequence(sequence)
.Setup(mock => mock.GenerateTypes(It.Is <IEnumerable <MutableType> > (mutableTypes => mutableTypes.SequenceEqual(new[] { additionalType, proxyType }))))
.Returns(
new[]
{
new KeyValuePair <MutableType, Type> (proxyType, fakeGeneratedType),
new KeyValuePair <MutableType, Type> (additionalType, fakeGeneratedAdditionalType)
})
.Callback(
(IEnumerable <MutableType> _) =>
{
Assert.That(generationCompletedEventRaised, Is.False);
var proxyAttribute = proxyType.AddedCustomAttributes.Single();
Assert.That(proxyAttribute.Type, Is.SameAs(typeof(AssembledTypeAttribute)));
Assert.That(proxyAttribute.ConstructorArguments, Is.Empty);
Assert.That(proxyAttribute.NamedArguments, Is.Empty);
});
var typeAssembler = CreateTypeAssembler(
mutableTypeFactoryMock.Object,
assembledTypeIdentifierProviderMock.Object,
complexSerializationEnablerMock.Object,
participantConfigurationID,
new[] { participantMock1.Object, participantMock2.Object });
var result = typeAssembler.AssembleType(typeID, _participantStateMock.Object, codeGeneratorMock.Object);
participantMock1.Verify();
participantMock2.Verify();
mutableTypeFactoryMock.Verify();
typeModificationTrackerMock.Verify();
assembledTypeIdentifierProviderMock.Verify();
codeGeneratorMock.Verify();
Assert.That(generationCompletedEventRaised, Is.True);
Assert.That(result, Is.Not.Null);
Assert.That(result.Type, Is.SameAs(fakeGeneratedType));
Assert.That(result.AdditionalTypes.Count, Is.EqualTo(1));
Assert.That(result.AdditionalTypes[additionalTypeID], Is.SameAs(fakeGeneratedAdditionalType));
}
public void AssembleType()
{
var mockRepository = new MockRepository();
var participantMock1 = mockRepository.StrictMock <IParticipant>();
var participantMock2 = mockRepository.StrictMock <IParticipant>();
var mutableTypeFactoryMock = mockRepository.StrictMock <IMutableTypeFactory>();
var assembledTypeIdentifierProviderMock = mockRepository.StrictMock <IAssembledTypeIdentifierProvider>();
var complexSerializationEnablerMock = mockRepository.StrictMock <IComplexSerializationEnabler>();
var codeGeneratorMock = mockRepository.StrictMock <IMutableTypeBatchCodeGenerator>();
var participantConfigurationID = "participant configuration id";
var typeID = AssembledTypeIDObjectMother.Create(_requestedType, new object[] { "type id part" });
var additionalTypeID = new object();
var generationCompletedEventRaised = false;
var fakeGeneratedType = ReflectionObjectMother.GetSomeType();
var fakeGeneratedAdditionalType = ReflectionObjectMother.GetSomeType();
using (mockRepository.Ordered())
{
var typeIdentifierProviderMock = MockRepository.GenerateStrictMock <ITypeIdentifierProvider>();
participantMock1.Expect(mock => mock.PartialTypeIdentifierProvider).Return(typeIdentifierProviderMock);
participantMock2.Expect(mock => mock.PartialTypeIdentifierProvider).Return(null);
var proxyType = MutableTypeObjectMother.Create();
var typeModificationTrackerMock = mockRepository.StrictMock <ITypeModificationTracker>();
mutableTypeFactoryMock.Expect(mock => mock.CreateProxy(_requestedType, ProxyKind.AssembledType)).Return(typeModificationTrackerMock);
typeModificationTrackerMock.Stub(stub => stub.Type).Return(proxyType);
var idPart = new object();
assembledTypeIdentifierProviderMock
.Expect(mock => mock.GetPart(Arg <AssembledTypeID> .Matches(id => id.Equals(typeID)), Arg.Is(participantMock1)))
.Return(idPart);
IProxyTypeAssemblyContext proxyTypeAssemblyContext = null;
participantMock1.Expect(mock => mock.Participate(Arg.Is(idPart), Arg <IProxyTypeAssemblyContext> .Is.Anything)).WhenCalled(
mi =>
{
proxyTypeAssemblyContext = (IProxyTypeAssemblyContext)mi.Arguments[1];
Assert.That(proxyTypeAssemblyContext.ParticipantConfigurationID, Is.EqualTo(participantConfigurationID));
Assert.That(proxyTypeAssemblyContext.ParticipantState, Is.SameAs(_participantStateMock));
Assert.That(proxyTypeAssemblyContext.RequestedType, Is.SameAs(_requestedType));
Assert.That(proxyTypeAssemblyContext.ProxyType, Is.SameAs(proxyType));
proxyTypeAssemblyContext.CreateAdditionalType(additionalTypeID, "AdditionalType", null, 0, typeof(int));
proxyTypeAssemblyContext.GenerationCompleted += ctx =>
{
Assert.That(ctx.GetGeneratedType(proxyType), Is.SameAs(fakeGeneratedType));
generationCompletedEventRaised = true;
};
});
var additionalType = MutableTypeObjectMother.Create();
mutableTypeFactoryMock.Expect(mock => mock.CreateType("AdditionalType", null, 0, typeof(int), null)).Return(additionalType);
assembledTypeIdentifierProviderMock
.Expect(mock => mock.GetPart(Arg <AssembledTypeID> .Matches(id => id.Equals(typeID)), Arg.Is(participantMock2)))
.Return(null);
participantMock2.Expect(mock => mock.Participate(Arg.Is <object> (null), Arg <IProxyTypeAssemblyContext> .Matches(ctx => ctx == proxyTypeAssemblyContext)));
typeModificationTrackerMock.Expect(mock => mock.IsModified()).Return(true);
assembledTypeIdentifierProviderMock.Expect(mock => mock.AddTypeID(Arg.Is(proxyType), Arg <AssembledTypeID> .Matches(id => id.Equals(typeID))));
complexSerializationEnablerMock
.Expect(
mock => mock.MakeSerializable(
Arg.Is(proxyType),
Arg.Is(participantConfigurationID),
Arg.Is(assembledTypeIdentifierProviderMock),
Arg <AssembledTypeID> .Matches(id => id.Equals(typeID))));
codeGeneratorMock
.Expect(mock => mock.GenerateTypes(Arg <IEnumerable <MutableType> > .List.Equal(new[] { additionalType, proxyType })))
.Return(
new[]
{
new KeyValuePair <MutableType, Type> (proxyType, fakeGeneratedType),
new KeyValuePair <MutableType, Type> (additionalType, fakeGeneratedAdditionalType)
})
.WhenCalled(
mi =>
{
Assert.That(generationCompletedEventRaised, Is.False);
var proxyAttribute = proxyType.AddedCustomAttributes.Single();
Assert.That(proxyAttribute.Type, Is.SameAs(typeof(AssembledTypeAttribute)));
Assert.That(proxyAttribute.ConstructorArguments, Is.Empty);
Assert.That(proxyAttribute.NamedArguments, Is.Empty);
});
}
mockRepository.ReplayAll();
var typeAssembler = CreateTypeAssembler(
mutableTypeFactoryMock,
assembledTypeIdentifierProviderMock,
complexSerializationEnablerMock,
participantConfigurationID,
new[] { participantMock1, participantMock2 });
var result = typeAssembler.AssembleType(typeID, _participantStateMock, codeGeneratorMock);
mockRepository.VerifyAll();
Assert.That(generationCompletedEventRaised, Is.True);
Assert.That(result, Is.Not.Null);
Assert.That(result.Type, Is.SameAs(fakeGeneratedType));
Assert.That(result.AdditionalTypes.Count, Is.EqualTo(1));
Assert.That(result.AdditionalTypes[additionalTypeID], Is.SameAs(fakeGeneratedAdditionalType));
}
public void Participate(object id, IProxyTypeAssemblyContext proxyTypeAssemblyContext)
{
_participateAction(id, proxyTypeAssemblyContext);
}
public abstract void Participate(object id, IProxyTypeAssemblyContext proxyTypeAssemblyContext);
