public void EmptyGuidValue_TrowsInvalidEngineIdException()
{
var stubCommand = GetValidUpdateEngineCommand();
stubCommand.Id = new Guid();
Assert.Throws <InvalidEngineIdException>(() => updateEngineCommandValidator.Validate(stubCommand));
}
public void EmptyGuidIdValue_ThrowsInvalidManufacturerIdException()
{
var stubCommand = GetValidAddManufacturerCommand();
stubCommand.Id = new Guid();
Assert.Throws <InvalidManufacturerIdException>(() => addManufacturerValidator.Validate(stubCommand));
}
public void EmptyGuidIdValue_ThrowsInvalidVehicleIdException()
{
var stubCommand = GetValidDeleteVehicleCommand();
stubCommand.Id = new Guid();
Assert.Throws <InvalidVehicleIdException>(() => deleteVehicleValidator.Validate(stubCommand));
}
public void EmptyConsumptionReportId_ThrowsInvalidConsumptionReportId()
{
var stubCommand = GetValidCeleteConsumptionReportCommand();
stubCommand.Id = new Guid();
Assert.Throws <InvalidConsumptionReportIdException>(() => deleteConsumtionReportValidator.Validate(stubCommand));
}
public void FuelTypeValueOutOfEnumRange_ThrowsInvalidFuelTypeException()
{
var stubCommand = GetStubValidCommand();
stubCommand.FuelType = (FuelType)3;
Assert.Throws <FuelTypeOutOfRangeException>(() => addEngineCommandValidator.Validate(stubCommand));
}
public void Validate_WithNullArgs_ShouldThrowArgumentNullException()
{
// Arrange
// Act
Action action = () => _sut.Validate(CommandType.CreateNewSheet, null, null);
// Assert
action.Should().ThrowExactly <ArgumentNullException>();
}
public void CommandValid_EngineDeleted()
{
var engineId = InsertEngineToDatabase();
var deleteEngineCommand = new DeleteEngine(engineId);
A.CallTo(() => deleteEngineValidator.Validate(deleteEngineCommand)).DoesNothing();
deleteEngineHandler.Handle(deleteEngineCommand);
context.SaveChanges();
var result = context.Engine.FirstOrDefault(e => e.Id == engineId);
A.CallTo(() => deleteEngineValidator.Validate(deleteEngineCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.Null(result);
}
private async ValueTask <ICommandResult> Process <TCommand>(TCommand command, CancellationToken cancellationToken = default) where TCommand : ICommand
{
var commandResult = new CommandResult();
try
{
await _permissionValidator.Validate(command, cancellationToken).ConfigureAwait(false);
await _validation.Validate(command, cancellationToken).ConfigureAwait(false);
var concreteCommand = _mapper.CreateConcreteObject(command);
var handler = _resolveHandler.ResolveHandler <ICommandHandler <TCommand> >();
commandResult = (CommandResult)await handler.Handle(concreteCommand).ConfigureAwait(false);
await _eventPublisher.Publish(commandResult.Events, cancellationToken).ConfigureAwait(false);
}
catch (PermissionValidationException ex)
{
_logger.Error(ex, "Error command permission validation");
commandResult.Exception = ex;
}
catch (ValidationException ex)
{
_logger.Error(ex, "Error command validation");
commandResult.Exception = ex;
}
catch (Exception ex)
{
_logger.Error(ex, "Command was not successful");
commandResult.Exception = ex;
}
return(commandResult);
}
public ActionResult <Issue> Create(CreateIssueCommand createIssueCommand)
{
_createIssueCommandValidator.Validate(createIssueCommand);
var createdIssueId = _createIssueOperationService.Create(createIssueCommand);
return(Get(createdIssueId));
}
public async Task <TResponse> Handle(TCommand request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next)
{
if (request == null)
{
throw new ArgumentNullException($"{typeof(TCommand)} is null");
}
if (_commandValidator == null)
{
return(await next());
}
if ((_commandValidator is CommandValidator <TCommand>) == false)
{
throw new ArgumentException($"{typeof(ICommandValidator<TCommand>)} is not CommandValidator");
}
var validationResult = _commandValidator.Validate(request);
if (validationResult.IsValid == false)
{
//TODO
throw new CommandValidationException(validationResult);
// throw new CommandValidationException($"CommandException: {validationResult.Errors[0].ErrorMessage}");
}
return(await next());
}
public void Handle(DeleteVehicle command)
{
commandValidator.Validate(command);
var vehicleToDelete = unitOfWork.Context.Vehicle.Single(s => s.Id == command.Id);
var consumptionReportsToDelete = unitOfWork.Context.ConsumptionReport.Where(c => c.VehicleId == vehicleToDelete.Id);
unitOfWork.Context.ConsumptionReport.RemoveRange(consumptionReportsToDelete);
var fuelSummaryToDelete = unitOfWork.Context.FuelSummary.Where(f => f.VehicleId == vehicleToDelete.Id).SingleOrDefault();
if (fuelSummaryToDelete != null)
{
unitOfWork.Context.FuelSummary.Remove(fuelSummaryToDelete);
}
if (vehicleToDelete != null)
{
unitOfWork.Context.Vehicle.Remove(vehicleToDelete);
}
else
{
throw new VehicleNotFoundException(command.Id);
}
}
public void Handle(UpdateVehicle command)
{
commandValidator.Validate(command);
var vehicleToUpdate = unitOfWork.Context.Vehicle.Single(v => v.Id == command.Id);
if (vehicleToUpdate == null)
{
throw new VehicleNotFoundException(command.Id);
}
if (command.EngineId.HasValue)
{
var selectedEngine = unitOfWork.Context.Engine.FirstOrDefault(e => e.Id == command.EngineId);
if (selectedEngine == null)
{
throw new EngineNotFoundException(command.EngineId.Value);
}
vehicleToUpdate.ProductionYear = command.ProductionYear;
vehicleToUpdate.EngineId = command.EngineId;
}
vehicleToUpdate.ProductionYear = command.ProductionYear;
}
public void CommandValid_VehicleDeleted()
{
var modelId = InsertModelToDatabase();
var vehicleId = InsertVehicleToDatabase(modelId);
var deleteVehicleCommand = new DeleteVehicle(vehicleId);
A.CallTo(() => deleteVehicleValidator.Validate(deleteVehicleCommand)).DoesNothing();
deleteVehicleHandler.Handle(deleteVehicleCommand);
context.SaveChanges();
var result = context.Vehicle.FirstOrDefault(m => m.Id == deleteVehicleCommand.Id);
A.CallTo(() => deleteVehicleValidator.Validate(deleteVehicleCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.Null(result);
}
public void CommandValid_ManufacturerDeleted()
{
var manufacturerId = InsertManufacturerToDatabase();
var modelId = InsertModelToDatabase(manufacturerId);
var deleteModelNameCommand = new DeleteModelName(manufacturerId, modelId);
A.CallTo(() => deleteModelNameValidator.Validate(deleteModelNameCommand)).DoesNothing();
deleteModelNameHandler.Handle(deleteModelNameCommand);
context.SaveChanges();
var result = context.ModelName.FirstOrDefault(m => m.Id == deleteModelNameCommand.Id);
A.CallTo(() => deleteModelNameValidator.Validate(deleteModelNameCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.Null(result);
}
public void Handle(TCommand command)
{
// Validate command, should throw ArgumentException if invalid
validator.Validate(command);
commandHandler.Handle(command);
}
public void Handle(string line)
{
var(type, args) = _parser.Parse(line, SimpleHandler.LineSeparator);
_validator.Validate(type, args, this.CurrentSheet);
var command = CommandFactory.Create(type, args, this.CurrentSheet);
this.CurrentSheet = command.Execute();
}
public void CommandValid_ManufacturerUpdated()
{
var manufacturerId = InsertManufacturerToDatabase();
var updateManufacturerCommand = new UpdateManufacturer(manufacturerId, "UpdatedName");
A.CallTo(() => updateManufacturerValidator.Validate(updateManufacturerCommand)).DoesNothing();
updateManufacturerHandler.Handle(updateManufacturerCommand);
context.SaveChanges();
var result = context.Manufacturer.FirstOrDefault(m => m.Id == updateManufacturerCommand.Id);
A.CallTo(() => updateManufacturerValidator.Validate(updateManufacturerCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.NotNull(result);
Assert.Equal(result.Id, updateManufacturerCommand.Id);
Assert.Equal(result.Name, updateManufacturerCommand.Name);
}
public void EmptyIdGuidValue_ThrowsInvalidCalculateFuelConsumptionIdException()
{
var stubCommand = GetValidCalculateFuelConsumptionCommand();
stubCommand.Id = new Guid();
Assert.Throws<InvalidCalculateFuelConsumptionIdException>(() => calculateFuelConsumptionValidator.Validate(stubCommand));
}
public void CommandValid_ModelNameAdded()
{
var manufacturerId = InsertManufacturerToDatabase();
var addModelNameCommand = new AddModelName(manufacturerId, expectedModelName);
A.CallTo(() => addModelNameValidator.Validate(addModelNameCommand)).DoesNothing();
addModelNameHandler.Handle(addModelNameCommand);
context.SaveChanges();
var result = context.ModelName.FirstOrDefault(m => m.Id == addModelNameCommand.Id);
A.CallTo(() => addModelNameValidator.Validate(addModelNameCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.NotNull(result);
Assert.Equal(addModelNameCommand.Id, result.Id);
Assert.Equal(expectedModelName, result.Name);
Assert.Equal(manufacturerId, result.ManufacturerId);
}
public void CommandValid_VehicleAdded()
{
var modelId = InsertModelToDatabase();
var userId = InsertUserToDatabase();
var addVehicleCommand = new AddVehicle(modelId, userId);
A.CallTo(() => addVehicleValidator.Validate(addVehicleCommand)).DoesNothing();
addVehicleHandler.Handle(addVehicleCommand);
context.SaveChanges();
var result = context.Vehicle.FirstOrDefault(v => v.Id == addVehicleCommand.Id);
A.CallTo(() => addVehicleValidator.Validate(addVehicleCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.NotNull(result);
Assert.Equal(addVehicleCommand.Id, result.Id);
Assert.Equal(addVehicleCommand.ModelNameId, result.ModelNameId);
}
public void CommandValid_EngineUpdated()
{
var vehicleId = InsertVehicleToDatabase();
var engineId = InsertEngineToDatabase();
var updateVehicleCommand = new UpdateVehicle(vehicleId, 2010, engineId);
A.CallTo(() => updateVehicleValidator.Validate(updateVehicleCommand)).DoesNothing();
updateVehicleHandler.Handle(updateVehicleCommand);
context.SaveChanges();
var result = context.Vehicle.FirstOrDefault(v => v.Id == updateVehicleCommand.Id);
A.CallTo(() => updateVehicleValidator.Validate(updateVehicleCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.NotNull(result);
Assert.Equal(result.Id, updateVehicleCommand.Id);
Assert.Equal(result.ProductionYear, updateVehicleCommand.ProductionYear);
Assert.Equal(result.EngineId, updateVehicleCommand.EngineId);
}
private static bool ValidateCommand(CommandHandlerRequest request)
{
Contract.Requires(request != null);
Contract.Requires(request.Configuration != null);
ICommandValidator validator = request.Configuration.Services.GetCommandValidator();
bool valid = validator.Validate(request);
return(valid);
}
public void Handle(UpdateManufacturer command)
{
commandValidator.Validate(command);
var manufacturerToUpdate = unitOfWork.Context.Manufacturer.Single(e => e.Id == command.Id);
manufacturerToUpdate.Name = command.Name;
unitOfWork.Context.Entry(manufacturerToUpdate).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
}
public void Handle(DeleteConsumptionReport command)
{
commandValidator.Validate(command);
var reportToDelete = unitOfWork.Context.ConsumptionReport.Where(r => r.VehicleId == command.VehicleId).SingleOrDefault(r => r.Id == command.Id);
if (reportToDelete == null)
{
throw new ConsumptionReportNotFoundException(command.VehicleId, command.Id);
}
var fuelSummaryToUpdate = unitOfWork.Context.FuelSummary.SingleOrDefault(f => f.VehicleId == reportToDelete.VehicleId);
if (fuelSummaryToUpdate == null)
{
throw new FuelSummaryNotFoundException(reportToDelete.VehicleId);
}
if (reportToDelete.Units == fuelSummaryToUpdate.Units)
{
fuelSummaryToUpdate.DistanceDriven -= reportToDelete.Distance;
fuelSummaryToUpdate.FuelBurned -= reportToDelete.FuelBurned;
fuelSummaryToUpdate.MoneySpent -= (reportToDelete.PricePerUnit * reportToDelete.FuelBurned);
switch (fuelSummaryToUpdate.Units)
{
case Units.Metric:
fuelSummaryToUpdate.AverageConsumption = (fuelSummaryToUpdate.FuelBurned * 100) / fuelSummaryToUpdate.DistanceDriven;
break;
case Units.Imperial:
fuelSummaryToUpdate.AverageConsumption = fuelSummaryToUpdate.DistanceDriven / fuelSummaryToUpdate.FuelBurned;
break;
}
}
else
{
if (reportToDelete.Units == Units.Imperial && fuelSummaryToUpdate.Units == Units.Metric)
{
fuelSummaryToUpdate.DistanceDriven -= reportToDelete.Distance * UnitsConverters.MilesToKilometersConst;
fuelSummaryToUpdate.FuelBurned -= reportToDelete.FuelBurned * UnitsConverters.GalonsToLitresConst;
fuelSummaryToUpdate.AverageConsumption = (fuelSummaryToUpdate.FuelBurned * 100) / fuelSummaryToUpdate.DistanceDriven;
}
if (reportToDelete.Units == Units.Metric && fuelSummaryToUpdate.Units == Units.Imperial)
{
fuelSummaryToUpdate.DistanceDriven -= reportToDelete.Distance * UnitsConverters.KilometersToMilesConst;
fuelSummaryToUpdate.FuelBurned -= reportToDelete.FuelBurned * UnitsConverters.LitresToGalonsConst;
fuelSummaryToUpdate.AverageConsumption = fuelSummaryToUpdate.DistanceDriven / fuelSummaryToUpdate.FuelBurned;
}
}
unitOfWork.Context.Entry(reportToDelete).State = Microsoft.EntityFrameworkCore.EntityState.Deleted;
unitOfWork.Context.Entry(fuelSummaryToUpdate).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
}
public async Task HandleAsync(T command, CancellationToken cancellationToken)
{
var results = _commandValidator.Validate(command);
if (!results.IsValid)
{
var failures = results.Errors.Where(f => f != null).ToList();
throw new ValidationException(failures);
}
await _decoratee.HandleAsync(command, cancellationToken);
}
public void Handle(T command)
{
var results = _validator.Validate(command);
if (!results.IsValid)
{
throw new ValidationException(results.Errors);
}
_decoratee.Handle(command);
}
public void CommandValid_EngineAdded()
{
var addEngineCommand = new AddEngine("Test", 10, 10, 4, 10, FuelType.Diesel);
A.CallTo(() => addEngineValidator.Validate(addEngineCommand)).DoesNothing();
addEngineHandler.Handle(addEngineCommand);
context.SaveChanges();
var result = context.Engine.FirstOrDefault(e => e.Id == addEngineCommand.Id);
A.CallTo(() => addEngineValidator.Validate(addEngineCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.NotNull(result);
Assert.Equal(result.Id, addEngineCommand.Id);
Assert.Equal(result.Name, addEngineCommand.Name);
Assert.Equal(result.Power, addEngineCommand.Power);
Assert.Equal(result.Torque, addEngineCommand.Torque);
Assert.Equal(result.Cylinders, addEngineCommand.Cylinders);
Assert.Equal(result.Displacement, addEngineCommand.Displacement);
Assert.Equal(result.FuelType, addEngineCommand.FuelType);
}
public void CommandValid_EngineUpdated()
{
var engineId = InsertEngineToDatabase();
var updateEngineCommand = new UpdateEngine(engineId, "Updated", power: 150, torque: 300, cylinders: 6, displacement: 3000);
A.CallTo(() => updateEngineValidator.Validate(updateEngineCommand)).DoesNothing();
updateEngineHandler.Handle(updateEngineCommand);
context.SaveChanges();
var result = context.Engine.FirstOrDefault(e => e.Id == updateEngineCommand.Id);
A.CallTo(() => updateEngineValidator.Validate(updateEngineCommand)).MustHaveHappened(Repeated.Exactly.Once);
Assert.NotNull(result);
Assert.Equal(result.Id, updateEngineCommand.Id);
Assert.Equal(result.Name, updateEngineCommand.Name);
Assert.Equal(result.Power, updateEngineCommand.Power);
Assert.Equal(result.Torque, updateEngineCommand.Torque);
Assert.Equal(result.Cylinders, updateEngineCommand.Cylinders);
Assert.Equal(result.Displacement, updateEngineCommand.Displacement);
}
public void Handle(DeleteModelName command)
{
commandValidator.Validate(command);
var modelToDelete = unitOfWork.Context.ModelName.Where(m => m.ManufacturerId == command.ManufacturerId).Single(m => m.Id == command.Id);
if (modelToDelete == null)
{
throw new ModelNotFoundException(command.ManufacturerId, command.Id);
}
unitOfWork.Context.Entry(modelToDelete).State = Microsoft.EntityFrameworkCore.EntityState.Deleted;
}
public void Handle(DeleteManufacturer command)
{
commandValidator.Validate(command);
var manufacturerToDelete = unitOfWork.Context.Manufacturer.Single(m => m.Id == command.Id);
var modelsToDelete = unitOfWork.Context.ModelName.Where(m => m.ManufacturerId == manufacturerToDelete.Id);
unitOfWork.Context.Entry(manufacturerToDelete).State = Microsoft.EntityFrameworkCore.EntityState.Deleted;
foreach (var model in modelsToDelete)
{
unitOfWork.Context.Entry(model).State = Microsoft.EntityFrameworkCore.EntityState.Deleted;
}
}
