public async Task GivenMappingFromObjectAToObjectB_WhenSolvingCollectionToCollection_ItShouldResolve()
{
// pre-arrangement
int counter = 0;
var expectedReturnObject = new TestObjectB();
// arrange
var semanticBuilder = new SemanticBuilder();
semanticBuilder.InstallPipe <TestObjectA, TestObjectB>((source, innerBroker) =>
{
counter++;
return(expectedReturnObject);
});
ISemanticBroker semanticBroker = semanticBuilder.CreateBroker();
// act
var enumerable = await semanticBroker.On(new[] { new TestObjectA() }.AsEnumerable())
.Output <IEnumerable <TestObjectB> >();
// assert
TestObjectB returnedType = enumerable.Single();
Assert.AreSame(expectedReturnObject, returnedType);
Assert.AreEqual(1, counter);
}
public void GivenRegistry_WhenResolvingToUnresolveableDestination_ItShouldThrowCannotResolveSemanticException()
{
var instanceClassA = new TestClassA();
var instanceClassC = new TestClassC();
// arrange
var semanaticBuilder = new SemanticBuilder();
semanaticBuilder.InstallPipe <TestClassA, TestClassB>((a, semanticBroker) => new TestClassB());
semanaticBuilder.InstallPipe <TestClassB, TestClassA>((b, semanticBroker) => new TestClassA());
ISemanticBroker broker = semanaticBuilder.CreateBroker();
// act
var exception1 =
Assert.Throws <CannotResolveSemanticException>(async() => await broker.On(instanceClassA).Output <TestClassC>());
var exception2 =
Assert.Throws <CannotResolveSemanticException>(async() => await broker.On(instanceClassC).Output <TestClassA>());
// assert
string expectedExceptionMessage1 =
string.Format("The input type '{0}' could not be resolved to output a type of {1}",
typeof(TestClassA), typeof(TestClassC));
string expectedExceptionMessage2 =
string.Format("The input type '{0}' could not be resolved to output a type of {1}",
typeof(TestClassC), typeof(TestClassA));
Assert.AreEqual(expectedExceptionMessage1, exception1.Message);
Assert.AreEqual(expectedExceptionMessage2, exception2.Message);
}
public async Task GivenAtoListB_WhenSolvingSingleAToListA_ItShouldResolve()
{
// pre-arrangement
var expectedReturnObject = new TestObjectA();
// arrange
var semanticBuilder = new SemanticBuilder();
semanticBuilder.InstallPipe <TestObjectA, List <TestObjectB> >(
(source, innerBroker) => new List <TestObjectB> {
new TestObjectB()
});
ISemanticBroker semanticBroker = semanticBuilder.CreateBroker();
// act
var enumerable = await semanticBroker.On(expectedReturnObject).Output <List <TestObjectA> >();
// assert
TestObjectA returnedType = enumerable.Single();
Assert.AreSame(expectedReturnObject, returnedType);
}
public void GivenEmptyBroker_WhenResolvingNullSource_ItShouldThrowArgumentNullException()
{
// arrange
var builder = new SemanticBuilder();
ISemanticBroker broker = builder.CreateBroker();
// act
var argumentNullException = Assert.Throws <ArgumentNullException>(() => broker.On <string>(null));
// assert
Assert.AreEqual("source", argumentNullException.ParamName);
}
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 Task <object> ProcessInput(object input, ISemanticBroker semanticBroker)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
GuardAgainstUnexpectedInputType(input);
var processingTask = _processCallbackFunc(input, semanticBroker);
GuardAgainstNullResultFromCallback(processingTask);
return(processingTask.ContinueWith(task =>
{
object output = task.Result;
GuardAgainstNullResultFromCallback(output);
GuardAgainstUnexpectedReturnTypeFromCallback(output);
return output;
}));
}
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);
}
public Task<object> ProcessInput(object input, ISemanticBroker semanticBroker)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
GuardAgainstUnexpectedInputType(input);
var processingTask = _processCallbackFunc(input, semanticBroker);
GuardAgainstNullResultFromCallback(processingTask);
return processingTask.ContinueWith(task =>
{
object output = task.Result;
GuardAgainstNullResultFromCallback(output);
GuardAgainstUnexpectedReturnTypeFromCallback(output);
return output;
});
}
