public void ShouldNotCallDispatcherIfOrderDoesNotValidate()
{
var processor = new IncomingMessageProcessor(ordereRepositoryMock, outgoingQueueMock, dateServiceMock, orderDispatcherMock, serializer);
var invalidLimitOrder = new LimitOrderDto();
invalidLimitOrder.Reeset();
var messageBytes = serializer.Serialize(new ClientToServerMessageQueueItem
{
Message = new ClientToServerMessage
{
ClientId = 1,
LimitOrder = invalidLimitOrder,
MessageType = ClientToServerMessageTypeEnum.PlaceLimitOrder
},
});
var queueItem = new RingbufferByteArray();
queueItem.Set(messageBytes);
processor.OnNext(queueItem, 1, true);
orderDispatcherMock.AssertWasNotCalled(a => a.HandleAddLimitOrder(Arg <ILimitOrder> .Is.Anything));
outgoingQueueMock.AssertWasNotCalled(a => a.EnqueueAddedLimitOrder(Arg <ILimitOrder> .Is.Anything));
}
public void ShouldCallDispatcherWhenLimitOrderValidates()
{
var processor = new IncomingMessageProcessor(ordereRepositoryMock, outgoingQueueMock, dateServiceMock, orderDispatcherMock, serializer);
var limitOrder = new LimitOrderDto();
limitOrder.Reeset();
limitOrder.Symbol = "QQQ";
limitOrder.Price = 30;
limitOrder.Quantity = 10;
limitOrder.ClientId = 1;
limitOrder.Way = WayEnum.Sell;
var messageBytes = serializer.Serialize(new ClientToServerMessageQueueItem
{
Message =
new ClientToServerMessage
{
ClientId = 1,
LimitOrder = limitOrder,
MessageType = ClientToServerMessageTypeEnum.PlaceLimitOrder
}
});
var queueItem = new RingbufferByteArray();
queueItem.Set(messageBytes);
processor.OnNext(queueItem, 1, true);
orderDispatcherMock.AssertWasCalled(a => a.HandleAddLimitOrder(Arg <ILimitOrder> .Is.Equal(limitOrder)));
}
public void ClientShouldRaiseLimitOrderModifiedEvent()
{
var modifiedLimitOrders = new List <LimitOrderDto>();
client.LimitOrderChanged += (sender, order) => modifiedLimitOrders.Add(order);
var newLimitOrder = new LimitOrderDto
{
ClientId = 88,
Price = 10,
ExchangeOrderId = 123,
Quantity = 90,
Symbol = "TSLA",
Way = WayEnum.Buy
};
messagePublisher.Publish(88, new ServerToClientMessage
{
LimitOrder = newLimitOrder,
MessageType = ServerToClientMessageTypeEnum.LimitOrderChanged,
ReceiverClientId = 88
});
Assert.That(() => modifiedLimitOrders.Count, Is.EqualTo(1).After(500, 100));
}
void client_LimitOrderAccepted(object sender, LimitOrderDto e)
{
UiDispatcher.Dispatcher.Invoke(() =>
{
LimitOrders.Add(new LimitOrderViewModel(e, client));
});
}
public void ClientShouldRaiseLimitOrderAddedEvent()
{
var addedLimitOrders = new List <LimitOrderDto>();
client.LimitOrderAccepted += (sender, order) => addedLimitOrders.Add(order);
var newLimitOrder = new LimitOrderDto
{
ClientId = 88,
Price = 10,
ExchangeOrderId = 123,
Quantity = 90,
Symbol = "TSLA",
Way = WayEnum.Buy
};
messagePublisher.Publish(88, new ServerToClientMessage
{
LimitOrder = newLimitOrder,
MessageType = ServerToClientMessageTypeEnum.LimitOrderAccepted,
ReceiverClientId = 88
});
Assert.That(() => addedLimitOrders.Count, Is.EqualTo(1).After(500, 100));
Assert.AreEqual(newLimitOrder.ClientId, addedLimitOrders[0].ClientId);
Assert.AreEqual(newLimitOrder.Price, addedLimitOrders[0].Price);
Assert.AreEqual(newLimitOrder.ExchangeOrderId, addedLimitOrders[0].ExchangeOrderId);
Assert.AreEqual(newLimitOrder.Quantity, addedLimitOrders[0].Quantity);
Assert.AreEqual(newLimitOrder.Symbol, addedLimitOrders[0].Symbol);
Assert.AreEqual(newLimitOrder.Way, addedLimitOrders[0].Way);
}
public void ShouldNotCallDispatcherWhenLimitOrderIsInvalidOnCancelOrder()
{
var processor = new IncomingMessageProcessor(ordereRepositoryMock.Object, outgoingQueueMock.Object, dateServiceMock.Object, orderDispatcherMock.Object, serializer);
var limitOrder = new LimitOrderDto();
limitOrder.Reeset();
var messageBytes = serializer.Serialize(new ClientToServerMessageQueueItem
{
Message =
new ClientToServerMessage
{
ClientId = 1,
LimitOrder = limitOrder,
MessageType = ClientToServerMessageTypeEnum.CancelLimitOrder
}
});
var queueItem = new RingbufferByteArray();
queueItem.Set(messageBytes);
processor.OnEvent(queueItem, 1, true);
orderDispatcherMock.Verify(a => a.HandleAddLimitOrder(It.IsAny <ILimitOrder>()), Times.Never());
}
public EditLimitOrderViewModel(LimitOrderDto limitOrder, IClient client)
{
this.limitOrder = limitOrder;
this.client = client;
SetupCommandsAndBehaviour();
SetFields();
}
public ClientToServerMessage()
{
LimitOrder = new LimitOrderDto();
MarketOrder = new MarketOrderDto();
StopLimitOrder = new StopLimitOrderDto();
DuoLimitOrder = new DuoLimitOrderDto();
Reset();
}
void client_LimitOrderChanged(object sender, LimitOrderDto e)
{
if (e.ExchangeOrderId != limitOrder.ExchangeOrderId)
{
return;
}
SetFields(e);
}
private void SetFields(LimitOrderDto limitOrder)
{
Symbol = limitOrder.Symbol;
Quantity = limitOrder.Quantity;
Price = limitOrder.Price;
Way = limitOrder.Way;
OrderType = "Limit order";
OrderId = limitOrder.ExchangeOrderId;
}
public LimitOrderViewModel(LimitOrderDto limitOrder, IClient client)
{
this.limitOrder = limitOrder;
this.client = client;
SetFields(limitOrder);
this.client.LimitOrderChanged += client_LimitOrderChanged;
SetupCommandsAndBehaviour();
}
public ServerToClientMessage()
{
LimitOrder = new LimitOrderDto();
LimitOrderList = new List <LimitOrderDto>();
Execution = new ExecutionDto();
Level1 = new MarketBestBidAskDto();
StopLimitOrder = new StopLimitOrderDto();
StopLimitOrderList = new List <StopLimitOrderDto>();
Reset();
}
void client_LimitOrderDeleted(object sender, LimitOrderDto e)
{
UiDispatcher.Dispatcher.Invoke(() =>
{
var order = LimitOrders.FirstOrDefault(a => a.OrderId == e.ExchangeOrderId);
if (order == null)
{
return;
}
LimitOrders.Remove(order);
order.Dispose();
});
}
public void ShouldCallDispatcherWhenLimitOrderValidates()
{
var processor = new IncomingMessageProcessor(ordereRepositoryMock.Object, outgoingQueueMock.Object, dateServiceMock.Object, orderDispatcherMock.Object, serializer);
var limitOrder = new LimitOrderDto();
limitOrder.Reeset();
limitOrder.Symbol = "QQQ";
limitOrder.Price = 30;
limitOrder.Quantity = 10;
limitOrder.ClientId = 1;
limitOrder.Way = WayEnum.Sell;
var messageBytes = serializer.Serialize(new ClientToServerMessageQueueItem
{
Message =
new ClientToServerMessage
{
ClientId = 1,
LimitOrder = limitOrder,
MessageType = ClientToServerMessageTypeEnum.PlaceLimitOrder
}
});
var queueItem = new RingbufferByteArray();
queueItem.Set(messageBytes);
processor.OnEvent(queueItem, 1, true);
orderDispatcherMock.Verify(a => a.HandleAddLimitOrder(It.Is <ILimitOrder>(order =>
order.Symbol == limitOrder.Symbol &&
order.Price == limitOrder.Price &&
order.Quantity == limitOrder.Quantity &&
order.ClientId == limitOrder.ClientId &&
order.Way == limitOrder.Way
)), Times.Once);
}
public ILimitOrder NewLimitOrder(LimitOrderDto dtoLimitOrder)
{
return(NewLimitOrder(dtoLimitOrder.Symbol, dtoLimitOrder.ClientId, dtoLimitOrder.Price, dtoLimitOrder.Quantity, dtoLimitOrder.Way));
}
