public void TestSearchOrderField(Enums.ResourceType resourceType, List <string> fieldsName, OrderTestHelper.OrderType orderType)
{
string smallestId = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
//Read & verify the field's value
OrderTestHelper.ReadAndVerify(resourceType, fieldsName, orderType, smallestId, typeof(User), NumberOfResourceSet);
}
public void ValidateIncorrectOrderTest()
{
var order = OrderTestHelper.CreateInvalidNaTestInvalidIndexIs1();
step.Validate(order);
Assert.AreEqual(1, order.FirstError.Value);
}
public void CtorOrder_AssignsVariables_Correctly()
{
var orderId = "order-id";
var fund = "fund-a";
var strategy = "strategy-b";
var clientAccount = "client-account";
var orderFilledVolume = 1002;
var order = OrderTestHelper.Random(new Order());
order.OrderId = orderId;
order.OrderFund = fund;
order.OrderStrategy = strategy;
order.OrderClientAccountAttributionId = clientAccount;
order.OrderFilledVolume = orderFilledVolume;
var alloc = new OrderAllocation(order);
Assert.AreEqual(string.Empty, alloc.Id);
Assert.AreEqual(orderId, alloc.OrderId);
Assert.AreEqual(fund, alloc.Fund);
Assert.AreEqual(strategy, alloc.Strategy);
Assert.AreEqual(orderFilledVolume, alloc.OrderFilledVolume);
Assert.IsNull(alloc.CreatedDate);
}
public void ValidateCorrectOrderTest()
{
var order = OrderTestHelper.CreateValidNaTest();
step.Validate(order);
Assert.IsFalse(order.FirstError.HasValue);
}
public void ValidateAlreadyValidatedInvalidOrderErrorIndexChangesTest()
{
var order = OrderTestHelper.CreateValidatedInvalidOrderInvalidIndexIs2();
order.FirstError = 3;
step.Validate(order);
Assert.AreEqual(2, order.FirstError.Value);
}
public void Ctor_AssignsVariables_Correctly()
{
var order = OrderTestHelper.Random(new Order(), 30);
var orderAnalysis = new OrderAnalysis(order, PriceSentiment.Negative);
Assert.AreEqual(PriceSentiment.Negative, orderAnalysis.Sentiment);
Assert.AreEqual(order, orderAnalysis.Order);
}
public void ValidateAlreadyValidatedInvalidOrderErrorIndexDoesNotChangeTest()
{
var order = OrderTestHelper.CreateInvalidNaTestInvalidIndexIs1();
order.FirstError = 0;
step.Validate(order);
Assert.AreEqual(0, order.FirstError.Value);
}
public void GenerateOutputWithMultipleItems()
{
var dishes = new Dish[]
{
DishConstants.Coffeex3
};
var result = gen.GenerateResult(OrderTestHelper.CreateOrder(EOrderType.Morning, null, dishes));
Assert.AreEqual("coffee(x3)", result);
}
public void GenerateOutputForOrderWithError()
{
var dishes = new Dish[]
{
DishConstants.Steak, DishConstants.Steak, DishConstants.Potatoes, DishConstants.Wine
};
var result = gen.GenerateResult(OrderTestHelper.CreateOrder(EOrderType.Night, 1, dishes));
Assert.AreEqual("steak, error", result);
}
public void ValidateIncorrectOrderTest()
{
var order = OrderTestHelper.CreateInvalidMorningOrderWrongSecondItem();
step.Validate(order);
Assert.AreEqual(2, order.FirstError.Value);
order = OrderTestHelper.CreateInvalidNightOrderWronSecondItem();
step.Validate(order);
Assert.AreEqual(2, order.FirstError.Value);
}
public void ResolveSentiment_CoverOrder_IsPositive()
{
var service = this.Service();
var order = OrderTestHelper.Random(new Order());
order.OrderDirection = OrderDirections.COVER;
var sentiment = service.ResolveSentiment(new[] { order });
Assert.AreEqual(sentiment, PriceSentiment.Positive);
}
public void ResolveSentiment_ShortOrder_IsNegative()
{
var service = this.Service();
var order = OrderTestHelper.Random(new Order());
order.OrderDirection = OrderDirections.SHORT;
var sentiment = service.ResolveSentiment(new[] { order });
Assert.AreEqual(sentiment, PriceSentiment.Negative);
}
public void GenerateOutputForOrderWithoutErrors()
{
var dishes = new Dish[]
{
DishConstants.Coffee, DishConstants.Eggs, DishConstants.Cake, DishConstants.Potatoes, DishConstants.Steak, DishConstants.Toast, DishConstants.Wine
};
var result = gen.GenerateResult(OrderTestHelper.CreateOrder(EOrderType.Morning, null, dishes.ToArray()));
List <string> expectedList = new List <string>(dishes.Length);
expectedList.AddRange(dishes.Select(dish => dish.DishDescription));
Assert.AreEqual(string.Join(", ", expectedList.ToArray()), result);
}
public void ResolveSentiment_BuyThenSell_IsMixed()
{
var service = this.Service();
var order1 = OrderTestHelper.Random(new Order());
order1.OrderDirection = OrderDirections.BUY;
var order2 = OrderTestHelper.Random(new Order());
order2.OrderDirection = OrderDirections.SELL;
var sentiment = service.ResolveSentiment(new[] { order1, order2 });
Assert.AreEqual(sentiment, PriceSentiment.Mixed);
}
public async Task GetOrderTestAsync()
{
// Arrange
mockOrderService.Setup(service => service.SingleOrder(It.IsAny <int>())).ReturnsAsync(await OrderTestHelper.GetOrder());
OrderController controller = new OrderController(mockOrderService.Object);
// Act
var result = await controller.Single(It.IsAny <int>());
var okResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsType <OrderViewDto>(okResult.Value);
// Assert
Assert.Equal((await OrderTestHelper.GetOrder()).TotalSum, model.TotalSum);
}
public async Task CreateOrderTestAsync()
{
// Arrange
Mock <CreateOrderDto> mockOrderDto = new Mock <CreateOrderDto>();
OrderController controller = new OrderController(mockOrderService.Object);
// Act
var result = await controller.Create(await OrderTestHelper.GetOrderCreateNormal());
var okResult = Assert.IsType <OkObjectResult>(result);
// Assert
Assert.IsType <OkObjectResult>(result);
mockOrderService.Verify(
mock => mock.CreateOrder(mockOrderDto.Object), Times.Never());
}
public async Task GetListOrdersTestAsync()
{
// Arrange
mockOrderService.Setup(service => service.ListOrders()).ReturnsAsync(await OrderTestHelper.GetOrders());
OrderController controller = new OrderController(mockOrderService.Object);
// Act
var result = await controller.List();
var okResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsType <List <OrderListDto> >(okResult.Value);
// Assert
Assert.Equal((await OrderTestHelper.GetOrders()).Where(o => o.TotalSum == 4000).FirstOrDefault().TotalCount, model.Where(o => o.TotalSum == 4000).FirstOrDefault().TotalCount);
Assert.Equal((await OrderTestHelper.GetOrders()).Count, model.Count);
}
public void TestSearchOrderPhase(List <string> fieldsName, OrderTestHelper.OrderType orderType)
{
Enums.ResourceType resourceType = Enums.ResourceType.Client;
string id = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
List <string> phaseIdList = new List <string>();
for (int i = 0; i < NumberOfResourceSet; i++)
{
var phase = FieldHelper.CreatePhaseInstance(resourceType, id);
string phaseId = ResourceHelper.WriteResource(phase, null);
phaseIdList.Add(phaseId);
Assume.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, nameof(Phase)));
}
OrderTestHelper.ReadPhaseAndVerify(resourceType, fieldsName, orderType, phaseIdList.FirstOrDefault(), typeof(User), NumberOfResourceSet);
}
public void ValidateCorrectOrderTest()
{
var order = OrderTestHelper.CreateValidMorningOrder();
step.Validate(order);
Assert.IsFalse(order.FirstError.HasValue);
order = OrderTestHelper.CreateValidMorningOrderWith3CupsOfCoffee();
step.Validate(order);
Assert.IsFalse(order.FirstError.HasValue);
order = OrderTestHelper.CreateValidNightOrder();
step.Validate(order);
Assert.IsFalse(order.FirstError.HasValue);
order = OrderTestHelper.CreateValidNightOrderWithMultipleServingsOfPotatoes();
step.Validate(order);
Assert.IsFalse(order.FirstError.HasValue);
}
public void OpposingSentiment_HasFullCoverage_OfAllPriceSentiments()
{
var service = this.Service();
var rawValues = Enum.GetValues(typeof(PriceSentiment));
var order1 = OrderTestHelper.Random(new Order());
order1.OrderDirection = OrderDirections.BUY;
var orderAnalysis1 = new OrderAnalysis(order1, PriceSentiment.Positive);
var order2 = OrderTestHelper.Random(new Order());
order2.OrderDirection = OrderDirections.SELL;
var orderAnalysis2 = new OrderAnalysis(order2, PriceSentiment.Negative);
var orders = new[] { orderAnalysis1, orderAnalysis2 };
foreach (var val in rawValues)
{
Assert.DoesNotThrow(() => service.OpposingSentiment(orders, (PriceSentiment)val));
}
}
