def testLoadTicks_tick(self): time1 = datetime.now() time2 = datetime.now() tickTime1Dam1 = Tick(time1, 100.0, 100.0, 100.0, 100.0, 100.0) tickTime2Dam1 = Tick(time2, 100.0, 100.0, 100.0, 100.0, 100.0) tickTime1Dam2 = Tick(time1, 100.0, 100.0, 100.0, 100.0, 100.0) tickTime2Dam2 = Tick(time2, 100.0, 100.0, 100.0, 100.0, 100.0) dam1 = self.mock.CreateMock(BaseDAM) dam1.readTicks(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn([tickTime1Dam1, tickTime2Dam1]) dam2 = self.mock.CreateMock(BaseDAM) dam2.readTicks(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn([tickTime1Dam2, tickTime2Dam2]) tf = TickFeeder() tf._TickFeeder__source = {'s1': dam1, 's2': dam2} tf.inputType = TICK appGlobal[TRADE_TYPE] = TICK self.mock.ReplayAll() timeTicks = tf.loadTicks() self.mock.VerifyAll() self.assertEquals({time1: {'s1': tickTime1Dam1, 's2': tickTime1Dam2}, time2: {'s1': tickTime2Dam1, 's2': tickTime2Dam2}}, timeTicks)
def testAddSource(self): dam = self.mock.CreateMockAnything('dam') dam.symbol = 's1' tf = TickFeeder() tf.addSource(dam) self.assertEquals({'s1': dam}, tf._TickFeeder__source)
def testPubTicks(self): sub = self.mock.CreateMock(TickSubsriber) sub.tickUpdate(['ticks']) tf = TickFeeder() self.mock.ReplayAll() thread = tf.pubTicks(['ticks'], sub) self.mock.VerifyAll()
def testInputType(self): tf = TickFeeder() #invalid type - test assignment self.assertRaises(UfException, tf._TickFeeder__setInputType, 'adafsdf') #valid type - test assignment tf.inputType = TickFeeder.TICK_TYPE self.assertEquals(TickFeeder.TICK_TYPE, tf.inputType)
def testRegister_Exception(self): sub = self.mock.CreateMock(TickSubsriber) sub.subRules().AndReturn(['s3', 'mockRule']) tf = TickFeeder() tf._TickFeeder__source = {'s1': 'dam1', 's11': 'dam2', 's2': 'dam3'} self.mock.ReplayAll() self.assertRaises(UfException, tf.register, sub) self.mock.VerifyAll()
def __init__(self, config, mCalculator, symbol): self.__accountManager = AccountManager() self.__tickFeeder = TickFeeder() self.__tradingCenter = TradingCenter() self.__tradingEngine = TradingEngine() self.__indexHelper = IndexHelper() self.__history = History() self.__saver = None self.__symbol = symbol self.__config = config self.__mCalculator = mCalculator
def testValidate_Normal(self): sub = self.mock.CreateMock(TickSubsriber) sub.subRules().AndReturn(['s1', 'mockRule']) tf = TickFeeder() tf._TickFeeder__source = {'s1': 'dam1', 's11': 'dam2', 's2': 'dam3'} self.mock.ReplayAll() symbols, sub = tf.validate(sub) self.mock.VerifyAll() print(symbols)
def testGetSymbolsByRe(self): tf = TickFeeder() tf._TickFeeder__source = {'s1': 'dam1', 's11': 'dam2', 's2': 'dam3'} symbols = tf.getSymbolsByRe('s3') print(symbols) self.assertEquals([], symbols) symbols = tf.getSymbolsByRe('s1') print(symbols) self.assertEquals(['s1'], symbols) symbols = tf.getSymbolsByRe('.*') print(symbols) self.assertEquals(set(symbols), set(['s1', 's11', 's2']))
def testRegister_Normal(self): sub = self.mock.CreateMock(TickSubsriber) sub.subRules().AndReturn(['s1', 'mockRule']) tf = TickFeeder() tf._TickFeeder__source = {'s1': 'dam1', 's11': 'dam2', 's2': 'dam3'} self.mock.ReplayAll() tf.register(sub) self.mock.VerifyAll() subs = tf.getSubs() print(subs) self.assertEquals({sub: {'symbols': ['s1'], 'fail': 0} }, subs)
def __init__(self, config, metricManager, accounts, symbols, startTickDate, endTradeDate, cash): self.__accountManager = AccountManager() self.__accountId = None self.__startTickDate = startTickDate self.__endTradeDate = endTradeDate self.__tickFeeder = TickFeeder(start=startTickDate, end=endTradeDate) self.__tradingCenter = TradingCenter() self.__tradingEngine = TradingEngine() self.__indexHelper = IndexHelper() self.__accounts = accounts self.__history = History() self.__saver = None self.__symbols = symbols self.__config = config self.__metricManager = metricManager self.__cash = cash
def testIndexTicks_tick(self): tickTime1Dam1 = Tick('time1', 'open1', 'high1', 'low1', 'close1', 'volume1') tickTime2Dam1 = Tick('time2', 'open2', 'high2', 'low2', 'close2', 'volume2') tickTime1Dam2 = Tick('time1', 'open11', 'high11', 'low11', 'close11', 'volume11') tickTime2Dam2 = Tick('time2', 'open22', 'high22', 'low22', 'close22', 'volume22') dam1 = self.mock.CreateMock(BaseDAM) dam1.readTicks(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn( [tickTime1Dam1, tickTime2Dam1]) dam2 = self.mock.CreateMock(BaseDAM) dam2.readTicks(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn( [tickTime1Dam2, tickTime2Dam2]) tf = TickFeeder() tf.inputType = TickFeeder.TICK_TYPE tf._TickFeeder__source = {'s1': dam1, 's2': dam2} self.mock.ReplayAll() timeTicks = tf.indexTicks() self.mock.VerifyAll() print(timeTicks) self.assertEquals( { 'time1': { 's1': tickTime1Dam1, 's2': tickTime1Dam2 }, 'time2': { 's1': tickTime2Dam1, 's2': tickTime2Dam2 } }, timeTicks)
def __init__(self, config, mCalculator, accounts, symbols, startTickDate, endTradeDate, cash): self.__accountManager = AccountManager() self.__accountId = None self.__tickFeeder = TickFeeder(start=startTickDate, end=endTradeDate) self.__tradingCenter = TradingCenter() self.__tradingEngine = TradingEngine() self.__indexHelper = IndexHelper() self.__accounts = accounts self.__history = History() self.__saver = None self.__symbols = symbols self.__config = config self.__mCalculator = mCalculator self.__cash = cash
def testLoadTicks_quote(self): time1 = datetime.now() time2 = datetime.now() quoteTime1Dam1 = Quote(time1, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0) quoteTime2Dam1 = Quote(time2, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0) quoteTime1Dam2 = Quote(time1, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0) quoteTime2Dam2 = Quote(time2, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0) dam1 = self.mock.CreateMock(BaseDAM) dam1.readQuotes(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn( [quoteTime1Dam1, quoteTime2Dam1]) dam2 = self.mock.CreateMock(BaseDAM) dam2.readQuotes(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn( [quoteTime1Dam2, quoteTime2Dam2]) tf = TickFeeder() tf.inputType = QUOTE appGlobal[TRADE_TYPE] = QUOTE tf._TickFeeder__source = {'s1': dam1, 's2': dam2} self.mock.ReplayAll() timeTicks = tf.loadTicks() self.mock.VerifyAll() self.assertEquals( { time1: { 's1': quoteTime1Dam1, 's2': quoteTime1Dam2 }, time2: { 's1': quoteTime2Dam1, 's2': quoteTime2Dam2 } }, timeTicks)
def testIndexTicks_tick(self): tickTime1Dam1 = Tick('time1', 'open1', 'high1', 'low1', 'close1', 'volume1') tickTime2Dam1 = Tick('time2', 'open2', 'high2', 'low2', 'close2', 'volume2') tickTime1Dam2 = Tick('time1', 'open11', 'high11', 'low11', 'close11', 'volume11') tickTime2Dam2 = Tick('time2', 'open22', 'high22', 'low22', 'close22', 'volume22') dam1 = self.mock.CreateMock(BaseDAM) dam1.readTicks(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn([tickTime1Dam1, tickTime2Dam1]) dam2 = self.mock.CreateMock(BaseDAM) dam2.readTicks(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn([tickTime1Dam2, tickTime2Dam2]) tf = TickFeeder() tf.inputType = TickFeeder.TICK_TYPE tf._TickFeeder__source = {'s1': dam1, 's2': dam2} self.mock.ReplayAll() timeTicks = tf.indexTicks() self.mock.VerifyAll() print(timeTicks) self.assertEquals({'time1': {'s1': tickTime1Dam1, 's2': tickTime1Dam2}, 'time2': {'s1': tickTime2Dam1, 's2': tickTime2Dam2}}, timeTicks)
def testRegister_Normal(self): sub = self.mock.CreateMock(TickSubsriber) sub.subRules().AndReturn(['s1', 'mockRule']) tf = TickFeeder() tf._TickFeeder__source = {'s1': 'dam1', 's11': 'dam2', 's2': 'dam3'} self.mock.ReplayAll() tf.register(sub) self.mock.VerifyAll() subs = tf.getSubs() print(subs) self.assertEquals({sub: {'symbols': ['s1'], 'fail': 0}}, subs)
class TestRunner(object): ''' back testing ''' def __init__(self, config, mCalculator, accounts, symbols, startTickDate, endTradeDate, cash): self.__accountManager = AccountManager() self.__accountId = None self.__tickFeeder = TickFeeder(start=startTickDate, end=endTradeDate) self.__tradingCenter = TradingCenter() self.__tradingEngine = TradingEngine() self.__indexHelper = IndexHelper() self.__accounts = accounts self.__history = History() self.__saver = None self.__symbols = symbols self.__config = config self.__mCalculator = mCalculator self.__cash = cash def _setup(self): ''' setup ''' self._setupTradingCenter() self._setupTickFeeder() self._setupSaver() #wire things together self._setupStrategy() self.__tickFeeder.tradingCenter = self.__tradingCenter self.__tradingEngine.tickProxy = self.__tickFeeder self.__tradingEngine.orderProxy = self.__tradingCenter self.__tradingCenter.accountManager = self.__accountManager self.__tradingEngine.saver = self.__saver self.__tickFeeder.saver = self.__saver self.__accountManager.saver = self.__saver def _setupTradingCenter(self): self.__tradingCenter.start = 0 self.__tradingCenter.end = None def _setupTickFeeder(self): ''' setup tickFeeder''' self.__tickFeeder.indexHelper = self.__indexHelper self.__tickFeeder.setSymbols(self.__symbols) self.__tickFeeder.setDam(self._createDam("")) # no need to set symbol because it's batch operation iSymbol = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_INDEX) self.__tickFeeder.setIndexSymbol(iSymbol) def _createDam(self, symbol): ''' setup Dam''' damName = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_INPUT_DAM) inputDb = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_INPUT_DB) dam = DAMFactory.createDAM(damName, {'db': inputDb}) dam.setSymbol(symbol) return dam def _setupSaver(self): ''' setup Saver ''' saverName = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_SAVER) outputDb = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_OUTPUT_DB) if saverName: self.__saver = StateSaverFactory.createStateSaver(saverName, {'db': outputDb}, getBackTestTableName(self.__symbols, self.__config.getOption( CONF_ULTRAFINANCE_SECTION, CONF_STRATEGY_NAME))) def _setupStrategy(self): ''' setup tradingEngine''' strategy = StrategyFactory.createStrategy( self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_STRATEGY_NAME), self.__config.getSection(CONF_ULTRAFINANCE_SECTION)) strategy.setSymbols(self.__symbols) strategy.history = self.__history #associate account self.__accountId = self.__accountManager.createAccount(self.__cash) strategy.accountId = self.__accountId strategy.accountManager = self.__accountManager #register on trading engine strategy.tradingEngine = self.__tradingEngine self.__tradingEngine.register(strategy) def _execute(self): ''' run backtest ''' LOG.info("Running backtest for %s" % self.__symbols) #start trading engine thread = Thread(target=self.__tradingEngine.runListener, args=()) thread.setDaemon(False) thread.start() #start tickFeeder self.__tickFeeder.execute() self.__tickFeeder.complete() timePositions = self.__accountManager.getAccountPostions(self.__accountId) startTradeDate = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_START_TRADE_DATE) if startTradeDate: startTradeDate = int(startTradeDate) timePositions = [tp for tp in timePositions if tp[0] >= startTradeDate] self.__mCalculator.calculate(self.__symbols, timePositions, self.__tickFeeder.iTimePositionDict) self.__tradingEngine.stop() thread.join(timeout=240) LOG.info("Stop backtest for %s" % self.__symbols) def _printResult(self): ''' print result''' account = self.__accountManager.getAccount(self.__accountId) self.__accounts.append(account) LOG.info("account %s" % account) LOG.debug([str(order) for order in account.orderHistory]) LOG.debug("account position %s" % self.__accountManager.getAccountPostions(self.__accountId)) def runTest(self): ''' run one test ''' self._setup() self._execute() self._printResult()
class TestRunner(object): ''' back testing ''' CASH = 100000 # 0.1 million to start def __init__(self, config, mCalculator, symbol): self.__accountManager = AccountManager() self.__tickFeeder = TickFeeder() self.__tradingCenter = TradingCenter() self.__tradingEngine = TradingEngine() self.__indexHelper = IndexHelper() self.__history = History() self.__saver = None self.__symbol = symbol self.__config = config self.__mCalculator = mCalculator def _setup(self): ''' setup ''' self._setupTradingCenter() self._setupTickFeeder() self._setupSaver() #wire things together self._setupStrategy() self.__tickFeeder.tradingCenter = self.__tradingCenter self.__tradingEngine.tickProxy = self.__tickFeeder self.__tradingEngine.orderProxy = self.__tradingCenter self.__tradingCenter.accountManager = self.__accountManager self.__tradingEngine.saver = self.__saver self.__accountManager.saver = self.__saver def _setupTradingCenter(self): self.__tradingCenter.start = 0 self.__tradingCenter.end = None def _setupTickFeeder(self): ''' setup tickFeeder''' self.__tickFeeder.indexHelper = self.__indexHelper self.__tickFeeder.hisotry = self.__history #set source dam sDam = self._createDam(self.__symbol) self.__tickFeeder.addSource(sDam) #set index dam iSymbol = self.__config.getOption(CONF_APP_MAIN, CONF_INDEX) iDam = self._createDam(iSymbol) self.__tickFeeder.setIndexDam(iDam) def _createDam(self, symbol): ''' setup Dam''' damName = self.__config.getOption(CONF_INPUT_SECTION, CONF_DAM) setting = self.__config.getSection(CONF_INPUT_SECTION) dam = DAMFactory.createDAM(damName, setting) dam.setSymbol(symbol) return dam def _setupSaver(self): ''' setup Saver ''' saverName = self.__config.getOption(CONF_OUTPUT_SECTION, CONF_SAVER) setting = self.__config.getSection(CONF_OUTPUT_SECTION) if saverName: self.__saver = StateSaverFactory.createStateSaver( saverName, setting, "%s_%s" % (self.__symbol, self.__config.getOption(CONF_STRATEGY, CONF_STRATEGY_NAME))) def _setupStrategy(self): ''' setup tradingEngine''' strategy = StrategyFactory.createStrategy( self.__config.getOption(CONF_STRATEGY, CONF_STRATEGY_NAME), self.__config.getSection(CONF_STRATEGY)) strategy.setSymbols([self.__symbol]) strategy.indexHelper = self.__indexHelper strategy.history = self.__history #associate account accountId = self.__accountManager.createAccount(BackTester.CASH) strategy.accountId = accountId #register on trading engine strategy.tradingEngine = self.__tradingEngine self.__tradingEngine.register(strategy) def _execute(self): ''' run backtest ''' LOG.info("Running backtest for %s" % self.__symbol) #start trading engine thread = Thread(target=self.__tradingEngine.runListener, args=()) thread.setDaemon(True) thread.start() #start tickFeeder self.__tickFeeder.execute() self.__tradingEngine.stop() thread.join(timeout=60) def _printResult(self): ''' print result''' for account in self.__accountManager.getAccounts(): accountId = account.accountId LOG.info("account %s" % account) LOG.debug([str(order) for order in account.orderHistory]) LOG.debug("account position %s" % self.__accountManager.getAccountPostions(accountId)) LOG.info( self.__mCalculator.formatMetrics( self.__accountManager.getAccountPostions(accountId))) def runTest(self): ''' run one test ''' self._setup() self._execute() self._printResult()
class TestRunner(object): ''' back testing ''' def __init__(self, config, metricManager, accounts, symbols, startTickDate, endTradeDate, cash): self.__accountManager = AccountManager() self.__accountId = None self.__startTickDate = startTickDate self.__endTradeDate = endTradeDate self.__tickFeeder = TickFeeder(start=startTickDate, end=endTradeDate) self.__tradingCenter = TradingCenter() self.__tradingEngine = TradingEngine() self.__indexHelper = IndexHelper() self.__accounts = accounts self.__history = History() self.__saver = None self.__symbols = symbols self.__config = config self.__metricManager = metricManager self.__cash = cash def _setup(self): ''' setup ''' self._setupTradingCenter() self._setupTickFeeder() self._setupSaver() #wire things together self._setupStrategy() self.__tickFeeder.tradingCenter = self.__tradingCenter self.__tradingEngine.tickProxy = self.__tickFeeder self.__tradingEngine.orderProxy = self.__tradingCenter self.__tradingCenter.accountManager = self.__accountManager self.__tradingEngine.saver = self.__saver self.__tickFeeder.saver = self.__saver self.__accountManager.saver = self.__saver def _setupTradingCenter(self): self.__tradingCenter.start = 0 self.__tradingCenter.end = None def _setupTickFeeder(self): ''' setup tickFeeder''' self.__tickFeeder.indexHelper = self.__indexHelper self.__tickFeeder.setSymbols(self.__symbols) self.__tickFeeder.setDam(self._createDam( "")) # no need to set symbol because it's batch operation iSymbol = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_INDEX) self.__tickFeeder.setIndexSymbol(iSymbol) def _createDam(self, symbol): ''' setup Dam''' damName = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_INPUT_DAM) inputDb = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_INPUT_DB) dam = DAMFactory.createDAM(damName, {'db': inputDb}) dam.setSymbol(symbol) return dam def _setupSaver(self): ''' setup Saver ''' saverName = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_SAVER) outputDbPrefix = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_OUTPUT_DB_PREFIX) if saverName: self.__saver = StateSaverFactory.createStateSaver( saverName, { 'db': outputDbPrefix + getBackTestResultDbName( self.__symbols, self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_STRATEGY_NAME), self.__startTickDate, self.__endTradeDate) }) def _setupStrategy(self): ''' setup tradingEngine''' strategy = StrategyFactory.createStrategy( self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_STRATEGY_NAME), self.__config.getSection(CONF_ULTRAFINANCE_SECTION)) strategy.setSymbols(self.__symbols) strategy.history = self.__history #associate account self.__accountId = self.__accountManager.createAccount(self.__cash) strategy.accountId = self.__accountId strategy.accountManager = self.__accountManager #register on trading engine strategy.tradingEngine = self.__tradingEngine self.__tradingEngine.register(strategy) def _execute(self): ''' run backtest ''' LOG.info("Running backtest for %s" % self.__symbols) #start trading engine thread = Thread(target=self.__tradingEngine.runListener, args=()) thread.setDaemon(False) thread.start() #start tickFeeder self.__tickFeeder.execute() self.__tickFeeder.complete() timePositions = self.__accountManager.getAccountPostions( self.__accountId) startTradeDate = self.__config.getOption(CONF_ULTRAFINANCE_SECTION, CONF_START_TRADE_DATE) if startTradeDate: startTradeDate = int(startTradeDate) timePositions = [ tp for tp in timePositions if tp[0] >= startTradeDate ] #get and save metrics result = self.__metricManager.calculate( self.__symbols, timePositions, self.__tickFeeder.iTimePositionDict) account = self.__accountManager.getAccount(self.__accountId) self.__saver.writeMetrics(result[BasicMetric.START_TIME], result[BasicMetric.END_TIME], result[BasicMetric.MIN_TIME_VALUE][1], result[BasicMetric.MAX_TIME_VALUE][1], result[BasicMetric.SRATIO], result[BasicMetric.MAX_DRAW_DOWN][1], result[BasicMetric.R_SQUARED], account.getTotalValue(), account.holdings) #write to saver LOG.debug("Writing state to saver") self.__saver.commit() self.__tradingEngine.stop() thread.join(timeout=240) def _printResult(self): ''' print result''' account = self.__accountManager.getAccount(self.__accountId) self.__accounts.append(account) LOG.info("account %s" % account) LOG.debug([str(order) for order in account.orderHistory]) LOG.debug("account position %s" % self.__accountManager.getAccountPostions(self.__accountId)) def runTest(self): ''' run one test ''' self._setup() self._execute() self._printResult()
class TestRunner(object): """ back testing """ CASH = 100000 # 0.1 million to start def __init__(self, config, mCalculator, symbol): self.__accountManager = AccountManager() self.__tickFeeder = TickFeeder() self.__tradingCenter = TradingCenter() self.__tradingEngine = TradingEngine() self.__indexHelper = IndexHelper() self.__history = History() self.__saver = None self.__symbol = symbol self.__config = config self.__mCalculator = mCalculator def _setup(self): """ setup """ self._setupTradingCenter() self._setupTickFeeder() self._setupSaver() # wire things together self._setupStrategy() self.__tickFeeder.tradingCenter = self.__tradingCenter self.__tradingEngine.tickProxy = self.__tickFeeder self.__tradingEngine.orderProxy = self.__tradingCenter self.__tradingCenter.accountManager = self.__accountManager self.__tradingEngine.saver = self.__saver self.__accountManager.saver = self.__saver def _setupTradingCenter(self): self.__tradingCenter.start = 0 self.__tradingCenter.end = None def _setupTickFeeder(self): """ setup tickFeeder""" self.__tickFeeder.indexHelper = self.__indexHelper self.__tickFeeder.hisotry = self.__history # set source dam sDam = self._createDam(self.__symbol) self.__tickFeeder.addSource(sDam) # set index dam iSymbol = self.__config.getOption(CONF_APP_MAIN, CONF_INDEX) iDam = self._createDam(iSymbol) self.__tickFeeder.setIndexDam(iDam) def _createDam(self, symbol): """ setup Dam""" damName = self.__config.getOption(CONF_INPUT_SECTION, CONF_DAM) setting = self.__config.getSection(CONF_INPUT_SECTION) dam = DAMFactory.createDAM(damName, setting) dam.setSymbol(symbol) return dam def _setupSaver(self): """ setup Saver """ saverName = self.__config.getOption(CONF_OUTPUT_SECTION, CONF_SAVER) setting = self.__config.getSection(CONF_OUTPUT_SECTION) if saverName: self.__saver = StateSaverFactory.createStateSaver( saverName, setting, "%s_%s" % (self.__symbol, self.__config.getOption(CONF_STRATEGY, CONF_STRATEGY_NAME)), ) def _setupStrategy(self): """ setup tradingEngine""" strategy = StrategyFactory.createStrategy( self.__config.getOption(CONF_STRATEGY, CONF_STRATEGY_NAME), self.__config.getSection(CONF_STRATEGY) ) strategy.setSymbols([self.__symbol]) strategy.indexHelper = self.__indexHelper strategy.history = self.__history # associate account accountId = self.__accountManager.addAccount(Account(BackTester.CASH, 0)) strategy.accountId = accountId # register on trading engine strategy.tradingEngine = self.__tradingEngine self.__tradingEngine.register(strategy) def _execute(self): """ run backtest """ LOG.info("Running backtest for %s" % self.__symbol) # start trading engine thread = Thread(target=self.__tradingEngine.runListener, args=()) thread.setDaemon(True) thread.start() # start tickFeeder self.__tickFeeder.execute() self.__tradingEngine.stop() thread.join(timeout=60) def _printResult(self): """ print result""" for account in self.__accountManager.getAccounts(): accountId = account.accountId LOG.info("account %s" % account) LOG.debug([str(order) for order in account.orderHistory]) LOG.debug("account position %s" % self.__accountManager.getAccountPostions(accountId)) LOG.info(self.__mCalculator.formatMetrics(self.__accountManager.getAccountPostions(accountId))) def runTest(self): """ run one test """ self._setup() self._execute() self._printResult()