class LoggingTestCase(TestCase): def setUp(self): super(LoggingTestCase, self).setUp() from logbook import TestHandler self.log_handler = TestHandler() self.log_handler.push_application() def tearDown(self): super(LoggingTestCase, self).tearDown() self.log_handler.pop_application() def assert_log_records_len(self, n): self.assertEquals(len(self.log_handler.records), n) def assert_any_log_record(self, pred): self.assertTrue(any(pred(o) for o in self.log_handler.records), "any_log_record({!r}) is False, log records: {!r}".format(pred, self.dump_log_records())) def assert_no_log_record(self, pred): self.assertFalse(any(pred(o) for o in self.log_handler.records), "no_log_record({!r}) is False, log records: {!r}".format(pred, self.dump_log_records())) def assert_all_log_record(self, pred): self.assertTrue(all(pred(o) for o in self.log_handler.records), "all_log_record({!r}) is False, log records: {!r}".format(pred, self.dump_log_records())) def dump_log_records(self): return [r.to_dict() for r in self.log_handler.records]
class KettleTestCase(TestCase): def _pre_setup(self): # set up logging # TODO: Make this actually work self.log_handler = TestHandler() self.log_handler.push_thread() # Truncate all tables truncate_all(engine) # Reset session session.Session.remove() def __call__(self, result=None): """ Wrapper around default __call__ method to perform common test set up. This means that user-defined Test Cases aren't required to include a call to super().setUp(). """ try: self._pre_setup() except (KeyboardInterrupt, SystemExit): raise except Exception: import sys result.addError(self, sys.exc_info()) return super(KettleTestCase, self).__call__(result) try: self._post_teardown() except (KeyboardInterrupt, SystemExit): raise except Exception: import sys result.addError(self, sys.exc_info()) return def _post_teardown(self): # tear down logging self.log_handler.pop_thread() del calls[:] def assertRun(self, task): if (task.id, "run") not in calls: raise AssertionError("%s has not been run" % (task,)) def assertNotRun(self, task): if (task.id, "run") in calls: raise AssertionError("%s has been run" % (task,)) def assertReverted(self, task): if (task.id, "revert") not in calls: raise AssertionError("%s has not been reverted" % (task,)) def assertNotReverted(self, task): if (task.id, "revert") in calls: raise AssertionError("%s has been reverted" % (task,))
class BaseTestCase(unittest.TestCase): MOCKS = [] def setUp(self): self.log_handler = TestHandler() self.log_handler.format_string = '{record.message}' self.log_handler.push_thread() def tearDown(self): self.log_handler.pop_thread()
class BaseTestCase(unittest.TestCase): def setUp(self): # Capture the log self.log_handler = TestHandler() self.log_handler.push_application() # Connect to the database self.rd = redis.StrictRedis(REDIS['host'], port=REDIS['port'], password=REDIS['password'], socket_timeout=REDIS['timeout']) self.rd.flushdb() def tearDown(self): # Removes the log capture self.log_handler.pop_application() # Removes all data from the local redis instance self.rd.flushdb()
def test_standard_logging_works(): with TestHandler() as handler: logger = logging.getLogger('Dummy') with redirected_logging(): logger.info('hello world') assert handler.formatted_records == [ '[INFO] Dummy: hello world' ]
def compare_current_with_last_candle(self, exchange, assets, end_dt, freq, data_frequency, data_portal): """ Creates DataFrames from the bundle and exchange for the specified data set. Parameters ---------- exchange: Exchange assets end_dt bar_count freq data_frequency data_portal Returns ------- """ data = dict() assets = sorted(assets, key=lambda a: a.symbol) log_catcher = TestHandler() with log_catcher: symbols = [asset.symbol for asset in assets] print( 'comparing data for {}/{} with {} timeframe on {}'.format( exchange.name, symbols, freq, end_dt ) ) data['candle'] = data_portal.get_history_window( assets=assets, end_dt=end_dt, bar_count=1, frequency=freq, field='close', data_frequency=data_frequency, ) set_print_settings() print( 'the bundle first / last row:\n{}'.format( data['candle'].iloc[[-1]] ) ) current = data_portal.get_spot_value( assets=assets, field='close', dt=end_dt, data_frequency=data_frequency, ) data['current'] = pd.Series(data=current, index=assets) print( 'the current price:\n{}'.format( data['current'] ) ) pass
def test_orders(self): population = 3 quote_currency = 'eth' order_amount = 0.1 exchanges = select_random_exchanges( population=population, features=['fetchOrder'], is_authenticated=True, base_currency=quote_currency, ) # Type: list[Exchange] log_catcher = TestHandler() with log_catcher: for exchange in exchanges: exchange.init() assets = exchange.get_assets(quote_currency=quote_currency) asset = select_random_assets(assets, 1)[0] self.assertIsInstance(asset, TradingPair) tickers = exchange.tickers([asset]) price = tickers[asset]['last_price'] amount = order_amount / price limit_price = price * 0.8 style = ExchangeLimitOrder(limit_price=limit_price) order = exchange.order( asset=asset, amount=amount, style=style, ) sleep(1) open_order, _ = exchange.get_order(order.id, asset) self.assertEqual(0, open_order.status) exchange.cancel_order(open_order, asset) sleep(1) canceled_order, _ = exchange.get_order(open_order.id, asset) warnings = [ record for record in log_catcher.records if record.level == WARNING ] self.assertEqual(0, len(warnings)) self.assertEqual(2, canceled_order.status) print('tested {exchange} / {symbol}, order: {order}'.format( exchange=exchange.name, symbol=asset.symbol, order=order.id, )) pass
def compare_bundle_with_exchange(self, exchange, assets, end_dt, bar_count, freq, data_frequency, data_portal): """ Creates DataFrames from the bundle and exchange for the specified data set. Parameters ---------- exchange: Exchange assets end_dt bar_count sample_minutes Returns ------- """ data = dict() log_catcher = TestHandler() with log_catcher: data['bundle'] = data_portal.get_history_window( assets=assets, end_dt=end_dt, bar_count=bar_count, frequency=freq, field='close', data_frequency=data_frequency, ) print('bundle data:\n{}'.format(data['bundle'].tail(10))) candles = exchange.get_candles( end_dt=end_dt, freq=freq, assets=assets, bar_count=bar_count, ) data['exchange'] = get_candles_df( candles=candles, field='close', freq=freq, bar_count=bar_count, end_dt=end_dt, ) print('exchange data:\n{}'.format(data['exchange'].tail(10))) for source in data: df = data[source] path = output_df(df, assets, '{}_{}'.format(freq, source)) print('saved {}:\n{}'.format(source, path)) assert_frame_equal( right=data['bundle'], left=data['exchange'], check_less_precise=True, )
def _pre_setup(self): # set up logging # TODO: Make this actually work self.log_handler = TestHandler() self.log_handler.push_thread() # Truncate all tables truncate_all(engine) # Reset session session.Session.remove()
def setUp(self): # Capture the log self.log_handler = TestHandler() self.log_handler.push_application() # Connect to the database self.rd = redis.StrictRedis(REDIS['host'], port=REDIS['port'], password=REDIS['password'], socket_timeout=REDIS['timeout']) self.rd.flushdb()
def test_asyncio(): logger = logging.getLogger('Dummy') async def util(): for i in range(3): logger.info('I am the util function', extra={'iteration': i+1}) await asyncio.sleep(0) async def task(task_name: str): def inject_extra(record): record.extra['task_name'] = task_name record.extra['task_id'] = id(asyncio.current_task()) with Handler(bubble=True).contextbound(): with Processor(inject_extra).contextbound(): logger.info('I am the task') await asyncio.sleep(0) await util() logger.info('I am still the task') root_handler = TestHandler() root_handler.formatter = text_formatter with root_handler.applicationbound(): with redirected_logging(): asyncio.get_event_loop().run_until_complete(asyncio.gather(task('one'), task('two'), task('three'))) records = root_handler.formatted_records assert 'INFO: Dummy: I am the task <task_name=one' in records[0] assert 'INFO: Dummy: I am the task <task_name=two' in records[1] assert 'INFO: Dummy: I am the task <task_name=three' in records[2] assert 'INFO: Dummy: I am the util function <iteration=1, task_name=one' in records[3] assert 'INFO: Dummy: I am the util function <iteration=1, task_name=two' in records[4] assert 'INFO: Dummy: I am the util function <iteration=1, task_name=three' in records[5] assert 'INFO: Dummy: I am the util function <iteration=2, task_name=one' in records[6] assert 'INFO: Dummy: I am the util function <iteration=2, task_name=two' in records[7] assert 'INFO: Dummy: I am the util function <iteration=2, task_name=three' in records[8] assert 'INFO: Dummy: I am the util function <iteration=3, task_name=one' in records[9] assert 'INFO: Dummy: I am the util function <iteration=3, task_name=two' in records[10] assert 'INFO: Dummy: I am the util function <iteration=3, task_name=three' in records[11] assert 'INFO: Dummy: I am still the task <task_name=one' in records[12] assert 'INFO: Dummy: I am still the task <task_name=two' in records[13] assert 'INFO: Dummy: I am still the task <task_name=three' in records[14]
def genome(aphidicola): handler = TestHandler() genome = ("GCA_000521565.1_Buchnera_aphidicola_G002_" "Myzus_persicae_Complete_Genome.fasta") genome = os.path.join(aphidicola.path, genome) with handler: genome = Genome(genome, assembly_summary) genome.sketch() genome.get_contigs() genome.get_assembly_size() genome.get_unknowns() yield genome, handler
def test_mdc_works(): def inject_extra(record): record.extra['ip'] = '127.0.0.1' record.extra['username'] = '******' with TestHandler() as handler: handler.formatter = text_formatter logger = logging.getLogger('Dummy') with redirected_logging(): with Processor(inject_extra): logger.info('hello world') assert len(handler.formatted_records) == 1 assert 'INFO: Dummy: hello world <ip=127.0.0.1, username=Andrey>' in handler.formatted_records[0]
def test_exception_text_formatter(): with TestHandler() as handler: handler.formatter = text_formatter logger = logging.getLogger('Dummy') with redirected_logging(): try: raise Exception('Something bad!') except Exception: logger.error('hello world', exc_info=True) assert len(handler.formatted_records) == 1 record = handler.formatted_records[0] assert 'ERROR: Dummy: hello world' in record assert '/logbook_test.py' in record assert 'Exception: Something bad!' in record
def test_exception_json_formatter(): with TestHandler() as handler: handler.formatter = json_formatter logger = logging.getLogger('Dummy') with redirected_logging(): try: raise Exception('Something bad!') except Exception: logger.error('hello world', exc_info=True) assert len(handler.formatted_records) == 1 record = json.loads(handler.formatted_records[0]) assert record['level'] == 'ERROR' assert record['name'] == 'Dummy' assert record['message'] == 'hello world' assert '/logbook_test.py' in record['exception'] assert 'Exception: Something bad!' in record['exception']
def test_json_formatting_works(): def inject_extra(record): record.extra['ip'] = '127.0.0.1' record.extra['username'] = '******' with TestHandler() as handler: handler.formatter = json_formatter logger = logging.getLogger('Dummy') with redirected_logging(): with Processor(inject_extra): logger.info('hello world') assert len(handler.formatted_records) == 1 record = json.loads(handler.formatted_records[0]) assert record['level'] == 'INFO' assert record['name'] == 'Dummy' assert record['message'] == 'hello world' assert record['ip'] == '127.0.0.1' assert record['username'] == 'Andrey'
def make_test_handler(testcase, *args, **kwargs): """ Returns a TestHandler which will be used by the given testcase. This handler can be used to test log messages. Parameters ---------- testcase: unittest.TestCase The test class in which the log handler will be used. *args, **kwargs Forwarded to the new TestHandler object. Returns ------- handler: logbook.TestHandler The handler to use for the test case. """ handler = TestHandler(*args, **kwargs) testcase.addCleanup(handler.close) return handler
def test_run_examples(self): folder = join('..', '..', '..', 'catalyst', 'examples') files = [f for f in listdir(folder) if isfile(join(folder, f))] algo_list = [] for filename in files: name = os.path.basename(filename) if filter_algos and name not in filter_algos: continue module_name = 'catalyst.examples.{}'.format(name.replace( '.py', '')) algo_list.append(module_name) for module_name in algo_list: algo = importlib.import_module(module_name) namespace = module_name.replace('.', '_') log_catcher = TestHandler() with log_catcher: run_algorithm( capital_base=0.1, data_frequency='minute', initialize=algo.initialize, handle_data=algo.handle_data, analyze=TestSuiteAlgo.analyze, exchange_name='poloniex', algo_namespace='test_{}'.format(namespace), base_currency='eth', start=pd.to_datetime('2017-10-01', utc=True), end=pd.to_datetime('2017-10-02', utc=True), # output=out ) warnings = [ record for record in log_catcher.records if record.level == WARNING ] if len(warnings) > 0: print('WARNINGS:\n{}'.format(warnings)) pass
def run(): with TestHandler() as handler: for x in xrange(500): log.warning('this is not handled')
def test_run_examples(self): # folder = join('..', '..', '..', 'catalyst', 'examples') HERE = os.path.dirname(os.path.abspath(__file__)) folder = os.path.join(HERE, '..', '..', '..', 'catalyst', 'examples') files = [ f for f in os.listdir(folder) if os.path.isfile(os.path.join(folder, f)) ] algo_list = [] for filename in files: name = os.path.basename(filename) if filter_algos and name not in filter_algos: continue module_name = 'catalyst.examples.{}'.format(name.replace( '.py', '')) algo_list.append(module_name) exchanges = ['poloniex', 'bittrex', 'binance'] asset_name = 'btc_usdt' quote_currency = 'usdt' capital_base = 10000 data_freq = 'daily' start_date = pd.to_datetime('2017-10-01', utc=True) end_date = pd.to_datetime('2017-12-01', utc=True) for exchange_name in exchanges: ingest_exchange_bundles(exchange_name, data_freq, asset_name) for module_name in algo_list: algo = importlib.import_module(module_name) # namespace = module_name.replace('.', '_') log_catcher = TestHandler() with log_catcher: run_algorithm( capital_base=capital_base, data_frequency=data_freq, initialize=algo.initialize, handle_data=algo.handle_data, analyze=TestSuiteAlgo.analyze, exchange_name=exchange_name, algo_namespace='test_{}'.format(exchange_name), quote_currency=quote_currency, start=start_date, end=end_date, # output=out ) warnings = [ record for record in log_catcher.records if record.level == WARNING ] assert (len(warnings) == 1) assert (warnings[0].message == ALPHA_WARNING_MESSAGE) assert (not log_catcher.has_errors) assert (not log_catcher.has_criticals) clean_exchange_bundles(exchange_name, data_freq)
def setUp(self): super(LoggingTestCase, self).setUp() from logbook import TestHandler self.log_handler = TestHandler() self.log_handler.push_application()
def setUp(self): self.log_handler = TestHandler() self.log_handler.format_string = '{record.message}' self.log_handler.push_thread()
def compare_bundle_with_exchange(self, exchange, assets, end_dt, bar_count, freq, data_frequency, data_portal, field): """ Creates DataFrames from the bundle and exchange for the specified data set. Parameters ---------- exchange: Exchange assets end_dt bar_count freq data_frequency data_portal Returns ------- """ data = dict() log_catcher = TestHandler() with log_catcher: symbols = [asset.symbol for asset in assets] print( 'comparing {} for {}/{} with {} timeframe until {}'.format( field, exchange.name, symbols, freq, end_dt ) ) data['bundle'] = data_portal.get_history_window( assets=assets, end_dt=end_dt, bar_count=bar_count, frequency=freq, field=field, data_frequency=data_frequency, ) set_print_settings() print( 'the bundle data:\n{}'.format( data['bundle'] ) ) candles = exchange.get_candles( end_dt=end_dt, freq=freq, assets=assets, bar_count=bar_count, ) data['exchange'] = get_candles_df( candles=candles, field=field, freq=freq, bar_count=bar_count, end_dt=end_dt, ) print( 'the exchange data:\n{}'.format( data['exchange'] ) ) for source in data: df = data[source] path, folder = output_df( df, assets, '{}_{}'.format(freq, source) ) print('saved {} test results: {}'.format(end_dt, folder)) assert_frame_equal( right=data['bundle'][:-1], left=data['exchange'][:-1], check_less_precise=1, ) try: assert_frame_equal( right=data['bundle'][:-1], left=data['exchange'][:-1], check_less_precise=min([a.decimals for a in assets]), ) except Exception as e: print( 'Some differences were found within a 1 decimal point ' 'interval of confidence: {}'.format(e) ) with open(os.path.join(folder, 'compare.txt'), 'w+') as handle: handle.write(e.args[0]) pass