public void SecondTotalFillBeforeFirstFillMarketOrderAcceptedThrows()
{
const decimal totalQ = 20;
const decimal clipQ = 5;
const decimal delta = 1;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock <IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny <OrderRecord>())).Returns(true);
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
delta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
Assert.Throws <ApplicationException>(iceberg.OnTotalFill);
mockServer.Verify(s => s.CreateOrder(It.IsAny <OrderRecord>()),
Times.Exactly(2));
}
public void ThrowsIfActivatedWhenAlreadyActive()
{
var expected = DefaultFakeOrderRecord();
var mockServer = new Mock <IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny <OrderRecord>())).Returns(true);
var clipSize = expected.Quantity;
const decimal priceDelta = 0;
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipSize,
expected.Price,
priceDelta);
iceberg.Activate();
mockServer.Verify(s => s.CreateOrder(It.IsAny <OrderRecord>()),
Times.Once());
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
Assert.Throws <ApplicationException>(iceberg.Activate);
}
public void TotalFillWithDeltaAdjustsPriceAsWellAsRefilling(MarketSide side,
decimal delta,
decimal price,
decimal priceAfterFill)
{
const decimal totalQ = 20;
const decimal clipQ = 10;
var expected = DefaultFakeOrderRecord(quantity: totalQ, price: price, side: side);
var mockServer = new Mock <IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny <OrderRecord>())).Returns(true);
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
price,
delta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny <OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(clipQ, iceberg.CurrentQuantity, "Order not refilled to clip size");
Assert.AreEqual(totalQ - clipQ,
iceberg.RemainingQuantity,
"Remaining quantity should be total minus one clip");
Assert.AreEqual(priceAfterFill,
iceberg.CurrentPrice,
"Current price not as expected after fill with delta");
Assert.AreNotEqual(iceberg.InitialPrice,
iceberg.CurrentPrice,
"Current price should not equal initial price after fill with delta");
}
public void TwoRefillsWithDeltaAdjustsPriceTwiceAndReducesQtyTwice()
{
const decimal totalQ = 20;
const decimal clipQ = 5;
const decimal delta = 1;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock <IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny <OrderRecord>())).Returns(true);
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
delta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny <OrderRecord>()),
Times.Exactly(3));
Assert.AreEqual(expected.Price - (2 * delta),
iceberg.CurrentPrice,
"Current price not as expected after two fills with delta");
Assert.AreEqual(totalQ - (2 * clipQ),
iceberg.RemainingQuantity,
"Remaining quantity not as expected after two fills");
Assert.AreEqual(clipQ,
iceberg.CurrentQuantity,
"Current quantity not equal to clip size after two fills");
}
public void OrderNotRefilledAfterQuantityExhausted()
{
const decimal totalQ = 15;
const decimal clipQ = 10;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock <IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny <OrderRecord>())).Returns(true);
const decimal priceDelta = 0;
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
priceDelta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
mockServer.Verify(s => s.CreateOrder(It.IsAny <OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(IcebergOrder.ActivationState.Suspended,
iceberg.State,
"Order should not be active after being exhausted");
Assert.AreEqual(0, iceberg.CurrentQuantity, "Order should have no quantity left");
Assert.AreEqual(0,
iceberg.RemainingQuantity,
"Order should have no quantity left");
}
public void TotalFillWithNoDeltaReplenishesWithClipSizePriceStaysSame()
{
const decimal totalQ = 20;
const decimal clipQ = 10;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock <IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny <OrderRecord>())).Returns(true);
const decimal priceDelta = 0;
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
priceDelta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny <OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(clipQ, iceberg.CurrentQuantity, "Order not refilled to clip size");
Assert.AreEqual(totalQ - clipQ,
iceberg.RemainingQuantity,
"Remaining quantity should be total minus one clip");
Assert.AreEqual(expected.Price, iceberg.CurrentPrice, "Current price not as expected");
Assert.AreEqual(iceberg.InitialPrice,
iceberg.CurrentPrice,
"Current price should equal initial price");
}
public void PartialFillThenTotalFillOnlyRemovesAClipSizeOfQuantity()
{
const decimal totalQ = 25;
const decimal clipQ = 10;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock <IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny <OrderRecord>())).Returns(true);
const decimal priceDelta = 0;
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
priceDelta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnPartialFill(5);
iceberg.OnTotalFill();
mockServer.Verify(s => s.CreateOrder(It.IsAny <OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(clipQ,
iceberg.CurrentQuantity,
"Order not refilled to correct clip size");
Assert.AreEqual(totalQ - clipQ,
iceberg.RemainingQuantity,
"Remaining quantity should be total minus one clip");
}
public void RefillWithDeltaHasZeroPriceFloor()
{
const decimal totalQ = 20;
const decimal clipQ = 10;
const decimal price = 0.1m;
const decimal delta = 0.2m;
var expected = DefaultFakeOrderRecord(quantity: totalQ, price: price);
var mockServer = new Mock <IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny <OrderRecord>())).Returns(true);
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
price,
delta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny <OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(0,
iceberg.CurrentPrice,
"Current price not oberying zero floor after fill with delta");
}
public void TwoRefillsWithDeltaAdjustsPriceTwiceAndReducesQtyTwice()
{
const decimal totalQ = 20;
const decimal clipQ = 5;
const decimal delta = 1;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock<IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny<OrderRecord>())).Returns(true);
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
delta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny<OrderRecord>()),
Times.Exactly(3));
Assert.AreEqual(expected.Price - (2*delta),
iceberg.CurrentPrice,
"Current price not as expected after two fills with delta");
Assert.AreEqual(totalQ - (2*clipQ),
iceberg.RemainingQuantity,
"Remaining quantity not as expected after two fills");
Assert.AreEqual(clipQ,
iceberg.CurrentQuantity,
"Current quantity not equal to clip size after two fills");
}
public void OrderNotRefilledAfterQuantityExhausted()
{
const decimal totalQ = 15;
const decimal clipQ = 10;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock<IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny<OrderRecord>())).Returns(true);
const decimal priceDelta = 0;
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
priceDelta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
mockServer.Verify(s => s.CreateOrder(It.IsAny<OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(IcebergOrder.ActivationState.Suspended,
iceberg.State,
"Order should not be active after being exhausted");
Assert.AreEqual(0, iceberg.CurrentQuantity, "Order should have no quantity left");
Assert.AreEqual(0,
iceberg.RemainingQuantity,
"Order should have no quantity left");
}
public void TotalFillWithNoDeltaReplenishesWithClipSizePriceStaysSame()
{
const decimal totalQ = 20;
const decimal clipQ = 10;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock<IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny<OrderRecord>())).Returns(true);
const decimal priceDelta = 0;
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
priceDelta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny<OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(clipQ, iceberg.CurrentQuantity, "Order not refilled to clip size");
Assert.AreEqual(totalQ - clipQ,
iceberg.RemainingQuantity,
"Remaining quantity should be total minus one clip");
Assert.AreEqual(expected.Price, iceberg.CurrentPrice, "Current price not as expected");
Assert.AreEqual(iceberg.InitialPrice,
iceberg.CurrentPrice,
"Current price should equal initial price");
}
public void TotalFillWithDeltaAdjustsPriceAsWellAsRefilling(MarketSide side,
decimal delta,
decimal price,
decimal priceAfterFill)
{
const decimal totalQ = 20;
const decimal clipQ = 10;
var expected = DefaultFakeOrderRecord(quantity: totalQ, price: price, side: side);
var mockServer = new Mock<IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny<OrderRecord>())).Returns(true);
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
price,
delta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny<OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(clipQ, iceberg.CurrentQuantity, "Order not refilled to clip size");
Assert.AreEqual(totalQ - clipQ,
iceberg.RemainingQuantity,
"Remaining quantity should be total minus one clip");
Assert.AreEqual(priceAfterFill,
iceberg.CurrentPrice,
"Current price not as expected after fill with delta");
Assert.AreNotEqual(iceberg.InitialPrice,
iceberg.CurrentPrice,
"Current price should not equal initial price after fill with delta");
}
public void ThrowsIfActivatedWhenAlreadyActive()
{
var expected = DefaultFakeOrderRecord();
var mockServer = new Mock<IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny<OrderRecord>())).Returns(true);
var clipSize = expected.Quantity;
const decimal priceDelta = 0;
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipSize,
expected.Price,
priceDelta);
iceberg.Activate();
mockServer.Verify(s => s.CreateOrder(It.IsAny<OrderRecord>()),
Times.Once());
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
Assert.Throws<ApplicationException>(iceberg.Activate);
}
public void SecondTotalFillBeforeFirstFillMarketOrderAcceptedThrows()
{
const decimal totalQ = 20;
const decimal clipQ = 5;
const decimal delta = 1;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock<IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny<OrderRecord>())).Returns(true);
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
delta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
Assert.Throws<ApplicationException>(iceberg.OnTotalFill);
mockServer.Verify(s => s.CreateOrder(It.IsAny<OrderRecord>()),
Times.Exactly(2));
}
public void RefillWithLessRemainingQtyThanClipSizeRefillsToRemaining()
{
const decimal totalQ = 15;
const decimal clipQ = 10;
const decimal remainingQ = totalQ - clipQ;
var expected = DefaultFakeOrderRecord(quantity: totalQ);
var mockServer = new Mock<IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny<OrderRecord>())).Returns(true);
const decimal priceDelta = 0;
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
expected.Price,
priceDelta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny<OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(remainingQ, iceberg.CurrentQuantity, "Order not refilled to correct");
Assert.AreEqual(remainingQ,
iceberg.RemainingQuantity,
"Remaining quantity should be total minus one clip");
}
public void RefillWithDeltaHasZeroPriceFloor()
{
const decimal totalQ = 20;
const decimal clipQ = 10;
const decimal price = 0.1m;
const decimal delta = 0.2m;
var expected = DefaultFakeOrderRecord(quantity: totalQ, price: price);
var mockServer = new Mock<IServerFacade>();
mockServer.Setup(s => s.CreateOrder(It.IsAny<OrderRecord>())).Returns(true);
var iceberg = new IcebergOrder(mockServer.Object,
expected.Symbol,
expected.ClOrdID,
expected.Side,
expected.Quantity,
clipQ,
price,
delta);
iceberg.Activate();
var idGen = new SimpleOrderIDGenerator();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
iceberg.OnTotalFill();
iceberg.ActivatedMarketOrderAccepted(idGen.GetID());
mockServer.Verify(s => s.CreateOrder(It.IsAny<OrderRecord>()),
Times.Exactly(2));
Assert.AreEqual(0,
iceberg.CurrentPrice,
"Current price not oberying zero floor after fill with delta");
}
