public void Edit_IsApprovedOrder_ThrowsDomainValidationException()
{
_orderForEdit.IsApproved = true;
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,
_userContext);
Edit(_orderForEditId, supplierId, currencyId, instructions);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.EditApprovedOrder));
}
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 Edit_ValidOrderDetails_EditSuccessful()
{
var supplierId = Guid.NewGuid();
var currencyId = Guid.NewGuid();
var instructions = "some edited instructions";
var orderRepositoryMock = MockRepository.GenerateMock <IOrderRepository>();
orderRepositoryMock.Stub(x => x.GetById(_orderForEditId)).Return(_orderForEdit);
orderRepositoryMock.Expect(x => x.Update(_orderForEdit)).IgnoreArguments();
var supplierRepositoryStub = MockRepository.GenerateMock <ISupplierRepository>();
supplierRepositoryStub.Stub(x => x.GetById(supplierId)).Return(new Supplier {
Id = supplierId, Name = "Supplier for edit"
});
var currencyRepositoryStub = MockRepository.GenerateMock <ICurrencyRepository>();
currencyRepositoryStub.Stub(x => x.GetById(currencyId)).Return(new Currency {
Id = currencyId, Name = "USD"
});
_orderService = OrderServiceTestHelper.CreateOrderService(
orderRepositoryMock, supplierRepositoryStub, currencyRepositoryStub, _userContext);
Edit(_orderForEditId, supplierId, currencyId, instructions);
orderRepositoryMock.VerifyAllExpectations();
Assert.AreEqual(_orderForEdit.Id, _orderForEditId);
Assert.AreEqual(_orderForEdit.Supplier.Id, supplierId);
Assert.AreEqual(_orderForEdit.Currency.Id, currencyId);
Assert.AreEqual(_orderForEdit.Instructions, instructions);
}
public void Approve_InvalidOrderId_DomainValidationExceptionThrown()
{
_orderService = OrderServiceTestHelper.CreateOrderService(
OrderRepositoryTestHelper.GetOrderRepository_StubsGetById_ReturnsNull(_orderForApprovalId),
MockRepository.GenerateStub <ISupplierRepository>(),
MockRepository.GenerateStub <ICurrencyRepository>(),
_userContext);
Approve(_orderForApprovalId);
}
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 Approve_OrderWithNoItems_DomainValidationExceptionThrown()
{
var orderRepositoryStub = MockRepository.GenerateMock <IOrderRepository>();
orderRepositoryStub.Stub(x => x.GetById(_orderForApprovalId)).Return(OrderRepositoryTestHelper.GetOrder(_orderForApprovalId));
_orderService = OrderServiceTestHelper.CreateOrderService(
orderRepositoryStub,
MockRepository.GenerateStub <ISupplierRepository>(),
MockRepository.GenerateStub <ICurrencyRepository>(),
_userContext);
Approve(_orderForApprovalId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.ApprovalWithZeroItems));
}
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 Create_InvalidCurrencyId_ArgumentExceptionThrown()
{
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_ReturnsNull(currencyId),
_userContext);
CreateOrder(orderId, supplierId, instructions, currencyId);
}
public void Approve_ValidApprovalContext_OrderSuccessfullyApproved()
{
var orderRepositoryMock = MockRepository.GenerateMock <IOrderRepository>();
orderRepositoryMock.Stub(x => x.GetById(_orderForApprovalId)).Return(_orderForApproval);
orderRepositoryMock.Expect(x => x.Update(null)).IgnoreArguments();
_orderService = OrderServiceTestHelper.CreateOrderService(
orderRepositoryMock,
MockRepository.GenerateStub <ISupplierRepository>(),
MockRepository.GenerateStub <ICurrencyRepository>(),
_userContext);
Approve(_orderForApprovalId);
orderRepositoryMock.VerifyAllExpectations();
Assert.IsTrue(_orderForApproval.IsApproved);
}
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 Create_InstructionsGreaterThan255Characters_ArgumentExceptionThrown()
{
var orderId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instructions = new string('a', 256);
var currencyId = Guid.NewGuid();
_orderService = OrderServiceTestHelper.CreateOrderService(
MockRepository.GenerateStub <IOrderRepository>(),
SupplierRepositoryTestHelper.GetSupplierRepository_GetById_ReturnsSupplier(supplierId),
CurrencyRepositoryTestHelper.GetCurrencyRepository_StubsGetById_ReturnsGbpCurrency(currencyId),
_userContext);
CreateOrder(orderId, supplierId, instructions, currencyId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InstructionsTooLarge));
}
public void Edit_InvalidOrderId_ThrowsArgumentException()
{
_orderForEditId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var currencyId = Guid.NewGuid();
var instructions = "some edited instructions";
var orderRepositoryStub = MockRepository.GenerateMock <IOrderRepository>();
orderRepositoryStub.Stub(x => x.GetById(_orderForEditId)).Return(null);
_orderService = OrderServiceTestHelper.CreateOrderService(
orderRepositoryStub,
MockRepository.GenerateStub <ISupplierRepository>(),
MockRepository.GenerateStub <ICurrencyRepository>(),
_userContext);
Edit(_orderForEditId, supplierId, currencyId, instructions);
}
public void Create_ValidOrderDetails_OrderCreated()
{
var orderId = Guid.NewGuid();
var supplierId = Guid.NewGuid();
var instructions = "some instructions";
var currencyId = Guid.NewGuid();
var orderRepositoryMock = MockRepository.GenerateMock <IOrderRepository>();
orderRepositoryMock.Expect(x => x.Create(null)).IgnoreArguments();
_orderService = OrderServiceTestHelper.CreateOrderService(
orderRepositoryMock,
SupplierRepositoryTestHelper.GetSupplierRepository_GetById_ReturnsSupplier(supplierId),
CurrencyRepositoryTestHelper.GetCurrencyRepository_StubsGetById_ReturnsGbpCurrency(currencyId),
_userContext);
CreateOrder(orderId, supplierId, instructions, currencyId);
orderRepositoryMock.VerifyAllExpectations();
Assert.AreNotEqual(Guid.Empty, _savedOrder.Id);
Assert.That(_savedOrder.OrderNo.StartsWith("OR"));
Assert.AreEqual("*****@*****.**", _savedOrder.CreatedBy.EmailAddress);
Assert.AreEqual(_dateCreated, _savedOrder.DateCreated);
Assert.AreEqual(false, _savedOrder.IsApproved);
}
/// <summary>
/// Инициализация контекста тестов.
/// </summary>
public override void ClassInitialize()
{
base.ClassInitialize();
Orders = OrderServiceTestHelper.GetOrderTestContext();
}
