The great bump

apps/cic-ussd/tests/cic_ussd/http/test_requests.py

@@ -0,0 +1,69 @@
+# standard imports
+from urllib.parse import urlparse, parse_qs
+
+# external imports
+import pytest
+import requests
+from requests.exceptions import HTTPError
+import requests_mock
+
+# local imports
+from cic_ussd.http.requests import (error_handler,
+                                    get_query_parameters,
+                                    get_request_endpoint,
+                                    get_request_method,
+                                    make_request)
+from cic_ussd.error import UnsupportedMethodError
+# test imports
+
+
+@pytest.mark.parametrize('status_code, starts_with', [
+    (102, 'Informational errors'),
+    (303, 'Redirect Issues'),
+    (406, 'Client Error'),
+    (500, 'Server Error')
+])
+def test_error_handler(status_code, starts_with, mocker):
+    mock_result = mocker.patch('requests.Response')
+    mock_result.status_code = status_code
+    with pytest.raises(HTTPError) as error:
+        error_handler(mock_result)
+    assert str(error.value).startswith(starts_with)
+
+
+def test_get_query_parameters(with_params_env):
+    assert get_query_parameters(with_params_env, 'phone') == with_params_env.get('REQUEST_URI')[8:]
+    parsed_url = urlparse(with_params_env.get('REQUEST_URI'))
+    params = parse_qs(parsed_url.query)
+    assert get_query_parameters(with_params_env) == params
+
+
+def test_get_request_endpoint(with_params_env):
+    assert get_request_endpoint(with_params_env) == with_params_env.get('PATH_INFO')
+
+
+def test_get_request_method(with_params_env):
+    assert get_request_method(with_params_env) == with_params_env.get('REQUEST_METHOD')
+
+
+def test_make_request(mock_response, mock_url):
+    with requests_mock.Mocker(real_http=False) as request_mocker:
+        request_mocker.register_uri('GET', mock_url, status_code=200, reason='OK', json=mock_response)
+        response = make_request(method='GET', url=mock_url)
+        assert response.json() == requests.get(mock_url).json()
+
+    with requests_mock.Mocker(real_http=False) as request_mocker:
+        request_mocker.register_uri('POST', mock_url, status_code=201, reason='CREATED', json=mock_response)
+        response = make_request('POST', mock_url, {'test': 'data'})
+        assert response.content == requests.post(mock_url).content
+
+    with requests_mock.Mocker(real_http=False) as request_mocker:
+        request_mocker.register_uri('PUT', mock_url, status_code=200, reason='OK')
+        response = make_request('PUT', mock_url, data={'test': 'data'})
+        assert response.content == requests.put(mock_url).content
+
+    with pytest.raises(UnsupportedMethodError) as error:
+        with requests_mock.Mocker(real_http=False) as request_mocker:
+            request_mocker.register_uri('DELETE', mock_url, status_code=200, reason='OK')
+            make_request('DELETE', mock_url)
+        assert str(error.value) == 'Unsupported method: DELETE'

apps/cic-ussd/tests/cic_ussd/http/test_responses.py

@@ -0,0 +1,18 @@
+# standard imports
+
+# external imports
+import pytest
+
+# local imports
+from cic_ussd.http.responses import with_content_headers
+
+# test imports
+
+
+@pytest.mark.parametrize('headers, response, expected_result',[
+    ([('Content-Type', 'text/plain')], 'some-text', (b'some-text', [('Content-Type', 'text/plain'), ('Content-Length', '9')])),
+    ([('Content-Type', 'text/plain'), ('Content-Length', '0')], 'some-text', (b'some-text', [('Content-Type', 'text/plain'), ('Content-Length', '9')]))
+])
+def test_with_content_headers(headers, response, expected_result):
+    response_bytes, headers = with_content_headers(headers, response)
+    assert response_bytes, headers == expected_result

apps/cic-ussd/tests/cic_ussd/http/test_routes.py

@@ -0,0 +1,45 @@
+# standard imports
+import json
+
+# external imports
+import pytest
+
+# local imports
+from cic_ussd.db.models.account import Account
+from cic_ussd.http.routes import locked_accounts, pin_reset
+
+# test imports
+
+
+@pytest.mark.parametrize('method, expected_response, expected_message', [
+    ('GET', '{"status": "LOCKED"}', '200 OK'),
+    ('PUT', 'Pin reset successful.', '200 OK'),
+])
+def test_pin_reset(method, expected_response, expected_message, init_database, pin_blocked_account, uwsgi_env):
+    uwsgi_env['REQUEST_METHOD'] = method
+    response, message = pin_reset(uwsgi_env, pin_blocked_account.phone_number, init_database)
+    assert response == expected_response
+    assert message == expected_message
+
+    response, message = pin_reset(uwsgi_env, '070000000', init_database)
+    assert response == ''
+    assert message == '404 Not found'
+
+
+def test_locked_accounts(init_database, locked_accounts_env, locked_accounts_traffic):
+    response, message = locked_accounts(locked_accounts_env, init_database)
+    assert message == '200 OK'
+    locked_account_addresses = json.loads(response)
+    assert len(locked_account_addresses) == 10
+    account_1 = init_database.query(Account).filter_by(blockchain_address=locked_account_addresses[2]).first()
+    account_2 = init_database.query(Account).filter_by(blockchain_address=locked_account_addresses[7]).first()
+    assert account_1.updated > account_2.updated
+    locked_accounts_env['PATH_INFO'] = '/accounts/locked/10'
+    response, message = locked_accounts(locked_accounts_env, init_database)
+    assert message == '200 OK'
+    locked_account_addresses = json.loads(response)
+    assert len(locked_account_addresses) == 10
+    locked_accounts_env['REQUEST_METHOD'] = 'POST'
+    response, message = locked_accounts(locked_accounts_env, init_database)
+    assert message == '405 Play by the rules'
+    assert response == ''