コード例 #1
0
class BaseFlumineTest(unittest.TestCase):
    def setUp(self):
        self.mock_client = mock.Mock(paper_trade=False)
        self.base_flumine = BaseFlumine(self.mock_client)

    def test_init(self):
        self.assertFalse(self.base_flumine.BACKTEST)
        self.assertEqual(self.base_flumine.client, self.mock_client)
        self.assertFalse(self.base_flumine._running)
        self.assertEqual(self.base_flumine._market_middleware, [])
        self.assertEqual(self.base_flumine._logging_controls, [])
        self.assertEqual(len(self.base_flumine._trading_controls), 2)
        self.assertEqual(self.base_flumine._workers, [])

    @mock.patch("flumine.baseflumine.SimulatedMiddleware")
    @mock.patch("flumine.baseflumine.BaseFlumine.add_market_middleware")
    def test_init_backtest(self, mock_add_market_middleware,
                           mock_SimulatedMiddleware):
        BaseFlumine.BACKTEST = True
        mock_client = mock.Mock(paper_trade=False)
        BaseFlumine(mock_client)
        mock_add_market_middleware.assert_called_with(
            mock_SimulatedMiddleware())
        BaseFlumine.BACKTEST = False

    @mock.patch("flumine.baseflumine.SimulatedMiddleware")
    @mock.patch("flumine.baseflumine.BaseFlumine.add_market_middleware")
    def test_init_paper_trade(self, mock_add_market_middleware,
                              mock_SimulatedMiddleware):
        mock_client = mock.Mock(paper_trade=True)
        BaseFlumine(mock_client)
        mock_add_market_middleware.assert_called_with(
            mock_SimulatedMiddleware())

    def test_run(self):
        with self.assertRaises(NotImplementedError):
            self.base_flumine.run()

    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test_add_strategy(self, mock_log_control, mock_events):
        mock_strategy = mock.Mock()
        mock_client = mock.Mock()
        self.base_flumine.add_strategy(mock_strategy, mock_client)
        self.assertEqual(len(self.base_flumine.strategies), 1)
        self.assertEqual(len(self.base_flumine.streams), 1)
        mock_log_control.assert_called_with(
            mock_events.StrategyEvent(mock_strategy))

    def test_add_worker(self):
        mock_worker = mock.Mock()
        self.base_flumine.add_worker(mock_worker)
        self.assertEqual(len(self.base_flumine._workers), 1)

    def test_add_client_control(self):
        self.mock_client.trading_controls = []
        mock_control = mock.Mock()
        self.base_flumine.add_client_control(mock_control)
        self.assertEqual(
            self.base_flumine.client.trading_controls,
            [mock_control(self.base_flumine, self.mock_client)],
        )

    def test_add_trading_control(self):
        mock_control = mock.Mock()
        self.base_flumine.add_trading_control(mock_control)
        self.assertEqual(len(self.base_flumine._trading_controls), 3)

    def test_add_market_middleware(self):
        mock_middleware = mock.Mock()
        self.base_flumine.add_market_middleware(mock_middleware)
        self.assertEqual(len(self.base_flumine._market_middleware), 1)

    def test_add_logging_control(self):
        mock_control = mock.Mock()
        self.base_flumine.add_logging_control(mock_control)
        self.assertEqual(len(self.base_flumine._logging_controls), 1)

    def test_log_control(self):
        mock_control = mock.Mock()
        self.base_flumine._logging_controls.append(mock_control)
        mock_event = mock.Mock()
        self.base_flumine.log_control(mock_event)
        mock_control.logging_queue.put.assert_called_with(mock_event)

    def test__add_default_workers(self):
        self.base_flumine._add_default_workers()
        self.assertEqual(len(self.base_flumine._workers), 0)

    def test__process_market_books(self):
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(publish_time_epoch=123)
        mock_market_book.runners = []
        mock_event.event = [mock_market_book]
        self.base_flumine._process_market_books(mock_event)

    def test__process_market_orders(self):
        mock_market = mock.Mock()
        mock_market.blotter.process_orders.return_value = [1, 2, 3]
        self.base_flumine.markets = [mock_market]
        self.base_flumine._process_market_orders()
        mock_market.blotter.process_orders.assert_called_with(self.mock_client)

    def test__process_order_package(self):
        mock_trading_control = mock.Mock()
        self.base_flumine._trading_controls = [mock_trading_control]
        mock_client_trading_control = mock.Mock()
        mock_order_package = mock.Mock()
        mock_order_package.market_id = "1.123"
        mock_order_package.client.trading_controls = [
            mock_client_trading_control
        ]
        self.base_flumine._process_order_package(mock_order_package)
        mock_order_package.client.execution.handler.assert_called_with(
            mock_order_package)
        mock_trading_control.assert_called_with(mock_order_package)
        mock_client_trading_control.assert_called_with(mock_order_package)

    def test__process_order_package_empty(self):
        mock_client_trading_control = mock.Mock()
        mock_order_package = mock.Mock()
        mock_order_package.market_id = "1.123"
        mock_order_package.client.trading_controls = [
            mock_client_trading_control
        ]
        mock_order_package.info = {}
        mock_order_package.orders = []
        self.base_flumine._trading_controls = []
        self.base_flumine._process_order_package(mock_order_package)
        mock_order_package.client.execution.handler.assert_not_called()

    def test__process_order_package_controls(self):
        mock_trading_control = mock.Mock()
        mock_client_control = mock.Mock()
        self.base_flumine._trading_controls = [mock_trading_control]
        mock_client_trading_control = mock.Mock()
        mock_order_package = mock.Mock()
        mock_order_package.market_id = "1.123"
        mock_order_package.client.trading_controls = [
            mock_client_trading_control
        ]
        mock_order_package.info = {}
        mock_order_package.orders = []
        mock_order_package.client.trading_controls = [mock_client_control]
        self.base_flumine._process_order_package(mock_order_package)
        mock_order_package.client.execution.handler.assert_not_called()
        mock_trading_control.assert_called_with(mock_order_package)
        mock_client_control.assert_called_with(mock_order_package)

    @mock.patch("flumine.baseflumine.Market")
    def test__add_market(self, mock_market):
        mock_middleware = mock.Mock()
        self.base_flumine._market_middleware = [mock_middleware]
        mock_market_book = mock.Mock()
        self.assertEqual(
            self.base_flumine._add_market("1.234", mock_market_book),
            mock_market())
        self.assertEqual(len(self.base_flumine.markets._markets), 1)
        mock_middleware.add_market.assert_called_with(mock_market())

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    def test__remove_market(self, _):
        mock_markets = mock.Mock()
        self.base_flumine.markets = mock_markets
        mock_middleware = mock.Mock()
        self.base_flumine._market_middleware = [mock_middleware]
        mock_market = mock.Mock()
        self.base_flumine._remove_market(mock_market)
        mock_markets.remove_market.assert_called_with(mock_market.market_id)
        mock_middleware.remove_market.assert_called_with(mock_market)

    @mock.patch("flumine.baseflumine.BaseFlumine._add_market")
    def test__process_raw_data(self, mock__add_market):
        mock_event = mock.Mock()
        mock_event.event = (12, 12345, [{"id": "1.23"}])
        self.base_flumine._process_raw_data(mock_event)
        mock__add_market.assert_called_with("1.23", None)

    @mock.patch("flumine.baseflumine.BaseFlumine._add_market")
    def test__process_raw_data_closed(self, mock__add_market):
        mock_event = mock.Mock()
        mock_event.event = (
            12,
            12345,
            [{
                "id": "1.23",
                "marketDefinition": {
                    "status": "CLOSED"
                }
            }],
        )
        self.base_flumine._process_raw_data(mock_event)
        mock__add_market.assert_called_with("1.23", None)
        mock__add_market().close_market.assert_called()

    @mock.patch("flumine.baseflumine.BaseFlumine._add_market")
    def test__process_raw_data_no_id(self, mock__add_market):
        mock_event = mock.Mock()
        mock_event.event = (12, 12345, [{"mid": "1.23"}])
        self.base_flumine._process_raw_data(mock_event)
        mock__add_market.assert_not_called()

    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_market_catalogue(self, mock_log_control, mock_events):
        mock_market = mock.Mock()
        mock_market.market_catalogue = None
        mock_markets = mock.Mock()
        mock_markets.markets = {"1.23": mock_market}
        self.base_flumine.markets = mock_markets
        mock_market_catalogue = mock.Mock()
        mock_market_catalogue.market_id = "1.23"
        mock_event = mock.Mock()
        mock_event.event = [mock_market_catalogue]
        self.base_flumine._process_market_catalogues(mock_event)
        self.assertEqual(mock_market.market_catalogue, mock_market_catalogue)
        mock_log_control.assert_called_with(
            mock_events.MarketEvent(mock_market))

    def test__process_current_orders(self):
        mock_event = mock.Mock()
        mock_current_orders = mock.Mock()
        mock_current_orders.orders = []
        mock_event.event = [mock_current_orders]
        self.base_flumine._process_current_orders(mock_event)

    @mock.patch("flumine.baseflumine.BaseFlumine._process_market_orders")
    def test__process_custom_event(self, mock__process_market_orders):
        mock_market = mock.Mock()
        self.base_flumine.markets = [mock_market]
        mock_event = mock.Mock()
        self.base_flumine._process_custom_event(mock_event)
        mock_event.callback.assert_called_with(self.base_flumine, mock_event)
        mock__process_market_orders.assert_called_with()

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_close_market(self, mock_log_control, mock_info):
        mock_strategy = mock.Mock()
        mock_strategy.stream_ids = [1, 2, 3]
        self.base_flumine.strategies = [mock_strategy]
        mock_market = mock.Mock(closed=False, elapsed_seconds_closed=None)
        self.base_flumine.markets._markets = {"1.23": mock_market}
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(market_id="1.23", streaming_unique_id=2)
        mock_event.event = mock_market_book
        self.base_flumine._process_close_market(mock_event)
        mock_market.close_market.assert_called_with()
        mock_market.blotter.process_closed_market.assert_called_with(
            mock_market_book)
        mock_strategy.process_closed_market.assert_called_with(
            mock_market, mock_market_book)
        mock_log_control.assert_called_with(mock_event)
        self.assertEqual(self.base_flumine.cleared_market_queue.get(),
                         mock_market.market_id)

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    def test__process_close_market_no_market(self, mock_info):
        mock_market = mock.Mock(closed=False, elapsed_seconds_closed=None)
        mock_market.market_book.streaming_unique_id = 2
        self.base_flumine.markets._markets = {"1.23": mock_market}
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(market_id="1.45")
        mock_event.event = mock_market_book
        self.base_flumine._process_close_market(mock_event)
        mock_market.close_market.assert_not_called()

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_close_market_closed(self, mock_log_control, mock_info):
        mock_strategy = mock.Mock()
        mock_strategy.stream_ids = [1, 2, 3]
        self.base_flumine.strategies = [mock_strategy]
        mock_market = mock.Mock(closed=False, elapsed_seconds_closed=None)
        mock_market.market_book.streaming_unique_id = 2
        self.base_flumine.markets._markets = {
            "1.23":
            mock_market,
            "4.56":
            mock.Mock(market_id="4.56", closed=True,
                      elapsed_seconds_closed=25),
            "7.89":
            mock.Mock(market_id="7.89",
                      closed=True,
                      elapsed_seconds_closed=3601),
            "1.01":
            mock.Mock(market_id="1.01",
                      closed=False,
                      elapsed_seconds_closed=3601),
        }
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(market_id="1.23")
        mock_event.event = mock_market_book
        self.base_flumine._process_close_market(mock_event)

        self.assertEqual(len(self.base_flumine.markets._markets), 3)

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_close_market_closed_paper(self, mock_log_control,
                                                mock_info):
        self.base_flumine.client.paper_trade = True
        mock_strategy = mock.Mock()
        mock_strategy.stream_ids = [1, 2, 3]
        self.base_flumine.strategies = [mock_strategy]
        mock_market = mock.Mock(closed=False, elapsed_seconds_closed=None)
        mock_market.market_book.streaming_unique_id = 2
        self.base_flumine.markets._markets = {
            "1.23":
            mock_market,
            "4.56":
            mock.Mock(market_id="4.56", closed=True,
                      elapsed_seconds_closed=25),
            "7.89":
            mock.Mock(market_id="7.89",
                      closed=True,
                      elapsed_seconds_closed=3601),
            "1.01":
            mock.Mock(market_id="1.01",
                      closed=False,
                      elapsed_seconds_closed=3601),
        }
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(market_id="1.23")
        mock_event.event = mock_market_book
        self.base_flumine._process_close_market(mock_event)
        self.assertEqual(len(self.base_flumine.markets._markets), 4)

    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    def test__process_cleared_orders(self, mock_info, mock_log_control,
                                     mock_events):
        mock_market = mock.Mock()
        mock_market.blotter.process_cleared_orders.return_value = []
        mock_markets = mock.Mock()
        mock_markets.markets = {"1.23": mock_market}
        self.base_flumine.markets = mock_markets
        mock_event = mock.Mock()
        mock_event.event.market_id = "1.23"
        mock_event.event.orders = []
        self.base_flumine._process_cleared_orders(mock_event)
        mock_market.blotter.process_cleared_orders.assert_called_with(
            mock_event.event)
        mock_log_control.assert_called_with(
            mock_events.ClearedOrdersMetaEvent())

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    def test__process_cleared_orders_no_market(self, mock_info):
        mock_market = mock.Mock()
        mock_markets = mock.Mock()
        mock_markets.markets = {"1.23": mock_market}
        self.base_flumine.markets = mock_markets
        mock_event = mock.Mock()
        mock_event.event.market_id = "1.24"
        mock_event.event.orders = []
        self.base_flumine._process_cleared_orders(mock_event)
        mock_market.blotter.process_cleared_orders.assert_not_called()

    def test__process_cleared_markets(self):
        mock_event = mock.Mock()
        mock_event.event.orders = []
        self.base_flumine._process_cleared_markets(mock_event)

    def test__process_end_flumine(self):
        self.base_flumine._process_end_flumine()

    def test_info(self):
        self.assertTrue(self.base_flumine.info)

    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test_enter_exit(self, mock_log_control, mock_events):
        control = mock.Mock()
        self.base_flumine._logging_controls = [control]
        self.base_flumine.simulated_execution = mock.Mock()
        self.base_flumine.betfair_execution = mock.Mock()
        with self.base_flumine:
            self.assertTrue(self.base_flumine._running)
            self.mock_client.login.assert_called_with()

        self.assertFalse(self.base_flumine._running)
        self.mock_client.logout.assert_called_with()
        self.base_flumine.simulated_execution.shutdown.assert_called_with()
        self.base_flumine.betfair_execution.shutdown.assert_called_with()
        control.start.assert_called_with()
        mock_log_control.assert_called_with(mock_events.TerminationEvent(None))
