C# TaskController.Create方法代码示例

        public void CreateGetReturnsHttpUnauthorizedResultWhenActivityIsNull()
        {
            var sut = new TaskController(Mock.Of<IMediator>());
            var result = sut.Create(It.IsAny<int>());

            Assert.IsType<HttpUnauthorizedResult>(result);
        }

        public void CreateGetReturnsHttpUnauthorizedResultWhenEventIsNull()
        {
            var sut = new TaskController(Mock.Of<IMediator>(), Mock.Of<ITaskSummaryModelValidator>());
            var result = sut.Create(It.IsAny<int>());

            Assert.IsType<HttpUnauthorizedResult>(result);
        }

        public void CreateGetSendsActivityByActivityIdQueryWithTheCorrectActivityId()
        {
            const int activityId = 1;
            var mediator = new Mock<IMediator>();
            var sut = new TaskController(mediator.Object);
            sut.Create(activityId);

            mediator.Verify(x => x.Send(It.Is<ActivityByActivityIdQuery>(y => y.ActivityId == activityId)), Times.Once);
        }

        public void CreateGetSendsEventByEventIdQueryWithTheCorrectEventId()
        {
            const int eventId = 1;
            var mediator = new Mock<IMediator>();
            var sut = new TaskController(mediator.Object);
            sut.Create(eventId);

            mediator.Verify(x => x.Send(It.Is<EventByIdQuery>(y => y.EventId == eventId)), Times.Once);
        }

        public void CreateGetReturnsHttpUnauthorizedResultWhenUserIsNotOrganizationAdminForTheirOrganization()
        {
            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.Send(It.IsAny<EventByIdQuery>())).Returns(new Event { Campaign = new Campaign { ManagingOrganizationId = 1 } });

            var sut = new TaskController(mediator.Object, Mock.Of<ITaskSummaryModelValidator>());
            sut.SetDefaultHttpContext();

            var result = sut.Create(It.IsAny<int>());

            Assert.IsType<HttpUnauthorizedResult>(result);
        }

        public async Task CreateGetReturnsUnauthorizedResultWhenUserIsNotOrganizationAdmin()
        {
            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.SendAsync(It.IsAny<CreateTaskQueryAsync>())).ReturnsAsync(new EditViewModel());

            var sut = new TaskController(mediator.Object, null);
            sut.SetDefaultHttpContext();

            var result = await sut.Create(It.IsAny<int>());

            Assert.IsType<UnauthorizedResult>(result);
        }

        public async Task CreateGetSendsCreateTaskQueryAsyncWithTheCorrectEventId()
        {
            const int eventId = 1;
            const int organizationId = 1;

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.SendAsync(It.IsAny<CreateTaskQueryAsync>())).ReturnsAsync(new EditViewModel { OrganizationId = organizationId });

            var urlHelper = new Mock<IUrlHelper>();
            urlHelper.Setup(x => x.Action(It.IsAny<UrlActionContext>())).Returns(It.IsAny<string>());

            var sut = new TaskController(mediator.Object, null) { Url = urlHelper.Object };
            sut.MakeUserAnOrgAdmin(organizationId.ToString());

            await sut.Create(eventId);
            mediator.Verify(x => x.SendAsync(It.Is<CreateTaskQueryAsync>(y => y.EventId == eventId)), Times.Once);
        }

        public async Task CreateGetInvokesUrlActionWithTheCorrectParameters()
        {
            var model = new EditViewModel { EventId = 1, OrganizationId = 1 };

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.SendAsync(It.IsAny<CreateTaskQueryAsync>())).ReturnsAsync(model);

            var urlHelper = new Mock<IUrlHelper>();
            urlHelper.Setup(x => x.Action(It.IsAny<UrlActionContext>())).Returns(It.IsAny<string>());

            var sut = new TaskController(mediator.Object, null) { Url = urlHelper.Object };
            sut.MakeUserAnOrgAdmin(model.OrganizationId.ToString());

            await sut.Create(It.IsAny<int>());

            urlHelper.Verify(x => x.Action(It.Is<UrlActionContext>(y =>
                y.Action == nameof(EventController.Details) &&
                y.Controller == "Event" &&
                y.Values.ToString() == $"{{ id = {model.EventId}, area = Admin }}")),
            Times.Once);
        }

        public async Task CreateGetAssignsCancelUrlToModel()
        {
            const string cancelUrl = "url";
            var model = new EditViewModel { EventId = 1, OrganizationId = 1 };

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.SendAsync(It.IsAny<CreateTaskQueryAsync>())).ReturnsAsync(model);

            var urlHelper = new Mock<IUrlHelper>();
            urlHelper.Setup(x => x.Action(It.IsAny<UrlActionContext>())).Returns(cancelUrl);

            var sut = new TaskController(mediator.Object, null) { Url = urlHelper.Object };
            sut.MakeUserAnOrgAdmin(model.OrganizationId.ToString());

            var result = await sut.Create(It.IsAny<int>()) as ViewResult;
            var modelResult = result.Model as EditViewModel;

            Assert.Equal(modelResult.CancelUrl, cancelUrl);
        }

        public async Task CreatePostRedirectsToCorrectAction()
        {
            const int organizationId = 1;
            var taskSummaryModel = new TaskSummaryModel { OrganizationId = organizationId };
            var startDateTime = DateTimeOffset.Now.AddDays(-1);
            var endDateTime = DateTimeOffset.Now.AddDays(1);
            const int TaskSummaryModelId = 1;
            var model = new TaskSummaryModel { Id = TaskSummaryModelId, StartDateTime = startDateTime, EndDateTime = endDateTime, OrganizationId = organizationId };

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.Send(It.IsAny<EventByIdQuery>())).Returns(new Event
            {
                Campaign = new Campaign { TimeZoneId = "Eastern Standard Time" },
                StartDateTime = startDateTime.AddDays(-1),
                EndDateTime = endDateTime.AddDays(1)
            });
            mediator.Setup(x => x.SendAsync(It.IsAny<TaskQueryAsync>())).ReturnsAsync(taskSummaryModel);

            var routeValues = new Dictionary<string, object> { ["id"] = model.Id };

            var validator = new Mock<ITaskSummaryModelValidator>();
            validator.Setup(x => x.Validate(It.IsAny<TaskSummaryModel>())).Returns(new List<KeyValuePair<string, string>>());

            var sut = new TaskController(mediator.Object, validator.Object);
            MakeUserOrganizationAdminUser(sut, organizationId.ToString());

            var result = await sut.Create(TaskSummaryModelId, model) as RedirectToActionResult;

            Assert.Equal(result.ActionName, nameof(TaskController.Details));
            Assert.Equal(result.ControllerName, "Event");
            Assert.Equal(result.RouteValues, routeValues);
        }

        public async Task CreatePostSendsEditTaskCommandAsyncWhenModelStateIsValidAndUserIsOrganizationAdmin()
        {
            const int organizationId = 1;
            var taskSummaryModel = new TaskSummaryModel { OrganizationId = organizationId };
            var startDateTime = DateTimeOffset.Now.AddDays(-1);
            var endDateTime = DateTimeOffset.Now.AddDays(1);

            var model = new TaskSummaryModel { StartDateTime = startDateTime, EndDateTime = endDateTime, OrganizationId = organizationId };

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.Send(It.IsAny<EventByIdQuery>())).Returns(new Event
            {
                Campaign = new Campaign { TimeZoneId = "Eastern Standard Time" },
                StartDateTime = startDateTime.AddDays(-1),
                EndDateTime = endDateTime.AddDays(1)
            });
            mediator.Setup(x => x.SendAsync(It.IsAny<TaskQueryAsync>())).ReturnsAsync(taskSummaryModel);

            var validator = new Mock<ITaskSummaryModelValidator>();
            validator.Setup(x => x.Validate(It.IsAny<TaskSummaryModel>())).Returns(new List<KeyValuePair<string, string>>());

            var sut = new TaskController(mediator.Object, validator.Object);
            MakeUserOrganizationAdminUser(sut, organizationId.ToString());

            await sut.Create(It.IsAny<int>(), model);

            mediator.Verify(x => x.SendAsync(It.Is<EditTaskCommandAsync>(y => y.Task == model)));
        }

        public async Task CreatePostReturnsHttpUnauthorizedResultWhenModelStateIsValidAndUserIsNotAnOrganizationAdminUser()
        {
            var startDateTime = DateTimeOffset.Now.AddDays(-1);
            var endDateTime = DateTimeOffset.Now.AddDays(1);
            var model = new TaskSummaryModel { StartDateTime = startDateTime, EndDateTime = endDateTime, OrganizationId = 1 };

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.Send(It.IsAny<EventByIdQuery>())).Returns(new Event
            {
                Campaign = new Campaign { TimeZoneId = "Eastern Standard Time" },
                StartDateTime = startDateTime.AddDays(-1),
                EndDateTime = endDateTime.AddDays(1)
            });

            var validator = new Mock<ITaskSummaryModelValidator>();
            validator.Setup(x => x.Validate(It.IsAny<TaskSummaryModel>())).Returns(new List<KeyValuePair<string, string>>());

            var sut = new TaskController(mediator.Object, validator.Object);
            sut.SetDefaultHttpContext();

            var result = await sut.Create(It.IsAny<int>(), model);

            Assert.IsType<HttpUnauthorizedResult>(result);
        }

        public async Task CreatePostReturnsCorrectViewAndViewModelWhenValidatorReturnsError()
        {
            var model = new TaskSummaryModel { EndDateTime = DateTimeOffset.Now.AddDays(-1), StartDateTime = DateTimeOffset.Now.AddDays(1) };

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.Send(It.IsAny<EventByIdQuery>())).Returns(new Event { Campaign = new Campaign { TimeZoneId = "Eastern Standard Time" } });

            var validator = new Mock<ITaskSummaryModelValidator>();
            validator.Setup(x => x.Validate(It.IsAny<TaskSummaryModel>())).Returns(new List<KeyValuePair<string, string>> { new KeyValuePair<string, string>(nameof(TaskSummaryModel.EndDateTime), "Ending time cannot be earlier than the starting time") });

            var sut = new TaskController(mediator.Object, validator.Object);
            var result = await sut.Create(It.IsAny<int>(), model) as ViewResult;
            var modelResult = result.ViewData.Model as TaskSummaryModel;

            Assert.IsType<ViewResult>(result);
            Assert.Equal(modelResult, model);
        }

        public async Task CreatePostAddsCorrectModelStateErrorWhenValidatorReturnsError()
        {
            var mediator = new Mock<IMediator>();
            //mgmccarthy: for a list of time zone's to feed to TimeZoneInfo.FindSystemTimeZoneById, check here:
            //http://stackoverflow.com/questions/7908343/list-of-timezone-ids-for-use-with-findtimezonebyid-in-c
            mediator.Setup(x => x.Send(It.IsAny<EventByIdQuery>())).Returns(new Event { Campaign = new Campaign { TimeZoneId = "Eastern Standard Time" } });

            var validator = new Mock<ITaskSummaryModelValidator>();
            validator.Setup(x => x.Validate(It.IsAny<TaskSummaryModel>())).Returns(new List<KeyValuePair<string, string>> { new KeyValuePair<string, string>(nameof(TaskSummaryModel.EndDateTime), "Ending time cannot be earlier than the starting time") });

            var sut = new TaskController(mediator.Object, validator.Object);
            await sut.Create(It.IsAny<int>(), new TaskSummaryModel { EndDateTime = DateTimeOffset.Now.AddDays(-1), StartDateTime = DateTimeOffset.Now.AddDays(1) });

            var modelStateErrorCollection = sut.ModelState.GetErrorMessagesByKey(nameof(TaskSummaryModel.EndDateTime));
            Assert.Equal(modelStateErrorCollection.Single().ErrorMessage, "Ending time cannot be earlier than the starting time");
        }

        public async Task CreatePostCallsValidateOnTaskSummaryModelValidator()
        {
            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.Send(It.IsAny<EventByIdQuery>())).Returns(new Event { Campaign = new Campaign { TimeZoneId = "Eastern Standard Time" } });

            var validator = new Mock<ITaskSummaryModelValidator>();
            validator.Setup(x => x.Validate(It.IsAny<TaskSummaryModel>())).Returns(new List<KeyValuePair<string, string>>());

            var sut = new TaskController(mediator.Object, validator.Object);
            sut.SetFakeUserType(UserType.OrgAdmin);

            await sut.Create(It.IsAny<int>(), new TaskSummaryModel { OrganizationId = 1 });

            validator.Verify(x => x.Validate(It.IsAny<TaskSummaryModel>()), Times.Once);
        }