def setUpClass(cls):
super(TestTimersHolder, cls).setUpClass()
loader = FixturesLoader()
TestTimersHolder.MODELS = loader.load_fixtures(
fixtures_pack=PACK, fixtures_dict=FIXTURES)['triggers']
loader.save_fixtures_to_db(fixtures_pack=PACK, fixtures_dict=FIXTURES)
def test_create_or_update_trigger_db_simple_triggers(self):
test_fixtures = {
'triggertypes': ['triggertype1.yaml']
}
loader = FixturesLoader()
fixtures = loader.save_fixtures_to_db(fixtures_pack='generic', fixtures_dict=test_fixtures)
triggertypes = fixtures['triggertypes']
trigger_type_ref = ResourceReference.to_string_reference(
name=triggertypes['triggertype1.yaml']['name'],
pack=triggertypes['triggertype1.yaml']['pack'])
trigger = {
'name': triggertypes['triggertype1.yaml']['name'],
'pack': triggertypes['triggertype1.yaml']['pack'],
'type': trigger_type_ref
}
trigger_service.create_or_update_trigger_db(trigger)
triggers = Trigger.get_all()
self.assertTrue(len(triggers) == 1, 'Only one trigger should be created.')
self.assertTrue(triggers[0]['name'] == triggertypes['triggertype1.yaml']['name'])
# Try adding duplicate
trigger_service.create_or_update_trigger_db(trigger)
triggers = Trigger.get_all()
self.assertTrue(len(triggers) == 1, 'Only one trigger should be present.')
self.assertTrue(triggers[0]['name'] == triggertypes['triggertype1.yaml']['name'])
def setUpClass(cls):
EventletTestCase.setUpClass()
DbTestCase.setUpClass()
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
def test_exception_thrown_when_rule_creation_no_trigger_yes_triggertype(self):
test_fixtures = {
'triggertypes': ['triggertype1.yaml']
}
loader = FixturesLoader()
fixtures = loader.save_fixtures_to_db(fixtures_pack='generic', fixtures_dict=test_fixtures)
triggertypes = fixtures['triggertypes']
trigger_type_ref = ResourceReference.to_string_reference(
name=triggertypes['triggertype1.yaml']['name'],
pack=triggertypes['triggertype1.yaml']['pack'])
rule = {
'name': 'fancyrule',
'trigger': {
'type': trigger_type_ref
},
'criteria': {
},
'action': {
'ref': 'core.local',
'parameters': {
'cmd': 'date'
}
}
}
rule_api = RuleAPI(**rule)
self.assertRaises(TriggerDoesNotExistException,
trigger_service.create_trigger_db_from_rule, rule_api)
def setUpClass(cls):
super(BackstopRuleMatcherTestCase, cls).setUpClass()
fixturesloader = FixturesLoader()
# Create TriggerTypes before creation of Rule to avoid failure. Rule requires the
# Trigger and therefore TriggerType to be created prior to rule creation.
cls.models = fixturesloader.save_fixtures_to_db(
fixtures_pack=PACK, fixtures_dict=FIXTURES_TRIGGERS)
cls.models.update(fixturesloader.save_fixtures_to_db(
fixtures_pack=PACK, fixtures_dict=FIXTURES_RULES))
def setUpClass(cls):
EventletTestCase.setUpClass()
DbTestCase.setUpClass()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
def setUp(self):
super(SchedulerPoliciesTest, self).setUp()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
models = loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES_2)
# Policy with "post_run" application
self.policy_db = models['policies']['policy_1.yaml']
def setUpClass(cls):
ExecutionDbTestCase.setUpClass()
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
def setUp(self):
super(NotifierPoliciesTestCase, self).setUp()
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
models = loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES_1)
# Policy with "post_run" application
self.policy_db = models['policies']['policy_4.yaml']
def setUpClass(cls):
EventletTestCase.setUpClass()
DbTestCase.setUpClass()
# Override the coordinator to use the noop driver otherwise the tests will be blocked.
tests_config.parse_args(coordinator_noop=True)
coordination.COORDINATOR = None
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
def test_create_trigger_db_from_rule_duplicate(self):
test_fixtures = {
'rules': ['cron_timer_rule_1.yaml', 'cron_timer_rule_2.yaml']
}
loader = FixturesLoader()
fixtures = loader.load_fixtures(fixtures_pack='generic', fixtures_dict=test_fixtures)
rules = fixtures['rules']
trigger_db_ret_1 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules['cron_timer_rule_1.yaml']))
self.assertTrue(trigger_db_ret_1 is not None)
trigger_db_ret_2 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules['cron_timer_rule_2.yaml']))
self.assertTrue(trigger_db_ret_2 is not None)
self.assertEqual(trigger_db_ret_1, trigger_db_ret_2, 'Should reuse same trigger.')
trigger_db = Trigger.get_by_id(trigger_db_ret_1.id)
self.assertDictEqual(trigger_db.parameters,
rules['cron_timer_rule_1.yaml']['trigger']['parameters'])
def setUp(self):
super(RetryPolicyTestCase, self).setUp()
# Register common policy types
register_policy_types(st2actions)
loader = FixturesLoader()
models = loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
# Instantiate policy applicator we will use in the tests
policy_db = models['policies']['policy_4.yaml']
retry_on = policy_db.parameters['retry_on']
max_retry_count = policy_db.parameters['max_retry_count']
self.policy = ExecutionRetryPolicyApplicator(policy_ref='test_policy',
policy_type='action.retry',
retry_on=retry_on,
max_retry_count=max_retry_count,
delay=0)
def setUpClass(cls):
super(TraceInjectionTests, cls).setUpClass()
cls.models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_MODELS)
cls.traceable_liveaction = cls.models['liveactions'][
'traceable_liveaction.yaml']
cls.traceable_execution = cls.models['executions'][
'traceable_execution.yaml']
cls.action = cls.models['actions']['chain1.yaml']
def setUpClass(cls):
super(TestApiKeyController, cls).setUpClass()
cfg.CONF.set_override(name='mask_secrets', override=True, group='api')
cfg.CONF.set_override(name='mask_secrets', override=True, group='log')
models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_MODELS)
cls.apikey1 = models['apikeys']['apikey1.yaml']
cls.apikey2 = models['apikeys']['apikey2.yaml']
cls.apikey3 = models['apikeys']['apikey3.yaml']
def setUp(self):
super(RetryPolicyTestCase, self).setUp()
# Register common policy types
register_policy_types(st2actions)
loader = FixturesLoader()
models = loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
# Instantiate policy applicator we will use in the tests
policy_db = models['policies']['policy_4.yaml']
retry_on = policy_db.parameters['retry_on']
max_retry_count = policy_db.parameters['max_retry_count']
self.policy = ExecutionRetryPolicyApplicator(
policy_ref='test_policy',
policy_type='action.retry',
retry_on=retry_on,
max_retry_count=max_retry_count,
delay=0)
def test_matching_trigger_from_file(self):
FixturesLoader().save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=TEST_MODELS_ACTIONS)
rule_file_path = os.path.join(BASE_PATH, '../fixtures/rule.yaml')
trigger_instance_file_path = os.path.join(
BASE_PATH, '../fixtures/trigger_instance_1.yaml')
tester = RuleTester(
rule_file_path=rule_file_path,
trigger_instance_file_path=trigger_instance_file_path)
matching = tester.evaluate()
self.assertTrue(matching)
class RunnerTypesControllerRBACTestCase(APIControllerWithRBACTestCase):
fixtures_loader = FixturesLoader()
def setUp(self):
super(RunnerTypesControllerRBACTestCase, self).setUp()
self.fixtures_loader.save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=TEST_FIXTURES)
def test_get_all_and_get_one_no_permissions(self):
# get all
user_db = self.users['no_permissions']
self.use_user(user_db)
resp = self.app.get('/v1/runnertypes', expect_errors=True)
expected_msg = (
'User "no_permissions" doesn\'t have required permission '
'"runner_type_list"')
self.assertEqual(resp.status_code, http_client.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
# get one
resp = self.app.get('/v1/runnertypes/test-runner-1',
expect_errors=True)
expected_msg = (
'User "no_permissions" doesn\'t have required permission '
'"runner_type_view" on resource "runner_type:test-runner-1"')
self.assertEqual(resp.status_code, http_client.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def test_put_disable_runner_no_permissions(self):
user_db = self.users['admin']
self.use_user(user_db)
runnertype_id = 'test-runner-1'
resp = self.app.get('/v1/runnertypes/%s' % runnertype_id)
# Disable the runner
user_db = self.users['no_permissions']
self.use_user(user_db)
update_input = resp.json
update_input['enabled'] = False
resp = self.__do_put(runnertype_id, update_input)
expected_msg = (
'User "no_permissions" doesn\'t have required permission '
'"runner_type_modify" on resource "runner_type:test-runner-1"')
self.assertEqual(resp.status_code, http_client.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def __do_put(self, runner_type_id, runner_type):
return self.app.put_json('/v1/runnertypes/%s' % runner_type_id,
runner_type,
expect_errors=True)
def setUpClass(cls):
super(AliasExecutionTestCase, cls).setUpClass()
cls.models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_MODELS)
cls.runner1 = cls.models['runners']['runner1.yaml']
cls.action1 = cls.models['actions']['action1.yaml']
cls.alias1 = cls.models['aliases']['alias1.yaml']
cls.alias2 = cls.models['aliases']['alias2.yaml']
cls.alias4 = cls.models['aliases']['alias4.yaml']
cls.alias_with_undefined_jinja_in_ack_format = \
cls.models['aliases']['alias_with_undefined_jinja_in_ack_format.yaml']
def test_create_trigger_db_from_rule(self):
test_fixtures = {
'rules': ['cron_timer_rule_1.yaml', 'cron_timer_rule_3.yaml']
}
loader = FixturesLoader()
fixtures = loader.load_fixtures(fixtures_pack='generic',
fixtures_dict=test_fixtures)
rules = fixtures['rules']
trigger_db_ret_1 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules['cron_timer_rule_1.yaml']))
self.assertIsNotNone(trigger_db_ret_1)
trigger_db = Trigger.get_by_id(trigger_db_ret_1.id)
self.assertDictEqual(
trigger_db.parameters,
rules['cron_timer_rule_1.yaml']['trigger']['parameters'])
trigger_db_ret_2 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules['cron_timer_rule_3.yaml']))
self.assertIsNotNone(trigger_db_ret_2)
self.assertTrue(trigger_db_ret_2.id != trigger_db_ret_1.id)
def test_create_trigger_db_from_rule_duplicate(self):
test_fixtures = {
'rules': ['cron_timer_rule_1.json', 'cron_timer_rule_2.json']
}
loader = FixturesLoader()
fixtures = loader.load_fixtures(fixtures_pack='generic',
fixtures_dict=test_fixtures)
rules = fixtures['rules']
trigger_db_ret_1 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules['cron_timer_rule_1.json']))
self.assertTrue(trigger_db_ret_1 is not None)
trigger_db_ret_2 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules['cron_timer_rule_2.json']))
self.assertTrue(trigger_db_ret_2 is not None)
self.assertEqual(trigger_db_ret_1, trigger_db_ret_2,
'Should reuse same trigger.')
trigger_db = Trigger.get_by_id(trigger_db_ret_1.id)
self.assertDictEqual(
trigger_db.parameters,
rules['cron_timer_rule_1.json']['trigger']['parameters'])
def setUpClass(cls):
super(TestApiKeyController, cls).setUpClass()
cfg.CONF.set_override(name="mask_secrets", override=True, group="api")
cfg.CONF.set_override(name="mask_secrets", override=True, group="log")
models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_MODELS)
cls.apikey1 = models["apikeys"]["apikey1.yaml"]
cls.apikey2 = models["apikeys"]["apikey2.yaml"]
cls.apikey3 = models["apikeys"]["apikey3.yaml"]
cls.apikey4 = models["apikeys"]["apikey_disabled.yaml"]
cls.apikey5 = models["apikeys"]["apikey_malformed.yaml"]
def setUpClass(cls):
super(ActionAliasControllerTestCase, cls).setUpClass()
cls.models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_MODELS
)
cls.alias1 = cls.models["aliases"]["alias1.yaml"]
cls.alias2 = cls.models["aliases"]["alias2.yaml"]
loaded_models = FixturesLoader().load_models(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_LOAD_MODELS
)
cls.alias3 = loaded_models["aliases"]["alias3.yaml"]
FixturesLoader().save_fixtures_to_db(
fixtures_pack=GENERIC_FIXTURES_PACK,
fixtures_dict={"aliases": ["alias7.yaml"]},
)
loaded_models = FixturesLoader().load_models(
fixtures_pack=GENERIC_FIXTURES_PACK, fixtures_dict=TEST_LOAD_MODELS_GENERIC
)
cls.alias3_generic = loaded_models["aliases"]["alias3.yaml"]
def test_create_trigger_db_from_rule_duplicate(self):
test_fixtures = {
"rules": ["cron_timer_rule_1.yaml", "cron_timer_rule_2.yaml"]
}
loader = FixturesLoader()
fixtures = loader.load_fixtures(fixtures_pack="generic",
fixtures_dict=test_fixtures)
rules = fixtures["rules"]
trigger_db_ret_1 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules["cron_timer_rule_1.yaml"]))
self.assertIsNotNone(trigger_db_ret_1)
trigger_db_ret_2 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules["cron_timer_rule_2.yaml"]))
self.assertIsNotNone(trigger_db_ret_2)
self.assertEqual(trigger_db_ret_1, trigger_db_ret_2,
"Should reuse same trigger.")
trigger_db = Trigger.get_by_id(trigger_db_ret_1.id)
self.assertDictEqual(
trigger_db.parameters,
rules["cron_timer_rule_1.yaml"]["trigger"]["parameters"],
)
def setUpClass(cls):
super(TestActionExecutionControllerAuthEnabled, cls).setUpClass()
cls.action = copy.deepcopy(ACTION_1)
headers = {
'content-type': 'application/json',
'X-Auth-Token': str(SYS_TOKEN.token)
}
post_resp = cls.app.post_json('/v1/actions',
cls.action,
headers=headers)
cls.action['id'] = post_resp.json['id']
FixturesLoader().save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=FIXTURES)
def setUpClass(cls):
super(TestTraceService, cls).setUpClass()
cls.models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_MODELS)
cls.trace1 = cls.models['traces']['trace_multiple_components.yaml']
cls.trace2 = cls.models['traces']['trace_one_each.yaml']
cls.trace3 = cls.models['traces']['trace_one_each_dup.yaml']
cls.trace_empty = cls.models['traces']['trace_empty.yaml']
cls.trace_execution = cls.models['traces']['trace_execution.yaml']
cls.traceable_liveaction = cls.models['liveactions'][
'traceable_liveaction.yaml']
cls.traceable_execution = cls.models['executions'][
'traceable_execution.yaml']
class TestDumper(DbTestCase):
fixtures_loader = FixturesLoader()
loaded_fixtures = fixtures_loader.load_fixtures(fixtures_pack=DESCENDANTS_PACK,
fixtures_dict=DESCENDANTS_FIXTURES)
loaded_executions = loaded_fixtures['executions']
execution_apis = []
for execution in loaded_executions.values():
execution_apis.append(ActionExecutionAPI(**execution))
def get_queue(self):
executions_queue = queue.Queue()
for execution in self.execution_apis:
executions_queue.put(execution)
return executions_queue
@mock.patch.object(os.path, 'exists', mock.MagicMock(return_value=True))
def test_write_marker_to_db(self):
executions_queue = self.get_queue()
dumper = Dumper(queue=executions_queue,
export_dir='/tmp', batch_size=5,
max_files_per_sleep=1,
file_prefix='st2-stuff-', file_format='json')
timestamps = [isotime.parse(execution.end_timestamp) for execution in self.execution_apis]
max_timestamp = max(timestamps)
marker_db = dumper._write_marker_to_db(max_timestamp)
persisted_marker = marker_db.marker
self.assertTrue(isinstance(persisted_marker, six.string_types))
self.assertEqual(isotime.parse(persisted_marker), max_timestamp)
@mock.patch.object(os.path, 'exists', mock.MagicMock(return_value=True))
def test_write_marker_to_db_marker_exists(self):
executions_queue = self.get_queue()
dumper = Dumper(queue=executions_queue,
export_dir='/tmp', batch_size=5,
max_files_per_sleep=1,
file_prefix='st2-stuff-', file_format='json')
timestamps = [isotime.parse(execution.end_timestamp) for execution in self.execution_apis]
max_timestamp = max(timestamps)
first_marker_db = dumper._write_marker_to_db(max_timestamp)
second_marker_db = dumper._write_marker_to_db(max_timestamp + datetime.timedelta(hours=1))
markers = DumperMarker.get_all()
self.assertEqual(len(markers), 1)
final_marker_id = markers[0].id
self.assertEqual(first_marker_db.id, final_marker_id)
self.assertEqual(second_marker_db.id, final_marker_id)
self.assertEqual(markers[0].marker, second_marker_db.marker)
self.assertTrue(second_marker_db.updated_at > first_marker_db.updated_at)
def setUpClass(cls):
super(ActionExecutionControllerTestCaseAuthEnabled, cls).setUpClass()
cls.action = copy.deepcopy(ACTION_1)
headers = {
'content-type': 'application/json',
'X-Auth-Token': str(SYS_TOKEN.token)
}
post_resp = cls.app.post_json('/v1/actions',
cls.action,
headers=headers)
cls.action['id'] = post_resp.json['id']
cls.action_encrypt = copy.deepcopy(ACTION_DEFAULT_ENCRYPT)
post_resp = cls.app.post_json('/v1/actions',
cls.action_encrypt,
headers=headers)
cls.action_encrypt['id'] = post_resp.json['id']
FixturesLoader().save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=FIXTURES)
# register datastore values which are used in this tests
KeyValuePairAPI._setup_crypto()
register_items = [
{
'name':
'secret',
'secret':
True,
'value':
crypto_utils.symmetric_encrypt(KeyValuePairAPI.crypto_key,
'foo')
},
{
'name':
'user1:secret',
'secret':
True,
'scope':
FULL_USER_SCOPE,
'value':
crypto_utils.symmetric_encrypt(KeyValuePairAPI.crypto_key,
'bar')
},
]
cls.kvps = [
KeyValuePair.add_or_update(KeyValuePairDB(**x))
for x in register_items
]
def setUpClass(cls):
super(ActionExecutionControllerTestCaseAuthEnabled, cls).setUpClass()
cls.action = copy.deepcopy(ACTION_1)
headers = {
"content-type": "application/json",
"X-Auth-Token": str(SYS_TOKEN.token),
}
post_resp = cls.app.post_json("/v1/actions",
cls.action,
headers=headers)
cls.action["id"] = post_resp.json["id"]
cls.action_encrypt = copy.deepcopy(ACTION_DEFAULT_ENCRYPT)
post_resp = cls.app.post_json("/v1/actions",
cls.action_encrypt,
headers=headers)
cls.action_encrypt["id"] = post_resp.json["id"]
FixturesLoader().save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=FIXTURES)
# register datastore values which are used in this tests
KeyValuePairAPI._setup_crypto()
register_items = [
{
"name":
"secret",
"secret":
True,
"value":
crypto_utils.symmetric_encrypt(KeyValuePairAPI.crypto_key,
"foo"),
},
{
"name":
"user1:secret",
"secret":
True,
"scope":
FULL_USER_SCOPE,
"value":
crypto_utils.symmetric_encrypt(KeyValuePairAPI.crypto_key,
"bar"),
},
]
cls.kvps = [
KeyValuePair.add_or_update(KeyValuePairDB(**x))
for x in register_items
]
def setUp(self):
super(RetryPolicyTestCase, self).setUp()
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2actions)
loader = FixturesLoader()
models = loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
# Instantiate policy applicator we will use in the tests
policy_db = models["policies"]["policy_4.yaml"]
retry_on = policy_db.parameters["retry_on"]
max_retry_count = policy_db.parameters["max_retry_count"]
self.policy = ExecutionRetryPolicyApplicator(
policy_ref="test_policy",
policy_type="action.retry",
retry_on=retry_on,
max_retry_count=max_retry_count,
delay=0,
)
class WorkerTestCase(DbTestCase):
fixtures_loader = FixturesLoader()
@classmethod
def setUpClass(cls):
super(WorkerTestCase, cls).setUpClass()
models = WorkerTestCase.fixtures_loader.save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_FIXTURES)
WorkerTestCase.local_runnertype_db = models['runners'][
'run-local.yaml']
WorkerTestCase.local_action_db = models['actions']['local.yaml']
@mock.patch.object(
LocalShellRunner, 'run',
mock.MagicMock(
return_value=(action_constants.LIVEACTION_STATUS_SUCCEEDED,
NON_UTF8_RESULT, None)))
def test_non_utf8_action_result_string(self):
action_worker = actions_worker.get_worker()
params = {'cmd': "python -c 'print \"\\x82\"'"}
liveaction_db = self._get_liveaction_model(
WorkerTestCase.local_action_db, params)
liveaction_db = LiveAction.add_or_update(liveaction_db)
execution_db = executions.create_execution_object(liveaction_db)
try:
action_worker._run_action(liveaction_db)
except InvalidStringData:
liveaction_db = LiveAction.get_by_id(liveaction_db.id)
self.assertEqual(liveaction_db.status, "failed")
self.assertTrue('error' in liveaction_db.result)
self.assertTrue('traceback' in liveaction_db.result)
execution_db = ActionExecution.get_by_id(execution_db.id)
self.assertEqual(liveaction_db.status, "failed")
def _get_liveaction_model(self, action_db, params):
status = action_constants.LIVEACTION_STATUS_REQUESTED
start_timestamp = date_utils.get_datetime_utc_now()
action_ref = ResourceReference(name=action_db.name,
pack=action_db.pack).ref
parameters = params
context = {'user': cfg.CONF.system_user.user}
liveaction_db = LiveActionDB(status=status,
start_timestamp=start_timestamp,
action=action_ref,
parameters=parameters,
context=context)
return liveaction_db
def test_file_partitioner(self):
partition_file = FixturesLoader().get_fixture_file_path_abs(
fixtures_pack=PACK, fixtures_type='sensors', fixture_name='partition_file.yaml')
cfg.CONF.set_override(name='partition_provider',
override={'name': FILE_PARTITION_LOADER,
'partition_file': partition_file},
group='sensorcontainer')
provider = get_sensors_partitioner()
sensors = provider.get_sensors()
self.assertEqual(len(sensors), 2)
sensor1 = self.models['sensors']['sensor1.yaml']
self.assertTrue(provider.is_sensor_owner(sensor1))
sensor3 = self.models['sensors']['sensor3.yaml']
self.assertFalse(provider.is_sensor_owner(sensor3))
class TestJsonConverter(unittest2.TestCase):
fixtures_loader = FixturesLoader()
loaded_fixtures = fixtures_loader.load_fixtures(
fixtures_pack=DESCENDANTS_PACK, fixtures_dict=DESCENDANTS_FIXTURES)
def test_convert(self):
executions_list = list(self.loaded_fixtures['executions'].values())
converter = JsonConverter()
converted_doc = converter.convert(executions_list)
self.assertTrue(type(converted_doc), 'string')
reversed_doc = json.loads(converted_doc)
self.assertListEqual(executions_list, reversed_doc)
def test_convert_non_list(self):
executions_dict = self.loaded_fixtures['executions']
converter = JsonConverter()
try:
converter.convert(executions_dict)
self.fail('Should have thrown exception.')
except ValueError:
pass
from st2common.transport.publishers import PoolPublisher
from st2common.util import date as date_utils
from st2common.util import param as param_utils
from st2common.util.config_loader import get_config
from st2tests import DbTestCase
from st2tests.fixturesloader import FixturesLoader
FIXTURES_PACK = 'generic'
TEST_MODELS = {
'actions': ['action_4_action_context_param.yaml', 'action_system_default.yaml'],
'runners': ['testrunner1.yaml']
}
FIXTURES = FixturesLoader().load_models(fixtures_pack=FIXTURES_PACK,
fixtures_dict=TEST_MODELS)
@mock.patch.object(PoolPublisher, 'publish', mock.MagicMock())
class ParamsUtilsTest(DbTestCase):
action_db = FIXTURES['actions']['action_4_action_context_param.yaml']
action_system_default_db = FIXTURES['actions']['action_system_default.yaml']
runnertype_db = FIXTURES['runners']['testrunner1.yaml']
def test_get_finalized_params(self):
params = {
'actionstr': 'foo',
'some_key_that_aint_exist_in_action_or_runner': 'bar',
'runnerint': 555,
'runnerimmutable': 'failed_override',
'actionimmutable': 'failed_override'
WF_INVALID_SYNTAX_FILE,
WF_INVALID_YAQL_FILE
],
'actions': [
'a1.yaml',
'a2.yaml',
'action1.yaml'
],
'runners': [
'testrunner1.yaml',
'testrunner2.yaml'
]
}
PACK = 'generic'
LOADER = FixturesLoader()
FIXTURES = LOADER.load_fixtures(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
WB_PRE_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WB_PRE_XFORM_FILE)
WB_INVALID_SYNTAX_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WB_INVALID_SYNTAX_FILE)
WB_INVALID_YAQL_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WB_INVALID_YAQL_FILE)
WF_PRE_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_PRE_XFORM_FILE)
WF_NO_REQ_PARAM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_NO_REQ_PARAM_FILE)
WF_UNEXP_PARAM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_UNEXP_PARAM_FILE)
WF_INVALID_SYNTAX_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_INVALID_SYNTAX_FILE)
WF_INVALID_YAQL_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_INVALID_YAQL_FILE)
class MistralValidationControllerTest(FunctionalTest):
@classmethod
def setUpClass(cls):
class LocalShellCommandRunnerTestCase(RunnerTestCase, CleanDbTestCase):
fixtures_loader = FixturesLoader()
def setUp(self):
super(LocalShellCommandRunnerTestCase, self).setUp()
# False is a default behavior so end result should be the same
cfg.CONF.set_override(name='stream_output',
group='actionrunner',
override=False)
def test_shell_command_action_basic(self):
models = self.fixtures_loader.load_models(
fixtures_pack='generic', fixtures_dict={'actions': ['local.yaml']})
action_db = models['actions']['local.yaml']
runner = self._get_runner(action_db, cmd='echo 10')
runner.pre_run()
status, result, _ = runner.run({})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEquals(result['stdout'], 10)
# End result should be the same when streaming is enabled
cfg.CONF.set_override(name='stream_output',
group='actionrunner',
override=True)
# Verify initial state
output_dbs = ActionExecutionOutput.get_all()
self.assertEqual(len(output_dbs), 0)
runner = self._get_runner(action_db, cmd='echo 10')
runner.pre_run()
status, result, _ = runner.run({})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEquals(result['stdout'], 10)
output_dbs = ActionExecutionOutput.get_all()
self.assertEqual(len(output_dbs), 1)
self.assertEqual(output_dbs[0].output_type, 'stdout')
self.assertEqual(output_dbs[0].data, '10\n')
def test_shell_script_action(self):
models = self.fixtures_loader.load_models(
fixtures_pack='localrunner_pack',
fixtures_dict={'actions': ['text_gen.yml']})
action_db = models['actions']['text_gen.yml']
entry_point = self.fixtures_loader.get_fixture_file_path_abs(
'localrunner_pack', 'actions', 'text_gen.py')
runner = self._get_runner(action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run({'chars': 1000})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEquals(len(result['stdout']), 1000)
def test_timeout(self):
models = self.fixtures_loader.load_models(
fixtures_pack='generic', fixtures_dict={'actions': ['local.yaml']})
action_db = models['actions']['local.yaml']
# smaller timeout == faster tests.
runner = self._get_runner(action_db, cmd='sleep 10', timeout=0.01)
runner.pre_run()
status, result, _ = runner.run({})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_TIMED_OUT)
@mock.patch.object(shell, 'run_command',
mock.MagicMock(return_value=(-15, '', '', False)))
def test_shutdown(self):
models = self.fixtures_loader.load_models(
fixtures_pack='generic', fixtures_dict={'actions': ['local.yaml']})
action_db = models['actions']['local.yaml']
runner = self._get_runner(action_db, cmd='sleep 0.1')
runner.pre_run()
status, result, _ = runner.run({})
self.assertEquals(status, action_constants.LIVEACTION_STATUS_ABANDONED)
def test_large_stdout(self):
models = self.fixtures_loader.load_models(
fixtures_pack='localrunner_pack',
fixtures_dict={'actions': ['text_gen.yml']})
action_db = models['actions']['text_gen.yml']
entry_point = self.fixtures_loader.get_fixture_file_path_abs(
'localrunner_pack', 'actions', 'text_gen.py')
runner = self._get_runner(action_db, entry_point=entry_point)
runner.pre_run()
char_count = 10**6 # Note 10^7 succeeds but ends up being slow.
status, result, _ = runner.run({'chars': char_count})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEquals(len(result['stdout']), char_count)
def test_common_st2_env_vars_are_available_to_the_action(self):
models = self.fixtures_loader.load_models(
fixtures_pack='generic', fixtures_dict={'actions': ['local.yaml']})
action_db = models['actions']['local.yaml']
runner = self._get_runner(action_db, cmd='echo $ST2_ACTION_API_URL')
runner.pre_run()
status, result, _ = runner.run({})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEqual(result['stdout'].strip(), get_full_public_api_url())
runner = self._get_runner(action_db, cmd='echo $ST2_ACTION_AUTH_TOKEN')
runner.pre_run()
status, result, _ = runner.run({})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEqual(result['stdout'].strip(), 'mock-token')
def test_sudo_and_env_variable_preservation(self):
# Verify that the environment environment are correctly preserved when running as a
# root / non-system user
# Note: This test will fail if SETENV option is not present in the sudoers file
models = self.fixtures_loader.load_models(
fixtures_pack='generic', fixtures_dict={'actions': ['local.yaml']})
action_db = models['actions']['local.yaml']
cmd = 'echo `whoami` ; echo ${VAR1}'
env = {'VAR1': 'poniesponies'}
runner = self._get_runner(action_db, cmd=cmd, sudo=True, env=env)
runner.pre_run()
status, result, _ = runner.run({})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEqual(result['stdout'].strip(), 'root\nponiesponies')
@mock.patch('st2common.util.green.shell.subprocess.Popen')
@mock.patch('st2common.util.green.shell.eventlet.spawn')
def test_action_stdout_and_stderr_is_stored_in_the_db(
self, mock_spawn, mock_popen):
# Feature is enabled
cfg.CONF.set_override(name='stream_output',
group='actionrunner',
override=True)
# Note: We need to mock spawn function so we can test everything in single event loop
# iteration
mock_spawn.side_effect = blocking_eventlet_spawn
# No output to stdout and no result (implicit None)
mock_stdout = [
'stdout line 1\n',
'stdout line 2\n',
]
mock_stderr = ['stderr line 1\n', 'stderr line 2\n', 'stderr line 3\n']
mock_process = mock.Mock()
mock_process.returncode = 0
mock_popen.return_value = mock_process
mock_process.stdout.closed = False
mock_process.stderr.closed = False
mock_process.stdout.readline = make_mock_stream_readline(
mock_process.stdout, mock_stdout, stop_counter=2)
mock_process.stderr.readline = make_mock_stream_readline(
mock_process.stderr, mock_stderr, stop_counter=3)
models = self.fixtures_loader.load_models(
fixtures_pack='generic', fixtures_dict={'actions': ['local.yaml']})
action_db = models['actions']['local.yaml']
runner = self._get_runner(action_db, cmd='echo $ST2_ACTION_API_URL')
runner.pre_run()
status, result, _ = runner.run({})
runner.post_run(status, result)
self.assertEquals(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEqual(result['stdout'], 'stdout line 1\nstdout line 2')
self.assertEqual(result['stderr'],
'stderr line 1\nstderr line 2\nstderr line 3')
self.assertEqual(result['return_code'], 0)
# Verify stdout and stderr lines have been correctly stored in the db
output_dbs = ActionExecutionOutput.query(output_type='stdout')
self.assertEqual(len(output_dbs), 2)
self.assertEqual(output_dbs[0].data, mock_stdout[0])
self.assertEqual(output_dbs[1].data, mock_stdout[1])
output_dbs = ActionExecutionOutput.query(output_type='stderr')
self.assertEqual(len(output_dbs), 3)
self.assertEqual(output_dbs[0].data, mock_stderr[0])
self.assertEqual(output_dbs[1].data, mock_stderr[1])
self.assertEqual(output_dbs[2].data, mock_stderr[2])
@mock.patch('st2common.util.green.shell.subprocess.Popen')
@mock.patch('st2common.util.green.shell.eventlet.spawn')
def test_action_stdout_and_stderr_is_stored_in_the_db_short_running_action(
self, mock_spawn, mock_popen):
# Verify that we correctly retrieve all the output and wait for stdout and stderr reading
# threads for short running actions.
models = self.fixtures_loader.load_models(
fixtures_pack='generic', fixtures_dict={'actions': ['local.yaml']})
action_db = models['actions']['local.yaml']
# Feature is enabled
cfg.CONF.set_override(name='stream_output',
group='actionrunner',
override=True)
# Note: We need to mock spawn function so we can test everything in single event loop
# iteration
mock_spawn.side_effect = blocking_eventlet_spawn
# No output to stdout and no result (implicit None)
mock_stdout = ['stdout line 1\n', 'stdout line 2\n']
mock_stderr = ['stderr line 1\n', 'stderr line 2\n']
# We add a sleep to simulate action process exiting before we finish reading data from
mock_process = mock.Mock()
mock_process.returncode = 0
mock_popen.return_value = mock_process
mock_process.stdout.closed = False
mock_process.stderr.closed = False
mock_process.stdout.readline = make_mock_stream_readline(
mock_process.stdout, mock_stdout, stop_counter=2, sleep_delay=1)
mock_process.stderr.readline = make_mock_stream_readline(
mock_process.stderr, mock_stderr, stop_counter=2)
for index in range(1, 4):
mock_process.stdout.closed = False
mock_process.stderr.closed = False
mock_process.stdout.counter = 0
mock_process.stderr.counter = 0
runner = self._get_runner(action_db, cmd='echo "foobar"')
runner.pre_run()
status, result, _ = runner.run({})
self.assertEquals(status,
action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertEqual(result['stdout'], 'stdout line 1\nstdout line 2')
self.assertEqual(result['stderr'], 'stderr line 1\nstderr line 2')
self.assertEqual(result['return_code'], 0)
# Verify stdout and stderr lines have been correctly stored in the db
output_dbs = ActionExecutionOutput.query(output_type='stdout')
if index == 1:
db_index_1 = 0
db_index_2 = 1
elif index == 2:
db_index_1 = 2
db_index_2 = 3
elif index == 3:
db_index_1 = 4
db_index_2 = 5
elif index == 4:
db_index_1 = 6
db_index_2 = 7
self.assertEqual(len(output_dbs), (index * 2))
self.assertEqual(output_dbs[db_index_1].data, mock_stdout[0])
self.assertEqual(output_dbs[db_index_2].data, mock_stdout[1])
output_dbs = ActionExecutionOutput.query(output_type='stderr')
self.assertEqual(len(output_dbs), (index * 2))
self.assertEqual(output_dbs[db_index_1].data, mock_stderr[0])
self.assertEqual(output_dbs[db_index_2].data, mock_stderr[1])
@staticmethod
def _get_runner(action_db,
entry_point=None,
cmd=None,
on_behalf_user=None,
user=None,
kwarg_op=local_runner.DEFAULT_KWARG_OP,
timeout=LOCAL_RUNNER_DEFAULT_ACTION_TIMEOUT,
sudo=False,
env=None):
runner = local_runner.LocalShellRunner(uuid.uuid4().hex)
runner.container_service = RunnerContainerService()
runner.execution = MOCK_EXECUTION
runner.action = action_db
runner.action_name = action_db.name
runner.liveaction_id = uuid.uuid4().hex
runner.entry_point = entry_point
runner.runner_parameters = {
local_runner.RUNNER_COMMAND: cmd,
local_runner.RUNNER_SUDO: sudo,
local_runner.RUNNER_ENV: env,
local_runner.RUNNER_ON_BEHALF_USER: user,
local_runner.RUNNER_KWARG_OP: kwarg_op,
local_runner.RUNNER_TIMEOUT: timeout
}
runner.context = dict()
runner.callback = dict()
runner.libs_dir_path = None
runner.auth_token = mock.Mock()
runner.auth_token.token = 'mock-token'
return runner
class LocalShellScriptRunnerTestCase(RunnerTestCase, CleanDbTestCase):
fixtures_loader = FixturesLoader()
def setUp(self):
super(LocalShellScriptRunnerTestCase, self).setUp()
# False is a default behavior so end result should be the same
cfg.CONF.set_override(name='stream_output',
group='actionrunner',
override=False)
def test_script_with_paramters_parameter_serialization(self):
models = self.fixtures_loader.load_models(
fixtures_pack='generic',
fixtures_dict={'actions': ['local_script_with_params.yaml']})
action_db = models['actions']['local_script_with_params.yaml']
entry_point = os.path.join(
get_fixtures_base_path(),
'generic/actions/local_script_with_params.sh')
action_parameters = {
'param_string': 'test string',
'param_integer': 1,
'param_float': 2.55,
'param_boolean': True,
'param_list': ['a', 'b', 'c'],
'param_object': {
'foo': 'bar'
}
}
runner = self._get_runner(action_db=action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run(action_parameters=action_parameters)
runner.post_run(status, result)
self.assertEqual(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertTrue('PARAM_STRING=test string' in result['stdout'])
self.assertTrue('PARAM_INTEGER=1' in result['stdout'])
self.assertTrue('PARAM_FLOAT=2.55' in result['stdout'])
self.assertTrue('PARAM_BOOLEAN=1' in result['stdout'])
self.assertTrue('PARAM_LIST=a,b,c' in result['stdout'])
self.assertTrue('PARAM_OBJECT={"foo": "bar"}' in result['stdout'])
action_parameters = {
'param_string': 'test string',
'param_integer': 1,
'param_float': 2.55,
'param_boolean': False,
'param_list': ['a', 'b', 'c'],
'param_object': {
'foo': 'bar'
}
}
runner = self._get_runner(action_db=action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run(action_parameters=action_parameters)
runner.post_run(status, result)
self.assertEqual(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertTrue('PARAM_BOOLEAN=0' in result['stdout'])
action_parameters = {
'param_string': '',
'param_integer': None,
'param_float': None,
}
runner = self._get_runner(action_db=action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run(action_parameters=action_parameters)
runner.post_run(status, result)
self.assertEqual(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertTrue('PARAM_STRING=\n' in result['stdout'])
self.assertTrue('PARAM_INTEGER=\n' in result['stdout'])
self.assertTrue('PARAM_FLOAT=\n' in result['stdout'])
# End result should be the same when streaming is enabled
cfg.CONF.set_override(name='stream_output',
group='actionrunner',
override=True)
# Verify initial state
output_dbs = ActionExecutionOutput.get_all()
self.assertEqual(len(output_dbs), 0)
action_parameters = {
'param_string': 'test string',
'param_integer': 1,
'param_float': 2.55,
'param_boolean': True,
'param_list': ['a', 'b', 'c'],
'param_object': {
'foo': 'bar'
}
}
runner = self._get_runner(action_db=action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run(action_parameters=action_parameters)
runner.post_run(status, result)
self.assertEqual(status, action_constants.LIVEACTION_STATUS_SUCCEEDED)
self.assertTrue('PARAM_STRING=test string' in result['stdout'])
self.assertTrue('PARAM_INTEGER=1' in result['stdout'])
self.assertTrue('PARAM_FLOAT=2.55' in result['stdout'])
self.assertTrue('PARAM_BOOLEAN=1' in result['stdout'])
self.assertTrue('PARAM_LIST=a,b,c' in result['stdout'])
self.assertTrue('PARAM_OBJECT={"foo": "bar"}' in result['stdout'])
output_dbs = ActionExecutionOutput.query(output_type='stdout')
self.assertEqual(len(output_dbs), 6)
self.assertEqual(output_dbs[0].data, 'PARAM_STRING=test string\n')
self.assertEqual(output_dbs[5].data, 'PARAM_OBJECT={"foo": "bar"}\n')
output_dbs = ActionExecutionOutput.query(output_type='stderr')
self.assertEqual(len(output_dbs), 0)
@mock.patch('st2common.util.green.shell.subprocess.Popen')
@mock.patch('st2common.util.green.shell.eventlet.spawn')
def test_action_stdout_and_stderr_is_stored_in_the_db(
self, mock_spawn, mock_popen):
# Feature is enabled
cfg.CONF.set_override(name='stream_output',
group='actionrunner',
override=True)
# Note: We need to mock spawn function so we can test everything in single event loop
# iteration
mock_spawn.side_effect = blocking_eventlet_spawn
# No output to stdout and no result (implicit None)
mock_stdout = [
'stdout line 1\n', 'stdout line 2\n', 'stdout line 3\n',
'stdout line 4\n'
]
mock_stderr = ['stderr line 1\n', 'stderr line 2\n', 'stderr line 3\n']
mock_process = mock.Mock()
mock_process.returncode = 0
mock_popen.return_value = mock_process
mock_process.stdout.closed = False
mock_process.stderr.closed = False
mock_process.stdout.readline = make_mock_stream_readline(
mock_process.stdout, mock_stdout, stop_counter=4)
mock_process.stderr.readline = make_mock_stream_readline(
mock_process.stderr, mock_stderr, stop_counter=3)
models = self.fixtures_loader.load_models(
fixtures_pack='generic',
fixtures_dict={'actions': ['local_script_with_params.yaml']})
action_db = models['actions']['local_script_with_params.yaml']
entry_point = os.path.join(
get_fixtures_base_path(),
'generic/actions/local_script_with_params.sh')
action_parameters = {
'param_string': 'test string',
'param_integer': 1,
'param_float': 2.55,
'param_boolean': True,
'param_list': ['a', 'b', 'c'],
'param_object': {
'foo': 'bar'
}
}
runner = self._get_runner(action_db=action_db, entry_point=entry_point)
runner.pre_run()
status, result, _ = runner.run(action_parameters=action_parameters)
runner.post_run(status, result)
self.assertEqual(
result['stdout'],
'stdout line 1\nstdout line 2\nstdout line 3\nstdout line 4')
self.assertEqual(result['stderr'],
'stderr line 1\nstderr line 2\nstderr line 3')
self.assertEqual(result['return_code'], 0)
# Verify stdout and stderr lines have been correctly stored in the db
output_dbs = ActionExecutionOutput.query(output_type='stdout')
self.assertEqual(len(output_dbs), 4)
self.assertEqual(output_dbs[0].data, mock_stdout[0])
self.assertEqual(output_dbs[1].data, mock_stdout[1])
self.assertEqual(output_dbs[2].data, mock_stdout[2])
self.assertEqual(output_dbs[3].data, mock_stdout[3])
output_dbs = ActionExecutionOutput.query(output_type='stderr')
self.assertEqual(len(output_dbs), 3)
self.assertEqual(output_dbs[0].data, mock_stderr[0])
self.assertEqual(output_dbs[1].data, mock_stderr[1])
self.assertEqual(output_dbs[2].data, mock_stderr[2])
def _get_runner(self, action_db, entry_point):
runner = local_runner.LocalShellRunner(uuid.uuid4().hex)
runner.container_service = RunnerContainerService()
runner.execution = MOCK_EXECUTION
runner.action = action_db
runner.action_name = action_db.name
runner.liveaction_id = uuid.uuid4().hex
runner.entry_point = entry_point
runner.runner_parameters = {}
runner.context = dict()
runner.callback = dict()
runner.libs_dir_path = None
runner.auth_token = mock.Mock()
runner.auth_token.token = 'mock-token'
return runner
def setUpClass(cls):
super(TestTimersController, cls).setUpClass()
loader = FixturesLoader()
TestTimersController.MODELS = loader.save_fixtures_to_db(fixtures_pack=PACK, fixtures_dict=FIXTURES)["triggers"]
TEST_FIXTURES = {
'actions': [
'action1.yaml'
],
'policytypes': [
'fake_policy_type_1.yaml',
'fake_policy_type_2.yaml'
],
'policies': [
'policy_1.yaml',
'policy_2.yaml'
]
}
PACK = 'generic'
LOADER = FixturesLoader()
FIXTURES = LOADER.load_fixtures(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
@mock.patch.object(
CUDPublisher, 'publish_update',
mock.MagicMock(side_effect=MockExecutionPublisher.publish_update))
@mock.patch.object(
CUDPublisher, 'publish_create',
mock.MagicMock(return_value=None))
@mock.patch.object(
LiveActionPublisher, 'publish_state',
mock.MagicMock(side_effect=MockLiveActionPublisher.publish_state))
@mock.patch('st2common.runners.base.get_runner', mock.Mock(return_value=runner.get_runner()))
@mock.patch('st2actions.container.base.get_runner', mock.Mock(return_value=runner.get_runner()))
class SchedulingPolicyTest(ExecutionDbTestCase):
class WorkerTestCase(DbTestCase):
fixtures_loader = FixturesLoader()
@classmethod
def setUpClass(cls):
super(WorkerTestCase, cls).setUpClass()
models = WorkerTestCase.fixtures_loader.save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_FIXTURES)
WorkerTestCase.local_runnertype_db = models['runners'][
'run-local.yaml']
WorkerTestCase.local_action_db = models['actions']['local.yaml']
def _get_liveaction_model(self, action_db, params):
status = action_constants.LIVEACTION_STATUS_REQUESTED
start_timestamp = date_utils.get_datetime_utc_now()
action_ref = ResourceReference(name=action_db.name,
pack=action_db.pack).ref
parameters = params
context = {'user': cfg.CONF.system_user.user}
liveaction_db = LiveActionDB(status=status,
start_timestamp=start_timestamp,
action=action_ref,
parameters=parameters,
context=context)
return liveaction_db
@mock.patch.object(
LocalShellCommandRunner, 'run',
mock.MagicMock(
return_value=(action_constants.LIVEACTION_STATUS_SUCCEEDED,
NON_UTF8_RESULT, None)))
def test_non_utf8_action_result_string(self):
action_worker = actions_worker.get_worker()
params = {'cmd': "python -c 'print \"\\x82\"'"}
liveaction_db = self._get_liveaction_model(
WorkerTestCase.local_action_db, params)
liveaction_db = LiveAction.add_or_update(liveaction_db)
execution_db = executions.create_execution_object(liveaction_db)
try:
action_worker._run_action(liveaction_db)
except InvalidStringData:
liveaction_db = LiveAction.get_by_id(liveaction_db.id)
self.assertEqual(liveaction_db.status,
action_constants.LIVEACTION_STATUS_FAILED)
self.assertTrue('error' in liveaction_db.result)
self.assertTrue('traceback' in liveaction_db.result)
execution_db = ActionExecution.get_by_id(execution_db.id)
self.assertEqual(liveaction_db.status,
action_constants.LIVEACTION_STATUS_FAILED)
def test_worker_shutdown(self):
action_worker = actions_worker.get_worker()
temp_file = None
# Create a temporary file that is deleted when the file is closed and then set up an
# action to wait for this file to be deleted. This allows this test to run the action
# over a separate thread, run the shutdown sequence on the main thread, and then let
# the local runner to exit gracefully and allow _run_action to finish execution.
with tempfile.NamedTemporaryFile() as fp:
temp_file = fp.name
self.assertIsNotNone(temp_file)
self.assertTrue(os.path.isfile(temp_file))
# Launch the action execution in a separate thread.
params = {
'cmd': 'while [ -e \'%s\' ]; do sleep 0.1; done' % temp_file
}
liveaction_db = self._get_liveaction_model(
WorkerTestCase.local_action_db, params)
liveaction_db = LiveAction.add_or_update(liveaction_db)
executions.create_execution_object(liveaction_db)
runner_thread = eventlet.spawn(action_worker._run_action,
liveaction_db)
# Wait for the worker up to 10s to add the liveaction to _running_liveactions.
for i in range(0, int(10 / 0.1)):
eventlet.sleep(0.1)
if len(action_worker._running_liveactions) > 0:
break
self.assertEqual(len(action_worker._running_liveactions), 1)
# Shutdown the worker to trigger the abandon process.
action_worker.shutdown()
liveaction_db = LiveAction.get_by_id(liveaction_db.id)
# Verify that _running_liveactions is empty and the liveaction is abandoned.
self.assertEqual(len(action_worker._running_liveactions), 0)
self.assertEqual(liveaction_db.status,
action_constants.LIVEACTION_STATUS_ABANDONED)
# Make sure the temporary file has been deleted.
self.assertFalse(os.path.isfile(temp_file))
# Wait for the local runner to complete. This will activate the finally block in
# _run_action but will not result in KeyError because the discard method is used to
# to remove the liveaction from _running_liveactions.
runner_thread.wait()
class ActionExecutionRBACControllerTestCase(
BaseActionExecutionControllerTestCase, APIControllerWithRBACTestCase):
fixtures_loader = FixturesLoader()
@mock.patch.object(action_validator, 'validate_action',
mock.MagicMock(return_value=True))
def setUp(self):
super(ActionExecutionRBACControllerTestCase, self).setUp()
self.fixtures_loader.save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=TEST_FIXTURES)
# Insert mock users, roles and assignments
# Users
user_1_db = UserDB(name='multiple_roles')
user_1_db = User.add_or_update(user_1_db)
self.users['multiple_roles'] = user_1_db
# Roles
roles = ['role_1', 'role_2', 'role_3']
for role in roles:
role_db = RoleDB(name=role)
Role.add_or_update(role_db)
# Role assignments
user_db = self.users['multiple_roles']
role_assignment_db = UserRoleAssignmentDB(
user=user_db.name,
role='admin',
source='assignments/%s.yaml' % user_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
for role in roles:
role_assignment_db = UserRoleAssignmentDB(
user=user_db.name,
role=role,
source='assignments/%s.yaml' % user_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
def test_post_rbac_info_in_context_success(self):
# When RBAC is enabled, additional RBAC related info should be included in action_context
data = {
'action': 'wolfpack.action-1',
'parameters': {
'actionstr': 'foo'
}
}
# User with one role assignment
user_db = self.users['admin']
self.use_user(user_db)
resp = self._do_post(data)
self.assertEqual(resp.status_int, 201)
expected_context = {
'pack': 'wolfpack',
'user': '******',
'rbac': {
'user': '******',
'roles': ['admin']
}
}
self.assertEqual(resp.json['context'], expected_context)
# User with multiple role assignments
user_db = self.users['multiple_roles']
self.use_user(user_db)
resp = self._do_post(data)
self.assertEqual(resp.status_int, 201)
expected_context = {
'pack': 'wolfpack',
'user': '******',
'rbac': {
'user': '******',
'roles': ['admin', 'role_1', 'role_2', 'role_3']
}
}
self.assertEqual(resp.json['context'], expected_context)
def test_get_all_limit_minus_one(self):
user_db = self.users['observer']
self.use_user(user_db)
resp = self.app.get('/v1/actionexecutions?limit=-1',
expect_errors=True)
self.assertEqual(resp.status_code, http_client.FORBIDDEN)
user_db = self.users['admin']
self.use_user(user_db)
resp = self.app.get('/v1/actionexecutions?limit=-1')
self.assertEqual(resp.status_code, http_client.OK)
],
'actions': [
'local.yaml',
'a1.yaml',
'a2.yaml',
'action1.yaml'
],
'runners': [
'run-local.yaml',
'testrunner1.yaml',
'testrunner2.yaml'
]
}
PACK = 'generic'
LOADER = FixturesLoader()
FIXTURES = LOADER.load_fixtures(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
WB_PRE_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WB_PRE_XFORM_FILE)
WB_PRE_XFORM_DEF = FIXTURES['workflows'][WB_PRE_XFORM_FILE]
WB_POST_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WB_POST_XFORM_FILE)
WB_POST_XFORM_DEF = FIXTURES['workflows'][WB_POST_XFORM_FILE]
WF_PRE_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_PRE_XFORM_FILE)
WF_PRE_XFORM_DEF = FIXTURES['workflows'][WF_PRE_XFORM_FILE]
WF_POST_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_POST_XFORM_FILE)
WF_POST_XFORM_DEF = FIXTURES['workflows'][WF_POST_XFORM_FILE]
WF_JINJA_ST2KV_PRE_XFORM_PATH = LOADER.get_fixture_file_path_abs(
PACK, 'workflows', WF_JINJA_ST2KV_PRE_XFORM_FILE)
WF_JINJA_ST2KV_PRE_XFORM_DEF = FIXTURES['workflows'][WF_JINJA_ST2KV_PRE_XFORM_FILE]
WF_JINJA_ST2KV_POST_XFORM_PATH = LOADER.get_fixture_file_path_abs(
PACK, 'workflows', WF_JINJA_ST2KV_POST_XFORM_FILE)
WF_JINJA_MIXED_CTX1_DEF = FIXTURES['workflows'][WF_JINJA_MIXED_CTX1_FILE]
def setUp(self):
super(TestPurgeExecutions, self).setUp()
fixtures_loader = FixturesLoader()
self.models = fixtures_loader.load_models(fixtures_pack='generic',
fixtures_dict=TEST_FIXTURES)
def setUpClass(cls):
super(TestApiKeyBasedAuth, cls).setUpClass()
models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_MODELS)
cls.apikey1 = models['apikeys']['apikey1.yaml']
cls.apikey_disabled = models['apikeys']['apikey_disabled.yaml']
from oslo_config import cfg
import st2actions.resultstracker.resultstracker as results_tracker
from st2common.constants import action as action_constants
from st2common.exceptions.db import StackStormDBObjectNotFoundError
from st2common.persistence.action import Action
from st2common.persistence.executionstate import ActionExecutionState
from st2common.persistence.liveaction import LiveAction
from st2common.runners import utils as runners_utils
from st2common.services import executions
from st2common.util import action_db as action_db_utils
from st2tests.base import (DbTestCase, EventletTestCase)
from st2tests.fixturesloader import FixturesLoader
FIXTURES_LOADER = FixturesLoader()
FIXTURES_PACK = 'generic'
FIXTURES = {
'actionstates': ['state1.yaml', 'state2.yaml'],
'liveactions': ['liveaction1.yaml', 'liveaction2.yaml']
}
@mock.patch.object(executions, 'update_execution',
mock.MagicMock(return_value=None))
@mock.patch.object(LiveAction, 'publish_update',
mock.MagicMock(return_value=None))
class ResultsTrackerTests(EventletTestCase, DbTestCase):
states = None
models = None
liveactions = None
def setUpClass(cls):
super(TestExportWorker, cls).setUpClass()
fixtures_loader = FixturesLoader()
loaded_fixtures = fixtures_loader.save_fixtures_to_db(fixtures_pack=DESCENDANTS_PACK,
fixtures_dict=DESCENDANTS_FIXTURES)
TestExportWorker.saved_executions = loaded_fixtures['executions']
class TraceControllerRBACTestCase(APIControllerWithRBACTestCase):
fixtures_loader = FixturesLoader()
def setUp(self):
super(TraceControllerRBACTestCase, self).setUp()
self.models = self.fixtures_loader.save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=TEST_FIXTURES)
file_name = 'trace_for_test_enforce.yaml'
TraceControllerRBACTestCase.TRACE_1 = self.fixtures_loader.load_fixtures(
fixtures_pack=FIXTURES_PACK,
fixtures_dict={'traces': [file_name]})['traces'][file_name]
file_name = 'trace_for_test_enforce_2.yaml'
TraceControllerRBACTestCase.TRACE_1 = self.fixtures_loader.load_fixtures(
fixtures_pack=FIXTURES_PACK,
fixtures_dict={'traces': [file_name]})['traces'][file_name]
file_name = 'trace_for_test_enforce_3.yaml'
TraceControllerRBACTestCase.TRACE_1 = self.fixtures_loader.load_fixtures(
fixtures_pack=FIXTURES_PACK,
fixtures_dict={'traces': [file_name]})['traces'][file_name]
# Insert mock users, roles and assignments
# Users
user_1_db = UserDB(name='trace_list')
user_1_db = User.add_or_update(user_1_db)
self.users['trace_list'] = user_1_db
user_2_db = UserDB(name='trace_view')
user_2_db = User.add_or_update(user_2_db)
self.users['trace_view'] = user_2_db
# Roles
# trace_list
grant_db = PermissionGrantDB(resource_uid=None,
resource_type=ResourceType.TRACE,
permission_types=[PermissionType.TRACE_LIST])
grant_db = PermissionGrant.add_or_update(grant_db)
permission_grants = [str(grant_db.id)]
role_1_db = RoleDB(name='trace_list', permission_grants=permission_grants)
role_1_db = Role.add_or_update(role_1_db)
self.roles['trace_list'] = role_1_db
# trace_view on trace 1
trace_uid = self.models['traces']['trace_for_test_enforce.yaml'].get_uid()
grant_db = PermissionGrantDB(resource_uid=trace_uid,
resource_type=ResourceType.TRACE,
permission_types=[PermissionType.TRACE_VIEW])
grant_db = PermissionGrant.add_or_update(grant_db)
permission_grants = [str(grant_db.id)]
role_1_db = RoleDB(name='trace_view', permission_grants=permission_grants)
role_1_db = Role.add_or_update(role_1_db)
self.roles['trace_view'] = role_1_db
# Role assignments
role_assignment_db = UserRoleAssignmentDB(
user=self.users['trace_list'].name,
role=self.roles['trace_list'].name)
UserRoleAssignment.add_or_update(role_assignment_db)
role_assignment_db = UserRoleAssignmentDB(
user=self.users['trace_view'].name,
role=self.roles['trace_view'].name)
UserRoleAssignment.add_or_update(role_assignment_db)
def test_get_all_no_permissions(self):
user_db = self.users['no_permissions']
self.use_user(user_db)
resp = self.app.get('/v1/traces', expect_errors=True)
expected_msg = ('User "no_permissions" doesn\'t have required permission "trace_list"')
self.assertEqual(resp.status_code, httplib.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def test_get_one_no_permissions(self):
user_db = self.users['no_permissions']
self.use_user(user_db)
trace_id = self.models['traces']['trace_for_test_enforce.yaml'].id
trace_uid = self.models['traces']['trace_for_test_enforce.yaml'].get_uid()
resp = self.app.get('/v1/traces/%s' % (trace_id), expect_errors=True)
expected_msg = ('User "no_permissions" doesn\'t have required permission "trace_view"'
' on resource "%s"' % (trace_uid))
self.assertEqual(resp.status_code, httplib.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def test_get_all_permission_success_get_one_no_permission_failure(self):
user_db = self.users['trace_list']
self.use_user(user_db)
# trace_list permission, but no trace_view permission
resp = self.app.get('/v1/traces')
self.assertEqual(resp.status_code, httplib.OK)
self.assertEqual(len(resp.json), 3)
trace_id = self.models['traces']['trace_for_test_enforce.yaml'].id
trace_uid = self.models['traces']['trace_for_test_enforce.yaml'].get_uid()
resp = self.app.get('/v1/traces/%s' % (trace_id), expect_errors=True)
expected_msg = ('User "trace_list" doesn\'t have required permission "trace_view"'
' on resource "%s"' % (trace_uid))
self.assertEqual(resp.status_code, httplib.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def test_get_one_permission_success_get_all_no_permission_failure(self):
user_db = self.users['trace_view']
self.use_user(user_db)
# trace_view permission, but no trace_list permission
trace_id = self.models['traces']['trace_for_test_enforce.yaml'].id
trace_uid = self.models['traces']['trace_for_test_enforce.yaml'].get_uid()
resp = self.app.get('/v1/traces/%s' % (trace_id))
self.assertEqual(resp.status_code, httplib.OK)
self.assertEqual(resp.json['uid'], trace_uid)
resp = self.app.get('/v1/traces', expect_errors=True)
expected_msg = ('User "trace_view" doesn\'t have required permission "trace_list"')
self.assertEqual(resp.status_code, httplib.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def setUpClass(cls):
super(PolicyTest, cls).setUpClass()
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
class ActionViewsControllerRBACTestCase(
APIControllerWithRBACTestCase,
APIControllerWithIncludeAndExcludeFilterTestCase):
# Attributes used by APIControllerWithIncludeAndExcludeFilterTestCase
get_all_path = '/v1/actions/views/overview'
controller_cls = OverviewController
include_attribute_field_name = 'entry_point'
exclude_attribute_field_name = 'parameters'
rbac_enabled = True
fixtures_loader = FixturesLoader()
def setUp(self):
super(ActionViewsControllerRBACTestCase, self).setUp()
self.models = self.fixtures_loader.save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_FIXTURES)
file_name = 'a1.yaml'
ActionViewsControllerRBACTestCase.ACTION_1 = self.fixtures_loader.load_fixtures(
fixtures_pack=FIXTURES_PACK,
fixtures_dict={'actions': [file_name]})['actions'][file_name]
file_name = 'a2.yaml'
ActionViewsControllerRBACTestCase.ACTION_1 = self.fixtures_loader.load_fixtures(
fixtures_pack=FIXTURES_PACK,
fixtures_dict={'actions': [file_name]})['actions'][file_name]
# Insert mock users, roles and assignments
# Users
user_2_db = UserDB(name='action_view_a1')
user_2_db = User.add_or_update(user_2_db)
self.users['action_view_a1'] = user_2_db
# Roles
# action_view on a1
action_uid = self.models['actions']['a1.yaml'].get_uid()
grant_db = PermissionGrantDB(
resource_uid=action_uid,
resource_type=ResourceType.ACTION,
permission_types=[PermissionType.ACTION_VIEW])
grant_db = PermissionGrant.add_or_update(grant_db)
permission_grants = [str(grant_db.id)]
role_1_db = RoleDB(name='action_view_a1',
permission_grants=permission_grants)
role_1_db = Role.add_or_update(role_1_db)
self.roles['action_view_a1'] = role_1_db
# Role assignments
role_assignment_db = UserRoleAssignmentDB(
user=self.users['action_view_a1'].name,
role=self.roles['action_view_a1'].name,
source='assignments/%s.yaml' % self.users['action_view_a1'].name)
UserRoleAssignment.add_or_update(role_assignment_db)
def test_get_entry_point_view_no_permission(self):
user_db = self.users['no_permissions']
self.use_user(user_db)
action_id = self.models['actions']['a1.yaml'].id
action_uid = self.models['actions']['a1.yaml'].get_uid()
resp = self.app.get('/v1/actions/views/entry_point/%s' % (action_id),
expect_errors=True)
expected_msg = (
'User "no_permissions" doesn\'t have required permission "action_view"'
' on resource "%s"' % (action_uid))
self.assertEqual(resp.status_code, http_client.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
@mock.patch.object(content_utils, 'get_entry_point_abs_path',
mock.MagicMock(return_value='/path/to/file'))
@mock.patch(mock_open_name,
mock.mock_open(read_data='file content'),
create=True)
def test_get_entry_point_view_success(self):
user_db = self.users['action_view_a1']
self.use_user(user_db)
# action_view on a1, but no permissions on a2
action_id = self.models['actions']['a1.yaml'].id
resp = self.app.get('/v1/actions/views/entry_point/%s' % (action_id))
self.assertEqual(resp.status_code, http_client.OK)
action_id = self.models['actions']['a2.yaml'].id
action_uid = self.models['actions']['a2.yaml'].get_uid()
resp = self.app.get('/v1/actions/views/entry_point/%s' % (action_id),
expect_errors=True)
expected_msg = (
'User "action_view_a1" doesn\'t have required permission "action_view"'
' on resource "%s"' % (action_uid))
self.assertEqual(resp.status_code, http_client.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def test_get_parameters_view_no_permission(self):
user_db = self.users['no_permissions']
self.use_user(user_db)
action_id = self.models['actions']['a1.yaml'].id
action_uid = self.models['actions']['a1.yaml'].get_uid()
resp = self.app.get('/v1/actions/views/parameters/%s' % (action_id),
expect_errors=True)
expected_msg = (
'User "no_permissions" doesn\'t have required permission "action_view"'
' on resource "%s"' % (action_uid))
self.assertEqual(resp.status_code, http_client.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def test_get_parameters_view_success(self):
user_db = self.users['action_view_a1']
self.use_user(user_db)
# action_view on a1, but no permissions on a2
action_id = self.models['actions']['a1.yaml'].id
resp = self.app.get('/v1/actions/views/parameters/%s' % (action_id))
self.assertEqual(resp.status_code, http_client.OK)
action_id = self.models['actions']['a2.yaml'].id
action_uid = self.models['actions']['a2.yaml'].get_uid()
resp = self.app.get('/v1/actions/views/parameters/%s' % (action_id),
expect_errors=True)
expected_msg = (
'User "action_view_a1" doesn\'t have required permission "action_view"'
' on resource "%s"' % (action_uid))
self.assertEqual(resp.status_code, http_client.FORBIDDEN)
self.assertEqual(resp.json['faultstring'], expected_msg)
def _insert_mock_models(self):
action_ids = [
action['id'] for action in self.models['actions'].values()
]
return action_ids
'workflow_v2_many_workflows.yaml'
],
'actions': [
'workbook_v2.yaml',
'workbook_v2_many_workflows.yaml',
'workbook_v2_many_workflows_no_default.yaml',
'workflow_v2.yaml',
'workflow_v2_many_workflows.yaml',
'workbook_v2_name_mismatch.yaml',
'workflow_v2_name_mismatch.yaml',
'local.yaml'
]
}
PACK = 'generic'
LOADER = FixturesLoader()
FIXTURES = LOADER.load_fixtures(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
MISTRAL_EXECUTION = {'id': str(uuid.uuid4()), 'state': 'RUNNING', 'workflow_name': None}
# Workbook with a single workflow
WB1_YAML_FILE_NAME = TEST_FIXTURES['workflows'][0]
WB1_YAML_FILE_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WB1_YAML_FILE_NAME)
WB1_SPEC = FIXTURES['workflows'][WB1_YAML_FILE_NAME]
WB1_YAML = yaml.safe_dump(WB1_SPEC, default_flow_style=False)
WB1_NAME = '%s.%s' % (PACK, WB1_YAML_FILE_NAME.replace('.yaml', ''))
WB1 = workbooks.Workbook(None, {'name': WB1_NAME, 'definition': WB1_YAML})
WB1_OLD = workbooks.Workbook(None, {'name': WB1_NAME, 'definition': ''})
WB1_EXEC = copy.deepcopy(MISTRAL_EXECUTION)
WB1_EXEC['workflow_name'] = WB1_NAME
def setUpClass(cls):
super(PolicyTestCase, cls).setUpClass()
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
WB_PRE_XFORM_FILE = 'wb_pre_xform.yaml'
WB_POST_XFORM_FILE = 'wb_post_xform.yaml'
WF_PRE_XFORM_FILE = 'wf_pre_xform.yaml'
WF_POST_XFORM_FILE = 'wf_post_xform.yaml'
TEST_FIXTURES = {
'workflows': [
WB_PRE_XFORM_FILE,
WB_POST_XFORM_FILE,
WF_PRE_XFORM_FILE,
WF_POST_XFORM_FILE
],
'actions': ['local.yaml']
}
PACK = 'generic'
LOADER = FixturesLoader()
FIXTURES = LOADER.load_fixtures(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
WB_PRE_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WB_PRE_XFORM_FILE)
WB_PRE_XFORM_DEF = FIXTURES['workflows'][WB_PRE_XFORM_FILE]
WB_POST_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WB_POST_XFORM_FILE)
WB_POST_XFORM_DEF = FIXTURES['workflows'][WB_POST_XFORM_FILE]
WF_PRE_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_PRE_XFORM_FILE)
WF_PRE_XFORM_DEF = FIXTURES['workflows'][WF_PRE_XFORM_FILE]
WF_POST_XFORM_PATH = LOADER.get_fixture_file_path_abs(PACK, 'workflows', WF_POST_XFORM_FILE)
WF_POST_XFORM_DEF = FIXTURES['workflows'][WF_POST_XFORM_FILE]
def _read_file_content(path):
with open(path, 'r') as f:
return f.read()