コード例 #2
0
class BaseFlumineTest(unittest.TestCase):
    def setUp(self):
        self.mock_client = mock.Mock(EXCHANGE=ExchangeType.BETFAIR,
                                     paper_trade=False)
        self.base_flumine = BaseFlumine(self.mock_client)

    def test_init(self):
        self.assertFalse(self.base_flumine.SIMULATED)
        self.assertFalse(self.base_flumine._running)
        self.assertEqual(self.base_flumine._market_middleware, [])
        self.assertEqual(self.base_flumine._logging_controls, [])
        self.assertEqual(len(self.base_flumine.trading_controls), 3)
        self.assertEqual(self.base_flumine._workers, [])

    @mock.patch("flumine.baseflumine.SimulatedMiddleware")
    @mock.patch("flumine.baseflumine.BaseFlumine.add_market_middleware")
    def test_init_simulated(self, mock_add_market_middleware,
                            mock_SimulatedMiddleware):
        BaseFlumine.SIMULATED = True
        mock_client = mock.Mock(EXCHANGE=ExchangeType.SIMULATED,
                                paper_trade=False)
        BaseFlumine(mock_client)
        mock_add_market_middleware.assert_called_with(
            mock_SimulatedMiddleware())
        BaseFlumine.SIMULATED = False

    @mock.patch("flumine.baseflumine.SimulatedMiddleware")
    @mock.patch("flumine.baseflumine.BaseFlumine.add_market_middleware")
    def test_init_paper_trade(self, mock_add_market_middleware,
                              mock_SimulatedMiddleware):
        mock_client = mock.Mock(EXCHANGE=ExchangeType.BETFAIR,
                                paper_trade=True)
        BaseFlumine(mock_client)
        mock_add_market_middleware.assert_called_with(
            mock_SimulatedMiddleware())

    def test_run(self):
        with self.assertRaises(NotImplementedError):
            self.base_flumine.run()

    @mock.patch("flumine.baseflumine.BaseFlumine.add_market_middleware")
    @mock.patch("flumine.baseflumine.BaseFlumine.add_client_control")
    def test_add_client(self, mock_add_client_control,
                        mock_add_market_middleware):
        mock_clients = mock.Mock()
        self.base_flumine.clients = mock_clients
        mock_streams = mock.Mock()
        self.base_flumine.streams = mock_streams
        mock_client = mock.Mock()
        self.base_flumine.add_client(mock_client)
        mock_clients.add_client.assert_called_with(mock_client)
        mock_streams.add_client.assert_called_with(mock_client)
        mock_client.add_execution.assert_called_with(self.base_flumine)
        mock_add_market_middleware.assert_called()
        mock_add_client_control.assert_called_with(mock_client,
                                                   MaxTransactionCount)

    @mock.patch("flumine.baseflumine.BaseFlumine.add_market_middleware")
    @mock.patch("flumine.baseflumine.BaseFlumine.add_client_control")
    def test_add_client_with_middleware(self, mock_add_client_control,
                                        mock_add_market_middleware):
        self.base_flumine._market_middleware.append(SimulatedMiddleware())
        mock_clients = mock.Mock()
        self.base_flumine.clients = mock_clients
        mock_streams = mock.Mock()
        self.base_flumine.streams = mock_streams
        mock_client = mock.Mock()
        self.base_flumine.add_client(mock_client)
        mock_clients.add_client.assert_called_with(mock_client)
        mock_streams.add_client.assert_called_with(mock_client)
        mock_client.add_execution.assert_called_with(self.base_flumine)
        mock_add_market_middleware.assert_not_called()
        mock_add_client_control.assert_called_with(mock_client,
                                                   MaxTransactionCount)

    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test_add_strategy(self, mock_log_control, mock_events):
        mock_streams = mock.Mock()
        self.base_flumine.streams = mock_streams
        mock_strategies = mock.Mock()
        self.base_flumine.strategies = mock_strategies
        mock_strategy = mock.Mock(market_filter={}, sports_data_filter=[])
        self.base_flumine.add_strategy(mock_strategy)
        mock_streams.assert_called_with(mock_strategy)
        mock_strategies.assert_called_with(mock_strategy,
                                           self.base_flumine.clients)
        mock_log_control.assert_called_with(
            mock_events.StrategyEvent(mock_strategy))

    def test_add_worker(self):
        mock_worker = mock.Mock()
        self.base_flumine.add_worker(mock_worker)
        self.assertEqual(len(self.base_flumine._workers), 1)

    def test_add_client_control(self):
        self.mock_client.trading_controls = []
        mock_control = mock.Mock()
        self.base_flumine.add_client_control(self.mock_client, mock_control)
        self.assertEqual(
            self.mock_client.trading_controls,
            [mock_control(self.base_flumine, self.mock_client)],
        )

    def test_add_trading_control(self):
        mock_control = mock.Mock()
        self.base_flumine.add_trading_control(mock_control)
        self.assertEqual(len(self.base_flumine.trading_controls), 4)

    def test_add_market_middleware(self):
        mock_middleware = mock.Mock()
        self.base_flumine.add_market_middleware(mock_middleware)
        self.assertEqual(len(self.base_flumine._market_middleware), 1)

    def test_add_logging_control(self):
        mock_control = mock.Mock()
        self.base_flumine.add_logging_control(mock_control)
        self.assertEqual(len(self.base_flumine._logging_controls), 1)

    def test_log_control(self):
        mock_control = mock.Mock()
        self.base_flumine._logging_controls.append(mock_control)
        mock_event = mock.Mock()
        self.base_flumine.log_control(mock_event)
        mock_control.logging_queue.put.assert_called_with(mock_event)

    def test__add_default_workers(self):
        self.base_flumine._add_default_workers()
        self.assertEqual(len(self.base_flumine._workers), 0)

    def test__process_market_books(self):
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(publish_time_epoch=123)
        mock_market_book.runners = []
        mock_event.event = [mock_market_book]
        self.base_flumine._process_market_books(mock_event)

    @mock.patch("flumine.baseflumine.utils.call_strategy_error_handling")
    def test__process_sports_data(self, mock_call_strategy_error_handling):
        mock_market = mock.Mock()
        self.base_flumine.markets._markets = {"1.1": mock_market}
        mock_strategy_one = mock.Mock(stream_ids=[123])
        mock_strategy_two = mock.Mock(stream_ids=[])
        self.base_flumine.strategies = [
            mock_strategy_one,
            mock_strategy_two,
        ]
        mock_sports_data = mock.Mock(streaming_unique_id=123, market_id="1.1")
        mock_event = mock.Mock(event=[mock_sports_data])
        self.base_flumine._process_sports_data(mock_event)
        mock_call_strategy_error_handling.assert_has_calls([
            mock.call(
                mock_strategy_one.process_sports_data,
                mock_market,
                mock_sports_data,
            )
        ])

    def test_process_order_package(self):
        mock_order_package = mock.Mock()
        self.base_flumine.process_order_package(mock_order_package)
        mock_order_package.client.execution.handler.assert_called_with(
            mock_order_package)

    @mock.patch("flumine.baseflumine.Market")
    def test__add_market(self, mock_market):
        mock_middleware = mock.Mock()
        self.base_flumine._market_middleware = [mock_middleware]
        mock_market_book = mock.Mock()
        self.assertEqual(
            self.base_flumine._add_market("1.234", mock_market_book),
            mock_market())
        self.assertEqual(len(self.base_flumine.markets._markets), 1)
        mock_middleware.add_market.assert_called_with(mock_market())

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    def test__remove_market(self, _):
        mock_strategy = mock.Mock()
        self.base_flumine.strategies = [mock_strategy]
        mock_markets = mock.Mock()
        self.base_flumine.markets = mock_markets
        mock_middleware = mock.Mock()
        self.base_flumine._market_middleware = [mock_middleware]
        mock_market = mock.Mock()
        self.base_flumine._remove_market(mock_market)
        mock_markets.remove_market.assert_called_with(mock_market.market_id)
        mock_middleware.remove_market.assert_called_with(mock_market)
        mock_strategy.remove_market.assert_called_with(mock_market.market_id)

    @mock.patch("flumine.baseflumine.BaseFlumine._add_market")
    def test__process_raw_data(self, mock__add_market):
        mock_event = mock.Mock()
        mock_event.event = (12, "AAA", 12345, [{"id": "1.23"}])
        self.base_flumine._process_raw_data(mock_event)
        mock__add_market.assert_called_with("1.23", None)

    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine._add_market")
    def test__process_raw_data_closed(self, mock__add_market, mock_events):
        mock_queue = mock.Mock()
        self.base_flumine.handler_queue = mock_queue
        mock_event = mock.Mock()
        mock_event.event = (
            12,
            "AAA",
            12345,
            [{
                "id": "1.23",
                "marketDefinition": {
                    "status": "CLOSED"
                }
            }],
        )
        self.base_flumine._process_raw_data(mock_event)
        mock__add_market.assert_called_with("1.23", None)
        mock_queue.put.assert_called_with(mock_events.CloseMarketEvent())
        self.assertEqual(mock_event.event[3][0]["_stream_id"],
                         mock_event.event[0])

    @mock.patch("flumine.baseflumine.BaseFlumine._add_market")
    def test__process_raw_data_no_id(self, mock__add_market):
        mock_event = mock.Mock()
        mock_event.event = (12, "AAA", 12345, [{"mid": "1.23"}])
        self.base_flumine._process_raw_data(mock_event)
        mock__add_market.assert_not_called()

    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_market_catalogues(self, mock_log_control, mock_events):
        mock_market = mock.Mock()
        mock_market.market_catalogue = None
        mock_markets = mock.Mock()
        mock_markets.markets = {"1.23": mock_market}
        self.base_flumine.markets = mock_markets
        mock_market_catalogue = mock.Mock()
        mock_market_catalogue.market_id = "1.23"
        mock_event = mock.Mock()
        mock_event.event = [mock_market_catalogue]
        self.base_flumine._process_market_catalogues(mock_event)
        self.assertEqual(mock_market.market_catalogue, mock_market_catalogue)
        mock_log_control.assert_called_with(
            mock_events.MarketEvent(mock_market))
        self.assertFalse(mock_market.update_market_catalogue)

    @mock.patch("flumine.baseflumine.utils.call_process_orders_error_handling")
    @mock.patch("flumine.baseflumine.process_current_orders")
    def test__process_current_orders(self, mock_process_current_orders,
                                     mock_call_process_orders_error_handling):
        mock_order = mock.Mock(complete=True)
        mock_market = mock.Mock(closed=False)
        mock_market.blotter.active = True
        mock_market.blotter.strategy_orders.return_value = [mock_order]
        self.base_flumine.markets = [mock_market]
        mock_strategy = mock.Mock()
        self.base_flumine.strategies = [mock_strategy]
        mock_current_orders = mock.Mock(orders=[mock_order])
        mock_event = mock.Mock(event=[mock_current_orders])
        self.base_flumine._process_current_orders(mock_event)
        mock_process_current_orders.assert_called_with(
            self.base_flumine.markets,
            self.base_flumine.strategies,
            mock_event,
            self.base_flumine.log_control,
            self.base_flumine._add_market,
        )
        mock_market.blotter.strategy_orders.assert_called_with(mock_strategy)
        mock_call_process_orders_error_handling.assert_called_with(
            mock_strategy, mock_market, [mock_order])

    @mock.patch("flumine.baseflumine.process_current_orders")
    def test__process_current_orders_no_event(self,
                                              mock_process_current_orders):
        mock_event = mock.Mock(event=[])
        self.base_flumine._process_current_orders(mock_event)
        mock_process_current_orders.assert_not_called()

    def test__process_custom_event(self):
        mock_market = mock.Mock()
        self.base_flumine.markets = [mock_market]
        mock_event = mock.Mock()
        self.base_flumine._process_custom_event(mock_event)
        mock_event.callback.assert_called_with(self.base_flumine, mock_event)

    def test__process_custom_event_flu_error(self):
        mock_market = mock.Mock()
        self.base_flumine.markets = [mock_market]
        mock_event = mock.Mock()
        mock_event.callback.side_effect = FlumineException()
        self.base_flumine._process_custom_event(mock_event)
        mock_event.callback.assert_called_with(self.base_flumine, mock_event)

    def test__process_custom_event_error(self):
        mock_market = mock.Mock()
        self.base_flumine.markets = [mock_market]
        mock_event = mock.Mock()
        mock_event.callback.side_effect = ValueError()
        self.base_flumine._process_custom_event(mock_event)
        mock_event.callback.assert_called_with(self.base_flumine, mock_event)

    @mock.patch("flumine.baseflumine.config")
    def test__process_custom_event_error_raise(self, mock_config):
        mock_config.raise_errors = True
        mock_market = mock.Mock()
        self.base_flumine.markets = [mock_market]
        mock_event = mock.Mock()
        mock_event.callback.side_effect = ValueError()
        with self.assertRaises(ValueError):
            self.base_flumine._process_custom_event(mock_event)

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_close_market(self, mock_log_control, mock_info):
        mock_strategy = mock.Mock()
        mock_strategy.stream_ids = [1, 2, 3]
        self.base_flumine.strategies = [mock_strategy]
        mock_market = mock.Mock(closed=False, elapsed_seconds_closed=None)
        self.base_flumine.markets._markets = {"1.23": mock_market}
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(market_id="1.23", streaming_unique_id=2)
        mock_event.event = mock_market_book
        self.base_flumine._process_close_market(mock_event)
        mock_market.close_market.assert_called_with()
        mock_market.blotter.process_closed_market.assert_called_with(
            mock_market_book)
        mock_strategy.process_closed_market.assert_called_with(
            mock_market, mock_market_book)
        mock_log_control.assert_called_with(mock_event)
        mock_market.assert_called_with(mock_market_book)

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_close_market_datum(self, mock_log_control, mock_info):
        mock_strategy = mock.Mock()
        mock_strategy.stream_ids = [1, 2, 3]
        self.base_flumine.strategies = [mock_strategy]
        mock_market = mock.Mock(closed=False, elapsed_seconds_closed=None)
        self.base_flumine.markets._markets = {"1.23": mock_market}
        mock_event = mock.Mock()
        mock_market_book = {"id": "1.23", "_stream_id": 2}
        mock_event.event = mock_market_book
        self.base_flumine._process_close_market(mock_event)
        mock_market.close_market.assert_called_with()
        mock_market.blotter.process_closed_market.assert_not_called()
        mock_strategy.process_closed_market.assert_called_with(
            mock_market, mock_market_book)
        mock_log_control.assert_called_with(mock_event)
        mock_market.assert_not_called()

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    def test__process_close_market_no_market(self, mock_info):
        mock_market = mock.Mock(closed=False, elapsed_seconds_closed=None)
        mock_market.market_book.streaming_unique_id = 2
        self.base_flumine.markets._markets = {"1.23": mock_market}
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(market_id="1.45")
        mock_event.event = mock_market_book
        self.base_flumine._process_close_market(mock_event)
        mock_market.close_market.assert_not_called()

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_close_market_closed(self, mock_log_control, mock_info):
        mock_strategy = mock.Mock()
        mock_strategy.stream_ids = [1, 2, 3]
        self.base_flumine.strategies = [mock_strategy]
        mock_market = mock.Mock(market_id="1.23",
                                event_id="1",
                                closed=False,
                                elapsed_seconds_closed=None)
        mock_market.market_book.streaming_unique_id = 2
        markets = [
            mock_market,
            mock.Mock(market_id="4.56",
                      event_id="1",
                      closed=True,
                      elapsed_seconds_closed=25),
            mock.Mock(market_id="7.89",
                      event_id="1",
                      closed=True,
                      elapsed_seconds_closed=3601),
            mock.Mock(
                market_id="1.01",
                event_id="2",
                closed=False,
                elapsed_seconds_closed=3601,
            ),
        ]
        for market in markets:
            self.base_flumine.markets.add_market(market.market_id, market)
        mock_market_book = mock.Mock(market_id="1.23")
        mock_event = mock.Mock(event=mock_market_book)
        self.base_flumine._process_close_market(mock_event)

        self.assertEqual(len(self.base_flumine.markets._markets), 3)
        self.assertEqual(len(self.base_flumine.markets.events), 2)

    @mock.patch("flumine.baseflumine.BaseFlumine._process_cleared_markets")
    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine._process_cleared_orders")
    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_close_market_closed_paper(
        self,
        mock_log_control,
        mock_info,
        mock__process_cleared_orders,
        mock_events,
        mock__process_cleared_markets,
    ):
        self.mock_client.paper_trade = True
        mock_strategy = mock.Mock()
        mock_strategy.stream_ids = [1, 2, 3]
        self.base_flumine.strategies = [mock_strategy]
        mock_market = mock.Mock(closed=False, elapsed_seconds_closed=None)
        mock_market.market_book.streaming_unique_id = 2
        mock_market.cleared.return_value = {}
        self.base_flumine.markets._markets = {
            "1.23":
            mock_market,
            "4.56":
            mock.Mock(market_id="4.56", closed=True,
                      elapsed_seconds_closed=25),
            "7.89":
            mock.Mock(market_id="7.89",
                      closed=True,
                      elapsed_seconds_closed=3601),
            "1.01":
            mock.Mock(market_id="1.01",
                      closed=False,
                      elapsed_seconds_closed=3601),
        }
        mock_event = mock.Mock()
        mock_market_book = mock.Mock(market_id="1.23")
        mock_event.event = mock_market_book
        self.base_flumine._process_close_market(mock_event)
        self.assertEqual(len(self.base_flumine.markets._markets), 4)
        mock__process_cleared_orders.assert_called_with(
            mock_events.ClearedOrdersEvent())
        mock_market.cleared.assert_called_with(self.mock_client)
        mock__process_cleared_markets.assert_called_with(
            mock_events.ClearedMarketsEvent())

    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    def test__process_cleared_orders(self, mock_info, mock_log_control,
                                     mock_events):
        mock_market = mock.Mock()
        mock_market.blotter.process_cleared_orders.return_value = []
        mock_markets = mock.Mock()
        mock_markets.markets = {"1.23": mock_market}
        self.base_flumine.markets = mock_markets
        mock_event = mock.Mock()
        mock_event.event.market_id = "1.23"
        mock_event.event.orders = []
        self.base_flumine._process_cleared_orders(mock_event)
        mock_market.blotter.process_cleared_orders.assert_called_with(
            mock_event.event)
        mock_log_control.assert_called_with(
            mock_events.ClearedOrdersMetaEvent())

    @mock.patch("flumine.baseflumine.BaseFlumine.info")
    def test__process_cleared_orders_no_market(self, mock_info):
        mock_market = mock.Mock()
        mock_markets = mock.Mock()
        mock_markets.markets = {"1.23": mock_market}
        self.base_flumine.markets = mock_markets
        mock_event = mock.Mock()
        mock_event.event.market_id = "1.24"
        mock_event.event.orders = []
        self.base_flumine._process_cleared_orders(mock_event)
        mock_market.blotter.process_cleared_orders.assert_not_called()

    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test__process_cleared_markets(self, mock_log_control):
        mock_event = mock.Mock()
        mock_event.event.orders = []
        self.base_flumine._process_cleared_markets(mock_event)
        mock_log_control.assert_called_with(mock_event)

    def test__process_end_flumine(self):
        mock_strategies = mock.Mock()
        self.base_flumine.strategies = mock_strategies
        self.base_flumine._process_end_flumine()
        mock_strategies.finish.assert_called_with(self.base_flumine)

    def test_info(self):
        self.assertTrue(self.base_flumine.info)

    def test_enter_no_clients(self):
        self.base_flumine.clients._clients = []
        with self.assertRaises(ClientError):
            with self.base_flumine:
                pass

    @mock.patch("flumine.baseflumine.BaseFlumine._process_end_flumine")
    @mock.patch("flumine.baseflumine.events")
    @mock.patch("flumine.baseflumine.BaseFlumine.log_control")
    def test_enter_exit(self, mock_log_control, mock_events,
                        mock__process_end_flumine):
        control = mock.Mock()
        self.base_flumine._logging_controls = [control]
        self.base_flumine.simulated_execution = mock.Mock()
        self.base_flumine.betfair_execution = mock.Mock()
        with self.base_flumine:
            self.assertTrue(self.base_flumine._running)
            self.mock_client.login.assert_called_with()
            mock_log_control.assert_called_with(mock_events.ConfigEvent(None))

        self.assertFalse(self.base_flumine._running)
        mock__process_end_flumine.assert_called_with()
        self.mock_client.logout.assert_called_with()
        self.base_flumine.simulated_execution.shutdown.assert_called_with()
        self.base_flumine.betfair_execution.shutdown.assert_called_with()
        control.start.assert_called_with()
        mock_log_control.assert_called_with(mock_events.TerminationEvent(None))