cic cache build

apps/cic-cache/tests/conftest.py

@@ -0,0 +1,86 @@
+# standard imports
+import os
+import sys
+import datetime
+
+# third-party imports
+import pytest
+
+# local imports
+from cic_cache import db
+
+script_dir = os.path.dirname(os.path.realpath(__file__))
+root_dir = os.path.dirname(script_dir)
+sys.path.insert(0, root_dir)
+
+# fixtures
+from tests.fixtures_config import *
+from tests.fixtures_database import *
+from tests.fixtures_celery import *
+
+
+@pytest.fixture(scope='session')
+def balances_dict_fields():
+    return {
+            'out_pending': 0,
+            'out_synced': 1,
+            'out_confirmed': 2,
+            'in_pending': 3,
+            'in_synced': 4,
+            'in_confirmed': 5,
+    }
+
+
+@pytest.fixture(scope='function')
+def txs(
+        init_database,
+        list_defaults,
+        list_actors,
+        list_tokens,
+        ):
+
+    session = init_database
+
+    tx_number = 13 
+    tx_hash_first = '0x' + os.urandom(32).hex()
+    val = 15000
+    nonce = 1
+    dt = datetime.datetime.utcnow()
+    db.add_transaction(
+        session,
+        tx_hash_first,
+        list_defaults['block'],
+        tx_number,
+        list_actors['alice'],
+        list_actors['bob'],
+        list_tokens['foo'],
+        list_tokens['foo'],
+        1024,
+        2048,
+        True,
+        dt.timestamp(),
+            )
+
+
+    tx_number = 42
+    tx_hash_second = '0x' + os.urandom(32).hex()
+    tx_signed_second = '0x' + os.urandom(128).hex()
+    nonce = 1
+    dt -= datetime.timedelta(hours=1)
+    db.add_transaction(
+        session,
+        tx_hash_second,
+        list_defaults['block']-1,
+        tx_number,
+        list_actors['diane'],
+        list_actors['alice'],
+        list_tokens['foo'],
+        list_tokens['foo'],
+        1024,
+        2048,
+        False,
+        dt.timestamp(),
+        )
+    
+    session.commit()
+

apps/cic-cache/tests/fixtures_celery.py

@@ -0,0 +1,48 @@
+# third-party imports
+import pytest
+import tempfile
+import logging
+import shutil
+
+logg = logging.getLogger(__name__)
+
+
+# celery fixtures
+@pytest.fixture(scope='session')
+def celery_includes():
+    return [
+        'cic_cache.tasks.tx',
+    ]
+
+
+@pytest.fixture(scope='session')
+def celery_config():
+    bq = tempfile.mkdtemp()
+    bp = tempfile.mkdtemp()
+    rq = tempfile.mkdtemp()
+    logg.debug('celery broker queue {} processed {}'.format(bq, bp))
+    logg.debug('celery backend store {}'.format(rq))
+    yield {
+        'broker_url': 'filesystem://',
+        'broker_transport_options': {
+            'data_folder_in': bq,
+            'data_folder_out': bq,
+            'data_folder_processed': bp,
+            },
+        'result_backend': 'file://{}'.format(rq),
+            }
+    logg.debug('cleaning up celery filesystem backend files {} {} {}'.format(bq, bp, rq))
+    shutil.rmtree(bq)
+    shutil.rmtree(bp)
+    shutil.rmtree(rq)
+
+
+@pytest.fixture(scope='session')
+def celery_worker_parameters():
+    return {
+#            'queues': ('cic-cache'),
+            }
+
+@pytest.fixture(scope='session')
+def celery_enable_logging():
+    return True

apps/cic-cache/tests/fixtures_config.py

@@ -0,0 +1,20 @@
+# standard imports
+import os
+import logging
+
+# third-party imports
+import pytest
+import confini
+
+script_dir = os.path.dirname(os.path.realpath(__file__))
+root_dir = os.path.dirname(script_dir)
+logg = logging.getLogger(__file__)
+
+
+@pytest.fixture(scope='session')
+def load_config():
+    config_dir = os.path.join(root_dir, '.config/test')
+    conf = confini.Config(config_dir, 'CICTEST')
+    conf.process()
+    logg.debug('config {}'.format(conf))
+    return conf

apps/cic-cache/tests/fixtures_database.py

