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 }); }