public void OrderGetTotalOrderSumLines() { //Arrange string shippingName = "shippingName"; string shippingCity = "shippingCity"; string shippingZipCode = "shippingZipCode"; string shippingAddress = "shippingAddress"; Customer customer = new Customer(); customer.GenerateNewIdentity(); Order order = OrderFactory.CreateOrder(customer, shippingName, shippingCity, shippingAddress, shippingZipCode); order.AddNewOrderLine(Guid.NewGuid(), 1, 500, 10); order.AddNewOrderLine(Guid.NewGuid(), 2, 300, 10); decimal expected = ((1 * 500) * (1 - (10M / 100M))) + ((2 * 300) * (1 - (10M / 100M))); //Act decimal actual = order.GetOrderTotal(); //Assert Assert.AreEqual(expected, actual); }
public void OrderDiscountGreatherThan100IsEqualTo100Discount() { //Arrange var shippingName = "shippingName"; var shippingCity = "shippingCity"; var shippingZipCode = "shippingZipCode"; var shippingAddress = "shippingAddress"; var customer = new Customer(); customer.GenerateNewIdentity(); var order = OrderFactory.CreateOrder(customer, shippingName, shippingCity, shippingAddress, shippingZipCode); order.AddNewOrderLine(Guid.NewGuid(), 1, 500, 101); order.AddNewOrderLine(Guid.NewGuid(), 2, 300, 101); var expected = ((1 * 500) * (1 - (100M / 100M))) + ((2 * 300) * (1 - (100M / 100M))); //Act var actual = order.GetOrderTotal(); //Assert Assert.AreEqual(expected, actual); }
public void OrderNumberIsComposedWithOrderDateAndSequenceOrderNumber() { //Arrange var shippingName = "shippingName"; var shippingCity = "shippingCity"; var shippingZipCode = "shippingZipCode"; var shippingAddress = "shippingAddress"; var customer = new Customer(); customer.GenerateNewIdentity(); var order = OrderFactory.CreateOrder(customer, shippingName, shippingCity, shippingAddress, shippingZipCode); //Act var expected = string.Format( "{0}/{1}-{2}", order.OrderDate.Year, order.OrderDate.Month, order.SequenceNumberOrder); var result = order.OrderNumber; //Assert Assert.AreEqual(expected, result); }
public void Add_100_OrderItem() { var dbContextScopeFactory = new DbContextScopeFactory(); var ambientDbContextLocator = new AmbientDbContextLocator(); var orderFactory = new OrderFactory(); using (var dbContextScope = dbContextScopeFactory.Create()) { var personRepository = new PersonRepository(ambientDbContextLocator); var orderRepository = new OrderRepository(ambientDbContextLocator); var person = personRepository.GetByName("ding.p"); var order = orderFactory.CreateOrder(person); orderRepository.Add(order); for (int i = 0; i < 100; i++) { var orderItem = order.CreateItem("A-" + i); order.OrderLine.Add(orderItem); } dbContextScope.SaveChanges(); } }
public void FindOrdersMaterializeResultsIfCustomerExist() { //Arrange var customerRepository = new SICustomerRepository(); var productRepository = new SIProductRepository(); var orderRepository = new SIOrderRepository(); orderRepository.GetFilteredExpressionOfFuncOfOrderBoolean = (filter) => { var orders = new List <Order>(); var customer = new Customer(); customer.ChangeCurrentIdentity(Guid.NewGuid()); orders.Add(OrderFactory.CreateOrder(customer, "name", "city", "address", "zipcode")); return(orders); }; var salesManagement = new SalesAppService(productRepository, orderRepository, customerRepository); //act var result = salesManagement.FindOrders(Guid.NewGuid()); //Assert Assert.IsNotNull(result); Assert.IsTrue(result.Count == 1); }
public void OrderRepositoryRemoveItemDeleteIt() { //Arrange var unitOfWork = new MainBcUnitOfWork(); var customerRepository = new CustomerRepository(unitOfWork); var orderRepository = new OrderRepository(unitOfWork); var customer = customerRepository.Get(new Guid("0CD6618A-9C8E-4D79-9C6B-4AA69CF18AE6")); var order = OrderFactory.CreateOrder( customer, "shipping name", "shipping city", "shipping address", "shipping zip code"); order.GenerateNewIdentity(); orderRepository.Add(order); orderRepository.UnitOfWork.Commit(); //Act orderRepository.Remove(order); unitOfWork.Commit(); }
public void FindOrdersMaterializeResultsIfCustomerExist() { //Arrange var customerRepository = new Mock <ICustomerRepository>(); var productRepository = new Mock <IProductRepository>(); var orderRepository = new Mock <IOrderRepository>(); Mock <ILogger <SalesAppService> > _mockLogger = new Mock <ILogger <SalesAppService> >(); orderRepository .Setup(x => x.GetFiltered(It.IsAny <Expression <Func <Order, bool> > >())) .Returns((Expression <Func <Order, bool> > filter) => { var orders = new List <Order>(); var customer = new Customer(); customer.ChangeCurrentIdentity(Guid.NewGuid()); orders.Add(OrderFactory.CreateOrder(customer, "name", "city", "address", "zipcode")); return(orders); }); var salesManagement = new SalesAppService(productRepository.Object, orderRepository.Object, customerRepository.Object, _mockLogger.Object); //act var result = salesManagement.FindOrders(Guid.NewGuid()); //Assert Assert.NotNull(result); Assert.True(result.Count == 1); }
public void GetOpenOrders_IfTraderIdIsProvided_RetrievedOrdersShouldBeDateTimeSortedAsDescending() { ManualResetEvent resetEvent = new ManualResetEvent(false); Order order = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); resetEvent.WaitOne(2000); resetEvent.Reset(); Order order1 = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); resetEvent.WaitOne(2000); resetEvent.Reset(); Order order2 = OrderFactory.CreateOrder("100", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); resetEvent.WaitOne(2000); resetEvent.Reset(); OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order); _persistanceRepository.SaveOrUpdate(model); OrderReadModel model1 = ReadModelAdapter.GetOrderReadModel(order1); _persistanceRepository.SaveOrUpdate(model1); OrderReadModel model2 = ReadModelAdapter.GetOrderReadModel(order2); _persistanceRepository.SaveOrUpdate(model2); IList <OrderReadModel> getReadModel = _orderRepository.GetOpenOrders("100"); Assert.NotNull(getReadModel); Assert.AreEqual(getReadModel.Count, 3); Assert.True(getReadModel[0].DateTime > getReadModel[1].DateTime); Assert.True(getReadModel[1].DateTime > getReadModel[2].DateTime); }
public void CreateOrder_SingleOrder_ReturnsSingleOrder() { var logger = Mock.Of <ILogger <OrderFactory> >(); var factory = new OrderFactory(logger); var message = "custom message"; var order = factory.CreateOrder(message); Assert.NotNull(order); Assert.Equal(message, order.Message); var noMessageOrder = factory.CreateOrder(); Assert.NotNull(noMessageOrder); Assert.Null(noMessageOrder.Message); }
public void OrderFactoryCreateValidOrder() { //Arrange string shippingName = "shippingName"; string shippingCity = "shippingCity"; string shippingZipCode = "shippingZipCode"; string shippingAddress = "shippingAddress"; Customer customer = new Customer(); customer.GenerateNewIdentity(); //Act Order order = OrderFactory.CreateOrder(customer, shippingName, shippingCity, shippingAddress, shippingZipCode); var validationContext = new ValidationContext(order, null, null); var validationResult = order.Validate(validationContext); //Assert ShippingInfo shippingInfo = new ShippingInfo(shippingName, shippingAddress, shippingCity, shippingZipCode); Assert.AreEqual(shippingInfo, order.ShippingInformation); Assert.AreEqual(order.Customer, customer); Assert.AreEqual(order.CustomerId, customer.Id); Assert.IsFalse(order.IsDelivered); Assert.IsNull(order.DeliveryDate); Assert.IsTrue(order.OrderDate != default(DateTime)); Assert.IsFalse(validationResult.Any()); }
public void IsCreditValidForOrderReturnFalseIfTotalOrderIsGreaterThanCustomerCredit() { //Arrange string shippingName = "shippingName"; string shippingCity = "shippingCity"; string shippingZipCode = "shippingZipCode"; string shippingAddress = "shippingAddress"; var country = new Country("spain", "es-ES"); country.GenerateNewIdentity(); var customer = CustomerFactory.CreateCustomer("jhon", "el rojo", "+3422", "company", country, new Address("city", "zipCode", "address line1", "addres line2")); //Act Order order = OrderFactory.CreateOrder(customer, shippingName, shippingCity, shippingAddress, shippingZipCode); order.AddNewOrderLine(Guid.NewGuid(), 100, 240, 0); // this is greater that 1000 ( default customer credit ) //assert var result = order.IsCreditValidForOrder(); //Assert Assert.IsFalse(result); }
private void PublishOrdersAfterReplay() { string currencyPair = "XBTUSD"; Order order1 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 406, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1)); Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 406, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2)); Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 405, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3)); Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 100, 407, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4)); Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 409, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5)); Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 413, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6)); ManualResetEvent resetEvent = new ManualResetEvent(false); resetEvent.WaitOne(10000); }
public static void Main(string[] args) { // Lazy loading var orderLazy = new OrderLazy(); var customer = orderLazy.Customer; orderLazy.PrintLabel(); // Virtual Proxy var factory = new OrderFactory(); var order = factory.CreateOrder(123); order.PrintLabel(); order.PrintLabel(); order.PrintLabel(); // Value holder var valueOrderFactory = new OrderFactoryValueHolder(); var factoryOrder = valueOrderFactory.CreareOrder(11); var items = factoryOrder.Items; var items2 = factoryOrder.Items; var items3 = factoryOrder.Items; Console.ReadKey(); }
public void AddOrdersToExchange_IfOrdersAreMatching_TradeWillbeFormedAndStoredInDbAndAllEventShouldBeDispatched() { bool tradeEventArrived = false; bool depthArrived = false; bool bboChangeArrived = false; bool orderBookArrived = false; Trade receivedTrade = null; IList <CurrencyPair> currencyPairs = new List <CurrencyPair>(); currencyPairs.Add(new CurrencyPair("BTCLTC", "LTC", "BTC")); currencyPairs.Add(new CurrencyPair("BTCDOGE", "DOGE", "BTC")); Exchange exchange = new Exchange(currencyPairs); string currencyPair = "BTCLTC"; Order buyOrder = OrderFactory.CreateOrder("1234", currencyPair, "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); Order sellOrder = OrderFactory.CreateOrder("12334", currencyPair, "market", "sell", 5, 0, new StubbedOrderIdGenerator()); exchange.PlaceNewOrder(buyOrder); exchange.PlaceNewOrder(sellOrder); //receive dispatch event. TradeEvent.TradeOccured += delegate(Trade trade) { tradeEventArrived = true; receivedTrade = trade; //_manualResetEvent.Set(); }; DepthEvent.DepthChanged += delegate(Depth depth) { depthArrived = true; }; BBOEvent.BBOChanged += delegate(BBO bbo) { bboChangeArrived = true; }; LimitOrderBookEvent.LimitOrderBookChanged += delegate(LimitOrderBook orderBook) { orderBookArrived = true; }; _manualResetEvent.WaitOne(5000); IList <Trade> trades = _eventStore.GetTradeEventsFromOrderId(buyOrder.OrderId.Id.ToString()); //assert events fired Assert.True(tradeEventArrived); Assert.True(depthArrived); Assert.True(bboChangeArrived); Assert.True(orderBookArrived); //assert that trade event is stored in DB Assert.AreEqual(trades.Count, 1); AreEqual(trades[0].BuyOrder, buyOrder); AreEqual(trades[0].SellOrder, sellOrder); //assert received trade and stored trade are same Assert.NotNull(receivedTrade); AreEqual(trades[0], receivedTrade); }
public void OrderDateIsCurrentAfterCreation() { DateTime theTimeBefore = DateTime.Now.AddMilliseconds(-1); Order order = OrderFactory.CreateOrder(_FakeACustomer(1)); Assert.True(order.OrderDate > theTimeBefore); Assert.True(order.OrderDate < DateTime.Now.AddMilliseconds(1)); }
public void GetOrderBookTest_ChecksIfOrderBookIsRetreivedProperly_ValidatesReturnedOrderBook() { // Get the context // IApplicationContext applicationContext = ContextRegistry.GetContext(); // Get the instance through Spring configuration MarketController marketController = (MarketController)_applicationContext["MarketController"]; LimitOrderBook limitOrderBook = new LimitOrderBook("XBTUSD"); Order buyOrder1 = OrderFactory.CreateOrder("1233", "XBTUSD", Constants.ORDER_TYPE_LIMIT, Constants.ORDER_SIDE_BUY, 150, 481.34M, new StubbedOrderIdGenerator()); Order buyOrder2 = OrderFactory.CreateOrder("1234", "XBTUSD", Constants.ORDER_TYPE_LIMIT, Constants.ORDER_SIDE_BUY, 50, 482.34M, new StubbedOrderIdGenerator()); Order buyOrder3 = OrderFactory.CreateOrder("1222", "XBTUSD", Constants.ORDER_TYPE_LIMIT, Constants.ORDER_SIDE_BUY, 50, 483.34M, new StubbedOrderIdGenerator()); Order sellOrder1 = OrderFactory.CreateOrder("1233", "XBTUSD", Constants.ORDER_TYPE_LIMIT, Constants.ORDER_SIDE_SELL, 150, 491.34M, new StubbedOrderIdGenerator()); Order sellOrder2 = OrderFactory.CreateOrder("1234", "XBTUSD", Constants.ORDER_TYPE_LIMIT, Constants.ORDER_SIDE_SELL, 50, 492.34M, new StubbedOrderIdGenerator()); Order sellrder3 = OrderFactory.CreateOrder("1222", "XBTUSD", Constants.ORDER_TYPE_LIMIT, Constants.ORDER_SIDE_SELL, 50, 493.34M, new StubbedOrderIdGenerator()); limitOrderBook.PlaceOrder(buyOrder1); limitOrderBook.PlaceOrder(buyOrder2); limitOrderBook.PlaceOrder(buyOrder3); limitOrderBook.PlaceOrder(sellOrder1); limitOrderBook.PlaceOrder(sellOrder2); limitOrderBook.PlaceOrder(sellrder3); OrderBookMemoryImage orderBookMemoryImage = (OrderBookMemoryImage)_applicationContext["OrderBookMemoryImage"]; orderBookMemoryImage.OnOrderBookChanged(limitOrderBook); IHttpActionResult httpActionResult = marketController.GetOrderBook("XBTUSD"); OkNegotiatedContentResult <object> okResponseMessage = (OkNegotiatedContentResult <object>)httpActionResult; OrderBookRepresentation representation = okResponseMessage.Content as OrderBookRepresentation; Assert.IsNotNull(okResponseMessage); Assert.IsNotNull(representation); // Check the Currency Pair for Bid Book Assert.AreEqual("XBTUSD", representation.Bids.CurrencyPair); // Check the Currency Pair for Ask Book Assert.AreEqual("XBTUSD", representation.Asks.CurrencyPair); // Count of the number of Bids in the Bid Order Book Assert.AreEqual(3, representation.Bids.Count()); // Count of the number of Asks in the Ask Order Book Assert.AreEqual(3, representation.Asks.Count()); Assert.AreEqual(50, representation.Bids.ToList()[0].Volume); // Highest Bid Volumein Bid Order Book Assert.AreEqual(483.34M, representation.Bids.ToList()[0].Price); // Highest Bid Price in Bid Order Book Assert.AreEqual(150, representation.Asks.ToList()[0].Volume); // Highest Ask Volumein Ask Order Book Assert.AreEqual(491.34M, representation.Asks.ToList()[0].Price); // Highest Ask Price in Ask Order Book }
public void SetRegistroBitacoraStatusOk() { //Arrange(Preparar) OrderIncome order = OrderFactory.CreateOrder(_customer, "", "", ""); //Act(Actuar) order.SetRegistroBitacoraStatus(); //Assert(Afirmar) order.OrderIncomeStatusId.ShouldBe(OrderIncomeStatus.RegistroBitacora.Id); }
public void PublishOrderToOutputDisruptor_IfOrderIsConvertedToByteArray_ItShouldBeReceivedAndCastedToOrder() { Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "market", "buy", 5, 0, new StubbedOrderIdGenerator()); //byte[] array = ObjectToByteArray(order); OutputDisruptor.Publish(order); _manualResetEvent.WaitOne(3000); Assert.NotNull(_receviedOrder); Assert.AreEqual(_receviedOrder, order); }
public void CreateSellSideMarketOrderTest() { Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "market", "sell", 5, 0, new StubbedOrderIdGenerator()); Assert.NotNull(order.OrderId); Assert.AreEqual(order.CurrencyPair, "XBTUSD"); Assert.AreEqual(order.OrderType, OrderType.Market); Assert.AreEqual(order.OrderSide, OrderSide.Sell); Assert.AreEqual(order.Volume.Value, 5); }
public void PublishOrder_IfOrderIsAddedInPayload_ReceiveOrderInPayloadInConsumer() { _counter = 1;//as sending only one message Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); InputPayload payload = InputPayload.CreatePayload(order); InputDisruptorPublisher.Publish(payload); _manualResetEvent.WaitOne(2000); Assert.AreEqual(payload.Order, order); }
public void ValidateCancelOrderCommand_IfOrderIdAndTraderIdIsValidAndOrderStatusIsNotCompleteOrCancelled_CommandWillBeValidated() { Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order); _persistanceRepository.SaveOrUpdate(model); CancelOrderCommand command = new CancelOrderCommand(order.OrderId, order.TraderId); ICancelOrderCommandValidation validation = new CancelOrderCommandValidation(_orderRepository); Assert.True(validation.ValidateCancelOrderCommand(command)); }
public void CreateBuySideLimitOrderTest() { Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); Assert.NotNull(order.OrderId); Assert.AreEqual(order.CurrencyPair, "XBTUSD"); Assert.AreEqual(order.OrderType, OrderType.Limit); Assert.AreEqual(order.OrderSide, OrderSide.Buy); Assert.AreEqual(order.Volume.Value, 5); Assert.AreEqual(order.Price.Value, 10); }
public async Task HandleAsync(CreateNewOrderCommand command) { var orderId = Id.From(command.OrderId); var clientId = Id.From(command.ClientId); Order order = await _factory.CreateOrder(orderId, clientId); await _ordeRepository.Save(order); var paymentEvent = new OrderCreatedEvent(order.Id, order.Client.Id, CurrentDateTime.Local); await EventBus.Current.PublishAsync(paymentEvent); }
public string Proccess(HttpRequest request, HttpResponse response) { var context = Application.CreateContext(); if (!request.Headers.AllKeys.Contains("Api-Key")) { return("Failed."); } var key = request.Headers["Api-Key"]; if (context.Users.Count(x => x.ApiKey == key) == 0) { Console.WriteLine("no user"); return("Failed. No user."); } var user = context.Users.First(x => x.ApiKey == key); if (user.Role != UserRole.Operator) { return("Only operator can create orders."); } var json = request.Params["Order"]; var data = JsonConvert.DeserializeObject <ClientGoodsData[]>(json); try { var goods = data.Map(x => new OrderRelatedGoods { Good = context.Goods.First(good => good.Id == x.Id), Count = x.Count }); var order = OrderFactory.CreateOrder(user, goods); context.Orders.Add(order); context.SaveChanges(); var resp = "ТОВ \"БІЛОЦЕРКІВСЬКИЙ ХАВЧИК\"\n\n" + $"ФІКСАЛЬНИЙ ЧЕК НОМЕР {order.Id}\n" + $"КАССИР: {order.User.FullName}\n\n"; resp = order.Goods.Fold(resp, (current, pair) => current + $"{pair.Good.Name} x{pair.Count} : {pair.Sum} грн.\n"); resp += $"\n\nЗАГАЛЬНА СУММА: {order.Sum} грн.\n" + "ДЯКУЄМО ЗА ПОКУПКУ"; return(resp); } catch (Exception e) { return(e.Message); } }
public void VerifyTickerInfoCalculations_WhenANewTradeIsArrived_NewUpdatedTickerInfoShouldGetSaved() { Order buyOrder = OrderFactory.CreateOrder("123", "XBTUSD", "limit", "buy", 10, 100, new StubbedOrderIdGenerator()); Order sellOrder = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "sell", 10, 100, new StubbedOrderIdGenerator()); DateTime dateTime = DateTime.Now.AddSeconds(-1 * DateTime.Now.Second); Trade trade5 = new Trade(new TradeId("1"), "XBTUSD", new Price(2), new Volume(10), dateTime.AddDays(-1), buyOrder, sellOrder); Trade trade6 = new Trade(new TradeId("2"), "XBTUSD", new Price(3), new Volume(5), dateTime.AddDays(-1).AddMinutes(1), buyOrder, sellOrder); Trade trade1 = new Trade(new TradeId("3"), "XBTUSD", new Price(10), new Volume(10), dateTime.AddSeconds(10), buyOrder, sellOrder); Trade trade2 = new Trade(new TradeId("4"), "XBTUSD", new Price(15), new Volume(15), dateTime.AddSeconds(15), buyOrder, sellOrder); Trade trade3 = new Trade(new TradeId("5"), "XBTUSD", new Price(20), new Volume(5), dateTime.AddSeconds(20), buyOrder, sellOrder); Trade trade4 = new Trade(new TradeId("6"), "XBTUSD", new Price(5), new Volume(10), dateTime.AddSeconds(40), buyOrder, sellOrder); OutputDisruptor.Publish(trade5); _manualResetEvent.WaitOne(4000); OutputDisruptor.Publish(trade6); _manualResetEvent.WaitOne(4000); OutputDisruptor.Publish(trade1); _manualResetEvent.WaitOne(4000); OutputDisruptor.Publish(trade2); _manualResetEvent.WaitOne(4000); OutputDisruptor.Publish(trade3); _manualResetEvent.WaitOne(4000); OutputDisruptor.Publish(trade4); _manualResetEvent.WaitOne(10000); TickerInfoReadModel model = _tickerInfoRepository.GetTickerInfoByCurrencyPair("XBTUSD"); Assert.NotNull(model); Assert.AreEqual(model.CurrencyPair, "XBTUSD"); Assert.AreEqual(model.TradePrice, 5); Assert.AreEqual(model.TradeVolume, 10); Assert.AreEqual(model.OpeningPrice, 10); Assert.AreEqual(model.TodaysHigh, 20); Assert.AreEqual(model.Last24HoursHigh, 20); Assert.AreEqual(model.TodaysLow, 5); Assert.AreEqual(model.Last24HoursLow, 3); Assert.AreEqual(model.TodaysVolume, 40); Assert.AreEqual(model.Last24HourVolume, 45); Assert.AreEqual(model.TodaysTrades, 4); Assert.AreEqual(model.Last24HourTrades, 5); Assert.AreEqual(model.TodaysVolumeWeight, 11.875m); Assert.AreEqual(model.Last24HourVolumeWeight, 10.88889m); }
private void Scenario1() { string currencyPair = "XBTUSD"; Order order1 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 400, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1)); Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 401, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2)); Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 402, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3)); Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 103, 403, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4)); Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 104, 404, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5)); Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 105, 405, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6)); Order order7 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 106, 406, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order7)); Order order8 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 100, 410, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order8)); Order order9 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 101, 409, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order9)); Order order10 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 102, 407, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order10)); Order order11 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 103, 406, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order11)); Order order12 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 104, 405, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order12)); Order order13 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 105, 411, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order13)); Order order14 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 106, 412, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order14)); Order order15 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 107, 400, new StubbedOrderIdGenerator()); InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order15)); ManualResetEvent resetEvent = new ManualResetEvent(false); resetEvent.WaitOne(20000); }
public void SetCompletadoStatusOk() { //Arrange(Preparar) OrderIncome order = OrderFactory.CreateOrder(_customer, "", "", ""); //Act(Actuar) order.SetRegistroBitacoraStatus(); order.SetDianStatus(); order.SetVerificacionBitacoraStatus(); order.SetCompletadoStatus(); //Assert(Afirmar) order.OrderIncomeStatusId.ShouldBe(OrderIncomeStatus.Completado.Id); }
protected virtual Order ConvertOrder(ActiveCommerce.Orders.Legacy.Order source) { Assert.ArgumentNotNull(source, "source"); Assert.IsNotNull(source.CustomerInfo, "customerinfo"); Assert.IsNotNull(source.Currency, "currency"); var destination = OrderFactory.CreateOrder(); destination.ShopContext = Sitecore.Context.Site.Name; destination.IssueDate = source.OrderDate; destination.OrderId = source.OrderNumber; destination.State = GetState(source); var payment = GetPayment(source, destination); destination.Payments.Add(payment); destination.PricingCurrencyCode = source.Currency.Code; destination.TaxCurrencyCode = source.Currency.Code; destination.TaxTotal = GetTaxTotal(source); destination.AnticipatedMonetaryTotal = GetAnticipatedMonetaryTotal(source); destination.AllowanceCharge = GetAllowanceCharge(source); destination.DestinationCountryCode = source.CustomerInfo.BillingAddress.Country.Code; destination.BuyerCustomerParty = GetBuyerCustomerParty(source); destination.Delivery = GetDelivery(source, destination); destination.FreightForwarderParty = GetFreightForwarderParty(source); /** * TODO: populate any additional values on the order that you've added. * Cast to your order type if necessary. */ foreach (ActiveCommerce.Orders.Legacy.OrderLine cartLine in source.OrderLines) { var orderLine = GetOrderLine(cartLine, source.Currency.Code, string.Join(", ", source.Discounts)); orderLine.Order = destination; /** * TODO: populate any additional values on the order line that you've added. * Cast to your order line type if necessary. */ destination.OrderLines.Add(orderLine); foreach (var allowance in orderLine.AllowanceCharge) { destination.AllowanceCharge.Add(allowance); } } return(destination); }
public void ValidateCancelOrderCommand_IfOrderIdAndTraderIdIsValidAndOrderStatusIsCancelled_InvalidOperationException() { Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); order.OrderState = OrderState.Cancelled; OrderReadModel model = ReadModelAdapter.GetOrderReadModel(order); _persistanceRepository.SaveOrUpdate(model); CancelOrderCommand command = new CancelOrderCommand(order.OrderId, order.TraderId); ICancelOrderCommandValidation validation = new CancelOrderCommandValidation(_orderRepository); validation.ValidateCancelOrderCommand(command); }
public void CreateAndLogOrder_GetAllTheOrdersBackFromTheEventStore_CheckIfOrderIsRetreivedProperly() { Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10, new StubbedOrderIdGenerator()); InputPayload payload = InputPayload.CreatePayload(order); InputDisruptorPublisher.Publish(payload); _manualResetEvent.WaitOne(5000); //retrieve order Order savedOrder = _eventStore.GetEvent(order.OrderId.Id.ToString()) as Order; Assert.NotNull(savedOrder); Assert.AreEqual(savedOrder, order); }