Rehabilitate db unit tests

apps/cic-eth/tests/unit/db/test_block_sync.py

@@ -0,0 +1,29 @@
+# standard imports
+import logging
+
+# local imports
+from cic_eth.db.models.otx import OtxSync
+
+logg = logging.getLogger()
+
+
+def test_db_block_sync(
+        init_database,
+        ):
+
+    s = OtxSync('eip155:8995:bloxberg')
+
+    s.head(666, 12)
+    assert s.head() == (666, 12)
+
+    s.session(42, 13)
+    assert s.session() == (42, 13)
+
+    s.backlog(13, 2)
+    assert s.backlog() == (13, 2)
+
+    assert not s.synced
+
+    s.backlog(42, 13)
+    assert s.backlog() == (42, 13)
+    assert s.synced

apps/cic-eth/tests/unit/db/test_db_convert_transfer.py

@@ -0,0 +1,29 @@
+import os
+import logging
+
+import pytest
+
+from cic_eth.db import TxConvertTransfer
+from cic_eth.db.error import UnknownConvertError
+
+logg = logging.getLogger()
+
+
+def test_convert_transfer(
+        init_database,
+        default_chain_spec,
+        ):
+
+    tx_hash_hex = '0x' + os.urandom(32).hex()
+    recipient = '0x' + os.urandom(20).hex()
+    txct = TxConvertTransfer(tx_hash_hex, recipient, str(default_chain_spec))
+    init_database.add(txct)
+    init_database.commit()
+
+    txct = TxConvertTransfer.get(tx_hash_hex)
+    
+    assert txct.convert_tx_hash == tx_hash_hex
+
+    tx_hash_bogus_hex = '0x' + os.urandom(32).hex()
+    with pytest.raises(UnknownConvertError):
+        TxConvertTransfer.get(tx_hash_bogus_hex)

apps/cic-eth/tests/unit/db/test_debug.py

@@ -0,0 +1,16 @@
+# local imports
+from cic_eth.db.models.debug import Debug
+
+
+def test_debug(
+        init_database,
+        ):
+
+    o = Debug('foo', 'bar')
+    init_database.add(o)
+    init_database.commit()
+
+    q = init_database.query(Debug)
+    q = q.filter(Debug.tag=='foo')
+    o = q.first()
+    assert o.description == 'bar'

apps/cic-eth/tests/unit/db/test_default.py

@@ -0,0 +1,5 @@
+def test_db_init(
+        init_database,
+        ):
+    pass
+

apps/cic-eth/tests/unit/db/test_enum.py

@@ -0,0 +1,20 @@
+from cic_eth.db.enum import (
+        StatusEnum,
+        StatusBits,
+        status_str,
+        )
+
+
+def test_status_str():
+
+    # String representation for a status in StatusEnum
+    s = status_str(StatusEnum.REVERTED)
+    assert s == 'REVERTED'
+
+    # String representation for a status not in StatusEnum
+    s = status_str(StatusBits.LOCAL_ERROR | StatusBits.NODE_ERROR)
+    assert s == 'LOCAL_ERROR,NODE_ERROR*'
+
+    # String representation for a status in StatusEnum, but bits only representation bit set
+    s = status_str(StatusEnum.REVERTED, bits_only=True)
+    assert s == 'IN_NETWORK,NETWORK_ERROR,FINAL'

apps/cic-eth/tests/unit/db/test_lock.py

