public async Task TestSaveWhenCreateAndSuccess()
{
// Arrange
var model = new OrderSaveModel();
model.OrderId = null;
Order savedResult = null;
MockDbContext.Setup(a => a.Add(It.IsAny <Order>())).Callback <Order>(r => savedResult = r);
// Act
var controllerResult = await Controller.Save(model);
// Assert
var result = Assert.IsType <JsonResult>(controllerResult);
dynamic data = JObject.FromObject(result.Value);
((bool)data.success).ShouldBe(true);
((int)data.id).ShouldBe(0); //Because it would be set in the DB
MockOrderService.Verify(a => a.PopulateTestItemModel(It.IsAny <bool>()), Times.Once);
MockOrderService.Verify(a => a.PopulateOrder(model, It.IsAny <Order>()), Times.Once);
MockDbContext.Verify(a => a.Add(It.IsAny <Order>()), Times.Once);
MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Once);
savedResult.CreatorId.ShouldBe("Creator1");
savedResult.Creator.ShouldNotBeNull();
savedResult.Creator.Id.ShouldBe("Creator1");
savedResult.Status.ShouldBe(OrderStatusCodes.Created);
savedResult.ShareIdentifier.ShouldNotBeNull();
}
public async Task TestSaveWhenEditAndSuccess()
{
// Arrange
OrderData[1].Status = OrderStatusCodes.Created;
OrderData[1].CreatorId = "Creator1";
var model = new OrderSaveModel();
model.OrderId = 2;
OrderData[1].SavedTestDetails.ShouldBeNull();
// Act
var controllerResult = await Controller.Save(model);
// Assert
var result = Assert.IsType <JsonResult>(controllerResult);
dynamic data = JObject.FromObject(result.Value);
((bool)data.success).ShouldBe(true);
((int)data.id).ShouldBe(2);
MockOrderService.Verify(a => a.PopulateTestItemModel(It.IsAny <bool>()), Times.Once);
MockOrderService.Verify(a => a.PopulateOrder(model, OrderData[1]), Times.Once);
MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Once);
OrderData[1].SavedTestDetails.ShouldNotBeNull();
OrderData[1].GetTestDetails().Count.ShouldBe(10);
}
public void PopulateOrder(OrderSaveModel model, Order orderToUpdate)
{
orderToUpdate.Project = model.Project;
orderToUpdate.ClientId = model.ClientInfo.ClientId;
orderToUpdate.ClientName = model.ClientInfo.Name;
orderToUpdate.JsonDetails = JsonConvert.SerializeObject(model);
var orderDetails = orderToUpdate.GetOrderDetails();
orderDetails.Payment.Account = orderDetails.Payment.Account.SafeToUpper(); //Make sure any account is all upper case
var tests = CalculateTestDetails(orderToUpdate);
orderDetails.SelectedTests = tests.ToArray();
orderDetails.Total = orderDetails.SelectedTests.Sum(x => x.Total) + (orderDetails.Payment.IsInternalClient ? orderDetails.InternalProcessingFee : orderDetails.ExternalProcessingFee);
orderToUpdate.SaveDetails(orderDetails);
orderToUpdate.AdditionalEmails = string.Join(";", orderDetails.AdditionalEmails);
orderToUpdate.AdditionalEmails = AdditionalEmailsHelper.AddClientInfoEmails(orderToUpdate, orderDetails.ClientInfo);
if (orderDetails.Payment.IsInternalClient)
{
var account = new AccountModel(orderDetails.Payment.Account);
if (account.Chart == "3" || account.Chart == "L" || account.Chart == "H" || account.Chart == "M") //Removed S as a choice and added H to match _checkUcChart in react code
{
orderToUpdate.PaymentType = PaymentTypeCodes.UcDavisAccount;
}
else
{
orderToUpdate.PaymentType = PaymentTypeCodes.UcOtherAccount;
}
}
else
{
if (orderDetails.OtherPaymentInfo == null || string.IsNullOrWhiteSpace(orderDetails.OtherPaymentInfo.PaymentType))
{
orderToUpdate.PaymentType = PaymentTypeCodes.CreditCard;
}
else
{
orderToUpdate.PaymentType = PaymentTypeCodes.Other;
}
}
}
public async Task TestSaveChecksIfItIsYourOrder()
{
// Arrange
OrderData[1].CreatorId = "XXX";
var model = new OrderSaveModel();
model.OrderId = 2;
// Act
var controllerResult = await Controller.Save(model);
// Assert
var result = Assert.IsType <JsonResult>(controllerResult);
dynamic data = JObject.FromObject(result.Value);
((string)data.message).ShouldBe("This is not your order.");
((bool)data.success).ShouldBe(false);
MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Never);
}
public async Task TestSaveChecksIfYourOrderIsInCreatedStatus()
{
// Arrange
OrderData[1].Status = OrderStatusCodes.Confirmed;
OrderData[1].CreatorId = "Creator1";
var model = new OrderSaveModel();
model.OrderId = 2;
// Act
var controllerResult = await Controller.Save(model);
// Assert
var result = Assert.IsType <JsonResult>(controllerResult);
dynamic data = JObject.FromObject(result.Value);
((string)data.message).ShouldBe("This has been confirmed and may not be updated.");
((bool)data.success).ShouldBe(false);
MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Never);
}
public async Task <IActionResult> Save(OrderSaveModel model)
{
if (!ModelState.IsValid)
{
var errors = new List <string>();
foreach (var result in ModelState.Values)
{
foreach (var errs in result.Errors)
{
errors.Add(errs.ErrorMessage);
}
}
//TODO: A better way to return errors. Or maybe not, they shouldn't really ever happen.
return(Json(new { success = false, message = "There were problems with your order. Unable to save. Errors: " + string.Join("--", errors) }));
}
var idForRedirection = 0;
if (model.OrderId.HasValue)
{
var orderToUpdate = await _context.Orders.Include(i => i.Creator).SingleAsync(a => a.Id == model.OrderId.Value);
if (orderToUpdate.CreatorId != CurrentUserId)
{
return(Json(new { success = false, message = "This is not your order." }));
}
if (orderToUpdate.Status != OrderStatusCodes.Created)
{
return(Json(new { success = false, message = "This has been confirmed and may not be updated." }));
}
var allTests = await _orderService.PopulateTestItemModel();
orderToUpdate.SaveTestDetails(allTests);
_orderService.PopulateOrder(model, orderToUpdate);
idForRedirection = model.OrderId.Value;
await _context.SaveChangesAsync();
}
else
{
var user = _context.Users.Single(a => a.Id == CurrentUserId);
var order = new Order
{
CreatorId = CurrentUserId,
Creator = user,
Status = OrderStatusCodes.Created,
ShareIdentifier = Guid.NewGuid(),
};
var allTests = await _orderService.PopulateTestItemModel();
order.SaveTestDetails(allTests);
_orderService.PopulateOrder(model, order);
_context.Add(order);
await _context.SaveChangesAsync();
idForRedirection = order.Id;
}
return(Json(new { success = true, id = idForRedirection }));
}
