public void Edit_UserHasInsufficientSecurityClearance_ThrowsDomainValidationException()
{
var supplierId = Guid.NewGuid();
var currencyId = Guid.NewGuid();
var instructions = "some edited instructions";
var orderRepositoryStub = MockRepository.GenerateStub <IOrderRepository>();
orderRepositoryStub.Stub(x => x.GetById(_orderForEditId)).Return(_orderForEdit);
var supplierRepositoryStub = MockRepository.GenerateStub <ISupplierRepository>();
supplierRepositoryStub.Stub(x => x.GetById(supplierId)).Return(new Supplier {
Id = supplierId, Name = "Supplier for edit"
});
var currencyRepositoryStub = MockRepository.GenerateStub <ICurrencyRepository>();
currencyRepositoryStub.Stub(x => x.GetById(currencyId)).Return(new Currency {
Id = currencyId, Name = "USD"
});
_orderService = OrderServiceTestHelper.CreateOrderService(
orderRepositoryStub,
supplierRepositoryStub,
currencyRepositoryStub,
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
Edit(_orderForEditId, supplierId, currencyId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void Setup()
{
_domainValidationException = null;
_savedBankDetails = null;
_userContext = TestUserContext.Create(
"*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Manager | UserRole.Member);
}
public static InstrumentService CreateForSearch(IInstrumentRepository repository)
{
return(new InstrumentService(
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.Member),
repository,
MockRepository.GenerateStub <IQueueDispatcher <IMessage> >()));
}
public void Setup()
{
_userContext = TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Manager | UserRole.Member);
_domainValidationException = null;
_savedCertificate = null;
AppDateTime.GetUtcNow = () => _dateCreated;
}
public static JobItemService Create(
IJobItemRepository jobItemRepository, Guid jobId, Guid instrumentId, Guid initialStatusId, Guid fieldId, int jobItemCount)
{
return(Create(
jobItemRepository, jobId, instrumentId, initialStatusId, fieldId, jobItemCount,
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.Member)));
}
public void GetById_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
_orderService = OrderServiceTestHelper.CreateOrderService(
MockRepository.GenerateStub <IOrderRepository>(),
MockRepository.GenerateStub <ISupplierRepository>(),
MockRepository.GenerateStub <ICurrencyRepository>(),
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
GetById(Guid.NewGuid());
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void Create_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var supplierId = Guid.NewGuid();
_consignmentService = ConsignmentServiceFactory.Create(supplierId,
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.Public));
CreateConsignment(id, supplierId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void GetQuotes_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
_quoteService = QuoteServiceTestHelper.CreateQuoteService(
MockRepository.GenerateStub<IQuoteRepository>(),
MockRepository.GenerateStub<ICustomerRepository>(),
MockRepository.GenerateStub<ICurrencyRepository>(),
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
GetQuotes();
Assert.IsTrue(_domainValidationException.ResultContainsMessage(JobSystem.Resources.Quotes.Messages.InsufficientSecurity));
}
public void GetCertificates_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
_certificateService = CertificateServiceFactory.Create(
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public),
MockRepository.GenerateStub <IListItemRepository>(),
MockRepository.GenerateStub <ICertificateRepository>(),
MockRepository.GenerateStub <IJobItemRepository>());
GetCertificates();
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void GetCurrencies_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
_userContext = TestUserContext.Create(
"*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public);
_currencyService = new CurrencyService(
_userContext,
MockRepository.GenerateStub <ICurrencyRepository>(),
MockRepository.GenerateStub <IQueueDispatcher <IMessage> >());
GetCurrencies();
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public static JobService Create(IJobRepository jobRepository, IJobAttachmentDataRepository attachmentRepository)
{
return(new JobService(
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.Member),
attachmentRepository,
jobRepository,
MockRepository.GenerateStub <IListItemRepository>(),
MockRepository.GenerateStub <ICustomerRepository>(),
MockRepository.GenerateStub <IEntityIdProvider>(),
MockRepository.GenerateStub <IQueueDispatcher <IMessage> >()));
}
public void Approve_JobIdNotSupplied_ArgumentExceptionThrown()
{
var id = Guid.Empty;
var customerId = Guid.NewGuid();
var typeId = Guid.NewGuid();
var jobRepository = MockRepository.GenerateMock <IJobRepository>();
_jobService = JobServiceFactory.CreateForApproval(jobRepository, id, typeId, customerId,
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.JobApprover));
ApproveJob(id);
}
public void GetInvoices_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
_invoiceService = InvoiceServiceFactory.Create(
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public),
MockRepository.GenerateStub <IInvoiceRepository>(),
MockRepository.GenerateStub <IListItemRepository>(),
MockRepository.GenerateStub <ICustomerRepository>(),
MockRepository.GenerateStub <IBankDetailsRepository>(),
MockRepository.GenerateStub <ITaxCodeRepository>(),
MockRepository.GenerateStub <ICurrencyRepository>());
GetInvoices();
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void AddAttachment_UserDoesNotHaveMemberRole_ArgumentExceptionThrow()
{
var attachmentId = Guid.NewGuid();
var fileName = "attachment.pdf";
var contentType = "image";
byte[] content = new byte[] { 1, 2, 3, 4, 5 };
_attachmentService = AttachmentServiceFactory.Create(MockRepository.GenerateStub <IJobAttachmentDataRepository>(),
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
AddAttachment(attachmentId, fileName, contentType, content);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(JobSystem.Resources.Jobs.Messages.InsufficientSecurityClearance));
}
public void Create_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var customerId = Guid.NewGuid();
var fao = "Graham Robertson";
_deliveryService = DeliveryServiceFactory.Create(
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public),
MockRepository.GenerateStub <IDeliveryRepository>(),
CustomerRepositoryTestHelper.GetCustomerRepository_StubsGetById_ReturnsCustomer(customerId));
Create(id, customerId, fao);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void Edit_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrow()
{
var name = "CAD";
var displayMessage = "All prices in Canadian Dollars";
_userContext = TestUserContext.Create(
"*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Member);
var currencyRepositoryStub = MockRepository.GenerateMock <ICurrencyRepository>();
_currencyService = new CurrencyService(_userContext, currencyRepositoryStub, MockRepository.GenerateStub <IQueueDispatcher <IMessage> >());
EditCurrency(_currencyForEditId, name, displayMessage);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void Approve_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var customerId = Guid.NewGuid();
var typeId = Guid.NewGuid();
var jobRepository = MockRepository.GenerateMock <IJobRepository>();
_jobService = JobServiceFactory.CreateForApproval(jobRepository, id, typeId, customerId,
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.Member));
ApproveJob(id);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(JobSystem.Resources.Jobs.Messages.InsufficientSecurityClearance));
}
public void Approve_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
var orderRepositoryStub = MockRepository.GenerateMock <IOrderRepository>();
orderRepositoryStub.Stub(x => x.GetById(_orderForApprovalId)).Return(_orderForApproval);
_orderService = OrderServiceTestHelper.CreateOrderService(
orderRepositoryStub,
MockRepository.GenerateStub <ISupplierRepository>(),
MockRepository.GenerateStub <ICurrencyRepository>(),
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Member));
Approve(_orderForApprovalId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void Setup()
{
_domainValidationException = null;
AppDateTime.GetUtcNow = () => _dateCreated;
_userContext = TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Admin | UserRole.Manager);
_jobForAttachment = new Job
{
Id = _jobForAttachmentId,
Type = new ListItem
{
Id = Guid.NewGuid(),
Type = ListItemType.JobTypeField,
Name = "Field",
Category = new ListItemCategory {
Id = Guid.NewGuid(), Name = "Job Type", Type = ListItemCategoryType.JobType
}
},
Customer = new Customer {
Id = Guid.NewGuid(), Name = "Gael Ltd"
},
OrderNo = "blah",
DateCreated = DateTime.Now,
CreatedBy = _userContext.GetCurrentUser(),
JobNo = "JR2000"
};
_jobForEditId = Guid.NewGuid();
_jobForEdit = new Job
{
Id = _jobForEditId,
Type = new ListItem
{
Id = Guid.NewGuid(),
Type = ListItemType.JobTypeField,
Name = "Field",
Category = new ListItemCategory {
Id = Guid.NewGuid(), Name = "Job Type", Type = ListItemCategoryType.JobType
}
},
Customer = new Customer {
Id = Guid.NewGuid(), Name = "Gael Ltd"
},
OrderNo = "orderno",
AdviceNo = "adviceno",
Notes = "notes",
Contact = "contact",
Instructions = "instructions",
DateCreated = DateTime.Now,
CreatedBy = _userContext.GetCurrentUser(),
JobNo = "JR2001"
};
}
public void GetSuppliers_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
try
{
_supplierService = SupplierServiceFactory.Create(
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.Public));
_supplierService.GetSuppliers();
}
catch (DomainValidationException dex)
{
_domainValidationException = dex;
}
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void Approve_JobHasNoItems_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var customerId = Guid.NewGuid();
var typeId = Guid.NewGuid();
var jobRepository = MockRepository.GenerateStub <IJobRepository>();
jobRepository.Stub(x => x.GetJobItemCount(id)).Return(0);
_jobService = JobServiceFactory.CreateForApproval(jobRepository, id, typeId, customerId,
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.JobApprover));
ApproveJob(id);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(JobSystem.Resources.Jobs.Messages.ApprovingJobHasNoItems));
}
public void Setup()
{
_savedCurrency = null;
_domainValidationException = null;
_userContext = TestUserContext.Create(
"*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Manager | UserRole.Member);
_currencyForEditId = Guid.NewGuid();
_currencyForEdit = new Currency
{
Id = _currencyForEditId,
Name = "CAD",
DisplayMessage = "All prices in Canadian Dollars"
};
}
public void Setup()
{
_userContext = TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Manager | UserRole.Member);
_domainValidationException = null;
_savedPendingItem = null;
_savedDeliveryItem = null;
_jobItemService = null;
_deliveryItemService = null;
_jobItemToUpdateId = Guid.NewGuid();
_jobItemToUpdate = new JobItem
{
Id = _jobItemToUpdateId,
Job = new Job
{
Id = Guid.NewGuid(),
JobNo = "JR2000",
CreatedBy = _userContext.GetCurrentUser(),
OrderNo = "ORDER12345",
DateCreated = DateTime.UtcNow,
Customer = new Customer {
Id = Guid.NewGuid(), Name = "Gael Ltd"
}
},
ItemNo = 1,
SerialNo = "12345",
Instrument = new Instrument
{
Id = Guid.NewGuid(),
Manufacturer = "Druck",
ModelNo = "DPI601IS",
Range = "None",
Description = "Digital Pressure Indicator"
},
CalPeriod = 12,
Created = DateTime.UtcNow,
CreatedUser = _userContext.GetCurrentUser(),
};
_deliveryItemForEditId = Guid.NewGuid();
_deliveryItemForEdit = new DeliveryItem
{
Id = _deliveryItemForEditId,
Delivery = new Delivery {
Id = Guid.NewGuid(), DeliveryNoteNumber = "DR2000", Customer = new Customer {
Id = Guid.NewGuid(), Name = "Gael"
}
},
ItemNo = 1,
};
}
public void Create_UserHasInsufficentSecurity_DomainValidationExceptionThrown()
{
var orderId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instructions = "some instructions";
var currencyId = Guid.NewGuid();
_orderService = OrderServiceTestHelper.CreateOrderService(
MockRepository.GenerateStub <IOrderRepository>(),
SupplierRepositoryTestHelper.GetSupplierRepository_GetById_ReturnsSupplier(supplierId),
CurrencyRepositoryTestHelper.GetCurrencyRepository_StubsGetById_ReturnsGbpCurrency(currencyId),
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
CreateOrder(orderId, supplierId, instructions, currencyId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void Approve_UserHasSufficientSecurityClearance_JobSuccessfullyApproved()
{
var id = Guid.NewGuid();
var customerId = Guid.NewGuid();
var typeId = Guid.NewGuid();
var jobRepository = MockRepository.GenerateMock <IJobRepository>();
jobRepository.Stub(x => x.GetJobItemCount(id)).Return(1);
jobRepository.Expect(x => x.Update(null)).IgnoreArguments();
_jobService = JobServiceFactory.CreateForApproval(jobRepository, id, typeId, customerId,
TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.JobApprover));
ApproveJob(id);
jobRepository.VerifyAllExpectations();
Assert.That(!_savedJob.IsPending);
}
public void Edit_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
var orderNo = "ORDER12345";
var adviceNo = "ADV12345";
var currencyId = Guid.NewGuid();
var quoteRepositoryStub = MockRepository.GenerateMock<IQuoteRepository>();
quoteRepositoryStub.Stub(x => x.GetById(_quoteForEditId)).Return(_quoteForEdit);
_quoteService = QuoteServiceTestHelper.CreateQuoteService(
quoteRepositoryStub,
MockRepository.GenerateStub<ICustomerRepository>(),
CurrencyRepositoryTestHelper.GetCurrencyRepository_StubsGetById_ReturnsGbpCurrency(currencyId),
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Member));
Edit(_quoteForEditId, orderNo, adviceNo, currencyId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(JobSystem.Resources.Quotes.Messages.InsufficientSecurityClearance));
}
public void AddWorkItem_CurrentUserHasInsufficientSecurity_DomainValidationExceptionThrown()
{
var workStatusId = Guid.NewGuid();
var workTypeId = Guid.NewGuid();
var workTime = 25;
var overTime = 10;
var report = "Instrument calibrated OK";
var jobItemRepositoryStub = MockRepository.GenerateStub <IJobItemRepository>();
jobItemRepositoryStub.Stub(x => x.GetById(_jobItemToUpdateId)).Return(_jobItemToUpdate);
_jobItemService = JobItemServiceFactory.CreateForAddWorkItem(
jobItemRepositoryStub, workStatusId, workTypeId, TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public));
AddWorkItem(_jobItemToUpdateId, workTime, overTime, report, workStatusId, workTypeId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(JobSystem.Resources.JobItems.Messages.InsufficientSecurityClearance));
}
public void EditInformation_InsufficientSecurityClearance_DomainValidationExceptionThrown()
{
var serialNo = "123456";
var instructions = "some instructions";
var accessories = "some accessories";
var comments = "some comments";
var jobItemRepositoryMock = MockRepository.GenerateMock <IJobItemRepository>();
jobItemRepositoryMock.Stub(x => x.GetById(_jobItemForEditInformationId)).Return(_jobItemForEditInformation);
_jobItemService = JobItemServiceFactory.Create(
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Member),
jobItemRepositoryMock);
EditInformation(_jobItemForEditInformationId, serialNo, instructions, accessories, comments);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(JobSystem.Resources.JobItems.Messages.InsufficientSecurityClearance));
}
public void Create_UserHasInsufficientClearance_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var certificateTypeId = Guid.NewGuid();
var categoryId = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
var procedureList = "001; 002";
_certificateService = CertificateServiceFactory.Create(
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public),
ListItemRepositoryTestHelper.GetListItemRepository_StubsGetById_ReturnsCertificateAndCategory(certificateTypeId, categoryId),
MockRepository.GenerateStub <ICertificateRepository>(),
JobItemRepositoryTestHelper.GetJobItemRepository_StubsGetById_ReturnsJobItem(jobItemId));
Create(id, certificateTypeId, categoryId, jobItemId, procedureList);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void GetInstruments_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
try
{
var id = Guid.NewGuid();
var instrumentRepositoryMock = MockRepository.GenerateMock <IInstrumentRepository>();
_instrumentService = InstrumentServiceFactory.Create(
MockRepository.GenerateMock <IInstrumentRepository>(), TestUserContext.Create("*****@*****.**", "Test User", "Operations Manager", UserRole.Public));
_instrumentService.GetInstruments();
}
catch (DomainValidationException dex)
{
_domainValidationException = dex;
}
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