@@ -0,0 +1,67 @@
+# standard imports
+import os
+
+# local imports
+from cic_eth.db.models.lock import Lock
+from cic_eth.db.enum import LockEnum
+
+
+def test_lock(
+        init_database,
+        default_chain_spec,
+        ):
+
+    chain_str = str(default_chain_spec) 
+
+    # Check matching flag for global (zero-address) lock
+    a = 0xffffffffffffffff & LockEnum.CREATE
+    r = Lock.set(chain_str, a)
+    assert r == a
+    assert Lock.check(chain_str, a) > 0
+
+    # Check matching flag for address specific lock
+    address = '0x' + os.urandom(20).hex()
+    b = 0xffffffffffffffff & (LockEnum.QUEUE | LockEnum.SEND)
+    Lock.set(chain_str, b, address=address)
+    assert Lock.check(chain_str, b, address=address) == b
+    assert Lock.check(chain_str, a, address=address) == 0
+    assert Lock.check(chain_str, b & LockEnum.QUEUE, address=address) == LockEnum.QUEUE
+    assert Lock.check(chain_str, b) == 0
+
+    # Reset single flag
+    r = Lock.reset(chain_str, LockEnum.QUEUE, address=address)
+    assert r == LockEnum.SEND
+
+    # Reset to 0
+    r = Lock.reset(chain_str, LockEnum.SEND, address=address)
+    assert r == 0
+    
+    # Row should be deleted when flags value reaches 0
+    q = init_database.query(Lock)
+    q = q.filter(Lock.address==address)
+    assert q.first() == None
+
+
+
+def test_lock_merge_check(
+        init_database,
+        default_chain_spec,
+        ):
+
+    chain_str = str(default_chain_spec) 
+
+    foo_address = '0x' + os.urandom(20).hex()
+    bar_address = '0x' + os.urandom(20).hex()
+
+    Lock.set(chain_str, LockEnum.CREATE)
+    assert Lock.check_aggregate(chain_str, LockEnum.CREATE, address=foo_address) > 0
+    assert Lock.check_aggregate(chain_str, LockEnum.CREATE, address=bar_address) > 0
+
+
+    Lock.set(chain_str, LockEnum.CREATE, address=foo_address)
+    assert Lock.check_aggregate(chain_str, LockEnum.CREATE, address=foo_address) > 0
+    assert Lock.check_aggregate(chain_str, LockEnum.CREATE, address=bar_address) > 0
+
+    Lock.reset(chain_str, LockEnum.CREATE)
+    assert Lock.check_aggregate(chain_str, LockEnum.CREATE, address=foo_address) > 0
+    assert Lock.check_aggregate(chain_str, LockEnum.CREATE, address=bar_address) == 0

apps/cic-eth/tests/unit/db/test_nonce_db.py

@@ -0,0 +1,76 @@
+# third-party imports
+import pytest
+import uuid
+
+# local imports
+from cic_eth.db.models.nonce import (
+        Nonce,
+        NonceReservation,
+        )
+from cic_eth.error import (
+        InitializationError,
+        IntegrityError,
+        )
+
+
+def test_nonce_init(
+        init_database,
+        eth_empty_accounts,
+        ):
+
+    nonce = Nonce.init(eth_empty_accounts[0], 42, session=init_database)
+    init_database.commit()
+
+    with pytest.raises(InitializationError):
+        nonce = Nonce.init(eth_empty_accounts[0], 42, session=init_database)
+
+
+def test_nonce_increment(
+        init_database,
+        eth_empty_accounts,
+        database_engine,
+        ):
+
+    nonce = Nonce.next(eth_empty_accounts[0], 3)
+    assert nonce == 3
+
+    nonce = Nonce.next(eth_empty_accounts[0], 3)
+    assert nonce == 4
+
+
+def test_nonce_reserve(
+        init_database,
+        eth_empty_accounts,
+    ):
+   
+    nonce = Nonce.init(eth_empty_accounts[0], 42, session=init_database)
+    init_database.commit()
+    uu = uuid.uuid4()
+    nonce = NonceReservation.next(eth_empty_accounts[0], str(uu), session=init_database)
+    init_database.commit()
+    assert nonce == 42
+
+    q = init_database.query(Nonce)
+    q = q.filter(Nonce.address_hex==eth_empty_accounts[0])
+    o = q.first()
+    assert o.nonce == 43
+
+    nonce = NonceReservation.release(eth_empty_accounts[0], str(uu))
+    init_database.commit()
+    assert nonce == 42
+
+    q = init_database.query(NonceReservation)
+    q = q.filter(NonceReservation.key==str(uu))
+    o = q.first()
+    assert o == None
+
+
+def test_nonce_reserve_integrity(
+        init_database,
+        eth_empty_accounts,
+        ):
+
+    uu = uuid.uuid4()
+    nonce = Nonce.init(eth_empty_accounts[0], 42, session=init_database)
+    with pytest.raises(IntegrityError):
+        NonceReservation.release(eth_empty_accounts[0], str(uu))

apps/cic-eth/tests/unit/db/test_otx.py

