The great bump
This commit is contained in:
@@ -0,0 +1,154 @@
|
||||
# standard imports
|
||||
import json
|
||||
|
||||
# external imports
|
||||
import pytest
|
||||
import requests_mock
|
||||
from chainlib.hash import strip_0x
|
||||
from cic_types.models.person import Person, get_contact_data_from_vcard
|
||||
|
||||
# local imports
|
||||
from cic_ussd.cache import get_cached_data
|
||||
from cic_ussd.account.maps import gender
|
||||
from cic_ussd.account.metadata import get_cached_preferred_language
|
||||
from cic_ussd.db.enum import AccountStatus
|
||||
from cic_ussd.metadata import PreferencesMetadata
|
||||
from cic_ussd.state_machine.logic.account import (change_preferred_language,
|
||||
edit_user_metadata_attribute,
|
||||
parse_gender,
|
||||
parse_person_metadata,
|
||||
save_complete_person_metadata,
|
||||
save_metadata_attribute_to_session_data,
|
||||
update_account_status_to_active)
|
||||
from cic_ussd.translation import translation_for
|
||||
|
||||
|
||||
# test imports
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input, expected_preferred_language', [
|
||||
('1', 'en'),
|
||||
('2', 'sw')
|
||||
])
|
||||
def test_change_preferred_language(activated_account,
|
||||
celery_session_worker,
|
||||
expected_preferred_language,
|
||||
init_database,
|
||||
generic_ussd_session,
|
||||
mock_response,
|
||||
preferences,
|
||||
setup_metadata_request_handler,
|
||||
user_input):
|
||||
identifier = bytes.fromhex(strip_0x(activated_account.blockchain_address))
|
||||
preferences_metadata_client = PreferencesMetadata(identifier)
|
||||
with requests_mock.Mocker(real_http=False) as requests_mocker:
|
||||
requests_mocker.register_uri(
|
||||
'POST', preferences_metadata_client.url, status_code=200, reason='OK', json=mock_response
|
||||
)
|
||||
state_machine_data = (user_input, generic_ussd_session, activated_account, init_database)
|
||||
res = change_preferred_language(state_machine_data)
|
||||
init_database.commit()
|
||||
assert res.id is not None
|
||||
assert activated_account.preferred_language == expected_preferred_language
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input', [
|
||||
'1',
|
||||
'2',
|
||||
'3'
|
||||
])
|
||||
def test_parse_gender(activated_account, cache_preferences, user_input):
|
||||
preferred_language = get_cached_preferred_language(activated_account.blockchain_address)
|
||||
parsed_gender = parse_gender(activated_account, user_input)
|
||||
r_user_input = gender().get(user_input)
|
||||
assert parsed_gender == translation_for(f'helpers.{r_user_input}', preferred_language)
|
||||
|
||||
|
||||
def test_parse_person_metadata(activated_account, load_chain_spec, raw_person_metadata):
|
||||
parsed_user_metadata = parse_person_metadata(activated_account, raw_person_metadata)
|
||||
person = Person()
|
||||
user_metadata = person.deserialize(parsed_user_metadata)
|
||||
assert parsed_user_metadata == user_metadata.serialize()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("current_state, expected_key, expected_result, user_input", [
|
||||
("enter_given_name", "given_name", "John", "John"),
|
||||
("enter_family_name", "family_name", "Doe", "Doe"),
|
||||
("enter_location", "location", "Kangemi", "Kangemi"),
|
||||
("enter_products", "products", "Mandazi", "Mandazi"),
|
||||
])
|
||||
def test_save_metadata_attribute_to_session_data(activated_account,
|
||||
cached_ussd_session,
|
||||
celery_session_worker,
|
||||
current_state,
|
||||
expected_key,
|
||||
expected_result,
|
||||
init_cache,
|
||||
init_database,
|
||||
load_chain_spec,
|
||||
set_locale_files,
|
||||
persisted_ussd_session,
|
||||
user_input):
|
||||
persisted_ussd_session.state = current_state
|
||||
ussd_session = persisted_ussd_session.to_json()
|
||||
state_machine_data = (user_input, ussd_session, activated_account, init_database)
|
||||
ussd_session_in_cache = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session_in_cache = json.loads(ussd_session_in_cache)
|
||||
assert ussd_session_in_cache.get('data') == {}
|
||||
ussd_session['state'] = current_state
|
||||
save_metadata_attribute_to_session_data(state_machine_data)
|
||||
cached_ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
cached_ussd_session = json.loads(cached_ussd_session)
|
||||
assert cached_ussd_session.get('data')[expected_key] == expected_result
|
||||
|
||||
|
||||
def test_update_account_status_to_active(generic_ussd_session, init_database, pending_account):
|
||||
state_machine_data = ('', generic_ussd_session, pending_account, init_database)
|
||||
assert pending_account.get_status(init_database) == AccountStatus.PENDING.name
|
||||
update_account_status_to_active(state_machine_data)
|
||||
assert pending_account.get_status(init_database) == AccountStatus.ACTIVE.name
|
||||
|
||||
|
||||
def test_save_complete_person_metadata(activated_account,
|
||||
cached_ussd_session,
|
||||
celery_session_worker,
|
||||
init_database,
|
||||
load_chain_spec,
|
||||
mocker,
|
||||
person_metadata,
|
||||
raw_person_metadata):
|
||||
ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session = json.loads(ussd_session)
|
||||
ussd_session['data'] = raw_person_metadata
|
||||
metadata = parse_person_metadata(activated_account, raw_person_metadata)
|
||||
state_machine_data = ('', ussd_session, activated_account, init_database)
|
||||
mocked_create_metadata_task = mocker.patch('cic_ussd.tasks.metadata.create_person_metadata.apply_async')
|
||||
save_complete_person_metadata(state_machine_data=state_machine_data)
|
||||
mocked_create_metadata_task.assert_called_with(
|
||||
(activated_account.blockchain_address, metadata), {}, queue='cic-ussd')
|
||||
|
||||
|
||||
def test_edit_user_metadata_attribute(activated_account,
|
||||
cache_person_metadata,
|
||||
cached_ussd_session,
|
||||
celery_session_worker,
|
||||
init_cache,
|
||||
init_database,
|
||||
load_chain_spec,
|
||||
mocker,
|
||||
person_metadata):
|
||||
ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session = json.loads(ussd_session)
|
||||
assert person_metadata['location']['area_name'] == 'kayaba'
|
||||
ussd_session['data'] = {'location': 'nairobi'}
|
||||
contact_data = get_contact_data_from_vcard(person_metadata.get('vcard'))
|
||||
phone_number = contact_data.get('tel')
|
||||
activated_account.phone_number = phone_number
|
||||
state_machine_data = ('', ussd_session, activated_account, init_database)
|
||||
mocked_edit_metadata = mocker.patch('cic_ussd.tasks.metadata.create_person_metadata.apply_async')
|
||||
edit_user_metadata_attribute(state_machine_data)
|
||||
person_metadata['date_registered'] = int(activated_account.created.replace().timestamp())
|
||||
person_metadata['location']['area_name'] = 'nairobi'
|
||||
mocked_edit_metadata.assert_called_with(
|
||||
(activated_account.blockchain_address, person_metadata), {}, queue='cic-ussd')
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
# local imports
|
||||
from cic_ussd.state_machine.logic.menu import (menu_one_selected,
|
||||
menu_two_selected,
|
||||
menu_three_selected,
|
||||
menu_four_selected)
|
||||
|
||||
|
||||
def test_menu_selection(create_pending_user, create_in_db_ussd_session):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
assert menu_one_selected(('1', serialized_in_db_ussd_session, create_pending_user)) is True
|
||||
assert menu_one_selected(('x', serialized_in_db_ussd_session, create_pending_user)) is False
|
||||
|
||||
assert menu_two_selected(('2', serialized_in_db_ussd_session, create_pending_user)) is True
|
||||
assert menu_two_selected(('1', serialized_in_db_ussd_session, create_pending_user)) is False
|
||||
|
||||
assert menu_three_selected(('3', serialized_in_db_ussd_session, create_pending_user)) is True
|
||||
assert menu_three_selected(('4', serialized_in_db_ussd_session, create_pending_user)) is False
|
||||
|
||||
assert menu_four_selected(('4', serialized_in_db_ussd_session, create_pending_user)) is True
|
||||
assert menu_four_selected(('d', serialized_in_db_ussd_session, create_pending_user)) is False
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
# standard imports
|
||||
|
||||
# external imports
|
||||
|
||||
# local imports
|
||||
from cic_ussd.state_machine.logic.menu import (menu_one_selected,
|
||||
menu_two_selected,
|
||||
menu_three_selected,
|
||||
menu_four_selected,
|
||||
menu_five_selected,
|
||||
menu_six_selected,
|
||||
menu_zero_zero_selected,
|
||||
menu_ninety_nine_selected)
|
||||
|
||||
# test imports
|
||||
|
||||
|
||||
def test_menu_selection(init_database, pending_account, persisted_ussd_session):
|
||||
ussd_session = persisted_ussd_session.to_json()
|
||||
assert menu_one_selected(('1', ussd_session, pending_account, init_database)) is True
|
||||
assert menu_one_selected(('x', ussd_session, pending_account, init_database)) is False
|
||||
assert menu_two_selected(('2', ussd_session, pending_account, init_database)) is True
|
||||
assert menu_two_selected(('1', ussd_session, pending_account, init_database)) is False
|
||||
assert menu_three_selected(('3', ussd_session, pending_account, init_database)) is True
|
||||
assert menu_three_selected(('4', ussd_session, pending_account, init_database)) is False
|
||||
assert menu_four_selected(('4', ussd_session, pending_account, init_database)) is True
|
||||
assert menu_four_selected(('d', ussd_session, pending_account, init_database)) is False
|
||||
assert menu_five_selected(('5', ussd_session, pending_account, init_database)) is True
|
||||
assert menu_five_selected(('e', ussd_session, pending_account, init_database)) is False
|
||||
assert menu_six_selected(('6', ussd_session, pending_account, init_database)) is True
|
||||
assert menu_six_selected(('8', ussd_session, pending_account, init_database)) is False
|
||||
assert menu_zero_zero_selected(('00', ussd_session, pending_account, init_database)) is True
|
||||
assert menu_zero_zero_selected(('/', ussd_session, pending_account, init_database)) is False
|
||||
assert menu_ninety_nine_selected(('99', ussd_session, pending_account, init_database)) is True
|
||||
assert menu_ninety_nine_selected(('d', ussd_session, pending_account, init_database)) is False
|
||||
|
||||
|
||||
@@ -1,94 +0,0 @@
|
||||
# standards imports
|
||||
import json
|
||||
|
||||
# third party imports
|
||||
import pytest
|
||||
|
||||
# local imports
|
||||
from cic_ussd.encoder import check_password_hash, create_password_hash
|
||||
from cic_ussd.state_machine.logic.pin import (complete_pin_change,
|
||||
is_valid_pin,
|
||||
is_valid_new_pin,
|
||||
is_authorized_pin,
|
||||
is_blocked_pin,
|
||||
pins_match,
|
||||
save_initial_pin_to_session_data)
|
||||
|
||||
|
||||
def test_complete_pin_change(init_database, create_pending_user, create_in_db_ussd_session):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = ('1212', serialized_in_db_ussd_session, create_pending_user)
|
||||
assert create_pending_user.password_hash is None
|
||||
create_in_db_ussd_session.set_data(key='initial_pin', session=init_database, value=create_password_hash('1212'))
|
||||
complete_pin_change(state_machine_data)
|
||||
assert create_pending_user.password_hash is not None
|
||||
assert create_pending_user.verify_password(password='1212') is True
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input, expected', [
|
||||
('4562', True),
|
||||
('jksu', False),
|
||||
('ij45', False),
|
||||
])
|
||||
def test_is_valid_pin(create_pending_user, create_in_db_ussd_session, user_input, expected):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (user_input, serialized_in_db_ussd_session, create_pending_user)
|
||||
assert is_valid_pin(state_machine_data) is expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input, expected', [
|
||||
('1212', True),
|
||||
('0000', False)
|
||||
])
|
||||
def test_pins_match(init_database, create_pending_user, create_in_db_ussd_session, user_input, expected):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (user_input, serialized_in_db_ussd_session, create_pending_user)
|
||||
create_in_db_ussd_session.set_data(key='initial_pin', session=init_database, value=create_password_hash(user_input))
|
||||
assert pins_match(state_machine_data) is True
|
||||
|
||||
|
||||
def test_save_initial_pin_to_session_data(create_pending_user,
|
||||
create_in_redis_ussd_session,
|
||||
create_in_db_ussd_session,
|
||||
celery_session_worker):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = ('1212', serialized_in_db_ussd_session, create_pending_user)
|
||||
save_initial_pin_to_session_data(state_machine_data)
|
||||
external_session_id = create_in_db_ussd_session.external_session_id
|
||||
in_memory_ussd_session = create_in_redis_ussd_session.get(external_session_id)
|
||||
in_memory_ussd_session = json.loads(in_memory_ussd_session)
|
||||
assert check_password_hash(
|
||||
password='1212', hashed_password=in_memory_ussd_session.get('session_data')['initial_pin'])
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input, expected_result', [
|
||||
('1212', False),
|
||||
('0000', True)
|
||||
])
|
||||
def test_is_authorized_pin(create_activated_user, create_in_db_ussd_session, expected_result, user_input):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (user_input, serialized_in_db_ussd_session, create_activated_user)
|
||||
assert is_authorized_pin(state_machine_data=state_machine_data) is expected_result
|
||||
|
||||
|
||||
def test_is_not_blocked_pin(create_activated_user, create_in_db_ussd_session):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = ('', serialized_in_db_ussd_session, create_activated_user)
|
||||
assert is_blocked_pin(state_machine_data=state_machine_data) is False
|
||||
|
||||
|
||||
def test_is_blocked_pin(create_pin_blocked_user, create_in_db_ussd_session):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
alt_state_machine_data = ('user_input', serialized_in_db_ussd_session, create_pin_blocked_user)
|
||||
assert is_blocked_pin(state_machine_data=alt_state_machine_data) is True
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input, expected_result', [
|
||||
('1212', True),
|
||||
('0000', False)
|
||||
])
|
||||
def test_is_valid_new_pin(create_activated_user, create_in_db_ussd_session, expected_result, user_input):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (user_input, serialized_in_db_ussd_session, create_activated_user)
|
||||
assert is_valid_new_pin(state_machine_data=state_machine_data) is expected_result
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
# standard imports
|
||||
import json
|
||||
|
||||
# external imports
|
||||
import pytest
|
||||
|
||||
# local imports
|
||||
from cic_ussd.cache import get_cached_data
|
||||
from cic_ussd.encoder import check_password_hash, create_password_hash
|
||||
from cic_ussd.state_machine.logic.pin import (complete_pin_change,
|
||||
is_valid_pin,
|
||||
is_valid_new_pin,
|
||||
is_authorized_pin,
|
||||
is_blocked_pin,
|
||||
is_locked_account,
|
||||
pins_match,
|
||||
save_initial_pin_to_session_data)
|
||||
|
||||
|
||||
def test_complete_pin_change(activated_account, cached_ussd_session, init_database):
|
||||
state_machine_data = ('1212', cached_ussd_session.to_json(), activated_account, init_database)
|
||||
assert activated_account.password_hash is not None
|
||||
cached_ussd_session.set_data('initial_pin', create_password_hash('1212'))
|
||||
complete_pin_change(state_machine_data)
|
||||
assert activated_account.verify_password('1212') is True
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input, expected', [
|
||||
('4562', True),
|
||||
('jksu', False),
|
||||
('ij45', False),
|
||||
])
|
||||
def test_is_valid_pin(activated_account, expected, generic_ussd_session, init_database, user_input):
|
||||
state_machine_data = (user_input, generic_ussd_session, activated_account, init_database)
|
||||
assert is_valid_pin(state_machine_data) is expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input', [
|
||||
'1212',
|
||||
'0000'
|
||||
])
|
||||
def test_pins_match(activated_account, cached_ussd_session, init_cache, init_database, user_input):
|
||||
state_machine_data = (user_input, cached_ussd_session.to_json(), activated_account, init_database)
|
||||
cached_ussd_session.set_data('initial_pin', create_password_hash(user_input))
|
||||
assert pins_match(state_machine_data) is True
|
||||
|
||||
|
||||
def test_save_initial_pin_to_session_data(activated_account,
|
||||
cached_ussd_session,
|
||||
celery_session_worker,
|
||||
init_cache,
|
||||
init_database,
|
||||
persisted_ussd_session,
|
||||
set_fernet_key):
|
||||
state_machine_data = ('1212', cached_ussd_session.to_json(), activated_account, init_database)
|
||||
save_initial_pin_to_session_data(state_machine_data)
|
||||
ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session = json.loads(ussd_session)
|
||||
assert check_password_hash('1212', ussd_session.get('data')['initial_pin'])
|
||||
cached_ussd_session.set_data('some_key', 'some_value')
|
||||
state_machine_data = ('1212', cached_ussd_session.to_json(), activated_account, init_database)
|
||||
save_initial_pin_to_session_data(state_machine_data)
|
||||
ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session = json.loads(ussd_session)
|
||||
assert ussd_session.get('data')['some_key'] == 'some_value'
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input, expected_result', [
|
||||
('1212', False),
|
||||
('0000', True)
|
||||
])
|
||||
def test_is_authorized_pin(activated_account, cached_ussd_session, expected_result, init_database, user_input):
|
||||
state_machine_data = (user_input, cached_ussd_session.to_json(), activated_account, init_database)
|
||||
assert is_authorized_pin(state_machine_data) is expected_result
|
||||
|
||||
|
||||
def test_is_not_blocked_pin(activated_account, cached_ussd_session, init_database):
|
||||
state_machine_data = ('', cached_ussd_session.to_json(), activated_account, init_database)
|
||||
assert is_blocked_pin(state_machine_data) is False
|
||||
|
||||
|
||||
def test_is_blocked_pin(cached_ussd_session, init_database, pin_blocked_account):
|
||||
state_machine_data = ('user_input', cached_ussd_session, pin_blocked_account, init_database)
|
||||
assert is_blocked_pin(state_machine_data) is True
|
||||
|
||||
|
||||
def test_is_locked_account(activated_account, generic_ussd_session, init_database, pin_blocked_account):
|
||||
state_machine_data = ('', generic_ussd_session, activated_account, init_database)
|
||||
assert is_locked_account(state_machine_data) is False
|
||||
state_machine_data = ('', generic_ussd_session, pin_blocked_account, init_database)
|
||||
assert is_locked_account(state_machine_data) is True
|
||||
|
||||
|
||||
@pytest.mark.parametrize('user_input, expected_result', [
|
||||
('1212', True),
|
||||
('0000', False)
|
||||
])
|
||||
def test_is_valid_new_pin(activated_account, cached_ussd_session, expected_result, init_database, user_input):
|
||||
state_machine_data = (user_input, cached_ussd_session.to_json(), activated_account, init_database)
|
||||
assert is_valid_new_pin(state_machine_data) is expected_result
|
||||
|
||||
@@ -1,36 +0,0 @@
|
||||
# standard imports
|
||||
|
||||
# third-party imports
|
||||
import pytest
|
||||
|
||||
# local imports
|
||||
from cic_ussd.state_machine.logic.sms import (send_terms_to_user_if_required,
|
||||
process_mini_statement_request,
|
||||
upsell_unregistered_recipient)
|
||||
|
||||
|
||||
def test_send_terms_to_user_if_required(caplog,
|
||||
create_in_db_ussd_session,
|
||||
create_activated_user):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = ('', serialized_in_db_ussd_session, create_activated_user)
|
||||
send_terms_to_user_if_required(state_machine_data=state_machine_data)
|
||||
assert 'Requires integration to cic-notify.' in caplog.text
|
||||
|
||||
|
||||
def test_process_mini_statement_request(caplog,
|
||||
create_in_db_ussd_session,
|
||||
create_activated_user):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = ('', serialized_in_db_ussd_session, create_activated_user)
|
||||
process_mini_statement_request(state_machine_data=state_machine_data)
|
||||
assert 'Requires integration to cic-notify.' in caplog.text
|
||||
|
||||
|
||||
def test_upsell_unregistered_recipient(caplog,
|
||||
create_in_db_ussd_session,
|
||||
create_activated_user):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = ('', serialized_in_db_ussd_session, create_activated_user)
|
||||
upsell_unregistered_recipient(state_machine_data=state_machine_data)
|
||||
assert 'Requires integration to cic-notify.' in caplog.text
|
||||
@@ -0,0 +1,42 @@
|
||||
# standard imports
|
||||
import json
|
||||
|
||||
# external imports
|
||||
|
||||
# local imports
|
||||
from cic_ussd.account.metadata import get_cached_preferred_language
|
||||
from cic_ussd.account.tokens import get_default_token_symbol
|
||||
from cic_ussd.cache import get_cached_data
|
||||
from cic_ussd.phone_number import Support
|
||||
from cic_ussd.state_machine.logic.sms import upsell_unregistered_recipient
|
||||
from cic_ussd.translation import translation_for
|
||||
|
||||
|
||||
# tests imports
|
||||
|
||||
|
||||
def test_upsell_unregistered_recipient(activated_account,
|
||||
cache_default_token_data,
|
||||
cache_preferences,
|
||||
cached_ussd_session,
|
||||
init_database,
|
||||
load_support_phone,
|
||||
mock_notifier_api,
|
||||
set_locale_files,
|
||||
valid_recipient):
|
||||
cached_ussd_session.set_data('recipient_phone_number', valid_recipient.phone_number)
|
||||
state_machine_data = ('', cached_ussd_session.to_json(), activated_account, init_database)
|
||||
upsell_unregistered_recipient(state_machine_data)
|
||||
ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session = json.loads(ussd_session)
|
||||
phone_number = ussd_session.get('data')['recipient_phone_number']
|
||||
preferred_language = get_cached_preferred_language(activated_account.blockchain_address)
|
||||
token_symbol = get_default_token_symbol()
|
||||
tx_sender_information = activated_account.standard_metadata_id()
|
||||
message = translation_for('sms.upsell_unregistered_recipient',
|
||||
preferred_language,
|
||||
tx_sender_information=tx_sender_information,
|
||||
token_symbol=token_symbol,
|
||||
support_phone=Support.phone_number)
|
||||
assert mock_notifier_api.get('message') == message
|
||||
assert mock_notifier_api.get('recipient') == phone_number
|
||||
@@ -1,111 +0,0 @@
|
||||
# standard imports
|
||||
import json
|
||||
|
||||
# third-party imports
|
||||
import pytest
|
||||
|
||||
# local imports
|
||||
from cic_ussd.state_machine.logic.transaction import (has_sufficient_balance,
|
||||
is_valid_recipient,
|
||||
is_valid_transaction_amount,
|
||||
process_transaction_request,
|
||||
save_recipient_phone_to_session_data,
|
||||
save_transaction_amount_to_session_data)
|
||||
from cic_ussd.redis import InMemoryStore
|
||||
|
||||
|
||||
@pytest.mark.parametrize("amount, expected_result", [
|
||||
('50', True),
|
||||
('', False)
|
||||
])
|
||||
def test_is_valid_transaction_amount(create_activated_user, create_in_db_ussd_session, amount, expected_result):
|
||||
state_machine_data = (amount, create_in_db_ussd_session, create_activated_user)
|
||||
validity = is_valid_transaction_amount(state_machine_data=state_machine_data)
|
||||
assert validity == expected_result
|
||||
|
||||
|
||||
def test_save_recipient_phone_to_session_data(create_activated_user,
|
||||
create_in_db_ussd_session,
|
||||
celery_session_worker,
|
||||
create_in_redis_ussd_session,
|
||||
init_database):
|
||||
phone_number = '+254712345678'
|
||||
in_memory_ussd_session = InMemoryStore.cache.get('AT974186')
|
||||
in_memory_ussd_session = json.loads(in_memory_ussd_session)
|
||||
|
||||
assert in_memory_ussd_session.get('session_data') == {}
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (phone_number, serialized_in_db_ussd_session, create_activated_user)
|
||||
save_recipient_phone_to_session_data(state_machine_data=state_machine_data)
|
||||
|
||||
in_memory_ussd_session = InMemoryStore.cache.get('AT974186')
|
||||
in_memory_ussd_session = json.loads(in_memory_ussd_session)
|
||||
|
||||
assert in_memory_ussd_session.get('session_data')['recipient_phone_number'] == phone_number
|
||||
|
||||
|
||||
def test_save_transaction_amount_to_session_data(create_activated_user,
|
||||
create_in_db_ussd_session,
|
||||
celery_session_worker,
|
||||
create_in_redis_ussd_session,
|
||||
init_database):
|
||||
transaction_amount = '100'
|
||||
in_memory_ussd_session = InMemoryStore.cache.get('AT974186')
|
||||
in_memory_ussd_session = json.loads(in_memory_ussd_session)
|
||||
|
||||
assert in_memory_ussd_session.get('session_data') == {}
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (transaction_amount, serialized_in_db_ussd_session, create_activated_user)
|
||||
save_transaction_amount_to_session_data(state_machine_data=state_machine_data)
|
||||
|
||||
in_memory_ussd_session = InMemoryStore.cache.get('AT974186')
|
||||
in_memory_ussd_session = json.loads(in_memory_ussd_session)
|
||||
|
||||
assert in_memory_ussd_session.get('session_data')['transaction_amount'] == transaction_amount
|
||||
|
||||
|
||||
@pytest.mark.parametrize("test_value, expected_result", [
|
||||
('45', True),
|
||||
('75', False)
|
||||
])
|
||||
def test_has_sufficient_balance(mock_balance,
|
||||
create_in_db_ussd_session,
|
||||
create_valid_tx_sender,
|
||||
expected_result,
|
||||
test_value):
|
||||
mock_balance(60)
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (test_value, serialized_in_db_ussd_session, create_valid_tx_sender)
|
||||
result = has_sufficient_balance(state_machine_data=state_machine_data)
|
||||
assert result == expected_result
|
||||
|
||||
|
||||
@pytest.mark.parametrize("test_value, expected_result", [
|
||||
('+25498765432', True),
|
||||
('+25498765433', False)
|
||||
])
|
||||
def test_is_valid_recipient(create_in_db_ussd_session,
|
||||
create_valid_tx_recipient,
|
||||
create_valid_tx_sender,
|
||||
expected_result,
|
||||
test_value):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (test_value, serialized_in_db_ussd_session, create_valid_tx_sender)
|
||||
result = is_valid_recipient(state_machine_data=state_machine_data)
|
||||
assert result == expected_result
|
||||
|
||||
|
||||
def test_process_transaction_request(create_valid_tx_recipient,
|
||||
create_valid_tx_sender,
|
||||
load_config,
|
||||
mock_outgoing_transactions,
|
||||
setup_chain_spec,
|
||||
ussd_session_data):
|
||||
ussd_session_data['session_data'] = {
|
||||
'recipient_phone_number': create_valid_tx_recipient.phone_number,
|
||||
'transaction_amount': '50'
|
||||
}
|
||||
state_machine_data = ('', ussd_session_data, create_valid_tx_sender)
|
||||
process_transaction_request(state_machine_data=state_machine_data)
|
||||
assert mock_outgoing_transactions[0].get('amount') == 50.0
|
||||
assert mock_outgoing_transactions[0].get('token_symbol') == 'SRF'
|
||||
@@ -0,0 +1,112 @@
|
||||
# standard imports
|
||||
import json
|
||||
|
||||
# external imports
|
||||
import pytest
|
||||
import requests_mock
|
||||
from chainlib.hash import strip_0x
|
||||
|
||||
# local imports
|
||||
from cic_ussd.account.transaction import to_wei
|
||||
from cic_ussd.cache import get_cached_data
|
||||
from cic_ussd.metadata import PersonMetadata
|
||||
from cic_ussd.state_machine.logic.transaction import (is_valid_recipient,
|
||||
is_valid_transaction_amount,
|
||||
has_sufficient_balance,
|
||||
process_transaction_request,
|
||||
retrieve_recipient_metadata,
|
||||
save_recipient_phone_to_session_data,
|
||||
save_transaction_amount_to_session_data)
|
||||
|
||||
|
||||
# test imports
|
||||
|
||||
|
||||
def test_is_valid_recipient(activated_account,
|
||||
generic_ussd_session,
|
||||
init_database,
|
||||
load_e164_region,
|
||||
pending_account,
|
||||
valid_recipient):
|
||||
state_machine = ('0112365478', generic_ussd_session, valid_recipient, init_database)
|
||||
assert is_valid_recipient(state_machine) is False
|
||||
state_machine = (pending_account.phone_number, generic_ussd_session, valid_recipient, init_database)
|
||||
assert is_valid_recipient(state_machine) is False
|
||||
state_machine = (valid_recipient.phone_number, generic_ussd_session, activated_account, init_database)
|
||||
assert is_valid_recipient(state_machine) is True
|
||||
|
||||
|
||||
@pytest.mark.parametrize("amount, expected_result", [
|
||||
('50', True),
|
||||
('', False)
|
||||
])
|
||||
def test_is_valid_transaction_amount(activated_account, amount, expected_result, generic_ussd_session, init_database):
|
||||
state_machine_data = (amount, generic_ussd_session, activated_account, init_database)
|
||||
assert is_valid_transaction_amount(state_machine_data) is expected_result
|
||||
|
||||
|
||||
@pytest.mark.parametrize("value, expected_result", [
|
||||
('45', True),
|
||||
('75', False)
|
||||
])
|
||||
def test_has_sufficient_balance(activated_account,
|
||||
cache_balances,
|
||||
expected_result,
|
||||
generic_ussd_session,
|
||||
init_database,
|
||||
value):
|
||||
state_machine_data = (value, generic_ussd_session, activated_account, init_database)
|
||||
assert has_sufficient_balance(state_machine_data=state_machine_data) == expected_result
|
||||
|
||||
|
||||
def test_process_transaction_request(activated_account,
|
||||
cache_default_token_data,
|
||||
cached_ussd_session,
|
||||
celery_session_worker,
|
||||
init_cache,
|
||||
init_database,
|
||||
load_chain_spec,
|
||||
load_config,
|
||||
mock_transfer_api,
|
||||
valid_recipient):
|
||||
cached_ussd_session.set_data('recipient_phone_number', valid_recipient.phone_number)
|
||||
cached_ussd_session.set_data('transaction_amount', '50')
|
||||
ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session = json.loads(ussd_session)
|
||||
state_machine_data = ('', ussd_session, activated_account, init_database)
|
||||
process_transaction_request(state_machine_data)
|
||||
assert mock_transfer_api['from_address'] == activated_account.blockchain_address
|
||||
assert mock_transfer_api['to_address'] == valid_recipient.blockchain_address
|
||||
assert mock_transfer_api['value'] == to_wei(50)
|
||||
assert mock_transfer_api['token_symbol'] == load_config.get('TEST_TOKEN_SYMBOL')
|
||||
|
||||
|
||||
def test_retrieve_recipient_metadata(activated_account,
|
||||
generic_ussd_session,
|
||||
init_database,
|
||||
load_chain_spec,
|
||||
mocker,
|
||||
valid_recipient):
|
||||
state_machine_data = (valid_recipient.phone_number, generic_ussd_session, activated_account, init_database)
|
||||
mocked_query_metadata = mocker.patch('cic_ussd.tasks.metadata.query_person_metadata.apply_async')
|
||||
retrieve_recipient_metadata(state_machine_data)
|
||||
mocked_query_metadata.assert_called_with((valid_recipient.blockchain_address, ), {}, queue='cic-ussd')
|
||||
|
||||
|
||||
def test_transaction_information_to_session_data(activated_account,
|
||||
cached_ussd_session,
|
||||
init_cache,
|
||||
init_database,
|
||||
load_e164_region,
|
||||
valid_recipient):
|
||||
assert cached_ussd_session.to_json()['data'] == {}
|
||||
state_machine_data = (valid_recipient.phone_number, cached_ussd_session.to_json(), activated_account, init_database)
|
||||
save_recipient_phone_to_session_data(state_machine_data)
|
||||
ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session = json.loads(ussd_session)
|
||||
assert ussd_session.get('data')['recipient_phone_number'] == valid_recipient.phone_number
|
||||
state_machine_data = ('25', cached_ussd_session.to_json(), activated_account, init_database)
|
||||
save_transaction_amount_to_session_data(state_machine_data)
|
||||
ussd_session = get_cached_data(cached_ussd_session.external_session_id)
|
||||
ussd_session = json.loads(ussd_session)
|
||||
assert ussd_session.get('data')['transaction_amount'] == '25'
|
||||
@@ -1,155 +0,0 @@
|
||||
# standard imports
|
||||
import json
|
||||
|
||||
# third-party-imports
|
||||
import pytest
|
||||
|
||||
# local imports
|
||||
from cic_ussd.chain import Chain
|
||||
from cic_ussd.redis import InMemoryStore
|
||||
from cic_ussd.state_machine.logic.user import (
|
||||
change_preferred_language_to_en,
|
||||
change_preferred_language_to_sw,
|
||||
edit_user_metadata_attribute,
|
||||
format_user_metadata,
|
||||
get_user_metadata,
|
||||
save_complete_user_metadata,
|
||||
process_gender_user_input,
|
||||
save_metadata_attribute_to_session_data,
|
||||
update_account_status_to_active)
|
||||
|
||||
|
||||
def test_change_preferred_language(create_pending_user, create_in_db_ussd_session):
|
||||
state_machine_data = ('', create_in_db_ussd_session, create_pending_user)
|
||||
assert create_pending_user.preferred_language is None
|
||||
change_preferred_language_to_en(state_machine_data)
|
||||
assert create_pending_user.preferred_language == 'en'
|
||||
change_preferred_language_to_sw(state_machine_data)
|
||||
assert create_pending_user.preferred_language == 'sw'
|
||||
|
||||
|
||||
def test_update_account_status_to_active(create_pending_user, create_in_db_ussd_session):
|
||||
state_machine_data = ('', create_in_db_ussd_session, create_pending_user)
|
||||
update_account_status_to_active(state_machine_data)
|
||||
assert create_pending_user.get_account_status() == 'ACTIVE'
|
||||
|
||||
|
||||
@pytest.mark.parametrize("current_state, expected_key, expected_result, user_input", [
|
||||
("enter_given_name", "given_name", "John", "John"),
|
||||
("enter_family_name", "family_name", "Doe", "Doe"),
|
||||
("enter_gender", "gender", "Male", "1"),
|
||||
("enter_location", "location", "Kangemi", "Kangemi"),
|
||||
("enter_products", "products", "Mandazi", "Mandazi"),
|
||||
])
|
||||
def test_save_metadata_attribute_to_session_data(current_state,
|
||||
expected_key,
|
||||
expected_result,
|
||||
user_input,
|
||||
celery_session_worker,
|
||||
create_activated_user,
|
||||
create_in_db_ussd_session,
|
||||
create_in_redis_ussd_session):
|
||||
create_in_db_ussd_session.state = current_state
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (user_input, serialized_in_db_ussd_session, create_activated_user)
|
||||
in_memory_ussd_session = InMemoryStore.cache.get('AT974186')
|
||||
in_memory_ussd_session = json.loads(in_memory_ussd_session)
|
||||
assert in_memory_ussd_session.get('session_data') == {}
|
||||
serialized_in_db_ussd_session['state'] = current_state
|
||||
save_metadata_attribute_to_session_data(state_machine_data=state_machine_data)
|
||||
|
||||
in_memory_ussd_session = InMemoryStore.cache.get('AT974186')
|
||||
in_memory_ussd_session = json.loads(in_memory_ussd_session)
|
||||
|
||||
assert in_memory_ussd_session.get('session_data')[expected_key] == expected_result
|
||||
|
||||
|
||||
@pytest.mark.parametrize("preferred_language, user_input, expected_gender_value", [
|
||||
("en", "1", "Male"),
|
||||
("en", "2", "Female"),
|
||||
("sw", "1", "Mwanaume"),
|
||||
("sw", "2", "Mwanamke"),
|
||||
])
|
||||
def test_process_gender_user_input(create_activated_user, expected_gender_value, preferred_language, user_input):
|
||||
create_activated_user.preferred_language = preferred_language
|
||||
gender = process_gender_user_input(user=create_activated_user, user_input=user_input)
|
||||
assert gender == expected_gender_value
|
||||
|
||||
|
||||
def test_format_user_metadata(create_activated_user,
|
||||
complete_user_metadata,
|
||||
setup_chain_spec):
|
||||
from cic_types.models.person import Person
|
||||
formatted_user_metadata = format_user_metadata(metadata=complete_user_metadata, user=create_activated_user)
|
||||
person = Person()
|
||||
user_metadata = person.deserialize(person_data=formatted_user_metadata)
|
||||
assert formatted_user_metadata == user_metadata.serialize()
|
||||
|
||||
|
||||
def test_save_complete_user_metadata(celery_session_worker,
|
||||
complete_user_metadata,
|
||||
create_activated_user,
|
||||
create_in_redis_ussd_session,
|
||||
mocker,
|
||||
setup_chain_spec,
|
||||
ussd_session_data):
|
||||
ussd_session = create_in_redis_ussd_session.get(ussd_session_data.get('external_session_id'))
|
||||
ussd_session = json.loads(ussd_session)
|
||||
ussd_session['session_data'] = complete_user_metadata
|
||||
user_metadata = format_user_metadata(metadata=ussd_session.get('session_data'), user=create_activated_user)
|
||||
state_machine_data = ('', ussd_session, create_activated_user)
|
||||
mocked_create_metadata_task = mocker.patch('cic_ussd.tasks.metadata.create_person_metadata.apply_async')
|
||||
save_complete_user_metadata(state_machine_data=state_machine_data)
|
||||
mocked_create_metadata_task.assert_called_with(
|
||||
(user_metadata, create_activated_user.blockchain_address),
|
||||
{},
|
||||
queue='cic-ussd'
|
||||
)
|
||||
|
||||
|
||||
def test_edit_user_metadata_attribute(celery_session_worker,
|
||||
cached_user_metadata,
|
||||
create_activated_user,
|
||||
create_in_redis_ussd_session,
|
||||
init_redis_cache,
|
||||
mocker,
|
||||
person_metadata,
|
||||
setup_chain_spec,
|
||||
ussd_session_data):
|
||||
ussd_session = create_in_redis_ussd_session.get(ussd_session_data.get('external_session_id'))
|
||||
ussd_session = json.loads(ussd_session)
|
||||
|
||||
assert person_metadata['location']['area_name'] == 'kayaba'
|
||||
|
||||
# appropriately format session
|
||||
ussd_session['session_data'] = {
|
||||
'location': 'nairobi'
|
||||
}
|
||||
state_machine_data = ('', ussd_session, create_activated_user)
|
||||
|
||||
mocked_edit_metadata = mocker.patch('cic_ussd.tasks.metadata.edit_person_metadata.apply_async')
|
||||
edit_user_metadata_attribute(state_machine_data=state_machine_data)
|
||||
person_metadata['location']['area_name'] = 'nairobi'
|
||||
mocked_edit_metadata.assert_called_with(
|
||||
(create_activated_user.blockchain_address, person_metadata, Chain.spec.engine()),
|
||||
{},
|
||||
queue='cic-ussd'
|
||||
)
|
||||
|
||||
|
||||
def test_get_user_metadata_attribute(celery_session_worker,
|
||||
create_activated_user,
|
||||
create_in_redis_ussd_session,
|
||||
mocker,
|
||||
ussd_session_data):
|
||||
ussd_session = create_in_redis_ussd_session.get(ussd_session_data.get('external_session_id'))
|
||||
ussd_session = json.loads(ussd_session)
|
||||
state_machine_data = ('', ussd_session, create_activated_user)
|
||||
|
||||
mocked_get_metadata = mocker.patch('cic_ussd.tasks.metadata.query_person_metadata.apply_async')
|
||||
get_user_metadata(state_machine_data=state_machine_data)
|
||||
mocked_get_metadata.assert_called_with(
|
||||
(create_activated_user.blockchain_address,),
|
||||
{},
|
||||
queue='cic-ussd'
|
||||
)
|
||||
@@ -1,55 +1,54 @@
|
||||
# standard imports
|
||||
import json
|
||||
|
||||
# third-party imports
|
||||
# external imports
|
||||
import pytest
|
||||
from cic_types.models.person import generate_metadata_pointer
|
||||
|
||||
# local imports
|
||||
from cic_ussd.metadata import blockchain_address_to_metadata_pointer
|
||||
from cic_ussd.redis import cache_data
|
||||
from cic_ussd.state_machine.logic.validator import (is_valid_name,
|
||||
from cic_ussd.state_machine.logic.validator import (has_cached_person_metadata,
|
||||
is_valid_name,
|
||||
is_valid_gender_selection,
|
||||
has_cached_user_metadata)
|
||||
is_valid_date)
|
||||
|
||||
# test imports
|
||||
|
||||
|
||||
def test_has_cached_person_metadata(activated_account,
|
||||
cache_person_metadata,
|
||||
generic_ussd_session,
|
||||
init_database,
|
||||
pending_account):
|
||||
state_machine_data = ('', generic_ussd_session, activated_account, init_database)
|
||||
assert has_cached_person_metadata(state_machine_data) is True
|
||||
state_machine_data = ('', generic_ussd_session, pending_account, init_database)
|
||||
assert has_cached_person_metadata(state_machine_data) is False
|
||||
|
||||
|
||||
@pytest.mark.parametrize("user_input, expected_result", [
|
||||
("Arya", True),
|
||||
("1234", False)
|
||||
])
|
||||
def test_is_valid_name(create_in_db_ussd_session, create_pending_user, user_input, expected_result):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (user_input, serialized_in_db_ussd_session, create_pending_user)
|
||||
result = is_valid_name(state_machine_data=state_machine_data)
|
||||
assert result is expected_result
|
||||
def test_is_valid_name(expected_result, generic_ussd_session, init_database, pending_account, user_input):
|
||||
|
||||
|
||||
def test_has_cached_user_metadata(create_in_db_ussd_session,
|
||||
create_activated_user,
|
||||
init_redis_cache,
|
||||
person_metadata):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = ('', serialized_in_db_ussd_session, create_activated_user)
|
||||
result = has_cached_user_metadata(state_machine_data=state_machine_data)
|
||||
assert result is False
|
||||
# cache metadata
|
||||
user = create_activated_user
|
||||
key = generate_metadata_pointer(
|
||||
identifier=blockchain_address_to_metadata_pointer(blockchain_address=user.blockchain_address),
|
||||
cic_type=':cic.person'
|
||||
)
|
||||
cache_data(key=key, data=json.dumps(person_metadata))
|
||||
result = has_cached_user_metadata(state_machine_data=state_machine_data)
|
||||
assert result
|
||||
state_machine_data = (user_input, generic_ussd_session, pending_account, init_database)
|
||||
assert is_valid_name(state_machine_data) is expected_result
|
||||
|
||||
|
||||
@pytest.mark.parametrize("user_input, expected_result", [
|
||||
("1", True),
|
||||
("2", True),
|
||||
("3", True),
|
||||
("4", False)
|
||||
])
|
||||
def test_is_valid_gender_selection(expected_result, generic_ussd_session, init_database, pending_account, user_input):
|
||||
state_machine_data = (user_input, generic_ussd_session, pending_account, init_database)
|
||||
assert is_valid_gender_selection(state_machine_data) is expected_result
|
||||
|
||||
|
||||
@pytest.mark.parametrize("user_input, expected_result", [
|
||||
("1935", True),
|
||||
("1825", False),
|
||||
("3", False)
|
||||
])
|
||||
def test_is_valid_gender_selection(create_in_db_ussd_session, create_pending_user, user_input, expected_result):
|
||||
serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
|
||||
state_machine_data = (user_input, serialized_in_db_ussd_session, create_pending_user)
|
||||
result = is_valid_gender_selection(state_machine_data=state_machine_data)
|
||||
assert result is expected_result
|
||||
def test_is_valid_date(expected_result, generic_ussd_session, init_database, pending_account, user_input):
|
||||
state_machine_data = (user_input, generic_ussd_session, pending_account, init_database)
|
||||
assert is_valid_date(state_machine_data) is expected_result
|
||||
|
||||
Reference in New Issue
Block a user