public void TestCopySetsTheCreatorToCurrectUserWhenAdminIsTrueButNotAdminRole()
{
// Arrange
Order savedResult = null;
MockDbContext.Setup(a => a.Add(It.IsAny <Order>())).Callback <Order>(r => savedResult = r);
var copiedOrder = CreateValidEntities.Order(7);
copiedOrder.Creator = CreateValidEntities.User(5, true);
OrderData[1].CreatorId = "xxx";
OrderData[1].Creator = CreateValidEntities.User(5);
MockOrderService.Setup(a => a.DuplicateOrder(OrderData[1], true)).ReturnsAsync(copiedOrder);
// Act
var ex = Assert.ThrowsAsync <Exception>(async() => await Controller.Copy(SpecificGuid.GetGuid(2), true));
// Assert
ex.Result.Message.ShouldBe("Permissions Missing");
MockOrderService.Verify(a => a.DuplicateOrder(OrderData[1], true), Times.Once);
MockDbContext.Verify(a => a.Add(It.IsAny <Order>()), Times.Never);
MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Never);
}
public void TestOrderApproved()
{
#region Arrange
var users = new List <User>();
for (int i = 0; i < 3; i++)
{
users.Add(CreateValidEntities.User(i + 1));
users[i].SetIdTo((i + 1).ToString(CultureInfo.InvariantCulture));
}
new FakeUsers(0, UserRepository, users, true);
var order = CreateValidEntities.Order(1);
var approval = CreateValidEntities.Approval(1);
approval.User = UserRepository.Queryable.Single(a => a.Id == "3");
approval.StatusCode = CreateValidEntities.OrderStatusCode(4);
UserIdentity.Expect(a => a.Current).Return("2");
#endregion Arrange
#region Act
EventService.OrderApproved(order, approval);
#endregion Act
#region Assert
NotificationService.AssertWasCalled(a => a.OrderApproved(order, approval));
Assert.AreEqual(1, order.OrderTrackings.Count());
Assert.AreEqual("FirstName2 LastName2", order.OrderTrackings[0].User.FullName);
Assert.AreEqual("Name4", order.OrderTrackings[0].StatusCode.Name);
Assert.AreEqual("approved", order.OrderTrackings[0].Description);
#endregion Assert
}
public void TestCreateApprovalsForNewOrderRequiresAccountIdOrManager()
{
var thisFar = false;
try
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.Splits = new List <Split>();
order.Splits.Add(new Split());
order.Splits[0].Account = "12345";
thisFar = true;
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, null, null, null, null);
#endregion Act
}
catch (Exception ex)
{
Assert.IsTrue(thisFar);
Assert.IsNotNull(ex);
Assert.AreEqual("You must either supply the ID of a valid account or provide the userId for an account manager", ex.Message);
throw;
}
}
public void TestReroutePurchaserThrowsExceptionIfUserDoesNotExist()
{
var thisFar = false;
try
{
#region Arrange
var orders = new List <Order>();
orders.Add(CreateValidEntities.Order(1));
orders[0].StatusCode.SetIdTo(OrderStatusCode.Codes.AccountManager);
orders[0].Approvals.Add(CreateValidEntities.Approval(1));
orders[0].Approvals[0].StatusCode.SetIdTo(OrderStatusCode.Codes.AccountManager);
orders[0].Approvals[0].User = CreateValidEntities.User(99);
new FakeOrders(0, OrderRepository, orders);
new FakeUsers(3, UserRepository);
//new FakeOrderPeeps(3, OrderPeepRepository);
thisFar = true;
#endregion Arrange
#region Act
Controller.ReroutePurchaser(1, "NotMe");
#endregion Act
}
catch (Exception ex)
{
Assert.IsTrue(thisFar);
Assert.IsNotNull(ex);
Assert.AreEqual("Sequence contains no matching element", ex.Message);
throw;
}
}
protected void SetupDataForTests1()
{
var statusCodes = new List <OrderStatusCode>();
for (int i = 0; i < 5; i++)
{
statusCodes.Add(CreateValidEntities.OrderStatusCode(i + 1));
statusCodes[i].Level = i + 1;
}
statusCodes[3].ShowInFilterList = true;
statusCodes[2].ShowInFilterList = true;
new FakeOrderStatusCodes(0, OrderStatusCodeRepository, statusCodes, false);
var orders = new List <Order>();
for (int i = 0; i < 3; i++)
{
orders.Add(CreateValidEntities.Order(i + 1));
orders[i].Workgroup = CreateValidEntities.Workgroup(i + 1);
orders[i].CreatedBy = CreateValidEntities.User(i + 1);
orders[i].StatusCode = OrderStatusCodeRepository.Queryable.First();
}
new FakeOrders(0, OrderRepository, orders);
//OrderService.Expect(a => a.GetListofOrders(Arg<bool>.Is.Anything, Arg<bool>.Is.Anything, Arg<string>.Is.Anything, Arg<DateTime?>.Is.Anything, Arg<DateTime>.Is.Anything, Arg<bool>.Is.Anything)).Return(OrderRepository.Queryable);
}
public void TestCreateApprovalsForNewOrder1()
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.SetIdTo(99);
order.Splits = new List <Split>();
order.Splits.Add(new Split());
order.Splits[0].Account = "12345";
order.Splits[0].Order = order;
order.Workgroup.SetIdTo(1);
new FakeWorkgroupAccounts(3, WorkgroupAccountRepository);
new FakeAccounts(3, AccountRepository);
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, null, "12345", null, null);
#endregion Act
#region Assert
SecurityService.AssertWasNotCalled(a => a.GetUser(Arg <string> .Is.Anything)); // the account was not found in the workgroup or the account table
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(2));
EventService.AssertWasNotCalled(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
EventService.AssertWasCalled(a => a.OrderCreated(order));
Assert.AreEqual(2, order.Approvals.Count); //Only 2 approvals for an external account
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[0].StatusCode.Id);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[1].StatusCode.Id);
foreach (var approval in order.Approvals)
{
Assert.IsNull(approval.User);
}
#endregion Assert
}
public async Task TestViewMessageReturnsView()
{
// Arrange
var mail = new List <MailMessage>();
for (int i = 0; i < 5; i++)
{
var mm = CreateValidEntities.MailMessage(i + 1);
mm.Order = CreateValidEntities.Order(i + 1);
mm.User = UserData[i % 2];
mm.Sent = null;
mm.SentAt = DateTime.UtcNow.AddDays(-35);
mail.Add(mm);
}
MockDbContext.Setup(a => a.MailMessages).Returns(mail.AsQueryable().MockAsyncDbSet().Object);
// Act
var controllerResult = await Controller.ViewMessage(3);
// Assert
var viewResult = Assert.IsType <ViewResult>(controllerResult);
var modelResult = Assert.IsType <MailMessage>(viewResult.Model);
modelResult.ShouldNotBeNull();
modelResult.Id.ShouldBe(3);
}
public async Task TestMailQueueReturnsView1()
{
// Arrange
var mail = new List <MailMessage>();
for (int i = 0; i < 10; i++)
{
var mm = CreateValidEntities.MailMessage(i + 1);
mm.Order = CreateValidEntities.Order(i + 1);
mm.User = UserData[i % 2];
mail.Add(mm);
}
MockDbContext.Setup(a => a.MailMessages).Returns(mail.AsQueryable().MockAsyncDbSet().Object);
for (int i = 0; i < 3; i++)
{
mail[i].Order = CreateValidEntities.Order(2);
}
// Act
var controllerResult = await Controller.MailQueue(mail[0].Order.Id);
// Assert
var viewResult = Assert.IsType <ViewResult>(controllerResult);
var modelResult = Assert.IsType <List <MailMessage> >(viewResult.Model);
modelResult.ShouldNotBeNull();
modelResult.Count.ShouldBe(3);
modelResult[0].Id.ShouldBe(1);
modelResult[0].Order.Id.ShouldBe(2);
}
public void TestCreateApprovalsForNewOrder23()
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.SetIdTo(99);
order.Splits = new List <Split>();
order.Splits.Add(new Split());
order.Splits[0].Account = null;
order.Splits[0].Order = order;
order.Workgroup.SetIdTo(1);
new FakeWorkgroupAccounts(3, WorkgroupAccountRepository);
new FakeAccounts(3, AccountRepository);
new FakeUsers(3, UserRepository);
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, null, null, null, "2");
#endregion Act
#region Assert
SecurityService.AssertWasNotCalled(a => a.GetUser(Arg <string> .Is.Anything)); // the account was not found in the workgroup or the account table
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(3));
EventService.AssertWasNotCalled(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
EventService.AssertWasCalled(a => a.OrderCreated(order));
Assert.AreEqual(3, order.Approvals.Count);
Assert.AreEqual(OrderStatusCode.Codes.Approver, order.Approvals[0].StatusCode.Id);
Assert.IsNull(order.Approvals[0].User);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[1].StatusCode.Id);
Assert.AreEqual("LastName2", order.Approvals[1].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[2].StatusCode.Id);
#endregion Assert
}
public void TestReroutePurchaserGetReturnsView1()
{
#region Arrange
var orders = new List <Order>();
orders.Add(CreateValidEntities.Order(1));
orders[0].StatusCode.SetIdTo(OrderStatusCode.Codes.AccountManager);
orders[0].Approvals.Add(CreateValidEntities.Approval(1));
orders[0].Approvals[0].StatusCode.SetIdTo(OrderStatusCode.Codes.AccountManager);
orders[0].Approvals[0].User = CreateValidEntities.User(99);
new FakeOrders(0, OrderRepository, orders);
new FakeUsers(3, UserRepository);
//new FakeOrderPeeps(3, OrderPeepRepository);
#endregion Arrange
#region Act
var result = Controller.ReroutePurchaser(1)
.AssertViewRendered()
.WithViewData <OrderReRoutePurchaserModel>();
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(0, result.PurchaserPeeps.Count());
#endregion Assert
}
public async Task TestCopySetsTheCreatorToCurrectUserWhenNotAdmin()
{
// Arrange
Order savedResult = null;
MockDbContext.Setup(a => a.Add(It.IsAny <Order>())).Callback <Order>(r => savedResult = r);
var copiedOrder = CreateValidEntities.Order(7);
copiedOrder.Creator = CreateValidEntities.User(5, true);
OrderData[1].CreatorId = "xxx";
OrderData[1].Creator = CreateValidEntities.User(5);
MockOrderService.Setup(a => a.DuplicateOrder(OrderData[1], false)).ReturnsAsync(copiedOrder);
// Act
var controllerResult = await Controller.Copy(SpecificGuid.GetGuid(2));
// Assert
MockOrderService.Verify(a => a.DuplicateOrder(OrderData[1], false), Times.Once);
MockDbContext.Verify(a => a.Add(It.IsAny <Order>()), Times.Once);
MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Once);
savedResult.ShouldNotBeNull();
savedResult.CreatorId.ShouldBe("Creator1");
savedResult.Creator.Id.ShouldBe("Creator1");
savedResult.ShareIdentifier.ShouldNotBe(SpecificGuid.GetGuid(2));
savedResult.SavedTestDetails.ShouldBeNull();
var redirectResult = Assert.IsType <RedirectToActionResult>(controllerResult);
redirectResult.ActionName.ShouldBe("Edit");
redirectResult.ControllerName.ShouldBeNull();
redirectResult.RouteValues["id"].ShouldBe(savedResult.Id);
}
public void TestCreateApprovalsForNewOrder4()
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.SetIdTo(99);
order.Splits = new List <Split>();
order.Splits.Add(new Split());
//order.Splits[0].Account = "12345";
order.Splits[0].Order = order;
order.Workgroup.SetIdTo(1);
var workgroupAccounts = new List <WorkgroupAccount>();
workgroupAccounts.Add(CreateValidEntities.WorkgroupAccount(1));
workgroupAccounts[0].Workgroup = order.Workgroup;
workgroupAccounts[0].Account = CreateValidEntities.Account(9);
workgroupAccounts[0].Account.SetIdTo("12345");
workgroupAccounts[0].Approver = CreateValidEntities.User(11);
workgroupAccounts[0].Approver.SetIdTo("11");
workgroupAccounts[0].AccountManager = CreateValidEntities.User(22);
workgroupAccounts[0].Purchaser = CreateValidEntities.User(33);
new FakeWorkgroupAccounts(0, WorkgroupAccountRepository, workgroupAccounts);
//var accounts = new List<Account>();
//accounts.Add(CreateValidEntities.Account(1));
//accounts[0].SetIdTo("12345");
//accounts[0].AccountManagerId = "TestUser";
new FakeAccounts(3, AccountRepository);
SecurityService.Expect(a => a.GetUser("TestUser")).Return(CreateValidEntities.User(55));
UserIdentity.Expect(a => a.Current).Return("22"); //NOT same as approver
new FakeAutoApprovals(3, AutoAprovalRepository);
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, null, "12345", null, null);
#endregion Act
#region Assert
SecurityService.AssertWasNotCalled(a => a.GetUser(Arg <string> .Is.Anything)); // the account was not found in the workgroup or the account table
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(3));
EventService.AssertWasNotCalled(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
//var args = (Approval)EventService.GetArgumentsForCallsMadeOn(a => a.OrderAutoApprovalAdded(Arg<Order>.Is.Anything, Arg<Approval>.Is.Anything))[0][1];
//Assert.AreEqual(OrderStatusCode.Codes.Approver, args.StatusCode.Id);
EventService.AssertWasCalled(a => a.OrderCreated(order));
Assert.AreEqual(3, order.Approvals.Count);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[1].StatusCode.Id);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[2].StatusCode.Id);
Assert.AreEqual("LastName11", order.Approvals[0].User.LastName);
Assert.IsFalse(order.Approvals[0].Completed);
Assert.AreEqual("LastName22", order.Approvals[1].User.LastName);
Assert.AreEqual("LastName33", order.Approvals[2].User.LastName);
Assert.AreEqual("12345", order.Splits[0].Account);
#endregion Assert
}
public void TestReRouteApprovalsForExistingOrderWhenCurrectLevelIsApprove05()
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.CreatedBy = CreateValidEntities.User(109);
order.SetIdTo(99);
order.Splits = new List <Split>();
order.Splits.Add(CreateValidEntities.Split(1));
order.Splits.Add(CreateValidEntities.Split(2));
order.Splits[0].Order = order;
order.Splits[1].Order = order;
order.Splits[0].Account = "12345";
order.Splits[1].Account = "23456";
order.StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.Approver);
order.Approvals = new List <Approval>();
order.Approvals.Add(CreateValidEntities.Approval(1));
order.Approvals.Add(CreateValidEntities.Approval(2));
order.Approvals.Add(CreateValidEntities.Approval(3));
order.Approvals.Add(CreateValidEntities.Approval(4));
order.Approvals[0].StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.Approver);
order.Approvals[0].Completed = true;
order.Approvals[0].User = CreateValidEntities.User(88);
order.Approvals[1].StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.AccountManager);
order.Approvals[2].StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.Purchaser);
order.Approvals[3].StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.ConditionalApprover);
order.Approvals[3].User = CreateValidEntities.User(99);
new FakeUsers(4, UserRepository);
new FakeWorkgroupAccounts(3, WorkgroupAccountRepository);
#endregion Arrange
#region Act
OrderService.ReRouteApprovalsForExistingOrder(order, string.Empty, string.Empty);
#endregion Act
#region Assert
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(3));
EventService.AssertWasCalled(a => a.OrderReRouted(order));
SecurityService.AssertWasNotCalled(a => a.GetUser(Arg <string> .Is.Anything));
Assert.AreEqual(4, order.Approvals.Count);
Assert.AreEqual("LastName99", order.Approvals[0].User.LastName);
Assert.IsFalse(order.Approvals[0].Completed);
Assert.IsNull(order.Approvals[1].User);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[1].StatusCode.Id);
Assert.IsNull(order.Approvals[2].User);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[2].StatusCode.Id);
Assert.IsNull(order.Approvals[3].User);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[3].StatusCode.Id);
#endregion Assert
}
public void TestEditGetReturnsView3()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(0, new[] { "" }, "3");
SetupRoles();
new FakeUsers(3, UserRepository);
new FakeWorkgroups(3, WorkgroupRepository);
var wps = new List <WorkgroupPermission>();
wps.Add(CreateValidEntities.WorkgroupPermission(1));
wps[0].Workgroup = WorkgroupRepository.Queryable.Single(a => a.Id == 2);
wps[0].User = UserRepository.Queryable.Single(a => a.Id == "3");
wps[0].Role = RoleRepository.Queryable.Single(a => a.Id == Role.Codes.Requester);
new FakeWorkgroupPermissions(0, WorkgroupPermissionRepository, wps);
new FakeUnitOfMeasures(3, RepositoryFactory.UnitOfMeasureRepository);
new FakeWorkgroupAccounts(3, RepositoryFactory.WorkgroupAccountRepository);
var wgVendors = new List <WorkgroupVendor>();
for (int i = 0; i < 5; i++)
{
wgVendors.Add(CreateValidEntities.WorkgroupVendor(i + 1));
wgVendors[i].Workgroup = WorkgroupRepository.Queryable.Single(a => a.Id == 2);
}
wgVendors[1].Workgroup = WorkgroupRepository.Queryable.Single(a => a.Id == 1);
wgVendors[2].IsActive = false;
wgVendors[3].Name = "AAA";
new FakeWorkgroupVendors(0, RepositoryFactory.WorkgroupVendorRepository, wgVendors);
new FakeWorkAddresses(3, RepositoryFactory.WorkgroupAddressRepository);
new FakeShippingTypes(3, RepositoryFactory.ShippingTypeRepository);
new FakeCustomFields(3, RepositoryFactory.CustomFieldRepository);
new FakeSplits(3, RepositoryFactory.SplitRepository);
new FakeAccounts(3, RepositoryFactory.AccountRepository);
var orders = new List <Order>();
orders.Add(CreateValidEntities.Order(1));
orders[0].Workgroup = RepositoryFactory.WorkgroupRepository.Queryable.Single(a => a.Id == 2);
new FakeOrders(0, RepositoryFactory.OrderRepository, orders);
#endregion Arrange
#region Act
var result = Controller.Edit(1)
.AssertViewRendered()
.WithViewData <OrderModifyModel>();
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Vendors.Count());
Assert.AreEqual("AAA", result.Vendors.ElementAt(0).Name);
Assert.AreEqual("Name1", result.Vendors.ElementAt(1).Name);
Assert.AreEqual("Name5", result.Vendors.ElementAt(2).Name);
#endregion Assert
}
public void TestCreateApprovalsForNewOrder29()
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.SetIdTo(99);
order.Splits = new List <Split>();
order.Splits.Add(new Split());
order.Splits[0].Account = null;
order.Splits[0].Order = order;
order.Workgroup.SetIdTo(1);
new FakeWorkgroupAccounts(3, WorkgroupAccountRepository);
new FakeAccounts(3, AccountRepository);
new FakeUsers(6, UserRepository);
var conditionalApprovalIds = new[] { 1, 2 };
var conditionalApprovals = new List <ConditionalApproval>();
conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(1));
conditionalApprovals[0].PrimaryApprover = CreateValidEntities.User(4);
conditionalApprovals[0].SecondaryApprover = CreateValidEntities.User(5);
conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(2));
conditionalApprovals[1].PrimaryApprover = CreateValidEntities.User(6);
conditionalApprovals[1].SecondaryApprover = null;
new FakeConditionalApprovals(0, ConditionalApprovalRepository, conditionalApprovals);
UserIdentity.Expect(a => a.Current).Return("4"); // Same As conditional approval, but conditional approvals do not auto approve.
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, conditionalApprovalIds, null, null, "2");
#endregion Act
#region Assert
SecurityService.AssertWasNotCalled(a => a.GetUser(Arg <string> .Is.Anything)); // the account was not found in the workgroup or the account table
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(3));
EventService.AssertWasNotCalled(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
EventService.AssertWasCalled(a => a.OrderCreated(order));
Assert.AreEqual(5, order.Approvals.Count);
Assert.AreEqual(OrderStatusCode.Codes.Approver, order.Approvals[0].StatusCode.Id);
Assert.IsNull(order.Approvals[0].User);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[1].StatusCode.Id);
Assert.AreEqual("LastName2", order.Approvals[1].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[2].StatusCode.Id);
Assert.AreEqual("LastName4", order.Approvals[3].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.ConditionalApprover, order.Approvals[3].StatusCode.Id);
Assert.AreEqual("LastName5", order.Approvals[3].SecondaryUser.LastName);
Assert.AreEqual("LastName6", order.Approvals[4].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.ConditionalApprover, order.Approvals[4].StatusCode.Id);
Assert.IsNull(order.Approvals[4].SecondaryUser);
#endregion Assert
}
public void TestEditExistingOrder()
{
#region Arrange
var order = CreateValidEntities.Order(7);
var order2 = CreateValidEntities.Order(8);
#endregion Arrange
#region Act
OrderService.EditExistingOrder(order);
#endregion Act
#region Assert
EventService.AssertWasCalled(a => a.OrderEdited(order));
EventService.AssertWasNotCalled(a => a.OrderEdited(order2));
#endregion Assert
}
public async Task TestCopySetsTheCreatorToCorrectUserWhenAdminIsTrue()
{
MockClaimsPrincipal.Setup(a => a.IsInRole(RoleCodes.Admin)).Returns(true);
Order savedResult = null;
MockDbContext.Setup(a => a.Add(It.IsAny <Order>())).Callback <Order>(r => savedResult = r);
var copiedOrder = CreateValidEntities.Order(7, true);
var testItemModel = new List <TestItemModel>();
for (int i = 0; i < 5; i++)
{
testItemModel.Add(CreateValidEntities.TestItemModel(1));
}
copiedOrder.SaveTestDetails(testItemModel);
OrderData[1].SaveTestDetails(testItemModel);
copiedOrder.Creator = CreateValidEntities.User(5, true);
OrderData[1].CreatorId = "xxx";
OrderData[1].Creator = CreateValidEntities.User(5);
MockOrderService.Setup(a => a.DuplicateOrder(OrderData[1], true)).ReturnsAsync(copiedOrder);
// Act
var controllerResult = await Controller.Copy(SpecificGuid.GetGuid(2), true);
// Assert
MockOrderService.Verify(a => a.DuplicateOrder(OrderData[1], true), Times.Once);
MockDbContext.Verify(a => a.Add(It.IsAny <Order>()), Times.Once);
MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Once);
savedResult.ShouldNotBeNull();
savedResult.CreatorId.ShouldBe("xxx");
savedResult.Creator.Id.ShouldBe("5");
savedResult.ShareIdentifier.ShouldNotBe(SpecificGuid.GetGuid(2));
savedResult.Status.ShouldBe(OrderStatusCodes.Confirmed);
savedResult.GetOrderDetails().LabComments.ShouldContain("Duplicated from 2");
savedResult.GetTestDetails().Count.ShouldBe(5);
var redirectResult = Assert.IsType <RedirectToActionResult>(controllerResult);
redirectResult.ActionName.ShouldBe("AddRequestNumber");
redirectResult.ControllerName.ShouldBe("Lab");
redirectResult.RouteValues["id"].ShouldBe(savedResult.Id);
MockClaimsPrincipal.Verify(a => a.IsInRole(RoleCodes.Admin), Times.Once);
}
public void TestOrderApprovalAddedDoesNothing()
{
#region Arrange
var order = CreateValidEntities.Order(1);
var approval = CreateValidEntities.Approval(1);
var trackingCount = order.OrderTrackings.Count();
#endregion Arrange
#region Act
EventService.OrderApprovalAdded(order, approval);
#endregion Act
#region Assert
NotificationService.AssertWasNotCalled(a => a.OrderReRouted(Arg <Order> .Is.Anything, Arg <int> .Is.Anything, Arg <bool> .Is.Anything));
Assert.AreEqual(trackingCount, order.OrderTrackings.Count());
#endregion Assert
}
public void TestCreateApprovalsForNewOrder26()
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.CreatedBy = CreateValidEntities.User(109);
order.SetIdTo(99);
order.Splits = new List <Split>();
order.Splits.Add(new Split());
order.Splits[0].Account = null;
order.Splits[0].Order = order;
order.Workgroup.SetIdTo(1);
new FakeWorkgroupAccounts(3, WorkgroupAccountRepository);
new FakeAccounts(3, AccountRepository);
new FakeUsers(3, UserRepository);
UserIdentity.Expect(a => a.Current).Return("3");
var autoApprovals = new List <AutoApproval>();
autoApprovals.Add(CreateValidEntities.AutoApproval(1));
autoApprovals[0].User = CreateValidEntities.User(1);
autoApprovals[0].IsActive = true;
autoApprovals[0].Expiration = DateTime.UtcNow.ToPacificTime().AddDays(1);
autoApprovals[0].TargetUser = order.CreatedBy;
autoApprovals[0].Account = null;
new FakeAutoApprovals(0, AutoAprovalRepository, autoApprovals);
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, null, null, "1", "2");
#endregion Act
#region Assert
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(2));
EventService.AssertWasCalled(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
var args = (Approval)EventService.GetArgumentsForCallsMadeOn(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything))[0][1];
Assert.AreEqual(OrderStatusCode.Codes.Approver, args.StatusCode.Id);
Assert.AreEqual(3, order.Approvals.Count);
Assert.AreEqual(OrderStatusCode.Codes.Approver, order.Approvals[0].StatusCode.Id);
Assert.AreEqual("LastName1", order.Approvals[0].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[1].StatusCode.Id);
Assert.AreEqual("LastName2", order.Approvals[1].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[2].StatusCode.Id);
#endregion Assert
}
public ResultsControllerTests()
{
MockDbContext = new Mock <ApplicationDbContext>();
MockHttpContext = new Mock <HttpContext>();
MockFileStorageService = new Mock <IFileStorageService>();
MockDataSigningService = new Mock <IDataSigningService>();
MockCyberSourceSettings = new Mock <IOptions <CyberSourceSettings> >();
MockAppSettings = new Mock <IOptions <AppSettings> >();
MockOrderMessageService = new Mock <IOrderMessageService>();
var mockDataProvider = new Mock <SessionStateTempDataProvider>();
//Data
OrderData = new List <Order>();
for (int i = 0; i < 3; i++)
{
var order = CreateValidEntities.Order(i + 1, true);
order.Creator = CreateValidEntities.User(2);
OrderData.Add(order);
}
CyberSourceSettings = new CyberSourceSettings();
CyberSourceSettings.AccessKey = "123";
CyberSourceSettings.ProfileId = "myProfile";
AppSettings = new AppSettings();
AppSettings.CyberSourceUrl = "Http://FakeUrl.com";
//Setup
MockDbContext.Setup(a => a.Orders).Returns(OrderData.AsQueryable().MockAsyncDbSet().Object);
MockCyberSourceSettings.Setup(a => a.Value).Returns(CyberSourceSettings);
MockAppSettings.Setup(a => a.Value).Returns(AppSettings);
Controller = new ResultsController(MockDbContext.Object,
MockFileStorageService.Object,
MockDataSigningService.Object,
MockCyberSourceSettings.Object,
MockAppSettings.Object,
MockOrderMessageService.Object)
{
TempData = new TempDataDictionary(MockHttpContext.Object, mockDataProvider.Object)
};
}
public void TestCreateApprovalsForNewOrder16()
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.SetIdTo(99);
order.CreatedBy = CreateValidEntities.User(109);
order.Splits = new List <Split>();
order.Splits.Add(new Split());
//order.Splits[0].Account = "12345";
order.Splits[0].Order = order;
order.Workgroup.SetIdTo(1);
new FakeUsers(3, UserRepository);
UserIdentity.Expect(a => a.Current).Return("1");
new FakeAutoApprovals(3, AutoAprovalRepository);
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, null, null, "3", "2");
#endregion Act
#region Assert
SecurityService.AssertWasNotCalled(a => a.GetUser(Arg <string> .Is.Anything)); // the account was not found in the workgroup or the account table
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(3));
EventService.AssertWasNotCalled(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
//var args = (Approval)EventService.GetArgumentsForCallsMadeOn(a => a.OrderAutoApprovalAdded(Arg<Order>.Is.Anything, Arg<Approval>.Is.Anything))[0][1];
//Assert.AreEqual(OrderStatusCode.Codes.Approver, args.StatusCode.Id);
EventService.AssertWasCalled(a => a.OrderCreated(order));
Assert.AreEqual(3, order.Approvals.Count);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[1].StatusCode.Id);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[2].StatusCode.Id);
Assert.AreEqual("LastName3", order.Approvals[0].User.LastName);
Assert.IsFalse(order.Approvals[0].Completed);
Assert.AreEqual("LastName2", order.Approvals[1].User.LastName);
Assert.IsNull(order.Approvals[2].User);
Assert.AreEqual(null, order.Splits[0].Account);
Assert.AreEqual(OrderStatusCode.Codes.Approver, order.StatusCode.Id);
#endregion Assert
}
public void TestEditGetReturnsView1()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(0, new[] { "" }, "3");
SetupRoles();
new FakeUsers(3, UserRepository);
new FakeWorkgroups(3, WorkgroupRepository);
var wps = new List <WorkgroupPermission>();
wps.Add(CreateValidEntities.WorkgroupPermission(1));
wps[0].Workgroup = WorkgroupRepository.Queryable.Single(a => a.Id == 2);
wps[0].User = UserRepository.Queryable.Single(a => a.Id == "3");
wps[0].Role = RoleRepository.Queryable.Single(a => a.Id == Role.Codes.Requester);
new FakeWorkgroupPermissions(0, WorkgroupPermissionRepository, wps);
new FakeUnitOfMeasures(3, RepositoryFactory.UnitOfMeasureRepository);
new FakeWorkgroupAccounts(3, RepositoryFactory.WorkgroupAccountRepository);
new FakeWorkgroupVendors(3, RepositoryFactory.WorkgroupVendorRepository);
new FakeWorkAddresses(3, RepositoryFactory.WorkgroupAddressRepository);
new FakeShippingTypes(3, RepositoryFactory.ShippingTypeRepository);
new FakeCustomFields(3, RepositoryFactory.CustomFieldRepository);
new FakeSplits(3, RepositoryFactory.SplitRepository);
new FakeAccounts(3, RepositoryFactory.AccountRepository);
var orders = new List <Order>();
orders.Add(CreateValidEntities.Order(1));
orders[0].Workgroup = RepositoryFactory.WorkgroupRepository.Queryable.Single(a => a.Id == 2);
new FakeOrders(0, RepositoryFactory.OrderRepository, orders);
#endregion Arrange
#region Act
var result = Controller.Edit(1)
.AssertViewRendered()
.WithViewData <OrderModifyModel>();
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(null, Controller.ErrorMessage);
Assert.AreEqual(1, result.Order.Id);
#endregion Assert
}
public async Task TestTestAsyncSave()
{
using (var contextHelper = new ContextHelper <ApplicationDbContext>())
{
(await contextHelper.Context.Orders.CountAsync()).ShouldBe(0);
await contextHelper.Context.Users.AddAsync(CreateValidEntities.User(1));
await contextHelper.Context.SaveChangesAsync();
var order = CreateValidEntities.Order(1);
order.Creator = await contextHelper.Context.Users.FirstOrDefaultAsync();
await contextHelper.Context.Orders.AddAsync(order);
await contextHelper.Context.SaveChangesAsync();
(await contextHelper.Context.Orders.CountAsync()).ShouldBe(1);
}
}
public Order SetupData1(string userId, OrderStatusCode currentLevel)
{
var approvals = new List <Approval>();
var order = CreateValidEntities.Order(1);
order.SetIdTo(1);
order.CreatedBy = UserRepository.GetNullableById(userId);
Assert.IsNotNull(order.CreatedBy);
order.StatusCode = currentLevel;
CreateApprovals(approvals, currentLevel, order);
new FakeApprovals(0, ApprovalRepository, approvals);
order.OrderTrackings = SetupOrderTracking(order);
order.Organization = CreateValidEntities.Organization(9);
order.Organization.SetIdTo("testOrg");
return(order);
}
public void TestReroutePurchaserGetRedirectsWhenWrongStatus7()
{
#region Arrange
var orders = new List <Order>();
orders.Add(CreateValidEntities.Order(1));
orders[0].StatusCode.SetIdTo(OrderStatusCode.Codes.Requester);
new FakeOrders(0, OrderRepository, orders);
#endregion Arrange
#region Act
var result = Controller.ReroutePurchaser(1)
.AssertActionRedirect()
.ToAction <OrderController>(a => a.Review(1));
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.RouteValues["id"]);
Assert.AreEqual("Order Status must be at account manager or purchaser to change purchaser.", Controller.ErrorMessage);
#endregion Assert
}
public void TestOrderAutoApprovalAddedAddsTracking()
{
#region Arrange
var order = CreateValidEntities.Order(1);
var approval = CreateValidEntities.Approval(1);
approval.User = CreateValidEntities.User(3);
approval.StatusCode = CreateValidEntities.OrderStatusCode(4);
#endregion Arrange
#region Act
EventService.OrderAutoApprovalAdded(order, approval);
#endregion Act
#region Assert
NotificationService.AssertWasNotCalled(a => a.OrderApproved(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
Assert.AreEqual(1, order.OrderTrackings.Count());
Assert.AreEqual("FirstName3 LastName3", order.OrderTrackings[0].User.FullName);
Assert.AreEqual("Name4", order.OrderTrackings[0].StatusCode.Name);
Assert.AreEqual("automatically approved", order.OrderTrackings[0].Description);
#endregion Assert
}
public void OrdersCanBeWrittenToDatabaseWithTheoryWithHelper(int value)
{
using (var contextHelper = new ContextHelper <ApplicationDbContext>())
{
contextHelper.Context.Orders.Count().ShouldBe(0);
contextHelper.Context.Users.Add(CreateValidEntities.User(1));
contextHelper.Context.SaveChanges();
for (int i = 0; i < value; i++)
{
var order = CreateValidEntities.Order(i + 1);
order.Creator = contextHelper.Context.Users.FirstOrDefault();
contextHelper.Context.Orders.Add(order);
}
contextHelper.Context.SaveChanges();
contextHelper.Context.Orders.Count().ShouldBe(value);
}
}
public void OrdersCanBeWrittenToDatabaseWithExistingUser()
{
using (var contextHelper = new ContextHelper <ApplicationDbContext>())
{
contextHelper.Context.Orders.Count().ShouldBe(0);
contextHelper.Context.Users.Add(CreateValidEntities.User(5));
contextHelper.Context.SaveChanges();
var order = CreateValidEntities.Order(1);
order.Creator = contextHelper.Context.Users.FirstOrDefault();
contextHelper.Context.Orders.Add(order);
contextHelper.Context.SaveChanges();
var updatedOrders = contextHelper.Context.Orders.Include(a => a.Creator).ToList();
contextHelper.Context.Users.Count().ShouldBe(1);
updatedOrders.Count().ShouldBe(1);
updatedOrders[0].Creator.FirstName.ShouldBe("FirstName5");
}
}
public void TestReRouteApprovalsForExistingOrderWhenCurrectLevelIsApprove02()
{
#region Arrange
var order = CreateValidEntities.Order(1);
order.CreatedBy = CreateValidEntities.User(3);
order.SetIdTo(99);
order.Splits = new List <Split>();
order.Splits.Add(CreateValidEntities.Split(1));
order.Splits[0].Order = order;
order.StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.Approver);
order.Approvals = new List <Approval>();
order.Approvals.Add(CreateValidEntities.Approval(1));
order.Approvals.Add(CreateValidEntities.Approval(2));
order.Approvals.Add(CreateValidEntities.Approval(3));
order.Approvals[0].StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.Approver);
order.Approvals[1].StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.AccountManager);
order.Approvals[2].StatusCode = OrderStatusCodeRepository.Queryable.Single(a => a.Id == OrderStatusCode.Codes.Purchaser);
new FakeUsers(4, UserRepository);
UserIdentity.Expect(a => a.Current).Return("3");
#endregion Arrange
#region Act
OrderService.ReRouteApprovalsForExistingOrder(order, "3", "2");
#endregion Act
#region Assert
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(2));
EventService.AssertWasCalled(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
EventService.AssertWasCalled(a => a.OrderReRouted(order));
Assert.AreEqual(3, order.Approvals.Count);
Assert.AreEqual("LastName3", order.Approvals[0].User.LastName);
Assert.IsTrue(order.Approvals[0].Completed);
Assert.AreEqual("LastName2", order.Approvals[1].User.LastName);
Assert.IsNull(order.Approvals[2].User);
#endregion Assert
}
public void TestReroutePurchaserPostRedirectsWhenWrongStatus7()
{
#region Arrange
var orders = new List <Order>();
orders.Add(CreateValidEntities.Order(1));
orders[0].StatusCode.SetIdTo(OrderStatusCode.Codes.Requester);
new FakeOrders(0, OrderRepository, orders);
#endregion Arrange
#region Act
var result = Controller.ReroutePurchaser(1, "test")
.AssertActionRedirect()
.ToAction <OrderController>(a => a.Review(1));
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.RouteValues["id"]);
Assert.AreEqual("Order Status must be at account manager or purchaser to change purchaser.", Controller.ErrorMessage);
ApprovalRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <Approval> .Is.Anything));
OrderService.AssertWasNotCalled(a => a.ReRouteSingleApprovalForExistingOrder(Arg <Approval> .Is.Anything, Arg <User> .Is.Anything, Arg <bool> .Is.Anything));
#endregion Assert
}