kamikazechaser/cic-internal-integration
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

The great bump

Browse Source
This commit is contained in:
Philip Wafula
2021-08-06 16:29:01 +00:00
parent f764b73f66
commit 0672a17d2e
195 changed files with 5791 additions and 4983 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
apps/cic-ussd/tests/cic_ussd/metadata/test_base.py Normal file
View File

@@ -0,0 +1,44 @@
# standard imports
import json
import os
# external imports
import requests_mock
from chainlib.hash import strip_0x
from cic_types.processor import generate_metadata_pointer
# local imports
from cic_ussd.metadata.base import MetadataRequestsHandler
# external imports
def test_metadata_requests_handler(activated_account,
init_cache,
load_config,
person_metadata,
setup_metadata_request_handler,
setup_metadata_signer):
identifier = bytes.fromhex(strip_0x(activated_account.blockchain_address))
cic_type = ':cic.person'
metadata_client = MetadataRequestsHandler(cic_type, identifier)
assert metadata_client.cic_type == cic_type
assert metadata_client.engine == 'pgp'
assert metadata_client.identifier == identifier
assert metadata_client.metadata_pointer == generate_metadata_pointer(identifier, cic_type)
assert metadata_client.url == os.path.join(load_config.get('CIC_META_URL'), metadata_client.metadata_pointer)
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri('POST', metadata_client.url, status_code=200, reason='OK', json=person_metadata)
person_metadata['digest'] = os.urandom(20).hex()
request_mocker.register_uri('PUT', metadata_client.url, status_code=200, reason='OK', json=person_metadata)
result = metadata_client.create(person_metadata)
assert result.json() == person_metadata
assert result.status_code == 200
person_metadata.pop('digest')
request_mocker.register_uri('GET', metadata_client.url, status_code=200, reason='OK', json=person_metadata)
result = metadata_client.query()
assert result == person_metadata
cached_metadata = metadata_client.get_cached_metadata()
assert json.loads(cached_metadata) == person_metadata

22
apps/cic-ussd/tests/cic_ussd/metadata/test_custom.py Normal file
View File

@@ -0,0 +1,22 @@
# standard imports
import os
# external imports
from chainlib.hash import strip_0x
from cic_types.processor import generate_metadata_pointer
# local imports
from cic_ussd.metadata import CustomMetadata
# test imports
def test_custom_metadata(activated_account, load_config, setup_metadata_request_handler, setup_metadata_signer):
cic_type = ':cic.custom'
identifier = bytes.fromhex(strip_0x(activated_account.blockchain_address))
custom_metadata_client = CustomMetadata(identifier)
assert custom_metadata_client.cic_type == cic_type
assert custom_metadata_client.engine == 'pgp'
assert custom_metadata_client.identifier == identifier
assert custom_metadata_client.metadata_pointer == generate_metadata_pointer(identifier, cic_type)
assert custom_metadata_client.url == os.path.join(
load_config.get('CIC_META_URL'), custom_metadata_client.metadata_pointer)

80
apps/cic-ussd/tests/cic_ussd/metadata/test_metadata.py
View File

@@ -1,80 +0,0 @@
# standard imports
import json
# third-party imports
import pytest
import requests
import requests_mock
# local imports
from cic_ussd.error import UnsupportedMethodError
from cic_ussd.metadata import blockchain_address_to_metadata_pointer, make_request
def test_make_request(define_metadata_pointer_url, mock_meta_get_response, mock_meta_post_response, person_metadata):
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'GET',
define_metadata_pointer_url,
status_code=200,
reason='OK',
content=json.dumps(mock_meta_get_response).encode('utf-8')
)
response = make_request(method='GET', url=define_metadata_pointer_url)
assert response.content == requests.get(define_metadata_pointer_url).content
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'POST',
define_metadata_pointer_url,
status_code=201,
reason='CREATED',
content=json.dumps(mock_meta_post_response).encode('utf-8')
)
response = make_request(
method='POST',
url=define_metadata_pointer_url,
data=json.dumps(person_metadata).encode('utf-8'),
headers={
'X-CIC-AUTOMERGE': 'server',
'Content-Type': 'application/json'
}
)
assert response.content == requests.post(define_metadata_pointer_url).content
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'PUT',
define_metadata_pointer_url,
status_code=200,
reason='OK'
)
response = make_request(
method='PUT',
url=define_metadata_pointer_url,
data=json.dumps(person_metadata).encode('utf-8'),
headers={
'X-CIC-AUTOMERGE': 'server',
'Content-Type': 'application/json'
}
)
assert response.content == requests.put(define_metadata_pointer_url).content
with pytest.raises(UnsupportedMethodError) as error:
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'DELETE',
define_metadata_pointer_url,
status_code=200,
reason='OK'
)
make_request(
method='DELETE',
url=define_metadata_pointer_url
)
assert str(error.value) == 'Unsupported method: DELETE'
def test_blockchain_address_to_metadata_pointer(create_activated_user):
blockchain_address = create_activated_user.blockchain_address
assert type(blockchain_address_to_metadata_pointer(blockchain_address)) == bytes

