The great bump

apps/cic-ussd/tests/cic_ussd/db/models/test_account.py

@@ -0,0 +1,96 @@
+# standard imports
+import json
+
+# external imports
+import pytest
+from cic_types.models.person import get_contact_data_from_vcard
+
+# local imports
+from cic_ussd.account.chain import Chain
+from cic_ussd.cache import get_cached_data
+from cic_ussd.db.enum import AccountStatus
+from cic_ussd.db.models.account import Account, create, cache_creation_task_uuid
+from cic_ussd.db.models.task_tracker import TaskTracker
+
+# test imports
+from tests.helpers.accounts import blockchain_address, phone_number
+
+
+def test_account(init_database, set_fernet_key):
+    address = blockchain_address()
+    phone = phone_number()
+    account = Account(address, phone)
+    account.create_password('0000')
+    account.activate_account()
+    init_database.add(account)
+    init_database.commit()
+
+    account = init_database.query(Account).get(1)
+    assert account.blockchain_address == address
+    assert account.phone_number == phone
+    assert account.failed_pin_attempts == 0
+    assert account.verify_password('0000') is True
+    assert account.get_status(init_database) == AccountStatus.ACTIVE.name
+
+
+def test_account_repr(activated_account):
+    assert repr(activated_account) == f'<Account: {activated_account.blockchain_address}>'
+
+
+def test_account_statuses(init_database, pending_account):
+    assert pending_account.get_status(init_database) == AccountStatus.PENDING.name
+    pending_account.create_password('1111')
+    pending_account.activate_account()
+    init_database.add(pending_account)
+    init_database.commit()
+    assert pending_account.get_status(init_database) == AccountStatus.ACTIVE.name
+    pending_account.failed_pin_attempts = 3
+    assert pending_account.get_status(init_database) == AccountStatus.LOCKED.name
+    pending_account.reset_pin(init_database)
+    assert pending_account.get_status(init_database) == AccountStatus.RESET.name
+    pending_account.activate_account()
+    assert pending_account.get_status(init_database) == AccountStatus.ACTIVE.name
+
+
+def test_get_by_phone_number(activated_account, init_database):
+    account = Account.get_by_phone_number(activated_account.phone_number, init_database)
+    assert account == activated_account
+
+
+def test_has_preferred_language(activated_account, cache_preferences):
+    assert activated_account.has_preferred_language() is True
+
+
+def test_lacks_preferred_language(activated_account):
+    assert activated_account.has_preferred_language() is False
+
+
+def test_has_valid_pin(activated_account, init_database, pending_account):
+    assert activated_account.has_valid_pin(init_database) is True
+    assert pending_account.has_valid_pin(init_database) is False
+
+
+def test_pin_is_blocked(activated_account, init_database):
+    assert activated_account.pin_is_blocked(init_database) is False
+    activated_account.failed_pin_attempts = 3
+    init_database.add(activated_account)
+    init_database.commit()
+    assert activated_account.pin_is_blocked(init_database) is True
+
+
+def test_standard_metadata_id(activated_account, cache_person_metadata, pending_account, person_metadata):
+    contact_information = get_contact_data_from_vcard(person_metadata.get('vcard'))
+    given_name = contact_information.get('given')
+    family_name = contact_information.get('family')
+    phone_number = contact_information.get('tel')
+    parsed_account_metadata = f'{given_name} {family_name} {phone_number}'
+    assert activated_account.standard_metadata_id() == parsed_account_metadata
+    assert pending_account.standard_metadata_id() == pending_account.phone_number
+
+
+def test_account_create(init_cache, init_database, load_chain_spec, mock_account_creation_task_result, task_uuid):
+    chain_str = Chain.spec.__str__()
+    create(chain_str, phone_number(), init_database)
+    assert len(init_database.query(TaskTracker).all()) == 1
+    account_creation_data = get_cached_data(task_uuid)
+    assert json.loads(account_creation_data).get('status') == AccountStatus.PENDING.name

apps/cic-ussd/tests/cic_ussd/db/models/test_task_tracker.py

@@ -6,9 +6,8 @@ def test_task_tracker(init_database):
     task_uuid = '31e85315-feee-4b6d-995e-223569082cc4'
     task_in_tracker = TaskTracker(task_uuid=task_uuid)
 
-    session = init_database
-    session.add(task_in_tracker)
-    session.commit()
+    init_database.add(task_in_tracker)
+    init_database.commit()
 
-    queried_task = session.query(TaskTracker).get(1)
+    queried_task = init_database.query(TaskTracker).get(1)
     assert queried_task.task_uuid == task_uuid

apps/cic-ussd/tests/cic_ussd/db/models/test_user.py

@@ -1,40 +0,0 @@
-"""Tests the persistence of the user record and associated functions to the user object"""
-
-# standard imports
-import pytest
-
-# platform imports
-from cic_ussd.db.models.account import Account
-
-
-def test_user(init_database, set_fernet_key):
-    user = Account(blockchain_address='0x417f5962fc52dc33ff0689659b25848680dec6dcedc6785b03d1df60fc6d5c51',
-                   phone_number='+254700000000')
-    user.create_password('0000')
-
-    session = Account.session
-    session.add(user)
-    session.commit()
-
-    queried_user = session.query(Account).get(1)
-    assert queried_user.blockchain_address == '0x417f5962fc52dc33ff0689659b25848680dec6dcedc6785b03d1df60fc6d5c51'
-    assert queried_user.phone_number == '+254700000000'
-    assert queried_user.failed_pin_attempts == 0
-    assert queried_user.verify_password('0000') is True
-
-
-def test_user_state_transition(create_pending_user):
-    user = create_pending_user
-    session = Account.session
-
-    assert user.get_account_status() == 'PENDING'
-    user.activate_account()
-    assert user.get_account_status() == 'ACTIVE'
-    user.failed_pin_attempts = 3
-    assert user.get_account_status() == 'LOCKED'
-    user.reset_account_pin()
-    assert user.get_account_status() == 'RESET'
-    user.activate_account()
-    assert user.get_account_status() == 'ACTIVE'
-    session.add(user)
-    session.commit()

