def test_cleared_orders(self):
        mock_response = create_mock_json('tests/resources/list_cleared_orders.json')
        cleared_orders = mock_response.json().get('result')
        resource = resources.ClearedOrders(date_time_sent=self.DATE_TIME_SENT,
                                           **cleared_orders)
        assert resource._datetime_sent == self.DATE_TIME_SENT
        assert len(resource.orders) == len(cleared_orders.get('clearedOrders'))

        for cleared_order in cleared_orders.get('clearedOrders'):
            assert resource.orders[0].bet_id == cleared_order['betId']
    def test_cleared_orders(self):
        mock_response = create_mock_json('tests/resources/list_cleared_orders.json')
        cleared_orders = mock_response.json().get('result')
        resource = resources.ClearedOrders(elapsed_time=self.ELAPSED_TIME,
                                           **cleared_orders)
        assert resource.elapsed_time == self.ELAPSED_TIME
        assert len(resource.orders) == len(cleared_orders.get('clearedOrders'))

        for cleared_order in cleared_orders.get('clearedOrders'):
            assert resource.orders[0].bet_id == cleared_order['betId']
Пример #3
0
    def _process_close_market(self, event: events.CloseMarketEvent) -> None:
        market_book = event.event
        if isinstance(market_book, dict):
            recorder = True
            market_id = market_book["id"]
            stream_id = market_book["_stream_id"]
        else:
            recorder = False
            market_id = market_book.market_id
            stream_id = market_book.streaming_unique_id
        market = self.markets.markets.get(market_id)
        if market is None:
            logger.warning(
                "Market %s not present when closing" % market_id,
                extra={
                    "market_id": market_id,
                    **self.info
                },
            )
            return
        if market.closed is False:
            market.close_market()
        if recorder is False:
            market.blotter.process_closed_market(event.event)

        for strategy in self.strategies:
            if stream_id in strategy.stream_ids:
                strategy.process_closed_market(market, event.event)

        if recorder is False:
            if self.BACKTEST or self.client.paper_trade:
                cleared_orders = resources.ClearedOrders(clearedOrders=[],
                                                         moreAvailable=False)
                cleared_orders.market_id = market_id
                self._process_cleared_orders(
                    events.ClearedOrdersEvent(cleared_orders))
        self.log_control(event)
        logger.info("Market closed",
                    extra={
                        "market_id": market_id,
                        **self.info
                    })

        # check for markets that have been closed for x seconds and remove
        if (self.BACKTEST is False and self.client.paper_trade is False
            ):  # due to monkey patching this will clear backtested markets
            closed_markets = [
                m for m in self.markets
                if m.closed and m.elapsed_seconds_closed
                and m.elapsed_seconds_closed > 3600
            ]
            for market in closed_markets:
                self._remove_market(market)