22
apps/cic-ussd/tests/cic_ussd/metadata/test_person.py Normal file
View File

@@ -0,0 +1,22 @@
# standard imports
import os
# external imports
from chainlib.hash import strip_0x
from cic_types.processor import generate_metadata_pointer
# local imports
from cic_ussd.metadata import PersonMetadata
# test imports
def test_person_metadata(activated_account, load_config, setup_metadata_request_handler, setup_metadata_signer):
cic_type = ':cic.person'
identifier = bytes.fromhex(strip_0x(activated_account.blockchain_address))
person_metadata_client = PersonMetadata(identifier)
assert person_metadata_client.cic_type == cic_type
assert person_metadata_client.engine == 'pgp'
assert person_metadata_client.identifier == identifier
assert person_metadata_client.metadata_pointer == generate_metadata_pointer(identifier, cic_type)
assert person_metadata_client.url == os.path.join(
load_config.get('CIC_META_URL'), person_metadata_client.metadata_pointer)

23
apps/cic-ussd/tests/cic_ussd/metadata/test_phone.py Normal file
View File

@@ -0,0 +1,23 @@
# standard imports
import os
# external imports
from chainlib.hash import strip_0x
from cic_types.processor import generate_metadata_pointer
# local imports
from cic_ussd.metadata import PhonePointerMetadata
# test imports
def test_phone_pointer_metadata(activated_account, load_config, setup_metadata_request_handler, setup_metadata_signer):
cic_type = ':cic.phone'
identifier = bytes.fromhex(strip_0x(activated_account.blockchain_address))
phone_pointer_metadata = PhonePointerMetadata(identifier)
assert phone_pointer_metadata.cic_type == cic_type
assert phone_pointer_metadata.engine == 'pgp'
assert phone_pointer_metadata.identifier == identifier
assert phone_pointer_metadata.metadata_pointer == generate_metadata_pointer(identifier, cic_type)
assert phone_pointer_metadata.url == os.path.join(
load_config.get('CIC_META_URL'), phone_pointer_metadata.metadata_pointer)

22
apps/cic-ussd/tests/cic_ussd/metadata/test_preferences.py Normal file
View File

@@ -0,0 +1,22 @@
# standard imports
import os
# external imports
from chainlib.hash import strip_0x
from cic_types.processor import generate_metadata_pointer
# local imports
from cic_ussd.metadata import PreferencesMetadata
# test imports
def test_preferences_metadata(activated_account, load_config, setup_metadata_request_handler, setup_metadata_signer):
cic_type = ':cic.preferences'
identifier = bytes.fromhex(strip_0x(activated_account.blockchain_address))
preferences_metadata_client = PreferencesMetadata(identifier)
assert preferences_metadata_client.cic_type == cic_type
assert preferences_metadata_client.engine == 'pgp'
assert preferences_metadata_client.identifier == identifier
assert preferences_metadata_client.metadata_pointer == generate_metadata_pointer(identifier, cic_type)
assert preferences_metadata_client.url == os.path.join(
load_config.get('CIC_META_URL'), preferences_metadata_client.metadata_pointer)

17
apps/cic-ussd/tests/cic_ussd/metadata/test_signer.py
View File

