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;
}
}
