Ejemplo n.º 1
0
        public async void ReturnsSuccessfulOnStepCreationFailure()
        {
            Mock <IEntitiesRepository> entitiesRepository = new Mock <IEntitiesRepository>();

            entitiesRepository.Setup(sr => sr.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <WorkflowTemplate, bool> > >())).Returns(Task.FromResult(FibonacciSampleData.ConcurrentWorkflowTemplate));
            entitiesRepository.Setup(sr => sr.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <StepTemplate, bool> > >())).Returns(Task.FromResult(FibonacciSampleData.StepTemplate));
            entitiesRepository.Setup(sr => sr.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <Workflow, bool> > >())).Returns(Task.FromResult(
                                                                                                                                     new Workflow(Guid.NewGuid(),
                                                                                                                                                  FibonacciSampleData.ConcurrentWorkflowTemplate.ReferenceId,
                                                                                                                                                  new Dictionary <string, object>(),
                                                                                                                                                  "",
                                                                                                                                                  "admin",
                                                                                                                                                  DateTime.Now
                                                                                                                                                  )));

            _mediator.Setup(m => m.Send(It.IsAny <CreateStepCommand>(), It.IsAny <CancellationToken>())).ThrowsAsync(new Exception("FAILED WITH GENERIC ERROR"));

            var handler = new CreateWorkflowCommandHandler(entitiesRepository.Object, _mediator.Object, _node.Object, _mockStateLogger.Object);

            await handler.Handle(new CreateWorkflowCommand()
            {
                WorkflowTemplateId = FibonacciSampleData.ConcurrentWorkflowTemplate.ReferenceId,
                Inputs             = new Dictionary <string, object>()
                {
                }
            }, new System.Threading.CancellationToken());
        }
Ejemplo n.º 2
0
        public async void ConcurrentStartSteps()
        {
            Mock <IEntitiesRepository> entitiesRepository = new Mock <IEntitiesRepository>();

            entitiesRepository.Setup(sr => sr.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <WorkflowTemplate, bool> > >())).Returns(Task.FromResult(FibonacciSampleData.ConcurrentWorkflowTemplate));
            entitiesRepository.Setup(sr => sr.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <StepTemplate, bool> > >())).Returns(Task.FromResult(FibonacciSampleData.StepTemplate));
            entitiesRepository.Setup(sr => sr.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <Workflow, bool> > >())).Returns(Task.FromResult(
                                                                                                                                     new Workflow(Guid.NewGuid(),
                                                                                                                                                  FibonacciSampleData.ConcurrentWorkflowTemplate.ReferenceId,
                                                                                                                                                  new Dictionary <string, object>(),
                                                                                                                                                  "",
                                                                                                                                                  "admin",
                                                                                                                                                  DateTime.Now
                                                                                                                                                  )));
            var handler = new CreateWorkflowCommandHandler(entitiesRepository.Object, _mediator.Object, _node.Object, _mockStateLogger.Object);

            await handler.Handle(new CreateWorkflowCommand()
            {
                WorkflowTemplateId = FibonacciSampleData.ConcurrentWorkflowTemplate.ReferenceId,
                Inputs             = new Dictionary <string, object>()
                {
                }
            }, new System.Threading.CancellationToken());

            _mediator.Verify(e => e.Send(It.IsAny <CreateStepCommand>(), It.IsAny <CancellationToken>()), Times.Exactly(2), "Should call twice to create both starting steps.");
        }
Ejemplo n.º 3
0
        public async void DetectMissingInput()
        {
            FibonacciWorkflowData      data = new FibonacciWorkflowData(5);
            Mock <IEntitiesRepository> entitiesRepository = new Mock <IEntitiesRepository>();

            entitiesRepository.Setup(sr => sr.GetFirstOrDefaultAsync(It.IsAny <Expression <Func <WorkflowTemplate, bool> > >())).Returns(Task.FromResult(data.workflowTemplateWithInputs));
            var handler = new CreateWorkflowCommandHandler(entitiesRepository.Object, _mediator.Object, _node.Object, _mockStateLogger.Object);

            await Assert.ThrowsAsync <MissingInputException>(async() => await handler.Handle(new CreateWorkflowCommand()
            {
                WorkflowTemplateId = data.workflowTemplate.ReferenceId,
                Inputs             = new Dictionary <string, object>()
                {
                    { "n-1", 1 }
                }
            }, new System.Threading.CancellationToken()));
        }