public void FlowTemplateStep_Post_should_return_bad_request_if_service_throws_validation_error()
        {
            // Assemble
            var unitOfWork = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWork.FlowTemplateSteps.Add(A <IFlowTemplateStep> ._))
            .Throws(new ValidationException("Example Validation Message"));

            var sut = new FlowTemplateStepsController(unitOfWork);

            SetupController(sut, "http://example.com/api/FlowTemplates/1/Steps", HttpMethod.Post);

            // Act
            var instance = new FlowTemplateStepDto {
                StepTypeName = "StartStep"
            };
            var response = sut.Post(3, instance);

            var task = response.Content.ReadAsAsync <ExpandoObject>();

            task.Wait();
            dynamic result = task.Result;

            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            Assert.Equal("Example Validation Message", result.BrokenRules[0]);
            Assert.Equal(1, result.BrokenRules.Count);
        }
        public void Should_return_step_matching_parent_and_id()
        {
            var unitOfWork = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWork.FlowTemplateSteps.Get()).Returns(
                new List <FlowTemplateStep>
            {
                new FlowTemplateStep {
                    Id = 1, Name = "Correct Step 1", FlowTemplateId = 1, StepTypeId = 1
                },
                new FlowTemplateStep {
                    Id = 2, Name = "Incorrect Step", FlowTemplateId = 2, StepTypeId = 1
                },
                new FlowTemplateStep {
                    Id = 3, Name = "Correct Step 3", FlowTemplateId = 1, StepTypeId = 2
                }
            });

            var sut = new FlowTemplateStepsController(unitOfWork);

            SetupController(sut, "http://example.com/api/FlowTemplates/1/Steps/2", HttpMethod.Get);

            var response = sut.Get(1, 3);
            var task     = response.Content.ReadAsAsync <FlowTemplateDto>();

            task.Wait();
            var result = task.Result;

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(3, result.Id);
        }
        public void Should_return_404_if_step_does_not_exist()
        {
            var unitOfWork = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWork.FlowTemplateSteps.Get(A <int> ._)).Returns(null);
            var sut = new FlowTemplateStepsController(unitOfWork);

            SetupController(sut, "http://example.com/api/FlowTemplates/1/Steps", HttpMethod.Get);

            var response = sut.Get(2);

            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
            Assert.Equal(null, response.Content);
        }
        public static void SetupController(FlowTemplateStepsController controller, string url, HttpMethod method)
        {
            var config    = new HttpConfiguration();
            var request   = new HttpRequestMessage(method, url);
            var route     = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
            var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
                { "controller", "FlowTemplateStep" }
            });

            controller.ControllerContext = new HttpControllerContext(config, routeData, request);
            controller.Request           = request;
            controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
            controller.Request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, routeData);
        }
        public void Should_return_200_if_step_is_deleted()
        {
            var unitOfWork = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWork.FlowTemplateSteps.Get())
            .Returns(new List <IFlowTemplateStep> {
                new FlowTemplateStep {
                    Id = 3, FlowTemplateId = 3, StepTypeId = 1
                }
            });
            var sut = new FlowTemplateStepsController(unitOfWork);

            SetupController(sut, "http://example.com/api/FlowTemplates/1/Steps", HttpMethod.Delete);

            var response = sut.Delete(3, 3);

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(null, response.Content);
        }
        public void FlowTemplateService_Post_should_add_StartStep_values()
        {
            var unitOfWork = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWork.FlowTemplateSteps.Get()).Returns(new List <IFlowTemplateStep>
            {
                new FlowTemplateStep {
                    Id = 10
                }
            });
            var sut = new FlowTemplateStepsController(unitOfWork);
            IFlowTemplateStep captured = null;

            A.CallTo(() => unitOfWork.FlowTemplateSteps.Add(A <IFlowTemplateStep> ._))
            .Invokes((IFlowTemplateStep item) => captured = item);
            SetupController(sut, "http://example.com/api/FlowTemplates/1/Steps", HttpMethod.Post);

            // Act
            var instance = new FlowTemplateStepDto {
                Name = "New StartStep", StepTypeName = "StartStep"
            };
            var response = sut.Post(3, instance);

            var task = response.Content.ReadAsAsync <ExpandoObject>();

            task.Wait();
            dynamic result = task.Result;

            A.CallTo(() => unitOfWork.FlowTemplateSteps.Get()).MustHaveHappened(Repeated.Exactly.Once);
            A.CallTo(() => unitOfWork.FlowTemplateSteps.Add(A <IFlowTemplateStep> ._)).MustHaveHappened(Repeated.Exactly.Once);
            A.CallTo(() => unitOfWork.Commit()).MustHaveHappened(Repeated.Exactly.Once);
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(11, result.Id);
            Assert.Equal(captured.Id, result.Id);
            Assert.Equal(3, captured.FlowTemplateId);
            Assert.Equal(1, captured.StepTypeId);
            Assert.Equal("New StartStep", captured.Name);
        }
        public void Should_return_404_if_step_does_not_exist_on_parent()
        {
            var unitOfWork = A.Fake <IUnitOfWork>();

            A.CallTo(() => unitOfWork.FlowTemplateSteps.Get()).Returns(
                new List <FlowTemplateStep>
            {
                new FlowTemplateStep {
                    Id = 1, Name = "Correct Step 1", FlowTemplateId = 1, StepTypeId = 1
                },
                new FlowTemplateStep {
                    Id = 2, Name = "Incorrect Step", FlowTemplateId = 2, StepTypeId = 1
                },
                new FlowTemplateStep {
                    Id = 3, Name = "Correct Step 3", FlowTemplateId = 1, StepTypeId = 2
                }
            }); var sut = new FlowTemplateStepsController(unitOfWork);
            SetupController(sut, "http://example.com/api/FlowTemplates/1/Steps", HttpMethod.Get);

            var response = sut.Get(3, 3);

            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
            Assert.Equal(null, response.Content);
        }