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 void TestCanUserManageGivenLogin3() { #region Arrange UserService = new UserService(UnitService, UnitAssociationRepository, PermissionRepository); ControllerRecordFakes.FakeUnits(6, UnitRepository); ControllerRecordFakes.FakeRoles(6, RoleRepository); ControllerRecordFakes.FakeApplications(3, ApplicationRepository); ControllerRecordFakes.FakeUsers(6, UserRepository); //These are the units that the current user has if he has the correct access UnitService.Expect(a => a.GetVisibleByUser("Name1", "UserName")).Return(UnitRepository.Queryable.Where(a => a.Id == 2 || a.Id == 4)).Repeat.Any(); var unitAssociations = new List <UnitAssociation>(); for (int i = 0; i < 5; i++) { unitAssociations.Add(CreateValidEntities.UnitAssociation(i + 1)); unitAssociations[i].User = UserRepository.GetNullableById(3); //Different LoginId unitAssociations[i].Application = ApplicationRepository.Queryable.First(); unitAssociations[i].Unit = UnitRepository.GetNullableById(i + 1); } ControllerRecordFakes.FakeUnitAssociations(0, UnitAssociationRepository, unitAssociations); #endregion Arrange #region Act var result = UserService.CanUserManageGivenLogin("Name1", "UserName", "LoginId2"); #endregion Act #region Assert Assert.IsFalse(result); #endregion Assert }
public void TestApprovalsWithANewValueDoesNotSave() { Split record = null; try { #region Arrange record = GetValid(9); record.Approvals.Add(CreateValidEntities.Approval(1)); #endregion Arrange #region Act SplitRepository.DbContext.BeginTransaction(); SplitRepository.EnsurePersistent(record); SplitRepository.DbContext.CommitTransaction(); #endregion Act } catch (Exception ex) { Assert.IsNotNull(record); Assert.IsNotNull(ex); Assert.AreEqual("object references an unsaved transient instance - save the transient instance before flushing or set cascade action for the property to something that would make it autosave. Type: Purchasing.Core.Domain.Approval, Entity: Purchasing.Core.Domain.Approval", ex.Message); throw; } }
public void TestByWorkgroupReturnsView1() { #region Arrange var wg1 = CreateValidEntities.Workgroup(1); var wg2 = CreateValidEntities.Workgroup(2); wg1.SetIdTo(2); wg2.SetIdTo(3); var conditionalApprovals = new List <ConditionalApproval>(); conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(1)); conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(2)); conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(3)); conditionalApprovals[0].Workgroup = wg1; conditionalApprovals[1].Workgroup = wg2; conditionalApprovals[2].Workgroup = wg1; new FakeConditionalApprovals(0, ConditionalApprovalRepository, conditionalApprovals); #endregion Arrange #region Act var result = Controller.ByWorkgroup(2) .AssertViewRendered() .WithViewData <IQueryable <ConditionalApproval> >(); #endregion Act #region Assert Assert.IsNotNull(result); Assert.AreEqual(2, result.Count()); Assert.AreEqual(2, Controller.ViewBag.WorkgroupId); #endregion Assert }
public void TestCanCorrectlyMapSchool2() { #region Arrange var session = NHibernateSessionManager.Instance.GetSession(); var school = new School(); school.SetIdTo("Id"); Repository.OfType <Unit>().DbContext.BeginTransaction(); for (int i = 0; i < 3; i++) { var unit = CreateValidEntities.Unit(i + 1); unit.School = school; Repository.OfType <Unit>().EnsurePersistent(unit); } Repository.OfType <Unit>().DbContext.CommitTransaction(); IList <Unit> units = Repository.OfType <Unit>().Queryable.Where(a => a.School.Id == "Id").ToList(); Assert.AreEqual(3, units.Count); #endregion Arrange #region Act/Assert new PersistenceSpecification <School>(session, new SchoolEqualityComparer()) .CheckProperty(c => c.Id, "Id") .CheckProperty(c => c.Abbreviation, "Abbreviation") .CheckProperty(c => c.LongDescription, "LongDescription") .CheckProperty(c => c.ShortDescription, "ShortDescription") .CheckProperty(c => c.Units, units) .VerifyTheMappings(); #endregion Act/Assert }
public void TestEditWorkgroupVendorPostThrowsException2() { var thisFar = false; try { #region Arrange new FakeVendors(3, VendorRepository); var workgroupVendors = new List <WorkgroupVendor>(); workgroupVendors.Add(CreateValidEntities.WorkgroupVendor(5)); workgroupVendors[0].VendorId = null; workgroupVendors[0].VendorAddressTypeCode = null; new FakeWorkgroupVendors(0, WorkgroupVendorRepository, workgroupVendors); var workgroupVendor = CreateValidEntities.WorkgroupVendor(9); workgroupVendor.VendorId = " "; workgroupVendor.VendorAddressTypeCode = "tc"; thisFar = true; #endregion Arrange #region Act Controller.EditWorkgroupVendor(0, 1, workgroupVendor); #endregion Act } catch (Exception ex) { Assert.IsTrue(thisFar); Assert.IsNotNull(ex); Assert.AreEqual("Can't have vendorAddresstypeCode when editing", ex.Message); throw; } }
public void TestGetRequesters() { #region Arrange var workgroupPermissions = new List <WorkgroupPermission>(); for (int i = 0; i < 6; i++) { workgroupPermissions.Add(CreateValidEntities.WorkgroupPermission(i + 1)); workgroupPermissions[i].User = CreateValidEntities.User(i + 1); workgroupPermissions[i].User.SetIdTo((i + 1).ToString(CultureInfo.InvariantCulture)); workgroupPermissions[i].User.IsActive = true; workgroupPermissions[i].Workgroup = CreateValidEntities.Workgroup(1); workgroupPermissions[i].Workgroup.SetIdTo(1); workgroupPermissions[i].Role = CreateValidEntities.Role(1); workgroupPermissions[i].Role.SetIdTo(Role.Codes.Requester); } workgroupPermissions[0].User.IsActive = false; workgroupPermissions[2].Workgroup.SetIdTo(99); workgroupPermissions[3].Role.SetIdTo(Role.Codes.Admin); new FakeWorkgroupPermissions(0, WorkgroupPermissionRepository, workgroupPermissions); #endregion Arrange #region Act var result = Controller.GetRequesters(1) .AssertResultIs <JsonNetResult>(); #endregion Act #region Assert Assert.IsNotNull(result); Assert.AreEqual("[{\"Name\":\"FirstName2 LastName2 (2)\",\"Id\":\"2\"},{\"Name\":\"FirstName5 LastName5 (5)\",\"Id\":\"5\"},{\"Name\":\"FirstName6 LastName6 (6)\",\"Id\":\"6\"}]", result.JsonResultString); #endregion Assert }
public void TestSearchUsersReturnsExpectedResults4() { #region Arrange var users = new List <User>(); for (int i = 0; i < 3; i++) { users.Add(CreateValidEntities.User(i + 1)); users[i].Email = "email" + (i + 1); } new FakeUsers(0, UserRepository, users, false); SearchService.Expect(a => a.SearchUsers("bob")).Return(new List <DirectoryUser>()); #endregion Arrange #region Act var result = Controller.SearchUsers("Bob") .AssertResultIs <JsonNetResult>(); #endregion Act #region Assert Assert.IsNotNull(result); Assert.AreEqual("[]", result.JsonResultString); UserRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <User> .Is.Anything)); SearchService.AssertWasCalled(a => a.SearchUsers("bob")); #endregion Assert }
public void TestAddPermissionThrowsExceptionIfloginIdDuplicate() { try { #region Arrange Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" }); ControllerRecordFakes.FakeApplications(3, ApplicationRepository); ControllerRecordFakes.FakeRoles(5, RoleRepository); var users = new List <User> { CreateValidEntities.User(1), CreateValidEntities.User(1) }; ControllerRecordFakes.FakeUsers(3, UserRepository, users); ControllerRecordFakes.FakePermissions(1, PermissionRepository); RoleService.Expect(a => a.GetVisibleByUser("Name2", "UserName")).Return(RoleRepository.Queryable).Repeat.Any(); UserService.Expect(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")).Return(true).Repeat.Any(); PermissionRepository.Expect(a => a.EnsurePersistent(Arg <Permission> .Is.Anything)).Repeat.Any(); #endregion Arrange #region Act Controller.AddPermission("Name2", "LoginId1", 3); #endregion Act } catch (Exception ex) { #region Assert Assert.IsNotNull(ex); Assert.AreEqual("Sequence contains more than one element", ex.Message); UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name2", "UserName", "LoginId1")); RoleService.AssertWasCalled(a => a.GetVisibleByUser("Name2", "UserName")); PermissionRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <Permission> .Is.Anything)); #endregion Assert throw; } }
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 TestSearchUsersReturnsExpectedResults3() { #region Arrange var users = new List <User>(); for (int i = 0; i < 3; i++) { users.Add(CreateValidEntities.User(i + 1)); users[i].Email = "email" + (i + 1); } new FakeUsers(0, UserRepository, users, false); var ldapLookup = new DirectoryUser(); ldapLookup.EmailAddress = "*****@*****.**"; ldapLookup.FirstName = "Bob"; ldapLookup.LastName = "Loblaw"; ldapLookup.LoginId = "belogin"; var ldapUsers = new List <DirectoryUser>(); ldapUsers.Add(ldapLookup); SearchService.Expect(a => a.SearchUsers("bob")).Return(ldapUsers); #endregion Arrange #region Act var result = Controller.SearchUsers("Bob") .AssertResultIs <JsonNetResult>(); #endregion Act #region Assert Assert.IsNotNull(result); Assert.AreEqual("[{\"Id\":\"belogin\",\"Label\":\"Bob Loblaw (belogin)\"}]", result.JsonResultString); UserRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <User> .Is.Anything)); SearchService.AssertWasCalled(a => a.SearchUsers("bob")); #endregion Assert }
public void TestPermissionWithUnsavedRoleDoesNotSaveOrCascade() { Permission permission = null; try { #region Arrange permission = GetValid(9); permission.Role = CreateValidEntities.Role(99); #endregion Arrange #region Act PermissionRepository.DbContext.BeginTransaction(); PermissionRepository.EnsurePersistent(permission); PermissionRepository.DbContext.CommitTransaction(); #endregion Act } catch (Exception ex) { Assert.IsNotNull(permission); Assert.IsNotNull(ex); Assert.AreEqual("not-null property references a null or transient value Catbert4.Core.Domain.Permission.Role", ex.Message); throw; } }
public void TestOrganizationWithNewValueDoesNotSave() { var thisFar = false; try { #region Arrange var record = GetValid(9); record.Organization = CreateValidEntities.Organization(99); thisFar = true; #endregion Arrange #region Act ConditionalApprovalRepository.DbContext.BeginTransaction(); ConditionalApprovalRepository.EnsurePersistent(record); ConditionalApprovalRepository.DbContext.CommitTransaction(); #endregion Act } catch (Exception ex) { Assert.IsTrue(thisFar); Assert.IsNotNull(ex); Assert.AreEqual("object references an unsaved transient instance - save the transient instance before flushing or set cascade action for the property to something that would make it autosave. Type: Purchasing.Core.Domain.Organization, Entity: Purchasing.Core.Domain.Organization", 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 TestDenyPostRedirectsWhenValid() { #region Arrange var dars = new List <DepartmentalAdminRequest>(); dars.Add(CreateValidEntities.DepartmentalAdminRequest(3)); dars[0].SetIdTo("3"); dars[0].Complete = false; new FakeDepartmentalAdminRequests(0, DepartmentalAdminRequestRepository, dars, true); var dar = new DepartmentalAdminRequestViewModel { DepartmentalAdminRequest = new DepartmentalAdminRequest("3") }; #endregion Arrange #region Act Controller.Deny(dar) .AssertActionRedirect() .ToAction <DepartmentalAdminRequestController>(a => a.Index(null)); #endregion Act #region Assert Assert.AreEqual("Request Denied for FirstName3 LastName3 (3)", Controller.Message); DepartmentalAdminRequestRepository.AssertWasCalled(a => a.EnsurePersistent(Arg <DepartmentalAdminRequest> .Is.Anything)); var args = (DepartmentalAdminRequest)DepartmentalAdminRequestRepository.GetArgumentsForCallsMadeOn(a => a.EnsurePersistent(Arg <DepartmentalAdminRequest> .Is.Anything))[0][0]; Assert.IsTrue(args.Complete); DepartmentalAdminRequestRepository.AssertWasNotCalled(a => a.Remove(Arg <DepartmentalAdminRequest> .Is.Anything)); #endregion Assert }
public void TestAddPermissionWhenPermissionAlreadyExists() { #region Arrange Controller.ControllerContext.HttpContext = new MockHttpContext(1, new[] { "" }); ControllerRecordFakes.FakeRoles(5, RoleRepository); ControllerRecordFakes.FakeApplications(3, ApplicationRepository); ControllerRecordFakes.FakeUsers(3, UserRepository); var permissions = new List <Permission> { CreateValidEntities.Permission(1) }; permissions[0].Application = ApplicationRepository.GetNullableById(3); permissions[0].User = UserRepository.GetNullableById(3); permissions[0].Role = RoleRepository.GetNullableById(2); ControllerRecordFakes.FakePermissions(1, PermissionRepository, permissions); UserService.Expect(a => a.CanUserManageGivenLogin("Name3", "UserName", "LoginId3")).Return(true).Repeat.Any(); RoleService.Expect(a => a.GetVisibleByUser("Name3", "UserName")).Return(RoleRepository.Queryable).Repeat.Any(); PermissionRepository.Expect(a => a.EnsurePersistent(Arg <Permission> .Is.Anything)).Repeat.Any(); #endregion Arrange #region Act Controller.AddPermission("Name3", "LoginId3", 2); #endregion Act #region Assert UserService.AssertWasCalled(a => a.CanUserManageGivenLogin("Name3", "UserName", "LoginId3")); RoleService.AssertWasCalled(a => a.GetVisibleByUser("Name3", "UserName")); PermissionRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <Permission> .Is.Anything)); #endregion Assert }
public void TestDetailsGetReturnsViewWhenDarCompleted() { #region Arrange var dars = new List <DepartmentalAdminRequest>(); dars.Add(CreateValidEntities.DepartmentalAdminRequest(1)); dars[0].Complete = true; new FakeDepartmentalAdminRequests(0, DepartmentalAdminRequestRepository, dars, false); new FakeUsers(2, UserRepository); new FakeOrganizations(3, OrganizationRepository); new FakeOrganizationDescendants(3, QueryRepositoryFactory.OrganizationDescendantRepository); #endregion Arrange #region Act var result = Controller.Details("1") .AssertViewRendered() .WithViewData <DepartmentalAdminRequestViewModel>(); #endregion Act #region Assert Assert.IsNotNull(result); Assert.AreEqual("1", result.DepartmentalAdminRequest.Id); Assert.IsTrue(result.UserExists); Assert.IsFalse(result.UserIsAlreadyDA); Assert.AreEqual(0, result.ExistingOrganizations.Count()); Assert.AreEqual(2, result.Organizations.Count()); Assert.AreEqual("1", result.Organizations[0].Id); Assert.AreEqual("2", result.Organizations[1].Id); #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 TestEditWorkgroupVendorPostReturnsViewWhenNotValid() { #region Arrange new FakeVendors(3, VendorRepository); var workgroupVendors = new List <WorkgroupVendor>(); workgroupVendors.Add(CreateValidEntities.WorkgroupVendor(5)); workgroupVendors[0].VendorId = null; workgroupVendors[0].VendorAddressTypeCode = null; new FakeWorkgroupVendors(0, WorkgroupVendorRepository, workgroupVendors); var workgroupVendor = CreateValidEntities.WorkgroupVendor(9); workgroupVendor.VendorId = null; workgroupVendor.VendorAddressTypeCode = null; workgroupVendor.Name = null; WorkgroupService.Expect(a => a.TransferValues(Arg <WorkgroupVendor> .Is.Anything, ref Arg <WorkgroupVendor> .Ref(Is.Anything(), workgroupVendor).Dummy)); #endregion Arrange #region Act var result = Controller.EditWorkgroupVendor(0, 1, workgroupVendor) .AssertViewRendered() .WithViewData <WorkgroupVendorViewModel>(); #endregion Act #region Assert Controller.ModelState.AssertErrorsAre("The Name field is required."); Assert.IsNotNull(result); Assert.AreEqual("Line19", result.WorkgroupVendor.Line1); #endregion Assert }
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 TestByOrgReturnsView2() { #region Arrange var org1 = CreateValidEntities.Organization(1); var org2 = CreateValidEntities.Organization(2); org1.SetIdTo("test"); org2.SetIdTo("test2"); var conditionalApprovals = new List <ConditionalApproval>(); conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(1)); conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(2)); conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(3)); conditionalApprovals[0].Organization = org1; conditionalApprovals[1].Organization = org2; conditionalApprovals[2].Organization = org1; new FakeConditionalApprovals(0, ConditionalApprovalRepository, conditionalApprovals); #endregion Arrange #region Act var result = Controller.ByOrg("test2") .AssertViewRendered() .WithViewData <IQueryable <ConditionalApproval> >(); #endregion Act #region Assert Assert.IsNotNull(result); Assert.AreEqual(1, result.Count()); Assert.AreEqual("test2", Controller.ViewBag.OrganizationId); #endregion Assert }
public async Task TestConfirmationPostWhenUcdAccountNotVerified2() { // Arrange OrderData[1].CreatorId = "Creator1"; OrderData[1].Status = OrderStatusCodes.Created; OrderData[1].PaymentType = PaymentTypeCodes.UcDavisAccount; Controller.ErrorMessage = null; var orderDetails = CreateValidEntities.OrderDetails(2); orderDetails.Payment.Account = "3-1234567"; orderDetails.Payment.AccountName = "WHAT!"; OrderData[1].SaveDetails(orderDetails); MockFinancialService.Setup(a => a.GetAccountName(It.IsAny <string>())).ReturnsAsync(string.Empty); // Act var controllerResult = await Controller.Confirmation(2, true); // Assert Controller.ErrorMessage.ShouldBe("Unable to verify UC Account number. Please edit your order and re-enter the UC account number. Then try again."); OrderData[1].GetOrderDetails().Payment.AccountName.ShouldBeEmpty(); MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Once); MockFinancialService.Verify(a => a.GetAccountName("3-1234567"), Times.Once); var redirectResult = Assert.IsType <RedirectToActionResult>(controllerResult); redirectResult.ActionName.ShouldBe("Confirmation"); redirectResult.RouteValues["id"].ShouldBe(2); redirectResult.ControllerName.ShouldBeNull(); }
public void TestUnitsWithNewUnitValueDoesNotSave() { School school = null; try { #region Arrange school = GetValid(9); school.Units.Add(CreateValidEntities.Unit(9)); #endregion Arrange #region Act SchoolRepository.DbContext.BeginTransaction(); SchoolRepository.EnsurePersistent(school); SchoolRepository.DbContext.CommitTransaction(); #endregion Act } catch (Exception ex) { Assert.IsNotNull(school); Assert.IsNotNull(ex); Assert.AreEqual("Object reference not set to an instance of an object.", ex.Message); throw; } }
public async Task TestConfirmationPostWhenUcdAccountVerified() { // Arrange OrderData[1].CreatorId = "Creator1"; OrderData[1].Status = OrderStatusCodes.Created; OrderData[1].PaymentType = PaymentTypeCodes.UcDavisAccount; Controller.ErrorMessage = null; var orderDetails = CreateValidEntities.OrderDetails(2); orderDetails.Payment.Account = "3-1234567"; orderDetails.Payment.AccountName = "WHAT!"; orderDetails.ClientInfo.ClientId = null; OrderData[1].SaveDetails(orderDetails); MockFinancialService.Setup(a => a.GetAccountName(It.IsAny <string>())).ReturnsAsync("My Fake Account"); // Act var controllerResult = await Controller.Confirmation(2, true); // Assert Controller.ErrorMessage.ShouldBeNull(); OrderData[1].GetOrderDetails().Payment.AccountName.ShouldBe("My Fake Account"); MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Once); MockFinancialService.Verify(a => a.GetAccountName("3-1234567"), Times.Once); MockOrderService.Verify(a => a.UpdateAdditionalInfo(OrderData[1]), Times.Once); MockOrderService.Verify(a => a.UpdateTestsAndPrices(OrderData[1]), Times.Once); var redirectResult = Assert.IsType <RedirectToActionResult>(controllerResult); redirectResult.ActionName.ShouldBe("Confirmed"); redirectResult.RouteValues["id"].ShouldBe(2); redirectResult.ControllerName.ShouldBeNull(); }
public void TestGetVisibleByUserReturnsExpectedResults1() { #region Arrange IRepository <School> schoolRepository = FakeRepository <School>(); Controller.Repository.Expect(a => a.OfType <School>()).Return(schoolRepository).Repeat.Any(); UnitService = new UnitService(RoleService, schoolRepository, UnitRepository, UnitAssociationRepository); var roles = new List <Role>(); roles.Add(CreateValidEntities.Role(1)); roles[0].Name = "ManageAll"; roles.Add(CreateValidEntities.Role(2)); roles[1].Name = "ManageSchool"; ControllerRecordFakes.FakeRoles(5, RoleRepository, roles); ControllerRecordFakes.FakeApplications(3, ApplicationRepository); ControllerRecordFakes.FakeUnits(3, UnitRepository); RoleService.Expect(a => a.GetManagementRolesForUserInApplication("Name2", "UserName")).Return(RoleRepository.Queryable.Select(a => a.Name).ToList()).Repeat.Any(); #endregion Arrange #region Act var result = UnitService.GetVisibleByUser("Name2", "UserName"); #endregion Act #region Assert Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IQueryable <Unit>)); Assert.AreEqual(3, result.Count()); Assert.AreEqual("ShortName2", result.ElementAt(1).ShortName); #endregion Assert }
public async Task TestConfirmationPostWhenPaymentOther2() { // Arrange OrderData[1].CreatorId = "Creator1"; OrderData[1].Status = OrderStatusCodes.Created; OrderData[1].PaymentType = PaymentTypeCodes.Other; Controller.ErrorMessage = null; var orderDetails = CreateValidEntities.OrderDetails(2); orderDetails.OtherPaymentInfo.PaymentType = "SomethingElse"; orderDetails.ClientInfo.ClientId = null; OrderData[1].SaveDetails(orderDetails); // Act var controllerResult = await Controller.Confirmation(2, true); // Assert Controller.ErrorMessage.ShouldBeNull(); OrderData[1].GetOrderDetails().Payment.AccountName.ShouldBeNull(); MockDbContext.Verify(a => a.SaveChangesAsync(new CancellationToken()), Times.Once); MockFinancialService.Verify(a => a.GetAccountName(It.IsAny <string>()), Times.Never); MockOrderMessagingService.Verify(a => a.EnqueueBillingMessage(OrderData[1], It.IsAny <string>()), Times.Never); MockOrderService.Verify(a => a.UpdateTestsAndPrices(OrderData[1]), Times.Once); MockOrderService.Verify(a => a.UpdateAdditionalInfo(OrderData[1]), Times.Once); MockLabworksService.Verify(a => a.GetClientDetails(It.IsAny <string>()), Times.Never); MockOrderMessagingService.Verify(a => a.EnqueueCreatedMessage(OrderData[1]), Times.Once); var redirectResult = Assert.IsType <RedirectToActionResult>(controllerResult); redirectResult.ActionName.ShouldBe("Confirmed"); redirectResult.RouteValues["id"].ShouldBe(2); redirectResult.ControllerName.ShouldBeNull(); }
public void TestCreateWhenWorkgroupNotFound() { var thisFar = false; try { #region Arrange var workgroups = new List <Workgroup>(); workgroups.Add(CreateValidEntities.Workgroup(1)); workgroups.Add(CreateValidEntities.Workgroup(2)); workgroups[0].Administrative = true; new FakeWorkgroups(0, WorkgroupRepository, workgroups); thisFar = true; #endregion Arrange #region Act Controller.Create(3, null); #endregion Act } catch (Exception ex) { Assert.IsTrue(thisFar); Assert.IsNotNull(ex); Assert.AreEqual("Sequence contains no matching element", ex.Message); throw; } }
public void TestDenyPostRedirectsWhenAlreadyCompleted() { #region Arrange var dars = new List <DepartmentalAdminRequest>(); dars.Add(CreateValidEntities.DepartmentalAdminRequest(3)); dars[0].SetIdTo("3"); dars[0].Complete = true; new FakeDepartmentalAdminRequests(0, DepartmentalAdminRequestRepository, dars, true); var dar = new DepartmentalAdminRequestViewModel { DepartmentalAdminRequest = new DepartmentalAdminRequest("3") }; #endregion Arrange #region Act Controller.Deny(dar) .AssertActionRedirect() .ToAction <DepartmentalAdminRequestController>(a => a.Index(null)); #endregion Act #region Assert Assert.AreEqual("Request was already completed", Controller.Message); DepartmentalAdminRequestRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <DepartmentalAdminRequest> .Is.Anything)); DepartmentalAdminRequestRepository.AssertWasNotCalled(a => a.Remove(Arg <DepartmentalAdminRequest> .Is.Anything)); #endregion Assert }
public void TestIndexReturnsView() { #region Arrange var daRequest = new List <DepartmentalAdminRequest>(); for (int i = 0; i < 4; i++) { daRequest.Add(CreateValidEntities.DepartmentalAdminRequest(i + 1)); daRequest[i].Complete = false; daRequest[i].DateCreated = DateTime.UtcNow.ToPacificTime().Date.AddDays(-i); } daRequest[1].Complete = true; new FakeDepartmentalAdminRequests(0, DepartmentalAdminRequestRepository, daRequest, false); #endregion Arrange #region Act var results = Controller.Index() .AssertViewRendered() .WithViewData <IList <DepartmentalAdminRequest> >(); #endregion Act #region Assert Assert.IsNotNull(results); Assert.AreEqual(3, results.Count()); Assert.AreEqual("4", results[0].Id); Assert.AreEqual("3", results[1].Id); Assert.AreEqual("1", results[2].Id); #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; } }