def get_workflow_registry_by_name(registry_name) -> models.WorkflowRegistry:
try:
r = models.WorkflowRegistry.find_by_name(registry_name)
if not r:
raise lm_exceptions.EntityNotFoundException(models.WorkflowRegistry, registry_name)
return r
except Exception:
raise lm_exceptions.EntityNotFoundException(models.WorkflowRegistry, registry_name)
def _find_and_check_workflow_version(cls, user: User, uuid, version=None):
w = None
if not version:
_w = models.Workflow.get_user_workflow(user, uuid)
if _w:
w = _w.latest_version
else:
w = models.WorkflowVersion.get_user_workflow_version(user, uuid, version)
if not w:
w = cls._find_and_check_shared_workflow_version(user, uuid, version=version)
if w is None:
raise lm_exceptions.EntityNotFoundException(models.WorkflowVersion, f"{uuid}_{version}")
# Check whether the user can access the workflow.
# As a general rule, we grant user access to the workflow
# 1. if the user belongs to the owners group
# 2. or the user belongs to the viewers group
# if user not in w.owners and user not in w.viewers:
if not user.has_permission(w):
# if the user is not the submitter
# and the workflow is associated with a registry
# then we try to check whether the user is allowed to view the workflow
if w.workflow_registry is None or w.workflow not in w.workflow_registry.get_user_workflows(user):
raise lm_exceptions.NotAuthorizedException(f"User {user.username} is not allowed to access workflow")
return w
def find_by_uri(cls, uri):
try:
return cls.query.filter(WorkflowRegistry.uri == uri).one()
except Exception as e:
raise lm_exceptions.EntityNotFoundException(WorkflowRegistry,
entity_id=uri,
exception=e)
def update_workflow_registry(
uuid,
name=None,
client_id=None,
client_secret=None,
client_auth_method=None,
api_base_url=None,
redirect_uris=None) -> models.WorkflowRegistry:
try:
registry = models.WorkflowRegistry.find_by_uuid(uuid)
if not registry:
raise lm_exceptions.EntityNotFoundException(
models.WorkflowRegistry, entity_id=uuid)
if name:
registry.set_name(name)
if api_base_url is not None:
registry.set_uri(api_base_url)
registry.update_client(client_id=client_id,
client_secret=client_secret,
redirect_uris=redirect_uris,
client_auth_method=client_auth_method)
registry.save()
logger.info(f"WorkflowRegistry '{uuid}' (name: {name})' updated!")
return registry
except providers.OAuth2ProviderNotSupportedException as e:
raise lm_exceptions.WorkflowRegistryNotSupportedException(
exception=e)
def find_by_name(cls, name):
try:
return cls.query.filter(WorkflowRegistry.name == name).one()
except Exception as e:
raise lm_exceptions.EntityNotFoundException(WorkflowRegistry,
entity_id=name,
exception=e)
def add_workflow_registry(type, name,
client_id, client_secret, client_auth_method="client_secret_post",
api_base_url=None, redirect_uris=None) -> models.WorkflowRegistry:
try:
# At the moment client_credentials of registries
# are associated with the admin account
user = User.find_by_username("admin")
if not user:
raise lm_exceptions.EntityNotFoundException(User, entity_id="admin")
server_credentials = providers.new_instance(provider_type=type,
name=name,
client_id=client_id,
client_secret=client_secret,
api_base_url=api_base_url)
client_credentials = \
server.create_client(user, name, server_credentials.api_base_url,
['client_credentials', 'authorization_code', 'refresh_token'],
["code", "token"],
"read write",
redirect_uris.split(',')
if isinstance(redirect_uris, str)
else redirect_uris,
client_auth_method, commit=False)
registry = models.WorkflowRegistry.new_instance(type, client_credentials, server_credentials)
registry.save()
logger.debug(f"WorkflowRegistry '{name}' (type: {type})' created: {registry}")
return registry
except providers.OAuth2ProviderNotSupportedException as e:
raise lm_exceptions.WorkflowRegistryNotSupportedException(exception=e)
def deregister_registry_workflow(workflow_uuid, workflow_version,
registry: models.WorkflowRegistry):
workflow = registry.get_workflow(workflow_uuid)
if not workflow:
raise lm_exceptions.EntityNotFoundException(
models.WorkflowVersion, (workflow_uuid, workflow_version))
logger.debug("WorkflowVersion to delete: %r", workflow)
try:
workflow_version = workflow.versions[workflow_version]
workflow.delete()
logger.debug("Deleted workflow wf_uuid: %r - version: %r",
workflow_uuid, workflow_version)
return workflow_uuid, workflow_version
except KeyError:
raise lm_exceptions.EntityNotFoundException(
models.WorkflowVersion, (workflow_uuid, workflow_version))
def get_users(self) -> List[auth_models.User]:
try:
return [
i.user for i in OAuthIdentity.query.filter(
OAuthIdentity.provider == self.server_credentials).all()
]
except Exception as e:
raise lm_exceptions.EntityNotFoundException(e)
def deregister_test_suite(test_suite: Union[models.TestSuite, str]) -> str:
suite = test_suite
if not isinstance(test_suite, models.TestSuite):
suite = models.TestSuite.find_by_uuid(test_suite)
if not suite:
raise lm_exceptions.EntityNotFoundException(models.TestSuite, test_suite)
suite.delete()
logger.debug("Deleted TestSuite: %r", suite.uuid)
return suite.uuid
def get_registry_workflow_version(registry: models.WorkflowRegistry,
uuid,
version=None) -> models.WorkflowVersion:
w = registry.get_workflow(uuid)
if w is None:
raise lm_exceptions.EntityNotFoundException(
models.WorkflowVersion, f"{uuid}_{version}")
return w.latest_version if version is None or version == "latest" else w.versions[
version]
def deregister_user_workflow(cls, workflow_uuid, workflow_version, user: User):
workflow = cls._find_and_check_workflow_version(user, workflow_uuid, workflow_version)
logger.debug("WorkflowVersion to delete: %r", workflow)
if not workflow:
raise lm_exceptions.EntityNotFoundException(models.WorkflowVersion, (workflow_uuid, workflow_version))
if workflow.submitter != user:
raise lm_exceptions.NotAuthorizedException("Only the workflow submitter can delete the workflow")
workflow.delete()
logger.debug("Deleted workflow wf_uuid: %r - version: %r", workflow_uuid, workflow_version)
return workflow_uuid, workflow_version
def deregister_test_instance(test_instance: Union[models.TestInstance,
str]):
instance = test_instance
if not isinstance(instance, models.TestInstance):
instance = models.TestSuite.find_by_uuid(instance)
if not instance:
raise lm_exceptions.EntityNotFoundException(
models.TestInstance, test_instance)
instance.delete()
return instance.uuid
def register_test_suite(workflow_uuid, workflow_version,
submitter: models.User, test_suite_metadata) -> models.TestSuite:
workflow = models.WorkflowVersion.get_user_workflow_version(submitter, workflow_uuid, workflow_version)
if not workflow:
raise lm_exceptions.EntityNotFoundException(models.WorkflowVersion, (workflow_uuid, workflow_version))
# For now only the workflow submitter can add test suites
if workflow.submitter != submitter:
raise lm_exceptions.NotAuthorizedException("Only the workflow submitter can add test suites")
suite = workflow.add_test_suite(submitter, test_suite_metadata)
suite.save()
return suite
def test_get_instance_build_by_user_error_not_found(m, request_context, mock_user):
assert not auth.current_user.is_anonymous, "Unexpected user in session"
assert auth.current_registry is not None, "Unexpected registry in session"
instance = MagicMock()
instance.get_test_build.side_effect = \
lm_exceptions.EntityNotFoundException(models.TestBuild)
m.get_test_instance.return_value = instance
response = controllers.instances_builds_get_by_id('111', '12345')
logger.debug("Response: %r", response)
m.get_test_instance.assert_called_once()
assert isinstance(response, Response), "Unexpected response type"
assert_status_code(404, response.status_code)
def test_post_workflow_by_user_error_invalid_registry_uri(m, request_context, mock_user):
assert not auth.current_user.is_anonymous, "Unexpected user in session"
assert auth.current_user == mock_user, "Unexpected user in session"
assert not auth.current_registry, "Unexpected registry in session"
# add one fake workflow
data = {"registry": "123456"}
m.get_workflow_registry_by_generic_reference.side_effect = lm_exceptions.EntityNotFoundException(models.WorkflowRegistry)
response = controllers.workflows_post(body=data)
m.get_workflow_registry_by_generic_reference.assert_called_once_with(data["registry"]), \
"get_workflow_registry_by_uri should be used"
logger.debug("Response: %r, %r", response, str(response.data))
assert response.status_code == 404, "Unexpected Workflow registry"
def get_test_build(self, test_instance: models.TestInstance,
build_number: int) -> JenkinsTestBuild:
try:
build_metadata = self.server.get_build_info(
self.get_job_name(test_instance.resource), int(build_number))
return JenkinsTestBuild(self, test_instance, build_metadata)
except jenkins.NotFoundException as e:
raise lm_exceptions.EntityNotFoundException(models.TestBuild,
entity_id=build_number,
detail=str(e))
except jenkins.JenkinsException as e:
raise lm_exceptions.TestingServiceException(e)
def test_get_instance_build_by_registry_error_not_found(m, request_context, mock_registry):
assert auth.current_user.is_anonymous, "Unexpected user in session"
assert auth.current_registry, "Unexpected registry in session"
build = MagicMock()
build.id = "1"
workflow = {'uuid': '11111'}
instance = MagicMock()
instance.uuid = '12345'
instance.get_test_build = Mock(side_effect=lm_exceptions.EntityNotFoundException(models.TestBuild))
instance.test_suite.workflow = workflow
m.get_test_instance.return_value = instance
mock_registry.registered_workflow_versions = [workflow]
response = controllers.instances_builds_get_by_id(instance['uuid'], '2222')
m.get_test_instance.assert_called_once()
assert isinstance(response, Response), "Unexpected response type"
assert_status_code(404, response.status_code)
def test_get_workflow_by_id_error_not_found(m, request_context, mock_registry):
assert auth.current_user.is_anonymous, "Unexpected user in session"
assert auth.current_registry, "Unexpected registry in session"
m.get_registry_workflow_version.side_effect = lm_exceptions.EntityNotFoundException(models.WorkflowVersion)
response = controllers.workflows_get_by_id(wf_uuid="12345", wf_version="1")
logger.debug("Response: %r", response)
assert_status_code(response.status_code, 404)
assert messages.workflow_not_found\
.format("12345", "1") in response.data.decode()
# test when the service return None
m.get_registry_workflow_version.return_value = None
response = controllers.workflows_get_by_id(wf_uuid="12345", wf_version="1")
logger.debug("Response: %r", response)
assert_status_code(response.status_code, 404)
assert messages.workflow_not_found\
.format("12345", "1") in response.data.decode()
def register_test_instance(test_suite: Union[models.TestSuite,
str], submitter: User,
managed: bool, test_name, testing_service_type,
testing_service_url, testing_service_resource):
suite = test_suite
if not isinstance(test_suite, models.TestSuite):
suite = models.TestSuite.find_by_uuid(test_suite)
if not suite:
raise lm_exceptions.EntityNotFoundException(
models.TestSuite, test_suite)
test_instance = suite.add_test_instance(submitter, managed, test_name,
testing_service_type,
testing_service_url,
testing_service_resource)
test_instance.save()
return test_instance
