def test_put_app_key_required_fail(app, mocker):
expected_status = 400
expected_json = {
'error': {
'application': ['Missing data for required field.'],
'foo': ['Unknown field.'],
'key': ['Missing data for required field.'],
'status': ['Missing data for required field.'],
}
}
request_mock = mocker.patch('modules.app_keys.routes_admin.request')
request_mock.json = {'foo': "bar"}
app_key_1 = AppKey()
app_key_1.id = 1
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.get.return_value = app_key_1
query_mock.return_value \
.filter.return_value \
.first.return_value = None
result = put_app_key(1)
assert result[1] == expected_status
assert result[0].json == expected_json
def test_put_app_key_type_fail(app, mocker):
expected_status = 400
expected_json = {
'error': {
'application': ['Not a valid string.'],
'key': ['Not a valid string.'],
'status': ['Not a valid integer.'],
}
}
request_mock = mocker.patch('modules.app_keys.routes_admin.request')
request_mock.json = {
'application': 10,
'key': 15,
"status": 'enabled'
}
app_key_1 = AppKey()
app_key_1.id = 1
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.get.return_value = app_key_1
query_mock.return_value \
.filter.return_value \
.first.return_value = None
result = put_app_key(1)
assert result[1] == expected_status
assert result[0].json == expected_json
def test_put_app_key_min_fail(app, mocker):
expected_status = 400
expected_json = {
'error': {
'application': [
'Value must be between 2 and 200 characters long.'],
'key': ['Value must be 32 characters long.'],
}
}
request_mock = mocker.patch('modules.app_keys.routes_admin.request')
request_mock.json = {
'application': "T",
'key': "B8CzqaJWs9TmffSJjxDCFrepzhvYzrK",
"status": 1
}
app_key_1 = AppKey()
app_key_1.id = 1
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.get.return_value = app_key_1
query_mock.return_value \
.filter.return_value \
.first.return_value = None
result = put_app_key(1)
assert result[1] == expected_status
assert result[0].json == expected_json
def test_put_app_key_max_fail(app, mocker):
expected_status = 400
expected_json = {
'error': {
'application': [
'Value must be between 2 and 200 characters long.'],
'key': ['Value must be 32 characters long.'],
}
}
request_mock = mocker.patch('modules.app_keys.routes_admin.request')
request_mock.json = {
'application': "9xAqdEjnQ8uHmQjnSWUutERKfmgBFjWWsKkwKy4EBbpjeC8FuAXYH4bBqg5FVGapD47LTDsJmUU7dgUrxBVuSjhRUcQvxxukMvVs87ndpZ76DK9ZULFB77DjGDxmqJ5QHfEV6FjNXK2sbkFzdUBbbkPkcGpvgMqamdP33WpMFcDXpAftcRJyUJtMpVStZ3MMBS7LLVuBaDSBznGSfnpzTk6dS8zhnxpy8EayF6LSuKUjN3d2JkCrRDge5W8Rcmve",
'key': "AFJdJ9JCUhASZ4cA2ptC7CA72bYKLZD28",
"status": 1
}
app_key_1 = AppKey()
app_key_1.id = 1
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.get.return_value = app_key_1
query_mock.return_value \
.filter.return_value \
.first.return_value = None
result = put_app_key(1)
assert result[1] == expected_status
assert result[0].json == expected_json
def test_get_app_keys_empty_route(app, mocker, client):
expected_status = 204
expected_json = None
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock user login db query
role2 = Role()
role2.id = 2
role2.name = 'SUPER_ADMIN'
role2.password_reset_days = 365
admin1 = Administrator()
admin1.id = 1
admin1.password = '******'
admin1.roles = [role2]
query_mock.return_value \
.filter.return_value \
.first.return_value = admin1
auth_db_mock = mocker.patch('modules.administrators.authentication.db')
auth_db_mock.add.return_value = None
auth_db_mock.commit.return_value = None
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.limit.return_value \
.offset.return_value \
.__iter__.return_value = []
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.count.return_value = 15
# mock user login
auth_mock = mocker.patch(
'modules.administrators.Authentication.is_account_locked')
auth_mock.return_value = False
credentials = base64.b64encode(
'admin1:admin1pass'.encode('ascii')).decode('utf-8')
response = client.get("/app_keys/3?app_key=123",
headers={"Authorization": f"Basic {credentials}"})
assert response.status_code == expected_status
assert response.json == expected_json
def test_get_regions_route_ok(app, mocker, client):
expected_status = 200
expected_length = 8
expected_limit = 100
expected_page = 1
expected_total = 8
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.filter.return_value \
.limit.return_value \
.offset.return_value \
.__iter__.return_value = [Region()] * expected_length
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.filter.return_value \
.count.return_value = expected_total
response = client.get("/regions/US?app_key=123")
assert response.status_code == expected_status
assert len(response.json['regions']) == expected_length
assert response.json['limit'] == expected_limit
assert response.json['page'] == expected_page
assert response.json['total'] == expected_total
def test_get_app_keys(app, mocker):
expected_status = 200
expected_length = 2
expected_properties = ['application', 'created_at', 'id', 'key', 'status',
'status_changed_at', 'updated_at']
expected_limit = 10
expected_page = 1
expected_total = 2
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.limit.return_value \
.offset.return_value \
.__iter__.return_value = [AppKey()] * expected_length
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.count.return_value = expected_total
result = get_app_keys()
assert result[1] == expected_status
assert len(result[0].json['app_keys']) == expected_length
assert result[0].json['app_keys'][0] == {
x: None for x in expected_properties}
assert result[0].json['limit'] == expected_limit
assert result[0].json['page'] == expected_page
assert result[0].json['total'] == expected_total
def test_get_terms_of_service_ok_route(app, mocker, client):
expected_status = 200
expected_json = {
'terms_of_service': {
'id': None,
'publish_date': None,
'text': None,
'version': None
}
}
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.limit.return_value \
.__iter__.return_value = [TermsOfService()]
response = client.get("/terms_of_service/current?app_key=123")
assert response.status_code == expected_status
assert response.json == expected_json
def test_get_regions_empty_route(app, mocker, client):
expected_status = 204
expected_json = None
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.filter.return_value \
.limit.return_value \
.offset.return_value \
.__iter__.return_value = []
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.filter.return_value \
.count.return_value = 15
response = client.get("/regions/US/3?app_key=123")
assert response.status_code == expected_status
assert response.json == expected_json
def test_get_app_keys_limit_10_page_2_of_3(app, mocker):
expected_status = 200
expected_length = 10
expected_properties = ['application', 'created_at', 'id', 'key', 'status',
'status_changed_at', 'updated_at']
expected_limit = 10
expected_page = 2
expected_total = 25
expected_previous_uri = 'http://localhost/app_keys/1/10'
expected_next_uri = 'http://localhost/app_keys/3/10'
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.limit.return_value \
.offset.return_value \
.__iter__.return_value = [AppKey()] * expected_length
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.count.return_value = expected_total
result = get_app_keys(expected_page, expected_limit)
assert result[1] == expected_status
assert len(result[0].json['app_keys']) == expected_length
assert result[0].json['app_keys'][0] == {
x: None for x in expected_properties}
assert result[0].json['previous_uri'] == expected_previous_uri
assert result[0].json['next_uri'] == expected_next_uri
assert result[0].json['limit'] == expected_limit
assert result[0].json['page'] == expected_page
assert result[0].json['total'] == expected_total
def test_get_logins_route(app, mocker, client):
expected_status = 200
expected_length = 25
expected_limit = 25
expected_page = 1
expected_total = 30
expected_next_uri = 'http://localhost/logins/2/25'
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock user login db query
role2 = Role()
role2.id = 2
role2.name = 'SUPER_ADMIN'
role2.password_reset_days = 365
admin1 = Administrator()
admin1.id = 1
admin1.password = '******'
admin1.roles = [role2]
query_mock.return_value \
.filter.return_value \
.first.return_value = admin1
auth_db_mock = mocker.patch('modules.administrators.authentication.db')
auth_db_mock.add.return_value = None
auth_db_mock.commit.return_value = None
query_mock.return_value \
.order_by.return_value \
.limit.return_value \
.offset.return_value \
.__iter__.return_value = [Login()] * expected_length
query_mock.return_value \
.order_by.return_value \
.count.return_value = expected_total
# mock user login
auth_mock = mocker.patch(
'modules.administrators.Authentication.is_account_locked')
auth_mock.return_value = False
credentials = base64.b64encode(
'admin1:admin1pass'.encode('ascii')).decode('utf-8')
response = client.get("/logins?app_key=123",
headers={"Authorization": f"Basic {credentials}"})
assert response.status_code == expected_status
assert len(response.json['logins']) == expected_length
assert response.json['limit'] == expected_limit
assert response.json['page'] == expected_page
assert response.json['total'] == expected_total
assert response.json['next_uri'] == expected_next_uri
def test_put_app_key_ok(app, mocker):
expected_status = 200
expected_m_length = 7
expected_m_application = 'Test Application A'
expected_m_id = 1
expected_m_key = 'B8CzqaJWs9TmffSJjxDCFrepzhvYzrKA'
expected_m_status = AppKey.STATUS_ENABLED
expected_m_created_at = None
expected_m_updated_at = None
# @todo: timezone
re_datetime = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$")
request_mock = mocker.patch('modules.app_keys.routes_admin.request')
request_mock.json = {
'application': expected_m_application,
'key': expected_m_key,
"status": expected_m_status
}
app_key_1 = AppKey()
app_key_1.id = expected_m_id
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.get.return_value = app_key_1
query_mock.return_value \
.filter.return_value \
.first.return_value = None
db_mock = mocker.patch('modules.app_keys.routes_admin.db')
db_mock.commit.return_value = None
result = put_app_key(expected_m_id)
assert result[1] == expected_status
assert 'app_key' in result[0].json
assert len(result[0].json['app_key']) == expected_m_length
assert result[0].json['app_key']['application'] == expected_m_application
assert result[0].json['app_key']['id'] == expected_m_id
assert result[0].json['app_key']['key'] == expected_m_key
assert result[0].json['app_key']['status'] == expected_m_status
assert bool(re_datetime.match(
result[0].json['app_key']['status_changed_at']))
assert result[0].json['app_key']['created_at'] == expected_m_created_at
assert result[0].json['app_key']['updated_at'] == expected_m_updated_at
def test_get_auth_token_route_ok(app, mocker, client):
expected_status = 200
expected_r_expiration = 14400
expected_r_user_id = 2
expected_r_username = "******"
# mock db query
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
role1 = Role()
role1.id = 1
role1.name = 'USER'
role1.password_reset_days = 365
role1.password_policy = True
role1.password_reuse_history = 10
user2 = User()
user2.id = 2
user2.username = expected_r_username
user2.password = "******"
user2.roles = [role1]
# mock user login db query
query_mock.return_value \
.filter.return_value \
.first.return_value = user2
db_mock = mocker.patch('modules.users.authentication.db')
db_mock.add.return_value = None
db_mock.commit.return_value = None
# mock user login
auth_mock = mocker.patch('modules.users.Authentication.is_account_locked')
auth_mock.return_value = False
credentials = base64.b64encode(
'user2:user2pass'.encode('ascii')).decode('utf-8')
response = client.get("/token?app_key=123",
headers={"Authorization": f"Basic {credentials}"})
assert response.status_code == expected_status
assert response.json['expiration'] == expected_r_expiration
assert response.json['user_id'] == expected_r_user_id
assert response.json['username'] == expected_r_username
assert 'token' in response.json
def test_get_app_key_ok(app, mocker):
expected_status = 200
expected_properties = ['application', 'created_at', 'id', 'key', 'status',
'status_changed_at', 'updated_at']
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.get.return_value = AppKey()
result = get_app_key(1)
assert result[1] == expected_status
assert result[0].json['app_key'] == {
x: None for x in expected_properties}
def test_get_auth_token_route_ok(app, mocker, client):
expected_status = 200
expected_r_expiration = 14400
expected_r_user_id = 1
expected_r_username = "******"
# mock db query
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock user login db query
role2 = Role()
role2.id = 2
role2.name = 'SUPER_ADMIN'
role2.password_reset_days = 365
admin1 = Administrator()
admin1.id = 1
admin1.username = expected_r_username
admin1.password = '******'
admin1.roles = [role2]
query_mock.return_value \
.filter.return_value \
.first.return_value = admin1
db_mock = mocker.patch('modules.administrators.authentication.db')
db_mock.add.return_value = None
db_mock.commit.return_value = None
# mock user login
auth_mock = mocker.patch(
'modules.administrators.Authentication.is_account_locked')
auth_mock.return_value = False
credentials = base64.b64encode(
'admin1:admin1pass'.encode('ascii')).decode('utf-8')
response = client.get("/token?app_key=123",
headers={"Authorization": f"Basic {credentials}"})
assert response.status_code == expected_status
assert response.json['expiration'] == expected_r_expiration
assert response.json['user_id'] == expected_r_user_id
assert response.json['username'] == expected_r_username
assert 'token' in response.json
def test_delete_app_key_ok(app, mocker):
expected_status = 204
expected_content = ''
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.get.return_value = AppKey()
db_mock = mocker.patch('modules.app_keys.routes_admin.db')
db_mock.commit.return_value = None
result = delete_app_key(1)
assert result[1] == expected_status
assert result[0] == expected_content
def test_get_auth_token_check_route_unauthorized(app, mocker, client):
expected_status = 401
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock user login
auth_mock = mocker.patch('modules.users.Authentication')
auth_mock.verify_password.side_effect = Unauthorized()
response = client.get("/token/check?app_key=123")
assert response.status_code == expected_status
assert 'error' in response.json
def test_post_app_key_unique_fail(app, mocker):
expected_status = 400
expected_json = {'error': {'key': ['Value must be unique.']}}
request_mock = mocker.patch('modules.app_keys.routes_admin.request')
request_mock.json = {
'application': "Test Application",
'key': "B8CzqaJWs9TmffSJjxDCFrepzhvYzrKz",
"status": 1
}
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.filter.return_value \
.first.side_effect = [AppKey(), None]
result = post_app_keys()
assert result[1] == expected_status
assert result[0].json == expected_json
def test_get_regions_limit_5_page_2_of_3_route(app, mocker, client):
expected_status = 200
expected_length = 5
expected_limit = 5
expected_page = 2
expected_total = 12
expected_next_uri = 'http://localhost/regions/US/3/5'
expected_previous_uri = 'http://localhost/regions/US/1/5'
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.filter.return_value \
.limit.return_value \
.offset.return_value \
.__iter__.return_value = [Region()] * expected_length
query_mock.return_value \
.filter.return_value \
.order_by.return_value \
.filter.return_value \
.count.return_value = expected_total
response = client.get(
"/regions/US/{}/{}?app_key=123".format(expected_page,
expected_limit))
assert response.status_code == expected_status
assert len(response.json['regions']) == expected_length
assert response.json['limit'] == expected_limit
assert response.json['page'] == expected_page
assert response.json['total'] == expected_total
assert response.json['next_uri'] == expected_next_uri
assert response.json['previous_uri'] == expected_previous_uri
def test_require_appkey_pass(app, mocker):
# mock request
request_mock = mocker.patch('modules.app_keys.middleware.request')
request_mock.args = {'app_key': '123'}
# mock app key db query
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# some function to wrap
def test_func():
return True
# wrap the function
wrapped_func = require_appkey(test_func)
try:
assert wrapped_func() is True
except Unauthorized:
assert False
def test_post_app_key_route_ok(app, mocker, client):
expected_status = 201
expected_m_length = 7
expected_m_application = 'Test Application'
expected_m_id = None
expected_m_key = 'B8CzqaJWs9TmffSJjxDCFrepzhvYzrKz'
expected_m_status = AppKey.STATUS_ENABLED
expected_m_created_at = None
expected_m_updated_at = None
# @todo: timezone
re_datetime = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$")
data = {
'application': expected_m_application,
'key': expected_m_key,
"status": expected_m_status
}
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock user login db query
role2 = Role()
role2.id = 2
role2.name = 'SUPER_ADMIN'
role2.password_reset_days = 365
admin1 = Administrator()
admin1.id = 1
admin1.password = '******'
admin1.roles = [role2]
query_mock.return_value \
.filter.return_value \
.first.side_effect = [admin1, None, None]
auth_db_mock = mocker.patch('modules.administrators.authentication.db')
auth_db_mock.add.return_value = None
auth_db_mock.commit.return_value = None
db_mock = mocker.patch('modules.app_keys.routes_admin.db')
db_mock.add.return_value = None
db_mock.commit.return_value = None
# mock user login
auth_mock = mocker.patch(
'modules.administrators.Authentication.is_account_locked')
auth_mock.return_value = False
credentials = base64.b64encode(
'admin1:admin1pass'.encode('ascii')).decode('utf-8')
response = client.post(
"/app_keys?app_key=123",
json=data,
headers={"Authorization": f"Basic {credentials}"})
assert response.status_code == expected_status
assert 'app_key' in response.json
assert len(response.json['app_key']) == expected_m_length
assert response.json['app_key']['application'] == expected_m_application
assert response.json['app_key']['id'] == expected_m_id
assert response.json['app_key']['key'] == expected_m_key
assert response.json['app_key']['status'] == expected_m_status
assert bool(re_datetime.match(
response.json['app_key']['status_changed_at']))
assert response.json['app_key']['created_at'] == expected_m_created_at
assert response.json['app_key']['updated_at'] == expected_m_updated_at
def test_put_terms_of_service_route_ok(app, mocker, client):
expected_status = 200
expected_m_length = 8
expected_m_id = 1
expected_m_text = "This is TOS 1a"
expected_m_version = "1.0b"
expected_m_publish_date = "2018-06-19T08:00:00+0000"
expected_m_status = TermsOfService.STATUS_DISABLED
expected_m_created_at = None
expected_m_updated_at = None
# @todo: timezone
re_datetime = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$")
data = {
'text': expected_m_text,
'version': expected_m_version,
"publish_date": expected_m_publish_date,
"status": expected_m_status,
}
tos_1 = TermsOfService()
tos_1.id = expected_m_id
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock user login db query
role2 = Role()
role2.id = 2
role2.name = 'SUPER_ADMIN'
role2.password_reset_days = 365
admin1 = Administrator()
admin1.id = 1
admin1.password = '******'
admin1.roles = [role2]
query_mock.return_value \
.filter.return_value \
.first.return_value = admin1
auth_db_mock = mocker.patch('modules.administrators.authentication.db')
auth_db_mock.add.return_value = None
auth_db_mock.commit.return_value = None
query_mock.return_value \
.get.return_value = tos_1
db_mock = mocker.patch('modules.terms_of_services.routes_admin.db')
db_mock.commit.return_value = None
# mock user login
auth_mock = mocker.patch(
'modules.administrators.Authentication.is_account_locked')
auth_mock.return_value = False
credentials = base64.b64encode(
'admin1:admin1pass'.encode('ascii')).decode('utf-8')
response = client.put(
"/terms_of_service/{}?app_key=123".format(expected_m_id),
json=data,
headers={"Authorization": f"Basic {credentials}"})
assert response.status_code == expected_status
assert 'terms_of_service' in response.json
assert len(response.json['terms_of_service']) == expected_m_length
assert response.json['terms_of_service']['id'] == expected_m_id
assert response.json['terms_of_service']['text'] == expected_m_text
assert response.json['terms_of_service']['version'] == \
expected_m_version
assert response.json['terms_of_service']['publish_date'] == \
expected_m_publish_date
assert response.json['terms_of_service']['status'] == expected_m_status
assert bool(
re_datetime.match(
response.json['terms_of_service']['status_changed_at']))
assert response.json['terms_of_service']['created_at'] == \
expected_m_created_at
assert response.json['terms_of_service']['updated_at'] == \
expected_m_updated_at
def test_post_user_route_ok(app, mocker, client):
expected_status = 201
expected_m_length = 9
expected_m_id = None
expected_m_user_id = 9
expected_m_first_name = "Service"
expected_m_last_name = "Account"
expected_m_joined_at = "2019-02-04T00:00:00+0000"
expected_m_status = UserProfile.STATUS_ENABLED
expected_m_created_at = None
expected_m_updated_at = None
# @todo: timezone
re_datetime = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$")
data = {
'user_id': expected_m_user_id,
'first_name': expected_m_first_name,
'last_name': expected_m_last_name,
'joined_at': expected_m_joined_at,
'status': expected_m_status,
}
query_mock = mocker.patch('flask_sqlalchemy._QueryProperty.__get__')
# mock app key authorization db query
query_mock.return_value \
.filter.return_value \
.one.return_value = AppKey()
# mock user login db query
role2 = Role()
role2.id = 2
role2.name = 'SUPER_ADMIN'
role2.password_reset_days = 365
admin1 = Administrator()
admin1.id = 1
admin1.password = '******'
admin1.roles = [role2]
query_mock.return_value \
.filter.return_value \
.first.return_value = admin1
auth_db_mock = mocker.patch('modules.administrators.authentication.db')
auth_db_mock.add.return_value = None
auth_db_mock.commit.return_value = None
# mock exists() validation
user_9 = User()
user_9.id = 9
query_mock.return_value \
.get.return_value = user_9
db_mock = mocker.patch('modules.user_profiles.routes_admin.db')
db_mock.add.return_value = None
db_mock.commit.return_value = None
# mock user login
auth_mock = mocker.patch(
'modules.administrators.Authentication.is_account_locked')
auth_mock.return_value = False
credentials = base64.b64encode(
'admin1:admin1pass'.encode('ascii')).decode('utf-8')
response = client.post(
"/user_profiles?app_key=123",
json=data,
headers={"Authorization": f"Basic {credentials}"})
assert response.status_code == expected_status
assert 'user_profile' in response.json
assert len(response.json['user_profile']) == expected_m_length
assert response.json['user_profile']['id'] == expected_m_id
assert response.json['user_profile']['user_id'] == expected_m_user_id
assert response.json['user_profile']['first_name'] == \
expected_m_first_name
assert response.json['user_profile']['last_name'] == expected_m_last_name
assert response.json['user_profile']['joined_at'] == expected_m_joined_at
assert response.json['user_profile']['status'] == expected_m_status
assert bool(re_datetime.match(
response.json['user_profile']['status_changed_at']))
assert response.json['user_profile']['created_at'] == \
expected_m_created_at
assert response.json['user_profile']['updated_at'] == \
expected_m_updated_at
