def setUpClass(cls):
super(TestActionExecutionHistoryWorker, cls).setUpClass()
runners_registrar.register_runner_types()
action_local = ActionAPI(**copy.deepcopy(fixture.ARTIFACTS['actions']['local']))
Action.add_or_update(ActionAPI.to_model(action_local))
action_chain = ActionAPI(**copy.deepcopy(fixture.ARTIFACTS['actions']['chain']))
action_chain.entry_point = fixture.PATH + '/chain.yaml'
Action.add_or_update(ActionAPI.to_model(action_chain))
def setUpClass(cls):
super(TestMistralRunner, cls).setUpClass()
runners_registrar.register_runner_types()
metadata = fixture.ARTIFACTS['metadata']
action_local = ActionAPI(**copy.deepcopy(metadata['actions']['local']))
Action.add_or_update(ActionAPI.to_model(action_local))
action_wkflow = ActionAPI(
**copy.deepcopy(metadata['actions']['workflow-v2']))
Action.add_or_update(ActionAPI.to_model(action_wkflow))
def setUpClass(cls):
super(TestActionExecutionHistoryWorker, cls).setUpClass()
runners_registrar.register_runners()
action_local = ActionAPI(
**copy.deepcopy(fixture.ARTIFACTS["actions"]["local"]))
Action.add_or_update(ActionAPI.to_model(action_local))
action_chain = ActionAPI(
**copy.deepcopy(fixture.ARTIFACTS["actions"]["chain"]))
action_chain.entry_point = fixture.PATH + "/chain.yaml"
Action.add_or_update(ActionAPI.to_model(action_chain))
def setUpClass(cls):
super(DSLTransformTestCase, cls).setUpClass()
runners_registrar.register_runner_types()
action_local = ActionAPI(**copy.deepcopy(FIXTURES['actions']['local.yaml']))
Action.add_or_update(ActionAPI.to_model(action_local))
for action_name in ['action1', 'action2', 'action3']:
metadata = copy.deepcopy(FIXTURES['actions']['local.yaml'])
metadata['name'] = action_name
metadata['pack'] = 'demo'
action = ActionAPI(**metadata)
Action.add_or_update(ActionAPI.to_model(action))
def setUpClass(cls):
super(MistralRunnerTest, cls).setUpClass()
runners_registrar.register_runner_types()
for _, fixture in six.iteritems(FIXTURES['actions']):
instance = ActionAPI(**fixture)
Action.add_or_update(ActionAPI.to_model(instance))
def get_all(self,
sort=None,
offset=0,
limit=None,
requester_user=None,
**raw_filters):
"""
List all actions.
Handles requests:
GET /actions/views/overview
"""
resp = super(OverviewController,
self)._get_all(sort=sort,
offset=offset,
limit=limit,
raw_filters=raw_filters)
result = []
for item in resp.json:
action_api = ActionAPI(**item)
result.append(
self._transform_action_api(action_api=action_api,
requester_user=requester_user))
resp.json = result
return resp
def test_validate_runner_type_happy_case(self):
action_api_dict = fixture.ARTIFACTS['actions']['local']
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
except:
self.fail('Exception validating action: %s' % json.dumps(action_api_dict))
def _register_action(self, pack, action):
content = self._meta_loader.load(action)
pack_field = content.get('pack', None)
if not pack_field:
content['pack'] = pack
pack_field = pack
if pack_field != pack:
raise Exception('Model is in pack "%s" but field "pack" is different: %s' %
(pack, pack_field))
action_api = ActionAPI(**content)
action_api.validate()
action_validator.validate_action(action_api)
model = ActionAPI.to_model(action_api)
action_ref = ResourceReference.to_string_reference(pack=pack, name=str(content['name']))
existing = action_utils.get_action_by_ref(action_ref)
if not existing:
LOG.debug('Action %s not found. Creating new one with: %s', action_ref, content)
else:
LOG.debug('Action %s found. Will be updated from: %s to: %s',
action_ref, existing, model)
model.id = existing.id
try:
model = Action.add_or_update(model)
extra = {'action_db': model}
LOG.audit('Action updated. Action %s from %s.', model, action, extra=extra)
except Exception:
LOG.exception('Failed to write action to db %s.', model.name)
raise
def setUpClass(cls):
super(ExecutionCancellationTestCase, cls).setUpClass()
for _, fixture in six.iteritems(FIXTURES['actions']):
instance = ActionAPI(**fixture)
Action.add_or_update(ActionAPI.to_model(instance))
runners_registrar.register_runners()
def setUpClass(cls):
super(TestActionExecutionService, cls).setUpClass()
cls.runner = RunnerTypeAPI(**RUNNER)
cls.runnerdb = RunnerType.add_or_update(
RunnerTypeAPI.to_model(cls.runner))
cls.action = ActionAPI(**ACTION)
cls.actiondb = Action.add_or_update(ActionAPI.to_model(cls.action))
def get_all(
self,
exclude_attributes=None,
include_attributes=None,
sort=None,
offset=0,
limit=None,
requester_user=None,
**raw_filters,
):
"""
List all actions.
Handles requests:
GET /actions/views/overview
"""
resp = super(OverviewController, self)._get_all(
exclude_fields=exclude_attributes,
include_fields=include_attributes,
sort=sort,
offset=offset,
limit=limit,
raw_filters=raw_filters,
requester_user=requester_user,
)
runner_type_names = set([])
action_ids = []
result = []
for item in resp.json:
action_api = ActionAPI(**item)
result.append(action_api)
runner_type_names.add(action_api.runner_type)
action_ids.append(str(action_api.id))
# Add combined runner and action parameters to the compound result object
# NOTE: This approach results in 2 additional queries while previous one resulted in
# N * 2 additional queries
# 1. Retrieve all the respective runner objects - we only need parameters
runner_type_dbs = RunnerType.query(
name__in=runner_type_names,
only_fields=["name", "runner_parameters"])
runner_type_dbs = dict([(runner_db.name, runner_db)
for runner_db in runner_type_dbs])
# 2. Retrieve all the respective action objects - we only need parameters
action_dbs = dict([(action_db.id, action_db) for action_db in result])
for action_api in result:
action_db = action_dbs.get(action_api.id, None)
runner_db = runner_type_dbs.get(action_api.runner_type, None)
all_params = action_param_utils.get_params_view(
action_db=action_db, runner_db=runner_db, merged_only=True)
action_api.parameters = all_params
resp.json = result
return resp
def setUpClass(cls):
super(TestStreamController, cls).setUpClass()
instance = RunnerTypeAPI(**RUNNER_TYPE_1)
RunnerType.add_or_update(RunnerTypeAPI.to_model(instance))
instance = ActionAPI(**ACTION_1)
Action.add_or_update(ActionAPI.to_model(instance))
def test_validate_runner_type_invalid_runner(self):
action_api_dict = fixture.ARTIFACTS['actions']['action-with-invalid-runner']
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
self.fail('Action validation should not have passed. %s' % json.dumps(action_api_dict))
except ValueValidationException:
pass
def test_validate_override_immutable_runner_param(self):
action_api_dict = fixture.ARTIFACTS['actions']['local-override-runner-immutable']
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
self.fail('Action validation should not have passed. %s' % json.dumps(action_api_dict))
except ValueValidationException as e:
self.assertTrue('Cannot override in action.' in e.message)
def test_validate_action_param_immutable(self):
action_api_dict = fixture.ARTIFACTS['actions']['action-immutable-param-no-default']
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
self.fail('Action validation should not have passed. %s' % json.dumps(action_api_dict))
except ValueValidationException as e:
self.assertTrue('requires a default value.' in e.message)
def setUpClass(cls):
super(ActionParamsUtilsTest, cls).setUpClass()
cls.runnertype = RunnerTypeAPI(
**FIXTURES['runners']['testrunner1.yaml'])
cls.runnertype_db = RunnerType.add_or_update(
RunnerTypeAPI.to_model(cls.runnertype))
cls.action = ActionAPI(**FIXTURES['actions']['action1.yaml'])
cls.action_db = Action.add_or_update(ActionAPI.to_model(cls.action))
def setUpClass(cls):
super(TestActionExecutionService, cls).setUpClass()
cls.runner = RunnerTypeAPI(**RUNNER)
cls.runnerdb = RunnerType.add_or_update(
RunnerTypeAPI.to_model(cls.runner))
runner_api = RunnerTypeAPI(**RUNNER_ACTION_CHAIN)
RunnerType.add_or_update(RunnerTypeAPI.to_model(runner_api))
cls.actions = {
ACTION['name']:
ActionAPI(**ACTION),
ACTION_WORKFLOW['name']:
ActionAPI(**ACTION_WORKFLOW),
ACTION_OVR_PARAM['name']:
ActionAPI(**ACTION_OVR_PARAM),
ACTION_OVR_PARAM_MUTABLE['name']:
ActionAPI(**ACTION_OVR_PARAM_MUTABLE),
ACTION_OVR_PARAM_IMMUTABLE['name']:
ActionAPI(**ACTION_OVR_PARAM_IMMUTABLE),
ACTION_OVR_PARAM_BAD_ATTR['name']:
ActionAPI(**ACTION_OVR_PARAM_BAD_ATTR),
ACTION_OVR_PARAM_BAD_ATTR_NOOP['name']:
ActionAPI(**ACTION_OVR_PARAM_BAD_ATTR_NOOP)
}
cls.actiondbs = {
name: Action.add_or_update(ActionAPI.to_model(action))
for name, action in six.iteritems(cls.actions)
}
cls.container = RunnerContainer()
def _register_action(self, pack, action):
content = self._meta_loader.load(action)
pack_field = content.get('pack', None)
if not pack_field:
content['pack'] = pack
pack_field = pack
if pack_field != pack:
raise Exception(
'Model is in pack "%s" but field "pack" is different: %s' %
(pack, pack_field))
action_api = ActionAPI(**content)
try:
action_api.validate()
except jsonschema.ValidationError as e:
# We throw a more user-friendly exception on invalid parameter name
msg = str(e)
is_invalid_parameter_name = 'Additional properties are not allowed' in msg
is_invalid_parameter_name &= 'in schema[\'properties\'][\'parameters\']' in msg
if is_invalid_parameter_name:
parameter_name = re.search('\'(.+?)\' was unexpected',
msg).groups()[0]
new_msg = (
'Parameter name "%s" is invalid. Valid characters for parameter name '
'are [a-zA-Z0-0_].' % (parameter_name))
new_msg += '\n\n' + msg
raise jsonschema.ValidationError(new_msg)
raise e
action_validator.validate_action(action_api)
model = ActionAPI.to_model(action_api)
action_ref = ResourceReference.to_string_reference(
pack=pack, name=str(content['name']))
existing = action_utils.get_action_by_ref(action_ref)
if not existing:
LOG.debug('Action %s not found. Creating new one with: %s',
action_ref, content)
else:
LOG.debug('Action %s found. Will be updated from: %s to: %s',
action_ref, existing, model)
model.id = existing.id
try:
model = Action.add_or_update(model)
extra = {'action_db': model}
LOG.audit('Action updated. Action %s from %s.',
model,
action,
extra=extra)
except Exception:
LOG.exception('Failed to write action to db %s.', model.name)
raise
def test_validate_action_param_immutable(self):
action_api_dict = fixture.ARTIFACTS["actions"][
"action-immutable-param-no-default"]
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
self.fail("Action validation should not have passed. %s" %
json.dumps(action_api_dict))
except ValueValidationException as e:
self.assertIn("requires a default value.", six.text_type(e))
def setUpClass(cls):
super(SchedulerTest, cls).setUpClass()
for _, fixture in six.iteritems(FIXTURES['runners']):
instance = RunnerTypeAPI(**fixture)
RunnerType.add_or_update(RunnerTypeAPI.to_model(instance))
for _, fixture in six.iteritems(FIXTURES['actions']):
instance = ActionAPI(**fixture)
Action.add_or_update(ActionAPI.to_model(instance))
def test_validate_override_immutable_runner_param(self):
action_api_dict = fixture.ARTIFACTS["actions"][
"remote-override-runner-immutable"]
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
self.fail("Action validation should not have passed. %s" %
json.dumps(action_api_dict))
except ValueValidationException as e:
self.assertIn("Cannot override in action.", six.text_type(e))
def setUpClass(cls):
super(DSLTransformTestCase, cls).setUpClass()
runners_registrar.register_runner_types()
for _, fixture in six.iteritems(FIXTURES['runners']):
instance = RunnerTypeAPI(**fixture)
RunnerType.add_or_update(RunnerTypeAPI.to_model(instance))
for _, fixture in six.iteritems(FIXTURES['actions']):
instance = ActionAPI(**fixture)
Action.add_or_update(ActionAPI.to_model(instance))
def test_validate_action_param_position_values_unique(self):
action_api_dict = fixture.ARTIFACTS["actions"][
"action-with-non-unique-positions"]
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
self.fail("Action validation should have failed " +
"because position values are not unique." %
json.dumps(action_api_dict))
except ValueValidationException as e:
self.assertIn("have same position", six.text_type(e))
def setUpClass(cls):
super(MistralValidationTest, cls).setUpClass()
for _, fixture in six.iteritems(FIXTURES['runners']):
instance = RunnerTypeAPI(**fixture)
RunnerType.add_or_update(RunnerTypeAPI.to_model(instance))
for _, fixture in six.iteritems(FIXTURES['actions']):
instance = ActionAPI(**fixture)
Action.add_or_update(ActionAPI.to_model(instance))
cls.validator = wf_validation_utils.get_validator()
def test_validate_action_param_position_values_unique(self):
action_api_dict = fixture.ARTIFACTS['actions'][
'action-with-non-unique-positions']
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
self.fail('Action validation should have failed ' +
'because position values are not unique.' %
json.dumps(action_api_dict))
except ValueValidationException as e:
self.assertTrue('have same position' in e.message)
def get_one(self, ref_or_id):
"""
List action by id.
Handle:
GET /actions/views/overview/1
"""
resp = super(OverviewController, self)._get_one(ref_or_id)
action_api = ActionAPI(**resp.json)
result = self._transform_action_api(action_api)
resp.json = result
return resp
def test_validate_action_param_position_values_contiguous(self):
action_api_dict = fixture.ARTIFACTS['actions'][
'action-with-non-contiguous-positions']
action_api = ActionAPI(**action_api_dict)
try:
action_validator.validate_action(action_api)
self.fail('Action validation should have failed ' +
'because position values are not contiguous.' %
json.dumps(action_api_dict))
except ValueValidationException as e:
self.assertIn('are not contiguous', six.text_type(e))
def test_validate_action_param_immutable_no_default(self):
action_api_dict = fixture.ARTIFACTS['actions'][
'action-immutable-runner-param-no-default']
action_api = ActionAPI(**action_api_dict)
# Runner param sudo is decalred immutable in action but no defualt value
# supplied in action. We should pick up default value from runner.
try:
action_validator.validate_action(action_api)
except ValueValidationException as e:
print(e)
self.fail('Action validation should have passed. %s' %
json.dumps(action_api_dict))
def get_all(self, **kwargs):
"""
List all actions.
Handles requests:
GET /actions/views/overview
"""
resp = super(OverviewController, self)._get_all(**kwargs)
result = []
for item in resp.json:
action_api = ActionAPI(**item)
result.append(self._transform_action_api(action_api))
resp.json = result
return resp
def get_one(self, ref_or_id, requester_user):
"""
List action by id.
Handle:
GET /actions/views/overview/1
"""
resp = super(OverviewController,
self)._get_one(ref_or_id,
requester_user=requester_user,
permission_type=PermissionType.ACTION_VIEW)
action_api = ActionAPI(**resp.json)
result = self._transform_action_api(action_api)
resp.json = result
return resp
