def test_create_valid(self):
name = self.dataset_populator.get_random_name()
description = "A test role."
payload = {
"name": name,
"description": description,
"user_ids": [self.dataset_populator.user_id()],
}
response = self._post("roles", payload, admin=True, json=True)
assert_status_code_is(response, 200)
role = response.json()
RolesApiTestCase.check_role_dict(role)
assert role["name"] == name
assert role["description"] == description
user_roles_response = self._get("roles")
with self._different_user():
different_user_roles_response = self._get("roles")
user_roles_response_ids = [r["id"] for r in user_roles_response.json()]
different_user_roles_response_ids = [
r["id"] for r in different_user_roles_response.json()
]
# This new role is public, all users see it.
assert role["id"] in user_roles_response_ids
assert role["id"] in different_user_roles_response_ids
def test_create_valid(self):
name = self.dataset_populator.get_random_name()
description = "A test role."
payload = {
"name": name,
"description": description,
"user_ids": json.dumps([self.dataset_populator.user_id()]),
}
response = self._post("roles", payload, admin=True)
assert_status_code_is(response, 200)
# TODO: Why does this return a singleton list - that is bad - should be deprecated
# and return a single role.
role = response.json()[0]
RolesApiTestCase.check_role_dict(role)
assert role["name"] == name
assert role["description"] == description
user_roles_response = self._get("roles")
with self._different_user():
different_user_roles_response = self._get("roles")
user_roles_response_ids = [r["id"] for r in user_roles_response.json()]
different_user_roles_response_ids = [
r["id"] for r in different_user_roles_response.json()
]
# This new role is public, all users see it.
assert role["id"] in user_roles_response_ids
assert role["id"] in different_user_roles_response_ids
def check_roles_response(response):
assert_status_code_is(response, 200)
as_list = response.json()
assert isinstance(as_list, list)
assert len(as_list) > 0
for role in as_list:
RolesApiTestCase.check_role_dict(role)
def entry_point_target(self, entry_point_id):
entry_point_access_response = self._get("entry_points/%s/access" %
entry_point_id)
api_asserts.assert_status_code_is(entry_point_access_response, 200)
access_json = entry_point_access_response.json()
api_asserts.assert_has_key(access_json, "target")
return access_json["target"]
def test_mapping_collection_states_running(self):
history_id = self.current_history_id()
input_collection = self.dataset_collection_populator.create_list_in_history(
history_id, contents=["0", "1"]).json()
running_inputs = {
"input1": {
'batch': True,
'values': [{
"src": "hdca",
"id": input_collection["id"]
}]
},
"sleep_time": 60,
}
running_response = self.dataset_populator.run_tool_raw(
"cat_data_and_sleep",
running_inputs,
history_id,
)
try:
assert_status_code_is(running_response, 200)
running_hid = running_response.json(
)["implicit_collections"][0]["hid"]
# sleep really shouldn't be needed :(
time.sleep(1)
self.home()
self.history_panel_wait_for_hid_state(running_hid, "running", 1)
self.screenshot("history_panel_collections_state_mapping_running")
finally:
for job in running_response.json()["jobs"]:
self.dataset_populator.cancel_job(job["id"])
def test_output_collection_states_running(self):
history_id = self.current_history_id()
running_inputs = {
"sleep_time": 180,
}
running_response = self.dataset_populator.run_tool(
"collection_creates_dynamic_nested",
running_inputs,
history_id,
assert_ok=False,
)
assert_status_code_is(running_response, 200)
payload = running_response.json()
assert payload["output_collections"]
assert payload["jobs"]
assert len(payload["jobs"]) > 0
assert len(["output_collections"]) > 0
running_hid = payload["output_collections"][0]["hid"]
assert running_hid
try:
if not self.is_beta_history():
# sleep really shouldn't be needed :(
time.sleep(1)
self.home()
self.history_panel_wait_for_hid_state(running_hid, "running")
self.screenshot("history_panel_collections_state_running")
finally:
for job in payload["jobs"]:
self.dataset_populator.cancel_job(job["id"])
def test_vault_secret_per_user_in_file_source(self):
"""
This file source performs a user vault lookup. The secret stored for the first user is a
valid path and should succeed, while the second user's stored secret should fail.
"""
with self._different_user(email=self.USER_1_APP_VAULT_ENTRY):
app = self._app
user = app.model.context.query(app.model.User).filter(
app.model.User.email == self.USER_1_APP_VAULT_ENTRY).first()
user_vault = UserVaultWrapper(self._app.vault, user)
# use a valid symlink path so the posix list succeeds
user_vault.write_secret(
'posix/root_path',
app.config.user_library_import_symlink_allowlist[0])
data = {"target": "gxfiles://test_user_vault"}
list_response = self.galaxy_interactor.get("remote_files", data)
api_asserts.assert_status_code_is_ok(list_response)
remote_files = list_response.json()
print(remote_files)
with self._different_user(email=self.USER_2_APP_VAULT_ENTRY):
app = self._app
user = app.model.context.query(app.model.User).filter(
app.model.User.email == self.USER_2_APP_VAULT_ENTRY).first()
user_vault = UserVaultWrapper(self._app.vault, user)
# use an invalid symlink path so the posix list fails
user_vault.write_secret('posix/root_path', '/invalid/root')
data = {"target": "gxfiles://test_user_vault"}
list_response = self.galaxy_interactor.get("remote_files", data)
api_asserts.assert_status_code_is(list_response, 404)
def test_show_error_codes(self):
# Bad role ids are 400.
response = self._get("roles/badroleid")
assert_status_code_is(response, 400)
# Trying to access roles are errors - should probably be 403 not 400 though?
with self._different_user():
different_user_role_id = self.dataset_populator.user_private_role_id(
)
response = self._get(f"roles/{different_user_role_id}")
assert_status_code_is(response, 400)
def test_501_on_download_pdf_when_service_unavailable(self):
configuration = self.dataset_populator.get_configuration()
can_produce_markdown = configuration["markdown_to_pdf_available"]
if can_produce_markdown:
raise SkipTest("Skipping test because server does implement markdown conversion to PDF")
page_request = self._test_page_payload(slug="md-page-to-pdf", content_format="markdown")
page_response = self._post("pages", page_request, json=True)
self._assert_status_code_is(page_response, 200)
page_id = page_response.json()['id']
pdf_response = self._get(f"pages/{page_id}.pdf")
api_asserts.assert_status_code_is(pdf_response, 501)
api_asserts.assert_error_code_is(pdf_response, error_codes.error_codes_by_name["SERVER_NOT_CONFIGURED_FOR_REQUEST"])
def repository_operation(self,
operation,
owner,
name,
changeset,
tool_shed_url='https://toolshed.g2.bx.psu.edu'):
payload = {
'tool_shed_url': tool_shed_url,
'name': name,
'owner': owner,
'changeset_revision': changeset
}
create_response = operation(payload)
assert_status_code_is(create_response, 200)
return create_response.json()
def test_pdf_when_service_available(self):
configuration = self.dataset_populator.get_configuration()
can_produce_markdown = configuration["markdown_to_pdf_available"]
if not can_produce_markdown:
raise SkipTest(
"Skipping test because server does not implement markdown conversion to PDF"
)
page_request = self._test_page_payload(slug="md-page-to-pdf",
content_format="markdown")
page_response = self._post("pages", page_request, json=True)
self._assert_status_code_is(page_response, 200)
page_id = page_response.json()['id']
pdf_response = self._get(f"pages/{page_id}.pdf")
api_asserts.assert_status_code_is(pdf_response, 200)
assert "application/pdf" in pdf_response.headers['content-type']
assert pdf_response.content[0:4] == b"%PDF"
def test_list_and_show(self):
def check_roles_response(response):
assert_status_code_is(response, 200)
as_list = response.json()
assert isinstance(as_list, list)
assert len(as_list) > 0
for role in as_list:
RolesApiTestCase.check_role_dict(role)
user_role_id = self.dataset_populator.user_private_role_id()
with self._different_user():
different_user_role_id = self.dataset_populator.user_private_role_id(
)
admin_roles_response = self._get("roles", admin=True)
user_roles_response = self._get("roles")
check_roles_response(admin_roles_response)
check_roles_response(user_roles_response)
admin_roles_response_ids = [
r["id"] for r in admin_roles_response.json()
]
user_roles_response_ids = [r["id"] for r in user_roles_response.json()]
# User can see their own private role not the other users, admin can see both.
assert user_role_id in user_roles_response_ids
assert different_user_role_id not in user_roles_response_ids
assert user_role_id in admin_roles_response_ids
assert different_user_role_id in admin_roles_response_ids
# Check showing a valid, role.
role_response = self._get(f"roles/{user_role_id}")
assert_status_code_is(role_response, 200)
role = role_response.json()
RolesApiTestCase.check_role_dict(role, assert_id=user_role_id)
def test_create_invalid_params(self):
# In theory these low-level validation test cases could be handled in more
# of a unit test style but it makes sense during the transition from wsgi to
# asgi to have some tests that validate the whole pipeline is being integrated
# properly in terms of exception handling.
# Test missing description
name = self.dataset_populator.get_random_name()
description = "A test role."
payload = {
"name": name,
"user_ids": [self.dataset_populator.user_id()],
}
response = self._post("roles", payload, admin=True, json=True)
assert_status_code_is(response, 400)
assert_error_code_is(
response, error_codes.
error_codes_by_name['USER_REQUEST_MISSING_PARAMETER'].code)
assert "description" in response.json()["err_msg"]
# Test missing name
payload = {
"name": None,
"description": description,
"user_ids": [self.dataset_populator.user_id()],
}
response = self._post("roles", payload, admin=True, json=True)
assert_status_code_is(response, 400)
assert_error_code_is(
response, error_codes.
error_codes_by_name['USER_REQUEST_MISSING_PARAMETER'].code)
assert "name" in response.json()["err_msg"]
# Test invalid type for name
payload = {
"name": ["a test", "name"],
"description": description,
"user_ids": [self.dataset_populator.user_id()],
}
response = self._post("roles", payload, admin=True, json=True)
assert_status_code_is(response, 400)
assert_error_code_is(
response, error_codes.
error_codes_by_name['USER_REQUEST_INVALID_PARAMETER'].code)
assert "name" in response.json()["err_msg"]
assert "validation_errors" in response.json()
def test_create_only_admin(self):
response = self._post("roles", json=True)
assert_status_code_is(response, 403)
response_err = response.json()
assert response_err["err_code"] == 403006
assert "administrator" in response_err["err_msg"]
def entry_points_for_job(self, job_id):
entry_points_response = self._get("entry_points?job_id=%s" % job_id)
api_asserts.assert_status_code_is(entry_points_response, 200)
return entry_points_response.json()
def _assert_status_code_is(self, response, expected_status_code):
assert_status_code_is(response, expected_status_code)
def _assert_access_forbidden_response(self, response):
api_asserts.assert_status_code_is(response, 403)
def test_create_only_admin(self):
response = self._post("roles")
assert_status_code_is(response, 403)
