public void Constructor_SetsProperties()
        {
            var dut = new UpdateAttendedStatusAndNotesOnParticipantsCommand(
                1,
                new List <UpdateAttendedStatusAndNoteOnParticipantForCommand>
            {
                new UpdateAttendedStatusAndNoteOnParticipantForCommand(2, true, "note", ParticipantRowVersion)
            });

            Assert.AreEqual(1, dut.InvitationId);
            Assert.AreEqual(1, dut.Participants.Count);
            Assert.AreEqual(ParticipantRowVersion, dut.Participants.First().RowVersion);
            Assert.AreEqual(2, dut.Participants.First().Id);
            Assert.AreEqual("note", dut.Participants.First().Note);
            Assert.AreEqual(true, dut.Participants.First().Attended);
        }
        public void Setup_OkState()
        {
            _invitationValidatorMock = new Mock <IInvitationValidator>();
            _rowVersionValidatorMock = new Mock <IRowVersionValidator>();
            _rowVersionValidatorMock.Setup(r => r.IsValid(_participantRowVersion1)).Returns(true);
            _rowVersionValidatorMock.Setup(r => r.IsValid(_participantRowVersion2)).Returns(true);
            _invitationValidatorMock.Setup(inv => inv.IpoExistsAsync(_id, default)).Returns(Task.FromResult(true));
            _invitationValidatorMock.Setup(inv => inv.IpoIsInStageAsync(_id, IpoStatus.Completed, default)).Returns(Task.FromResult(true));
            _invitationValidatorMock.Setup(inv => inv.CurrentUserIsValidCompleterParticipantAsync(_id, default)).Returns(Task.FromResult(true));
            _invitationValidatorMock.Setup(inv => inv.IpoHasCompleterAsync(_id, default)).Returns(Task.FromResult(true));
            _invitationValidatorMock.Setup(inv => inv.ParticipantExistsAsync(_participantId1, _id, default)).Returns(Task.FromResult(true));
            _invitationValidatorMock.Setup(inv => inv.ParticipantExistsAsync(_participantId2, _id, default)).Returns(Task.FromResult(true));
            _command = new UpdateAttendedStatusAndNotesOnParticipantsCommand(
                _id,
                _participants);

            _dut = new UpdateAttendedStatusAndNotesOnParticipantsCommandValidator(_invitationValidatorMock.Object, _rowVersionValidatorMock.Object);
        }
        public void Setup()
        {
            _plantProviderMock = new Mock <IPlantProvider>();
            _plantProviderMock
            .Setup(x => x.Plant)
            .Returns(_plant);

            _unitOfWorkMock = new Mock <IUnitOfWork>();

            _currentUserProviderMock = new Mock <ICurrentUserProvider>();
            _currentUserProviderMock
            .Setup(x => x.GetCurrentUserOid()).Returns(_azureOidForCurrentUser);


            //mock person response from main API
            var personDetails = new ProCoSysPerson
            {
                AzureOid  = _azureOidForCurrentUser.ToString(),
                FirstName = "Ola",
                LastName  = "Nordman",
                Email     = "*****@*****.**",
                UserName  = "******"
            };

            _personApiServiceMock = new Mock <IPersonApiService>();
            _personApiServiceMock
            .Setup(x => x.GetPersonInFunctionalRoleAsync(_plant,
                                                         _azureOidForCurrentUser.ToString(), _functionalRoleCode))
            .Returns(Task.FromResult(personDetails));

            //create invitation
            _invitation = new Invitation(
                _plant,
                _projectName,
                _title,
                _description,
                _typeDp,
                new DateTime(),
                new DateTime(),
                null,
                new List <McPkg> {
                new McPkg(_plant, _projectName, "Comm", "Mc", "d", "1|2")
            },
                null)
            {
                MeetingId = _meetingId
            };

            var participant1 = new Participant(
                _plant,
                Organization.Contractor,
                IpoParticipantType.FunctionalRole,
                _functionalRoleCode,
                null,
                null,
                null,
                null,
                null,
                0);

            participant1.SetProtectedIdForTesting(_contractorParticipantId);
            _invitation.AddParticipant(participant1);
            var participant2 = new Participant(
                _plant,
                Organization.ConstructionCompany,
                IpoParticipantType.Person,
                null,
                "Kari",
                "Nordmann",
                "KN",
                "*****@*****.**",
                null,
                1);

            participant2.SetProtectedIdForTesting(_constructionCompanyParticipantId);
            _invitation.AddParticipant(participant2);

            _invitationRepositoryMock = new Mock <IInvitationRepository>();
            _invitationRepositoryMock
            .Setup(x => x.GetByIdAsync(It.IsAny <int>()))
            .Returns(Task.FromResult(_invitation));

            var currentPerson = new Person(_azureOidForCurrentUser, null, null, null, null);

            currentPerson.SetProtectedIdForTesting(_contractorParticipantId);

            _personRepositoryMock = new Mock <IPersonRepository>();
            _personRepositoryMock
            .Setup(x => x.GetByOidAsync(It.IsAny <Guid>()))
            .Returns(Task.FromResult(currentPerson));

            _invitation.CompleteIpo(participant2, participant2.RowVersion.ConvertToString(), currentPerson, new DateTime());

            //command
            _command = new UpdateAttendedStatusAndNotesOnParticipantsCommand(
                _invitation.Id,
                _participants);

            _dut = new UpdateAttendedStatusAndNotesOnParticipantsCommandHandler(
                _plantProviderMock.Object,
                _invitationRepositoryMock.Object,
                _unitOfWorkMock.Object,
                _currentUserProviderMock.Object,
                _personApiServiceMock.Object);
        }