public void delegate_based_named_projector_alternate(SupportedProviderType supportedProviderType)
{
// arrange
var module = CommonModuleProvider.Create(supportedProviderType, item =>
{
item.RegisterProjector
<string, int, int>("foo")
.Bind(i => new[] { i * 2, i * 4 })
.Bind(i => new[] { i * 3, i * 5 });
item.RegisterProjector
<string, int, int>("bar")
.Bind(i => new[] { i * 20, i * 40 })
.Bind(i => new[] { i * 30, i * 50 });
});
var function = module.Resolve<Pipe<string, int, IEnumerable<int>>>();
// act
var resolvedItems = function("bar", 5);
// assert
Assert.NotNull(resolvedItems);
Assert.That(resolvedItems.Count(), Is.EqualTo(4));
Assert.That(resolvedItems.ToArray()[0], Is.EqualTo(100));
Assert.That(resolvedItems.ToArray()[1], Is.EqualTo(200));
Assert.That(resolvedItems.ToArray()[2], Is.EqualTo(150));
Assert.That(resolvedItems.ToArray()[3], Is.EqualTo(250));
}
public void verify_incomplete_registration_error(SupportedProviderType supportedProviderType)
{
var module = CommonModuleProvider.Create(supportedProviderType,
item => item.RegisterPipeline<IEnumerable<int>, IEnumerable<string>>()
.Bind(a => from p in a select p + 2)
.Bind(a => from p in a select p/2));
Assert.Throws<MismatchedClosingTypeDeclarationException>(module.Build);
}
/// <summary>
/// This retrieves the container associated with the provider type
/// </summary>
/// <param name="supportedProviderType">provider type</param>
/// <param name="pipeCreator">pipe configuration</param>
/// <returns>commond module</returns>
public static ICommonModule Create(SupportedProviderType supportedProviderType, Action<IPipeCreator> pipeCreator)
{
switch(supportedProviderType)
{
case SupportedProviderType.Autofac:
return new AutofacModule(pipeCreator);
case SupportedProviderType.Ninject:
return new NinjectModule(pipeCreator);
default:
throw new InvalidDataException("SupportedProviderType was not mapped to an actual module type");
}
}
public void verify_ordered_construction(SupportedProviderType supportedProviderType)
{
var module = CommonModuleProvider.Create(supportedProviderType, item => item.RegisterPipeline<IEnumerable<int>, IEnumerable<int>>()
.Bind(a => from p in a select p / 2)
.Bind(a => from p in a select p + 2));
var function = module.Resolve<Pipe<IEnumerable<int>, IEnumerable<int>>>();
var items = new[] { 10, 20, 30 };
var resolvedItems = function(items);
Assert.That(resolvedItems.Count(), Is.EqualTo(3));
Assert.That(resolvedItems.ToArray()[0], Is.EqualTo(7));
Assert.That(resolvedItems.ToArray()[1], Is.EqualTo(12));
Assert.That(resolvedItems.ToArray()[2], Is.EqualTo(17));
}
public void named_continuation_pipe_resolve(SupportedProviderType supportedProviderType, int pipeId)
{
var module = CommonModuleProvider.Create(SupportedProviderType.Autofac,
item =>
{
item.RegisterPipeline<string, IEnumerable<int>, IEnumerable<string>>("foo")
.Bind(a => from p in a select p.ToString());
item.RegisterPipeline<int, IEnumerable<int>, IEnumerable<string>>
(1)
.Bind(a => from p in a select p + 2)
.Bind(a => from p in a select p/2)
.ContinueWith("foo");
item.RegisterPipeline<int, IEnumerable<int>, IEnumerable<string>>(2)
.Bind(a => from p in a select p * 2)
.ContinueWith("foo");
});
var function = module.Resolve<Pipe<int, IEnumerable<int>, IEnumerable<string>>>();
var items = new[] { 10, 20, 30 };
var resolvedItems = function(pipeId, items);
if (pipeId == 1)
{
Assert.That(resolvedItems.Count(), Is.EqualTo(3));
Assert.That(resolvedItems.ToArray()[0], Is.EqualTo("6"));
Assert.That(resolvedItems.ToArray()[1], Is.EqualTo("11"));
Assert.That(resolvedItems.ToArray()[2], Is.EqualTo("16"));
}
else
{
Assert.That(resolvedItems.Count(), Is.EqualTo(3));
Assert.That(resolvedItems.ToArray()[0], Is.EqualTo("20"));
Assert.That(resolvedItems.ToArray()[1], Is.EqualTo("40"));
Assert.That(resolvedItems.ToArray()[2], Is.EqualTo("60"));
}
}
