public void AssembleAdditionalType_ParticipantReturnsMutableType()
{
var mockRepository = new MockRepository();
var participantMock1 = mockRepository.StrictMock <IParticipant>();
var participantMock2 = mockRepository.StrictMock <IParticipant>();
var participantMock3 = mockRepository.StrictMock <IParticipant>();
var mutableTypeFactoryMock = mockRepository.StrictMock <IMutableTypeFactory>();
var codeGeneratorMock = mockRepository.StrictMock <IMutableTypeBatchCodeGenerator>();
participantMock1.Stub(_ => _.PartialTypeIdentifierProvider);
participantMock2.Stub(_ => _.PartialTypeIdentifierProvider);
participantMock3.Stub(_ => _.PartialTypeIdentifierProvider);
var participantConfigurationID = "participant configuration ID";
var additionalTypeID = new object();
bool generationCompletedEventRaised = false;
var fakeAdditionalType = ReflectionObjectMother.GetSomeType();
var otherAdditionalTypeID = new object();
var otherFakeAdditionalType = ReflectionObjectMother.GetSomeType();
using (mockRepository.Ordered())
{
IAdditionalTypeAssemblyContext additionalTypeAssemblyContext = null;
var additionalMutableType = MutableTypeObjectMother.Create();
var otherAdditionalType = MutableTypeObjectMother.Create();
participantMock1
.Expect(mock => mock.GetOrCreateAdditionalType(Arg.Is(additionalTypeID), Arg <IAdditionalTypeAssemblyContext> .Is.Anything))
.Return(null)
.WhenCalled(
mi =>
{
additionalTypeAssemblyContext = (IAdditionalTypeAssemblyContext)mi.Arguments[1];
Assert.That(additionalTypeAssemblyContext.ParticipantConfigurationID, Is.EqualTo(participantConfigurationID));
Assert.That(additionalTypeAssemblyContext.ParticipantState, Is.SameAs(_participantStateMock));
additionalTypeAssemblyContext.CreateAdditionalType(additionalTypeID, "AdditionalType", null, 0, typeof(int));
additionalTypeAssemblyContext.CreateAdditionalType(otherAdditionalTypeID, "OtherAdditionalType", null, 0, typeof(int));
additionalTypeAssemblyContext.GenerationCompleted += ctx =>
{
Assert.That(ctx.GetGeneratedType(additionalMutableType), Is.SameAs(fakeAdditionalType));
Assert.That(ctx.GetGeneratedType(otherAdditionalType), Is.SameAs(otherFakeAdditionalType));
generationCompletedEventRaised = true;
};
});
mutableTypeFactoryMock.Expect(mock => mock.CreateType("AdditionalType", null, 0, typeof(int), null)).Return(additionalMutableType);
mutableTypeFactoryMock.Expect(mock => mock.CreateType("OtherAdditionalType", null, 0, typeof(int), null)).Return(otherAdditionalType);
participantMock2
.Expect(
mock => mock.GetOrCreateAdditionalType(
Arg.Is(additionalTypeID), Arg <IAdditionalTypeAssemblyContext> .Matches(ctx => ctx == additionalTypeAssemblyContext)))
.Return(additionalMutableType);
// Participant 3 is not invoked.
codeGeneratorMock
.Expect(mock => mock.GenerateTypes(new[] { additionalMutableType, otherAdditionalType }))
.Return(
new[]
{
new KeyValuePair <MutableType, Type> (additionalMutableType, fakeAdditionalType),
new KeyValuePair <MutableType, Type> (otherAdditionalType, otherFakeAdditionalType)
})
.WhenCalled(mi => Assert.That(generationCompletedEventRaised, Is.False));
}
mockRepository.ReplayAll();
var typeAssembler = CreateTypeAssembler(
mutableTypeFactoryMock,
configurationId: participantConfigurationID,
participants: new[] { participantMock1, participantMock2, participantMock3 });
var result = typeAssembler.AssembleAdditionalType(additionalTypeID, _participantStateMock, codeGeneratorMock);
mockRepository.VerifyAll();
Assert.That(generationCompletedEventRaised, Is.True);
Assert.That(result, Is.Not.Null);
Assert.That(result.Type, Is.SameAs(fakeAdditionalType));
Assert.That(result.AdditionalTypes.Count, Is.EqualTo(2));
Assert.That(result.AdditionalTypes[additionalTypeID], Is.SameAs(fakeAdditionalType));
Assert.That(result.AdditionalTypes[otherAdditionalTypeID], Is.SameAs(otherFakeAdditionalType));
}
