public void SplitShouldWorksWell()
{
// GIVEN
mLogs.Logs.Clear();
var intSource = new List <int> {
2, 4, 6
};
var injectionProvider = new IoCContainer();
injectionProvider.RegisterSingle(intSource);
JustConveyor.Contracts.Dependencies.Injection.RegisterInjectionProvider(injectionProvider);
var blueprint = PipelineBlueprint.CreateBlueprint(typeof(int), "IntMultiplicatorBlueprint")
.Split <TestIntSource>()
.Apply <TestMultiplicatorStep>("multiplybyfactor")
.Collect()
.Apply((List <UnitContext> unit) => unit.Select(el => el.GetUnit <int>()).ToList());
// WHEN
Pipeline pipeline = new Pipeline(blueprint);
TransferingContext tctx = new TransferingContext(new Headers {
{ "factor", 10 }
}.Dict);
pipeline.Process(tctx, 1).Wait();
List <int> result = tctx.GetResult <List <int> >();
// THAN
result.ShouldBeEquivalentTo(new List <int> {
20, 40, 60
});
}
public void ExceptionShouldBeProcessedWithErrorProcessor()
{
// GIVEN
var injectionProvider = new IoCContainer();
var step = new TestIntSource(new List <int> {
101
});
injectionProvider.RegisterSingle(step);
JustConveyor.Contracts.Dependencies.Injection.RegisterInjectionProvider(injectionProvider, false);
// WHEN
TransferingContext tctx = new TransferingContext();
new Pipeline(PipelineBlueprint.CreateBlueprint <int>("WithExceptionBlueprint")
.Split <TestIntSource>()
.Collect())
.Process(tctx, 1).Wait();
//// THAN
tctx.Exception.Should().NotBeNull();
step.ExceptionMessage.Should().Be("More than 100.");
tctx.FinalUnitContext.Should().BeNull();
}
// Boostraping conveyor
private static Finalizer BootstrapContainer()
{
var logger = LogManager.GetCurrentClassLogger();
var container = new IoCContainer();
container.SetLogger(logger);
Injection.RegisterInjectionProvider(container);
// Preparing jobs and finalizer
// This will be our jobs
var processingInts = Enumerable.Range(0, 1000).ToList();
container.RegisterSingle <IEnumerable <int> >(processingInts);
// And in "collector" we will accumulate results.
container.RegisterSingle("collector", new ConcurrentBag <int>());
// To find out when we can close application we use CountFinalizer
Action inTheEnd =
() => logger.Info($"Result: {string.Join(",", container.Get<IEnumerable<int>>("collector"))}");
var finalizer = new CountFinalizer(processingInts.Count, inTheEnd);
// And boostrapping Conveyor itself
Conveyor.Init(logger)
.ScanForBlueprints()
.WithMetricsService(new MetricsServiceSettings
{
BaseAddress = "http://localhost:5001/",
CorsAddresses = new List <string> {
"http://localhost/*"
},
MetricsConfig = new MetricsConfig
{
IncludeLastLogsFrom = new List <string> {
"mainLogFile"
},
CountOfLogLines = 100
}
})
.WithSupplier("IntsSupplier", Injection.InjectionProvider.Get <IntegersSupplier>())
.WithFinalizer(finalizer)
.Start();
return(finalizer);
}
public void ConveyorWithPipelineCallShouldWorksWell()
{
Stopwatch timer = Stopwatch.StartNew();
// GIVEN
var injectionProvider = new IoCContainer();
var listCollector = new ListCollector();
injectionProvider.RegisterSingle(new List <int> {
1, 2, 3, 4, 5
});
injectionProvider.Register <TestIntSource>();
injectionProvider.Register <TestMultiplicatorStep>();
injectionProvider.Register <TestPipelinesBuilder>();
injectionProvider.RegisterSingle(listCollector);
Contracts.Dependencies.Injection.RegisterLogger(mLogger);
Contracts.Dependencies.Injection.RegisterInjectionProvider(injectionProvider, false);
var count = 10;
var range = Enumerable.Range(1, count).ToList();
var builder = new TestPipelinesBuilder();
// WHEN
var countFinalizer = new CountFinalizer(count);
Conveyor.Init(mLogger)
.WithBlueprint(builder.CreateIntMultPipeline())
.WithBlueprint(builder.CreatePipelineWithCallOfAnother())
.WithPipelineFinalizer("TestPipelineWithCallOfAnother", countFinalizer.Finalization)
.WithSupplier("IntsSupplier", new LabeledIntSupplier(range, "TestPipelineWithCallOfAnother"))
.Start();
countFinalizer.GetWaitTask().Wait();
// THEN
listCollector.Lists.Count.Should().Be(count, "All lists should be added to list collector");
listCollector.Lists.Values.ToList().ForEach(el => el.ShouldAllBeEquivalentTo(new List <int> {
2, 4, 6, 8, 10
}));
listCollector.Lists.Keys.ToList().ShouldBeEquivalentTo(range.Select(el => $"id:{el}").ToList());
timer.Stop();
}
public void ReassignShouldWorksWell()
{
// GIVEN
IoCContainer container = new IoCContainer();
// WHEN
TestContractFirst objFirst = new TestContractFirst();
TestContractSecond objSecond = new TestContractSecond();
container.RegisterSingle <TestContract>(objFirst);
Action reassign = () => container.RegisterSingle <TestContract>(objSecond, true);
TestContract result = null;
Action get = () => result = container.Get <TestContract>();
// THEN
reassign.ShouldNotThrow();
get.ShouldNotThrow();
result.Should().Be(objSecond);
}
private static void BootstrapIoCContainer()
{
var container = new IoCContainer();
container.SetLogger(mLogger);
Injection.RegisterInjectionProvider(container);
mFinalizer = new Finalizer((package, ctx) =>
{
mMaxValue = ctx.FinalUnitContext.GetUnit <double>();
return(true);
});
container.RegisterSingle(mFinalizer);
var servicesSettings = new ServicesSettingsManager(
JObject.Parse(File.ReadAllText("./settings.json"))["services"]
.ToObject <Dictionary <string, ServiceSettings> >());
container.RegisterSingle(servicesSettings);
}
public void SimpleConveyorShouldWorksWell()
{
// GIVEN
var injectionProvider = new IoCContainer();
var listCollector = new ListCollector();
injectionProvider.RegisterSingle(new List <int> {
1, 2, 3, 4, 5
});
injectionProvider.Register <TestIntSource>();
injectionProvider.Register <TestMultiplicatorStep>();
injectionProvider.Register <TestPipelinesBuilder>();
injectionProvider.RegisterSingle(listCollector);
Contracts.Dependencies.Injection.RegisterLogger(mLogger);
Contracts.Dependencies.Injection.RegisterInjectionProvider(injectionProvider, false);
var range = new List <int> {
1, 2, 3, 4, 5, 6, 7
};
// WHEN
var countFinalizer = new CountFinalizer(range.Count);
Conveyor.Init(mLogger)
.ScanForBlueprints()
.WithSupplier("IntsSupplier", new IntSupplier(range))
.WithFinalizer(countFinalizer)
.Start();
countFinalizer.GetWaitTask().Wait();
// THEN
listCollector.Lists.Count.Should().Be(7, "All lists should be added to list collector");
listCollector.Lists.Values.ToList().ForEach(el => el.ShouldAllBeEquivalentTo(new List <int> {
2, 4, 6, 8, 10
}));
listCollector.Lists.Keys.ShouldBeEquivalentTo(range.Select(el => $"id:{el}"));
}
public void RegisterByInterfaceShouldWorksWell()
{
// GIVEN
IoCContainer container = new IoCContainer();
// WHEN
TestContractFirst obj = new TestContractFirst();
container.RegisterSingle <TestContract>(obj);
Action create = () => container.Get <TestContract>();
// THEN
create.ShouldNotThrow();
}
public void IncorrectNumberOfSplitsAndCollectorsShouldThrowException()
{
// GIVEN
mLogs.Logs.Clear();
var injectionProvider = new IoCContainer();
injectionProvider.RegisterSingle(new List <int>());
injectionProvider.Register <TestIntSource>();
Contracts.Dependencies.Injection.RegisterInjectionProvider(injectionProvider, false);
PipelineBlueprint blueprintNormal = PipelineBlueprint.CreateBlueprint(typeof(int), "Normal");
PipelineBlueprint blueprintOnlyCollect = PipelineBlueprint.CreateBlueprint(typeof(int), "OnlyCollect");
PipelineBlueprint blueprintOnlySplit = PipelineBlueprint.CreateBlueprint(typeof(int), "OnlySplit");
PipelineBlueprint blueprintSplitsMoreThanCollects = PipelineBlueprint.CreateBlueprint(typeof(int),
"SplitsMoreThanCollects");
PipelineBlueprint blueprintCollectsMoreThanSplits = PipelineBlueprint.CreateBlueprint(typeof(int),
"CollectsMoreThanSplits");
// WHEN
Action createNormal = () => new Pipeline(blueprintNormal
.Split <TestIntSource>()
.Collect());
Action createOnlySplit = () => new Pipeline(blueprintOnlySplit
.Split <TestIntSource>());
Action createOnlyCollect = () => new Pipeline(blueprintOnlyCollect
.Collect());
Action createSplitsMoreThanCollects = () => new Pipeline(blueprintSplitsMoreThanCollects
.Split <TestIntSource>()
.Split <TestIntSource>()
.Collect());
Action createCollectsMoreThanSplits = () => new Pipeline(blueprintCollectsMoreThanSplits
.Split <TestIntSource>()
.Collect()
.Collect());
// THAN
createNormal.ShouldNotThrow();
createOnlySplit.ShouldThrow <InvalidSplitCollectException>();
createOnlyCollect.ShouldThrow <InvalidSplitCollectException>();
createSplitsMoreThanCollects.ShouldThrow <InvalidSplitCollectException>();
createCollectsMoreThanSplits.ShouldThrow <InvalidSplitCollectException>();
}
public void SyncSpitCollectShouldWorksWell()
{
// GIVEN
mLogs.Logs.Clear();
var ints = new List <int> {
1, 2, 3
};
var injectionProvider = new IoCContainer();
injectionProvider.RegisterSingle(ints);
injectionProvider.Register <TestIntSource>();
injectionProvider.Register <TestMultiplicatorStep>();
Contracts.Dependencies.Injection.RegisterInjectionProvider(injectionProvider, false);
PipelineBlueprint blueprint = PipelineBlueprint.CreateBlueprint(typeof(int), "SyncSplitCollect");
// WHEN
var result = blueprint
.Split <TestIntSource>()
.Apply((int el) => el * 10)
.Collect()
.Apply((IList <UnitContext> octx) => octx.Select(el => el.GetUnit <int>()));
TransferingContext tctx = new TransferingContext();
new Pipeline(result)
.Process(tctx, 1)
.Wait();
// THAN
tctx.Exception.Should().BeNull();
tctx.GetResult <IEnumerable <int> >().ShouldBeEquivalentTo(new List <int> {
10, 20, 30
});
}
public void AsyncSpitCollectShouldWorksWell()
{
// GIVEN
mLogs.Logs.Clear();
var ints = new List <int> {
1, 2, 3
};
var injectionProvider = new IoCContainer();
injectionProvider.RegisterSingle(ints);
injectionProvider.Register <TestIntSource>();
injectionProvider.Register <TestMultiplicatorStep>();
Contracts.Dependencies.Injection.RegisterInjectionProvider(injectionProvider, false);
PipelineBlueprint blueprint = PipelineBlueprint.CreateBlueprint(typeof(int), "AsyncSplitCollect");
PipelineBlueprint blueprintOther = PipelineBlueprint.CreateBlueprint(typeof(int), "OtherAsyncSplitCollect");
PipelineBlueprint blueprintOneOther = PipelineBlueprint.CreateBlueprint(typeof(int),
"OneOtherAsyncSplitCollect");
// WHEN
TransferingContext tctx = new TransferingContext(new Headers {
{ "factor", 10 }
}.Dict);
new Pipeline(blueprint
.Split <TestIntSource>()
.Apply <TestMultiplicatorStep>("multiplybyfactor")
.Collect()
.Apply((IList <UnitContext> octx) => octx.Select(el => el.GetUnit <int>()).ToList()))
.Process(tctx, 1)
.Wait();
TransferingContext otherTctx = new TransferingContext(new Headers {
{ "factor", 10 }
}.Dict);
new Pipeline(blueprintOther
.Split <TestIntSource>()
.Apply <TestMultiplicatorStep>("multiplybyfactor")
.Collect()
.Apply <TestMultiplicatorStep>("strip"))
.Process(otherTctx, 1)
.Wait();
TransferingContext oneAnotherTctx = new TransferingContext(new Headers {
{ "factor", 10 }
}.Dict);
new Pipeline(blueprintOneOther
.Apply <TestMultiplicatorStep>("multiplybyfactor")
.Split <TestIntSource>()
.Apply <TestMultiplicatorStep>("multiplybyfactor")
.Collect()
.Apply <TestMultiplicatorStep>("strip"))
.Process(oneAnotherTctx, 1)
.Wait();
// THAN
tctx.Exception?.InnerException.Should().BeNull();
tctx.GetResult <List <int> >().ShouldBeEquivalentTo(new List <int> {
10, 20, 30
});
otherTctx.Exception?.InnerException.Should().BeNull();
otherTctx.GetResult <List <int> >().ShouldBeEquivalentTo(new List <int> {
10, 20, 30
});
oneAnotherTctx.Exception?.InnerException.Should().BeNull();
oneAnotherTctx.GetResult <List <int> >().ShouldBeEquivalentTo(new List <int> {
10, 20, 30
});
}
