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]}