@@ -0,0 +1,107 @@
+# standard imports
+import os
+import logging
+
+# third-party imports
+import pytest
+
+# local imports
+from cic_eth.db.models.base import SessionBase
+from cic_eth.db.models.otx import OtxStateLog
+from cic_eth.db.models.otx import Otx
+from cic_eth.db.enum import (
+        StatusEnum,
+        StatusBits,
+        is_alive,
+        )
+
+logg = logging.getLogger()
+
+
+#def test_get(
+#        rpc_eth,
+#        rpc_signer,
+#        agent_roles,
+#        init_database,
+#        ):
+#
+#    rpc = RPCConnection.connect(default_chain_spec, 'default')
+#    nonce_oracle = RPCNonceOracle(agent_roles['ALICE'])
+#    gas_oracle = RPCGasOracle(eth_rpc)
+#    c = Gas(signer=eth_signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle, chain_id=default_chain_spec.chain_id())
+#
+#    for i in range(10):
+#
+#        (tx_hash_hex, tx_rpc) = c.create(agent_roles['ALICE'], agent_roles['BOB'], 100 * (10 ** 6)),
+#
+#        tx_def = {
+#                'from': init_w3.eth.accounts[0],
+#                'to': init_w3.eth.accounts[1],
+#                'nonce': 0,
+#                'value': 101,
+#                'gasPrice': 2000000000,
+#                'gas': 21000,
+#                'data': '',
+#                'chainId': 1,
+#                }
+#
+#        session = init_database
+#        txs = []
+#        for i in range(10):
+#            nonce = init_w3.eth.getTransactionCount(init_w3.eth.accounts[0], 'pending')
+#            tx_def['nonce'] = nonce
+#            tx = init_w3.eth.sign_transaction(tx_def)
+#            tx_hash = init_w3.eth.send_raw_transaction(tx['raw'])
+#            logg.debug('tx {}'.format(tx))
+#
+#            address = init_w3.eth.accounts[i%3]
+#            otx = Otx(int((i/3)+1), address, '0x'+tx_hash.hex(), tx['raw'])
+#            txs.append(otx)
+#            session.add(otx)
+#            session.flush()
+#
+#        logg.debug(txs)
+#        session.commit()
+#
+#        txs[0].status = 0
+#        session.add(txs[0])
+#        session.commit()
+#        session.close()
+#        
+#        get_txs = Otx.get()
+#        logg.debug(get_txs)
+
+
+def test_state_log(
+        init_database,
+        ):
+
+    Otx.tracing = True
+
+    address = '0x' + os.urandom(20).hex()
+    tx_hash = '0x' + os.urandom(32).hex()
+    signed_tx = '0x' + os.urandom(128).hex()
+    otx = Otx.add(0, address, tx_hash, signed_tx, session=init_database)
+
+    otx.waitforgas(session=init_database)
+    init_database.commit()
+
+    otx.readysend(session=init_database)
+    init_database.commit()
+
+    otx.sent(session=init_database)
+    init_database.commit()
+
+    otx.success(1024, session=init_database)
+    init_database.commit()
+
+    q = init_database.query(OtxStateLog)
+    q = q.filter(OtxStateLog.otx_id==otx.id)
+    q = q.order_by(OtxStateLog.date.asc())
+    logs = q.all()
+    
+    assert logs[0].status == StatusEnum.PENDING
+    assert logs[1].status == StatusEnum.WAITFORGAS
+    assert logs[2].status & StatusBits.QUEUED
+    assert logs[3].status & StatusBits.IN_NETWORK
+    assert not is_alive(logs[4].status)

apps/cic-eth/tests/unit/db/test_role.py

@@ -0,0 +1,29 @@
+# local imports
+from cic_eth.db.models.role import AccountRole
+
+def test_db_role(
+        init_database,
+        eth_empty_accounts,
+        ):
+
+    foo = AccountRole.set('foo', eth_empty_accounts[0])
+    init_database.add(foo)
+    init_database.commit()
+    assert AccountRole.get_address('foo', init_database) == eth_empty_accounts[0]
+
+    bar = AccountRole.set('bar', eth_empty_accounts[1])
+    init_database.add(bar)
+    init_database.commit()
+    assert AccountRole.get_address('bar', init_database) == eth_empty_accounts[1]
+
+    foo = AccountRole.set('foo', eth_empty_accounts[2])
+    init_database.add(foo)
+    init_database.commit()
+    assert AccountRole.get_address('foo', init_database) == eth_empty_accounts[2]
+    assert AccountRole.get_address('bar', init_database) == eth_empty_accounts[1]
+
+    tag = AccountRole.role_for(eth_empty_accounts[2])
+    assert tag == 'foo'
+
+    tag = AccountRole.role_for(eth_empty_accounts[3])
+    assert tag == None

