Exemple #1
0
    async def liquidation_orders(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            LiquidationOrdersSubscription(Pair('BTC', 'USDT'), callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #2
0
    async def test_best_orderbook_symbol_ticker(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            OrderBookSymbolTickerSubscription(Pair('BTC', 'USDT'), callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #3
0
    async def test_all_liquidation_orders(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            AllMarketLiquidationOrdersSubscription(callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #4
0
    async def test_detph2(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            DepthSubscription(Pair('BTC', 'USDT'), 0, callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #5
0
    async def test_blvt(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            BlvtSubscription(Pair('BTC', 'UP'), callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_price_subscription(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            PricesSubscription([Pair("BTC", "EUR")], callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #7
0
    async def test_candlestick(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            CandlestickSubscription(Pair("BTC", "USDT"), enums.Interval.I_1MIN, callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #8
0
    async def test_trade_subscription(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            TradeSubscription([Pair('BTC', 'USDT')], callbacks = [message_counter.generate_callback(1)]),
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #9
0
    async def test_mark_price(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            MarkPriceSubscription(Pair("BTC", "USDT"), True, callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #10
0
    async def test_mark_price_all(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            MarkPriceAllSubscription(True, callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #11
0
    async def test_all_market_ticker(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            AllMarketTickersSubscription(callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #12
0
    async def test_aggregate_trade(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            AggregateTradeSubscription(Pair("BTC", "USDT"), callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #13
0
    async def test_best_orderbook_ticker(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            OrderBookTickerSubscription(callbacks = [message_counter.generate_callback(10)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #14
0
    async def test_order_book_L2_subscription(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            OrderbookL2Subscription([Pair('BTSE', 'BTC')], depth = 1, callbacks = [message_counter.generate_callback(2)]),
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_market_ticker_subscription(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            MarketTickerSubscription([Pair("BTC", "EUR")], callbacks = [message_counter.generate_callback(2)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #16
0
    async def test_mini_ticker(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            MiniTickerSubscription(Pair('BTC', 'USDT'), callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_order_book_subscription(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            OrderbookSubscription([Pair("BTC", "EUR")], "1", [message_counter.generate_callback(1)]),
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_candlesticks_subscription(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            CandlesticksSubscription([CandlesticksSubscriptionParams(Pair("BTC", "EUR"), enums.TimeUnit.MINUTES, 1)],
                                     callbacks = [message_counter.generate_callback(1)]),
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_multiple_subscription(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            MarketTickerSubscription([Pair("BTC", "EUR")], callbacks = [message_counter.generate_callback(2, name = "MarketTicker")]),
            OrderbookSubscription([Pair("BTC", "EUR")], "1", callbacks = [message_counter.generate_callback(1, name = "Orderbook")])
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_account_subscription(self):
        message_counter = WsMessageCounter()

        self.client.compose_subscriptions([
            AccountSubscription(callbacks = [message_counter.generate_callback(3)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #21
0
    async def test_composite_index(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            CompositeIndexSubscription(Pair('DEFI', 'USDT'),
                                        callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #22
0
    async def blvt_candlesticks(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            BlvtCandlestickSubscription(Pair('BTC', 'UP'), enums.Interval.I_1MIN,
                                        callbacks = [message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter, timeout = 60)
    async def test_liquidation_orders(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            LiquidationOrdersSubscription(
                symbol="BTCUSD_PERP",
                callbacks=[message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_ticker(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            TickerSubscription(
                symbol="BTCUSD_PERP",
                callbacks=[message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_detph2(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            DepthSubscription(symbol="BTCUSD_PERP",
                              level=0,
                              callbacks=[message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
Exemple #26
0
    async def test_order_book_subscription(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            OrderbookSubscription(
                Pair('BTC', 'USD'),
                callbacks=[message_counter.generate_callback(2)]),
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_mark_price(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            MarkPriceSubscription(
                symbol="BTCUSD_PERP",
                frequency1sec=True,
                callbacks=[message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_detph(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            DepthSubscription(symbol=Pair('BTC', 'USDT'),
                              level=0,
                              frequency=100,
                              callbacks=[message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_candlestick(self):
        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            CandlestickSubscription(
                symbol="BTCUSD_PERP",
                interval=enums.Interval.I_1MIN,
                callbacks=[message_counter.generate_callback(1)])
        ])

        await self.assertWsMessageCount(message_counter)
    async def test_order_book_subscription(self):
        ethusdt_id = await self.get_market_id('ETHUSDT')
        print(f'ETHUSDT: {ethusdt_id}')

        message_counter = WsMessageCounter()
        self.client.compose_subscriptions([
            OrderbookSubscription(
                market_ids=[ethusdt_id],
                callbacks=[message_counter.generate_callback(1)]),
        ])

        await self.assertWsMessageCount(message_counter)