public async Task EditPerson_GivenValidDataForExistingPerson_ShouldEditPerson()
        {
            var editPerson = new EditPersonDataDto
            {
                PersonId  = mockPersonId,
                UserId    = mockUserId,
                FirstName = "test",
                LastName  = "test",
                Role      = "role test",
                Company   = "company test",
                Country   = "country test"
            };

            mockPersonRepository.Setup(s => s.GetSingleByCondition(It.IsAny <Expression <Func <Core.Entities.Person, bool> > >()))
            .Returns(Task.FromResult(GetPeople().First()));
            mockPersonRepository.Setup(s => s.Update(It.IsAny <Core.Entities.Person>())).Returns(Task.CompletedTask);
            mockPersonRepository.Setup(s => s.SaveChanges()).ReturnsAsync(true);

            var personService = new PersonService(mockPersonRepository.Object, mapper);

            var result = await personService.EditPerson(editPerson);

            mockPersonRepository.Verify(v => v.Update(It.IsAny <Core.Entities.Person>()), Times.Once);
            mockPersonRepository.Verify(v => v.SaveChanges(), Times.Once);

            Assert.IsTrue(result);
        }
Esempio n. 2
0
        public async Task <IActionResult> EditPerson(EditPersonDataDto editPerson)
        {
            try
            {
                var result = await personService.EditPerson(editPerson);

                return(Ok(result));
            }
            catch (Exception ex)
            {
                return(HandleException(ex.Message));
            }
        }
Esempio n. 3
0
        public async Task <bool> EditPerson(EditPersonDataDto editPerson)
        {
            var entity = await personRepository.GetSingleByCondition(x => x.PersonId == editPerson.PersonId);

            if (entity == null)
            {
                return(false);
            }

            var updated = mapper.Map(editPerson, entity);

            await personRepository.Update(updated);

            return(await personRepository.SaveChanges());
        }
        public async Task EditPerson_GivenValidDataForUnexistingPerson_ShouldntEditPersonAndReturnFalse()
        {
            var editPerson = new EditPersonDataDto
            {
                PersonId  = mockPersonId,
                UserId    = mockUserId,
                FirstName = "test",
                LastName  = "test",
                Role      = "role test",
                Company   = "company test",
                Country   = "country test"
            };

            mockPersonRepository.Setup(s => s.GetSingleByCondition(It.IsAny <Expression <Func <Core.Entities.Person, bool> > >()))
            .Returns(Task.FromResult <Core.Entities.Person>(null));

            var personService = new PersonService(mockPersonRepository.Object, mapper);

            var result = await personService.EditPerson(editPerson);

            Assert.IsFalse(result);
        }