apps/cic-eth/tests/unit/db/test_status.py

@@ -0,0 +1,97 @@
+# standard imports
+import os
+
+# third-party imports
+import pytest
+
+# local imports
+from cic_eth.db.models.otx import Otx
+from cic_eth.db.enum import (
+        StatusEnum,
+        StatusBits,
+        is_alive,
+        )
+
+
+@pytest.fixture(scope='function')
+def otx(
+        init_database,
+        ):
+
+    bogus_hash = '0x' + os.urandom(32).hex()
+    bogus_address = '0x' + os.urandom(20).hex()
+    bogus_tx_raw = '0x' + os.urandom(128).hex()
+    return Otx(0, bogus_address, bogus_hash, bogus_tx_raw)
+
+
+def test_status_chain_gas(
+        init_database,
+        otx,
+        ):
+
+    otx.waitforgas(init_database)
+    otx.readysend(init_database)
+    otx.sent(init_database)
+    otx.success(1024, init_database)
+    assert not is_alive(otx.status)
+
+
+def test_status_chain_straight_success(
+        init_database,
+        otx,
+        ):
+
+    otx.readysend(init_database)
+    otx.sent(init_database)
+    otx.success(1024, init_database)
+    assert not is_alive(otx.status)
+
+
+def test_status_chain_straight_revert(
+        init_database,
+        otx,
+        ):
+
+    otx.readysend(init_database)
+    otx.sent(init_database)
+    otx.minefail(1024, init_database)
+    assert not is_alive(otx.status)
+
+
+def test_status_chain_nodeerror(
+        init_database,
+        otx,
+        ):
+
+    otx.readysend(init_database)
+    otx.sendfail(init_database)
+    otx.retry(init_database)
+    otx.sent(init_database)
+    otx.success(1024, init_database)
+    assert not is_alive(otx.status)
+
+
+
+def test_status_chain_nodeerror_multiple(
+        init_database,
+        otx,
+        ):
+
+    otx.readysend(init_database)
+    otx.sendfail(init_database)
+    otx.retry(init_database)
+    otx.sendfail(init_database)
+    otx.retry(init_database)
+    otx.sent(init_database)
+    otx.success(1024, init_database)
+    assert not is_alive(otx.status)
+
+
+def test_status_chain_nodeerror(
+        init_database,
+        otx,
+        ):
+
+    otx.readysend(init_database)
+    otx.reject(init_database)
+    assert not is_alive(otx.status)

apps/cic-eth/tests/unit/db/test_tx.py

