(feat) Add pytest-grpc plugin to mock grpc iteractions

Author: aarmoa

Pipfile

@@ -23,6 +23,7 @@ websockets = "*"
 [dev-packages]
 pytest = "*"
 pytest-asyncio = "*"
+pytest-grpc = "*"
 
 [requires]
 python_version = "3"

Pipfile.lock

@@ -1,12 +1,14 @@
-import os
+import asyncio
 import time
 import grpc
 import aiocron
-import logging
 import datetime
+from decimal import Decimal
 from http.cookies import SimpleCookie
-from typing import List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union
 
+from .core.market import Market
+from .core.token import Token
 from .exceptions import NotFoundError, EmptyMsgError
 
 from .proto.cosmos.base.abci.v1beta1 import abci_pb2 as abci_type
@@ -179,6 +181,11 @@ def __init__(
             start=True,
         )
 
+        self._tokens_and_markets_initialization_lock = asyncio.Lock()
+        self._tokens: Optional[Dict[str, Token]] = None
+        self._spot_markets: Optional[Dict[str, Market]] = None
+        self._derivative_markets: Optional[Dict]
+
     def get_sequence(self):
         current_seq = self.sequence
         self.sequence += 1
@@ -976,7 +983,7 @@ async def get_funding_rates(self, market_id: str, **kwargs):
             skip=kwargs.get("skip"),
             limit=kwargs.get("limit"),
             end_time=kwargs.get("end_time"),
-)
+        )
         return await self.stubDerivativeExchange.FundingRates(req)
 
     async def get_binary_options_markets(self, **kwargs):
@@ -1006,3 +1013,57 @@ async def stream_account_portfolio(self, account_address: str, **kwargs):
         )
         metadata = await self.load_cookie(type="exchange")
         return self.stubPortfolio.StreamAccountPortfolio.__call__(req, metadata=metadata)
+
+    async def _initialize_tokens_and_markets(self):
+        markets = dict()
+        tokens = dict()
+        markets_info = (await self.get_spot_markets()).markets
+
+        for market_info in markets_info:
+            base_token = tokens.get(market_info.base_token.symbol)
+            if base_token is None:
+                base_token = Token(
+                    name=market_info.base_token.name,
+                    symbol=market_info.base_token.symbol,
+                    decimals=market_info.base_token.decimals,
+                    logo=market_info.base_token.logo,
+                )
+                tokens[base_token.symbol] = base_token
+            base_token.add_source(
+                denom=market_info.base_denom,
+                symbol=market_info.base_token.symbol,
+                address=market_info.base_token.address,
+                decimals=market_info.base_token.decimals,
+                updated=market_info.base_token.updated_at,
+            )
+
+            quote_token = tokens.get(market_info.base_token.symbol)
+            if quote_token is None:
+                quote_token = Token(
+                    name=market_info.quote_token.name,
+                    symbol=market_info.quote_token.symbol,
+                    decimals=market_info.quote_token.decimals,
+                    logo=market_info.quote_token.logo,
+                )
+            quote_token.add_source(
+                denom=market_info.quote_denom,
+                symbol=market_info.quote_token.symbol,
+                address=market_info.quote_token.address,
+                decimals=market_info.quote_token.decimals,
+                updated=market_info.quote_token.updated_at,
+            )
+
+            market = Market(
+                id=market_info.market_id,
+                status=market_info.market_status,
+                ticker=market_info.ticker,
+                base_token=base_token,
+                quote_token=quote_token,
+                maker_fee_rate=Decimal(market_info.maker_fee_rate),
+                taker_fee_rate=Decimal(market_info.taker_fee_rate),
+                service_provider_fee=Decimal(market_info.service_provider_fee),
+                min_price_tick_size=Decimal(market_info.min_price_tick_size),
+                min_quantity_tick_size=Decimal(market_info.min_quantity_tick_size),
+            )
+
+            markets[market.id] = market

pyinjective/async_client.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from decimal import Decimal
+
+from pyinjective.core.token import Token
+
+
+@dataclass
+class Market:
+    id: str
+    status: str
+    ticker: str
+    base_token: Token
+    quote_token: Token
+    maker_fee_rate: Decimal
+    taker_fee_rate: Decimal
+    service_provider_fee: Decimal
+    min_price_tick_size: Decimal
+    min_quantity_tick_size: Decimal

pyinjective/core/__init__.py

