public void TrySetPrice_ToManyPeanuts()
{
double number;
bool state = OrderValidator.TrySetPrice("1.999", out number);
Assert.IsFalse(state);
}
public void TrySetPrice_NegativePrice()
{
double number;
bool state = OrderValidator.TrySetPrice("-1.99", out number);
Assert.IsFalse(state);
}
public void TrySetPrice_invalidCharacter()
{
double number;
bool state = OrderValidator.TrySetPrice("v", out number);
Assert.IsFalse(state);
}
public void TrySetPrice_emptyString()
{
double number;
bool state = OrderValidator.TrySetPrice(" ", out number);
Assert.IsFalse(state);
}
public void TrySetQuantityID_emptyString()
{
int number;
bool state = OrderValidator.TrySetQuantityID(" ", out number);
Assert.IsFalse(state);
}
public void TrySetQuantityID_negativeQuantity()
{
int number;
bool state = OrderValidator.TrySetQuantityID("-4", out number);
Assert.IsFalse(state);
}
public void TrySetQuantityID_invalidCharacter()
{
int number;
bool state = OrderValidator.TrySetQuantityID("x", out number);
Assert.IsFalse(state);
}
public void TrySetRequestID_emptyLong()
{
long number;
bool state = OrderValidator.TrySetRequestID("", out number);
Assert.IsFalse(state);
}
public void EditOrder(Order order, string clientId)
{
IValidator validator = OrderValidator.CreateValidator(order, true);
validator.Validate();
repository.EditOrder(order, clientId);
}
public OrderDTO AddOrder(OrderDTO orderDto)
{
var order = OrderMapper.DtoToDomain(orderDto);
var errorMessages = new List <string>();
if (!OrderValidator.Validate(order, unitOfWork, ref errorMessages))
{
throw new InvalidObjectException("Order", orderDto, errorMessages);
}
try
{
var customer = unitOfWork.CustomerRepository.GetById(order.CustomerId);
order.CustomerName = customer.CustomerName;
order.CustomerNumber = customer.CustomerNumber;
unitOfWork.OrderRepository.Add(order);
unitOfWork.Commit();
return(OrderMapper.DomainToDto(order));
}
catch (Exception exception)
{
throw new Exception("An exception occured adding customer: ", exception);
}
}
public IActionResult SessionCartOrder(OrderViewModel order)
{
var validator = new OrderValidator();
var validationResult = validator.Validate(order);
if (!validationResult.IsValid)
{
var model = _orderService.PrepareSessionCartOrder();
foreach (var error in validationResult.Errors)
{
model.Errors.Add(error.ToString());
}
return(View(model));
}
int orderId = _orderService.AddOrder(order);
_shoppingCartService.Cart.Lines.Clear();
ViewData["orderId"] = orderId;
return(View("Success"));
}
public Result <Order> CreateOrder(OrderDTO orderDTO)
{
ICollection <OrderDetail> orderDetails = orderDTO.OrderDetails.Select(od => new OrderDetail(od.Product, od.Price, od.Count)).ToList();
Order order = new Order(orderDetails);
//string failureMesasge = order.IsValid();
OrderValidator orderValidator = new OrderValidator();
var validationResult = orderValidator.Validate(order);
//if (failureMesasge == string.Empty)
if (validationResult.IsValid)
{
try
{
OrdersDbSet.Add(order);
_context.SaveChanges();
return(Result <Order> .Ok(order));
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(Result.Fail <Order>(ex.Message));
}
}
else
{
return(Result.Fail <Order>(string.Join(" ", validationResult.Errors)));
}
//return Result.Fail<Order>(failureMesasge);
}
public void IsNewMinimalOrderTotalCalculatedCorrectly_True()
{
double expectedTotal = ShopInitializer.MerchandiseList[0].Price;
OrderValidator.CalcTotal(minimalOrder);
Assert.AreEqual(expectedTotal, minimalOrder.OrderTotal);
}
public OrderValidatorTests()
{
_productRepository = new Mock <IProductCommandRepository>();
_serviceMethodRepository = new Mock <IServiceMethodCommandRepository>();
_validator = new OrderValidator(_productRepository.Object, _serviceMethodRepository.Object);
}
public void TrySetRequestID_invalidCharacter()
{
long number;
bool state = OrderValidator.TrySetRequestID("f", out number);
Assert.IsFalse(state);
}
public async Task <ActionResult <OrderAPIModel> > UpdateOrder(int id, OrderAPIModel order)
{
var validator = new OrderValidator();
var validationResult = await validator.ValidateAsync(order);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var orderToUpdate = await _orderService.GetOrderById(id);
if (orderToUpdate == null)
{
return(NotFound());
}
var orderModel = _mapper.Map <OrderAPIModel, Orders>(order);
await _orderService.UpdateOrder(orderToUpdate, orderModel);
orderModel = await _orderService.GetOrderById(id);
var orderAPIModel = _mapper.Map <Orders, OrderAPIModel>(orderModel);
return(Ok(orderAPIModel));
}
public void NewOrder(Order order, string clientId)
{
IValidator validator = OrderValidator.CreateValidator(order, false);
validator.Validate();
repository.NewOrder(order, clientId);
}
public void TrySetRequestID_negativeNumber()
{
long number;
bool state = OrderValidator.TrySetRequestID("-3", out number);
Assert.IsFalse(state);
}
public void TrySetClientID_checkSpace()
{
string TestString = null;
bool state = OrderValidator.TrySetClientID("123a o", out TestString);
Assert.IsFalse(state);
Assert.AreEqual(TestString, "");
}
private IOrderManager <string, string> GetOrderManager()
{
var validator = new OrderValidator(new IValidationStep[] { new MaxCountValidationStep(), new NotAvailableValidatorStep() });
var orderManager = new OrderManager(new StringToOrderConverter(), validator, new DishSorter(),
new OutputGenerator(), new OrderTrimmer());
return(orderManager);
}
public void TrySetRequestID_number()
{
long number;
bool state = OrderValidator.TrySetRequestID("3", out number);
Assert.IsTrue(state);
Assert.AreEqual(number, 3);
}
public void TrySetClientID_emptyString()
{
string TestString = null;
bool state = OrderValidator.TrySetClientID("", out TestString);
Assert.IsFalse(state);
Assert.AreEqual(TestString, "");
}
public void TrySetClientID_invalidCharacter()
{
string TestString = null;
bool state = OrderValidator.TrySetClientID("abc-de", out TestString);
Assert.IsFalse(state);
Assert.AreEqual(TestString, "");
}
public void ShouldNotValidOrder()
{
var order = new Order();
var orderValidator = new OrderValidator().Validate(order);
Assert.False(orderValidator.IsValid);
}
private bool VerifyOrderAmount(out string errorHeader, out string errorMessage)
{
OrderValidator orderValidator = new OrderValidator();
return(orderValidator.ValidateSubtotal(
CurrenntCurrency, StoreContext.WholesaleStatus, StoreContext.ShoppingCart,
out errorHeader, out errorMessage));
}
public void TrySetClientID_onlyNumbers()
{
string TestString = null;
bool state = OrderValidator.TrySetClientID("123456", out TestString);
Assert.IsTrue(state);
Assert.AreEqual(TestString, "123456");
}
public void UpdateOrder(Order order)
{
if (OrderValidator.IsOrderValid(order))
{
OrderValidator.CalcTotal(order);
context.Entry(order).State = EntityState.Modified;
}
}
public void CreateOrder(Order order)
{
if (OrderValidator.IsOrderValid(order))
{
OrderValidator.CalcTotal(order);
context.Orders.Add(order);
}
}
public DeleteOrderService(
IStockWalletDbContext context,
OrderValidator entityValidator,
DeleteOrderSpecificationsValidator domainValidator
) : base(entityValidator, domainValidator)
{
Context = context;
}
public PostOrderService(
IDefaultDbContext context,
OrderValidator entityValidator,
PostOrderSpecificationsValidator domainValidator
) : base(entityValidator, domainValidator)
{
Context = context;
}
public void Should_not_validate_on_null_property_even_though_the_default_validator_for_it_was_registered()
{
// Arrange
ValidatorFactory.Current.Register<OrderDetailValidator>();
var order = new Order();
var validator = new OrderValidator();
// Action
var results = validator.GetValidationResult(order).ToList();
// Assert
Assert.AreEqual(0, results.Count);
}
public void Should_register_default_validator_before_validation()
{
// Arrange
ValidatorFactory.Current.Register<OrderDetailValidator>();
var order = new Order
{
FirstOrderDetail = new OrderDetail {ProductCode = "P1"},
};
var validator = new OrderValidator();
// Action
var results = validator.GetValidationResult(order).ToList();
// Assert
Assert.AreEqual(1, results.Count());
Assert.AreEqual("Order.FirstOrderDetail.ProductCode", results[0].MemberName);
Assert.AreEqual("ProductCode must be between 3 and 5 in length. You had 2 in length.", results[0].Message);
}
public void Throw_exception_if_use_a_validator_without_registration()
{
// Arrange
var order = new Order
{
FirstOrderDetail = new OrderDetail(),
};
var validator = new OrderValidator();
// Action
validator.GetValidationResult(order).ToList();
}