@@ -9,26 +9,9 @@ from cic_ussd.metadata.signer import Signer
def test_client(load_config, setup_metadata_signer, person_metadata):
signer = Signer()
# get gpg used
digest = 'a4337bc45a8fc544c03f52dc550cd6e1e87021bc896588bd79e901e2'
person_metadata['digest'] = digest
gpg = signer.gpg
# check that key data was loaded
assert signer.key_data is not None
# check that correct operational key is returned
gpg.import_keys(key_data=signer.key_data)
gpg_keys = gpg.list_keys()
assert signer.get_operational_key() == gpg_keys[0]
# check that correct signature is returned
key_id = signer.get_operational_key().get('keyid')
signature = gpg.sign(message=digest, passphrase=load_config.get('KEYS_PASSPHRASE'), keyid=key_id)
assert str(signature) == signer.sign_digest(data=person_metadata)
# remove tmp gpg file
shutil.rmtree(Signer.gpg_path)

123
apps/cic-ussd/tests/cic_ussd/metadata/test_user_metadata.py
View File

@@ -1,123 +0,0 @@
# standard imports
import json
# third-party imports
import pytest
import requests_mock
from cic_types.models.person import generate_metadata_pointer
# local imports
from cic_ussd.metadata import blockchain_address_to_metadata_pointer
from cic_ussd.metadata.signer import Signer
from cic_ussd.metadata.person import PersonMetadata
from cic_ussd.redis import get_cached_data
def test_user_metadata(create_activated_user, define_metadata_pointer_url, load_config):
PersonMetadata.base_url = load_config.get('CIC_META_URL')
identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
person_metadata_client = PersonMetadata(identifier=identifier)
assert person_metadata_client.url == define_metadata_pointer_url
def test_create_person_metadata(caplog,
create_activated_user,
define_metadata_pointer_url,
load_config,
mock_meta_post_response,
person_metadata):
identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
person_metadata_client = PersonMetadata(identifier=identifier)
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'POST',
define_metadata_pointer_url,
status_code=201,
reason='CREATED',
content=json.dumps(mock_meta_post_response).encode('utf-8')
)
person_metadata_client.create(data=person_metadata)
assert 'Get signed material response status: 201' in caplog.text
with pytest.raises(RuntimeError) as error:
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'POST',
define_metadata_pointer_url,
status_code=400,
reason='BAD REQUEST'
)
person_metadata_client.create(data=person_metadata)
assert str(error.value) == f'400 Client Error: BAD REQUEST for url: {define_metadata_pointer_url}'
def test_edit_person_metadata(caplog,
create_activated_user,
define_metadata_pointer_url,
load_config,
person_metadata,
setup_metadata_signer):
Signer.gpg_passphrase = load_config.get('KEYS_PASSPHRASE')
identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
person_metadata_client = PersonMetadata(identifier=identifier)
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'PUT',
define_metadata_pointer_url,
status_code=200,
reason='OK'
)
person_metadata_client.edit(data=person_metadata)
assert 'Signed content submission status: 200' in caplog.text
with pytest.raises(RuntimeError) as error:
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'PUT',
define_metadata_pointer_url,
status_code=400,
reason='BAD REQUEST'
)
person_metadata_client.edit(data=person_metadata)
assert str(error.value) == f'400 Client Error: BAD REQUEST for url: {define_metadata_pointer_url}'
def test_get_user_metadata(caplog,
create_activated_user,
define_metadata_pointer_url,
init_redis_cache,
load_config,
person_metadata,
setup_metadata_signer):
identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
person_metadata_client = PersonMetadata(identifier=identifier)
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'GET',
define_metadata_pointer_url,
status_code=200,
content=json.dumps(person_metadata).encode('utf-8'),
reason='OK'
)
person_metadata_client.query()
assert 'Get latest data status: 200' in caplog.text
key = generate_metadata_pointer(
identifier=identifier,
cic_type=':cic.person'
)
cached_user_metadata = get_cached_data(key=key)
assert cached_user_metadata
with pytest.raises(RuntimeError) as error:
with requests_mock.Mocker(real_http=False) as request_mocker:
request_mocker.register_uri(
'GET',
define_metadata_pointer_url,
status_code=404,
reason='NOT FOUND'
)
person_metadata_client.query()
assert 'The data is not available and might need to be added.' in caplog.text
assert str(error.value) == f'400 Client Error: NOT FOUND for url: {define_metadata_pointer_url}'