public async Task Should_Return_All_By_Application_User_Async()
{
var applicationUserId = Guid.NewGuid();
var repository = MockOrder.GetDBTestRepository();
var order = MockOrder.GetEntityFake();
order.ApplicationUserId = applicationUserId;
order.OrderItems = new List <OrderItem>()
{
new OrderItem()
{
Quantity = 100,
Price = 1,
Fee = 10,
FeeAsset = new Asset()
}
};
order.BaseAsset = new Asset();
order.QuoteAsset = new Asset();
order.Exchange = new Exchange();
await repository.InsertAsync(order);
await repository.InsertAsync(order);
await repository.InsertAsync(MockOrder.GetEntityFake());
var result = await repository.GetAllByApplicationUserAsync(applicationUserId);
Assert.Equal(2, result.Count);
}
public static OrderBase CreateOrder3()
{
OrderBase order = new MockOrder();
//MockProduct prodA = new MockProduct("Product1", 50, "A");
// add items to the cart
// 3 A MockProduct
order.AddProduct(new MockProduct("Product1", 50, "A"));
order.AddProduct(new MockProduct("Product1", 50, "A"));
order.AddProduct(new MockProduct("Product1", 50, "A"));
// 5 B MockProduct
order.AddProduct(new MockProduct("Product2", 30, "B"));
order.AddProduct(new MockProduct("Product2", 30, "B"));
order.AddProduct(new MockProduct("Product2", 30, "B"));
order.AddProduct(new MockProduct("Product2", 30, "B"));
order.AddProduct(new MockProduct("Product2", 30, "B"));
// 1 C & 1 D
order.AddProduct(new MockProduct("Product3", 20, "C"));
order.AddProduct(new MockProduct("Product4", 15, "D"));
//order.AddProduct(new MockProduct("Product1", 50, "A"));
//order.AddProduct(new MockProduct("Product1", 50, "A"));
applyAllDiscounts(order);
return(order);
}
public async Task Should_Load_Childs_In_Orders_By_Application_User_Async()
{
var context = MockDbContext.CreateDBInMemoryContext();
var applicationUserId = Guid.NewGuid();
var repository = MockOrder.GetDBTestRepository(context);
var order = MockOrder.GetEntityFake();
order.ApplicationUserId = applicationUserId;
order.OrderItems = new List <OrderItem>()
{
new OrderItem()
{
Quantity = 100,
Price = 1,
Fee = 10,
FeeAsset = new Asset()
}
};
order.BaseAsset = new Asset();
order.QuoteAsset = new Asset();
order.Exchange = new Exchange();
await repository.InsertAsync(order);
await repository.InsertAsync(order);
await repository.InsertAsync(MockOrder.GetEntityFake());
var result = await repository.GetAllByApplicationUserAsync(applicationUserId);
Assert.Equal(2, result.Count);
Assert.True(result.First().OrderItems.Any());
}
public async Task <Order> PopulateMockOrder()
{
Order order = MockOrder.Populate();
await cosmosDbHelper.Create(order);
return(order);
}
public async Task Should_Return_All_Async()
{
var repository = MockOrder.GetDBTestRepository();
await repository.InsertAsync(MockOrder.GetEntityFake());
await repository.InsertAsync(MockOrder.GetEntityFake());
var result = await repository.GetAll();
Assert.Equal(2, result.ToList().Count);
}
public async Task Should_Delete_Async()
{
var repository = MockOrder.GetDBTestRepository();
var result = await repository.InsertAsync(MockOrder.GetEntityFake());
Assert.NotNull(result);
Assert.True(!result.IsExcluded);
await repository.DeleteAsync(result);
result = await repository.GetAsync(result.Id);
Assert.True(result.IsExcluded);
}
public async Task Should_Return_All_With_Disabled_Async()
{
var repository = MockOrder.GetDBTestRepository();
await repository.InsertAsync(MockOrder.GetEntityFake());
var disable = await repository.InsertAsync(MockOrder.GetEntityFake());
disable.IsEnabled = false;
await repository.UpdateAsync(disable);
var result = await repository.GetAll();
Assert.Equal(2, result.Count);
}
public async Task Should_Return_All_Without_Disabled_Async()
{
var repository = MockOrder.GetDBTestRepository();
await repository.InsertAsync(MockOrder.GetEntityFake());
var disable = await repository.InsertAsync(MockOrder.GetEntityFake());
disable.IsEnabled = false;
await repository.UpdateAsync(disable);
var result = await repository.GetAllWithoutDisable();
Assert.Single(result.ToList());
}
public async Task <MockOrder> CreateOrder(MockOrder mockOrder)
{
var relativeUrl = "OrderManagement/Orders";
try
{
mockOrder = await PostAndReturnCreatedObjectAsync(relativeUrl, mockOrder);
return(mockOrder);
}
catch (Exception)
{
return(null);
}
}
public async Task Should_Update_Async()
{
var repository = MockOrder.GetDBTestRepository();
var entity = MockOrder.GetEntityFake();
entity.Date = DateTime.Now;
var result = await repository.InsertAsync(entity);
Assert.NotNull(result);
result.Date = new DateTime(2000, 1, 1);
await repository.UpdateAsync(result);
result = await repository.GetAsync(result.Id);
Assert.Equal(new DateTime(2000, 1, 1), result.Date);
}
public async Task Should_Insert_And_GetOrder_And_GetOrderItem_Async()
{
var context = MockDbContext.CreateDBInMemoryContext();
var itemRepository = MockOrderItem.GetDBTestRepository(context);
var repository = MockOrder.GetDBTestRepository(context);
var order = MockOrder.GetEntityFake();
var orderItem = MockOrderItem.GetEntityFake();
order.OrderItems = new List <OrderItem>
{
orderItem
};
var result = await repository.InsertAsync(order);
Assert.NotNull(result);
result = await repository.GetAsync(result.Id);
Assert.NotNull(result);
var orderItems = await itemRepository.GetAll();
Assert.Single(orderItems);
}
public static OrderBase CreateOrder1()
{
OrderBase order = new MockOrder();
//MockProduct prodA = new MockProduct("Product1", 50, "A");
// add items to the cart
MockProduct prodA = new MockProduct("Product1", 50, "A");
MockProduct prodB = new MockProduct("Product2", 30, "B");
MockProduct prodC = new MockProduct("Product3", 20, "C");
// MockProduct prodD = new MockProduct("Product4", 15, "D");
order.AddProduct(prodA);
order.AddProduct(prodB);
order.AddProduct(prodC);
//order.AddProduct(new MockProduct("Product1", 50, "A"));
//order.AddProduct(new MockProduct("Product1", 50, "A"));
applyAllDiscounts(order);
return(order);
}
public void Install_should_call_installation_steps_by_a_fixed_sequence()
{
// Arrange
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var proj = fixture.Freeze <Project>();
var pwPkg = new ProjectWidePackage("Prig", "2.0.0", proj);
var callback = default(Action);
var metadataArr = fixture.CreateMany <IVsPackageMetadata>(3).ToArray();
{
var m = fixture.Freeze <Mock <IVsPackageInstallerEvents> >();
callback = () =>
{
m.Raise(_ => _.PackageInstalling += null, metadataArr[0]);
m.Raise(_ => _.PackageInstalled += null, metadataArr[1]);
m.Raise(_ => _.PackageReferenceAdded += null, metadataArr[2]);
};
}
{
var m = fixture.Freeze <Mock <IVsPackageInstaller> >();
m.Setup(_ => _.InstallPackage(It.IsAny <string>(), It.IsAny <Project>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>())).Callback(callback);
}
var mocks = new MockRepository(MockBehavior.Strict);
var order = new MockOrder();
pwPkg.PackageInstalling += mocks.InOrder <VsPackageEventHandler>(order, m => m.Setup(_ => _(metadataArr[0]))).Object;
pwPkg.PackageInstalled += mocks.InOrder <VsPackageEventHandler>(order, m => m.Setup(_ => _(metadataArr[1]))).Object;
pwPkg.PackageReferenceAdded += mocks.InOrder <VsPackageEventHandler>(order, m => m.Setup(_ => _(metadataArr[2]))).Object;
var pwInstllr = fixture.NewProjectWideInstaller();
// Act
pwInstllr.Install(pwPkg);
// Assert
mocks.VerifyAll();
}
public void Execute_should_raise_the_event_to_execute_specified_PowerShell_command_before_and_after()
{
// Arrange
var command = @"
([System.Management.Automation.PSMemberTypes])
";
var mci = new ManagementCommandInfo(command);
var mocks = new MockRepository(MockBehavior.Strict);
var order = new MockOrder();
mci.CommandExecuting += mocks.InOrder <Action>(order, m => m.Setup(_ => _())).Object;
mci.CommandExecuted += mocks.InOrder <Action>(order, m => m.Setup(_ => _())).Object;
var mcExecutor = new ManagementCommandExecutor();
// Act
mcExecutor.Execute(mci);
// Assert
mocks.VerifyAll();
}
public async Task Should_Delete_With_OrderItens_Async()
{
var context = MockDbContext.CreateDBInMemoryContext();
var applicationUserId = Guid.NewGuid();
var repository = MockOrder.GetDBTestRepository(context);
var orderItemRepository = MockOrderItem.GetDBTestRepository(context);
var order = MockOrder.GetEntityFake();
order.ApplicationUserId = applicationUserId;
order.OrderItems = new List <OrderItem>()
{
new OrderItem()
{
Quantity = 100,
Price = 1,
Fee = 10,
FeeAsset = new Asset()
}
};
order = await repository.InsertAsync(order);
Assert.NotNull(order);
Assert.True(!order.IsExcluded);
Assert.True(!order.OrderItems.First().IsExcluded);
var orderItems = await orderItemRepository.GetAllByOrderIdAsync(order.Id);
Assert.True(orderItems.Any());
await repository.DeleteAsync(order);
order = await repository.GetAsync(order.Id);
Assert.True(order.IsExcluded);
orderItems = await orderItemRepository.GetAllByOrderIdAsync(order.Id);
Assert.True(!orderItems.Any());
}
public async Task <MockOrder> CreateOrder(MockOrder order)
{
var result = await _capability1RestClient.CreateOrder(order);
return(result);
}
public void ThenANewPackingSlipIsGeneratedAndAddedToTheOrder()
{
_generatePackingSlipForPhysicalProduct.Apply(MockOrder.Object);
MockOrder.Verify(m => m.SetPackingSlip(It.Is <PackingSlip>(ps => PackingSlipDepartmentIsExpected(ps))), Times.Once);
}
public void ThenTheProductIsAddedToThePackingSlip()
{
_generatePackingSlipForPhysicalProduct.Apply(MockOrder.Object);
MockOrder.Verify(m => m.SetPackingSlip(It.Is <PackingSlip>(ps => PackingSlipProductListIsExpected(ps))), Times.Once);
}
