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 GivenBrokerWithPipeFromObjectAToObjectB_WhenResolving_ItShouldInstantiateThePipe()
{
// pre-arrangement
var expectedOutputObject = new TestClassB();
// arrangement
var builder = new SemanticBuilder();
builder.InstallPipe <TestClassA, TestClassB>((a, innerBroker) => expectedOutputObject);
ISemanticBroker broker = builder.CreateBroker();
// act
var actualOutputObject = await broker.On(new TestClassA()).Output <TestClassB>();
// assert
Assert.AreSame(expectedOutputObject, actualOutputObject);
}
public async Task GivenRegistryWithPipe_WhenResolvingFromListToArray_ItShouldUseTheShortCircuit()
{
for (int counter = 0; counter < 15; counter++)
{
// arrange
var semanticBuilder = new SemanticBuilder();
var enrollmentList = new List <Action>
{
() => semanticBuilder.InstallPipe <TestClassA, TestClassB>((a, innerBroker) =>
{
Assert.Fail();
return(new TestClassB());
}),
() => semanticBuilder.InstallPipe <List <TestClassA>, TestClassB[]>(
(a, innerBroker) => (from b in a select new TestClassB()).ToArray())
};
var enrollmentActions = enrollmentList.OrderBy(x => Guid.NewGuid());
foreach (var enrollmentAction in enrollmentActions)
{
enrollmentAction();
}
ISemanticBroker broker = semanticBuilder.CreateBroker();
// act
await broker.On(new[] { new TestClassA() }).Output <TestClassB[]>();
await broker.On(new List <TestClassA> {
new TestClassA()
}).Output <TestClassB[]>();
await broker.On(new List <TestClassA> {
new TestClassA()
}).Output <List <TestClassB> >();
await broker.On(new List <TestClassA> {
new TestClassA()
}).Output <IEnumerable <TestClassB> >();
await broker.On(new[] { new TestClassA() }).Output <List <TestClassB> >();
}
}
public async Task GivenTwoClasses_WhenSolvingSingleClassToArray_ItShouldResolve()
{
// pre-arrangement
var expectedReturnObject = new TestObjectB();
// arrange
var semanticBuilder = new SemanticBuilder();
semanticBuilder.InstallPipe <TestObjectA, TestObjectB>((source, innerBroker) => expectedReturnObject);
ISemanticBroker semanticBroker = semanticBuilder.CreateBroker();
// act
var enumerable = await semanticBroker.On(new TestObjectA()).Output <TestObjectB[]>();
// assert
TestObjectB returnedType = enumerable.Single();
Assert.AreSame(expectedReturnObject, returnedType);
}
public async Task GivenRegistration_WhenTheProcessDelegateIsCalled_ItShouldExecuteTheSpecifiedGenericCallback()
{
// pre-arrangement
var expectedTestClassA = new TestClassA();
var expectedTestClassB = new TestClassB();
// arrange
var semanticBuilder = new SemanticBuilder();
semanticBuilder.InstallPipe <TestClassA, TestClassB>((a, innerBroker) =>
{
Assert.AreSame(expectedTestClassA, a);
return(expectedTestClassB);
});
ISemanticBroker semanticBroker = semanticBuilder.CreateBroker();
// act
var processedOuput = await semanticBroker.On(expectedTestClassA).Output <TestClassB>();
// assert
Assert.AreSame(expectedTestClassB, processedOuput);
}
public async Task GivenRegistryWithOnePipes_WhenResolvingFromAToB_ItShouldCallIt()
{
// pre-arrange
var instanceClassA = new TestClassA();
var instanceClassB = new TestClassB();
// arrange
var semanaticBuilder = new SemanticBuilder();
semanaticBuilder.InstallPipe <TestClassA, TestClassB>((a, semanticBroker) =>
{
Assert.AreSame(instanceClassA, a);
return(instanceClassB);
});
ISemanticBroker broker = semanaticBuilder.CreateBroker();
// act
var solvedExecution = await broker.On(instanceClassA).Output <TestClassB>();
// assert
Assert.AreEqual(instanceClassB, solvedExecution);
}
public async Task GivenRegistryWithMultipleSources_WhenResolvingToSpecificType_ItShouldResolve()
{
// pre-arrange
var instanceClassA = new TestClassA();
var instanceClassB = new TestClassB();
var instanceClassC = new TestClassC();
// arrange
var semanaticBuilder = new SemanticBuilder();
semanaticBuilder.InstallPipe <TestClassA, TestClassB>((a, semanticBroker) => instanceClassB);
semanaticBuilder.InstallPipe <TestClassA, TestClassC>((a, semanticBroker) => instanceClassC);
ISemanticBroker broker = semanaticBuilder.CreateBroker();
// act
var solveToB = await broker.On(instanceClassA).Output <TestClassB>();
var solveToC = await broker.On(instanceClassA).Output <TestClassC>();
// assert
Assert.AreEqual(instanceClassB, solveToB);
Assert.AreEqual(instanceClassC, solveToC);
}