@@ -0,0 +1,46 @@
+from typing import Dict
+
+
+class TokenSource:
+
+    def __init__(
+        self,
+        denom: str,
+        symbol: str,
+        address: str,
+        decimals: int,
+        updated: int,
+    ):
+        self.denom = denom
+        self.symbol = symbol
+        self.address = address
+        self.decimals = decimals
+        self.updated = updated
+
+
+class Token:
+
+    def __init__(
+        self,
+        name: str,
+        symbol: str,
+        decimals: int,
+        logo: str,
+    ):
+        self.name = name
+        self.symbol = symbol
+        self.decimals = decimals
+        self.logo = logo
+
+        self._sources = Dict[str, TokenSource]
+
+    def add_source(self, denom: str, symbol: str, address: str, decimals: int, updated: int):
+        if denom not in self._sources:
+            token_source = TokenSource(
+                denom=denom,
+                symbol=symbol,
+                address=address,
+                decimals=decimals,
+                updated=updated,
+            )
+            self._sources[denom] = token_source

pyinjective/core/market.py

@@ -40,6 +40,7 @@
 DEV_REQUIRED = [
     "pytest",
     "pytest-asyncio",
+    "pytest-grpc",
 ]
 
 # The rest you shouldn't have to touch too much :)

pyinjective/core/token.py

@@ -4,7 +4,33 @@
 from pyinjective.constant import Network
 
 from pyinjective.async_client import AsyncClient
+from pyinjective.proto.exchange.injective_spot_exchange_rpc_pb2 import (
+    MarketRequest,
+    MarketsRequest,
+    MarketResponse,
+    MarketsResponse,
+)
+from tests.rpc_fixtures.markets_fixtures import inj_token_meta, ape_token_meta, usdt_token_meta, inj_usdt_spot_market, ape_usdt_spot_market
 
+@pytest.fixture(scope='module')
+def grpc_add_to_server():
+    from pyinjective.proto.exchange.injective_spot_exchange_rpc_pb2_grpc import add_InjectiveSpotExchangeRPCServicer_to_server
+
+    return add_InjectiveSpotExchangeRPCServicer_to_server
+
+
+@pytest.fixture(scope='module')
+def grpc_servicer():
+    from tests.rpc_fixtures.configurable_servicers import ConfigurableInjectiveSpotExchangeRPCServicer
+
+    return ConfigurableInjectiveSpotExchangeRPCServicer()
+
+
+@pytest.fixture(scope='module')
+def grpc_stub_cls(grpc_channel):
+    from pyinjective.proto.exchange.injective_spot_exchange_rpc_pb2_grpc import InjectiveSpotExchangeRPCStub
+
+    return InjectiveSpotExchangeRPCStub
 
 class TestAsyncClient:
 
@@ -81,4 +107,34 @@ async def test_get_account_logs_exception(self, caplog):
         )
         assert (found_log is not None)
         assert (found_log[0] == "pyinjective.async_client.AsyncClient")
-        assert (found_log[1] == logging.DEBUG)
+        assert (found_log[1] == logging.DEBUG)
+
+    @pytest.mark.asyncio
+    async def test_initialize_tokens_and_markets(
+            self,
+            grpc_stub,
+            grpc_servicer,
+            inj_usdt_spot_market,
+            ape_usdt_spot_market
+    ):
+        grpc_servicer.markets_queue.append(MarketsResponse(
+            markets=[inj_usdt_spot_market, ape_usdt_spot_market]
+        ))
+
+        client = AsyncClient(
+            network=Network.local(),
+            insecure=False,
+        )
+
+        client.stubSpotExchange = grpc_stub
+
+        await client._initialize_tokens_and_markets()
+
+        assert(3 == len(client.tokens))
+        assert(any((inj_usdt_spot_market.base_token_meta.symbol == token.symbol for token in client.tokens)))
+        assert (any((inj_usdt_spot_market.quote_token_meta.symbol == token.symbol for token in client.tokens)))
+        assert (any((ape_usdt_spot_market.base_token_meta.symbol == token.symbol for token in client.tokens)))
+
+        assert (2 == len(client.markets))
+        assert (any((inj_usdt_spot_market.market_id == market.id for market in client.markets)))
+        assert (any((ape_usdt_spot_market.market_id == market.id for market in client.markets)))

setup.py

@@ -0,0 +1,18 @@
+from collections import deque
+
+from pyinjective.proto.exchange.injective_spot_exchange_rpc_pb2 import (
+    MarketsRequest,
+    MarketsResponse,
+)
+from pyinjective.proto.exchange.injective_spot_exchange_rpc_pb2_grpc import InjectiveSpotExchangeRPCServicer
+
+
+class ConfigurableInjectiveSpotExchangeRPCServicer(InjectiveSpotExchangeRPCServicer):
+
+    def __init__(self):
+        super().__init__()
+        self.markets_queue = deque()
+
+    def Markets(self, request: MarketsRequest, context):
+        return self.markets_queue.pop()
+