public void GenerateTypes()
{
var mutableType1 = MutableTypeObjectMother.Create();
var mutableType2 = MutableTypeObjectMother.Create();
var nestedMutableType = MutableTypeObjectMother.Create();
var fakeType1 = ReflectionObjectMother.GetSomeType();
var fakeType2 = ReflectionObjectMother.GetSomeOtherType();
var fakeNestedType = ReflectionObjectMother.GetSomeNestedType();
var generatorMock1 = new Mock <IMutableTypeCodeGenerator> (MockBehavior.Strict);
var generatorMock2 = new Mock <IMutableTypeCodeGenerator> (MockBehavior.Strict);
var nestedGeneratorMock = new Mock <IMutableTypeCodeGenerator> (MockBehavior.Strict);
_mutableTypeCodeGeneratorFactoryMock
.Setup(_ => _.CreateGenerators(new[] { mutableType1, mutableType2 }))
.Returns(new[] { generatorMock1.Object, generatorMock2.Object })
.Verifiable();
var sequence = new MockSequence();
generatorMock1
.InSequence(sequence)
.Setup(_ => _.DeclareType());
generatorMock1
.InSequence(sequence)
.Setup(_ => _.CreateNestedTypeGenerators()).Returns(new[] { nestedGeneratorMock.Object });
nestedGeneratorMock
.InSequence(sequence)
.Setup(_ => _.DeclareType());
nestedGeneratorMock
.InSequence(sequence)
.Setup(_ => _.CreateNestedTypeGenerators()).Returns(new IMutableTypeCodeGenerator[0]);
generatorMock2
.InSequence(sequence)
.Setup(_ => _.DeclareType());
generatorMock2
.InSequence(sequence)
.Setup(_ => _.CreateNestedTypeGenerators()).Returns(new IMutableTypeCodeGenerator[0]);
generatorMock1
.InSequence(sequence)
.SetupGet(_ => _.MutableType).Returns(mutableType1);
nestedGeneratorMock
.InSequence(sequence)
.SetupGet(_ => _.MutableType).Returns(nestedMutableType);
generatorMock2
.InSequence(sequence)
.SetupGet(_ => _.MutableType).Returns(mutableType2);
generatorMock1
.InSequence(sequence)
.SetupGet(_ => _.MutableType).Returns(mutableType1);
nestedGeneratorMock
.InSequence(sequence)
.SetupGet(_ => _.MutableType).Returns(nestedMutableType);
generatorMock2
.InSequence(sequence)
.SetupGet(_ => _.MutableType).Returns(mutableType2);
_dependentTypeSorterMock
.Setup(
_ => _.Sort(It.Is <IEnumerable <MutableType> > (types => types.SequenceEqual(new[] { mutableType1, nestedMutableType, mutableType2 }))))
.Returns(new[] { mutableType2, mutableType1, nestedMutableType })
.Verifiable();
generatorMock2.Setup(_ => _.DefineTypeFacets()).Verifiable();
generatorMock1.Setup(_ => _.DefineTypeFacets()).Verifiable();
nestedGeneratorMock.Setup(_ => _.DefineTypeFacets()).Verifiable();
generatorMock2.SetupGet(_ => _.MutableType).Returns(mutableType2).Verifiable();
generatorMock2.Setup(_ => _.CreateType()).Returns(fakeType2).Verifiable();
generatorMock1.SetupGet(_ => _.MutableType).Returns(mutableType1).Verifiable();
generatorMock1.Setup(_ => _.CreateType()).Returns(fakeType1).Verifiable();
nestedGeneratorMock.SetupGet(_ => _.MutableType).Returns(nestedMutableType).Verifiable();
nestedGeneratorMock.Setup(_ => _.CreateType()).Returns(fakeNestedType).Verifiable();
var result = _generator.GenerateTypes(new[] { mutableType1, mutableType2 }).ForceEnumeration();
generatorMock1.Verify();
generatorMock2.Verify();
nestedGeneratorMock.Verify();
var expectedMapping =
new[]
{
new KeyValuePair <MutableType, Type> (mutableType2, fakeType2),
new KeyValuePair <MutableType, Type> (mutableType1, fakeType1)
// Nested types are not included in the result mapping.
};
Assert.That(result, Is.EqualTo(expectedMapping));
}
public void GenerateTypes()
{
var mutableType1 = MutableTypeObjectMother.Create();
var mutableType2 = MutableTypeObjectMother.Create();
var nestedMutableType = MutableTypeObjectMother.Create();
var fakeType1 = ReflectionObjectMother.GetSomeType();
var fakeType2 = ReflectionObjectMother.GetSomeOtherType();
var fakeNestedType = ReflectionObjectMother.GetSomeNestedType();
using (_mockRepository.Ordered())
{
var generatorMock1 = _mockRepository.StrictMock <IMutableTypeCodeGenerator>();
var generatorMock2 = _mockRepository.StrictMock <IMutableTypeCodeGenerator>();
var nestedGeneratorMock = _mockRepository.StrictMock <IMutableTypeCodeGenerator>();
_mutableTypeCodeGeneratorFactoryMock
.Expect(_ => _.CreateGenerators(new[] { mutableType1, mutableType2 }))
.Return(new[] { generatorMock1, generatorMock2 });
generatorMock1.Expect(_ => _.DeclareType());
generatorMock1.Expect(_ => _.CreateNestedTypeGenerators()).Return(new[] { nestedGeneratorMock });
nestedGeneratorMock.Expect(_ => _.DeclareType());
nestedGeneratorMock.Expect(_ => _.CreateNestedTypeGenerators()).Return(new IMutableTypeCodeGenerator[0]);
generatorMock2.Expect(_ => _.DeclareType());
generatorMock2.Expect(_ => _.CreateNestedTypeGenerators()).Return(new IMutableTypeCodeGenerator[0]);
generatorMock1.Expect(_ => _.MutableType).Return(mutableType1);
nestedGeneratorMock.Expect(_ => _.MutableType).Return(nestedMutableType);
generatorMock2.Expect(_ => _.MutableType).Return(mutableType2);
generatorMock1.Expect(_ => _.MutableType).Return(mutableType1);
nestedGeneratorMock.Expect(_ => _.MutableType).Return(nestedMutableType);
generatorMock2.Expect(_ => _.MutableType).Return(mutableType2);
_dependentTypeSorterMock
.Expect(_ => _.Sort(Arg <IEnumerable <MutableType> > .List.Equal(new[] { mutableType1, nestedMutableType, mutableType2 })))
.Return(new[] { mutableType2, mutableType1, nestedMutableType });
generatorMock2.Expect(_ => _.DefineTypeFacets());
generatorMock1.Expect(_ => _.DefineTypeFacets());
nestedGeneratorMock.Expect(_ => _.DefineTypeFacets());
generatorMock2.Expect(_ => _.MutableType).Return(mutableType2);
generatorMock2.Expect(_ => _.CreateType()).Return(fakeType2);
generatorMock1.Expect(_ => _.MutableType).Return(mutableType1);
generatorMock1.Expect(_ => _.CreateType()).Return(fakeType1);
nestedGeneratorMock.Expect(_ => _.MutableType).Return(nestedMutableType);
nestedGeneratorMock.Expect(_ => _.CreateType()).Return(fakeNestedType);
}
_mockRepository.ReplayAll();
var result = _generator.GenerateTypes(new[] { mutableType1, mutableType2 }).ForceEnumeration();
_mockRepository.VerifyAll();
var expectedMapping =
new[]
{
new KeyValuePair <MutableType, Type> (mutableType2, fakeType2),
new KeyValuePair <MutableType, Type> (mutableType1, fakeType1)
// Nested types are not included in the result mapping.
};
Assert.That(result, Is.EqualTo(expectedMapping));
}
