public void Map_MockedInternalMappers_Redirects()
{
BaseMapper <TestClassB, TestClassD>[] mapperMocks =
A.CollectionOfFake <BaseMapper <TestClassB, TestClassD> >(5).ToArray();
var results = new List <IEnumerable <MemberMappingInfo <TestClassB, TestClassD> > >();
for (int i = 0; i < mapperMocks.Length; ++i)
{
var res = new[]
{
A.Fake <MemberMappingInfo <TestClassB, TestClassD> >(
o => o.WithArgumentsForConstructor(
new object[]
{
Guid.NewGuid().ToString(),
Guid.NewGuid().ToString()
}))
};
results.Add(res);
A.CallTo(() => mapperMocks[i].GetMappings())
.Returns(res);
}
var target = new CompositeMapper <TestClassB, TestClassD>(mapperMocks);
var source = new TestClassB();
var result = new TestClassD();
target.Map(source, result);
foreach (var m in results.SelectMany(e => e))
{
A.CallTo(() => m.Map(source, result)).MustHaveHappened();
}
}
public void Given_PropertiesDateTimeAndIntRelatedBothNullableBothNull_When_TryValidateObject_Then_FalseRetrieved()
{
var classObj = new TestClassD {
};
var validationContext = new ValidationContext(classObj)
{
MemberName = nameof(TestClassA.TestString)
};
var validationResults = new List <ValidationResult>();
var result = Validator.TryValidateObject(classObj, validationContext, validationResults, true);
Assert.False(result);
}
public async Task GivenRegistryWithMultiplePipes_WhenResolvingFromAToD_ItShouldChainAllThePipes()
{
for (int counter = 0; counter < 15; counter++)
{
// pre-arrange
var instanceClassA = new TestClassA();
var instanceClassB = new TestClassB();
var instanceClassC = new TestClassC();
var instanceClassD = new TestClassD();
// arrange
var semanticBuilder = new SemanticBuilder();
var enrollmentList = new List<Action>
{
() => semanticBuilder.InstallPipe<TestClassA, TestClassB>((a, innerBroker) =>
{
Assert.AreSame(instanceClassA, a);
return instanceClassB;
}),
() => semanticBuilder.InstallPipe<TestClassB, TestClassC>((b, innerBroker) =>
{
Assert.AreSame(instanceClassB, b);
return instanceClassC;
}),
() => semanticBuilder.InstallPipe<TestClassC, TestClassD>((c, innerBroker) =>
{
Assert.AreSame(instanceClassC, c);
return instanceClassD;
}),
};
var enrollmentActions = enrollmentList.OrderBy(x=>Guid.NewGuid());
foreach (var enrollmentAction in enrollmentActions)
{
enrollmentAction();
}
ISemanticBroker broker = semanticBuilder.CreateBroker();
// act
var solvedExecution = await broker.On(instanceClassA).Output<TestClassD>();
// assert
Assert.AreEqual(instanceClassD, solvedExecution);
}
}
public async Task GivenRegistryWithMultiplePipes_WhenResolvingFromAToD_ItShouldChainAllThePipes()
{
for (int counter = 0; counter < 15; counter++)
{
// pre-arrange
var instanceClassA = new TestClassA();
var instanceClassB = new TestClassB();
var instanceClassC = new TestClassC();
var instanceClassD = new TestClassD();
// arrange
var semanticBuilder = new SemanticBuilder();
var enrollmentList = new List <Action>
{
() => semanticBuilder.InstallPipe <TestClassA, TestClassB>((a, innerBroker) =>
{
Assert.AreSame(instanceClassA, a);
return(instanceClassB);
}),
() => semanticBuilder.InstallPipe <TestClassB, TestClassC>((b, innerBroker) =>
{
Assert.AreSame(instanceClassB, b);
return(instanceClassC);
}),
() => semanticBuilder.InstallPipe <TestClassC, TestClassD>((c, innerBroker) =>
{
Assert.AreSame(instanceClassC, c);
return(instanceClassD);
}),
};
var enrollmentActions = enrollmentList.OrderBy(x => Guid.NewGuid());
foreach (var enrollmentAction in enrollmentActions)
{
enrollmentAction();
}
ISemanticBroker broker = semanticBuilder.CreateBroker();
// act
var solvedExecution = await broker.On(instanceClassA).Output <TestClassD>();
// assert
Assert.AreEqual(instanceClassD, solvedExecution);
}
}
public void Map_MapperTarget_MapsCorrectly()
{
string expectedName = "Test Name";
int expectedCode = 412;
var a = new TestClassA {Code = expectedCode, Name = expectedName};
var d = new TestClassD();
var target = new AttributeMapper<TestClassA, TestClassD>();
target.Map(a, d);
Assert.AreEqual(expectedName, d.SomeOtherName);
Assert.AreEqual(expectedCode, d.AnotherCode);
Assert.AreEqual(expectedName, a.Name);
Assert.AreEqual(expectedCode, a.Code);
}
public void AddMapping_MockedInternalMappers_Redirects()
{
BaseMapper <TestClassB, TestClassD>[] mapperMocks =
A.CollectionOfFake <BaseMapper <TestClassB, TestClassD> >(5).ToArray();
var extMock = A.Fake <BaseMapper <TestClassB, TestClassD> >(
o => o.Implements(typeof(IExtensibleMapper <TestClassB, TestClassD>)));
var results = new List <IEnumerable <MemberMappingInfo <TestClassB, TestClassD> > >();
Randomizer rnd = Randomizer.GetRandomizer(typeof(CompositeMapper <,>).GetMethod("AddMapping"));
int extPos = rnd.Next(mapperMocks.Length);
for (int i = 0; i < mapperMocks.Length; ++i)
{
var res = new[]
{
A.Fake <MemberMappingInfo <TestClassB, TestClassD> >(
o => o.WithArgumentsForConstructor(
new object[]
{
Guid.NewGuid().ToString(),
Guid.NewGuid().ToString()
}))
};
if (i == extPos)
{
mapperMocks[i] = extMock;
}
results.Add(res);
A.CallTo(() => mapperMocks[i].GetMappings())
.Returns(res);
}
var target = new CompositeMapper <TestClassB, TestClassD>(mapperMocks);
var source = new TestClassB();
var result = new TestClassD();
MappingAction <TestClassB, TestClassD> action = (s, t) => t.SomeOtherName = s.Name;
target.AddMappingAction("foo", "bar", action);
target.ExtensibleMapper.ShouldBeSameAs(extMock);
A.CallTo(() =>
((IExtensibleMapper <TestClassB, TestClassD>)extMock).AddMappingAction("foo", "bar", action))
.MustHaveHappened();
}
public void AddMapping_MockedInternalMappers_Redirects()
{
var mapperMocks = A.CollectionOfFake<BaseMapper<TestClassB, TestClassD>>(5).ToArray();
var extMock = A.Fake<BaseMapper<TestClassB, TestClassD>>(
o => o.Implements(typeof(IExtensibleMapper<TestClassB, TestClassD>)));
var results = new List<IEnumerable<MemberMappingInfo<TestClassB, TestClassD>>>();
var rnd = NUnit.Framework.Randomizer.GetRandomizer(typeof(CompositeMapper<,>).GetMethod("AddMapping"));
var extPos = rnd.Next(mapperMocks.Length);
for (int i = 0; i < mapperMocks.Length; ++i)
{
var res = new MemberMappingInfo<TestClassB, TestClassD>[]
{
A.Fake<MemberMappingInfo<TestClassB, TestClassD>>(
o => o.WithArgumentsForConstructor(
new object[]
{
Guid.NewGuid().ToString(),
Guid.NewGuid().ToString()
}))
};
if (i == extPos)
{
mapperMocks[i] = extMock;
}
results.Add(res);
A.CallTo(() => mapperMocks[i].GetMappings())
.Returns(res);
}
var target = new CompositeMapper<TestClassB, TestClassD>(mapperMocks);
var source = new TestClassB();
var result = new TestClassD();
MappingAction<TestClassB, TestClassD> action = (s, t) => t.SomeOtherName = s.Name;
target.AddMappingAction("foo", "bar", action);
target.ExtensibleMapper.ShouldBeSameAs(extMock);
A.CallTo(() =>
((IExtensibleMapper<TestClassB, TestClassD>)extMock).AddMappingAction("foo", "bar", action))
.MustHaveHappened();
}
public void Map_MapperTarget_MapsCorrectly()
{
string expectedName = "Test Name";
int expectedCode = 412;
var a = new TestClassA {
Code = expectedCode, Name = expectedName
};
var d = new TestClassD();
var target = new AttributeMapper <TestClassA, TestClassD>();
target.Map(a, d);
Assert.AreEqual(expectedName, d.SomeOtherName);
Assert.AreEqual(expectedCode, d.AnotherCode);
Assert.AreEqual(expectedName, a.Name);
Assert.AreEqual(expectedCode, a.Code);
}
public void Map_MappedSource_SkipsMapping()
{
string expectedName = "Test Name";
int expectedCode = 412;
var a = new TestClassA();
var d = new TestClassD {AnotherCode = expectedCode, SomeOtherName = expectedName};
var target = new AttributeMapper<TestClassD, TestClassA>();
target.Map(d, a);
Assert.AreEqual(expectedName, d.SomeOtherName);
Assert.AreEqual(expectedCode, d.AnotherCode);
Assert.AreEqual(expectedName, a.Name);
// since the mapping direction for AnotherCode is "TargetMemberName" only,
// a.Code should be left with its default sourceValue.
Assert.AreEqual(0, a.Code);
}
public void Map_MappedSource_SkipsMapping()
{
string expectedName = "Test Name";
int expectedCode = 412;
var a = new TestClassA();
var d = new TestClassD {
AnotherCode = expectedCode, SomeOtherName = expectedName
};
var target = new AttributeMapper <TestClassD, TestClassA>();
target.Map(d, a);
Assert.AreEqual(expectedName, d.SomeOtherName);
Assert.AreEqual(expectedCode, d.AnotherCode);
Assert.AreEqual(expectedName, a.Name);
// since the mapping direction for AnotherCode is "TargetMemberName" only,
// a.Code should be left with its default sourceValue.
Assert.AreEqual(0, a.Code);
}
public TestClassC(TestClassA testClassA, TestClassB testClassB, TestClassD testClassD)
{
this.TestClassA = testClassA;
this.TestClassB = testClassB;
this.TestClassD = testClassD;
}
public TestClassB(TestClassA testClassA, TestClassD testClassD)
{
this.TestClassA = testClassA;
this.TestClassD = testClassD;
}
public void MapTo_NullRepo_Throws_2()
{
var source = new TestClassD();
source.MapTo <TestClassA>((IMappingRepository)null);
}
public TestClassC(TestClassD d)
{
}
public async Task MapTo_NullRepo_Throws_2()
{
var source = new TestClassD();
await source.MapToAsync<TestClassA>((IMappingRepository) null);
}
public void MapTo_NullRepo_Throws_2()
{
var source = new TestClassD();
source.MapTo<TestClassA>((IMappingRepository) null);
}
public async Task MapTo_NullRepo_Throws_2()
{
var source = new TestClassD();
await source.MapToAsync <TestClassA>((IMappingRepository)null);
}
public void Map_MockedInternalMappers_Redirects()
{
BaseMapper<TestClassB, TestClassD>[] mapperMocks =
A.CollectionOfFake<BaseMapper<TestClassB, TestClassD>>(5).ToArray();
var results = new List<IEnumerable<MemberMappingInfo<TestClassB, TestClassD>>>();
for (int i = 0; i < mapperMocks.Length; ++i)
{
var res = new[]
{
A.Fake<MemberMappingInfo<TestClassB, TestClassD>>(
o => o.WithArgumentsForConstructor(
new object[]
{
Guid.NewGuid().ToString(),
Guid.NewGuid().ToString()
}))
};
results.Add(res);
A.CallTo(() => mapperMocks[i].GetMappings())
.Returns(res);
}
var target = new CompositeMapper<TestClassB, TestClassD>(mapperMocks);
var source = new TestClassB();
var result = new TestClassD();
target.Map(source, result);
foreach (var m in results.SelectMany(e => e))
{
A.CallTo(() => m.Map(source, result)).MustHaveHappened();
}
}
