def test_should_have_latest_of_twice_appended_rate(self): cache = FxPricesCache() cache.set_rate(TickEvent('CHF_USD', get_time(), 1.1, 1.2)) cache.set_rate(TickEvent('CHF_USD', get_time(), 1.15, 1.25)) rates = cache.get_rate('CHF_USD') self.assertEqual(1.15, rates['bid']) self.assertEqual(1.25, rates['ask'])
def test_should_generate_signal_when_ticks_are_enough_for_5_10_period_ma(self): strategy = TWMACrossoverStrategy(5, 10) ticks = list() ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.12404,"ask":1.1242}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:50:08.543570Z","bid":1.12403,"ask":1.12421}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:50:08.633262Z","bid":1.12406,"ask":1.12423}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:50:08.754773Z","bid":1.12405,"ask":1.12425}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:50:10.243141Z","bid":1.12411,"ask":1.12429}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:50:10.221148Z","bid":1.12409,"ask":1.12427}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:50:25.349546Z","bid":1.12415,"ask":1.12433}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:50:48.074682Z","bid":1.12411,"ask":1.12431}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:51:52.351710Z","bid":1.12409,"ask":1.12428}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:51:52.526526Z","bid":1.12407,"ask":1.12424}}') # ticks.append( # '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:51:52.721429Z","bid":1.12404,"ask":1.12423}}') for i in range(0, 10 - 1): self.assertIsNone( strategy.calculate_signals(parse_event_str(get_time(), ticks[i]))) #sending another tick will trigger MA crossover detection tick = parse_event_str(get_time(), ticks[10 - 1]) self.assertIsNotNone(strategy.calculate_signals(tick))
def test_should_generate_buy_signal_then_sell_signal(self): signal = self.strategy.calculate_signals( parse_event_str( get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.021,"ask":1.01}}' )) self.assertIsNone(signal) signal = self.strategy.calculate_signals( parse_event_str( get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.026,"ask":1.07}}' )) self.assertIsNone(signal) signal = self.strategy.calculate_signals( parse_event_str( get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.026,"ask":1.09}}' )) self.assertIsNotNone(signal) self.assertEqual(ORDER_SIDE_BUY, signal) signal = self.strategy.calculate_signals( parse_event_str( get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.026,"ask":1.07}}' )) self.assertIsNone(signal) signal = self.strategy.calculate_signals( parse_event_str( get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.023,"ask":1.09}}' )) self.assertIsNotNone(signal) self.assertEqual(ORDER_SIDE_SELL, signal)
def test_should_have_latest_of_twice_appended_rate(self): cache = FxPricesCache() cache.set_rate(TickEvent('CHF_USD', get_time(), 1.1, 1.2)) cache.set_rate(TickEvent('CHF_USD', get_time(), 1.15, 1.25)) rates = cache.get_rate('CHF_USD') self.assertEqual(1.15, rates['bid']) self.assertEqual(1.25, rates['ask'])
def test_should_eval_cost_if_two_ticks_available(self): tick1 = TickEvent('CHF_USD', get_time(), 1.01, 1.03) tick2 = TickEvent('CHF_USD', get_time(), 1.02, 1.03) self.cost_predictor.process(tick1) self.cost_predictor.process(tick2) order = OrderEvent(tick2.instrument, 100, 'buy') cost = self.cost_predictor.eval_cost(order) self.assertEqual(0.015, cost)
def test_should_re_evaluates_all_positions_after_2_orders_are_executed_in_diff_ccy_buy_sell(self): executed_order1 = ExecutedOrder(self.buy_100_CHF_USD, 1.1, 100) self.portfolio.append_position(executed_order1) executed_order2 = ExecutedOrder(self.sell_50_EUR_USD, 0.9, 50) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('CHF_USD', get_time(), 1.21, 1.22)) self.cache.set_rate(TickEvent('EUR_USD', get_time(), 0.91, 0.92)) expected = round(100/1.22 - 50/0.91 - 50, 2) self.assertEqual(expected, self.portfolio.reval_positions())
def test_should_eval_cost_if_two_ticks_available(self): tick1 = TickEvent('CHF_USD', get_time(), 1.01, 1.03) tick2 = TickEvent('CHF_USD', get_time(), 1.02, 1.03) self.cost_predictor.process(tick1) self.cost_predictor.process(tick2) order = OrderEvent(tick2.instrument, 100, 'buy') cost = self.cost_predictor.eval_cost(order) self.assertEqual(0.015, cost)
def test_should_re_evaluates_all_positions_after_2_orders_are_executed_in_diff_ccy( self): executed_order1 = ExecutedOrder(self.buy_100_CHF_USD, 1.1, 100) self.portfolio.append_position(executed_order1) executed_order2 = ExecutedOrder(self.buy_100_EUR_USD, 0.9, 100) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('CHF_USD', get_time(), 1.21, 1.22)) self.cache.set_rate(TickEvent('EUR_USD', get_time(), 0.91, 0.92)) expected = round(100 / 1.22 + 100 / 0.92 - 200, 2) self.assertEqual(expected, self.portfolio.reval_positions())
def setUp(self): self.tick = TickEvent('EUR_GBP', get_time(), 0.87, 0.88) self.order = OrderEvent('EUR_GBP', 100, 'buy') self.executed_order = ExecutedOrder(self.order, 1.1, 100) self.strategy = StrategyOrderManager(AlternateBuySellAt5thTickStrategy(), 1000) for i in range(1, 6): tick = TickEvent('EUR_GBP', get_time(), 0.87 + i, 0.88 + i) self.strategy.process(tick) self.snap_shot_helper = SnapShotHelper()
def test_should_be_able_to_pull_two_ticks_of_same_instrument_from_event_queue(self): tick1 = TickEvent('CHF_USD', get_time(), 1.0, 1.0) tick2 = TickEvent('CHF_USD', get_time(), 1.01, 1.02) self.cost_predictor.process(tick1) self.cost_predictor.process(tick2) last_tick = self.cost_predictor.get_last_tick() self.assertEqual(last_tick.instrument, tick2.instrument) self.assertEqual(last_tick.bid, tick2.bid) self.assertEqual(last_tick.ask, tick2.ask)
def test_should_not_generate_signal_when_no_cross_over(self): signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.02400,"ask":1.01}}')) self.assertIsNone(signal) signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:03.024026Z","bid":1.02401,"ask":1.07}}')) self.assertIsNone(signal) signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:04.024026Z","bid":1.02402,"ask":1.09}}')) self.assertIsNone(signal)
def test_should_not_generate_signal_when_ma_and_previous_ma_are_same_for_the_first_period(self): signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.024,"ask":1.01}}')) self.assertIsNone(signal) signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.026,"ask":1.07}}')) self.assertIsNone(signal) signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.024,"ask":1.09}}')) self.assertIsNone(signal)
def test_should_generate_buy_signal_when_ticks_are_enough_for_period2_ma(self): signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:02.024026Z","bid":1.023,"ask":1.01}}')) self.assertIsNone(signal) signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:03.024026Z","bid":1.024,"ask":1.07}}')) self.assertIsNone(signal) signal = self.strategy.calculate_signals(parse_event_str(get_time(), '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:04.024026Z","bid":1.026,"ask":1.09}}')) self.assertIsNotNone(signal) self.assertEqual(ORDER_SIDE_BUY, signal)
def setUp(self): self.tick = TickEvent('EUR_GBP', get_time(), 0.87, 0.88) self.order = OrderEvent('EUR_GBP', 100, 'buy') self.executed_order = ExecutedOrder(self.order, 1.1, 100) self.strategy = StrategyOrderManager( AlternateBuySellAt5thTickStrategy(), 1000) for i in range(1, 6): tick = TickEvent('EUR_GBP', get_time(), 0.87 + i, 0.88 + i) self.strategy.process(tick) self.snap_shot_helper = SnapShotHelper()
def test_should_be_able_to_pull_two_ticks_of_same_instrument_from_event_queue( self): tick1 = TickEvent('CHF_USD', get_time(), 1.0, 1.0) tick2 = TickEvent('CHF_USD', get_time(), 1.01, 1.02) self.cost_predictor.process(tick1) self.cost_predictor.process(tick2) last_tick = self.cost_predictor.get_last_tick() self.assertEqual(last_tick.instrument, tick2.instrument) self.assertEqual(last_tick.bid, tick2.bid) self.assertEqual(last_tick.ask, tick2.ask)
def test_should_have_zero_unrealized_pnl_after_closing_position(self): executed_order = ExecutedOrder(self.buy_100_EUR_USD, 1.4, 100) executed_order2 = ExecutedOrder(self.sell_100_EUR_USD, 1.3, 100) self.portfolio.append_position(executed_order) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('EUR_USD', get_time(), 0.91, 0.92)) self.assertEqual(0, self.portfolio.reval_positions())
def test_should_eval_cost_if_tick_available(self): tick = TickEvent('CHF_USD', get_time(), 1.01, 1.02) self.events.put_nowait(tick) self.looper.pull_process() order = OrderEvent(tick.instrument, 100, 'buy') cost = self.cost_predictor.eval_cost(order) self.assertEqual(0.01, cost)
def test_should_give_correct_rates_after_event_is_queued_using_event_loop( self): cache = self.play_event_loop( TickEvent('EUR_GBP', get_time(), 0.87, 0.88)) rates = cache.get_rate('EUR_GBP') self.assertEqual(0.87, rates['bid']) self.assertEqual(0.88, rates['ask'])
def test_should_be_able_to_process_fills(self): self.cache.set_rate(TickEvent('EUR_USD', get_time(), 1.11, 1.15)) executed_order = ExecutedOrder(self.buy_order, 1.12, 100) processed_value = self.portfolio.process(executed_order) self.assertIsNone(processed_value) self.assertEqual({'EUR_USD': 100}, self.portfolio.list_positions())
def test_should_allow_to_set_unity_fx_rate_and_have_same_units(self): ccy_limits = {'CHF': 110} rm = CcyExposureLimitRiskEvaluator('SGD', self.cache, ccy_limit=10000, ccy_limits=ccy_limits) rm.rates_cache.set_rate(TickEvent('CHF_SGD', get_time(), 1.0, 1.0)) order = OrderEvent('CHF_SGD', 105, 'buy') filtered = rm.filter_order(order) self.assertEquals(filtered.units, 105)
def setUp(self): self.tick = TickEvent('EUR_GBP', get_time(), 0.87, 0.88) self.order = OrderEvent('EUR_GBP', 100, 'buy') self.executed_order = ExecutedOrder(self.order, 1.1, 100) self.strategy = StrategyOrderManager(DummyBuyStrategy(), 1000) self.strategy.process(self.tick) self.snap_shot_helper = SnapShotHelper()
def test_should_allow_to_read_string_journals(self): filename = os.path.join(OUTPUT_DIR, 'journal_read_ut.txt') try: os.remove(filename) except OSError: pass print('writing..') journaler = FileJournaler(full_path=filename) journaler.start() event = 'this is a test event #1' journaler.log_event(get_time(), event) sleep(0.2) journaler.close() print('reading..') eq = Queue() reader = FileJournalerReader(eq, full_path=filename) reader.read_events() try: message = eq.get_nowait() self.assertEqual(event, message) except Empty: pass
def setUp(self): self.tick = TickEvent('EUR_GBP', get_time(), 0.87, 0.88) self.order = OrderEvent('EUR_GBP', 100, 'buy') self.executed_order = ExecutedOrder(self.order, 1.1, 100) self.strategy = StrategyOrderManager(DummyBuyStrategy(), 1000) self.strategy.process(self.tick) self.snap_shot_helper = SnapShotHelper()
def test_should_have_correct_realized_pnl_after_partial_close(self): executed_order = ExecutedOrder(self.buy_100_EUR_USD, 1.4, 100) executed_order2 = ExecutedOrder(self.sell_50_EUR_USD, 1.3, 50) self.portfolio.append_position(executed_order) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('EUR_USD', get_time(), 0.91, 0.92)) self.assertEqual(-5, self.portfolio.get_realized_pnl())
def test_should_eval_cost_if_tick_available(self): tick = TickEvent('CHF_USD', get_time(), 1.01, 1.02) self.events.put_nowait(tick) self.looper.pull_process() order = OrderEvent(tick.instrument, 100, 'buy') cost = self.cost_predictor.eval_cost(order) self.assertEqual(0.01, cost)
def test_should_allow_to_set_unity_fx_rate_and_have_less_units_when_order_size_breaches_specific_limit_on_1st_ccy(self): ccy_limits = {'CHF': 110} rm = CcyExposureLimitRiskEvaluator('SGD', self.cache, ccy_limit=10000, ccy_limits=ccy_limits) rm.rates_cache.set_rate(TickEvent('CHF_SGD', get_time(), 1.0, 1.0)) order = OrderEvent('CHF_SGD', 150, 'buy') filtered = rm.filter_order(order) self.assertEquals(filtered.units, 110)
def test_should_have_zero_unrealized_pnl_after_closing_position(self): executed_order = ExecutedOrder(self.buy_100_EUR_USD, 1.4, 100) executed_order2 = ExecutedOrder(self.sell_100_EUR_USD, 1.3, 100) self.portfolio.append_position(executed_order) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('EUR_USD', get_time(), 0.91, 0.92)) self.assertEqual(0, self.portfolio.reval_positions())
def test_should_re_evaluate_long_position_when_new_market_rate_goes_up( self): executed_order = ExecutedOrder(self.buy_100_CHF_USD, 1.1, 100) self.portfolio.append_position(executed_order) self.cache.set_rate(TickEvent('CHF_USD', get_time(), 1.2, 1.3)) revalued = self.portfolio.reval_position('CHF_USD') self.assertEqual(20, revalued)
def test_should_have_correct_realized_pnl_after_partial_close(self): executed_order = ExecutedOrder(self.buy_100_EUR_USD, 1.4, 100) executed_order2 = ExecutedOrder(self.sell_50_EUR_USD, 1.3, 50) self.portfolio.append_position(executed_order) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('EUR_USD', get_time(), 0.91, 0.92)) self.assertEqual(-5, self.portfolio.get_realized_pnl())
def put_nowait(self, item): for i in range(0, len(self.consumer_queues)): consumer_q = self.consumer_queues[i] try: consumer_q.put_nowait(item) except Full: self.journaler.log_event(get_time(), prepare_journal_message('q is full', item, i))
def test_should_re_evaluate_short_position_when_new_market_rate_goes_down(self): executed_order = ExecutedOrder(OrderEvent('CHF_USD', 100, 'sell'), 1.1, 100) self.portfolio.append_position(executed_order) self.cache.set_rate(TickEvent('CHF_USD', get_time(), 1.051, 1.064)) revalued = self.portfolio.reval_position('CHF_USD') expected = round(-100 * (1.051-1.1), 2) self.assertEqual(expected, revalued)
def test_should_have_correct_unrealized_pnl_after_partial_close(self): executed_order = ExecutedOrder(self.buy_100_EUR_USD, 0.905, 100) executed_order2 = ExecutedOrder(self.sell_50_EUR_USD, 0.900, 50) self.portfolio.append_position(executed_order) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('EUR_USD', get_time(), 0.910, 0.920)) expected = round(50 / 0.920 - 50, 2) self.assertEqual(expected, self.portfolio.reval_positions())
def test_should_re_evaluates_all_positions_after_2_orders_are_executed_net_short(self): executed_order1 = ExecutedOrder(self.sell_100_CHF_USD, 1.1, 100) self.portfolio.append_position(executed_order1) executed_order2 = ExecutedOrder(self.buy_50_CHF_USD, 1.15, 50) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('CHF_USD', get_time(), 1.21, 1.22)) expected = round(-50/1.21 + 50, 2) self.assertEqual(expected, self.portfolio.reval_positions())
def test_should_have_correct_unrealized_pnl_after_partial_close(self): executed_order = ExecutedOrder(self.buy_100_EUR_USD, 0.905, 100) executed_order2 = ExecutedOrder(self.sell_50_EUR_USD, 0.900, 50) self.portfolio.append_position(executed_order) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('EUR_USD', get_time(), 0.910, 0.920)) expected = round(50/0.920 - 50, 2) self.assertEqual(expected, self.portfolio.reval_positions())
def _put_in_q(self, q, item, timeout): try: q.put(item, True, timeout=timeout) print('successfully put item on queue [%s <- %s]' % (q, item)) except Full: self.journaler.log_event( get_time(), prepare_journal_message('target queue was full', item, q))
def put_nowait(self, item): for i in range(0, len(self.consumer_queues)): consumer_q = self.consumer_queues[i] try: consumer_q.put_nowait(item) except Full: self.journaler.log_event( get_time(), prepare_journal_message('q is full', item, i))
def test_should_not_eval_cost_if_no_tick_for_specific_instrument(self): tick = TickEvent('CHF_USD', get_time(), 1.0, 1.0) self.cost_predictor.process(tick) order = OrderEvent('EUR_USD', 100, 'buy') try: self.cost_predictor.eval_cost(order) self.fail('should have given error as no tick for [%s] is present' % order.instrument) except KeyError: pass
def test_should_allow_logging_file_journaler(self): filename = os.path.join(OUTPUT_DIR, 'journal_ut.txt') try: os.remove(filename) except OSError: pass journaler = FileJournaler(full_path=filename) journaler.start() journaler.log_event(get_time(), 'this is a test event #1') journaler.log_event(get_time(), 'this is a test event #2') journaler.log_event(get_time(), 'this is a test event #3') journaler.log_event(get_time(), 'this is a test event #4') journaler.log_event(get_time(), 'this is a test event #5') sleep(0.2) journaler.close() print('exit')
def test_should_re_evaluate_short_position_when_new_market_rate_goes_down( self): executed_order = ExecutedOrder(OrderEvent('CHF_USD', 100, 'sell'), 1.1, 100) self.portfolio.append_position(executed_order) self.cache.set_rate(TickEvent('CHF_USD', get_time(), 1.051, 1.064)) revalued = self.portfolio.reval_position('CHF_USD') expected = round(-100 * (1.051 - 1.1), 2) self.assertEqual(expected, revalued)
def test_should_re_evaluates_all_positions_after_2_orders_are_executed_net_long( self): executed_order1 = ExecutedOrder(self.buy_100_CHF_USD, 1.1, 100) self.portfolio.append_position(executed_order1) executed_order2 = ExecutedOrder(self.sell_50_CHF_USD, 1.15, 50) self.portfolio.append_position(executed_order2) self.cache.set_rate(TickEvent('CHF_USD', get_time(), 1.21, 1.22)) expected = round(50 / 1.22 - 50, 2) self.assertEqual(expected, self.portfolio.reval_positions())
def test_should_allow_to_set_unity_fx_rate_and_have_same_units(self): ccy_limits = {'CHF': 110} rm = CcyExposureLimitRiskEvaluator('SGD', self.cache, ccy_limit=10000, ccy_limits=ccy_limits) rm.rates_cache.set_rate(TickEvent('CHF_SGD', get_time(), 1.0, 1.0)) order = OrderEvent('CHF_SGD', 105, 'buy') filtered = rm.filter_order(order) self.assertEquals(filtered.units, 105)
def test_should_reduce_units_of_very_large_sell_order(self): self.cache.set_rate(TickEvent('EUR_USD', get_time(), 1.0, 1.0)) try: filtered_order = self.portfolio.check_order(self.large_sell_order) self.assertEqual(self.ccy_exposure_manager.ccy_limit_short, -1 * filtered_order.units) except RuntimeError as e: self.fail( 'Expecting a filtered order per currency manager\'s limit, but got exception - [%s]' % e)
def test_should_generate_signal_when_ticks_are_enough_for_2_3_period_ma(self): strategy = TWMACrossoverStrategy(2, 3, 'time', 'bid') ticks = list() ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:03.000000Z","bid":1.1000,"ask":1.1242}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:04.00000Z","bid":1.2000,"ask":1.12421}}') ticks.append( '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:48:05.000000Z","bid":1.3000,"ask":1.12423}}') # ticks.append( # '{"tick":{"instrument":"EUR_USD","time":"2015-06-11T22:50:08.754773Z","bid":1.12405,"ask":1.12425}}') for i in range(0, len(ticks) - 1): self.assertIsNone( strategy.calculate_signals(parse_event_str(get_time(), ticks[i]))) tick = parse_event_str(get_time(), ticks[len(ticks)-1]) self.assertIsNotNone(strategy.calculate_signals(tick))
def test_order_generation_in_same_queue(self): self.trader.processed_event_q = self.events tick = TickEvent('EUR_GBP', get_time(), 0.87, 0.88) self.events.put(tick) self.trader.pull_process() order = self.executor.get_last_event() self.assertEquals(tick.instrument, order.instrument) self.assertEquals(EVENT_TYPES_ORDER, order.TYPE) self.assertEquals(self.strategy.units, order.units)
def test_order_generation_in_same_queue(self): self.trader.processed_event_q = self.events tick = TickEvent('EUR_GBP', get_time(), 0.87, 0.88) self.events.put(tick) self.trader.pull_process() order = self.executor.get_last_event() self.assertEquals(tick.instrument, order.instrument) self.assertEquals(EVENT_TYPES_ORDER, order.TYPE) self.assertEquals(self.strategy.units, order.units)
def send_and_receive(self, func, url, request_args): self.logger.info('execution order parameter (url encoded) [%s]' % request_args) try: response = func(url, **request_args) receive_time = get_time() return self.parse_response(receive_time, response) except requests.RequestException as e: self.logger.error('exception during execution', e) return {'code': -2, 'message': e.args[0]}
def test_should_not_accept_day_old_tick(self): cache = FxPricesCache() one_day_in_seconds = 86400 one_day_ago = get_time(-1 * one_day_in_seconds) try: tick = TickEvent('CHF_USD', one_day_ago, 1.1, 1.2) cache.set_rate(tick) self.fail('FX price cache should not have accepted a day old tick - [%s]' % tick) except AssertionError: pass
def setUp(self): self.ticks_and_ack_q = Queue() self.signal_output_q = Queue() self.strategy = StrategyOrderManager(DummyBuyStrategy(), 100) self.strategy_loop = EventLoop(self.ticks_and_ack_q, self.strategy, processed_event_q=self.signal_output_q) self.strategy_thread = Thread(target=self.strategy_loop.start, args=[]) # ticks and events for testing self.tick = TickEvent('EUR_GBP', get_time(), 0.87, 0.88)
def test_should_not_accept_tick_older_than_max_acceptable_age(self): max_tick_age = 100 cache = FxPricesCache(max_tick_age=max_tick_age) older_than_max_tick_age = get_time(-2 * max_tick_age) try: tick = TickEvent('CHF_USD', older_than_max_tick_age, 1.1, 1.2) cache.set_rate(tick) self.fail('FX price cache should not have accepted a tick older than [%s] seconds - [%s]' % (max_tick_age, tick)) except AssertionError: pass
def test_should_allow_to_read_oanda_like_tick_journals_from_file_using_thread(self): self.journaler.start() self.journaler.log_event(get_time(), self.tick_str) self.journaler.stop() self.reader.read_events() try: ev_str = self.read_q.get_nowait() self.assertEqual(self.tick_str, ev_str) except Empty: self.fail('expecting a message from read queue')
def test_should_allow_to_set_unity_fx_rate_and_have_less_units_when_order_size_breaches_specific_limit_on_1st_ccy( self): ccy_limits = {'CHF': 110} rm = CcyExposureLimitRiskEvaluator('SGD', self.cache, ccy_limit=10000, ccy_limits=ccy_limits) rm.rates_cache.set_rate(TickEvent('CHF_SGD', get_time(), 1.0, 1.0)) order = OrderEvent('CHF_SGD', 150, 'buy') filtered = rm.filter_order(order) self.assertEquals(filtered.units, 110)
def test_order_generation_in_separate_queue(self): self.trader.processed_event_q = self.execution_q for i in range(1, 7): tick = TickEvent("EUR_GBP", get_time(), round(0.87 + (i / 100), 2), 0.88 + (i / 100)) self.events.put(tick) self.trader.pull_process() order = self.execution_q.get_nowait() self.assertEquals(tick.instrument, order.instrument) self.assertEquals(EVENT_TYPES_ORDER, order.TYPE) self.assertEquals(self.strategy.units, order.units)
def send_and_receive(self, func, url, request_args): self.logger.info('execution order parameter (url encoded) [%s]' % request_args) try: response = func(url, **request_args) receive_time = get_time() return self.parse_response(receive_time, response) except requests.RequestException as e: self.logger.error('exception during execution', e) return {'code': -2, 'message': e.args[0]}