public void UpdateVehicle_ReturnsFalseForInvalidFields()
        {
            var updatedVehicle = new UpdateVehicleCommandParameter(
                Guid.NewGuid(),
                -1,
                123.32,
                23.4,
                66,
                54.67,
                30);

            var isSuccessful = _setVehicleCommandHandler.UpdateVehicle(updatedVehicle);

            isSuccessful.Should().BeFalse();

            updatedVehicle = new UpdateVehicleCommandParameter(
                Guid.NewGuid(),
                50,
                123.32,
                23.4,
                -1,
                54.67,
                30);

            isSuccessful = _setVehicleCommandHandler.UpdateVehicle(updatedVehicle);
            isSuccessful.Should().BeFalse();

            updatedVehicle = new UpdateVehicleCommandParameter(
                Guid.NewGuid(),
                50,
                123.32,
                23.4,
                66,
                -54.67,
                30);
            isSuccessful = _setVehicleCommandHandler.UpdateVehicle(updatedVehicle);
            isSuccessful.Should().BeFalse();

            updatedVehicle = new UpdateVehicleCommandParameter(
                Guid.NewGuid(),
                -50,
                123.32,
                23.4,
                66,
                54.67,
                -3);
            isSuccessful = _setVehicleCommandHandler.UpdateVehicle(updatedVehicle);
            isSuccessful.Should().BeFalse();

            _vehicleRepositoryMock.Verify(x => x.UpdateVehicle(It.IsAny <Vehicle>()), Times.Never());
        }
        public IActionResult UpdateVehicle(UpdateVehicleApiParameters updateVehicleApiParameters)
        {
            var vehicle = new UpdateVehicleCommandParameter(
                updateVehicleApiParameters.VehicleId,
                updateVehicleApiParameters.Speed,
                updateVehicleApiParameters.Latitude,
                updateVehicleApiParameters.Longitude,
                updateVehicleApiParameters.EngineTemperature,
                updateVehicleApiParameters.RadiatorPressure,
                updateVehicleApiParameters.FuelRemaining);

            var isSuccessful = _setVehiclesCommandHandler.UpdateVehicle(vehicle);

            if (!isSuccessful)
            {
                return(BadRequest());
            }

            return(Ok());
        }
        public bool UpdateVehicle(
            UpdateVehicleCommandParameter updateVehiclesCommandParameters)
        {
            if (updateVehiclesCommandParameters.Speed < 0)
            {
                return(false);
            }
            if (updateVehiclesCommandParameters.EngineTemperature < 0)
            {
                return(false);
            }
            if (updateVehiclesCommandParameters.RadiatorPressure < 0)
            {
                return(false);
            }
            if (updateVehiclesCommandParameters.FuelRemaining < 0)
            {
                return(false);
            }

            var updatedVehicle = new Vehicle(
                updateVehiclesCommandParameters.VehicleId,
                updateVehiclesCommandParameters.Speed,
                updateVehiclesCommandParameters.Latitude,
                updateVehiclesCommandParameters.Longitude,
                updateVehiclesCommandParameters.EngineTemperature,
                updateVehiclesCommandParameters.RadiatorPressure,
                updateVehiclesCommandParameters.FuelRemaining);

            try
            {
                _vehicleRepository.UpdateVehicle(updatedVehicle);
            }
            catch (Exception)
            {
                return(false);
            }

            return(true);
        }
        public void UpdateVehicle_ReturnsFalseIfExceptionIsThrownFromRepository()
        {
            var updatedVehicle = new UpdateVehicleCommandParameter(
                Guid.NewGuid(),
                50,
                123.32,
                23.4,
                66,
                54.67,
                30);

            _vehicleRepositoryMock.Setup(x => x.UpdateVehicle(It.IsAny <Vehicle>()))
            .Callback <Vehicle>(x =>
            {
                throw new ArgumentException();
            });

            var updateSuccessful = _setVehicleCommandHandler.UpdateVehicle(updatedVehicle);

            _vehicleRepositoryMock.Verify(x => x.UpdateVehicle(It.IsAny <Vehicle>()), Times.Once());
            updateSuccessful.Should().BeFalse();
        }
        public void UpdateVehicle_SuccessfullyUpdatesVehicleInRepository()
        {
            var updatedVehicle = new UpdateVehicleCommandParameter(
                Guid.NewGuid(),
                50,
                123.32,
                23.4,
                66,
                54.67,
                30);

            var isSuccessful = _setVehicleCommandHandler.UpdateVehicle(updatedVehicle);

            _vehicleRepositoryMock.Verify(x => x.UpdateVehicle(It.Is <Vehicle>(x =>
                                                                               x.VehicleId == updatedVehicle.VehicleId &&
                                                                               x.Speed == updatedVehicle.Speed &&
                                                                               x.Latitude == updatedVehicle.Latitude &&
                                                                               x.Longitude == updatedVehicle.Longitude &&
                                                                               x.EngineTemperature == updatedVehicle.EngineTemperature &&
                                                                               x.RadiatorPressure == updatedVehicle.RadiatorPressure &&
                                                                               x.FuelRemaining == updatedVehicle.FuelRemaining)), Times.Once());

            isSuccessful.Should().BeTrue();
        }