public void PerformsLimitFillSell()
{
var model = new SecurityTransactionModel();
var order = new LimitOrder(Symbol, -100, 101.5m, DateTime.Now, type: SecurityType.Equity);
var config = new SubscriptionDataConfig(typeof(TradeBar), SecurityType.Equity, Symbol, Resolution.Minute, true, true, true, true, false, 0);
var security = new Security(config, 1);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 101m));
var fill = model.LimitFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(DateTime.Now, new TradeBar(DateTime.Now, Symbol, 102m, 103m, 101m, 102.3m, 100));
fill = model.LimitFill(security, order);
// this fills worst case scenario, so it's at the limit price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Max(order.LimitPrice, security.Low), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
public void PerformsLimitFillBuy()
{
var model = new SecurityTransactionModel();
var order = new LimitOrder(Symbol, 100, 101.5m, Noon, type: SecurityType.Equity);
var config = CreateTradeBarConfig(Symbol);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1);
security.SetMarketPrice(Noon, new IndicatorDataPoint(Symbol, Noon, 102m));
var fill = model.LimitFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(Noon, new TradeBar(Noon, Symbol, 102m, 103m, 101m, 102.3m, 100));
fill = model.LimitFill(security, order);
// this fills worst case scenario, so it's at the limit price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(order.LimitPrice, security.High), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
public void UpdatesAfterCorrectPeriodElapses()
{
const int periods = 3;
var periodSpan = Time.OneMinute;
var reference = new DateTime(2016, 04, 06, 12, 0, 0);
var referenceUtc = reference.ConvertToUtc(TimeZones.NewYork);
var timeKeeper = new TimeKeeper(referenceUtc);
var config = new SubscriptionDataConfig(typeof (TradeBar), Symbols.SPY, Resolution.Minute, TimeZones.NewYork, TimeZones.NewYork, true, false, false);
var security = new Security(SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork), config, new Cash("USD", 0, 0), SymbolProperties.GetDefault("USD"));
security.SetLocalTimeKeeper(timeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
var model = new RelativeStandardDeviationVolatilityModel(periodSpan, periods);
security.VolatilityModel = model;
var first = new IndicatorDataPoint(reference, 1);
security.SetMarketPrice(first);
Assert.AreEqual(0m, model.Volatility);
const decimal value = 0.471404520791032M; // std of 1,2 is ~0.707 over a mean of 1.5
var second = new IndicatorDataPoint(reference.AddMinutes(1), 2);
security.SetMarketPrice(second);
Assert.AreEqual(value, model.Volatility);
// update should not be applied since not enough time has passed
var third = new IndicatorDataPoint(reference.AddMinutes(1.01), 1000);
security.SetMarketPrice(third);
Assert.AreEqual(value, model.Volatility);
var fourth = new IndicatorDataPoint(reference.AddMinutes(2), 3m);
security.SetMarketPrice(fourth);
Assert.AreEqual(0.5m, model.Volatility);
}
public void PerformsLimitFillBuy()
{
var model = new ForexTransactionModel();
var order = new LimitOrder(Symbol, 100, 101.5m, DateTime.Now, type: SecurityType.Forex);
var config = CreateTradeBarDataConfig(SecurityType.Forex, Symbol);
var security = new Security(SecurityExchangeHours.AlwaysOpen, config, 1);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbol, DateTime.Now, 102m));
var fill = model.LimitFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(new TradeBar(DateTime.Now, Symbol, 102m, 103m, 101m, 102.3m, 100));
fill = model.LimitFill(security, order);
// this fills worst case scenario, so it's at the limit price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(order.LimitPrice, security.High), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
/// <summary>
/// Seed the security
/// </summary>
/// <param name="security"><see cref="Security"/> being seeded</param>
/// <returns>true if the security was seeded, false otherwise</returns>
public bool SeedSecurity(Security security)
{
try
{
// Do not seed canonical symbols
if (!security.Symbol.IsCanonical())
{
var gotData = false;
foreach (var seedData in _seedFunction(security))
{
gotData = true;
security.SetMarketPrice(seedData);
Log.Debug($"FuncSecuritySeeder.SeedSecurity(): Seeded security: {seedData.Symbol.Value}: {seedData.GetType()} {seedData.Value}");
}
if (!gotData)
{
Log.Trace($"FuncSecuritySeeder.SeedSecurity(): Unable to seed security: {security.Symbol.Value}");
return(false);
}
}
}
catch (Exception exception)
{
Log.Trace($"FuncSecuritySeeder.SeedSecurity(): Could not seed price for security {security.Symbol}: {exception}");
return(false);
}
return(true);
}
/// <summary>
/// Seed the security
/// </summary>
/// <param name="security"><see cref="Security"/> being seeded</param>
/// <returns>true if the security was seeded, false otherwise</returns>
public bool SeedSecurity(Security security)
{
try
{
// Do not seed canonical symbols
if (!security.Symbol.IsCanonical())
{
var seedData = _seedFunction(security);
if (seedData != null)
{
security.SetMarketPrice(seedData);
Log.Debug($"FuncSecuritySeeder.SeedSecurity(): Seeded security: {seedData.Symbol.Value}: {seedData.Value}");
}
else
{
Log.Trace($"FuncSecuritySeeder.SeedSecurity(): Unable to seed security: {security.Symbol.Value}");
return(false);
}
}
}
catch (Exception exception)
{
Log.Trace($"FuncSecuritySeeder.SeedSecurity(): Could not seed price for security {security.Symbol}: {exception}");
return(false);
}
return(true);
}
/// <summary>
/// Initializes the specified security by setting up the models
/// </summary>
/// <param name="security">The security to be initialized</param>
/// <param name="seedSecurity">True to seed the security, false otherwise</param>
public virtual void Initialize(Security security, bool seedSecurity)
{
// set leverage and models
security.SetLeverage(_brokerageModel.GetLeverage(security));
security.FillModel = _brokerageModel.GetFillModel(security);
security.FeeModel = _brokerageModel.GetFeeModel(security);
security.SlippageModel = _brokerageModel.GetSlippageModel(security);
security.SettlementModel = _brokerageModel.GetSettlementModel(security, _brokerageModel.AccountType);
if (seedSecurity)
{
// Do not seed canonical symbols
if (!security.Symbol.IsCanonical())
{
BaseData seedData = _securitySeeder.GetSeedData(security);
if (seedData != null)
{
security.SetMarketPrice(seedData);
Log.Trace("BrokerageModelSecurityInitializer.Initialize(): Seeded security: " + seedData.Symbol.Value + ": " + seedData.Value);
}
else
{
Log.Trace("BrokerageModelSecurityInitializer.Initialize(): Unable to seed security: " + security.Symbol.Value);
}
}
}
}
public void PerformsMarketFillSell()
{
var model = new SecurityTransactionModel();
var order = new MarketOrder(Symbols.SPY, -100, Noon);
var config = CreateTradeBarConfig(Symbols.SPY);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency));
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 101.123m));
var fill = model.MarketFill(security, order);
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(security.Price, fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
}
public void PerformsMarketFillBuy()
{
var model = new SecurityTransactionModel();
var order = new MarketOrder(Symbols.SPY, 100, Noon, type: SecurityType.Equity);
var config = CreateTradeBarConfig(Symbols.SPY);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 101.123m));
var fill = model.MarketFill(security, order);
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(security.Price, fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
}
public void PerformsLimitFillBuy()
{
var model = new SecurityTransactionModel();
var order = new LimitOrder(Symbols.SPY, 100, 101.5m, Noon);
var config = CreateTradeBarConfig(Symbols.SPY);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency));
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 102m));
var fill = model.LimitFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
security.SetMarketPrice(new TradeBar(Noon, Symbols.SPY, 102m, 103m, 101m, 102.3m, 100));
fill = model.LimitFill(security, order);
// this fills worst case scenario, so it's at the limit price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(order.LimitPrice, security.High), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
}
/// <summary>
/// Initializes the specified security by setting up the models
/// </summary>
/// <param name="security">The security to be initialized</param>
public virtual void Initialize(Security security)
{
// set leverage and models
security.SetLeverage(_brokerageModel.GetLeverage(security));
security.FillModel = _brokerageModel.GetFillModel(security);
security.FeeModel = _brokerageModel.GetFeeModel(security);
security.SlippageModel = _brokerageModel.GetSlippageModel(security);
security.SettlementModel = _brokerageModel.GetSettlementModel(security, _brokerageModel.AccountType);
BaseData seedData = _securitySeeder.GetSeedData(security);
if (seedData != null)
{
security.SetMarketPrice(seedData);
}
}
/// <summary>
/// Initializes the specified security by setting up the models
/// </summary>
/// <param name="security">The security to be initialized</param>
public virtual void Initialize(Security security)
{
// set leverage and models
security.SetLeverage(_brokerageModel.GetLeverage(security));
security.FillModel = _brokerageModel.GetFillModel(security);
security.FeeModel = _brokerageModel.GetFeeModel(security);
security.SlippageModel = _brokerageModel.GetSlippageModel(security);
security.SettlementModel = _brokerageModel.GetSettlementModel(security, _brokerageModel.AccountType);
BaseData seedData = _securitySeeder.GetSeedData(security);
if (seedData != null)
{
security.SetMarketPrice(seedData);
}
}
/// <summary>
/// Initializes the specified security by setting up the models
/// </summary>
/// <param name="security">The security to be initialized</param>
public virtual void Initialize(Security security)
{
// set leverage and models
security.SetLeverage(_brokerageModel.GetLeverage(security));
security.FillModel = _brokerageModel.GetFillModel(security);
security.FeeModel = _brokerageModel.GetFeeModel(security);
security.SlippageModel = _brokerageModel.GetSlippageModel(security);
security.SettlementModel = _brokerageModel.GetSettlementModel(security, _brokerageModel.AccountType);
// Do not seed Options and Futures
if (security.Symbol.SecurityType != SecurityType.Option && security.Symbol.SecurityType != SecurityType.Future)
{
BaseData seedData = _securitySeeder.GetSeedData(security);
if (seedData != null)
{
security.SetMarketPrice(seedData);
Log.Trace("BrokerageModelSecurityInitializer.Initialize(): Seeded security: " + seedData.Symbol.Value + ": " + seedData.Value);
}
else
{
Log.Trace("BrokerageModelSecurityInitializer.Initialize(): Unable to seed security: " + security.Symbol.Value);
}
}
}
public void PerformsMarketOnCloseUsingClosingPrice()
{
var reference = new DateTime(2015, 06, 05, 15, 0, 0); // before market close
var model = new SecurityTransactionModel();
var order = new MarketOnCloseOrder(Symbol, SecurityType.Equity, 100, reference);
var config = CreateTradeBarConfig(Symbol);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1)
{
Exchange = new EquityExchange(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours())
};
var time = reference;
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1m, 2m, 0.5m, 1.33m, 100));
var fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
// market closes after 60min, so this is just before market Close
time = reference.AddMinutes(59);
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1.33m, 2.75m, 1.15m, 1.45m, 100));
fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
// market closes
time = reference.AddMinutes(60);
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1.45m, 2.0m, 1.1m, 1.40m, 100));
while (security.Exchange.ExchangeOpen)
{
time += TimeSpan.FromTicks(1);
security.SetMarketPrice(time, null);
}
Console.WriteLine("Time: " + time);
fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(security.Close, fill.FillPrice);
}
public void PerformsStopMarketFillSell()
{
var model = new ForexTransactionModel();
var order = new StopMarketOrder(Symbol, -100, 101.5m, DateTime.Now, type: SecurityType.Forex);
var config = CreateTradeBarDataConfig(SecurityType.Forex, Symbol);
var security = new Security(SecurityExchangeHours.AlwaysOpen, config, 1);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbol, DateTime.Now, 102m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbol, DateTime.Now, 101m));
fill = model.StopMarketFill(security, order);
var slip = model.GetSlippageApproximation(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(security.Price - slip, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
public void PerformsMarketFillSell()
{
var model = new ForexTransactionModel();
var order = new MarketOrder(Symbol, -100, DateTime.Now, type: SecurityType.Forex);
var config = CreateTradeBarDataConfig(SecurityType.Forex, Symbol);
var security = new Security(SecurityExchangeHours.AlwaysOpen, config, 1);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbol, DateTime.Now, 101.123m));
var fill = model.MarketFill(security, order);
var slip = model.GetSlippageApproximation(security, order);
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(security.Price - slip, fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
private void Update(Security security, decimal close)
{
security.SetMarketPrice(new TradeBar
{
Time = DateTime.Now,
Symbol = security.Symbol,
Open = close,
High = close,
Low = close,
Close = close
});
}
private static DateTime InitializeTest(out BasicTemplateAlgorithm algorithm, out Security security, out PartialMarketFillModel model, out MarketOrder order, out OrderTicket ticket)
{
var referenceTimeNY = new DateTime(2015, 12, 21, 13, 0, 0);
var referenceTimeUtc = referenceTimeNY.ConvertToUtc(TimeZones.NewYork);
algorithm = new BasicTemplateAlgorithm();
algorithm.SetDateTime(referenceTimeUtc);
var transactionHandler = new BacktestingTransactionHandler();
transactionHandler.Initialize(algorithm, new BacktestingBrokerage(algorithm), new TestResultHandler(Console.WriteLine));
Task.Run(() => transactionHandler.Run());
algorithm.Transactions.SetOrderProcessor(transactionHandler);
var config = new SubscriptionDataConfig(typeof(TradeBar), Symbols.SPY, Resolution.Second, TimeZones.NewYork, TimeZones.NewYork, false, false, false);
security = new Security(SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork), config);
model = new PartialMarketFillModel(algorithm.Transactions, 2);
algorithm.Securities.Add(security);
algorithm.Securities[Symbols.SPY].FillModel = model;
security.SetMarketPrice(new Tick { Symbol = Symbols.SPY, Value = 100 });
algorithm.SetFinishedWarmingUp();
order = new MarketOrder(Symbols.SPY, 100, referenceTimeUtc) { Id = 1 };
var request = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, order.Quantity, 0, 0, algorithm.UtcTime, null);
ticket = algorithm.Transactions.ProcessRequest(request);
return referenceTimeUtc;
}
public void PerformsStopMarketFillBuy()
{
var model = new SecurityTransactionModel();
var order = new StopMarketOrder(Symbols.SPY, 100, 101.5m, Noon);
var config = CreateTradeBarConfig(Symbols.SPY);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 101m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 102.5m));
fill = model.StopMarketFill(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Max(security.Price, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
}
private Security InitializeTest(DateTime reference, out SecurityPortfolioManager portfolio)
{
var security = new Security(SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork), CreateTradeBarConfig(), new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency));
security.SetMarketPrice(new Tick { Value = 100 });
var timeKeeper = new TimeKeeper(reference);
var securityManager = new SecurityManager(timeKeeper);
securityManager.Add(security);
var transactionManager = new SecurityTransactionManager(securityManager);
portfolio = new SecurityPortfolioManager(securityManager, transactionManager);
portfolio.SetCash("USD", 100 * 1000m, 1m);
Assert.AreEqual(0, security.Holdings.Quantity);
Assert.AreEqual(100*1000m, portfolio.CashBook[CashBook.AccountCurrency].Amount);
return security;
}
public void PerformsStopMarketFillSell()
{
var model = new ForexTransactionModel();
var order = new StopMarketOrder(Symbol, -100, 101.5m, DateTime.Now, type: SecurityType.Forex);
var config = new SubscriptionDataConfig(typeof(TradeBar), SecurityType.Forex, Symbol, Resolution.Minute, true, true, true, true, false, 0);
var security = new Security(config, 1);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 102m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 101m));
fill = model.StopMarketFill(security, order);
var slip = model.GetSlippageApproximation(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(security.Price - slip, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
private static Security CreateSecurity(DateTime newLocalTime)
{
var security = new Security(CreateUsEquitySecurityExchangeHours(), CreateTradeBarConfig());
security.Exchange.SetLocalDateTimeFrontier(newLocalTime);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, newLocalTime, 100m));
return security;
}
public void PerformsMarketOnCloseUsingClosingPrice()
{
var reference = new DateTime(2015, 06, 05, 15, 0, 0); // before market close
var model = new SecurityTransactionModel();
var order = new MarketOnCloseOrder(Symbol, SecurityType.Equity, 100, reference, 1m);
var config = new SubscriptionDataConfig(typeof(TradeBar), SecurityType.Equity, Symbol, Resolution.Minute, true, true, true, true, false, 0);
var security = new Security(config, 1) { Exchange = new EquityExchange() };
var time = reference;
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1m, 2m, 0.5m, 1.33m, 100));
var fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
// market closes after 60min, so this is just before market Close
time = reference.AddMinutes(59);
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1.33m, 2.75m, 1.15m, 1.45m, 100));
fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
// market closes
time = reference.AddMinutes(60);
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1.45m, 2.0m, 1.1m, 1.40m, 100));
fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(security.Close, fill.FillPrice);
}
public void PerformsStopLimitFillSell()
{
var model = new ForexTransactionModel();
var order = new StopLimitOrder(Symbol, -100, 101.75m, 101.50m, DateTime.Now, type: SecurityType.Forex);
var config = CreateTradeBarDataConfig(SecurityType.Forex, Symbol);
var security = new Security(SecurityExchangeHours.AlwaysOpen, config, 1);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 102m));
var fill = model.StopLimitFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 101m));
fill = model.StopLimitFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 101.66m));
fill = model.StopLimitFill(security, order);
// this fills worst case scenario, so it's at the limit price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(order.LimitPrice, fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
private static Security CreateSecurity(DateTime newLocalTime)
{
var security = new Security(CreateUsEquitySecurityExchangeHours(), CreateTradeBarConfig(), new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency));
security.Exchange.SetLocalDateTimeFrontier(newLocalTime);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, newLocalTime, 100m));
return security;
}
public void PerformsStopLimitFillSell()
{
var model = new SecurityTransactionModel();
var order = new StopLimitOrder(Symbols.SPY, -100, 101.75m, 101.50m, Noon, type: SecurityType.Equity);
var config = CreateTradeBarConfig(Symbols.SPY);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1);
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 102m));
var fill = model.StopLimitFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 101m));
fill = model.StopLimitFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
security.SetMarketPrice(new IndicatorDataPoint(Symbols.SPY, Noon, 101.66m));
fill = model.StopLimitFill(security, order);
// this fills worst case scenario, so it's at the limit price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(order.LimitPrice, fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
}
public void TestCashFills()
{
// this test asserts the portfolio behaves according to the Test_Cash algo, see TestData\CashTestingStrategy.csv
// also "https://www.dropbox.com/s/oiliumoyqqj1ovl/2013-cash.csv?dl=1"
const string fillsFile = "TestData\\test_cash_fills.xml";
const string equityFile = "TestData\\test_cash_equity.xml";
var fills = XDocument.Load(fillsFile).Descendants("OrderEvent").Select(x => new OrderEvent(
x.Get<int>("OrderId"),
SymbolMap[x.Get<string>("Symbol")],
DateTime.MinValue,
x.Get<OrderStatus>("Status"),
x.Get<int>("FillQuantity") < 0 ? OrderDirection.Sell
: x.Get<int>("FillQuantity") > 0 ? OrderDirection.Buy
: OrderDirection.Hold,
x.Get<decimal>("FillPrice"),
x.Get<int>("FillQuantity"),
0m)
).ToList();
var equity = XDocument.Load(equityFile).Descendants("decimal")
.Select(x => decimal.Parse(x.Value, CultureInfo.InvariantCulture))
.ToList();
Assert.AreEqual(fills.Count + 1, equity.Count);
// we're going to process fills and very our equity after each fill
var subscriptions = new SubscriptionManager(TimeKeeper);
var securities = new SecurityManager(TimeKeeper);
var security = new Security(SecurityExchangeHours, subscriptions.Add(CASH, Resolution.Daily, TimeZones.NewYork, TimeZones.NewYork), new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency));
security.SetLeverage(10m);
securities.Add(CASH, security);
var transactions = new SecurityTransactionManager(securities);
var portfolio = new SecurityPortfolioManager(securities, transactions);
portfolio.SetCash(equity[0]);
for (int i = 0; i < fills.Count; i++)
{
// before processing the fill we must deduct the cost
var fill = fills[i];
var time = DateTime.Today.AddDays(i);
TimeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork));
// the value of 'CASH' increments for each fill, the original test algo did this monthly
// the time doesn't really matter though
security.SetMarketPrice(new IndicatorDataPoint(CASH, time, i + 1));
portfolio.ProcessFill(fill);
Assert.AreEqual(equity[i + 1], portfolio.TotalPortfolioValue, "Failed on " + i);
}
}
public void PerformsStopMarketFillSell()
{
var model = new SecurityTransactionModel();
var order = new StopMarketOrder(Symbol, -100, 101.5m, Noon, type: SecurityType.Equity);
var config = CreateTradeBarConfig(Symbol);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1);
security.SetMarketPrice(Noon, new IndicatorDataPoint(Symbol, Noon, 102m));
var fill = model.StopMarketFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
Assert.AreEqual(0, fill.FillPrice);
Assert.AreEqual(OrderStatus.None, fill.Status);
Assert.AreEqual(OrderStatus.None, order.Status);
security.SetMarketPrice(Noon, new IndicatorDataPoint(Symbol, Noon, 101m));
fill = model.StopMarketFill(security, order);
// this fills worst case scenario, so it's min of asset/stop price
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(Math.Min(security.Price, order.StopPrice), fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
public void PerformsMarketOnOpenUsingOpenPrice()
{
var reference = new DateTime(2015, 06, 05, 9, 0, 0); // before market open
var model = new SecurityTransactionModel();
var order = new MarketOnOpenOrder(Symbol, SecurityType.Equity, 100, reference);
var config = CreateTradeBarConfig(Symbol);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, 1)
{
Exchange = new EquityExchange(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours())
};
var time = reference;
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1m, 2m, 0.5m, 1.33m, 100));
var fill = model.MarketOnOpenFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
// market opens after 30min, so this is just before market open
time = reference.AddMinutes(29);
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1.33m, 2.75m, 1.15m, 1.45m, 100));
fill = model.MarketOnOpenFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
// market opens after 30min
time = reference.AddMinutes(30);
security.SetMarketPrice(time, new TradeBar(time, Symbol, 1.45m, 2.0m, 1.1m, 1.40m, 100));
fill = model.MarketOnOpenFill(security, order);
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(security.Open, fill.FillPrice);
}
public void PerformsMarketFillBuy()
{
var model = new SecurityTransactionModel();
var order = new MarketOrder(Symbol, 100, DateTime.Now, type: SecurityType.Equity);
var config = new SubscriptionDataConfig(typeof(TradeBar), SecurityType.Equity, Symbol, Resolution.Minute, true, true, true, true, false, 0);
var security = new Security(config, 1);
security.SetMarketPrice(DateTime.Now, new IndicatorDataPoint(Symbol, DateTime.Now, 101.123m));
var fill = model.MarketFill(security, order);
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(security.Price, fill.FillPrice);
Assert.AreEqual(OrderStatus.Filled, fill.Status);
Assert.AreEqual(OrderStatus.Filled, order.Status);
}
public void PerformsMarketOnCloseUsingClosingPrice()
{
var reference = new DateTime(2015, 06, 05, 15, 0, 0); // before market close
var model = new SecurityTransactionModel();
var order = new MarketOnCloseOrder(Symbols.SPY, 100, reference);
var config = CreateTradeBarConfig(Symbols.SPY);
var security = new Security(SecurityExchangeHoursTests.CreateUsEquitySecurityExchangeHours(), config, new Cash(CashBook.AccountCurrency, 0, 1m), SymbolProperties.GetDefault(CashBook.AccountCurrency));
security.SetLocalTimeKeeper(TimeKeeper.GetLocalTimeKeeper(TimeZones.NewYork));
var time = reference;
TimeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork));
security.SetMarketPrice(new TradeBar(time, Symbols.SPY, 1m, 2m, 0.5m, 1.33m, 100));
var fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
// market closes after 60min, so this is just before market Close
time = reference.AddMinutes(59);
TimeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork));
security.SetMarketPrice(new TradeBar(time, Symbols.SPY, 1.33m, 2.75m, 1.15m, 1.45m, 100));
fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(0, fill.FillQuantity);
// market closes
time = reference.AddMinutes(60);
TimeKeeper.SetUtcDateTime(time.ConvertToUtc(TimeZones.NewYork));
security.SetMarketPrice(new TradeBar(time, Symbols.SPY, 1.45m, 2.0m, 1.1m, 1.40m, 100));
fill = model.MarketOnCloseFill(security, order);
Assert.AreEqual(order.Quantity, fill.FillQuantity);
Assert.AreEqual(security.Close, fill.FillPrice);
}
public void UpdatingSecurityPriceTests()
{
var security = new Security(SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork), CreateTradeBarConfig());
// Update securuty price with a TradeBar
security.SetMarketPrice(new TradeBar(DateTime.Now, Symbols.SPY, 101m, 103m, 100m, 102m, 100000));
Assert.AreEqual(101m, security.Open);
Assert.AreEqual(103m, security.High);
Assert.AreEqual(100m, security.Low);
Assert.AreEqual(102m, security.Close);
Assert.AreEqual(100000, security.Volume);
// Update security price with a tick with higher prices
security.SetMarketPrice(new Tick(DateTime.Now, Symbols.SPY, 104m, 104m, 104m));
Assert.AreEqual(104m, security.High);
Assert.AreEqual(104m, security.Close);
// Update security price with a tick with lower prices
security.SetMarketPrice(new Tick(DateTime.Now, Symbols.SPY, 99m, 99m, 99m));
Assert.AreEqual(99m, security.Low);
Assert.AreEqual(99m, security.Close);
}