public void Create_ValidDetailsSuppliedConsignmentHas1Items_SuccessfullyCreated()
{
var id = Guid.NewGuid();
var consignmentId = Guid.NewGuid();
var instructions = "Consignment instructions";
var consignmentItemRepositoryMock = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepositoryMock.Expect(x => x.Create(null)).IgnoreArguments();
var jobItemRepositoryMock = MockRepository.GenerateMock <IJobItemRepository>();
jobItemRepositoryMock.Stub(x => x.GetById(_jobItemToUpdate.Id)).Return(_jobItemToUpdate);
jobItemRepositoryMock.Expect(x => x.EmitItemHistory(
_userContext.GetCurrentUser(), _jobItemToUpdate.Id, 0, 0, "Item consigned on CR2000", ListItemType.StatusConsigned, ListItemType.WorkTypeAdministration));
jobItemRepositoryMock.Expect(x => x.Update(_jobItemToUpdate)).IgnoreArguments();
_consignmentItemService = ConsignmentItemServiceFactory.Create(consignmentItemRepositoryMock, jobItemRepositoryMock, consignmentId, _userContext, 1);
_jobItemService = _jobItemService = JobItemServiceFactory.CreateToReturnJobItem(jobItemRepositoryMock, _userContext);
CreateConsignmentItem(id, _jobItemToUpdate.Id, consignmentId, instructions);
consignmentItemRepositoryMock.VerifyAllExpectations();
jobItemRepositoryMock.VerifyAllExpectations();
Assert.AreNotEqual(Guid.Empty, _savedConsigmentItem.Id);
Assert.AreEqual(2, _savedConsigmentItem.ItemNo);
Assert.AreEqual(ListItemType.StatusConsigned, _jobItemToUpdate.Status.Type);
}
public void CreatePending_InvalidSupplierId_ArgumentExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
var supplierId = Guid.Empty;
var instructions = "Please consign this item";
_consignmentItemService = ConsignmentItemServiceFactory.CreateForPendingItems(jobItemId, supplierId, _userContext);
CreatePendingConsignmentItem(id, jobItemId, supplierId, instructions);
}
public void Edit_InvalidConsignmentItemId_ArgumentExceptionThrown()
{
var consignmentItemId = Guid.NewGuid();
var instructions = "edited instructions";
var consignmentItemRepository = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepository.Stub(x => x.GetById(consignmentItemId)).Return(null);
_consignmentItemService = ConsignmentItemServiceFactory.Create(consignmentItemRepository, _userContext);
Edit(consignmentItemId, instructions);
}
public void Edit_InvalidInstructions_DomainValidationExceptionThrown()
{
var instructions = new String('a', 10001);
var consignmentItemRepository = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepository.Stub(x => x.GetById(_consignmentItemForEditId)).Return(_consignmentItemForEdit);
_consignmentItemService = ConsignmentItemServiceFactory.Create(consignmentItemRepository, _userContext);
Edit(_consignmentItemForEditId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InstructionsTooLarge));
}
public void CreatePending_JobIsInPendingState_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instructions = "Please consign this item";
_consignmentItemService = ConsignmentItemServiceFactory.CreateForPendingItems(jobItemId, supplierId, _userContext, true);
CreatePendingConsignmentItem(id, jobItemId, supplierId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.PendingJob));
}
public void EditPending_InvalidSupplierId_ArgumentException()
{
var supplierId = Guid.Empty;
var instructions = "some edited instructions";
var consignmentItemRepositoryStub = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepositoryStub.Stub(x => x.GetPendingItem(_pendingItemId)).Return(_pendingItemForEdit);
_consignmentItemService = ConsignmentItemServiceFactory.CreateForEditForPendingItems(consignmentItemRepositoryStub, _jobItemforEditPendingId, supplierId, _userContext);
EditPendingConsignmentItem(_pendingItemId, _jobItemforEditPendingId, supplierId, instructions);
}
public void Edit_ConsignmentIsOrdered_DomainValidationExceptionThrown()
{
_consignmentItemForEdit.Consignment.IsOrdered = true;
var instructions = "edited instructions";
var consignmentItemRepository = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepository.Stub(x => x.GetById(_consignmentItemForEditId)).Return(_consignmentItemForEdit);
_consignmentItemService = ConsignmentItemServiceFactory.Create(consignmentItemRepository, _userContext);
Edit(_consignmentItemForEditId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.ConsignmentIsOrdered));
}
public void CreatePending_InstructionsGreaterThan10000Characters_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instructions = new string('a', 10001);
_consignmentItemService = ConsignmentItemServiceFactory.CreateForPendingItems(jobItemId, supplierId, _userContext);
CreatePendingConsignmentItem(id, jobItemId, supplierId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InstructionsTooLarge));
}
public void EditPending_InvalidInstructions_DomainValidationException()
{
var supplierId = Guid.NewGuid();
var instructions = new string('a', 10001);
var consignmentItemRepositoryStub = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepositoryStub.Stub(x => x.GetPendingItem(_pendingItemId)).Return(_pendingItemForEdit);
_consignmentItemService = ConsignmentItemServiceFactory.CreateForEditForPendingItems(consignmentItemRepositoryStub, _jobItemforEditPendingId, supplierId, _userContext);
EditPendingConsignmentItem(_pendingItemId, _jobItemforEditPendingId, supplierId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InstructionsTooLarge));
}
public void GetAllConsignmentItemsTest()
{
using (IDataContextAsync context = new PAndIContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <ConsignmentItem> consignmentItemRepository = new Repository <ConsignmentItem>(context,
unitOfWork);
IConsignmentItemService consignmentItemService = new ConsignmentItemService(consignmentItemRepository);
var consignmentItemList = consignmentItemService.GetAllConsignmentItems();
Assert.Greater(consignmentItemList.Count, 0);
}
}
public void CreatePending_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instructions = "Please consign this item";
_consignmentItemService = ConsignmentItemServiceFactory.CreateForPendingItems(jobItemId, supplierId,
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
CreatePendingConsignmentItem(id, jobItemId, supplierId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void ConsignmentItemByConsignmentIDTest()
{
using (IDataContextAsync context = new PAndIContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <ConsignmentItem> consignmentItemRepository = new Repository <ConsignmentItem>(context,
unitOfWork);
IConsignmentItemService consignmentItemService = new ConsignmentItemService(consignmentItemRepository);
var guid = Guid.Parse("BBD967D8-3200-47DB-8352-E04362C5B394");
var consignmentItems = consignmentItemService.ConsignmentItemsByConsignmentID(guid);
Assert.AreEqual(consignmentItems.Count, 2);
}
}
public void EditPending_UserHasInsufficientSecurity_DomainValidationException()
{
var supplierId = Guid.NewGuid();
var instructions = "some instructions";
var consignmentItemRepositoryStub = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepositoryStub.Stub(x => x.GetPendingItem(_pendingItemId)).Return(_pendingItemForEdit);
_consignmentItemService = ConsignmentItemServiceFactory.CreateForEditForPendingItems(consignmentItemRepositoryStub, _jobItemforEditPendingId, supplierId,
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
EditPendingConsignmentItem(_pendingItemId, _jobItemforEditPendingId, supplierId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void CreatePending_JobItemAlreadyHasPendingItem_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instructions = "Please consign this item";
var consignmentItemRepositoryMock = MockRepository.GenerateStub <IConsignmentItemRepository>();
consignmentItemRepositoryMock.Stub(x => x.JobItemHasPendingConsignmentItem(jobItemId)).Return(true);
_consignmentItemService = ConsignmentItemServiceFactory.CreateForPendingItems(consignmentItemRepositoryMock, jobItemId, supplierId, _userContext);
CreatePendingConsignmentItem(id, jobItemId, supplierId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.PendingItemAlreadyExists));
}
public void Create_InvalidJobItemIdSupplied_ArgumentExceptionThrown()
{
var id = Guid.NewGuid();
var consignmentId = Guid.NewGuid();
var instructions = "Consignment instructions";
var jobItemRepositoryMock = MockRepository.GenerateMock <IJobItemRepository>();
jobItemRepositoryMock.Stub(x => x.GetById(Guid.NewGuid())).Return(null);
_consignmentItemService = ConsignmentItemServiceFactory.Create(MockRepository.GenerateStub <IConsignmentItemRepository>(), jobItemRepositoryMock, consignmentId, _userContext);
_jobItemService = _jobItemService = JobItemServiceFactory.CreateToReturnJobItem(jobItemRepositoryMock, _userContext);
CreateConsignmentItem(id, _jobItemToUpdate.Id, consignmentId, instructions);
}
public void Edit_ValidEdit_ItemEdited()
{
var instructions = "edited instructions";
var consignmentItemRepository = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepository.Stub(x => x.GetById(_consignmentItemForEditId)).Return(_consignmentItemForEdit);
consignmentItemRepository.Expect(x => x.Update(null)).IgnoreArguments();
_consignmentItemService = ConsignmentItemServiceFactory.Create(consignmentItemRepository, _userContext);
Edit(_consignmentItemForEditId, instructions);
consignmentItemRepository.VerifyAllExpectations();
Assert.AreEqual(_consignmentItemForEditId, _consignmentItemForEdit.Id);
Assert.AreEqual(instructions, _consignmentItemForEdit.Instructions);
}
public void Create_InstructionsGreaterThan10000Characters_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var consignmentId = Guid.NewGuid();
var instructions = new string('a', 10001);
var jobItemRepositoryMock = MockRepository.GenerateMock <IJobItemRepository>();
jobItemRepositoryMock.Stub(x => x.GetById(_jobItemToUpdate.Id)).Return(_jobItemToUpdate);
_consignmentItemService = ConsignmentItemServiceFactory.Create(MockRepository.GenerateStub <IConsignmentItemRepository>(), jobItemRepositoryMock, consignmentId, _userContext);
_jobItemService = _jobItemService = JobItemServiceFactory.CreateToReturnJobItem(jobItemRepositoryMock, _userContext);
CreateConsignmentItem(id, _jobItemToUpdate.Id, consignmentId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InstructionsTooLarge));
}
public void CreatePending_ValidPendingItemDetails_PendingItemCreated()
{
var id = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instructions = "Please consign this item";
var consignmentItemRepositoryMock = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepositoryMock.Expect(x => x.CreatePendingItem(null)).IgnoreArguments();
_consignmentItemService = ConsignmentItemServiceFactory.CreateForPendingItems(consignmentItemRepositoryMock, jobItemId, supplierId, _userContext);
CreatePendingConsignmentItem(id, jobItemId, supplierId, instructions);
consignmentItemRepositoryMock.VerifyAllExpectations();
Assert.AreNotEqual(Guid.Empty, _savedPendingItem.Id);
}
public void EditPending_ValidDetails_ItemEdited()
{
var supplierId = Guid.NewGuid();
var instructions = "some edited instructions";
var consignmentItemRepositoryMock = MockRepository.GenerateMock <IConsignmentItemRepository>();
consignmentItemRepositoryMock.Stub(x => x.GetPendingItem(_pendingItemId)).Return(_pendingItemForEdit);
consignmentItemRepositoryMock.Expect(x => x.UpdatePendingItem(null)).IgnoreArguments();
_consignmentItemService = ConsignmentItemServiceFactory.CreateForEditForPendingItems(consignmentItemRepositoryMock, _jobItemforEditPendingId, supplierId, _userContext);
EditPendingConsignmentItem(_pendingItemId, _jobItemforEditPendingId, supplierId, instructions);
consignmentItemRepositoryMock.VerifyAllExpectations();
Assert.AreEqual(instructions, _pendingItemForEdit.Instructions);
Assert.AreEqual(supplierId, _pendingItemForEdit.Supplier.Id);
}
public void Create_NoIdSupplied_ArgumentExceptionThrown()
{
var id = Guid.Empty;
var consignmentId = Guid.NewGuid();
var instructions = "Consignment instructions";
_jobItemToUpdate.Job.IsPending = true;
var jobItemRepositoryStub = MockRepository.GenerateMock <IJobItemRepository>();
jobItemRepositoryStub.Stub(x => x.GetById(_jobItemToUpdate.Id)).Return(_jobItemToUpdate);
_consignmentItemService = ConsignmentItemServiceFactory.Create(MockRepository.GenerateStub <IConsignmentItemRepository>(), jobItemRepositoryStub, consignmentId, _userContext);
_jobItemService = _jobItemService = JobItemServiceFactory.CreateToReturnJobItem(jobItemRepositoryStub, _userContext);
CreateConsignmentItem(id, _jobItemToUpdate.Id, consignmentId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.PendingJob));
}
public void ConsignmentItemByIdTest()
{
//Arrange
var consignmentItemID = string.Empty;
using (IDataContextAsync context = new PAndIContext())
using (IUnitOfWorkAsync unitOfWork = new UnitOfWork(context))
{
IRepositoryAsync <ConsignmentItem> consignmentItemRepository = new Repository <ConsignmentItem>(context,
unitOfWork);
IConsignmentItemService consignmentItemService = new ConsignmentItemService(consignmentItemRepository);
var consignmentItem = CreateConsignmentItem();
consignmentItemID = consignmentItem.ConsignmentItemID.ToString();
consignmentItemService.Insert(consignmentItem);
unitOfWork.SaveChanges();
}
}
public void Create_UserHasInsufficientSecurityClearance_ArgumentExceptionThrown()
{
var id = Guid.NewGuid();
var consignmentId = Guid.NewGuid();
var instructions = "Consignment instructions";
var jobItemRepositoryMock = MockRepository.GenerateMock <IJobItemRepository>();
jobItemRepositoryMock.Stub(x => x.GetById(Guid.NewGuid())).Return(null);
_consignmentItemService = ConsignmentItemServiceFactory.Create(
MockRepository.GenerateStub <IConsignmentItemRepository>(), jobItemRepositoryMock, consignmentId,
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
_jobItemService = _jobItemService = JobItemServiceFactory.CreateToReturnJobItem(jobItemRepositoryMock,
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
CreateConsignmentItem(id, _jobItemToUpdate.Id, consignmentId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
static void Main(string[] args)
{
CreateDatabase();
InitialiseNHibernateSessions();
var queueDispatcher = new NullQueueDispatcher();
var initialUserContext = new TestUserContext(TestUserContext.CreateAdminUser());
var userManagementService = new UserManagementService(initialUserContext, new UserAccountRepository(), new CryptographicService(), queueDispatcher);
var adminUser = userManagementService.GetUsers().Where(u => u.EmailAddress == "*****@*****.**").Single();
var testUserContext = new TestUserContext(adminUser);
var currentUser = testUserContext.GetCurrentUser();
var listItemService = new ListItemService(testUserContext, new ListItemRepository(), queueDispatcher);
var customerService = new CustomerService(testUserContext, new CustomerRepository(), queueDispatcher);
var jobService = new JobService(
testUserContext, new FileSystemAttachmentStorage(), new JobRepository(), new ListItemRepository(), new CustomerRepository(), new EntityIdProvider(), queueDispatcher);
var jobItemService = new JobItemService(
testUserContext, new JobRepository(), new JobItemRepository(),
new ListItemService(testUserContext, new ListItemRepository(), queueDispatcher),
new InstrumentService(testUserContext, new InstrumentRepository(), queueDispatcher),
queueDispatcher);
var instrumentService = new InstrumentService(testUserContext, new InstrumentRepository(), queueDispatcher);
var supplierService = new SupplierService(testUserContext, new SupplierRepository(), queueDispatcher);
var consignmentItemRepository = new ConsignmentItemService(
testUserContext,
new ConsignmentRepository(),
new ConsignmentItemRepository(),
new JobItemRepository(),
new ListItemRepository(),
new SupplierRepository(),
queueDispatcher);
var directEntityIdProvider = new DirectEntityIdProvider();
var certificateService = new CertificateService(
testUserContext, new JobItemRepository(), new CertificateRepository(), new ListItemRepository(), directEntityIdProvider, queueDispatcher);
var jobId = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
var customerId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instrumentId = Guid.NewGuid();
NHibernateSession.Current.BeginTransaction();
supplierService.Create(supplierId, "Gael Ltd", new Address(), new ContactInfo(), new Address(), new ContactInfo());
customerService.Create(customerId, "Gael Ltd", String.Empty, new Address(), new ContactInfo(), "Gael Ltd", new Address(), new ContactInfo(), "Gael Ltd", new Address(), new ContactInfo());
instrumentService.Create(instrumentId, "Druck", "DPI601IS", "None", "Digital Pressure Indicator", 0);
jobService.CreateJob(jobId, "job instructions", "ORDER12345", "ADVICE12345", listItemService.GetAllByCategory(ListItemCategoryType.JobType).First().Id, customerId, "job notes", "job contact");
jobItemService.CreateJobItem(
jobId, jobItemId, instrumentId, "12345", "AST12345", listItemService.GetAllByCategory(ListItemCategoryType.JobItemInitialStatus).First().Id,
listItemService.GetAllByCategory(ListItemCategoryType.JobItemCategory).First().Id, 12,
"job instructions", "accessories", false, String.Empty, "comments");
jobService.ApproveJob(jobId);
NHibernateSession.Current.Transaction.Commit();
NHibernateSession.Current.BeginTransaction();
certificateService.Create(
Guid.NewGuid(),
listItemService.GetByType(ListItemType.CertificateTypeHouse).Id,
listItemService.GetByType(ListItemType.CategoryDensity).Id,
jobItemId,
"001");
NHibernateSession.Current.Transaction.Commit();
}
public ConsignmentController(ConsignmentService consignmentService, ConsignmentItemService consignmentItemService, OrderService orderService)
{
_consignmentService = consignmentService;
_consignmentItemService = consignmentItemService;
_orderService = orderService;
}
public void CreateConsignmentsFromPendingItems_ValidPendingConsignmentItems_ConsignmentsCreated()
{
var dispatcher = MockRepository.GenerateMock <IQueueDispatcher <IMessage> >();
var userRepository = new UserAccountRepository();
var user = userRepository.GetByEmail("*****@*****.**", false);
var userContext = new TestUserContext(user);
var consignmentRepository = new ConsignmentRepository();
var consignmentItemRepository = new ConsignmentItemRepository();
var supplierRepository = new SupplierRepository();
var jobRepository = new JobRepository();
var jobItemRepository = new JobItemRepository();
var listItemRepository = new ListItemRepository();
var entityIdProvider = new DirectEntityIdProvider();
var instrumentRepository = new InstrumentRepository();
var supplier1Id = Guid.NewGuid();
var supplier2Id = Guid.NewGuid();
var supplier3Id = Guid.NewGuid();
var job1Id = Guid.NewGuid();
var job2Id = Guid.NewGuid();
var job3Id = Guid.NewGuid();
var jobItem1Id = Guid.NewGuid();
var jobItem2Id = Guid.NewGuid();
var jobItem3Id = Guid.NewGuid();
var jobItem4Id = Guid.NewGuid();
var jobItem5Id = Guid.NewGuid();
var jobItem6Id = Guid.NewGuid();
var jobItem7Id = Guid.NewGuid();
CreateConsignmentsFromPendingItemsHelper.CreateContextForPendingItemTests(
job1Id, job2Id, job3Id, supplier1Id, supplier2Id, supplier3Id,
jobItem1Id, jobItem2Id, jobItem3Id, jobItem4Id, jobItem5Id, jobItem6Id, jobItem7Id);
var instrumentService = new InstrumentService(userContext, instrumentRepository, dispatcher);
var listItemService = new ListItemService(userContext, listItemRepository, dispatcher);
var jobItemService = new JobItemService(userContext, jobRepository, jobItemRepository, listItemService, instrumentService, dispatcher);
var consignmentItemService = new ConsignmentItemService(
userContext,
consignmentRepository, consignmentItemRepository, jobItemRepository, new ListItemRepository(), supplierRepository, dispatcher);
_consignmentService = new ConsignmentService(userContext, consignmentRepository, supplierRepository, new DirectEntityIdProvider(), consignmentItemService, dispatcher);
var jobItems = jobItemService.GetJobItems(job1Id).OrderBy(ji => ji.ItemNo).ToList();
consignmentItemService.CreatePending(Guid.NewGuid(), jobItems[0].Id, supplier1Id, "for cal");
consignmentItemService.CreatePending(Guid.NewGuid(), jobItems[1].Id, supplier2Id, "for repair");
consignmentItemService.CreatePending(Guid.NewGuid(), jobItems[2].Id, supplier1Id, "for cal");
jobItems = jobItemService.GetJobItems(job2Id).OrderBy(ji => ji.ItemNo).ToList();
consignmentItemService.CreatePending(Guid.NewGuid(), jobItems[0].Id, supplier1Id, "for cal");
consignmentItemService.CreatePending(Guid.NewGuid(), jobItems[1].Id, supplier2Id, "for repair");
consignmentItemService.CreatePending(Guid.NewGuid(), jobItems[2].Id, supplier3Id, "for cal");
jobItems = jobItemService.GetJobItems(job3Id).OrderBy(ji => ji.ItemNo).ToList();
consignmentItemService.CreatePending(Guid.NewGuid(), jobItems[0].Id, supplier3Id, "for cal");
var consignmentService = new ConsignmentService(userContext, consignmentRepository, supplierRepository, entityIdProvider, consignmentItemService, dispatcher);
consignmentService.CreateConsignmentsFromPendingItems();
var consignments = consignmentService.GetConsignments().OrderBy(c => c.ConsignmentNo).ToList();
Assert.AreEqual(3, consignments.Count);
Assert.AreEqual("1", consignments[0].ConsignmentNo);
Assert.AreEqual(supplier1Id, consignments[0].Supplier.Id);
Assert.AreEqual("2", consignments[1].ConsignmentNo);
Assert.AreEqual(supplier2Id, consignments[1].Supplier.Id);
Assert.AreEqual("3", consignments[2].ConsignmentNo);
Assert.AreEqual(supplier3Id, consignments[2].Supplier.Id);
var consignmentItems = consignmentItemService.GetConsignmentItems(consignments[0].Id).OrderBy(ci => ci.ItemNo).ToList();
Assert.AreEqual(3, consignmentItems.Count);
Assert.AreEqual(jobItem1Id, consignmentItems[0].JobItem.Id); // JR2000/1
Assert.AreEqual(jobItem3Id, consignmentItems[1].JobItem.Id); // JR2000/3
Assert.AreEqual(jobItem4Id, consignmentItems[2].JobItem.Id); // JR2001/1
consignmentItems = consignmentItemService.GetConsignmentItems(consignments[1].Id).OrderBy(ci => ci.ItemNo).ToList();
Assert.AreEqual(2, consignmentItems.Count);
Assert.AreEqual(jobItem2Id, consignmentItems[0].JobItem.Id); // JR2000/2
Assert.AreEqual(jobItem5Id, consignmentItems[1].JobItem.Id); // JR2001/2
consignmentItems = consignmentItemService.GetConsignmentItems(consignments[2].Id).OrderBy(ci => ci.ItemNo).ToList();
Assert.AreEqual(2, consignmentItems.Count);
Assert.AreEqual(jobItem6Id, consignmentItems[0].JobItem.Id); // JR2001/3
Assert.AreEqual(jobItem7Id, consignmentItems[1].JobItem.Id); // JR2002/1
Assert.AreEqual(0, consignmentItemService.GetPendingItems().Count());
}
public static void CreateContextForCreateOrderFromConsignmentTest(
Guid jobId, Guid supplierId, Guid consignmentId, Guid jobItem1Id, Guid jobItem2Id, Guid jobItem3Id)
{
var dispatcher = MockRepository.GenerateMock <IQueueDispatcher <IMessage> >();
var userRepository = new UserAccountRepository();
var user = userRepository.GetByEmail("*****@*****.**", false);
var userContext = new TestUserContext(user);
var consignmentRepository = new ConsignmentRepository();
var consignmentItemRepository = new ConsignmentItemRepository();
var supplierRepository = new SupplierRepository();
var jobRepository = new JobRepository();
var jobItemRepository = new JobItemRepository();
var listItemRepository = new ListItemRepository();
var customerRepository = new CustomerRepository();
var entityIdProvider = new DirectEntityIdProvider();
var instrumentRepository = new InstrumentRepository();
var instrumentId = Guid.NewGuid();
var instrumentService = new InstrumentService(userContext, instrumentRepository, dispatcher);
instrumentService.Create(instrumentId, "Druck", "DPI601IS", "None", "Digital Pressure Indicator", 15);
var customerId = Guid.NewGuid();
var customerService = new CustomerService(userContext, customerRepository, dispatcher);
customerService.Create(customerId, "Gael Ltd", String.Empty, new Address(), new ContactInfo(), "Gael Ltd", new Address(), new ContactInfo(), "Gael Ltd", new Address(), new ContactInfo());
var supplierService = new SupplierService(userContext, supplierRepository, dispatcher);
supplierService.Create(supplierId, "Supplier 1", new Address(), new ContactInfo(), new Address(), new ContactInfo());
var listItemService = new ListItemService(userContext, listItemRepository, dispatcher);
var jobService = new JobService(userContext, null, jobRepository, listItemRepository, customerRepository, entityIdProvider, dispatcher);
jobService.CreateJob(jobId, "some instructions", "order no", "advice no", listItemService.GetAllByCategory(ListItemCategoryType.JobType).First().Id, customerId, "notes", "contact");
var jobItemService = new JobItemService(userContext, jobRepository, jobItemRepository, listItemService, instrumentService, dispatcher);
jobItemService.CreateJobItem(
jobId, jobItem1Id, instrumentId, "12345", String.Empty,
listItemService.GetAllByCategory(ListItemCategoryType.JobItemInitialStatus).First().Id,
listItemService.GetAllByCategory(ListItemCategoryType.JobItemCategory).First().Id,
12, "instructions", String.Empty, false, String.Empty, String.Empty);
jobItemService.CreateJobItem(
jobId, jobItem2Id, instrumentId, "123456", String.Empty,
listItemService.GetAllByCategory(ListItemCategoryType.JobItemInitialStatus).First().Id,
listItemService.GetAllByCategory(ListItemCategoryType.JobItemCategory).First().Id,
12, "instructions", String.Empty, false, String.Empty, String.Empty);
jobItemService.CreateJobItem(
jobId, jobItem3Id, instrumentId, "123457", String.Empty,
listItemService.GetAllByCategory(ListItemCategoryType.JobItemInitialStatus).First().Id,
listItemService.GetAllByCategory(ListItemCategoryType.JobItemCategory).First().Id,
12, "instructions", String.Empty, false, String.Empty, String.Empty);
jobService.ApproveJob(jobId);
var consignmentItemService = new ConsignmentItemService(
userContext,
consignmentRepository, consignmentItemRepository, jobItemRepository, new ListItemRepository(), supplierRepository, dispatcher);
var consignmentService = new ConsignmentService(userContext, consignmentRepository, supplierRepository, new DirectEntityIdProvider(), consignmentItemService, dispatcher);
consignmentService.Create(consignmentId, supplierId);
consignmentItemService.Create(Guid.NewGuid(), jobItem1Id, consignmentId, "some consignment instructions");
consignmentItemService.Create(Guid.NewGuid(), jobItem2Id, consignmentId, "some consignment instructions");
consignmentItemService.Create(Guid.NewGuid(), jobItem3Id, consignmentId, "some consignment instructions");
}