apps/cic-ussd/tests/cic_ussd/db/models/test_ussd_session.py

@@ -1,54 +1,78 @@
+# standard imports
+import os
+
 # third party imports
 import pytest
+from sqlalchemy import desc
 
 # local imports
 from cic_ussd.db.models.ussd_session import UssdSession
 from cic_ussd.error import VersionTooLowError
 
 
-def test_ussd_session(init_database, create_in_redis_ussd_session, create_activated_user):
-    session = init_database
-
+def test_ussd_session(activated_account, init_database, init_cache, load_config):
+    valid_service_codes = load_config.get('USSD_SERVICE_CODE').split(",")
     ussd_session = UssdSession(
-        external_session_id='AT65423',
-        service_code='*123#',
-        msisdn=create_activated_user.phone_number,
+        external_session_id=os.urandom(20).hex(),
+        service_code=valid_service_codes[0],
+        msisdn=activated_account.phone_number,
         user_input='1',
         state='start',
-        session_data={},
+        data={},
         version=1,
     )
 
-    session.add(ussd_session)
-    session.commit()
+    init_database.add(ussd_session)
+    init_database.commit()
 
     ussd_session.set_data(key='foo', session=init_database, value='bar')
 
     assert ussd_session.get_data('foo') == 'bar'
-    ussd_session.update(
-        session=init_database,
-        user_input='3',
-        state='next',
-        version=2
-    )
+    ussd_session.update('3', 'next', 2, init_database)
     assert ussd_session.version == 2
-    session.add(ussd_session)
-    session.commit()
+    init_database.add(ussd_session)
+    init_database.commit()
 
-    assert UssdSession.have_session_for_phone(create_activated_user.phone_number) is True
+    assert UssdSession.has_record_for_phone_number(activated_account.phone_number, init_database) is True
 
 
-def test_version_too_low_error(init_database, create_in_redis_ussd_session, create_activated_user):
+def test_version_too_low_error(activated_account, init_database, init_cache):
     with pytest.raises(VersionTooLowError) as e:
         session = UssdSession(
             external_session_id='AT38745',
             service_code='*123#',
-            msisdn=create_activated_user.phone_number,
+            msisdn=activated_account.phone_number,
             user_input='1',
             state='start',
-            session_data={},
+            data={},
             version=3,
         )
         assert session.check_version(1)
         assert session.check_version(3)
     assert str(e.value) == 'New session version number is not greater than last saved version!'
+
+
+def test_set_data(init_database, ussd_session_data, persisted_ussd_session):
+    assert persisted_ussd_session.data == {}
+    for key, value in ussd_session_data.items():
+        persisted_ussd_session.set_data(key, init_database, value)
+    init_database.commit()
+
+    assert persisted_ussd_session.get_data('recipient') == ussd_session_data.get('recipient')
+
+
+def test_has_record_for_phone_number(activated_account, init_database, persisted_ussd_session):
+    ussd_session = UssdSession.has_record_for_phone_number(activated_account.phone_number, init_database)
+    assert ussd_session is not None
+
+
+def test_last_ussd_session(init_database, ussd_session_traffic):
+    assert len(init_database.query(UssdSession).all()) >= 5
+    ussd_session = init_database.query(UssdSession).order_by(desc(UssdSession.created)).first()
+    phone_number = ussd_session.msisdn
+    assert UssdSession.last_ussd_session(phone_number, init_database).id == ussd_session.id
+
+
+def test_persisted_to_json(persisted_ussd_session):
+    assert isinstance(persisted_ussd_session, UssdSession)
+    assert isinstance(persisted_ussd_session.to_json(), dict)

apps/cic-ussd/tests/cic_ussd/db/test_db.py

@@ -10,11 +10,6 @@ from cic_ussd.db import dsn_from_config
 def test_dsn_from_config(load_config):
     """
     """
-    # test dsn for sqlite engine
-    dsn = dsn_from_config(load_config)
-    scheme = f'{load_config.get("DATABASE_ENGINE")}+{load_config.get("DATABASE_DRIVER")}'
-    assert dsn == f'{scheme}:///{load_config.get("DATABASE_NAME")}'
-
     # test dsn for other db formats
     overrides = {
         'DATABASE_PASSWORD': 'password',
@@ -28,3 +23,16 @@ def test_dsn_from_config(load_config):
     dsn = dsn_from_config(load_config)
     assert dsn == f"{scheme}://{load_config.get('DATABASE_USER')}:{load_config.get('DATABASE_PASSWORD')}@{load_config.get('DATABASE_HOST')}:{load_config.get('DATABASE_PORT')}/{load_config.get('DATABASE_NAME')}"
 
+    # undoes overrides to revert engine and drivers to sqlite
+    overrides = {
+        'DATABASE_PASSWORD': '',
+        'DATABASE_DRIVER': 'pysqlite',
+        'DATABASE_ENGINE': 'sqlite'
+    }
+    load_config.dict_override(dct=overrides, dct_description='Override values to test different db formats.')
+
+    # test dsn for sqlite engine
+    dsn = dsn_from_config(load_config)
+    scheme = f'{load_config.get("DATABASE_ENGINE")}+{load_config.get("DATABASE_DRIVER")}'
+    assert dsn == f'{scheme}:///{load_config.get("DATABASE_NAME")}'
+