public void AddCallsAddFromRepository()
{
var testItem = OrderObjectMother.CreateOrderWithItems(1);
OrderService.Add(testItem);
OrderRepositoryMock.Verify(x => x.Add(testItem), Times.Once());
}
public void CheckCreatingOrderWithoutClient()
{
// Arrange
DeliveryOrder order = OrderObjectMother.CreateOrder();
// Act
DeliveryOrder createdOrder = deliveryService.CreateNewOrder(order.size, order.weight, null);
}
public void UpdateCallsUpdateFromRepository()
{
var order = OrderObjectMother.CreateEmptyOrderWithNoId();
OrderService.Add(order);
order.CustomerId = 2137;
OrderService.Update(order);
OrderRepositoryMock.Verify(x => x.Update(order));
}
public Order CreateOrder(string username)
{
var transaction = _session.BeginTransaction();
Order order = OrderObjectMother.CreateOrder(username);
User user = us.CreateUser(UserObjectMother.CreateCustomerWithAddress(username));
order.Customer = user;
order = os.CreateOrder(order);
transaction.Commit();
return(order);
}
public void CheckAddProductToOrder()
{
// Arrange
var order = OrderObjectMother.CreateOrderWithNoItems();
var orderItem = OrderObjectMother.CreateOrderItemWith2Quantitity(1);
order.OrderItems.Add(orderItem);
// Assert
Assert.IsTrue(order.OrderItems.Count == 1);
}
public void CheckChoosePaymentType()
{
Mock <IOrderRepository> repositoryMock = new Mock <IOrderRepository>();
ShopService ss = new ShopService(repositoryMock.Object);
var order = OrderObjectMother.CreateOrderWithNoItems();
string paymentType = "newPaymentType";
ss.ChoosePaymentType(order, paymentType);
Assert.AreEqual(order.PaymentType, paymentType);
}
public void CheckAddingOrderToTheDriver()
{
//Arrange
DeliveryOrder order = OrderObjectMother.CreateOrder();
Driver driver = DriverObjectMother.CreateDriver();
//Act
deliveryService.AddOrderToDriver(order, driver);
//Assert
Assert.AreSame(driver, order.driver);
Assert.IsTrue(driver.orders.Contains(order));
}
public void CheckRetrievingFromDatabaseWhenThereIsNoSuchOrder()
{
// Arrange
DeliveryOrder order = OrderObjectMother.CreateReceivedOrder();
repository.InsertOrder(order);
//Act
DeliveryOrder receivedOrder = repository.RetrieveOrder(order.ID + 1);
//Assert
Assert.IsNull(receivedOrder);
}
public void CheckInsertMethodCalled()
{
// Arrange
Mock <IOrderRepository> repositoryMock = new Mock <IOrderRepository>();
IOrderService service = new OrderService(repositoryMock.Object);
var order = OrderObjectMother.CreateOrder();
// Act
service.Insert(order);
// Assert
repositoryMock.Verify(k => k.Insert(order), Times.Once());
}
public void CheckAddToOrder()
{
ShopService ss = new ShopService();
Product product = ProductObjectMother.CreateProductWithNoPropertiesAndNoBrand();
Order order = OrderObjectMother.CreateOrderWithNoItems();
int quantitity = 2;
var orderItems = ss.AddToOrder(product, order, quantitity);
Assert.AreEqual(orderItems.Product, product);
Assert.AreEqual(orderItems.Quantitity, quantitity);
Assert.AreEqual(order.OrderItems.Contains(orderItems), true);
}
public void CheckRetrievingFromDatabase()
{
// Arrange
DeliveryOrder order = OrderObjectMother.CreateReceivedOrder();
repository.InsertOrder(order);
//Act
DeliveryOrder receivedOrder = repository.RetrieveOrder(order.ID);
//Assert
Assert.AreEqual(order.ID, receivedOrder.ID);
Assert.AreEqual(order.size, receivedOrder.size);
Assert.AreEqual(order.weight, receivedOrder.weight);
Assert.AreEqual(order.receiving_date.Date, receivedOrder.receiving_date.Date);
Assert.AreEqual(order.posting_date.Date, receivedOrder.posting_date.Date);
}
public void CheckDeletingFromDatabase()
{
// Arrange
DeliveryOrder firstOrder = OrderObjectMother.CreateReceivedOrder();
DeliveryOrder secondOrder = OrderObjectMother.CreateReceivedOrder();
repository.InsertOrder(firstOrder);
repository.InsertOrder(secondOrder);
//Act
repository.DeleteOrder(firstOrder);
//Assert
ICollection <DeliveryOrder> orders = repository.RetrieveAllOrders();
Assert.AreEqual(1, orders.Count);
}
public void CheckCreatingOrder()
{
// Arrange
Client client = ClientObjectMother.CreateClient();
DeliveryOrder order = OrderObjectMother.CreateOrder();
deliveryFactoryMock.Setup(factory =>
factory.CreateOrder(order.size, order.weight))
.Returns(order);
// Act
DeliveryOrder createdOrder = deliveryService.CreateNewOrder(order.size, order.weight, client);
// Assert
orderRepositoryMock.Verify(r => r.InsertOrder(order), Times.Once());
Assert.AreSame(order, createdOrder);
Assert.AreSame(order.client, client);
Assert.IsTrue(client.orders.Contains(order));
}
public void CheckAddingToDatabase()
{
// Arrange
DeliveryOrder order = OrderObjectMother.CreateReceivedOrder();
// Act
repository.InsertOrder(order);
//Assert
ICollection <DeliveryOrder> orders = repository.RetrieveAllOrders();
Assert.AreEqual(1, orders.Count);
DeliveryOrder receivedOrder = orders.ElementAt(0);
Assert.AreEqual(order.ID, receivedOrder.ID);
Assert.AreEqual(order.size, receivedOrder.size);
Assert.AreEqual(order.weight, receivedOrder.weight);
Assert.AreEqual(order.receiving_date.Date, receivedOrder.receiving_date.Date);
Assert.AreEqual(order.posting_date.Date, receivedOrder.posting_date.Date);
}
public void CheckGettingUnreadyOrders()
{
// Arrange
DeliveryOrder firstUnreceivedOrder = OrderObjectMother.CreateOrder();
DeliveryOrder firstReadyOrder = OrderObjectMother.CreateReadyOrder();
DeliveryOrder secondUnreceivedOrder = OrderObjectMother.CreateOrder();
DeliveryOrder secondReadyOrder = OrderObjectMother.CreateReadyOrder();
List <DeliveryOrder> orders = new List <DeliveryOrder> {
firstReadyOrder, firstUnreceivedOrder, secondReadyOrder, secondUnreceivedOrder
};
orderRepositoryMock.Setup(repository =>
repository.RetrieveAllOrders())
.Returns(orders);
// Act
ICollection <DeliveryOrder> returnedOrders = deliveryService.GetNotReadyOrders();
// Assert
Assert.AreEqual(2, returnedOrders.Count);
Assert.IsTrue(returnedOrders.Contains(firstUnreceivedOrder));
Assert.IsTrue(returnedOrders.Contains(secondUnreceivedOrder));
}
