public void TestEditPostSavesWhenValid()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(0, new[] { "" }, "Me");
SetupData2();
SetupData3();
var autoApprovalToEdit = CreateValidEntities.AutoApproval(99);
autoApprovalToEdit.SetIdTo(99);
autoApprovalToEdit.MaxAmount = (decimal)12.44;
autoApprovalToEdit.TargetUser = null;
autoApprovalToEdit.Account = CreateValidEntities.Account(9);
autoApprovalToEdit.User = null;
var saveLessThan = AutoApprovalRepository.GetNullableById(3).LessThan;
autoApprovalToEdit.LessThan = !saveLessThan;
#endregion Arrange
#region Act
var result = Controller.Edit(3, autoApprovalToEdit, true)
.AssertActionRedirect()
.ToAction <AutoApprovalController>(a => a.Index(true));
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(true, result.RouteValues["showAll"]);
AutoApprovalRepository.AssertWasCalled(a => a.EnsurePersistent(Arg <AutoApproval> .Is.Anything));
var args = (AutoApproval)AutoApprovalRepository.GetArgumentsForCallsMadeOn(a => a.EnsurePersistent(Arg <AutoApproval> .Is.Anything))[0][0];
Assert.AreEqual(3, args.Id);
Assert.AreEqual((decimal)12.44, args.MaxAmount);
Assert.IsNotNull(args.User);
Assert.AreNotEqual(args.LessThan, saveLessThan);
Assert.AreEqual("AutoApproval Edited Successfully", Controller.Message);
#endregion Assert
}
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
}
/// <summary>
/// Loads the data.
/// </summary>
protected override void LoadData()
{
AccountRepository.DbContext.BeginTransaction();
for (int i = 0; i < 5; i++)
{
var account = CreateValidEntities.Account(i + 1);
account.SetIdTo(string.Format("Acc{0}", (i + 1).ToString(CultureInfo.InvariantCulture)));
AccountRepository.EnsurePersistent(account);
}
SubAccountRepository.DbContext.BeginTransaction();
LoadRecords(5);
SubAccountRepository.DbContext.CommitTransaction();
}
public void TestNameAndIdReturnsExpectedString()
{
#region Arrange
var record = CreateValidEntities.Account(4);
record.SetIdTo("IdTest");
#endregion Arrange
#region Act
var result = record.NameAndId;
#endregion Act
#region Assert
Assert.AreEqual("Name4 (IdTest)", result);
#endregion Assert
}
public void TestAccountDisplay2()
{
#region Arrange
var record = new Split();
record.Account = "Test";
record.DbAccount = CreateValidEntities.Account(3);
record.DbSubAccount = CreateValidEntities.SubAccount(4);
#endregion Arrange
#region Act
#endregion Act
#region Assert
Assert.AreEqual("Name3 (3)", record.AccountDisplay);
#endregion Assert
}
public void TestEditPostReturnsViewWhenInvalid3()
{
#region Arrange
Controller.ControllerContext.HttpContext = new MockHttpContext(0, new[] { "" }, "Me");
SetupData2();
SetupData3();
var autoApprovalToEdit = CreateValidEntities.AutoApproval(99);
autoApprovalToEdit.SetIdTo(99);
autoApprovalToEdit.MaxAmount = (decimal)12.44;
autoApprovalToEdit.TargetUser = CreateValidEntities.User(88);
autoApprovalToEdit.Account = CreateValidEntities.Account(87);
autoApprovalToEdit.User = null;
#endregion Arrange
#region Act
var result = Controller.Edit(3, autoApprovalToEdit, true)
.AssertViewRendered()
.WithViewData <AutoApprovalViewModel>();
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(4, result.Users.Count);
Assert.AreEqual(7, result.Accounts.Count);
Assert.AreEqual("Someone55", result.Users[0].Id);
Assert.AreEqual("Someone2", result.Users[1].Id);
Assert.AreEqual("Someone3", result.Users[2].Id);
Assert.AreEqual("Someone4", result.Users[3].Id);
Assert.AreEqual("AccountName2", result.Accounts[0].Name);
Assert.AreEqual("AccountName3", result.Accounts[1].Name);
Assert.AreEqual("AccountName5", result.Accounts[2].Name);
Assert.AreEqual("AccountName6", result.Accounts[3].Name);
Assert.AreEqual("AccountName7", result.Accounts[4].Name);
Assert.AreEqual("AccountName8", result.Accounts[5].Name);
Assert.AreEqual("AccountName9", result.Accounts[6].Name);
Assert.AreEqual(3, result.AutoApproval.Id);
Assert.AreEqual((decimal)12.44, result.AutoApproval.MaxAmount);
Assert.IsNotNull(result.AutoApproval.User);
Assert.IsTrue(Controller.ViewBag.ShowAll);
Assert.IsFalse(Controller.ViewBag.IsCreate);
Controller.ModelState.AssertErrorsAre("An account OR user must be selected, not both.");
AutoApprovalRepository.AssertWasNotCalled(a => a.EnsurePersistent(Arg <AutoApproval> .Is.Anything));
#endregion Assert
}
public void TestCreateWorkgroupWhenSyncAccountsIsSelectedAddsAccounts()
{
#region Arrange
var organizations = new List <Organization>();
organizations.Add(CreateValidEntities.Organization(1));
organizations[0].SetIdTo("1");
organizations.Add(CreateValidEntities.Organization(2));
organizations[1].SetIdTo("2");
new FakeOrganizations(0, OrganizationRepository, organizations, true);
var accounts = new List <Account>();
for (int i = 0; i < 5; i++)
{
accounts.Add(CreateValidEntities.Account(i + 1));
accounts[i].OrganizationId = "1";
}
accounts[3].OrganizationId = "2";
new FakeAccounts(0, RepositoryFactory.AccountRepository, accounts, false);
var workgroup = CreateValidEntities.Workgroup(1);
workgroup.SyncAccounts = true;
workgroup.Accounts = new List <WorkgroupAccount>();
workgroup.PrimaryOrganization = organizations[0];
workgroup.Organizations.Add(organizations[1]);
new FakeRelatedWorkgroups(3, QueryRepositoryFactory.RelatatedWorkgroupsRepository);
new FakeWorkgroupPermissions(3, WorkgroupPermissionRepository);
#endregion Arrange
#region Act
var result = WorkgroupService.CreateWorkgroup(workgroup, new [] { "2" });
#endregion Act
#region Assert
Assert.IsNotNull(result);
WorkgroupRepository.AssertWasCalled(a => a.EnsurePersistent(result));
RepositoryFactory.AccountRepository.AssertWasCalled(a => a.Queryable);
Assert.AreEqual(4, result.Accounts.Count());
#endregion Assert
}
public void TestAccountNumberWithOneCharacterSaves()
{
#region Arrange
AccountRepository.DbContext.BeginTransaction();
var account = CreateValidEntities.Account(1);
account.SetIdTo("x");
AccountRepository.EnsurePersistent(account);
var subAccount = GetValid(9);
subAccount.AccountNumber = "x";
#endregion Arrange
#region Act
SubAccountRepository.DbContext.BeginTransaction();
SubAccountRepository.EnsurePersistent(subAccount);
SubAccountRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.IsFalse(subAccount.IsTransient());
Assert.IsTrue(subAccount.IsValid());
#endregion Assert
}
public void TestAccountWithOneSpaceSaves()
{
#region Arrange
AccountRepository.DbContext.BeginTransaction();
var account = CreateValidEntities.Account(1);
account.SetIdTo(" ");
AccountRepository.EnsurePersistent(account);
var split = GetValid(9);
split.Account = " ";
#endregion Arrange
#region Act
SplitRepository.DbContext.BeginTransaction();
SplitRepository.EnsurePersistent(split);
SplitRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.IsFalse(split.IsTransient());
Assert.IsTrue(split.IsValid());
#endregion Assert
}
public void TestAccountWithLongValueSaves()
{
#region Arrange
AccountRepository.DbContext.BeginTransaction();
var account = CreateValidEntities.Account(1);
account.SetIdTo("x".RepeatTimes(10));
AccountRepository.EnsurePersistent(account);
var split = GetValid(9);
split.Account = "x".RepeatTimes(10);
#endregion Arrange
#region Act
SplitRepository.DbContext.BeginTransaction();
SplitRepository.EnsurePersistent(split);
SplitRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.AreEqual(10, split.Account.Length);
Assert.IsFalse(split.IsTransient());
Assert.IsTrue(split.IsValid());
#endregion Assert
}
public void SetupData1()
{
var autoApprovals = new List <AutoApproval>();
for (int i = 0; i < 6; i++)
{
autoApprovals.Add(CreateValidEntities.AutoApproval(i + 1));
if (i % 2 == 0)
{
autoApprovals[i].TargetUser = null;
autoApprovals[i].Account = CreateValidEntities.Account(i);
}
autoApprovals[i].User.SetIdTo("Me");
}
autoApprovals[0].User.SetIdTo("NotMe");
autoApprovals[1].IsActive = false;
autoApprovals[2].Expiration = DateTime.UtcNow.ToPacificTime().Date;
autoApprovals[3].Expiration = DateTime.UtcNow.ToPacificTime().Date.AddDays(1);
autoApprovals[4].Expiration = DateTime.UtcNow.ToPacificTime().Date.AddDays(-1);
new FakeAutoApprovals(0, AutoApprovalRepository, autoApprovals);
}
public void TestCreateApprovalsForNewOrder2()
{
#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);
var accounts = new List <Account>();
accounts.Add(CreateValidEntities.Account(1));
accounts[0].SetIdTo("12345");
accounts[0].AccountManagerId = "TestUser";
new FakeAccounts(0, AccountRepository, accounts, true);
SecurityService.Expect(a => a.GetUser("TestUser")).Return(CreateValidEntities.User(55));
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, null, "12345", null, null);
#endregion Act
#region Assert
SecurityService.AssertWasCalled(a => a.GetUser("TestUser")); // 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);
Assert.AreEqual("LastName55", order.Approvals[0].User.LastName);
Assert.IsNull(order.Approvals[1].User);
Assert.AreEqual("12345", order.Splits[0].Account);
#endregion Assert
}
public void TestCreateApprovalsForNewOrder20()
{
#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.Splits.Add(new Split());
order.Splits[1].Account = "23456";
order.Splits[1].Order = order;
order.Splits.Add(new Split());
order.Splits[2].Account = "777";
order.Splits[2].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("777");
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("23456");
accounts[0].AccountManagerId = "TestUser";
accounts.Add(CreateValidEntities.Account(2));
accounts[1].SetIdTo("12345");
accounts[1].AccountManagerId = null;
new FakeAccounts(0, AccountRepository, accounts, true);
SecurityService.Expect(a => a.GetUser("TestUser")).Return(CreateValidEntities.User(55));
SecurityService.Expect(a => a.GetUser(null)).Return(null);
new FakeAutoApprovals(3, AutoAprovalRepository);
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, null, null, null, null);
#endregion Act
#region Assert
SecurityService.AssertWasCalled(a => a.GetUser("TestUser"));
SecurityService.AssertWasCalled(a => a.GetUser(null));
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(5));
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.AccountManager, order.Approvals[0].StatusCode.Id);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[1].StatusCode.Id);
var purchaserCount = 0;
var approverCount = 0;
var acctManagerCount = 0;
foreach (var approval in order.Approvals)
{
switch (approval.StatusCode.Id)
{
case OrderStatusCode.Codes.Purchaser:
purchaserCount++;
break;
case OrderStatusCode.Codes.AccountManager:
acctManagerCount++;
break;
case OrderStatusCode.Codes.Approver:
approverCount++;
break;
default:
throw new Exception("Should not be here!");
}
//Assert.IsNull(approval.User);
}
Assert.AreEqual(1, purchaserCount);
Assert.AreEqual(3, acctManagerCount);
Assert.AreEqual(1, approverCount);
//Assert.AreEqual("LastName66", order.Approvals[0].User.LastName);
Assert.AreEqual("LastName55", order.Approvals[2].User.LastName);
Assert.AreEqual("12345", order.Splits[0].Account);
Assert.AreEqual("23456", order.Splits[1].Account);
#endregion Assert
}
public void TestReRouteApprovalsForExistingOrderWhenCurrectLevelIsApprove06()
{
#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);
var accounts = new List <Account>();
accounts.Add(CreateValidEntities.Account(1));
accounts.Add(CreateValidEntities.Account(2));
accounts[0].AccountManagerId = "123";
accounts[1].AccountManagerId = "124";
accounts[0].SetIdTo("12345");
accounts[1].SetIdTo("23456");
new FakeAccounts(0, AccountRepository, accounts, true);
SecurityService.Expect(a => a.GetUser("123")).Return(CreateValidEntities.User(66));
SecurityService.Expect(a => a.GetUser("124")).Return(CreateValidEntities.User(77));
#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.AssertWasCalled(a => a.GetUser(Arg <string> .Is.Anything), x => x.Repeat.Times(2));
Assert.AreEqual(4, order.Approvals.Count);
Assert.AreEqual("LastName99", order.Approvals[0].User.LastName);
Assert.IsFalse(order.Approvals[0].Completed);
Assert.AreEqual("LastName66", order.Approvals[1].User.LastName);
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.AreEqual("LastName77", order.Approvals[3].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[3].StatusCode.Id);
#endregion Assert
}
public void TestReRouteApprovalsForExistingOrderWhenCurrectLevelIsApprove09()
{
#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[1].Account = "12345"; // switched order from one above
order.Splits[0].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);
var workgroupAccounts = new List <WorkgroupAccount>();
workgroupAccounts.Add(CreateValidEntities.WorkgroupAccount(1));
workgroupAccounts[0].Account = CreateValidEntities.Account(1);
workgroupAccounts[0].Account.SetIdTo("23456");
workgroupAccounts[0].AccountManager = CreateValidEntities.User(555);
workgroupAccounts[0].Approver = CreateValidEntities.User(556);
workgroupAccounts[0].Purchaser = CreateValidEntities.User(557);
workgroupAccounts[0].Workgroup = CreateValidEntities.Workgroup(3);
workgroupAccounts[0].Workgroup.SetIdTo(3);
workgroupAccounts.Add(CreateValidEntities.WorkgroupAccount(2));
workgroupAccounts[1].Account = CreateValidEntities.Account(2);
workgroupAccounts[1].Account.SetIdTo("12345");
workgroupAccounts[1].AccountManager = CreateValidEntities.User(444);
workgroupAccounts[1].Approver = CreateValidEntities.User(445);
workgroupAccounts[1].Purchaser = CreateValidEntities.User(446);
workgroupAccounts[1].Workgroup = CreateValidEntities.Workgroup(3);
workgroupAccounts[1].Workgroup.SetIdTo(3);
new FakeWorkgroupAccounts(0, WorkgroupAccountRepository, workgroupAccounts);
order.Workgroup = workgroupAccounts[0].Workgroup;
order.Workgroup.Accounts = workgroupAccounts;
new FakeAutoApprovals(3, AutoAprovalRepository);
#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(5));
EventService.AssertWasCalled(a => a.OrderReRouted(order));
SecurityService.AssertWasNotCalled(a => a.GetUser(Arg <string> .Is.Anything));
Assert.AreEqual(6, order.Approvals.Count);
Assert.AreEqual("LastName99", order.Approvals[0].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.ConditionalApprover, order.Approvals[0].StatusCode.Id);
Assert.AreEqual("LastName556", order.Approvals[1].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.Approver, order.Approvals[1].StatusCode.Id);
Assert.AreEqual("LastName555", order.Approvals[2].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[2].StatusCode.Id);
Assert.AreEqual("LastName557", order.Approvals[3].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[3].StatusCode.Id);
Assert.AreEqual("LastName445", order.Approvals[4].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.Approver, order.Approvals[4].StatusCode.Id);
Assert.AreEqual("LastName444", order.Approvals[5].User.LastName);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[5].StatusCode.Id);
#endregion Assert
}
public void TestCreateApprovalsForNewOrder30()
{
#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.Splits.Add(new Split());
order.Splits[1].Account = "23456";
order.Splits[1].Order = order;
order.Splits.Add(new Split());
order.Splits[2].Account = "777";
order.Splits[2].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("777");
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("23456");
accounts[0].AccountManagerId = "TestUser";
accounts.Add(CreateValidEntities.Account(2));
accounts[1].SetIdTo("12345");
accounts[1].AccountManagerId = null;
new FakeAccounts(0, AccountRepository, accounts, true);
SecurityService.Expect(a => a.GetUser("TestUser")).Return(CreateValidEntities.User(55));
SecurityService.Expect(a => a.GetUser(null)).Return(null);
var autoApprovals = new List <AutoApproval>();
autoApprovals.Add(CreateValidEntities.AutoApproval(1));
autoApprovals[0].User = CreateValidEntities.User(11);
autoApprovals[0].IsActive = true;
autoApprovals[0].Expiration = DateTime.UtcNow.ToPacificTime().AddDays(1);
autoApprovals[0].TargetUser = null;
autoApprovals[0].Account = workgroupAccounts[0].Account;
new FakeAutoApprovals(0, AutoAprovalRepository, autoApprovals);
//UserIdentity.Expect(a => a.Current).Return("11");
new FakeUsers(5, UserRepository);
var conditionalApprovalIds = new[] { 1 };
var conditionalApprovals = new List <ConditionalApproval>();
conditionalApprovals.Add(CreateValidEntities.ConditionalApproval(1));
conditionalApprovals[0].PrimaryApprover = CreateValidEntities.User(4);
conditionalApprovals[0].SecondaryApprover = CreateValidEntities.User(5);
new FakeConditionalApprovals(0, ConditionalApprovalRepository, conditionalApprovals);
#endregion Arrange
#region Act
OrderService.CreateApprovalsForNewOrder(order, conditionalApprovalIds, null, null, null);
#endregion Act
#region Assert
SecurityService.AssertWasCalled(a => a.GetUser("TestUser"));
SecurityService.AssertWasCalled(a => a.GetUser(null));
EventService.AssertWasCalled(a => a.OrderApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything, Arg <bool> .Is.Anything), x => x.Repeat.Times(4));
EventService.AssertWasCalled(a => a.OrderAutoApprovalAdded(Arg <Order> .Is.Anything, Arg <Approval> .Is.Anything));
EventService.AssertWasCalled(a => a.OrderCreated(order));
Assert.AreEqual(6, order.Approvals.Count);
Assert.AreEqual(OrderStatusCode.Codes.AccountManager, order.Approvals[0].StatusCode.Id);
Assert.AreEqual(OrderStatusCode.Codes.Purchaser, order.Approvals[1].StatusCode.Id);
var purchaserCount = 0;
var approverCount = 0;
var acctManagerCount = 0;
var conditionalApproverCount = 0;
foreach (var approval in order.Approvals)
{
switch (approval.StatusCode.Id)
{
case OrderStatusCode.Codes.Purchaser:
purchaserCount++;
break;
case OrderStatusCode.Codes.AccountManager:
acctManagerCount++;
break;
case OrderStatusCode.Codes.Approver:
approverCount++;
break;
case OrderStatusCode.Codes.ConditionalApprover:
conditionalApproverCount++;
break;
default:
throw new Exception("Should not be here!");
}
//Assert.IsNull(approval.User);
}
Assert.AreEqual(1, purchaserCount);
Assert.AreEqual(3, acctManagerCount);
Assert.AreEqual(1, approverCount);
Assert.AreEqual(1, conditionalApproverCount);
//Assert.AreEqual("LastName66", order.Approvals[0].User.LastName);
Assert.AreEqual("LastName55", order.Approvals[2].User.LastName);
Assert.AreEqual("12345", order.Splits[0].Account);
Assert.AreEqual("23456", order.Splits[1].Account);
Assert.IsTrue(order.Approvals[3].Completed);
#endregion Assert
}
/// <summary>
/// Gets the valid entity of type T
/// </summary>
/// <param name="counter">The counter.</param>
/// <returns>A valid entity of type T</returns>
protected override Account GetValid(int?counter)
{
return(CreateValidEntities.Account(counter));
}
public void SetupDataForAccounts1(bool skip = false)
{
#region Setup Roles
var roles = new List <Role>();
SetupRoles(roles);
#endregion Setup Roles
#region Setup Users
var users = new List <User>();
for (int i = 0; i < 6; i++)
{
users.Add(CreateValidEntities.User(i + 1));
users[i].SetIdTo((i + 1).ToString());
}
new FakeUsers(0, UserRepository, users, true);
#endregion Setup Users
var workgroups = new List <Workgroup>();
for (int i = 0; i < 3; i++)
{
workgroups.Add(CreateValidEntities.Workgroup(i + 1));
}
var organizations = new List <Organization>();
for (int i = 0; i < 3; i++)
{
organizations.Add(CreateValidEntities.Organization(i + 1));
organizations[i].Accounts = new List <Account>();
for (int j = 0; j < 3; j++)
{
var account = CreateValidEntities.Account((i * 3) + (j + 1));
account.SetIdTo((i * 3) + (j + 1).ToString());
organizations[i].Accounts.Add(account);
}
}
organizations.Add(CreateValidEntities.Organization(4));
organizations[3].Accounts = new List <Account>();
organizations[3].Accounts.Add(organizations[0].Accounts[0]);
var account2 = CreateValidEntities.Account(10);
account2.SetIdTo("10");
organizations[3].Accounts.Add(account2);
workgroups[2].Organizations = organizations;
workgroups[1].Organizations.Add(CreateValidEntities.Organization(5));
workgroups[1].Organizations[0].Accounts = new List <Account>();
var account3 = CreateValidEntities.Account(11);
account3.SetIdTo("11");
workgroups[1].Organizations[0].Accounts.Add(account3);
new FakeWorkgroups(0, WorkgroupRepository, workgroups);
#region Setup WorkgroupPermissions
var workgroupPermissions = new List <WorkgroupPermission>();
for (int i = 0; i < 18; i++)
{
workgroupPermissions.Add(new WorkgroupPermission());
workgroupPermissions[i].Role = roles[(i % 6)];
workgroupPermissions[i].User = users[(i % 6)];
workgroupPermissions[i].Workgroup = WorkgroupRepository.GetNullableById((i / 3) + 1);
}
for (int i = 0; i < 9; i++)
{
workgroupPermissions.Add(new WorkgroupPermission());
workgroupPermissions[i + 18].Workgroup = WorkgroupRepository.GetNullableById(3);
workgroupPermissions[i + 18].User = users[2];
}
workgroupPermissions[18].Role = RoleRepository.GetNullableById(Role.Codes.Approver);
workgroupPermissions[19].Role = RoleRepository.GetNullableById(Role.Codes.AccountManager);
workgroupPermissions[20].Role = RoleRepository.GetNullableById(Role.Codes.Purchaser);
workgroupPermissions[21].Role = RoleRepository.GetNullableById(Role.Codes.Approver);
workgroupPermissions[22].Role = RoleRepository.GetNullableById(Role.Codes.AccountManager);
workgroupPermissions[23].Role = RoleRepository.GetNullableById(Role.Codes.AccountManager);
workgroupPermissions[24].Role = RoleRepository.GetNullableById(Role.Codes.Purchaser);
workgroupPermissions[25].Role = RoleRepository.GetNullableById(Role.Codes.Purchaser);
workgroupPermissions[26].Role = RoleRepository.GetNullableById(Role.Codes.Purchaser);
new FakeWorkgroupPermissions(0, WorkgroupPermissionRepository, workgroupPermissions);
#endregion Setup WorkgroupPermissions
if (!skip)
{
new FakeWorkgroupAccounts(1, WorkgroupAccountRepository);
}
}