@@ -0,0 +1,118 @@
+# standard imports
+import os
+import logging
+import re
+
+# third-party imports
+import pytest
+import sqlparse
+
+# local imports
+from cic_cache.db.models.base import SessionBase
+from cic_cache.db import dsn_from_config
+
+logg = logging.getLogger(__file__)
+
+
+@pytest.fixture(scope='function')
+def database_engine(
+    load_config,
+        ):
+    if load_config.get('DATABASE_ENGINE') == 'sqlite':
+        SessionBase.transactional = False
+        SessionBase.poolable = False
+        try:
+            os.unlink(load_config.get('DATABASE_NAME'))
+        except FileNotFoundError:
+            pass
+    dsn = dsn_from_config(load_config)
+    SessionBase.connect(dsn)
+    return dsn
+
+
+# TODO: use alembic instead to migrate db, here we have to keep separate schema than migration script in script/migrate.py
+@pytest.fixture(scope='function')
+def init_database(
+        load_config,
+        database_engine,
+        ):
+
+    rootdir = os.path.dirname(os.path.dirname(__file__))
+    schemadir = os.path.join(rootdir, 'db', load_config.get('DATABASE_DRIVER'))
+
+    if load_config.get('DATABASE_ENGINE') == 'sqlite':
+        rconn = SessionBase.engine.raw_connection()
+        f = open(os.path.join(schemadir, 'db.sql'))
+        s = f.read()
+        f.close()
+        rconn.executescript(s)
+
+    else:
+        rconn = SessionBase.engine.raw_connection()
+        rcursor = rconn.cursor()
+
+        #rcursor.execute('DROP FUNCTION IF EXISTS public.transaction_list')
+        #rcursor.execute('DROP FUNCTION IF EXISTS public.balances')
+
+        f = open(os.path.join(schemadir, 'db.sql'))
+        s = f.read()
+        f.close()
+        r = re.compile(r'^[A-Z]', re.MULTILINE)
+        for l in sqlparse.parse(s):
+            strl = str(l)
+            # we need to check for empty query lines, as sqlparse doesn't do that on its own (and psycopg complains when it gets them)
+            if not re.search(r, strl):
+                logg.warning('skipping parsed query line {}'.format(strl))
+                continue
+            rcursor.execute(strl)
+        rconn.commit()
+
+        rcursor.execute('SET search_path TO public')
+
+# this doesn't work when run separately, no idea why
+# functions have been manually added to original schema from cic-eth 
+#        f = open(os.path.join(schemadir, 'proc_transaction_list.sql'))
+#        s = f.read()
+#        f.close()
+#        rcursor.execute(s)
+# 
+#        f = open(os.path.join(schemadir, 'proc_balances.sql'))
+#        s = f.read()
+#        f.close()
+#        rcursor.execute(s)
+
+        rcursor.close()
+
+    session = SessionBase.create_session()
+    yield session
+    session.commit()
+    session.close()
+
+
+@pytest.fixture(scope='function')
+def list_tokens(
+        ):
+    return {
+            'foo': '0x' + os.urandom(20).hex(),
+            'bar': '0x' + os.urandom(20).hex(),
+        }
+
+
+@pytest.fixture(scope='function')
+def list_actors(
+        ):
+    return {
+            'alice': '0x' + os.urandom(20).hex(),
+            'bob': '0x' + os.urandom(20).hex(),
+            'charlie': '0x' + os.urandom(20).hex(),
+            'diane': '0x' + os.urandom(20).hex(),
+            }
+
+
+@pytest.fixture(scope='function')
+def list_defaults(
+        ):
+
+    return {
+        'block': 420000,
+    }

apps/cic-cache/tests/test_cache.py

@@ -0,0 +1,35 @@
+# standard imports
+import os
+import datetime
+import logging
+import json
+
+# third-party imports
+import pytest
+
+# local imports
+from cic_cache import BloomCache
+
+logg = logging.getLogger()
+
+
+def test_cache(
+        init_database,
+        list_defaults,
+        list_actors,
+        list_tokens,
+        txs,
+        ):
+
+    session = init_database
+
+    c = BloomCache(session)
+    b = c.load_transactions(0, 100)
+
+    assert b[0] == list_defaults['block'] - 1
+
+    c = BloomCache(session)
+    c.load_transactions_account(list_actors['alice'],0, 100)
+
+    assert b[0] == list_defaults['block'] - 1
+

apps/cic-cache/tests/test_task.py

@@ -0,0 +1,27 @@
+# standard imports
+import logging
+
+# third-party imports
+import celery
+
+# local imports
+from cic_cache.api import Api
+
+logg = logging.getLogger()
+
+
+def test_task(
+        init_database,
+        list_defaults,
+        list_actors,
+        list_tokens,
+        txs,
+        celery_session_worker,
+        ):
+
+    api = Api(queue=None)
+    t = api.list(0, 100)
+    r = t.get()
+    logg.debug('r {}'.format(r))
+
+    assert r['low'] == list_defaults['block'] - 1