public async Task ShouldUpdateShooterBeNotFoundHavingProvidedWrongId()
        {
            //conteggio esistenti
            var countBefore = Scenario.Shooters.Count;

            //Composizione della request
            var request = new ShooterUpdateRequest
            {
                ShooterId = RandomizationUtils.GenerateRandomString(10),
                Email     = RandomizationUtils.GenerateRandomEmail(),
                LastName  = RandomizationUtils.GenerateRandomString(10),
                FirstName = RandomizationUtils.GenerateRandomString(10),
                BirthDate = DateTime.Now,
                Username  = RandomizationUtils.GenerateRandomString(10)
            };

            //Invoke del metodo
            var response = await Controller.UpdateShooter(request);

            //Parsing della risposta e assert
            var parsed = ParseExpectedNotFound(response);

            //conteggio esistenti
            var countAfter = Scenario.Shooters.Count;


            Assert.IsTrue(parsed != null &&
                          parsed.Data == null);

            //verifica contatori
            Assert.AreEqual(countBefore, countAfter);
        }
        public async Task ShouldUpdateShooterBeOkHavingProvidedData()
        {
            //Recupero una Shooter esistente
            var existing = Scenario.Shooters.FirstOrDefault();

            if (existing == null)
            {
                Assert.Inconclusive("Shooter does not exists");
            }

            //conteggio esistenti
            var countBefore = Scenario.Shooters.Count;


            //Composizione della request
            var request = new ShooterUpdateRequest
            {
                ShooterId                    = existing.Id,
                Email                        = RandomizationUtils.GenerateRandomEmail(),
                LastName                     = RandomizationUtils.GenerateRandomString(10),
                FirstName                    = RandomizationUtils.GenerateRandomString(10),
                BirthDate                    = DateTime.Now,
                Username                     = RandomizationUtils.GenerateRandomString(10),
                FirearmsLicence              = RandomizationUtils.GenerateRandomString(10),
                FirearmsLicenceExpireDate    = DateTime.Now,
                MedicalExaminationExpireDate = DateTime.Now
            };

            //Invoke del metodo
            var response = await Controller.UpdateShooter(request);

            //Parsing della risposta e assert
            var parsed = ParseExpectedOk <ShooterContract>(response);

            //conteggio esistenti
            var countAfter = Scenario.Shooters.Count;


            Assert.IsTrue(parsed != null &&
                          parsed.Data.Email == request.Email &&
                          parsed.Data.LastName == request.LastName &&
                          parsed.Data.FirstName == request.FirstName &&
                          parsed.Data.BirthDate == request.BirthDate &&
                          parsed.Data.FirearmsLicence == request.FirearmsLicence &&
                          parsed.Data.FirearmsLicenceExpireDate == request.FirearmsLicenceExpireDate &&
                          parsed.Data.MedicalExaminationExpireDate == request.MedicalExaminationExpireDate &&
                          parsed.Data.Username == request.Username);

            //verifica contatori
            Assert.AreEqual(countBefore, countAfter);
        }
        public async Task ShouldUpdateShooterBeBadRequestHavingProvidedSameFirearmsLicence()
        {
            //conteggio esistenti
            var countBefore = Scenario.Shooters.Count;
            //Recupero una Shooter esistente
            var existing = Scenario.Shooters.FirstOrDefault();

            if (existing == null)
            {
                Assert.Inconclusive("Shooter does not exists");
            }

            //Recupero una Shooter esistente
            var existingToUpdate = Scenario.Shooters.FirstOrDefault(x => x.Id != existing.Id);

            if (existing == null)
            {
                Assert.Inconclusive("Shooter does not exists");
            }

            //Composizione della request
            var request = new ShooterUpdateRequest
            {
                ShooterId       = existingToUpdate.Id,
                FirearmsLicence = existing.FirearmsLicence,
                Email           = RandomizationUtils.GenerateRandomEmail(),
                LastName        = RandomizationUtils.GenerateRandomString(10),
                FirstName       = RandomizationUtils.GenerateRandomString(10),
                BirthDate       = DateTime.Now,
                Username        = RandomizationUtils.GenerateRandomString(10)
            };

            //Invoke del metodo
            var response = await Controller.UpdateShooter(request);

            //Parsing della risposta e assert
            var parsed = ParseExpectedBadRequest(response);

            //conteggio esistenti
            var countAfter = Scenario.Shooters.Count;

            Assert.IsNotNull(parsed);
            Assert.IsTrue(parsed.Data.Any());

            //verifica contatori
            Assert.AreEqual(countBefore, countAfter);
        }
예제 #4
0
        public async Task <IActionResult> UpdateShooter([EntityId] ShooterUpdateRequest request)
        {
            //Recupero l'elemento dal business layer
            var entity = BasicLayer.GetShooter(request.ShooterId);

            //modifica solo se admin o se utente richiedente è lo stesso che ha creato
            if (entity == null)
            {
                return(NotFound());
            }

            //Aggiornamento dell'entità
            entity.FirstName = request.FirstName;
            entity.LastName  = request.LastName;
            entity.BirthDate = request.BirthDate;
            entity.Email     = request.Email;
            entity.Username  = request.Username;
            entity.FirearmsLicenceExpireDate    = request.FirearmsLicenceExpireDate;
            entity.FirearmsLicence              = request.FirearmsLicence;
            entity.MedicalExaminationExpireDate = request.MedicalExaminationExpireDate;
            entity.BirthLocation = request.BirthLocation;
            entity.Address       = request.Address;
            entity.City          = request.City;
            entity.PostalCode    = request.PostalCode;
            entity.Province      = request.Province;
            entity.Country       = request.Country;
            entity.Phone         = request.Phone;
            entity.FiscalCode    = request.FiscalCode;

            //Salvataggio
            var validations = await BasicLayer.UpdateShooter(entity, PlatformUtils.GetIdentityUserId(User));

            if (validations.Count > 0)
            {
                return(BadRequest(validations));
            }

            //Confermo
            return(Ok(ContractUtils.GenerateContract(entity)));
        }