public async Task <IActionResult> UpdateGear(long id, GearDTO gearDTO)
        {
            if (id != gearDTO.Id)
            {
                return(BadRequest());
            }

            var gear = await _repository.GetByIdAsync(id);

            if (gear == null)
            {
                return(NotFound());
            }

            gear.Name        = gearDTO.Name;
            gear.Description = gearDTO.Description;
            gear.Brand       = gearDTO.Brand;
            gear.WeightGrams = gearDTO.WeightGrams;
            gear.LengthMM    = gearDTO.LengthMM;
            gear.WidthMM     = gearDTO.WidthMM;
            gear.DepthMM     = gearDTO.DepthMM;
            gear.Locking     = gearDTO.Locking;

            try
            {
                await _repository.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException) when(!_repository.Exists(id))
            {
                return(NotFound());
            }

            return(NoContent());
        }
        public async Task UpdateGear_CallWithIdThatDoesntExist_ShouldReturnNotFound()
        {
            var mockRepo   = new Mock <IGearRepository>();
            var controller = new GearController(mockRepo.Object);

            var gear = new GearDTO()
            {
                Id   = 42,
                Name = "EditedGear",
            };

            var result = await controller.UpdateGear(42, gear);

            Assert.IsType <NotFoundResult>(result);
        }
        public async Task <ActionResult <GearDTO> > CreateGear(GearDTO gearDTO)
        {
            Gear gear = new Gear
            {
                Name        = gearDTO.Name,
                Description = gearDTO.Description,
                Brand       = gearDTO.Brand,
                WeightGrams = gearDTO.WeightGrams,
                LengthMM    = gearDTO.LengthMM,
                WidthMM     = gearDTO.WidthMM,
                DepthMM     = gearDTO.DepthMM,
                Locking     = gearDTO.Locking,
            };

            await _repository.AddAsync(gear);

            return(CreatedAtAction(nameof(GetGear), new { id = gear.Id }, Gear.GearToDTO(gear)));
        }
        public async Task CreateGear_CallWithNewGearDTO_ShouldReturnNewGearAndCreated()
        {
            var mockRepo   = new Mock <IGearRepository>();
            var controller = new GearController(mockRepo.Object);

            var gear = new GearDTO()
            {
                Name = "NewGear",
            };

            var result = await controller.CreateGear(gear);

            var resultObject = result.Result as CreatedAtActionResult;
            var resultGear   = resultObject.Value as GearDTO;

            Assert.Equal(201, resultObject.StatusCode);
            Assert.Equal(gear.Name, resultGear.Name);
        }
        public async Task UpdateGear_CallWithIdAndWrongGearId_ShouldReturnBadRequest()
        {
            var mockRepo = new Mock <IGearRepository>();

            mockRepo.Setup(repo => repo.GetByIdAsync(It.IsAny <long>()).Result)
            .Returns(MockGear());

            var controller = new GearController(mockRepo.Object);

            var gear = new GearDTO()
            {
                Id   = 2,
                Name = "EditedGear",
            };

            var result = await controller.UpdateGear(1, gear);

            Assert.IsType <BadRequestResult>(result);
        }