コード例 #1
0
        public async Task Handle_ShouldReturnOkResult_WhenNoUnCancelledIpoExists()
        {
            using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                var invitationWithPersonParticipant =
                    context.Invitations.Single(i => i.Id == _invitationWithPersonParticipant.Id);

                var invitationWithFunctionalRoleParticipant =
                    context.Invitations.Single(i => i.Id == _invitationWithFunctionalRoleParticipant.Id);

                var invitationWithPersonParticipantContractor =
                    context.Invitations.Single(i => i.Id == _invitationWithPersonParticipantContractor.Id);

                var invitationWithFunctionalRoleParticipantContractor =
                    context.Invitations.Single(i => i.Id == _invitationWithFunctionalRoleParticipantContractor.Id);

                context.Remove(invitationWithPersonParticipant);
                context.Remove(invitationWithFunctionalRoleParticipant);
                context.Remove(invitationWithPersonParticipantContractor);
                context.Remove(invitationWithFunctionalRoleParticipantContractor);

                context.SaveChangesAsync().Wait();
            }

            using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                var dut = new GetOutstandingIposForCurrentPersonQueryHandler(context, _currentUserProvider,
                                                                             _meApiServiceMock.Object, _plantProvider);

                var result = await dut.Handle(_query, default);

                Assert.AreEqual(0, result.Data.Items.Count());
                Assert.AreEqual(ResultType.Ok, result.ResultType);
            }
        }
コード例 #2
0
        public async Task Handle_ShouldReturnOkResult()
        {
            using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                var dut    = new GetOutstandingIposForCurrentPersonQueryHandler(context, _currentUserProvider, _meApiServiceMock.Object, _plantProvider);
                var result = await dut.Handle(_query, default);

                Assert.AreEqual(ResultType.Ok, result.ResultType);
            }
        }
コード例 #3
0
        public async Task Handle_ShouldReturnEmptyList_WhenUserNotExists()
        {
            using (var context =
                       new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                _currentUserProviderMock = new Mock <ICurrentUserProvider>();
                _currentUserProviderMock.Setup(x => x.GetCurrentUserOid()).Throws(new Exception("Unable to determine current user"));
                var dut = new GetOutstandingIposForCurrentPersonQueryHandler(context, _currentUserProviderMock.Object,
                                                                             _meApiServiceMock.Object, _plantProvider);

                var result = await dut.Handle(_query, default);

                Assert.AreEqual(0, result.Data.Items.Count());
                Assert.AreEqual(ResultType.Ok, result.ResultType);
            }
        }
コード例 #4
0
        public async Task Handle_ShouldReturnCorrectItems()
        {
            using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                var dut    = new GetOutstandingIposForCurrentPersonQueryHandler(context, _currentUserProvider, _meApiServiceMock.Object, _plantProvider);
                var result = await dut.Handle(_query, default);

                Assert.AreEqual(4, result.Data.Items.Count());
                var outstandingInvitationWithPersonParticipant = result.Data.Items.ElementAt(0);
                Assert.AreEqual(_invitationWithPersonParticipant.Id,
                                outstandingInvitationWithPersonParticipant.InvitationId);
                Assert.AreEqual(_invitationWithPersonParticipant.Description,
                                outstandingInvitationWithPersonParticipant.Description);
                Assert.AreEqual(Organization.ConstructionCompany,
                                outstandingInvitationWithPersonParticipant.Organization);

                var outstandingInvitationWithFunctionalRoleParticipant = result.Data.Items.ElementAt(1);
                Assert.AreEqual(_invitationWithFunctionalRoleParticipant.Id,
                                outstandingInvitationWithFunctionalRoleParticipant.InvitationId);
                Assert.AreEqual(_invitationWithFunctionalRoleParticipant.Description,
                                outstandingInvitationWithFunctionalRoleParticipant.Description);
                Assert.AreEqual(Organization.ConstructionCompany,
                                outstandingInvitationWithFunctionalRoleParticipant.Organization);

                var outstandingInvitationWithPersonParticipantContractor = result.Data.Items.ElementAt(2);
                Assert.AreEqual(_invitationWithPersonParticipantContractor.Id,
                                outstandingInvitationWithPersonParticipantContractor.InvitationId);
                Assert.AreEqual(_invitationWithPersonParticipantContractor.Description,
                                outstandingInvitationWithPersonParticipantContractor.Description);
                Assert.AreEqual(Organization.Contractor,
                                outstandingInvitationWithPersonParticipantContractor.Organization);

                var outstandingInvitationWithFunctionalRoleParticipantContractor = result.Data.Items.ElementAt(3);
                Assert.AreEqual(_invitationWithFunctionalRoleParticipantContractor.Id,
                                outstandingInvitationWithFunctionalRoleParticipantContractor.InvitationId);
                Assert.AreEqual(_invitationWithFunctionalRoleParticipantContractor.Description,
                                outstandingInvitationWithFunctionalRoleParticipantContractor.Description);
                Assert.AreEqual(Organization.Contractor,
                                outstandingInvitationWithPersonParticipantContractor.Organization);
            }
        }
