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 }