@@ -0,0 +1,150 @@
+# standard imports
+import os
+
+# external imports
+import pytest
+from chainlib.connection import RPCConnection
+from chainlib.eth.constant import ZERO_ADDRESS
+from chainlib.eth.gas import (
+        Gas,
+        RPCGasOracle,
+        )
+from chainlib.eth.tx import (
+        TxFormat,
+        unpack,
+        )
+from chainlib.eth.nonce import RPCNonceOracle
+from hexathon import (
+        add_0x,
+        strip_0x,
+        )
+
+# local imports
+from cic_eth.db.models.tx import TxCache
+from cic_eth.db.models.otx import Otx
+
+# test imports
+from tests.util.gas import StaticGasOracle
+
+
+def test_set(
+        default_chain_spec,
+        init_database,
+        eth_rpc,
+        eth_signer,
+        agent_roles,
+        ):
+
+    chain_id = default_chain_spec.chain_id()
+    rpc = RPCConnection.connect(default_chain_spec, 'default')
+    nonce_oracle = RPCNonceOracle(agent_roles['ALICE'], eth_rpc)
+    gas_oracle = RPCGasOracle(eth_rpc)
+    c = Gas(signer=eth_signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle, chain_id=chain_id)
+
+    (tx_hash_hex, tx_signed_raw_hex) = c.create(agent_roles['ALICE'], agent_roles['BOB'], 100 * (10 ** 6), tx_format=TxFormat.RLP_SIGNED)
+    tx = unpack(bytes.fromhex(strip_0x(tx_signed_raw_hex)), chain_id)
+
+    otx = Otx(
+        tx['nonce'],
+        tx['from'],
+        tx_hash_hex,
+        tx_signed_raw_hex,
+        )
+    init_database.add(otx)
+    init_database.commit()
+
+    bogus_from_token = add_0x(os.urandom(20).hex())
+    to_value = int(tx['value'] / 2)
+
+    txc = TxCache(
+        tx_hash_hex,
+        tx['from'],
+        tx['to'],
+        bogus_from_token,
+        ZERO_ADDRESS,
+        tx['value'],
+        to_value,
+        666,
+        13,
+            )
+    init_database.add(txc)
+    init_database.commit()
+
+    tx_stored = init_database.query(TxCache).first()
+    assert (tx_stored.sender == tx['from'])
+    assert (tx_stored.recipient == tx['to'])
+    assert (tx_stored.source_token_address == bogus_from_token)
+    assert (tx_stored.destination_token_address == ZERO_ADDRESS)
+    assert (tx_stored.from_value == tx['value'])
+    assert (tx_stored.to_value == to_value)
+    assert (tx_stored.block_number == 666)
+    assert (tx_stored.tx_index == 13)
+
+
+def test_clone(
+        default_chain_spec,
+        init_database,
+        eth_rpc,
+        eth_signer,
+        agent_roles,
+        ):
+
+    chain_id = default_chain_spec.chain_id()
+    rpc = RPCConnection.connect(default_chain_spec, 'default')
+    nonce_oracle = RPCNonceOracle(agent_roles['ALICE'], eth_rpc)
+    gas_oracle = StaticGasOracle(2 * (10 ** 9), 21000)
+    c = Gas(signer=eth_signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle, chain_id=chain_id)
+
+    txs_rpc = [
+        c.create(agent_roles['ALICE'], agent_roles['BOB'], 100 * (10 ** 6), tx_format=TxFormat.RLP_SIGNED),
+        ]
+
+    gas_oracle = StaticGasOracle(4 * (10 ** 9), 21000)
+    c = Gas(signer=eth_signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle, chain_id=chain_id)
+    txs_rpc += [
+        c.create(agent_roles['ALICE'], agent_roles['BOB'], 100 * (10 ** 6), tx_format=TxFormat.RLP_SIGNED),
+        ]
+
+    txs = []
+    for tx_rpc in txs_rpc:
+        tx_hash_hex = tx_rpc[0]
+        tx_signed_raw_hex = tx_rpc[1]
+        tx_dict = unpack(bytes.fromhex(strip_0x(tx_signed_raw_hex)), chain_id)
+        otx = Otx(
+            tx_dict['nonce'],
+            tx_dict['from'],
+            tx_hash_hex,
+            tx_signed_raw_hex,
+            )
+        init_database.add(otx)
+        tx_dict['hash'] = tx_hash_hex
+        txs.append(tx_dict)
+
+    init_database.commit()
+
+    txc = TxCache(
+        txs[0]['hash'],
+        txs[0]['from'],
+        txs[0]['to'],
+        ZERO_ADDRESS,
+        ZERO_ADDRESS,
+        txs[0]['value'],
+        txs[0]['value'],
+            )
+    init_database.add(txc)
+    init_database.commit()
+
+    TxCache.clone(txs[0]['hash'], txs[1]['hash'])
+
+    q = init_database.query(TxCache)
+    q = q.join(Otx)
+    q = q.filter(Otx.tx_hash==txs[1]['hash'])
+    txc_clone = q.first()
+    
+    assert txc_clone != None
+    assert txc_clone.sender == txc.sender
+    assert txc_clone.recipient == txc.recipient
+    assert txc_clone.source_token_address == txc.source_token_address
+    assert txc_clone.destination_token_address == txc.destination_token_address
+    assert txc_clone.from_value == txc.from_value
+    assert txc_clone.to_value == txc.to_value