コード例 #5
0
        public async Task Handle_ShouldNotReturnIpoForContractor_AfterIpoHasBeenCompleted()
        {
            using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                var invitationWithPersonParticipantContractor =
                    context.Invitations.Single(i => i.Id == _invitationWithPersonParticipantContractor.Id);

                invitationWithPersonParticipantContractor.CompleteIpo(_personParticipant,
                                                                      _personParticipant.RowVersion.ConvertToString(), _person, DateTime.Now);

                context.SaveChangesAsync().Wait();
            }

            using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                var dut = new GetOutstandingIposForCurrentPersonQueryHandler(context, _currentUserProvider,
                                                                             _meApiServiceMock.Object, _plantProvider);
                var result = await dut.Handle(_query, default);

                Assert.AreEqual(3, result.Data.Items.Count());
                var outstandingInvitationWithPersonParticipant = result.Data.Items.ElementAt(0);
                Assert.AreEqual(_invitationWithPersonParticipant.Id,
                                outstandingInvitationWithPersonParticipant.InvitationId);
                Assert.AreEqual(_invitationWithPersonParticipant.Description,
                                outstandingInvitationWithPersonParticipant.Description);

                var outstandingInvitationWithFunctionalRoleParticipant = result.Data.Items.ElementAt(1);
                Assert.AreEqual(_invitationWithFunctionalRoleParticipant.Id,
                                outstandingInvitationWithFunctionalRoleParticipant.InvitationId);
                Assert.AreEqual(_invitationWithFunctionalRoleParticipant.Description,
                                outstandingInvitationWithFunctionalRoleParticipant.Description);

                var outstandingInvitationWithFunctionalRoleParticipantContractor = result.Data.Items.ElementAt(2);
                Assert.AreEqual(_invitationWithFunctionalRoleParticipantContractor.Id,
                                outstandingInvitationWithFunctionalRoleParticipantContractor.InvitationId);
                Assert.AreEqual(_invitationWithFunctionalRoleParticipantContractor.Description,
                                outstandingInvitationWithFunctionalRoleParticipantContractor.Description);
            }
        }
コード例 #6
0
        public async Task Handle_ShouldNotCheckForPersonsFunctionalRoles_WhenNoInvitationsExist()
        {
            using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                var invitationWithPersonParticipant =
                    context.Invitations.Single(i => i.Id == _invitationWithPersonParticipant.Id);

                var invitationWithFunctionalRoleParticipant =
                    context.Invitations.Single(i => i.Id == _invitationWithFunctionalRoleParticipant.Id);

                var cancelledInvitation = context.Invitations.Single(i => i.Id == _cancelledInvitation.Id);

                var invitationWithPersonParticipantContractor =
                    context.Invitations.Single(i => i.Id == _invitationWithPersonParticipantContractor.Id);

                var invitationWithFunctionalRoleParticipantContractor =
                    context.Invitations.Single(i => i.Id == _invitationWithFunctionalRoleParticipantContractor.Id);

                context.Remove(invitationWithPersonParticipant);
                context.Remove(invitationWithFunctionalRoleParticipant);
                context.Remove(cancelledInvitation);
                context.Remove(invitationWithPersonParticipantContractor);
                context.Remove(invitationWithFunctionalRoleParticipantContractor);

                context.SaveChangesAsync().Wait();

                var existingUncancelledInvitations = context.Invitations.Count(i => i.Status != IpoStatus.Canceled);
                Assert.AreEqual(0, existingUncancelledInvitations);

                var dut = new GetOutstandingIposForCurrentPersonQueryHandler(context, _currentUserProvider,
                                                                             _meApiServiceMock.Object, _plantProvider);

                await dut.Handle(_query, default);

                _meApiServiceMock.Verify(meApiService => meApiService.GetFunctionalRoleCodesAsync(TestPlant), Times.Never);
            }
        }
コード例 #7
0
        public async Task Handle_ShouldReturnCorrectItems_WhenUserIsNotInAnyFunctionalRoles()
        {
            using (var context = new IPOContext(_dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
            {
                var            dut = new GetOutstandingIposForCurrentPersonQueryHandler(context, _currentUserProvider, _meApiServiceMock.Object, _plantProvider);
                IList <string> emptyListOfFunctionalRoleCodes = new List <string>();
                _meApiServiceMock
                .Setup(x => x.GetFunctionalRoleCodesAsync(TestPlant))
                .Returns(Task.FromResult(emptyListOfFunctionalRoleCodes));

                var result = await dut.Handle(_query, default);

                Assert.AreEqual(2, result.Data.Items.Count());
                var outstandingInvitation = result.Data.Items.ElementAt(0);
                Assert.AreEqual(_invitationWithPersonParticipant.Id, outstandingInvitation.InvitationId);
                Assert.AreEqual(_invitationWithPersonParticipant.Description, outstandingInvitation.Description);

                var outstandingInvitationWithPersonParticipantContractor = result.Data.Items.ElementAt(1);
                Assert.AreEqual(_invitationWithPersonParticipantContractor.Id,
                                outstandingInvitationWithPersonParticipantContractor.InvitationId);
                Assert.AreEqual(_invitationWithPersonParticipantContractor.Description,
                                outstandingInvitationWithPersonParticipantContractor.Description);
            }
        }