public async void DeliverTheVehicleResultVehicleIsDelivered()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var driver = new Driver {
Id = commonId++
};
var order = new Order {
Id = commonId++, DriverId = driver.Id
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.VehicleIsLoaded
};
suite.DriverServiceMock
.Setup(m => m.IsExist(driver.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await suite.OrderStateService.DeliverTheVehicle(order.Id, driver.Id);
suite.OrderStateRepositoryMock
.Verify(m => m.Add(It.Is <OrderState>(
s => s.OrderId.Equals(order.Id) &&
s.Status.Equals(OrderStatus.VehicleIsDelivered))));
}
public async void LoadTheVehicleWhenOrderStatusIsUnsuitable()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var driver = new Driver {
Id = commonId++
};
var order = new Order {
Id = commonId++, DriverId = driver.Id
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.WentToCustomer
};
suite.DriverServiceMock
.Setup(m => m.IsExist(driver.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await Assert.ThrowsAsync <OrderStatusException>(() => suite.OrderStateService.LoadTheVehicle(order.Id, driver.Id));
}
public async void ConfirmByDriver()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var driver = new Driver {
Id = commonId++
};
var order = new Order {
Id = commonId++, DriverId = driver.Id
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.AssignedDriver
};
suite.DriverServiceMock
.Setup(m => m.IsExist(driver.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await suite.OrderStateService.ConfirmByDriver(order.Id, driver.Id);
suite.OrderStateRepositoryMock
.Verify(m => m.Add(It.Is <OrderState>(
s => s.OrderId.Equals(order.Id) &&
s.Status.Equals(OrderStatus.ConfirmedByDriver))));
}
public async void ArriveAtLoading()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var driver = new Driver {
Id = commonId++
};
var order = new Order {
Id = commonId++, DriverId = driver.Id
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.WentToCustomer
};
suite.DriverServiceMock
.Setup(m => m.IsExist(driver.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await suite.OrderStateService.ArriveAtLoadingPlace(order.Id, driver.Id);
suite.OrderStateRepositoryMock
.Verify(m => m.Add(It.Is <OrderState>(
s => s.OrderId.Equals(order.Id) &&
s.Status.Equals(OrderStatus.ArrivedAtLoadingPlace))));
}
public async void AssignToDriverWhenAnotherDispatcher()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var orderDispatcher = new Dispatcher {
Id = commonId++
};
var anotherDispatcherId = commonId++;
var driver = new Driver {
Id = commonId++
};
var order = new Order {
Id = commonId++, DispatcherId = orderDispatcher.Id
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.AssignedDispatcher
};
suite.DispatcherServiceMock
.Setup(m => m.IsExist(It.IsAny <int>()))
.ReturnsAsync(true);
suite.DriverServiceMock
.Setup(m => m.IsExist(driver.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await Assert.ThrowsAsync <AccessViolationException>(() => suite.OrderStateService.AssignToDriver(order.Id, anotherDispatcherId, driver.Id));
}
public async void AssignToDriverWhenDispatcherDoesNotFound()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var driver = new Driver {
Id = commonId++
};
var notExistingDispatcher = commonId++;
var order = new Order {
Id = commonId++, DispatcherId = commonId++
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.AssignedDispatcher
};
suite.DriverServiceMock
.Setup(m => m.IsExist(driver.Id))
.ReturnsAsync(true);
suite.DispatcherServiceMock
.Setup(m => m.IsExist(notExistingDispatcher))
.ReturnsAsync(false);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await Assert.ThrowsAsync <EntityNotFoundException>("Dispatcher", () => suite.OrderStateService.AssignToDriver(order.Id, notExistingDispatcher, driver.Id));
}
public async void AssignOrderToDispatcher()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var dispatcher = new Dispatcher {
Id = commonId++
};
var order = new Order {
Id = commonId++
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.Accepted
};
suite.DispatcherServiceMock
.Setup(m => m.IsExist(dispatcher.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await suite.OrderStateService.AssignToDispatcher(order.Id, dispatcher.Id);
suite.OrderStateRepositoryMock
.Verify(m => m.Add(It.Is <OrderState>(
s => s.OrderId.Equals(order.Id) &&
s.Status.Equals(OrderStatus.AssignedDispatcher))));
suite.OrderServiceMock
.Verify(m => m.AssignDispatcher(order.Id, dispatcher.Id));
}
public async void AssignToDriverWnenOrderStatusIsUnsuitable()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var dispatcher = new Dispatcher {
Id = commonId++
};
var driver = new Driver {
Id = commonId++
};
var order = new Order {
Id = commonId++, DispatcherId = dispatcher.Id
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.New
};
suite.DispatcherServiceMock
.Setup(m => m.IsExist(dispatcher.Id))
.ReturnsAsync(true);
suite.DriverServiceMock
.Setup(m => m.IsExist(driver.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await Assert.ThrowsAsync <OrderStatusException>(() => suite.OrderStateService.AssignToDriver(order.Id, dispatcher.Id, driver.Id));
}
public async void Trade()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var order = new Order {
Id = commonId++
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.ReadyForTrade
};
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await suite.OrderStateService.Trade(order.Id);
suite.OrderStateRepositoryMock
.Verify(m => m.Add(It.Is <OrderState>(
s => s.OrderId.Equals(order.Id) &&
s.Status.Equals(OrderStatus.SentToTrading))));
}
public async void ReadyToTradeWhenModeratorIsOther()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var moderator = new Moderator {
Id = commonId++
};
var order = new Order {
Id = commonId++, ModeratorId = -1
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.Accepted
};
suite.ModeratorServiceMock
.Setup(m => m.IsExist(moderator.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await Assert.ThrowsAsync <AccessViolationException>(() => suite.OrderStateService.ReadyToTrade(order.Id, moderator.Id));
}
public async void ReadyToTrade()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var moderator = new Moderator {
Id = commonId++
};
var order = new Order {
Id = commonId++, ModeratorId = moderator.Id
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.Accepted
};
suite.ModeratorServiceMock
.Setup(m => m.IsExist(moderator.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await suite.OrderStateService.ReadyToTrade(order.Id, moderator.Id);
suite.OrderStateRepositoryMock
.Verify(m => m.Add(It.Is <OrderState>(
s => s.OrderId.Equals(order.Id) &&
s.Status.Equals(OrderStatus.ReadyForTrade))));
}
public async void GetStatesWithNewCurentStatus()
{
var suite = new OrderStateServiceTestSuite();
var status = OrderStatus.New;
var newStates = await suite.OrderStateService.GetByCurrentStatus(status);
suite.OrderStateRepositoryMock
.Verify(m => m.GetStatesByCurrentStatus(status));
}
public async void GetAcceptedStatesCount()
{
var suite = new OrderStateServiceTestSuite();
var status = OrderStatus.Accepted;
var count = await suite.OrderStateService.GetCountByCurrentStatus(status);
suite.OrderStateRepositoryMock
.Verify(m => m.GetCountStatesByCurrentStatus(status));
}
public async void DeliverTheVehicleWhenDriverDoesNotExist()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var notExistingDriverId = commonId++;
var order = new Order {
Id = commonId++, DriverId = notExistingDriverId
};
suite.DriverServiceMock
.Setup(m => m.IsExist(1))
.ReturnsAsync(false);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
await Assert.ThrowsAsync <EntityNotFoundException>("Driver", () => suite.OrderStateService.DeliverTheVehicle(order.Id, notExistingDriverId));
}
public async void DeliverTheVehicleWhenAnotherDriver()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var driver = new Driver {
Id = commonId++
};
var order = new Order {
Id = commonId++, DriverId = commonId++
};
suite.DriverServiceMock
.Setup(m => m.IsExist(driver.Id))
.ReturnsAsync(true);
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
await Assert.ThrowsAsync <AccessViolationException>(() => suite.OrderStateService.DeliverTheVehicle(order.Id, driver.Id));
}
public async void TradeWnenOrderStatusIsUnsuitable()
{
var commonId = 1;
var suite = new OrderStateServiceTestSuite();
var order = new Order {
Id = commonId++
};
var currentState = new OrderState {
Id = commonId++, OrderId = order.Id, Status = OrderStatus.Accepted
};
suite.OrderServiceMock
.Setup(m => m.Get(order.Id))
.ReturnsAsync(order);
suite.OrderStateRepositoryMock
.Setup(m => m.GetCurrentState(order.Id))
.ReturnsAsync(currentState);
await Assert.ThrowsAsync <OrderStatusException>(() => suite.OrderStateService.Trade(order.Id));
}