public void AddsSubscription_NewUserUniverse()
{
FuncDataQueueHandler dataQueueHandler;
var feed = RunDataFeed(out dataQueueHandler, equities: new List <string> {
"SPY"
});
var forexFxcmUserUniverse = UserDefinedUniverse.CreateSymbol(SecurityType.Forex, Market.FXCM);
var emittedData = false;
var newDataCount = 0;
var securityChanges = 0;
ConsumeBridge(feed, TimeSpan.FromSeconds(5), true, ts =>
{
securityChanges += ts.SecurityChanges.Count;
if (!emittedData)
{
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.SPY));
if (ts.Data.Count > 0)
{
Assert.IsTrue(ts.Slice.Keys.Contains(Symbols.SPY));
}
Assert.AreEqual(1, dataQueueHandler.Subscriptions.Count);
_algorithm.AddSecurities(forex: new List <string> {
"EURUSD"
});
emittedData = true;
}
else
{
if (dataQueueHandler.Subscriptions.Count == 2) // there could be some slices with no data
{
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.SPY));
if (ts.Data.Count > 0)
{
Assert.IsTrue(ts.Slice.Keys.Contains(Symbols.SPY));
}
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.EURUSD) ||
dataQueueHandler.Subscriptions.Contains(forexFxcmUserUniverse));
// Might delay a couple of Slices to send over the data, so we will count them
// and assert a minimum amount
if (ts.Slice.Keys.Contains(Symbols.EURUSD))
{
newDataCount++;
}
}
else
{
Assert.Fail($"Subscriptions.Count: {dataQueueHandler.Subscriptions.Count}");
}
}
});
Console.WriteLine("newDataCount: " + newDataCount);
Assert.AreEqual(2, securityChanges);
Assert.GreaterOrEqual(newDataCount, 1000);
Assert.IsTrue(emittedData);
}
public void AddsSubscription_SameUserUniverse()
{
DataManager dataManager;
var algorithm = new AlgorithmStub(out dataManager, equities: new List <string> {
"SPY"
});
FuncDataQueueHandler dataQueueHandler;
var feed = RunDataFeed(algorithm, out dataQueueHandler, dataManager);
var emittedData = false;
var newDataCount = 0;
var securityChanges = 0;
ConsumeBridge(algorithm, feed, TimeSpan.FromSeconds(5), true, ts =>
{
securityChanges += ts.SecurityChanges.Count;
if (!emittedData)
{
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.SPY));
if (ts.Data.Count > 0)
{
Assert.IsTrue(ts.Slice.Keys.Contains(Symbols.SPY));
}
Assert.AreEqual(1, dataQueueHandler.Subscriptions.Count);
algorithm.AddSecurities(equities: new List <string> {
"AAPL"
});
emittedData = true;
}
else
{
if (dataQueueHandler.Subscriptions.Count == 2) // there could be some slices with no data
{
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.SPY));
if (ts.Data.Count > 0)
{
Assert.IsTrue(ts.Slice.Keys.Contains(Symbols.SPY));
}
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.AAPL));
// Might delay a couple of Slices to send over the data, so we will count them
// and assert a minimum amount
if (ts.Slice.Keys.Contains(Symbols.AAPL))
{
newDataCount++;
}
}
else
{
Assert.Fail($"Subscriptions.Count: {dataQueueHandler.Subscriptions.Count}");
}
}
});
Assert.GreaterOrEqual(newDataCount, 1000);
Assert.IsTrue(emittedData);
Assert.AreEqual(2, securityChanges + algorithm.SecurityChangesRecord.Count);
Assert.AreEqual(Symbols.AAPL, algorithm.SecurityChangesRecord.First().AddedSecurities.First().Symbol);
}
public void FastExitsDoNotThrowUnhandledExceptions()
{
var algorithm = new AlgorithmStub();
// job is used to send into DataQueueHandler
var job = new LiveNodePacket();
// result handler is used due to dependency in SubscriptionDataReader
var resultHandler = new BacktestingResultHandler();
var feed = new TestableLiveTradingDataFeed();
var marketHoursDatabase = MarketHoursDatabase.FromDataFolder();
var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder();
var securityService = new SecurityService(
algorithm.Portfolio.CashBook,
marketHoursDatabase,
symbolPropertiesDataBase,
algorithm);
algorithm.Securities.SetSecurityService(securityService);
var dataManager = new DataManager(feed,
new UniverseSelection(feed, algorithm, securityService),
algorithm.Settings,
algorithm.TimeKeeper,
marketHoursDatabase);
algorithm.SubscriptionManager.SetDataManager(dataManager);
algorithm.AddSecurities(Resolution.Tick, Enumerable.Range(0, 20).Select(x => x.ToString()).ToList());
var getNextTicksFunction = Enumerable.Range(0, 20).Select(x => new Tick {
Symbol = SymbolCache.GetSymbol(x.ToString())
}).ToList();
feed.DataQueueHandler = new FuncDataQueueHandler(handler => getNextTicksFunction);
var mapFileProvider = new LocalDiskMapFileProvider();
var fileProvider = new DefaultDataProvider();
feed.Initialize(algorithm, job, resultHandler, mapFileProvider, new LocalDiskFactorFileProvider(mapFileProvider), fileProvider, dataManager);
var unhandledExceptionWasThrown = false;
try
{
feed.Exit();
}
catch (Exception ex)
{
QuantConnect.Logging.Log.Error(ex.ToString());
unhandledExceptionWasThrown = true;
}
Thread.Sleep(500);
Assert.IsFalse(unhandledExceptionWasThrown);
}
public void FastExitsDoNotThrowUnhandledExceptions()
{
var algorithm = new AlgorithmStub();
// job is used to send into DataQueueHandler
var job = new LiveNodePacket();
// result handler is used due to dependency in SubscriptionDataReader
var resultHandler = new BacktestingResultHandler();
var feed = new TestableLiveTradingDataFeed();
var dataManager = new DataManager(feed, new UniverseSelection(feed, algorithm),
algorithm.Settings, algorithm.TimeKeeper);
algorithm.SubscriptionManager.SetDataManager(dataManager);
algorithm.AddSecurities(Resolution.Tick, Enumerable.Range(0, 20).Select(x => x.ToString()).ToList());
var getNextTicksFunction = Enumerable.Range(0, 20).Select(x => new Tick {
Symbol = SymbolCache.GetSymbol(x.ToString())
}).ToList();
feed.DataQueueHandler = new FuncDataQueueHandler(handler => getNextTicksFunction);
var mapFileProvider = new LocalDiskMapFileProvider();
var fileProvider = new DefaultDataProvider();
feed.Initialize(algorithm, job, resultHandler, mapFileProvider, new LocalDiskFactorFileProvider(mapFileProvider), fileProvider, dataManager);
var feedThreadStarted = new ManualResetEvent(false);
var unhandledExceptionWasThrown = false;
Task.Run(() =>
{
try
{
feedThreadStarted.Set();
feed.Run();
}
catch (Exception ex)
{
QuantConnect.Logging.Log.Error(ex.ToString());
unhandledExceptionWasThrown = true;
}
});
feedThreadStarted.WaitOne();
feed.Exit();
Thread.Sleep(1000);
Assert.IsFalse(unhandledExceptionWasThrown);
}
public void AddsSubscription_NewUserUniverse()
{
DataManager dataManager;
var algorithm = new AlgorithmStub(out dataManager, equities: new List <string> {
"SPY"
});
FuncDataQueueHandler dataQueueHandler;
var feed = RunDataFeed(algorithm, out dataQueueHandler, dataManager);
var emittedData = false;
var newDataCount = 0;
ConsumeBridge(algorithm, feed, TimeSpan.FromSeconds(5), false, ts =>
{
if (!emittedData)
{
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.SPY));
Assert.IsTrue(ts.Slice.Keys.Contains(Symbols.SPY));
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(_equityUsaUserUniverse));
Assert.AreEqual(2, dataQueueHandler.Subscriptions.Count);
algorithm.AddSecurities(forex: new List <string> {
"EURUSD"
});
emittedData = true;
}
else
{
if (dataQueueHandler.Subscriptions.Count == 3)
{
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.SPY));
Assert.IsTrue(ts.Slice.Keys.Contains(Symbols.SPY));
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(_equityUsaUserUniverse));
// first it will add the universe
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(_forexFxcmUserUniverse));
}
else if (dataQueueHandler.Subscriptions.Count == 4 &&
ts.Slice.HasData) // there could be some slices with no data
{
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.SPY));
Assert.IsTrue(ts.Slice.Keys.Contains(Symbols.SPY));
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(_equityUsaUserUniverse));
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(Symbols.EURUSD));
Assert.IsTrue(dataQueueHandler.Subscriptions.Contains(_forexFxcmUserUniverse));
// Might delay a couple of Slices to send over the data, so we will count them
// and assert a minimum amount
if (ts.Slice.Keys.Contains(Symbols.EURUSD))
{
newDataCount++;
}
}
else
{
Assert.Fail($"Subscriptions.Count: {dataQueueHandler.Subscriptions.Count}");
}
}
});
Console.WriteLine("newDataCount: " + newDataCount);
Assert.GreaterOrEqual(newDataCount, 1000);
Assert.IsTrue(emittedData);
}