From 7313137ec3b66975bc8491668badadfea0924aee Mon Sep 17 00:00:00 2001 From: Paul Abumov Date: Tue, 15 Aug 2023 20:29:16 -0400 Subject: [PATCH] Added unittests for prolific_utils and base_api_resource --- .../prolific/api/base_api_resource.py | 5 + .../providers/prolific/api/status.py | 1 + .../providers/prolific/__init__.py | 5 + .../providers/prolific/api/__init__.py | 5 + .../prolific/api/test_base_api_resourse.py | 362 ++++++ .../providers/prolific/test_prolific_utils.py | 1031 +++++++++-------- 6 files changed, 900 insertions(+), 509 deletions(-) create mode 100644 test/abstractions/providers/prolific/api/__init__.py create mode 100644 test/abstractions/providers/prolific/api/test_base_api_resourse.py diff --git a/mephisto/abstractions/providers/prolific/api/base_api_resource.py b/mephisto/abstractions/providers/prolific/api/base_api_resource.py index af30f52df..3c97eadab 100644 --- a/mephisto/abstractions/providers/prolific/api/base_api_resource.py +++ b/mephisto/abstractions/providers/prolific/api/base_api_resource.py @@ -87,6 +87,7 @@ def _base_request( elif method == HTTPMethod.DELETE: response = requests.delete(url, headers=headers, json=params) + else: raise ProlificException("Invalid HTTP method.") @@ -103,6 +104,10 @@ def _base_request( return result + except ProlificException: + # Reraise these errors further to avoid catching them in the latest `except` condition + raise + except requests.exceptions.HTTPError as err: logger.error( f"{log_prefix} Request error: {err}. Response text: `{err.response.text}`" diff --git a/mephisto/abstractions/providers/prolific/api/status.py b/mephisto/abstractions/providers/prolific/api/status.py index 12d1156e1..d746c5e23 100644 --- a/mephisto/abstractions/providers/prolific/api/status.py +++ b/mephisto/abstractions/providers/prolific/api/status.py @@ -5,6 +5,7 @@ # LICENSE file in the root directory of this source tree. # 2xx +HTTP_200_OK = 200 HTTP_204_NO_CONTENT = 204 # 4xx diff --git a/test/abstractions/providers/prolific/__init__.py b/test/abstractions/providers/prolific/__init__.py index e69de29bb..240697e32 100644 --- a/test/abstractions/providers/prolific/__init__.py +++ b/test/abstractions/providers/prolific/__init__.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/test/abstractions/providers/prolific/api/__init__.py b/test/abstractions/providers/prolific/api/__init__.py new file mode 100644 index 000000000..240697e32 --- /dev/null +++ b/test/abstractions/providers/prolific/api/__init__.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/test/abstractions/providers/prolific/api/test_base_api_resourse.py b/test/abstractions/providers/prolific/api/test_base_api_resourse.py new file mode 100644 index 000000000..164cefadd --- /dev/null +++ b/test/abstractions/providers/prolific/api/test_base_api_resourse.py @@ -0,0 +1,362 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import json +import unittest +from unittest.mock import patch +from urllib.parse import urljoin + +import pytest +from requests import Response +from requests.exceptions import HTTPError + +from mephisto.abstractions.providers.prolific.api import status +from mephisto.abstractions.providers.prolific.api.base_api_resource import BaseAPIResource +from mephisto.abstractions.providers.prolific.api.base_api_resource import HTTPMethod +from mephisto.abstractions.providers.prolific.api.exceptions import ProlificAPIKeyError +from mephisto.abstractions.providers.prolific.api.exceptions import ProlificAuthenticationError +from mephisto.abstractions.providers.prolific.api.exceptions import ProlificException +from mephisto.abstractions.providers.prolific.api.exceptions import ProlificRequestError + + +API_KEY_PATH = "mephisto.abstractions.providers.prolific.api.base_api_resource.PROLIFIC_API_KEY" +API_KEY = "test" + + +class TestApiResource(BaseAPIResource): + pass + + +@pytest.mark.prolific +class TestBaseAPIResource(unittest.TestCase): + @patch("requests.get") + def test__base_request_success(self, mock_requests_get, *args): + method = HTTPMethod.GET + api_endpoint = "test/" + params = { + "param": "test", + } + headers = { + "header": "test", + } + content = b'{"id": "60d9aadeb86739de712faee0","name": "Study"}' + + mock_response = Response() + mock_response.raise_for_status = lambda: None + mock_response.status_code = status.HTTP_200_OK + mock_response._content = content + + mock_requests_get.return_value = mock_response + + result = TestApiResource._base_request( + method=method, + api_endpoint=api_endpoint, + params=params, + headers=headers, + api_key=API_KEY, + ) + + self.assertEqual(json.loads(content), result) + mock_requests_get.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={**headers, **{"Authorization": f"Token {API_KEY}"}}, + params=params, + ) + + @patch("requests.get") + def test__base_request_success_no_content(self, mock_requests_get, *args): + method = HTTPMethod.GET + api_endpoint = "test/" + params = { + "param": "test", + } + headers = { + "header": "test", + } + content = None + + mock_response = Response() + mock_response.raise_for_status = lambda: None + mock_response.status_code = status.HTTP_204_NO_CONTENT + mock_response._content = content + + mock_requests_get.return_value = mock_response + + result = TestApiResource._base_request( + method=method, + api_endpoint=api_endpoint, + params=params, + headers=headers, + api_key=API_KEY, + ) + + self.assertEqual(None, result) + mock_requests_get.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={**headers, **{"Authorization": f"Token {API_KEY}"}}, + params=params, + ) + + @patch(API_KEY_PATH, "") + @patch("requests.get") + def test__base_request_no_api_key(self, mock_requests_get, *args): + method = HTTPMethod.GET + api_endpoint = "test/" + params = { + "param": "test", + } + headers = { + "header": "test", + } + + with self.assertRaises(ProlificAPIKeyError) as cm: + TestApiResource._base_request( + method=method, + api_endpoint=api_endpoint, + params=params, + headers=headers, + ) + + self.assertEqual(cm.exception.message, ProlificAPIKeyError.default_message) + mock_requests_get.assert_not_called() + + @patch("requests.get") + def test__base_request_incorrect_request_method(self, mock_requests_get, *args): + method = "unreal_method" + api_endpoint = "test/" + params = { + "param": "test", + } + headers = { + "header": "test", + } + + with self.assertRaises(ProlificException) as cm: + TestApiResource._base_request( + method=method, + api_endpoint=api_endpoint, + params=params, + headers=headers, + api_key=API_KEY, + ) + + self.assertEqual(cm.exception.message, "Invalid HTTP method.") + mock_requests_get.assert_not_called() + + @patch("requests.get") + def test__base_request_request_httperror(self, mock_requests_get, *args): + method = HTTPMethod.GET + api_endpoint = "test/" + params = { + "param": "test", + } + headers = { + "header": "test", + } + content = b"test" + + mock_response = Response() + mock_response.raise_for_status = lambda: None + mock_response.status_code = status.HTTP_204_NO_CONTENT + mock_response._content = content + + error_message = "Error" + exception = HTTPError(error_message) + exception.response = mock_response + + mock_requests_get.side_effect = exception + + with self.assertRaises(ProlificRequestError) as cm: + TestApiResource._base_request( + method=method, + api_endpoint=api_endpoint, + params=params, + headers=headers, + api_key=API_KEY, + ) + + self.assertEqual(cm.exception.message, f'{error_message}. {content.decode("utf8")}') + mock_requests_get.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={**headers, **{"Authorization": f"Token {API_KEY}"}}, + params=params, + ) + + @patch("requests.get") + def test__base_request_request_httperror_unauthorized(self, mock_requests_get, *args): + method = HTTPMethod.GET + api_endpoint = "test/" + params = { + "param": "test", + } + headers = { + "header": "test", + } + content = b"test" + + mock_response = Response() + mock_response.raise_for_status = lambda: None + mock_response.status_code = status.HTTP_401_UNAUTHORIZED + mock_response._content = content + + error_message = "Error" + exception = HTTPError(error_message) + exception.response = mock_response + + mock_requests_get.side_effect = exception + + with self.assertRaises(ProlificAuthenticationError) as cm: + TestApiResource._base_request( + method=method, + api_endpoint=api_endpoint, + params=params, + headers=headers, + api_key=API_KEY, + ) + + self.assertEqual(cm.exception.message, ProlificAuthenticationError.default_message) + self.assertEqual(cm.exception.status_code, ProlificAuthenticationError.status_code) + mock_requests_get.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={**headers, **{"Authorization": f"Token {API_KEY}"}}, + params=params, + ) + + @patch("requests.get") + def test__base_request_unexpected_exception(self, mock_requests_get, *args): + method = HTTPMethod.GET + api_endpoint = "test/" + params = { + "param": "test", + } + headers = { + "header": "test", + } + + error_message = "Error" + exception = ValueError(error_message) + + mock_requests_get.side_effect = exception + + with self.assertRaises(ProlificException) as cm: + TestApiResource._base_request( + method=method, + api_endpoint=api_endpoint, + params=params, + headers=headers, + api_key=API_KEY, + ) + + self.assertEqual(cm.exception.message, ProlificException.default_message) + mock_requests_get.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={**headers, **{"Authorization": f"Token {API_KEY}"}}, + params=params, + ) + + @patch(API_KEY_PATH, API_KEY) + @patch("requests.get") + def test_get(self, mock_requests_get, *args): + api_endpoint = "test-get/" + params = { + "param": "test", + } + content = b'{"id": "60d9aadeb86739de712faee0","name": "Study"}' + + mock_response = Response() + mock_response.raise_for_status = lambda: None + mock_response.status_code = status.HTTP_200_OK + mock_response._content = content + + mock_requests_get.return_value = mock_response + + result = TestApiResource.get(api_endpoint=api_endpoint, params=params) + + self.assertEqual(json.loads(content), result) + mock_requests_get.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={"Authorization": f"Token {API_KEY}"}, + params=params, + ) + + @patch(API_KEY_PATH, API_KEY) + @patch("requests.post") + def test_post(self, mock_requests_post, *args): + api_endpoint = "test-post/" + params = { + "param": "test", + } + content = b'{"id": "60d9aadeb86739de712faee0","name": "Study"}' + + mock_response = Response() + mock_response.raise_for_status = lambda: None + mock_response.status_code = status.HTTP_200_OK + mock_response._content = content + + mock_requests_post.return_value = mock_response + + result = TestApiResource.post(api_endpoint=api_endpoint, params=params) + + self.assertEqual(json.loads(content), result) + mock_requests_post.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={"Authorization": f"Token {API_KEY}"}, + params=params, + ) + + @patch(API_KEY_PATH, API_KEY) + @patch("requests.patch") + def test_patch(self, mock_requests_patch, *args): + api_endpoint = "test-patch/" + params = { + "param": "test", + } + content = b'{"id": "60d9aadeb86739de712faee0","name": "Study"}' + + mock_response = Response() + mock_response.raise_for_status = lambda: None + mock_response.status_code = status.HTTP_200_OK + mock_response._content = content + + mock_requests_patch.return_value = mock_response + + result = TestApiResource.patch(api_endpoint=api_endpoint, params=params) + + self.assertEqual(json.loads(content), result) + mock_requests_patch.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={"Authorization": f"Token {API_KEY}"}, + params=params, + ) + + @patch(API_KEY_PATH, API_KEY) + @patch("requests.delete") + def test_delete(self, mock_requests_delete, *args): + api_endpoint = "test-delete/" + params = { + "param": "test", + } + content = b'{"id": "60d9aadeb86739de712faee0","name": "Study"}' + + mock_response = Response() + mock_response.raise_for_status = lambda: None + mock_response.status_code = status.HTTP_200_OK + mock_response._content = content + + mock_requests_delete.return_value = mock_response + + result = TestApiResource.delete(api_endpoint=api_endpoint, params=params) + + self.assertEqual(json.loads(content), result) + mock_requests_delete.called_once_with( + urljoin("https://api.prolific.co/api/v1/", api_endpoint), + headers={"Authorization": f"Token {API_KEY}"}, + params=params, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/abstractions/providers/prolific/test_prolific_utils.py b/test/abstractions/providers/prolific/test_prolific_utils.py index dde2237ce..5b02af505 100644 --- a/test/abstractions/providers/prolific/test_prolific_utils.py +++ b/test/abstractions/providers/prolific/test_prolific_utils.py @@ -28,7 +28,7 @@ from mephisto.abstractions.providers.prolific.api.data_models import WorkspaceBalance from mephisto.abstractions.providers.prolific.api.exceptions import ProlificRequestError from mephisto.abstractions.providers.prolific.prolific_utils import ( - _convert_eligibility_requirements + _convert_eligibility_requirements, ) from mephisto.abstractions.providers.prolific.prolific_utils import _ec2_external_url from mephisto.abstractions.providers.prolific.prolific_utils import _find_prolific_project @@ -50,7 +50,7 @@ from mephisto.abstractions.providers.prolific.prolific_utils import expire_study from mephisto.abstractions.providers.prolific.prolific_utils import find_or_create_prolific_project from mephisto.abstractions.providers.prolific.prolific_utils import ( - find_or_create_prolific_workspace + find_or_create_prolific_workspace, ) from mephisto.abstractions.providers.prolific.prolific_utils import find_or_create_qualification from mephisto.abstractions.providers.prolific.prolific_utils import get_authenticated_client @@ -58,7 +58,7 @@ from mephisto.abstractions.providers.prolific.prolific_utils import get_submission from mephisto.abstractions.providers.prolific.prolific_utils import give_worker_qualification from mephisto.abstractions.providers.prolific.prolific_utils import ( - increase_total_available_places_for_study + increase_total_available_places_for_study, ) from mephisto.abstractions.providers.prolific.prolific_utils import is_study_expired from mephisto.abstractions.providers.prolific.prolific_utils import is_worker_blocked @@ -71,229 +71,241 @@ from mephisto.abstractions.providers.prolific.prolific_utils import unblock_worker from mephisto.data_model.requester import RequesterArgs -MOCK_PROLIFIC_CONFIG_DIR = '/tmp/' -MOCK_PROLIFIC_CONFIG_PATH = '/tmp/test_conf_credentials' +MOCK_PROLIFIC_CONFIG_DIR = "/tmp/" +MOCK_PROLIFIC_CONFIG_PATH = "/tmp/test_conf_credentials" + +API_PATH = "mephisto.abstractions.providers.prolific.api" +UTILS_PATH = "mephisto.abstractions.providers.prolific.prolific_utils" @dataclass class MockProlificRequesterArgs(RequesterArgs): name: str = field( - default='prolific', + default="prolific", ) api_key: str = field( - default='prolific', + default="prolific", ) -mock_task_run_args = DictConfig(dict( - architect=DictConfig(dict( - _architect_type='local', - )), - task=DictConfig(dict( - task_title='title', - task_description='This is a description', - task_reward=0.3, - task_tags='1,2,3', - task_lifetime_in_seconds=1, - )), - provider=DictConfig(dict( - prolific_external_study_url=( - 'https://example.com?' - 'participant_id={{%PROLIFIC_PID%}}&' - 'study_id={{%STUDY_ID%}}&' - 'submission_id={{%SESSION_ID%}}' +mock_task_run_args = DictConfig( + dict( + architect=DictConfig( + dict( + _architect_type="local", + ) + ), + task=DictConfig( + dict( + task_title="title", + task_description="This is a description", + task_reward=0.3, + task_tags="1,2,3", + task_lifetime_in_seconds=1, + ) + ), + provider=DictConfig( + dict( + prolific_external_study_url=( + "https://example.com?" + "participant_id={{%PROLIFIC_PID%}}&" + "study_id={{%STUDY_ID%}}&" + "submission_id={{%SESSION_ID%}}" + ), + prolific_id_option="url_parameters", + prolific_workspace_name="My Workspace", + prolific_project_name="Project", + prolific_allow_list_group_name="Allow list", + prolific_block_list_group_name="Block list", + prolific_estimated_completion_time_in_minutes=60, + ) ), - prolific_id_option='url_parameters', - prolific_workspace_name='My Workspace', - prolific_project_name='Project', - prolific_allow_list_group_name='Allow list', - prolific_block_list_group_name='Block list', - prolific_estimated_completion_time_in_minutes=60, - )), -)) + ) +) @pytest.mark.prolific class TestProlificUtils(unittest.TestCase): """Unit testing for Prolific Utils""" + @classmethod def setUpClass(cls): super().setUpClass() - cls.client = get_authenticated_client('prolific') + cls.client = get_authenticated_client("prolific") @staticmethod def remove_credentials_file(): if os.path.exists(MOCK_PROLIFIC_CONFIG_PATH): os.remove(MOCK_PROLIFIC_CONFIG_PATH) - @patch('mephisto.abstractions.providers.prolific.api.users.Users.me') + @patch(f"{API_PATH}.users.Users.me") def test_check_credentials_true(self, mock_prolific_users_me, *args): - mock_prolific_users_me.return_value = User(id='test') + mock_prolific_users_me.return_value = User(id="test") result = check_credentials() self.assertTrue(result) - @patch('mephisto.abstractions.providers.prolific.api.users.Users.me') + @patch(f"{API_PATH}.users.Users.me") def test_check_credentials_false(self, mock_prolific_users_me, *args): mock_prolific_users_me.side_effect = ProlificRequestError() result = check_credentials() self.assertFalse(result) - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.CREDENTIALS_CONFIG_DIR', - MOCK_PROLIFIC_CONFIG_DIR, - ) - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.CREDENTIALS_CONFIG_PATH', - MOCK_PROLIFIC_CONFIG_PATH, - ) + @patch(f"{UTILS_PATH}.CREDENTIALS_CONFIG_DIR", MOCK_PROLIFIC_CONFIG_DIR) + @patch(f"{UTILS_PATH}.CREDENTIALS_CONFIG_PATH", MOCK_PROLIFIC_CONFIG_PATH) def test_setup_credentials(self, *args): self.remove_credentials_file() self.assertFalse(os.path.exists(MOCK_PROLIFIC_CONFIG_PATH)) cfg = MockProlificRequesterArgs() - setup_credentials('name', cfg) + setup_credentials("name", cfg) self.assertTrue(os.path.exists(MOCK_PROLIFIC_CONFIG_PATH)) self.remove_credentials_file() def test__convert_eligibility_requirements(self, *args): income_value = [ { - 'name': 'AgeRangeEligibilityRequirement', - 'min_age': 18, - 'max_age': 100, + "name": "AgeRangeEligibilityRequirement", + "min_age": 18, + "max_age": 100, }, { - 'name': 'ApprovalNumbersEligibilityRequirement', - 'minimum_approvals': 1, - 'maximum_approvals': 100, + "name": "ApprovalNumbersEligibilityRequirement", + "minimum_approvals": 1, + "maximum_approvals": 100, }, { - 'name': 'ApprovalRateEligibilityRequirement', - 'minimum_approval_rate': 1, - 'maximum_approval_rate': 100, + "name": "ApprovalRateEligibilityRequirement", + "minimum_approval_rate": 1, + "maximum_approval_rate": 100, }, { - 'name': 'CustomBlacklistEligibilityRequirement', - 'black_list': ['54ac6ea9fdf99b2204feb893'], + "name": "CustomBlacklistEligibilityRequirement", + "black_list": ["54ac6ea9fdf99b2204feb893"], }, { - 'name': 'CustomWhitelistEligibilityRequirement', - 'white_list': ['54ac6ea9fdf99b2204feb893'], + "name": "CustomWhitelistEligibilityRequirement", + "white_list": ["54ac6ea9fdf99b2204feb893"], }, { - 'name': 'JoinedBeforeEligibilityRequirement', - 'joined_before': '2023‐08‐08T00:00:00Z', + "name": "JoinedBeforeEligibilityRequirement", + "joined_before": "2023‐08‐08T00:00:00Z", }, { - 'name': 'ParticipantGroupEligibilityRequirement', - 'id': '54ac6ea9fdf99b2204feb893', + "name": "ParticipantGroupEligibilityRequirement", + "id": "54ac6ea9fdf99b2204feb893", }, ] result = _convert_eligibility_requirements(income_value) - self.assertEqual(result, [ - { - '_cls': 'web.eligibility.models.AgeRangeEligibilityRequirement', - 'attributes': [ - {'name': 'min_age', 'value': 18}, - {'name': 'max_age', 'value': 100}, - ], - 'query': {'id': '54ac6ea9fdf99b2204feb893'}, - }, - { - '_cls': 'web.eligibility.models.ApprovalNumbersEligibilityRequirement', - 'attributes': [ - {'name': 'minimum_approvals', 'value': 1}, - {'name': 'maximum_approvals', 'value': 100}, - ], - }, - { - '_cls': 'web.eligibility.models.ApprovalRateEligibilityRequirement', - 'attributes': [ - {'name': 'minimum_approval_rate', 'value': 1}, - {'name': 'maximum_approval_rate', 'value': 100}, - ], - }, - { - '_cls': 'web.eligibility.models.CustomBlacklistEligibilityRequirement', - 'attributes': [ - {'name': 'black_list', 'value': ['54ac6ea9fdf99b2204feb893']}, - ], - }, - { - '_cls': 'web.eligibility.models.CustomWhitelistEligibilityRequirement', - 'attributes': [ - {'name': 'white_list', 'value': ['54ac6ea9fdf99b2204feb893']}, - ], - }, - { - '_cls': 'web.eligibility.models.JoinedBeforeEligibilityRequirement', - 'attributes': [ - {'name': 'joined_before', 'value': '2023‐08‐08T00:00:00Z'}, - ], - }, - { - '_cls': 'web.eligibility.models.ParticipantGroupEligibilityRequirement', - 'attributes': [ - {'id': '54ac6ea9fdf99b2204feb893', 'value': True}, - ], - }, - ]) + self.assertEqual( + result, + [ + { + "_cls": "web.eligibility.models.AgeRangeEligibilityRequirement", + "attributes": [ + {"name": "min_age", "value": 18}, + {"name": "max_age", "value": 100}, + ], + "query": {"id": "54ac6ea9fdf99b2204feb893"}, + }, + { + "_cls": "web.eligibility.models.ApprovalNumbersEligibilityRequirement", + "attributes": [ + {"name": "minimum_approvals", "value": 1}, + {"name": "maximum_approvals", "value": 100}, + ], + }, + { + "_cls": "web.eligibility.models.ApprovalRateEligibilityRequirement", + "attributes": [ + {"name": "minimum_approval_rate", "value": 1}, + {"name": "maximum_approval_rate", "value": 100}, + ], + }, + { + "_cls": "web.eligibility.models.CustomBlacklistEligibilityRequirement", + "attributes": [ + {"name": "black_list", "value": ["54ac6ea9fdf99b2204feb893"]}, + ], + }, + { + "_cls": "web.eligibility.models.CustomWhitelistEligibilityRequirement", + "attributes": [ + {"name": "white_list", "value": ["54ac6ea9fdf99b2204feb893"]}, + ], + }, + { + "_cls": "web.eligibility.models.JoinedBeforeEligibilityRequirement", + "attributes": [ + {"name": "joined_before", "value": "2023‐08‐08T00:00:00Z"}, + ], + }, + { + "_cls": "web.eligibility.models.ParticipantGroupEligibilityRequirement", + "attributes": [ + {"id": "54ac6ea9fdf99b2204feb893", "value": True}, + ], + }, + ], + ) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.get_balance') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_workspace') + @patch(f"{API_PATH}.workspaces.Workspaces.get_balance") + @patch(f"{UTILS_PATH}._find_prolific_workspace") def test_check_balance_success(self, mock__find_prolific_workspace, mock_get_balance, *args): expected_value = 9999 mock_workspace = Workspace() - mock_workspace.id = 'test' + mock_workspace.id = "test" mock_workspacebalance = WorkspaceBalance() mock_workspacebalance.available_balance = expected_value mock__find_prolific_workspace.return_value = (True, mock_workspace) mock_get_balance.return_value = mock_workspacebalance - balance = check_balance(self.client, workspace_name='test') + balance = check_balance(self.client, workspace_name="test") self.assertEqual(expected_value, balance) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.get_balance') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_workspace') + @patch(f"{API_PATH}.workspaces.Workspaces.get_balance") + @patch(f"{UTILS_PATH}._find_prolific_workspace") def test_check_balance_no_workspace_name(self, *args): balance = check_balance(self.client) self.assertEqual(None, balance) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.get_balance') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_workspace') + @patch(f"{API_PATH}.workspaces.Workspaces.get_balance") + @patch(f"{UTILS_PATH}._find_prolific_workspace") def test_check_balance_found_no_workspace(self, mock__find_prolific_workspace, *args): mock_workspace = Workspace() - mock_workspace.id = 'test' + mock_workspace.id = "test" mock__find_prolific_workspace.return_value = (False, None) - balance = check_balance(self.client, workspace_name='test') + balance = check_balance(self.client, workspace_name="test") self.assertEqual(None, balance) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.get_balance') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_workspace') + @patch(f"{API_PATH}.workspaces.Workspaces.get_balance") + @patch(f"{UTILS_PATH}._find_prolific_workspace") def test_check_balance_get_balance_exception( - self, mock__find_prolific_workspace, mock_get_balance, *args, + self, + mock__find_prolific_workspace, + mock_get_balance, + *args, ): expected_value = 9999 mock_workspace = Workspace() - mock_workspace.id = 'test' + mock_workspace.id = "test" mock_workspacebalance = WorkspaceBalance() mock_workspacebalance.available_balance = expected_value mock__find_prolific_workspace.return_value = (True, mock_workspace) - exception_message = 'Error' + exception_message = "Error" mock_get_balance.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: - check_balance(self.client, workspace_name='test') + check_balance(self.client, workspace_name="test") self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.retrieve') + @patch(f"{API_PATH}.workspaces.Workspaces.retrieve") def test__find_prolific_workspace_with_id_success(self, mock_retrieve, *args): - expected_id = 'test' - expected_title = 'test' + expected_id = "test" + expected_title = "test" mock_workspace = Workspace() mock_workspace.id = expected_id @@ -301,23 +313,23 @@ def test__find_prolific_workspace_with_id_success(self, mock_retrieve, *args): mock_retrieve.return_value = mock_workspace - result = _find_prolific_workspace(self.client, title='', id=expected_id) + result = _find_prolific_workspace(self.client, title="", id=expected_id) self.assertEqual((True, mock_workspace), result) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.retrieve') + @patch(f"{API_PATH}.workspaces.Workspaces.retrieve") def test__find_prolific_workspace_with_id_exception(self, mock_retrieve, *args): - expected_id = 'test' + expected_id = "test" - exception_message = 'Error' + exception_message = "Error" mock_retrieve.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: - _find_prolific_workspace(self.client, title='', id=expected_id) + _find_prolific_workspace(self.client, title="", id=expected_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.list') + @patch(f"{API_PATH}.workspaces.Workspaces.list") def test__find_prolific_workspace_with_title_success(self, mock_list, *args): - expected_title = 'test' + expected_title = "test" mock_workspace = Workspace() mock_workspace.title = expected_title @@ -327,9 +339,9 @@ def test__find_prolific_workspace_with_title_success(self, mock_list, *args): result = _find_prolific_workspace(self.client, title=expected_title) self.assertEqual((True, mock_workspace), result) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.list') + @patch(f"{API_PATH}.workspaces.Workspaces.list") def test__find_prolific_workspace_with_title_success_no_result(self, mock_list, *args): - expected_title = 'test' + expected_title = "test" mock_workspace = Workspace() mock_workspace.title = expected_title @@ -339,22 +351,24 @@ def test__find_prolific_workspace_with_title_success_no_result(self, mock_list, result = _find_prolific_workspace(self.client, title=expected_title) self.assertEqual((False, None), result) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.list') + @patch(f"{API_PATH}.workspaces.Workspaces.list") def test__find_prolific_workspace_with_title_exception(self, mock_list, *args): - expected_title = 'test' + expected_title = "test" - exception_message = 'Error' + exception_message = "Error" mock_list.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: _find_prolific_workspace(self.client, title=expected_title) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_workspace') + @patch(f"{UTILS_PATH}._find_prolific_workspace") def test_find_or_create_prolific_workspace_success_find( - self, mock__find_prolific_workspace, *args, + self, + mock__find_prolific_workspace, + *args, ): - expected_title = 'test' + expected_title = "test" mock_workspace = Workspace() mock_workspace.title = expected_title @@ -365,12 +379,15 @@ def test_find_or_create_prolific_workspace_success_find( self.assertEqual(mock_workspace, result) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.create') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_workspace') + @patch(f"{API_PATH}.workspaces.Workspaces.create") + @patch(f"{UTILS_PATH}._find_prolific_workspace") def test_find_or_create_prolific_workspace_success_create( - self, mock__find_prolific_workspace, mock_create, *args, + self, + mock__find_prolific_workspace, + mock_create, + *args, ): - expected_title = 'test' + expected_title = "test" mock_workspace = Workspace() mock_workspace.title = expected_title @@ -382,29 +399,32 @@ def test_find_or_create_prolific_workspace_success_create( self.assertEqual(mock_workspace, result) - @patch('mephisto.abstractions.providers.prolific.api.workspaces.Workspaces.create') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_workspace') + @patch(f"{API_PATH}.workspaces.Workspaces.create") + @patch(f"{UTILS_PATH}._find_prolific_workspace") def test_find_or_create_prolific_workspace_create_exception( - self, mock__find_prolific_workspace, mock_create, *args, + self, + mock__find_prolific_workspace, + mock_create, + *args, ): - expected_title = 'test' + expected_title = "test" mock_workspace = Workspace() mock_workspace.title = expected_title mock__find_prolific_workspace.return_value = (False, None) - exception_message = 'Error' + exception_message = "Error" mock_create.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: find_or_create_prolific_workspace(self.client, expected_title) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.projects.Projects.list_for_workspace') + @patch(f"{API_PATH}.projects.Projects.list_for_workspace") def test__find_prolific_project_success_with_title(self, mock_list_for_workspace, *args): - workspace_id = 'test' - project_title = 'test2' + workspace_id = "test" + project_title = "test2" mock_project = Project() mock_project.title = project_title @@ -414,13 +434,13 @@ def test__find_prolific_project_success_with_title(self, mock_list_for_workspace result = _find_prolific_project(self.client, workspace_id, project_title) self.assertEqual((True, mock_project), result) - self.assertFalse(hasattr(mock_project, 'id')) + self.assertFalse(hasattr(mock_project, "id")) - @patch('mephisto.abstractions.providers.prolific.api.projects.Projects.list_for_workspace') + @patch(f"{API_PATH}.projects.Projects.list_for_workspace") def test__find_prolific_project_success_with_id(self, mock_list_for_workspace, *args): - workspace_id = 'test' - project_title = 'test2' - project_id = 'test3' + workspace_id = "test" + project_title = "test2" + project_id = "test3" mock_project = Project() mock_project.title = project_title @@ -431,12 +451,12 @@ def test__find_prolific_project_success_with_id(self, mock_list_for_workspace, * result = _find_prolific_project(self.client, workspace_id, project_title, project_id) self.assertEqual((True, mock_project), result) - self.assertTrue(hasattr(mock_project, 'id')) + self.assertTrue(hasattr(mock_project, "id")) - @patch('mephisto.abstractions.providers.prolific.api.projects.Projects.list_for_workspace') + @patch(f"{API_PATH}.projects.Projects.list_for_workspace") def test__find_prolific_project_success_no_result(self, mock_list_for_workspace, *args): - workspace_id = 'test' - project_title = 'test2' + workspace_id = "test" + project_title = "test2" mock_project = Project() mock_project.title = project_title @@ -447,22 +467,22 @@ def test__find_prolific_project_success_no_result(self, mock_list_for_workspace, self.assertEqual((False, None), result) - @patch('mephisto.abstractions.providers.prolific.api.projects.Projects.list_for_workspace') + @patch(f"{API_PATH}.projects.Projects.list_for_workspace") def test__find_prolific_project_exception(self, mock_list_for_workspace, *args): - workspace_id = 'test' - project_title = 'test2' + workspace_id = "test" + project_title = "test2" - exception_message = 'Error' + exception_message = "Error" mock_list_for_workspace.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: _find_prolific_project(self.client, workspace_id, project_title) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_project') + @patch(f"{UTILS_PATH}._find_prolific_project") def test_find_or_create_prolific_project_success_find(self, mock__find_prolific_project, *args): - workspace_id = 'test' - project_title = 'test2' + workspace_id = "test" + project_title = "test2" mock_project = Project() mock_project.title = project_title @@ -473,13 +493,16 @@ def test_find_or_create_prolific_project_success_find(self, mock__find_prolific_ self.assertEqual(mock_project, result) - @patch('mephisto.abstractions.providers.prolific.api.projects.Projects.create_for_workspace') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_project') + @patch(f"{API_PATH}.projects.Projects.create_for_workspace") + @patch(f"{UTILS_PATH}._find_prolific_project") def test_find_or_create_prolific_project_success_create( - self, mock__find_prolific_project, mock_create_for_workspace, *args, + self, + mock__find_prolific_project, + mock_create_for_workspace, + *args, ): - workspace_id = 'test' - project_title = 'test2' + workspace_id = "test" + project_title = "test2" mock_project = Project() mock_project.title = project_title @@ -491,28 +514,29 @@ def test_find_or_create_prolific_project_success_create( self.assertEqual(mock_project, result) - @patch('mephisto.abstractions.providers.prolific.api.projects.Projects.create_for_workspace') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_prolific_project') + @patch(f"{API_PATH}.projects.Projects.create_for_workspace") + @patch(f"{UTILS_PATH}._find_prolific_project") def test_find_or_create_prolific_project_create_exception( - self, mock__find_prolific_project, mock_create_for_workspace, *args, + self, + mock__find_prolific_project, + mock_create_for_workspace, + *args, ): - workspace_id = 'test' - project_title = 'test2' + workspace_id = "test" + project_title = "test2" mock__find_prolific_project.return_value = (False, None) - exception_message = 'Error' + exception_message = "Error" mock_create_for_workspace.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: find_or_create_prolific_project(self.client, workspace_id, project_title) self.assertEqual(cm.exception.message, exception_message) - @patch( - 'mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.remove' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.remove") def test_delete_qualification_success(self, mock_remove, *args): - prolific_participant_group_id = 'test' + prolific_participant_group_id = "test" mock_remove.return_value = {} @@ -520,24 +544,22 @@ def test_delete_qualification_success(self, mock_remove, *args): self.assertTrue(result) - @patch( - 'mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.remove' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.remove") def test_delete_qualification_exception(self, mock_remove, *args): - prolific_participant_group_id = 'test' + prolific_participant_group_id = "test" - exception_message = 'Error' + exception_message = "Error" mock_remove.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: delete_qualification(self.client, prolific_participant_group_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.list') + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.list") def test__find_qualification_success(self, mock_participant_groups_list, *args): prolific_project_id = uuid4().hex[:24] - qualification_name = 'test' - qualification_description = 'test' + qualification_name = "test" + qualification_description = "test" expected_qualification_id = uuid4().hex[:24] mock_participant_groups_list.return_value = [ ParticipantGroup( @@ -550,31 +572,29 @@ def test__find_qualification_success(self, mock_participant_groups_list, *args): _, q = _find_qualification(self.client, prolific_project_id, qualification_name) self.assertEqual(q.id, expected_qualification_id) - @patch('mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.list') + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.list") def test__find_qualification_no_qualification(self, mock_participant_groups_list, *args): prolific_project_id = uuid4().hex[:24] - qualification_name = 'test' + qualification_name = "test" mock_participant_groups_list.return_value = [] result = _find_qualification(self.client, prolific_project_id, qualification_name) self.assertEqual(result, (False, None)) - @patch('mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.list') + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.list") def test__find_qualification_error(self, mock_participant_groups_list, *args): prolific_project_id = uuid4().hex[:24] - qualification_name = 'test' - exception_message = 'Error' + qualification_name = "test" + exception_message = "Error" mock_participant_groups_list.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: _find_qualification(self.client, prolific_project_id, qualification_name) self.assertEqual(cm.exception.message, exception_message) - @patch( - 'mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.create' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.create") def test_create_qualification_success(self, mock_create, *args): - prolific_project_id = 'test' - qualification_name = 'test2' - participant_group_id = 'test3' + prolific_project_id = "test" + qualification_name = "test2" + participant_group_id = "test3" mock_participant_group = ParticipantGroup() mock_participant_group.id = participant_group_id @@ -586,42 +606,43 @@ def test_create_qualification_success(self, mock_create, *args): self.assertEqual(mock_participant_group, result) - @patch( - 'mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.create' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.create") def test_create_qualification_exception(self, mock_create, *args): - prolific_project_id = 'test' - qualification_name = 'test2' + prolific_project_id = "test" + qualification_name = "test2" - exception_message = 'Error' + exception_message = "Error" mock_create.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: create_qualification(self.client, prolific_project_id, qualification_name) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_qualification') + @patch(f"{UTILS_PATH}._find_qualification") def test_find_or_create_qualification_found_one(self, mock_find_qualification, *args): prolific_project_id = uuid4().hex[:24] - qualification_name = 'test' + qualification_name = "test" expected_qualification_id = uuid4().hex[:24] expected_qualification = ParticipantGroup() expected_qualification.id = expected_qualification_id mock_find_qualification.return_value = (True, expected_qualification) result = find_or_create_qualification( - self.client, prolific_project_id, qualification_name, + self.client, + prolific_project_id, + qualification_name, ) self.assertEqual(result.id, expected_qualification_id) - @patch( - 'mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.create' - ) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_qualification') + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.create") + @patch(f"{UTILS_PATH}._find_qualification") def test_find_or_create_qualification_created_new( - self, mock_find_qualification, mock_participant_groups_create, *args, + self, + mock_find_qualification, + mock_participant_groups_create, + *args, ): - qualification_name = 'test' - qualification_description = 'test' + qualification_name = "test" + qualification_description = "test" expected_qualification_id = uuid4().hex[:24] mock_find_qualification.return_value = (False, None) mock_participant_groups_create.return_value = ParticipantGroup( @@ -630,39 +651,44 @@ def test_find_or_create_qualification_created_new( description=qualification_description, ) result = find_or_create_qualification( - self.client, qualification_name, qualification_description, + self.client, + qualification_name, + qualification_description, ) self.assertEqual(result.id, expected_qualification_id) - @patch( - 'mephisto.abstractions.providers.prolific.api.participant_groups.ParticipantGroups.create' - ) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_qualification') + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.create") + @patch(f"{UTILS_PATH}._find_qualification") def test_find_or_create_qualification_error( - self, mock_find_qualification, mock_participant_groups_create, *args, + self, + mock_find_qualification, + mock_participant_groups_create, + *args, ): - qualification_name = 'test' - qualification_description = 'test' + qualification_name = "test" + qualification_description = "test" mock_find_qualification.return_value = (False, None) - exception_message = 'Error' + exception_message = "Error" mock_participant_groups_create.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: find_or_create_qualification( - self.client, qualification_name, qualification_description, + self.client, + qualification_name, + qualification_description, ) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.architects.ec2.ec2_architect.get_full_domain') + @patch("mephisto.abstractions.architects.ec2.ec2_architect.get_full_domain") def test__ec2_external_url(self, mock_get_full_domain, *args): - mock_get_full_domain.return_value = 'http://test.com' + mock_get_full_domain.return_value = "http://test.com" result = _ec2_external_url(mock_task_run_args) self.assertEqual( - 'http://test.com?' - 'participant_id={{%PROLIFIC_PID%}}&' - 'study_id={{%STUDY_ID%}}&' - 'submission_id={{%SESSION_ID%}}', + "http://test.com?" + "participant_id={{%PROLIFIC_PID%}}&" + "study_id={{%STUDY_ID%}}&" + "submission_id={{%SESSION_ID%}}", result, ) @@ -670,20 +696,20 @@ def test__is_ec2_architect(self, *args): result_local_architect = _is_ec2_architect(mock_task_run_args) mock_task_run_args_ec2 = deepcopy(mock_task_run_args) - mock_task_run_args_ec2.architect._architect_type = 'ec2' + mock_task_run_args_ec2.architect._architect_type = "ec2" result_ec2_architect = _is_ec2_architect(mock_task_run_args_ec2) self.assertFalse(result_local_architect) self.assertTrue(result_ec2_architect) - @patch('mephisto.abstractions.architects.ec2.ec2_architect.get_full_domain') + @patch("mephisto.abstractions.architects.ec2.ec2_architect.get_full_domain") def test__get_external_study_url(self, mock_get_full_domain, *args): - mock_get_full_domain.return_value = 'http://test.com' + mock_get_full_domain.return_value = "http://test.com" result_local_architect = _get_external_study_url(mock_task_run_args) mock_task_run_args_ec2 = deepcopy(mock_task_run_args) - mock_task_run_args_ec2.architect._architect_type = 'ec2' + mock_task_run_args_ec2.architect._architect_type = "ec2" result_ec2_architect = _get_external_study_url(mock_task_run_args_ec2) self.assertEqual( @@ -691,29 +717,33 @@ def test__get_external_study_url(self, mock_get_full_domain, *args): result_local_architect, ) self.assertEqual( - 'http://test.com?' - 'participant_id={{%PROLIFIC_PID%}}&' - 'study_id={{%STUDY_ID%}}&' - 'submission_id={{%SESSION_ID%}}', + "http://test.com?" + "participant_id={{%PROLIFIC_PID%}}&" + "study_id={{%STUDY_ID%}}&" + "submission_id={{%SESSION_ID%}}", result_ec2_architect, ) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.update') - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.create') + @patch(f"{API_PATH}.studies.Studies.update") + @patch(f"{API_PATH}.studies.Studies.create") def test_create_study_success(self, mock_study_create, mock_study_update, *args): project_id = uuid4().hex[:24] expected_study_id = uuid4().hex[:24] mock_study = Study( project=project_id, id=expected_study_id, - name='test', - completion_codes=[dict( - code='test', - code_type='test', - actions=[dict( - action='test', - )], - )], + name="test", + completion_codes=[ + dict( + code="test", + code_type="test", + actions=[ + dict( + action="test", + ) + ], + ) + ], ) mock_study_create.return_value = mock_study mock_study_update.return_value = mock_study @@ -724,11 +754,11 @@ def test_create_study_success(self, mock_study_create, mock_study_update, *args) ) self.assertEqual(study.id, expected_study_id) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.update') - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.create') + @patch(f"{API_PATH}.studies.Studies.update") + @patch(f"{API_PATH}.studies.Studies.create") def test_create_study_error(self, mock_study_create, *args): project_id = uuid4().hex[:24] - exception_message = 'Error' + exception_message = "Error" mock_study_create.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: create_study( @@ -738,10 +768,10 @@ def test_create_study_error(self, mock_study_create, *args): ) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.update') - @patch('mephisto.abstractions.providers.prolific.prolific_utils.get_study') + @patch(f"{API_PATH}.studies.Studies.update") + @patch(f"{UTILS_PATH}.get_study") def test_increase_total_available_places_for_study_success(self, mock_get_study, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id @@ -753,12 +783,15 @@ def test_increase_total_available_places_for_study_success(self, mock_get_study, self.assertEqual(mock_study, result) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.update') - @patch('mephisto.abstractions.providers.prolific.prolific_utils.get_study') + @patch(f"{API_PATH}.studies.Studies.update") + @patch(f"{UTILS_PATH}.get_study") def test_increase_total_available_places_for_study_exception( - self, mock_get_study, mock_update, *args, + self, + mock_get_study, + mock_update, + *args, ): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id @@ -766,16 +799,16 @@ def test_increase_total_available_places_for_study_exception( mock_get_study.return_value = mock_study - exception_message = 'Error' + exception_message = "Error" mock_update.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: increase_total_available_places_for_study(self.client, study_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.retrieve') + @patch(f"{API_PATH}.studies.Studies.retrieve") def test_get_study_success(self, mock_retrieve, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id @@ -786,23 +819,23 @@ def test_get_study_success(self, mock_retrieve, *args): self.assertEqual(mock_study, result) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.retrieve') + @patch(f"{API_PATH}.studies.Studies.retrieve") def test_get_study_exception(self, mock_retrieve, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id - exception_message = 'Error' + exception_message = "Error" mock_retrieve.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: get_study(self.client, study_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.publish') + @patch(f"{API_PATH}.studies.Studies.publish") def test_publish_study_success(self, mock_publish, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id @@ -813,23 +846,23 @@ def test_publish_study_success(self, mock_publish, *args): self.assertEqual(study_id, result) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.publish') + @patch(f"{API_PATH}.studies.Studies.publish") def test_publish_study_exception(self, mock_publish, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id - exception_message = 'Error' + exception_message = "Error" mock_publish.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: publish_study(self.client, study_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.stop') + @patch(f"{API_PATH}.studies.Studies.stop") def test_stop_study_success(self, mock_stop, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id @@ -840,29 +873,29 @@ def test_stop_study_success(self, mock_stop, *args): self.assertEqual(mock_study, result) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.stop') + @patch(f"{API_PATH}.studies.Studies.stop") def test_stop_study_exception(self, mock_stop, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id - exception_message = 'Error' + exception_message = "Error" mock_stop.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: stop_study(self.client, study_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.update') - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.stop') - @patch('mephisto.abstractions.providers.prolific.prolific_utils.get_study') + @patch(f"{API_PATH}.studies.Studies.update") + @patch(f"{API_PATH}.studies.Studies.stop") + @patch(f"{UTILS_PATH}.get_study") def test_expire_study_success(self, mock_get_study, mock_stop, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id - mock_study.internal_name = 'test' + mock_study.internal_name = "test" mock_get_study.return_value = mock_study mock_stop.return_value = mock_study @@ -871,14 +904,14 @@ def test_expire_study_success(self, mock_get_study, mock_stop, *args): self.assertEqual(mock_study, result) - @patch('mephisto.abstractions.providers.prolific.prolific_utils.get_study') + @patch(f"{UTILS_PATH}.get_study") def test_expire_study_exception(self, mock_get_study, *args): - study_id = 'test' + study_id = "test" mock_study = Study() mock_study.id = study_id - exception_message = 'Error' + exception_message = "Error" mock_get_study.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: expire_study(self.client, study_id) @@ -886,8 +919,8 @@ def test_expire_study_exception(self, mock_get_study, *args): self.assertEqual(cm.exception.message, exception_message) def test_is_study_expired(self, *args): - study_id = 'test' - study_name = 'test' + study_id = "test" + study_name = "test" mock_study = Study() mock_study.id = study_id @@ -903,7 +936,7 @@ def test_is_study_expired(self, *args): result_just_with_awaiting_review_status = is_study_expired(mock_study) mock_study.status = constants.StudyStatus.COMPLETED - mock_study.internal_name = study_name + '_' + constants.StudyStatus._EXPIRED + mock_study.internal_name = study_name + "_" + constants.StudyStatus._EXPIRED result_with_completed_status_and_internal_name = is_study_expired(mock_study) self.assertFalse(result_just_with_completed_status) @@ -911,83 +944,71 @@ def test_is_study_expired(self, *args): self.assertFalse(result_just_with_awaiting_review_status) self.assertTrue(result_with_completed_status_and_internal_name) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.add_participants_to_group' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.add_participants_to_group") def test_add_workers_to_qualification_success(self, *args): - worker_ids = ['test', 'test2'] - participant_group_id = 'test3' + worker_ids = ["test", "test2"] + participant_group_id = "test3" result = add_workers_to_qualification(self.client, worker_ids, participant_group_id) self.assertIsNone(result) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.add_participants_to_group' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.add_participants_to_group") def test_add_workers_to_qualification_exception(self, mock_add_participants_to_group, *args): - worker_ids = ['test', 'test2'] - participant_group_id = 'test3' + worker_ids = ["test", "test2"] + participant_group_id = "test3" - exception_message = 'Error' + exception_message = "Error" mock_add_participants_to_group.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: add_workers_to_qualification(self.client, worker_ids, participant_group_id) self.assertEqual(cm.exception.message, exception_message) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.add_participants_to_group' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.add_participants_to_group") def test_give_worker_qualification_success(self, mock_add_participants_to_group, *args): - worker_id = 'test' - participant_group_id = 'test3' + worker_id = "test" + participant_group_id = "test3" result = give_worker_qualification(self.client, worker_id, participant_group_id) mock_add_participants_to_group.assert_called_once_with( - id=participant_group_id, participant_ids=[worker_id], + id=participant_group_id, + participant_ids=[worker_id], ) self.assertIsNone(result) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.remove_participants_from_group' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.remove_participants_from_group") def test_remove_worker_qualification_success(self, *args): - worker_id = 'test' - participant_group_id = 'test2' + worker_id = "test" + participant_group_id = "test2" result = remove_worker_qualification(self.client, worker_id, participant_group_id) self.assertIsNone(result) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.remove_participants_from_group' - ) + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.remove_participants_from_group") def test_remove_worker_qualification_exception( - self, mock_remove_participants_from_group, *args, + self, + mock_remove_participants_from_group, + *args, ): - worker_id = 'test' - participant_group_id = 'test2' + worker_id = "test" + participant_group_id = "test2" - exception_message = 'Error' + exception_message = "Error" mock_remove_participants_from_group.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: remove_worker_qualification(self.client, worker_id, participant_group_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.pay') - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.set_up') - @patch('mephisto.abstractions.providers.prolific.prolific_utils.check_balance') + @patch(f"{API_PATH}.bonuses.Bonuses.pay") + @patch(f"{API_PATH}.bonuses.Bonuses.set_up") + @patch(f"{UTILS_PATH}.check_balance") def test_pay_bonus_empty_balance(self, mock_check_balance, mock_set_up, mock_pay, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" bonus_amount = 1000 mock_check_balance.return_value = False @@ -998,12 +1019,12 @@ def test_pay_bonus_empty_balance(self, mock_check_balance, mock_set_up, mock_pay mock_pay.assert_not_called() self.assertFalse(result) - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.pay') - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.set_up') - @patch('mephisto.abstractions.providers.prolific.prolific_utils.check_balance') + @patch(f"{API_PATH}.bonuses.Bonuses.pay") + @patch(f"{API_PATH}.bonuses.Bonuses.set_up") + @patch(f"{UTILS_PATH}.check_balance") def test_pay_bonus_empty_balance(self, mock_check_balance, mock_set_up, mock_pay, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" bonus_amount = 1000 mock_check_balance.return_value = False @@ -1014,13 +1035,13 @@ def test_pay_bonus_empty_balance(self, mock_check_balance, mock_set_up, mock_pay mock_pay.assert_not_called() self.assertFalse(result) - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.pay') - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.set_up') - @patch('mephisto.abstractions.providers.prolific.prolific_utils.check_balance') + @patch(f"{API_PATH}.bonuses.Bonuses.pay") + @patch(f"{API_PATH}.bonuses.Bonuses.set_up") + @patch(f"{UTILS_PATH}.check_balance") def test_pay_bonus_success(self, mock_check_balance, mock_set_up, mock_pay, *args): - worker_id = 'test' - study_id = 'test2' - bonus_payments_id = 'test3' + worker_id = "test" + study_id = "test2" + bonus_payments_id = "test3" bonus_amount = 1000 mock_bonus_payments = BonusPayments() @@ -1030,36 +1051,36 @@ def test_pay_bonus_success(self, mock_check_balance, mock_set_up, mock_pay, *arg result = pay_bonus(self.client, mock_task_run_args, worker_id, bonus_amount, study_id) - mock_set_up.assert_called_once_with(study_id, f'{worker_id},{bonus_amount / 100}') + mock_set_up.assert_called_once_with(study_id, f"{worker_id},{bonus_amount / 100}") mock_pay.assert_called_once_with(mock_bonus_payments.id) self.assertTrue(result) - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.pay') - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.set_up') - @patch('mephisto.abstractions.providers.prolific.prolific_utils.check_balance') + @patch(f"{API_PATH}.bonuses.Bonuses.pay") + @patch(f"{API_PATH}.bonuses.Bonuses.set_up") + @patch(f"{UTILS_PATH}.check_balance") def test_pay_bonus_set_up_exception(self, mock_check_balance, mock_set_up, mock_pay, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" bonus_amount = 1000 mock_check_balance.return_value = True - exception_message = 'Error' + exception_message = "Error" mock_set_up.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: pay_bonus(self.client, mock_task_run_args, worker_id, bonus_amount, study_id) self.assertEqual(cm.exception.message, exception_message) - mock_set_up.assert_called_once_with(study_id, f'{worker_id},{bonus_amount / 100}') + mock_set_up.assert_called_once_with(study_id, f"{worker_id},{bonus_amount / 100}") mock_pay.assert_not_called() - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.pay') - @patch('mephisto.abstractions.providers.prolific.api.bonuses.Bonuses.set_up') - @patch('mephisto.abstractions.providers.prolific.prolific_utils.check_balance') + @patch(f"{API_PATH}.bonuses.Bonuses.pay") + @patch(f"{API_PATH}.bonuses.Bonuses.set_up") + @patch(f"{UTILS_PATH}.check_balance") def test_pay_bonus_pay_exception(self, mock_check_balance, mock_set_up, mock_pay, *args): - worker_id = 'test' - study_id = 'test2' - bonus_payments_id = 'test3' + worker_id = "test" + study_id = "test2" + bonus_payments_id = "test3" bonus_amount = 1000 mock_bonus_payments = BonusPayments() @@ -1067,22 +1088,18 @@ def test_pay_bonus_pay_exception(self, mock_check_balance, mock_set_up, mock_pay mock_check_balance.return_value = True mock_set_up.return_value = mock_bonus_payments - exception_message = 'Error' + exception_message = "Error" mock_pay.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: pay_bonus(self.client, mock_task_run_args, worker_id, bonus_amount, study_id) self.assertEqual(cm.exception.message, exception_message) - mock_set_up.assert_called_once_with(study_id, f'{worker_id},{bonus_amount / 100}') + mock_set_up.assert_called_once_with(study_id, f"{worker_id},{bonus_amount / 100}") mock_pay.assert_called_once_with(mock_bonus_payments.id) - @patch('mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_qualification') - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_project' - ) - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_workspace' - ) + @patch(f"{UTILS_PATH}.find_or_create_qualification") + @patch(f"{UTILS_PATH}.find_or_create_prolific_project") + @patch(f"{UTILS_PATH}.find_or_create_prolific_workspace") def test__get_block_list_qualification( self, mock_find_or_create_prolific_workspace, @@ -1091,13 +1108,13 @@ def test__get_block_list_qualification( *args, ): mock_workspace = Workspace() - mock_workspace.id = 'test' + mock_workspace.id = "test" mock_project = Project() - mock_project.id = 'test2' - mock_project.title = 'test2_title' + mock_project.id = "test2" + mock_project.title = "test2_title" mock_participant_group = ParticipantGroup() - mock_participant_group.id = 'test3' - mock_participant_group.name = 'test3_name' + mock_participant_group.id = "test3" + mock_participant_group.name = "test3_name" mock_find_or_create_prolific_workspace.return_value = mock_workspace mock_find_or_create_prolific_project.return_value = mock_project @@ -1107,15 +1124,18 @@ def test__get_block_list_qualification( self.assertEqual(mock_participant_group, result) - @patch('mephisto.abstractions.providers.prolific.prolific_utils.add_workers_to_qualification') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._get_block_list_qualification') + @patch(f"{UTILS_PATH}.add_workers_to_qualification") + @patch(f"{UTILS_PATH}._get_block_list_qualification") def test_block_worker_success( - self, mock__get_block_list_qualification, mock_add_workers_to_qualification, *args, + self, + mock__get_block_list_qualification, + mock_add_workers_to_qualification, + *args, ): - worker_id = 'test' + worker_id = "test" mock_participant_group = ParticipantGroup() - mock_participant_group.id = 'test2' + mock_participant_group.id = "test2" mock__get_block_list_qualification.return_value = mock_participant_group @@ -1123,21 +1143,23 @@ def test_block_worker_success( self.assertIsNone(result) mock_add_workers_to_qualification.called_once_with( - self.client, workers_ids=[worker_id], qualification_id=mock_participant_group.id, + self.client, + workers_ids=[worker_id], + qualification_id=mock_participant_group.id, ) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.remove_participants_from_group' - ) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._get_block_list_qualification') + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.remove_participants_from_group") + @patch(f"{UTILS_PATH}._get_block_list_qualification") def test_unblock_worker_success( - self, mock__get_block_list_qualification, mock_remove_participants_from_group, *args, + self, + mock__get_block_list_qualification, + mock_remove_participants_from_group, + *args, ): - worker_id = 'test' + worker_id = "test" mock_participant_group = ParticipantGroup() - mock_participant_group.id = 'test2' + mock_participant_group.id = "test2" mock__get_block_list_qualification.return_value = mock_participant_group @@ -1145,24 +1167,21 @@ def test_unblock_worker_success( self.assertIsNone(result) mock_remove_participants_from_group.called_once_with( - id=mock_participant_group.id, participant_ids=[worker_id], + id=mock_participant_group.id, + participant_ids=[worker_id], ) - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_project' - ) - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_workspace' - ) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.list_participants_for_group' - ) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_qualification') + @patch(f"{UTILS_PATH}.find_or_create_prolific_project") + @patch(f"{UTILS_PATH}.find_or_create_prolific_workspace") + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.list_participants_for_group") + @patch(f"{UTILS_PATH}._find_qualification") def test_is_worker_blocked_no_block_list_qualification( - self, mock__find_qualification, mock_list_participants_for_group, *args, + self, + mock__find_qualification, + mock_list_participants_for_group, + *args, ): - worker_id = 'test' + worker_id = "test" mock__find_qualification.return_value = (False, None) @@ -1171,24 +1190,20 @@ def test_is_worker_blocked_no_block_list_qualification( self.assertFalse(result) mock_list_participants_for_group.assert_not_called() - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_project' - ) - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_workspace' - ) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.list_participants_for_group' - ) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_qualification') + @patch(f"{UTILS_PATH}.find_or_create_prolific_project") + @patch(f"{UTILS_PATH}.find_or_create_prolific_workspace") + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.list_participants_for_group") + @patch(f"{UTILS_PATH}._find_qualification") def test_is_worker_blocked_success_true( - self, mock__find_qualification, mock_list_participants_for_group, *args, + self, + mock__find_qualification, + mock_list_participants_for_group, + *args, ): - worker_id = 'test' + worker_id = "test" mock_participant_group = ParticipantGroup() - mock_participant_group.id = 'test2' + mock_participant_group.id = "test2" mock_participant = Participant() mock_participant.participant_id = worker_id @@ -1200,26 +1215,22 @@ def test_is_worker_blocked_success_true( self.assertTrue(result) mock_list_participants_for_group.assert_called_once() - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_project' - ) - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_workspace' - ) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.list_participants_for_group' - ) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_qualification') + @patch(f"{UTILS_PATH}.find_or_create_prolific_project") + @patch(f"{UTILS_PATH}.find_or_create_prolific_workspace") + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.list_participants_for_group") + @patch(f"{UTILS_PATH}._find_qualification") def test_is_worker_blocked_success_false( - self, mock__find_qualification, mock_list_participants_for_group, *args, + self, + mock__find_qualification, + mock_list_participants_for_group, + *args, ): - worker_id = 'test' + worker_id = "test" mock_participant_group = ParticipantGroup() - mock_participant_group.id = 'test2' + mock_participant_group.id = "test2" mock_participant = Participant() - mock_participant.participant_id = 'test3' + mock_participant.participant_id = "test3" mock__find_qualification.return_value = (True, mock_participant_group) mock_list_participants_for_group.return_value = [mock_participant] @@ -1229,30 +1240,26 @@ def test_is_worker_blocked_success_false( self.assertFalse(result) mock_list_participants_for_group.assert_called_once() - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_project' - ) - @patch( - 'mephisto.abstractions.providers.prolific.prolific_utils.find_or_create_prolific_workspace' - ) - @patch( - 'mephisto.abstractions.providers.prolific.api.' - 'participant_groups.ParticipantGroups.list_participants_for_group' - ) - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_qualification') + @patch(f"{UTILS_PATH}.find_or_create_prolific_project") + @patch(f"{UTILS_PATH}.find_or_create_prolific_workspace") + @patch(f"{API_PATH}.participant_groups.ParticipantGroups.list_participants_for_group") + @patch(f"{UTILS_PATH}._find_qualification") def test_is_worker_blocked_exception( - self, mock__find_qualification, mock_list_participants_for_group, *args, + self, + mock__find_qualification, + mock_list_participants_for_group, + *args, ): - worker_id = 'test' + worker_id = "test" mock_participant_group = ParticipantGroup() - mock_participant_group.id = 'test2' + mock_participant_group.id = "test2" mock_participant = Participant() mock_participant.participant_id = worker_id mock__find_qualification.return_value = (True, mock_participant_group) - exception_message = 'Error' + exception_message = "Error" mock_list_participants_for_group.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: is_worker_blocked(self.client, mock_task_run_args, worker_id) @@ -1260,7 +1267,7 @@ def test_is_worker_blocked_exception( self.assertEqual(cm.exception.message, exception_message) mock_list_participants_for_group.assert_called_once() - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.calculate_cost') + @patch(f"{API_PATH}.studies.Studies.calculate_cost") def test_calculate_pay_amount_success(self, mock_calculate_cost, *args): task_amount = 1000 total_available_places = 2 @@ -1271,25 +1278,25 @@ def test_calculate_pay_amount_success(self, mock_calculate_cost, *args): self.assertEqual(task_amount * total_available_places, result) - @patch('mephisto.abstractions.providers.prolific.api.studies.Studies.calculate_cost') + @patch(f"{API_PATH}.studies.Studies.calculate_cost") def test_calculate_pay_amount_exception(self, mock_calculate_cost, *args): task_amount = 1000 total_available_places = 2 - exception_message = 'Error' + exception_message = "Error" mock_calculate_cost.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: calculate_pay_amount(self.client, task_amount, total_available_places) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.list') + @patch(f"{API_PATH}.submissions.Submissions.list") def test__find_submission_success_found(self, mock_list, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock_list_submission = ListSubmission() - mock_list_submission.id = 'test3' + mock_list_submission.id = "test3" mock_list_submission.participant_id = worker_id mock_list.return_value = [mock_list_submission] @@ -1298,14 +1305,14 @@ def test__find_submission_success_found(self, mock_list, *args): self.assertEqual(mock_list_submission, result) - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.list') + @patch(f"{API_PATH}.submissions.Submissions.list") def test__find_submission_success_not_found(self, mock_list, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock_list_submission = ListSubmission() - mock_list_submission.id = 'test3' - mock_list_submission.participant_id = 'test4' + mock_list_submission.id = "test3" + mock_list_submission.participant_id = "test4" mock_list.return_value = [mock_list_submission] @@ -1313,24 +1320,24 @@ def test__find_submission_success_not_found(self, mock_list, *args): self.assertEqual(None, result) - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.list') + @patch(f"{API_PATH}.submissions.Submissions.list") def test__find_submission_exception(self, mock_list, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" - exception_message = 'Error' + exception_message = "Error" mock_list.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: _find_submission(self.client, study_id, worker_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.retrieve') + @patch(f"{API_PATH}.submissions.Submissions.retrieve") def test_get_submission_success(self, mock_retrieve, *args): - submission_id = 'test' + submission_id = "test" mock_submission = Submission() - mock_submission.id = 'test2' + mock_submission.id = "test2" mock_retrieve.return_value = mock_submission @@ -1338,22 +1345,22 @@ def test_get_submission_success(self, mock_retrieve, *args): self.assertEqual(mock_submission, result) - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.retrieve') + @patch(f"{API_PATH}.submissions.Submissions.retrieve") def test_get_submission_exception(self, mock_retrieve, *args): - submission_id = 'test' + submission_id = "test" - exception_message = 'Error' + exception_message = "Error" mock_retrieve.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: get_submission(self.client, submission_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.approve') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_submission') + @patch(f"{API_PATH}.submissions.Submissions.approve") + @patch(f"{UTILS_PATH}._find_submission") def test_approve_work_submission_not_found(self, mock__find_submission, mock_approve, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock__find_submission.return_value = False @@ -1362,18 +1369,18 @@ def test_approve_work_submission_not_found(self, mock__find_submission, mock_app self.assertIsNone(result) mock_approve.assert_not_called() - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.approve') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_submission') + @patch(f"{API_PATH}.submissions.Submissions.approve") + @patch(f"{UTILS_PATH}._find_submission") def test_approve_work_success(self, mock__find_submission, mock_approve, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock_submission = Submission() - mock_submission.id = 'test3' + mock_submission.id = "test3" mock_submission.status = constants.SubmissionStatus.AWAITING_REVIEW mock_submission_approved = Submission() - mock_submission_approved.id = 'test4' + mock_submission_approved.id = "test4" mock_submission_approved.status = constants.SubmissionStatus.APPROVED mock__find_submission.return_value = mock_submission @@ -1384,16 +1391,19 @@ def test_approve_work_success(self, mock__find_submission, mock_approve, *args): self.assertEqual(mock_submission_approved, result) mock_approve.assert_called_once() - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.approve') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_submission') + @patch(f"{API_PATH}.submissions.Submissions.approve") + @patch(f"{UTILS_PATH}._find_submission") def test_approve_work_incorrect_submission_status( - self, mock__find_submission, mock_approve, *args, + self, + mock__find_submission, + mock_approve, + *args, ): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock_submission = Submission() - mock_submission.id = 'test3' + mock_submission.id = "test3" mock_submission.status = constants.SubmissionStatus.ACTIVE mock__find_submission.return_value = mock_submission @@ -1403,30 +1413,30 @@ def test_approve_work_incorrect_submission_status( self.assertIsNone(result) mock_approve.assert_not_called() - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.approve') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_submission') + @patch(f"{API_PATH}.submissions.Submissions.approve") + @patch(f"{UTILS_PATH}._find_submission") def test_approve_work_exception(self, mock__find_submission, mock_approve, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock_submission = Submission() - mock_submission.id = 'test3' + mock_submission.id = "test3" mock_submission.status = constants.SubmissionStatus.AWAITING_REVIEW mock__find_submission.return_value = mock_submission - exception_message = 'Error' + exception_message = "Error" mock_approve.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: approve_work(self.client, study_id, worker_id) self.assertEqual(cm.exception.message, exception_message) - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.reject') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_submission') + @patch(f"{API_PATH}.submissions.Submissions.reject") + @patch(f"{UTILS_PATH}._find_submission") def test_reject_work_submission_not_found(self, mock__find_submission, mock_reject, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock__find_submission.return_value = False @@ -1435,18 +1445,18 @@ def test_reject_work_submission_not_found(self, mock__find_submission, mock_reje self.assertIsNone(result) mock_reject.assert_not_called() - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.reject') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_submission') + @patch(f"{API_PATH}.submissions.Submissions.reject") + @patch(f"{UTILS_PATH}._find_submission") def test_reject_work_success(self, mock__find_submission, mock_reject, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock_submission = Submission() - mock_submission.id = 'test3' + mock_submission.id = "test3" mock_submission.status = constants.SubmissionStatus.AWAITING_REVIEW mock_submission_rejected = Submission() - mock_submission_rejected.id = 'test4' + mock_submission_rejected.id = "test4" mock_submission_rejected.status = constants.SubmissionStatus.REJECTED mock__find_submission.return_value = mock_submission @@ -1457,16 +1467,19 @@ def test_reject_work_success(self, mock__find_submission, mock_reject, *args): self.assertEqual(mock_submission_rejected, result) mock_reject.assert_called_once() - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.reject') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_submission') + @patch(f"{API_PATH}.submissions.Submissions.reject") + @patch(f"{UTILS_PATH}._find_submission") def test_reject_work_incorrect_submission_status( - self, mock__find_submission, mock_reject, *args, + self, + mock__find_submission, + mock_reject, + *args, ): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock_submission = Submission() - mock_submission.id = 'test3' + mock_submission.id = "test3" mock_submission.status = constants.SubmissionStatus.ACTIVE mock__find_submission.return_value = mock_submission @@ -1476,19 +1489,19 @@ def test_reject_work_incorrect_submission_status( self.assertIsNone(result) mock_reject.assert_not_called() - @patch('mephisto.abstractions.providers.prolific.api.submissions.Submissions.reject') - @patch('mephisto.abstractions.providers.prolific.prolific_utils._find_submission') + @patch(f"{API_PATH}.submissions.Submissions.reject") + @patch(f"{UTILS_PATH}._find_submission") def test_reject_work_exception(self, mock__find_submission, mock_reject, *args): - worker_id = 'test' - study_id = 'test2' + worker_id = "test" + study_id = "test2" mock_submission = Submission() - mock_submission.id = 'test3' + mock_submission.id = "test3" mock_submission.status = constants.SubmissionStatus.AWAITING_REVIEW mock__find_submission.return_value = mock_submission - exception_message = 'Error' + exception_message = "Error" mock_reject.side_effect = ProlificRequestError(exception_message) with self.assertRaises(ProlificRequestError) as cm: reject_work(self.client, study_id, worker_id)