fix PriceProvider, add test

proxy/indexer/price_provider.py

@@ -15,16 +15,31 @@
   'agg.status': { 'pos': 224, 'len': 4, 'format': '<I' },
 }
 
+
+def _unpack_field(raw_data: bytes, field_name: str):
+    field = field_info.get(field_name, None)
+    if field is None:
+        raise Exception(f'Unknown field name: {field_name}')
+
+    start_idx = field['pos']
+    stop_idx = field['pos'] + field['len']
+    return struct.unpack(field['format'], raw_data[start_idx:stop_idx])[0]
+
+
 price_accounts = {
     'SOL/USD': 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG'
 }
 
+PRICE_STATUS_UNKNOWN = 0
+PRICE_STATUS_TRADING = 1
+
 class PriceProvider:
     def __init__(self, solana_url, default_upd_int):
-        self.client = client = Client(solana_url)
+        self.client = Client(solana_url)
         self.default_upd_int = default_upd_int
         self.prices = {}
 
+
     def _read_price(self, pairname):
         acc_id = price_accounts.get(pairname, None)
         if acc_id is None:
@@ -56,13 +71,13 @@ def _read_price(self, pairname):
             logger.warning(f'Unknown encoding {encoding}')
             return None
 
-        status = struct.unpack(data, 'agg.status')
-        if status != 1: # not Trading
+        status = _unpack_field(data, 'agg.status')
+        if status != PRICE_STATUS_TRADING: # not Trading
             logger.warning(f'Price status is {status}')
             return None
 
-        expo = struct.unpack(data, 'expo')
-        price = struct.unpack(data, 'agg.price')
+        expo = _unpack_field(data, 'expo')
+        price = _unpack_field(data, 'agg.price')
         return price * pow(10, expo)
 
 

proxy/testing/test_price_provider.py

@@ -0,0 +1,80 @@
+from proxy.indexer.price_provider import PriceProvider, field_info, PRICE_STATUS_TRADING, PRICE_STATUS_UNKNOWN, price_accounts
+from unittest import TestCase
+from unittest.mock import patch, MagicMock, call
+from datetime import datetime
+from solana.rpc.api import Client
+from solana.publickey import PublicKey
+from struct import pack
+from random import uniform
+
+
+class TestPriceProvider(TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        print("Testing PriceProvider")
+        cls.solana_url = 'https://api.mainnet-beta.solana.com' # use contract in mainnet
+        cls.default_upd_int = 10
+
+
+    def setUp(self) -> None:
+        self.price_provider = PriceProvider(self.solana_url,
+                                            self.default_upd_int)
+
+    def _create_price_account_info(self, price: float, status: int):
+        # Follow link https://github.com/pyth-network/pyth-client-rs/blob/main/src/lib.rs
+        # for details on structure of pyth.network price accounts.
+        # Current implementation of PriceProvider uses only few fields of account
+        # so no need to generate all data in tests
+
+        exponent = -8 # use as default
+        # Fill gap between account data begining and expo field with zeros
+        data = b'\x00' * field_info['expo']['pos']
+        data += pack(field_info['expo']['format'], exponent)
+
+        raw_price = int(price / pow(10, exponent))
+        # fill gap between expo and agg.price fields with zeros
+        data += b'\x00' * (field_info['agg.price']['pos'] - len(data))
+        data += pack(field_info['agg.price']['format'], raw_price)
+
+        # fill gap between agg.price and agg.status fields with zeros
+        data += b'\x00' * (field_info['agg.status']['pos'] - len(data))
+        data += pack(field_info['agg.status']['format'], status)
+        # rest of data array is not used by PriceProvier so no need to fill it
+
+        return {
+            'result': {
+                'value': {
+                    'data': [
+                        data,
+                        'base64'
+                    ]
+                }
+            }
+        }
+
+    @patch.object(Client, 'get_account_info')
+    @patch.object(datetime, 'now')
+    def test_success_read_price_two_times_with_small_interval(self, mock_now, mock_get_account_info):
+        print("Should call get_price two times but will cause only one call to get_account_info")
+        mock_nowtime = MagicMock()
+        mock_timestamp = MagicMock()
+        mock_nowtime.timestamp = mock_timestamp
+
+        # some random time
+        first_call_time =  uniform(0, 100000)
+        # not enough time left to cause second account reload
+        second_call_time = first_call_time + self.default_upd_int - 1
+
+        mock_now.side_effect = [mock_nowtime, mock_nowtime]
+        mock_timestamp.side_effect = [ first_call_time, second_call_time]
+
+        current_price = 315.0
+        mock_get_account_info.side_effect = [self._create_price_account_info(current_price, PRICE_STATUS_TRADING)]
+
+        pair_name = 'SOL/USD'
+        self.assertEqual(self.price_provider.get_price(pair_name), current_price)
+        self.assertEqual(self.price_provider.get_price(pair_name), current_price)
+
+        mock_now.assert_has_calls([call(),call()])
+        mock_timestamp.assert_has_calls([call(), call()])
+        mock_get_account_info.assert_called_once_with(PublicKey(price_accounts[pair_name]))