def test_login_with_code_returns_redirect_to_frontend(self): from foundations_rest_api.global_state import app_manager with app_manager.app().test_request_context(query_string="code=code"): resp = self.auth_controller.get("login") self.assertIn("http://localhost:3000/projects", resp.headers["Location"])
def test_login_with_code_exchanges_code_for_token(self): from foundations_rest_api.global_state import app_manager with app_manager.app().test_request_context(query_string="code=code"): self.auth_controller.get("login") self.auth_client.token_using_auth_code.assert_called_once_with( code="code")
def test_logout_uses_client_logout(self): from foundations_rest_api.global_state import app_manager headers = {"Authorization": "bearer token"} with app_manager.app().test_request_context(headers=headers): self.auth_controller.get("logout") self.auth_client.logout.assert_called_once_with("token")
def test_login_without_code_redirects_to_login_page(self): from foundations_core_rest_api_components.v1.controllers.authentication_controller import ( AuthenticationController, ) from foundations_rest_api.global_state import app_manager with app_manager.app().test_request_context(): resp = self.auth_controller.get("login") self.assertIn("AuthenticationClient().authentication_url()", resp.headers["Location"])
def test_post_then_index_returns_same_data(self): from foundations_rest_api.global_state import app_manager headers = {"Authorization": "bearer token"} self.auth_client.users_info = ConditionalReturn() self.auth_client.users_info.return_when({self.userid: self.username}, "token") with app_manager.app().test_request_context(headers=headers): self.controller.post() index_result = self.controller.index().as_json() self.assertEqual(1, len(index_result)) self.assertEqual(self.message, index_result[0]["message"])
def test_cli_login(self): from foundations_rest_api.global_state import app_manager import base64 username = self.faker.word() password = self.faker.word() code = base64.b64encode(f"{username}:{password}".encode()).decode() headers = {"Authorization": f"Basic {code}"} with app_manager.app().test_request_context(headers=headers): self.auth_controller.get("cli_login") self.auth_client.token_using_username_password.assert_called_once_with( username, password)
class TestProjectsListingEndpoint(Spec): client = app_manager.app().test_client() url = '/api/v2beta/projects' def _str_random_uuid(self): import uuid return str(uuid.uuid4()) @let def redis(self): from foundations_contrib.global_state import redis_connection return redis_connection @set_up def set_up(self): self.project_name_1 = self._str_random_uuid() self.project_name_2 = self._str_random_uuid() self.project_name_3 = self._str_random_uuid() self._create_project(self.project_name_1) self._create_project(self.project_name_2) self._create_project(self.project_name_3) def _create_project(self, project_name): import time from foundations_contrib.global_state import redis_connection self.redis.execute_command('ZADD', 'projects', 'NX', time.time(), project_name) def _get_from_route(self): import json response = self.client.get(self.url) response_data = response.data.decode() return json.loads(response_data) def test_get_project_listing(self): data = self._get_from_route() self._assert_project_in(self.project_name_1, data) self._assert_project_in(self.project_name_2, data) self._assert_project_in(self.project_name_3, data) def _assert_project_in(self, project_name, projects): for project in projects: if project['name'] == project_name: return raise AssertionError(f'no project with name \'{project_name}\' exists in {projects}')
def test_verify_calls_verify_token_with_token_and_client_jwks_issuer( self, verify): self.auth_client.json_web_key_set = None self.auth_client.issuer = "value" from foundations_rest_api.global_state import app_manager headers = {"Authorization": "bearer token"} with app_manager.app().test_request_context(headers=headers): self.auth_controller.get("verify") verify.assert_called_once_with("token", self.auth_client.json_web_key_set, self.auth_client.issuer)
'deployment_implementation': { 'deployment_type': JobDeployment, }, 'scheduler_url': os.environ["FOUNDATIONS_SCHEDULER_URL"], } configuration = config_manager.config() configuration.update(translated_submission_config) root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler = logging.FileHandler('/var/foundations/rest_api.log') file_handler.setLevel(logging.DEBUG) file_handler.setFormatter(formatter) root_logger.addHandler(file_handler) root_logger.info("Running with configuration {}".format(configuration)) app = app_manager.app() @app.after_request def apply_caching(response): response.headers["X-Frame-Options"] = "DENY" response.headers["X-XSS-Protection"] = "1; mode=block" response.headers["X-Content-Type-Options"] = "nosniff" response.headers["Content-Type"] = "application/json" return response
def _test_client(self): from foundations_rest_api.global_state import app_manager return app_manager.app().test_client()
class APIAcceptanceTestCaseBase( with_metaclass(APIAcceptanceTestCaseMeta, unittest.TestCase)): client = app_manager.app().test_client() url = None @classmethod def _setup(klass): klass._query_string_generator = QueryStringGenerator() return itertools.chain( klass._set_method_for_normal_route(), klass._set_methods_for_sorted_route(), klass._set_methods_for_sorted_route_all_columns(), klass._set_methods_for_sorted_route_alternation(), klass._set_methods_for_filtering_by_range(), klass._set_methods_for_filtering_by_exact_match(), ) def _extract_url_params(self): from string import Formatter formatter = Formatter() params = [ format_tuple[1] for format_tuple in formatter.parse(self.url) ] return params def _get_base_url(self): url = self.url params = self._extract_url_params() for param in params: if param: url = url.replace("{{{}}}".format(param), getattr(self, param)) return url @classmethod def _get_test_route_method(klass, query_string=""): def test_method(self): base_url = self._get_base_url() resp = self.client.get(base_url + query_string) self.assertEqual(resp.status_code, 200) return json.loads(resp.data.decode()) return test_method @classmethod def _add_route_sorted_methods(klass, column): method_name_descendant = "test_sorted_{}_descending".format(column) method_name_ascendant = "test_sorted_{}_ascending".format(column) descending_query_string = klass._query_string_generator.sort_column( column, descending=True) ascending_query_string = klass._query_string_generator.sort_column( column, descending=False) setattr( klass, method_name_descendant, klass._get_test_route_method(descending_query_string), ) setattr( klass, method_name_ascendant, klass._get_test_route_method(ascending_query_string), ) return [method_name_descendant, method_name_ascendant] @classmethod def _set_methods_for_sorted_route(klass): methods_names = [] for sorting_column in klass.sorting_columns: methods_names += klass._add_route_sorted_methods(sorting_column) return methods_names @classmethod def _set_methods_for_sorted_route_all_columns(klass): if len(klass.sorting_columns) > 1: method_name_ascending = "test_all_ascending" method_name_descending = "test_all_descending" ascending_query_string = klass._query_string_generator.sort_all_columns( klass.sorting_columns, descending=False) descending_query_string = klass._query_string_generator.sort_all_columns( klass.sorting_columns, descending=True) setattr( klass, method_name_ascending, klass._get_test_route_method(ascending_query_string), ) setattr( klass, method_name_descending, klass._get_test_route_method(descending_query_string), ) return [method_name_ascending, method_name_descending] return [] @classmethod def _set_methods_for_sorted_route_alternation(klass): if len(klass.sorting_columns) > 1: method_name_alternation = "test_alternation" alternation_query_string = klass._query_string_generator.sort_alternation( klass.sorting_columns) setattr( klass, method_name_alternation, klass._get_test_route_method(alternation_query_string), ) return [method_name_alternation] return [] @classmethod def _set_method_for_normal_route(klass): setattr(klass, "test_get_route", klass._get_test_route_method()) return ["test_get_route"] @classmethod def _add_filter_range_method(klass, column_data): method_name = "test_filter_{}_range".format(column_data["name"]) range_query_string = klass._query_string_generator.filter_range( column_data) setattr(klass, method_name, klass._get_test_route_method(range_query_string)) return [method_name] @classmethod def _set_methods_for_filtering_by_range(klass): methods_names = [] for column_data in klass.filtering_columns: methods_names += klass._add_filter_range_method(column_data) return methods_names @classmethod def _add_filter_exact_match_methods(klass, column_data): method_name_one_option = "test_filter_{}_exact_match_one_option".format( column_data["name"]) method_name_two_options = "test_filter_{}_exact_match_two_options".format( column_data["name"]) one_option_match_query_string = klass._query_string_generator.filter_exact_match_one_option( column_data) two_option_match_query_string = klass._query_string_generator.filter_exact_match_two_options( column_data) setattr( klass, method_name_one_option, klass._get_test_route_method(one_option_match_query_string), ) setattr( klass, method_name_two_options, klass._get_test_route_method(two_option_match_query_string), ) return [method_name_one_option, method_name_two_options] @classmethod def _set_methods_for_filtering_by_exact_match(klass): methods_names = [] for column_data in klass.filtering_columns: methods_names += klass._add_filter_exact_match_methods(column_data) return methods_names