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);
}
