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