C# Controllers.TaskController类代码示例

        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 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 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 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 void CreateGetReturnsCorrectViewModel()
        {
            const int organizationId = 1;
            const int campaignId = 1;
            var campaignStartDateTime = DateTime.Now.AddDays(-1);
            var campaignEndDateTime = DateTime.Now.AddDays(1);

            var campaignEvent = new Event
            {
                Id = 1,
                Name = "EventName",
                CampaignId = campaignId,
                Campaign = new Campaign
                {
                    Id = campaignId,
                    Name = "CampaignName",
                    ManagingOrganizationId = organizationId,
                    TimeZoneId = "EST",
                    StartDateTime = campaignStartDateTime,
                    EndDateTime = campaignEndDateTime
                }
            };

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.Send(It.IsAny<EventByIdQuery>())).Returns(campaignEvent);

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

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

            Assert.Equal(modelResult.EventId, campaignEvent.Id);
            Assert.Equal(modelResult.EventName, campaignEvent.Name);
            Assert.Equal(modelResult.CampaignId, campaignEvent.CampaignId);
            Assert.Equal(modelResult.CampaignName, campaignEvent.Campaign.Name);
            Assert.Equal(modelResult.OrganizationId, campaignEvent.Campaign.ManagingOrganizationId);
            Assert.Equal(modelResult.TimeZoneId, campaignEvent.Campaign.TimeZoneId);
            Assert.Equal(modelResult.StartDateTime, campaignEvent.StartDateTime);
            Assert.Equal(modelResult.EndDateTime, campaignEvent.EndDateTime);
        }

        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 void ControllerHasAreaAtttributeWithTheCorrectAreaName()
 {
     var sut = new TaskController(null, Mock.Of<ITaskSummaryModelValidator>());
     sut.SetDefaultHttpContext();
     var attribute = sut.GetAttributes().OfType<AreaAttribute>().SingleOrDefault();
     Assert.NotNull(attribute);
     Assert.Equal(attribute.RouteValue, "Admin");
 }

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

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

            var sut = new TaskController(mediator.Object, Mock.Of<ITaskSummaryModelValidator>());
            MakeUserOrganizationAdminUser(sut, organizationId.ToString());
            var result = await sut.MessageAllVolunteers(new MessageTaskVolunteersModel());

            Assert.IsType<HttpOkResult>(result);
        }

        public async Task MessageAllVolunttersReturnsHttpUnauthorizedResultWhenUserIsNotOrgAdmin()
        {
            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.SendAsync(It.IsAny<TaskQueryAsync>())).ReturnsAsync(new TaskSummaryModel());

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

            Assert.IsType<HttpUnauthorizedResult>(result);
        }

        public async Task MessageAllVounteersSendsTaskQueryAsyncWithCorrectTaskId()
        {
            var model = new MessageTaskVolunteersModel { TaskId = 1 };
            var mediator = new Mock<IMediator>();

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

            mediator.Verify(x => x.SendAsync(It.Is<TaskQueryAsync>(y => y.TaskId == model.TaskId)), Times.Once);
        }

 public void AssignHasValidateAntiForgeryTokenAttribute()
 {
     var sut = new TaskController(null, Mock.Of<ITaskSummaryModelValidator>());
     var attribute = sut.GetAttributesOn(x => x.Assign(It.IsAny<int>(), It.IsAny<List<string>>())).OfType<ValidateAntiForgeryTokenAttribute>().SingleOrDefault();
     Assert.NotNull(attribute);
 }

        public async Task AssignSendsAssignTaskCommandAsync()
        {
            const int organizationId = 1;
            const int taskId = 1;
            var taskModelSummary = new TaskSummaryModel { EventId = 1 };
            var userIds = new List<string> { "1", "2" };

            var mediator = new Mock<IMediator>();
            mediator.Setup(x => x.SendAsync(It.IsAny<TaskQueryAsync>())).ReturnsAsync(taskModelSummary);
            mediator.Setup(x => x.Send(It.Is<EventByIdQuery>(y => y.EventId == taskModelSummary.EventId))).Returns(new Event { Campaign = new Campaign { ManagingOrganizationId = organizationId } });

            var sut = new TaskController(mediator.Object, Mock.Of<ITaskSummaryModelValidator>());
            MakeUserOrganizationAdminUser(sut, organizationId.ToString());
            await sut.Assign(taskId, userIds);

            mediator.Verify(x => x.SendAsync(It.Is<AssignTaskCommandAsync>(y => y.TaskId == taskId && y.UserIds == userIds)), Times.Once);
        }