def _setup_sample_triggers(self, names=['st2.test.trigger1', 'st2.test.trigger2',
'st2.test.trigger3', 'st2.test.trigger4']):
trigger_dbs = []
for name in names:
trigtype = None
try:
trigtype = TriggerTypeDB(pack='dummy_pack_1', name=name, description='',
payload_schema={}, parameters_schema={})
try:
trigtype = TriggerType.get_by_name(name)
except:
trigtype = TriggerType.add_or_update(trigtype)
except NotUniqueError:
pass
created = TriggerDB(pack='dummy_pack_1', name=name, description='',
type=trigtype.get_reference().ref)
if name in ['st2.test.trigger4']:
created.parameters = {'url': 'sample'}
else:
created.parameters = {}
created = Trigger.add_or_update(created)
trigger_dbs.append(created)
return trigger_dbs
def _setup_sample_triggers(self,
names=[
'st2.test.trigger1', 'st2.test.trigger2',
'st2.test.trigger3', 'st2.test.trigger4'
]):
trigger_dbs = []
for name in names:
trigtype = None
try:
trigtype = TriggerTypeDB(pack='dummy_pack_1',
name=name,
description='',
payload_schema={},
parameters_schema={})
try:
trigtype = TriggerType.get_by_name(name)
except:
trigtype = TriggerType.add_or_update(trigtype)
except NotUniqueError:
pass
created = TriggerDB(pack='dummy_pack_1',
name=name,
description='',
type=trigtype.get_reference().ref)
if name in ['st2.test.trigger4']:
created.parameters = {'url': 'sample'}
else:
created.parameters = {}
created = Trigger.add_or_update(created)
trigger_dbs.append(created)
return trigger_dbs
def setUpClass(cls):
super(ReferenceTest, cls).setUpClass()
trigger = TriggerDB()
trigger.name = 'trigger-1'
trigger.pack = 'dummy_pack_1'
cls.__model = Trigger.add_or_update(trigger)
cls.__ref = {'id': str(cls.__model.id), 'name': cls.__model.name}
def test_get_trigger_db_given_type_and_params(self):
# Add dummy triggers
trigger_1 = TriggerDB(pack='testpack', name='testtrigger1', type='testpack.testtrigger1')
trigger_2 = TriggerDB(pack='testpack', name='testtrigger2', type='testpack.testtrigger2')
trigger_3 = TriggerDB(pack='testpack', name='testtrigger3', type='testpack.testtrigger3')
trigger_4 = TriggerDB(pack='testpack', name='testtrigger4', type='testpack.testtrigger4',
parameters={'ponies': 'unicorn'})
Trigger.add_or_update(trigger_1)
Trigger.add_or_update(trigger_2)
Trigger.add_or_update(trigger_3)
Trigger.add_or_update(trigger_4)
# Trigger with no parameters, parameters={} in db
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type,
parameters={})
self.assertEqual(trigger_db, trigger_1)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type,
parameters=None)
self.assertEqual(trigger_db, trigger_1)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type,
parameters={'fo': 'bar'})
self.assertEqual(trigger_db, None)
# Trigger with no parameters, no parameters attribute in the db
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type,
parameters={})
self.assertEqual(trigger_db, trigger_2)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type,
parameters=None)
self.assertEqual(trigger_db, trigger_2)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type,
parameters={'fo': 'bar'})
self.assertEqual(trigger_db, None)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_3.type,
parameters={})
self.assertEqual(trigger_db, trigger_3)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_3.type,
parameters=None)
self.assertEqual(trigger_db, trigger_3)
# Trigger with parameters
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_4.type,
parameters=trigger_4.parameters)
self.assertEqual(trigger_db, trigger_4)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_4.type,
parameters=None)
self.assertEqual(trigger_db, None)
def setUpClass(cls):
super(ReferenceTest, cls).setUpClass()
trigger = TriggerDB()
trigger.name = 'trigger-1'
trigger.pack = 'dummy_pack_1'
cls.__model = Trigger.add_or_update(trigger)
cls.__ref = {'id': str(cls.__model.id),
'name': cls.__model.name}
def test_trigger_cud_event_handlers(self):
trigger_id = "57861fcb0640fd1524e577c0"
file_path = os.path.join(RESOURCES_DIR, "test_sensor.py")
trigger_types = ["trigger1", "trigger2"]
parent_args = ["--config-file", TESTS_CONFIG_PATH]
wrapper = SensorWrapper(
pack="core",
file_path=file_path,
class_name="TestSensor",
trigger_types=trigger_types,
parent_args=parent_args,
)
self.assertEqual(wrapper._trigger_names, {})
wrapper._sensor_instance.add_trigger = mock.Mock()
wrapper._sensor_instance.update_trigger = mock.Mock()
wrapper._sensor_instance.remove_trigger = mock.Mock()
# Call create handler with a trigger which refers to this sensor
self.assertEqual(wrapper._sensor_instance.add_trigger.call_count, 0)
trigger = TriggerDB(id=trigger_id,
name="test",
pack="dummy",
type=trigger_types[0])
wrapper._handle_create_trigger(trigger=trigger)
self.assertEqual(wrapper._trigger_names, {trigger_id: trigger})
self.assertEqual(wrapper._sensor_instance.add_trigger.call_count, 1)
# Validate that update handler updates the trigger_names
self.assertEqual(wrapper._sensor_instance.update_trigger.call_count, 0)
trigger = TriggerDB(id=trigger_id,
name="test",
pack="dummy",
type=trigger_types[0])
wrapper._handle_update_trigger(trigger=trigger)
self.assertEqual(wrapper._trigger_names, {trigger_id: trigger})
self.assertEqual(wrapper._sensor_instance.update_trigger.call_count, 1)
# Validate that delete handler deletes the trigger from trigger_names
self.assertEqual(wrapper._sensor_instance.remove_trigger.call_count, 0)
trigger = TriggerDB(id=trigger_id,
name="test",
pack="dummy",
type=trigger_types[0])
wrapper._handle_delete_trigger(trigger=trigger)
self.assertEqual(wrapper._trigger_names, {})
self.assertEqual(wrapper._sensor_instance.remove_trigger.call_count, 1)
def test_timer_trace_tag_creation(self, dispatch_mock):
timer = St2Timer()
timer._scheduler = mock.Mock()
timer._trigger_watcher = mock.Mock()
# Add a dummy timer Trigger object
type_ = list(TIMER_TRIGGER_TYPES.keys())[0]
parameters = {'unit': 'seconds', 'delta': 1}
trigger_db = TriggerDB(name='test_trigger_1', pack='dummy', type=type_,
parameters=parameters)
timer.add_trigger(trigger_db)
timer._emit_trigger_instance(trigger=trigger_db.to_serializable_dict())
self.assertEqual(dispatch_mock.call_args[1]['trace_context'].trace_tag,
'%s-%s' % (TIMER_TRIGGER_TYPES[type_]['name'], trigger_db.name))
def setUp(self):
super(ContainerUtilsTest, self).setUp()
# Insert mock TriggerDB
trigger_db = TriggerDB(name='name1', pack='pack1', type='type1',
parameters={'a': 1, 'b': '2', 'c': 'foo'})
self.trigger_db = Trigger.add_or_update(trigger_db)
def _create_save_trigger(triggertype):
created = TriggerDB(pack='dummy_pack_1',
name='trigger-1',
description='',
type=triggertype.get_reference().ref,
parameters={})
return Trigger.add_or_update(created)
def test_existing_rules_are_loaded_on_start(self):
# Assert that we dispatch message for every existing Trigger object
St2Timer._handle_create_trigger = mock.Mock()
timer = St2Timer()
timer._scheduler = mock.Mock()
timer._trigger_watcher.run = mock.Mock()
# Verify there are no Trigger and TriggerType in the db wh:w
self.assertItemsEqual(Trigger.get_all(), [])
self.assertItemsEqual(TriggerType.get_all(), [])
# Add a dummy timer Trigger object
type_ = list(TIMER_TRIGGER_TYPES.keys())[0]
parameters = {'unit': 'seconds', 'delta': 1000}
trigger_db = TriggerDB(id=bson.ObjectId(),
name='test_trigger_1',
pack='dummy',
type=type_,
parameters=parameters)
trigger_db = Trigger.add_or_update(trigger_db)
# Verify object has been added
self.assertEqual(len(Trigger.get_all()), 1)
timer.start()
timer._trigger_watcher._load_thread.wait()
# Verify handlers are called
timer._handle_create_trigger.assert_called_with(trigger_db)
def _get_trigger_instance_db_from_file(self, file_path):
data = self._meta_loader.load(file_path=file_path)
instance = TriggerInstanceDB(**data)
trigger_ref = ResourceReference.from_string_reference(instance['trigger'])
trigger_db = TriggerDB(pack=trigger_ref.pack, name=trigger_ref.name, type=trigger_ref.ref)
return instance, trigger_db
def _setup_sample_triggers(
self, names=["st2.test.trigger1", "st2.test.trigger2", "st2.test.trigger3", "st2.test.trigger4"]
):
trigger_dbs = []
for name in names:
trigtype = None
try:
trigtype = TriggerTypeDB()
trigtype.pack = "dummy_pack_1"
trigtype.name = name
trigtype.description = ""
trigtype.payload_schema = {}
trigtype.parameters_schema = {}
try:
trigtype = TriggerType.get_by_name(name)
except:
trigtype = TriggerType.add_or_update(trigtype)
except NotUniqueError:
pass
created = TriggerDB()
created.name = name
created.pack = "dummy_pack_1"
created.description = ""
created.type = trigtype.get_reference().ref
if name in ["st2.test.trigger4"]:
created.parameters = {"url": "sample"}
else:
created.parameters = {}
created = Trigger.add_or_update(created)
trigger_dbs.append(created)
return trigger_dbs
def test_timer_trace_tag_creation(self, dispatch_mock):
timer = St2Timer()
timer._scheduler = mock.Mock()
timer._trigger_watcher = mock.Mock()
# Add a dummy timer Trigger object
type_ = list(TIMER_TRIGGER_TYPES.keys())[0]
parameters = {'unit': 'seconds', 'delta': 1}
trigger_db = TriggerDB(name='test_trigger_1',
pack='dummy',
type=type_,
parameters=parameters)
timer.add_trigger(trigger_db)
timer._emit_trigger_instance(trigger=trigger_db.to_serializable_dict())
self.assertEqual(
dispatch_mock.call_args[1]['trace_context'].trace_tag,
'%s-%s' % (TIMER_TRIGGER_TYPES[type_]['name'], trigger_db.name))
def _create_save_trigger(triggertype):
created = TriggerDB(
pack="dummy_pack_1",
name="trigger-1",
description="",
type=triggertype.get_reference().ref,
parameters={},
)
return Trigger.add_or_update(created)
def test_get_uid(self):
pack_db = PackDB(ref='ma_pack')
self.assertEqual(pack_db.get_uid(), 'pack:ma_pack')
sensor_type_db = SensorTypeDB(name='sname', pack='spack')
self.assertEqual(sensor_type_db.get_uid(), 'sensor_type:spack:sname')
action_db = ActionDB(name='aname', pack='apack', runner_type={})
self.assertEqual(action_db.get_uid(), 'action:apack:aname')
rule_db = RuleDB(name='rname', pack='rpack')
self.assertEqual(rule_db.get_uid(), 'rule:rpack:rname')
trigger_type_db = TriggerTypeDB(name='ttname', pack='ttpack')
self.assertEqual(trigger_type_db.get_uid(), 'trigger_type:ttpack:ttname')
trigger_db = TriggerDB(name='tname', pack='tpack')
self.assertTrue(trigger_db.get_uid().startswith('trigger:tpack:tname:'))
def _create_save_trigger(triggertype):
created = TriggerDB()
created.name = 'trigger-1'
created.pack = 'dummy_pack_1'
created.description = ''
created.type = triggertype.get_reference().ref
created.parameters = {}
return Trigger.add_or_update(created)
def _setup_sample_triggers(
self,
names=[
"st2.test.trigger1",
"st2.test.trigger2",
"st2.test.trigger3",
"st2.test.trigger4",
],
):
trigger_dbs = []
for name in names:
trigtype = None
try:
trigtype = TriggerTypeDB(
pack="dummy_pack_1",
name=name,
description="",
payload_schema={},
parameters_schema={},
)
try:
trigtype = TriggerType.get_by_name(name)
except:
trigtype = TriggerType.add_or_update(trigtype)
except NotUniqueError:
pass
created = TriggerDB(
pack="dummy_pack_1",
name=name,
description="",
type=trigtype.get_reference().ref,
)
if name in ["st2.test.trigger4"]:
created.parameters = {"url": "sample"}
else:
created.parameters = {}
created = Trigger.add_or_update(created)
trigger_dbs.append(created)
return trigger_dbs
def test_timer_trace_tag_creation(self, dispatch_mock):
timer = St2Timer()
timer._scheduler = mock.Mock()
timer._trigger_watcher = mock.Mock()
# Add a dummy timer Trigger object
type_ = list(TIMER_TRIGGER_TYPES.keys())[0]
parameters = {"unit": "seconds", "delta": 1}
trigger_db = TriggerDB(name="test_trigger_1",
pack="dummy",
type=type_,
parameters=parameters)
timer.add_trigger(trigger_db)
timer._emit_trigger_instance(trigger=trigger_db.to_serializable_dict())
self.assertEqual(
dispatch_mock.call_args[1]["trace_context"].trace_tag,
"%s-%s" % (TIMER_TRIGGER_TYPES[type_]["name"], trigger_db.name),
)
def _setup_sample_trigger(self, name):
trigtype = TriggerTypeDB(name=name,
pack='dummy_pack_1',
payload_schema={},
parameters_schema={})
TriggerType.add_or_update(trigtype)
created = TriggerDB(name=name,
pack='dummy_pack_1',
type=trigtype.get_reference().ref,
parameters={})
Trigger.add_or_update(created)
def test_get_uid(self):
pack_db = PackDB(ref='ma_pack')
self.assertEqual(pack_db.get_uid(), 'pack:ma_pack')
sensor_type_db = SensorTypeDB(name='sname', pack='spack')
self.assertEqual(sensor_type_db.get_uid(), 'sensor_type:spack:sname')
action_db = ActionDB(name='aname', pack='apack', runner_type={})
self.assertEqual(action_db.get_uid(), 'action:apack:aname')
rule_db = RuleDB(name='rname', pack='rpack')
self.assertEqual(rule_db.get_uid(), 'rule:rpack:rname')
trigger_type_db = TriggerTypeDB(name='ttname', pack='ttpack')
self.assertEqual(trigger_type_db.get_uid(), 'trigger_type:ttpack:ttname')
trigger_db = TriggerDB(name='tname', pack='tpack')
self.assertTrue(trigger_db.get_uid().startswith('trigger:tpack:tname:'))
# Verify that same set of parameters always results in the same hash
parameters = {'a': 1, 'b': 2, 'c': [1, 2, 3], 'd': {'g': 1, 'h': 2}, 'b': u'unicode'}
paramers_hash = json.dumps(parameters, sort_keys=True)
paramers_hash = hashlib.md5(paramers_hash).hexdigest()
parameters = {'a': 1, 'b': 2, 'c': [1, 2, 3], 'b': u'unicode', 'd': {'g': 1, 'h': 2}}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
parameters = {'c': [1, 2, 3], 'b': u'unicode', 'd': {'h': 2, 'g': 1}, 'a': 1}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
parameters = {'b': u'unicode', 'c': [1, 2, 3], 'd': {'h': 2, 'g': 1}, 'a': 1}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
parameters = OrderedDict({'c': [1, 2, 3], 'b': u'unicode', 'd': {'h': 2, 'g': 1}, 'a': 1})
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
def evaluate(self):
"""
Evaluate trigger instance against the rule.
:return: ``True`` if the rule matches, ``False`` otherwise.
:rtype: ``boolean``
"""
rule_db = self._get_rule_db_from_file(file_path=self._rule_file_path)
trigger_instance_db = \
self._get_trigger_instance_db_from_file(file_path=self._trigger_instance_file_path)
trigger_ref = ResourceReference.from_string_reference(trigger_instance_db['trigger'])
trigger_db = TriggerDB()
trigger_db.pack = trigger_ref.pack
trigger_db.name = trigger_ref.name
trigger_db.type = trigger_ref.ref
matcher = RulesMatcher(trigger_instance=trigger_instance_db, trigger=trigger_db,
rules=[rule_db])
matching_rules = matcher.get_matching_rules()
return len(matching_rules) >= 1
def _create_save_trigger(triggertype):
created = TriggerDB()
created.name = 'trigger-1'
created.pack = 'dummy_pack_1'
created.description = ''
created.type = triggertype.get_reference().ref
created.parameters = {}
return Trigger.add_or_update(created)
def setUp(self):
super(ContainerUtilsTest, self).setUp()
# Insert mock TriggerDB
trigger_db = TriggerDB(
name="name1",
pack="pack1",
type="type1",
parameters={
"a": 1,
"b": "2",
"c": "foo"
},
)
self.trigger_db = Trigger.add_or_update(trigger_db)
def evaluate(self):
"""
Evaluate trigger instance against the rule.
:return: ``True`` if the rule matches, ``False`` otherwise.
:rtype: ``boolean``
"""
rule_db = self._get_rule_db_from_file(file_path=self._rule_file_path)
trigger_instance_db = \
self._get_trigger_instance_db_from_file(file_path=self._trigger_instance_file_path)
trigger_ref = ResourceReference.from_string_reference(
trigger_instance_db['trigger'])
trigger_db = TriggerDB()
trigger_db.pack = trigger_ref.pack
trigger_db.name = trigger_ref.name
trigger_db.type = trigger_ref.ref
matcher = RulesMatcher(trigger_instance=trigger_instance_db,
trigger=trigger_db,
rules=[rule_db])
matching_rules = matcher.get_matching_rules()
return len(matching_rules) >= 1
def _setup_sample_trigger(self, name):
trigtype = TriggerTypeDB()
trigtype.name = name
trigtype.pack = 'dummy_pack_1'
trigtype.description = ''
trigtype.payload_schema = {}
trigtype.parameters_schema = {}
TriggerType.add_or_update(trigtype)
created = TriggerDB()
created.name = name
created.pack = 'dummy_pack_1'
created.description = ''
created.type = trigtype.get_reference().ref
created.parameters = {}
Trigger.add_or_update(created)
def test_get_uid(self):
pack_db = PackDB(ref='ma_pack')
self.assertEqual(pack_db.get_uid(), 'pack:ma_pack')
self.assertTrue(pack_db.has_valid_uid())
sensor_type_db = SensorTypeDB(name='sname', pack='spack')
self.assertEqual(sensor_type_db.get_uid(), 'sensor_type:spack:sname')
self.assertTrue(sensor_type_db.has_valid_uid())
action_db = ActionDB(name='aname', pack='apack', runner_type={})
self.assertEqual(action_db.get_uid(), 'action:apack:aname')
self.assertTrue(action_db.has_valid_uid())
rule_db = RuleDB(name='rname', pack='rpack')
self.assertEqual(rule_db.get_uid(), 'rule:rpack:rname')
self.assertTrue(rule_db.has_valid_uid())
trigger_type_db = TriggerTypeDB(name='ttname', pack='ttpack')
self.assertEqual(trigger_type_db.get_uid(), 'trigger_type:ttpack:ttname')
self.assertTrue(trigger_type_db.has_valid_uid())
trigger_db = TriggerDB(name='tname', pack='tpack')
self.assertTrue(trigger_db.get_uid().startswith('trigger:tpack:tname:'))
# Verify that same set of parameters always results in the same hash
parameters = {'a': 1, 'b': 'unicode', 'c': [1, 2, 3], 'd': {'g': 1, 'h': 2}}
paramers_hash = json.dumps(parameters, sort_keys=True)
paramers_hash = hashlib.md5(paramers_hash.encode()).hexdigest()
parameters = {'a': 1, 'b': 'unicode', 'c': [1, 2, 3], 'd': {'g': 1, 'h': 2}}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
self.assertTrue(trigger_db.has_valid_uid())
parameters = {'c': [1, 2, 3], 'b': u'unicode', 'd': {'h': 2, 'g': 1}, 'a': 1}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
self.assertTrue(trigger_db.has_valid_uid())
parameters = {'b': u'unicode', 'c': [1, 2, 3], 'd': {'h': 2, 'g': 1}, 'a': 1}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
self.assertTrue(trigger_db.has_valid_uid())
parameters = OrderedDict({'c': [1, 2, 3], 'b': u'unicode', 'd': {'h': 2, 'g': 1}, 'a': 1})
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
self.assertTrue(trigger_db.has_valid_uid())
policy_type_db = PolicyTypeDB(resource_type='action', name='concurrency')
self.assertEqual(policy_type_db.get_uid(), 'policy_type:action:concurrency')
self.assertTrue(policy_type_db.has_valid_uid())
policy_db = PolicyDB(pack='dummy', name='policy1')
self.assertEqual(policy_db.get_uid(), 'policy:dummy:policy1')
api_key_db = ApiKeyDB(key_hash='valid')
self.assertEqual(api_key_db.get_uid(), 'api_key:valid')
self.assertTrue(api_key_db.has_valid_uid())
api_key_db = ApiKeyDB()
self.assertEqual(api_key_db.get_uid(), 'api_key:')
self.assertFalse(api_key_db.has_valid_uid())
def test_get_uid(self):
pack_db = PackDB(ref='ma_pack')
self.assertEqual(pack_db.get_uid(), 'pack:ma_pack')
self.assertTrue(pack_db.has_valid_uid())
sensor_type_db = SensorTypeDB(name='sname', pack='spack')
self.assertEqual(sensor_type_db.get_uid(), 'sensor_type:spack:sname')
self.assertTrue(sensor_type_db.has_valid_uid())
action_db = ActionDB(name='aname', pack='apack', runner_type={})
self.assertEqual(action_db.get_uid(), 'action:apack:aname')
self.assertTrue(action_db.has_valid_uid())
rule_db = RuleDB(name='rname', pack='rpack')
self.assertEqual(rule_db.get_uid(), 'rule:rpack:rname')
self.assertTrue(rule_db.has_valid_uid())
trigger_type_db = TriggerTypeDB(name='ttname', pack='ttpack')
self.assertEqual(trigger_type_db.get_uid(), 'trigger_type:ttpack:ttname')
self.assertTrue(trigger_type_db.has_valid_uid())
trigger_db = TriggerDB(name='tname', pack='tpack')
self.assertTrue(trigger_db.get_uid().startswith('trigger:tpack:tname:'))
# Verify that same set of parameters always results in the same hash
parameters = {'a': 1, 'b': 'unicode', 'c': [1, 2, 3], 'd': {'g': 1, 'h': 2}}
paramers_hash = json.dumps(parameters, sort_keys=True)
paramers_hash = hashlib.md5(paramers_hash.encode()).hexdigest()
parameters = {'a': 1, 'b': 'unicode', 'c': [1, 2, 3], 'd': {'g': 1, 'h': 2}}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
self.assertTrue(trigger_db.has_valid_uid())
parameters = {'c': [1, 2, 3], 'b': u'unicode', 'd': {'h': 2, 'g': 1}, 'a': 1}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
self.assertTrue(trigger_db.has_valid_uid())
parameters = {'b': u'unicode', 'c': [1, 2, 3], 'd': {'h': 2, 'g': 1}, 'a': 1}
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
self.assertTrue(trigger_db.has_valid_uid())
parameters = OrderedDict({'c': [1, 2, 3], 'b': u'unicode', 'd': {'h': 2, 'g': 1}, 'a': 1})
trigger_db = TriggerDB(name='tname', pack='tpack', parameters=parameters)
self.assertEqual(trigger_db.get_uid(), 'trigger:tpack:tname:%s' % (paramers_hash))
self.assertTrue(trigger_db.has_valid_uid())
policy_type_db = PolicyTypeDB(resource_type='action', name='concurrency')
self.assertEqual(policy_type_db.get_uid(), 'policy_type:action:concurrency')
self.assertTrue(policy_type_db.has_valid_uid())
policy_db = PolicyDB(pack='dummy', name='policy1')
self.assertEqual(policy_db.get_uid(), 'policy:dummy:policy1')
api_key_db = ApiKeyDB(key_hash='valid')
self.assertEqual(api_key_db.get_uid(), 'api_key:valid')
self.assertTrue(api_key_db.has_valid_uid())
api_key_db = ApiKeyDB()
self.assertEqual(api_key_db.get_uid(), 'api_key:')
self.assertFalse(api_key_db.has_valid_uid())
ST2_WEBHOOK = {
'trigger': 'git.pr-merged',
'payload': {
'value_str': 'string!',
'value_int': 12345
}
}
WEBHOOK_DATA = {
'value_str': 'test string 1',
'value_int': 987654,
}
# 1. Trigger which references a system webhook trigger type
DUMMY_TRIGGER_DB = TriggerDB(name='pr-merged', pack='git')
DUMMY_TRIGGER_DB.type = list(WEBHOOK_TRIGGER_TYPES.keys())[0]
DUMMY_TRIGGER_API = TriggerAPI.from_model(DUMMY_TRIGGER_DB)
DUMMY_TRIGGER_DICT = vars(DUMMY_TRIGGER_API)
# 2. Custom TriggerType object
DUMMY_TRIGGER_TYPE_DB = TriggerTypeDB(name='pr-merged', pack='git')
DUMMY_TRIGGER_TYPE_DB.payload_schema = {
'type': 'object',
'properties': {
'body': {
'properties': {
'value_str': {
'type': 'string',
# See the License for the specific language governing permissions and
# limitations under the License.
import bson
import copy
import mock
from st2common.models.db.action import ActionDB
from st2common.models.db.rule import RuleDB, ActionExecutionSpecDB
from st2common.models.db.trigger import TriggerDB, TriggerInstanceDB
from st2common.util import reference
from st2common.util import date as date_utils
from st2reactor.rules.filter import RuleFilter
from st2tests import DbTestCase
MOCK_TRIGGER = TriggerDB()
MOCK_TRIGGER.id = bson.ObjectId()
MOCK_TRIGGER.name = 'trigger-test.name'
MOCK_TRIGGER.pack = 'dummy_pack_1'
MOCK_TRIGGER.type = 'system.test'
MOCK_TRIGGER_INSTANCE = TriggerInstanceDB()
MOCK_TRIGGER_INSTANCE.id = bson.ObjectId()
MOCK_TRIGGER_INSTANCE.trigger = MOCK_TRIGGER.get_reference().ref
MOCK_TRIGGER_INSTANCE.payload = {
'p1': 'v1',
'p2': 'preYYYpost',
'bool': True,
'int': 1,
'float': 0.8
}
from __future__ import absolute_import
import bson
import copy
import mock
from st2common.models.db.action import ActionDB
from st2common.models.db.rule import RuleDB, ActionExecutionSpecDB
from st2common.models.db.trigger import TriggerDB, TriggerInstanceDB
from st2common.util import reference
from st2common.util import date as date_utils
from st2reactor.rules.filter import RuleFilter
from st2tests import DbTestCase
MOCK_TRIGGER = TriggerDB(pack='dummy_pack_1', name='trigger-test.name', type='system.test')
MOCK_TRIGGER_INSTANCE = TriggerInstanceDB(
trigger=MOCK_TRIGGER.get_reference().ref,
occurrence_time=date_utils.get_datetime_utc_now(),
payload={
'p1': 'v1',
'p2': 'preYYYpost',
'bool': True,
'int': 1,
'float': 0.8,
'list': ['v1', True, 1],
'recursive_list': [
{
'field_name': "Status",
'to_value': "Approved",
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
from st2common.exceptions.triggers import TriggerDoesNotExistException
from st2common.models.api.rule import RuleAPI
from st2common.models.system.common import ResourceReference
from st2common.models.db.trigger import TriggerDB
from st2common.persistence.trigger import (Trigger, TriggerType)
import st2common.services.triggers as trigger_service
from st2tests.base import CleanDbTestCase
from st2tests.fixturesloader import FixturesLoader
MOCK_TRIGGER = TriggerDB(pack='dummy_pack_1', name='trigger-test.name', parameters={},
type='dummy_pack_1.trigger-type-test.name')
class TriggerServiceTests(CleanDbTestCase):
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.assertTrue(trigger_db_ret_1 is not None)
def test_get_trigger_db_given_type_and_params(self):
# Add dummy triggers
trigger_1 = TriggerDB()
trigger_1.pack = 'testpack'
trigger_1.name = 'testtrigger1'
trigger_1.type = 'testpack.testtrigger1'
trigger_1.parameters = {}
trigger_2 = TriggerDB()
trigger_2.pack = 'testpack'
trigger_2.name = 'testtrigger2'
trigger_2.type = 'testpack.testtrigger2'
trigger_2.parameters = None
trigger_3 = TriggerDB()
trigger_3.pack = 'testpack'
trigger_3.name = 'testtrigger3'
trigger_3.type = 'testpack.testtrigger3'
trigger_4 = TriggerDB()
trigger_4.pack = 'testpack'
trigger_4.name = 'testtrigger4'
trigger_4.type = 'testpack.testtrigger4'
trigger_4.parameters = {'ponies': 'unicorn'}
Trigger.add_or_update(trigger_1)
Trigger.add_or_update(trigger_2)
Trigger.add_or_update(trigger_3)
Trigger.add_or_update(trigger_4)
# Trigger with no parameters, parameters={} in db
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type,
parameters={})
self.assertEqual(trigger_db, trigger_1)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type,
parameters=None)
self.assertEqual(trigger_db, trigger_1)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type,
parameters={'fo': 'bar'})
self.assertEqual(trigger_db, None)
# Trigger with no parameters, no parameters attribute in the db
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type,
parameters={})
self.assertEqual(trigger_db, trigger_2)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type,
parameters=None)
self.assertEqual(trigger_db, trigger_2)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type,
parameters={'fo': 'bar'})
self.assertEqual(trigger_db, None)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_3.type,
parameters={})
self.assertEqual(trigger_db, trigger_3)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_3.type,
parameters=None)
self.assertEqual(trigger_db, trigger_3)
# Trigger with parameters
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_4.type,
parameters=trigger_4.parameters)
self.assertEqual(trigger_db, trigger_4)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_4.type,
parameters=None)
self.assertEqual(trigger_db, None)
ST2_WEBHOOK = {
"trigger": "git.pr-merged",
"payload": {
"value_str": "string!",
"value_int": 12345
},
}
WEBHOOK_DATA = {
"value_str": "test string 1",
"value_int": 987654,
}
# 1. Trigger which references a system webhook trigger type
DUMMY_TRIGGER_DB = TriggerDB(name="pr-merged", pack="git")
DUMMY_TRIGGER_DB.type = list(WEBHOOK_TRIGGER_TYPES.keys())[0]
DUMMY_TRIGGER_API = TriggerAPI.from_model(DUMMY_TRIGGER_DB)
DUMMY_TRIGGER_DICT = vars(DUMMY_TRIGGER_API)
# 2. Custom TriggerType object
DUMMY_TRIGGER_TYPE_DB = TriggerTypeDB(name="pr-merged", pack="git")
DUMMY_TRIGGER_TYPE_DB.payload_schema = {
"type": "object",
"properties": {
"body": {
"properties": {
"value_str": {
"type": "string",
"required": True
def get_webhook_trigger(name, url):
trigger = TriggerDB(name=name, pack='test')
trigger.type = list(WEBHOOK_TRIGGER_TYPES.keys())[0]
trigger.parameters = {'url': url}
return trigger
# limitations under the License.
from __future__ import absolute_import
from st2common.exceptions.triggers import TriggerDoesNotExistException
from st2common.models.api.rule import RuleAPI
from st2common.models.system.common import ResourceReference
from st2common.models.db.trigger import TriggerDB
from st2common.persistence.trigger import Trigger, TriggerType
import st2common.services.triggers as trigger_service
from st2tests.base import CleanDbTestCase
from st2tests.fixturesloader import FixturesLoader
MOCK_TRIGGER = TriggerDB(
pack="dummy_pack_1",
name="trigger-test.name",
parameters={},
type="dummy_pack_1.trigger-type-test.name",
)
class TriggerServiceTests(CleanDbTestCase):
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(
def test_get_trigger_db_given_type_and_params(self):
# Add dummy triggers
trigger_1 = TriggerDB(pack="testpack",
name="testtrigger1",
type="testpack.testtrigger1")
trigger_2 = TriggerDB(pack="testpack",
name="testtrigger2",
type="testpack.testtrigger2")
trigger_3 = TriggerDB(pack="testpack",
name="testtrigger3",
type="testpack.testtrigger3")
trigger_4 = TriggerDB(
pack="testpack",
name="testtrigger4",
type="testpack.testtrigger4",
parameters={"ponies": "unicorn"},
)
Trigger.add_or_update(trigger_1)
Trigger.add_or_update(trigger_2)
Trigger.add_or_update(trigger_3)
Trigger.add_or_update(trigger_4)
# Trigger with no parameters, parameters={} in db
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_1.type, parameters={})
self.assertEqual(trigger_db, trigger_1)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_1.type, parameters=None)
self.assertEqual(trigger_db, trigger_1)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_1.type, parameters={"fo": "bar"})
self.assertEqual(trigger_db, None)
# Trigger with no parameters, no parameters attribute in the db
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_2.type, parameters={})
self.assertEqual(trigger_db, trigger_2)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_2.type, parameters=None)
self.assertEqual(trigger_db, trigger_2)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_2.type, parameters={"fo": "bar"})
self.assertEqual(trigger_db, None)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_3.type, parameters={})
self.assertEqual(trigger_db, trigger_3)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_3.type, parameters=None)
self.assertEqual(trigger_db, trigger_3)
# Trigger with parameters
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_4.type, parameters=trigger_4.parameters)
self.assertEqual(trigger_db, trigger_4)
trigger_db = trigger_service.get_trigger_db_given_type_and_params(
type=trigger_4.type, parameters=None)
self.assertEqual(trigger_db, None)
http_client = six.moves.http_client
WEBHOOK_1 = {
'action': 'closed',
'pull_request': {
'merged': True
}
}
ST2_WEBHOOK = {
'trigger': 'foo.bar',
'payload': {'ponies': 'unicorns'}
}
DUMMY_TRIGGER = TriggerDB(name='pr-merged', pack='git')
DUMMY_TRIGGER.type = WEBHOOK_TRIGGER_TYPES.keys()[0]
class TestWebhooksController(FunctionalTest):
@mock.patch.object(TriggerInstancePublisher, 'publish_trigger', mock.MagicMock(
return_value=True))
@mock.patch.object(WebhooksController, '_is_valid_hook', mock.MagicMock(
return_value=True))
@mock.patch.object(HooksHolder, 'get_triggers_for_hook', mock.MagicMock(
return_value=[DUMMY_TRIGGER]))
@mock.patch('st2common.transport.reactor.TriggerDispatcher.dispatch')
def test_post(self, dispatch_mock):
post_resp = self.__do_post('git', WEBHOOK_1, expect_errors=False)
self.assertEqual(post_resp.status_int, http_client.ACCEPTED)
# limitations under the License.
import bson
import copy
import mock
from st2common.models.db.action import ActionDB
from st2common.models.db.rule import RuleDB, ActionExecutionSpecDB
from st2common.models.db.trigger import TriggerDB, TriggerInstanceDB
from st2common.util import reference
from st2common.util import date as date_utils
from st2reactor.rules.filter import RuleFilter
from st2tests import DbTestCase
MOCK_TRIGGER = TriggerDB()
MOCK_TRIGGER.id = bson.ObjectId()
MOCK_TRIGGER.name = "trigger-test.name"
MOCK_TRIGGER.pack = "dummy_pack_1"
MOCK_TRIGGER.type = "system.test"
MOCK_TRIGGER_INSTANCE = TriggerInstanceDB()
MOCK_TRIGGER_INSTANCE.id = bson.ObjectId()
MOCK_TRIGGER_INSTANCE.trigger = MOCK_TRIGGER.get_reference().ref
MOCK_TRIGGER_INSTANCE.payload = {"p1": "v1", "p2": "preYYYpost", "bool": True, "int": 1, "float": 0.8}
MOCK_TRIGGER_INSTANCE.occurrence_time = date_utils.get_datetime_utc_now()
MOCK_ACTION = ActionDB()
MOCK_ACTION.id = bson.ObjectId()
MOCK_ACTION.name = "action-test-1.name"
# limitations under the License.
import bson
import copy
import mock
from st2common.models.db.action import ActionDB
from st2common.models.db.rule import RuleDB, ActionExecutionSpecDB
from st2common.models.db.trigger import TriggerDB, TriggerInstanceDB
from st2common.util import reference
from st2common.util import date as date_utils
from st2reactor.rules.filter import RuleFilter
from st2tests import DbTestCase
MOCK_TRIGGER = TriggerDB(pack='dummy_pack_1', name='trigger-test.name', type='system.test')
MOCK_TRIGGER_INSTANCE = TriggerInstanceDB(trigger=MOCK_TRIGGER.get_reference().ref,
occurrence_time=date_utils.get_datetime_utc_now(),
payload={
'p1': 'v1',
'p2': 'preYYYpost',
'bool': True,
'int': 1,
'float': 0.8})
MOCK_ACTION = ActionDB(id=bson.ObjectId(), pack='wolfpack', name='action-test-1.name')
MOCK_RULE_1 = RuleDB(id=bson.ObjectId(), pack='wolfpack', name='some1',
trigger=reference.get_str_resource_ref_from_model(MOCK_TRIGGER),
criteria={}, action=ActionExecutionSpecDB(ref="somepack.someaction"))
def _get_trigger_with_parameters(self):
"""
All TriggerDB that has a parameter.
"""
return TriggerDB.objects(Q(parameters__exists=True) & Q(parameters__nin=[{}]))
def test_get_uid(self):
pack_db = PackDB(ref='ma_pack')
self.assertEqual(pack_db.get_uid(), 'pack:ma_pack')
sensor_type_db = SensorTypeDB(name='sname', pack='spack')
self.assertEqual(sensor_type_db.get_uid(), 'sensor_type:spack:sname')
action_db = ActionDB(name='aname', pack='apack', runner_type={})
self.assertEqual(action_db.get_uid(), 'action:apack:aname')
rule_db = RuleDB(name='rname', pack='rpack')
self.assertEqual(rule_db.get_uid(), 'rule:rpack:rname')
trigger_type_db = TriggerTypeDB(name='ttname', pack='ttpack')
self.assertEqual(trigger_type_db.get_uid(),
'trigger_type:ttpack:ttname')
trigger_db = TriggerDB(name='tname', pack='tpack')
self.assertTrue(
trigger_db.get_uid().startswith('trigger:tpack:tname:'))
# Verify that same set of parameters always results in the same hash
parameters = {
'a': 1,
'b': 2,
'c': [1, 2, 3],
'd': {
'g': 1,
'h': 2
},
'b': u'unicode'
}
paramers_hash = json.dumps(parameters, sort_keys=True)
paramers_hash = hashlib.md5(paramers_hash).hexdigest()
parameters = {
'a': 1,
'b': 2,
'c': [1, 2, 3],
'b': u'unicode',
'd': {
'g': 1,
'h': 2
}
}
trigger_db = TriggerDB(name='tname',
pack='tpack',
parameters=parameters)
self.assertEqual(trigger_db.get_uid(),
'trigger:tpack:tname:%s' % (paramers_hash))
parameters = {
'c': [1, 2, 3],
'b': u'unicode',
'd': {
'h': 2,
'g': 1
},
'a': 1
}
trigger_db = TriggerDB(name='tname',
pack='tpack',
parameters=parameters)
self.assertEqual(trigger_db.get_uid(),
'trigger:tpack:tname:%s' % (paramers_hash))
parameters = {
'b': u'unicode',
'c': [1, 2, 3],
'd': {
'h': 2,
'g': 1
},
'a': 1
}
trigger_db = TriggerDB(name='tname',
pack='tpack',
parameters=parameters)
self.assertEqual(trigger_db.get_uid(),
'trigger:tpack:tname:%s' % (paramers_hash))
parameters = OrderedDict({
'c': [1, 2, 3],
'b': u'unicode',
'd': {
'h': 2,
'g': 1
},
'a': 1
})
trigger_db = TriggerDB(name='tname',
pack='tpack',
parameters=parameters)
self.assertEqual(trigger_db.get_uid(),
'trigger:tpack:tname:%s' % (paramers_hash))
# limitations under the License.
import bson
import copy
import mock
from st2common.models.db.action import ActionDB
from st2common.models.db.rule import RuleDB, ActionExecutionSpecDB
from st2common.models.db.trigger import TriggerDB, TriggerInstanceDB
from st2common.util import reference
from st2common.util import date as date_utils
from st2reactor.rules.filter import RuleFilter
from st2tests import DbTestCase
MOCK_TRIGGER = TriggerDB(pack='dummy_pack_1',
name='trigger-test.name',
type='system.test')
MOCK_TRIGGER_INSTANCE = TriggerInstanceDB(
trigger=MOCK_TRIGGER.get_reference().ref,
occurrence_time=date_utils.get_datetime_utc_now(),
payload={
'p1': 'v1',
'p2': 'preYYYpost',
'bool': True,
'int': 1,
'float': 0.8
})
MOCK_ACTION = ActionDB(id=bson.ObjectId(),
pack='wolfpack',
from st2common.models.db.rbac import PermissionGrantDB
from st2common.models.db.webhook import WebhookDB
from st2common.constants.triggers import WEBHOOK_TRIGGER_TYPES
from st2common.models.api.trigger import TriggerAPI
from st2common.models.db.trigger import TriggerDB
from st2tests.fixturesloader import FixturesLoader
from tests.base import APIControllerWithRBACTestCase
http_client = six.moves.http_client
__all__ = ['WebhookControllerRBACTestCase']
# 1. Trigger which references a system webhook trigger type
DUMMY_TRIGGER_DB = TriggerDB(name='pr-merged', pack='git')
DUMMY_TRIGGER_DB.type = list(WEBHOOK_TRIGGER_TYPES.keys())[0]
DUMMY_TRIGGER_API = TriggerAPI.from_model(DUMMY_TRIGGER_DB)
DUMMY_TRIGGER_DICT = vars(DUMMY_TRIGGER_API)
class WebhookControllerRBACTestCase(APIControllerWithRBACTestCase):
fixtures_loader = FixturesLoader()
def setUp(self):
super(WebhookControllerRBACTestCase, self).setUp()
# Insert mock users, roles and assignments
# Users
import mock
from st2common.models.db.trigger import TriggerDB
from st2common.transport.publishers import PoolPublisher
import st2reactor.container.utils as container_utils
from st2tests.base import CleanDbTestCase
MOCK_TRIGGER_TYPE = {}
MOCK_TRIGGER_TYPE['id'] = 'trigger-type-test.id'
MOCK_TRIGGER_TYPE['name'] = 'trigger-type-test.name'
MOCK_TRIGGER_TYPE['pack'] = 'dummy_pack_1'
MOCK_TRIGGER_TYPE['parameters_schema'] = {}
MOCK_TRIGGER_TYPE['payload_schema'] = {}
MOCK_TRIGGER = TriggerDB()
MOCK_TRIGGER.id = 'trigger-test.id'
MOCK_TRIGGER.name = 'trigger-test.name'
MOCK_TRIGGER.pack = 'dummy_pack_1'
MOCK_TRIGGER.parameters = {}
MOCK_TRIGGER.type = 'dummy_pack_1.trigger-type-test.name'
@mock.patch.object(PoolPublisher, 'publish', mock.MagicMock())
class ContainerUtilsTest(CleanDbTestCase):
def test_create_trigger_instance_invalid_trigger(self):
trigger_instance = 'dummy_pack.footrigger'
instance = container_utils.create_trigger_instance(trigger_instance, {}, None)
self.assertTrue(instance is None)
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from st2common.exceptions.triggers import TriggerDoesNotExistException
from st2common.models.api.rule import RuleAPI
from st2common.models.system.common import ResourceReference
from st2common.models.db.trigger import TriggerDB
from st2common.persistence.trigger import (Trigger, TriggerType)
import st2common.services.triggers as trigger_service
from st2tests.base import CleanDbTestCase
from st2tests.fixturesloader import FixturesLoader
MOCK_TRIGGER = TriggerDB()
MOCK_TRIGGER.id = 'trigger-test.id'
MOCK_TRIGGER.name = 'trigger-test.name'
MOCK_TRIGGER.pack = 'dummy_pack_1'
MOCK_TRIGGER.parameters = {}
MOCK_TRIGGER.type = 'dummy_pack_1.trigger-type-test.name'
class TriggerServiceTests(CleanDbTestCase):
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)
def get_webhook_trigger(name, url):
trigger = TriggerDB(name=name, pack='test')
trigger.type = WEBHOOK_TRIGGER_TYPES.keys()[0]
trigger.parameters = {'url': url}
return trigger
from __future__ import absolute_import
import bson
import copy
import mock
from st2common.models.db.action import ActionDB
from st2common.models.db.rule import RuleDB, ActionExecutionSpecDB
from st2common.models.db.trigger import TriggerDB, TriggerInstanceDB
from st2common.util import reference
from st2common.util import date as date_utils
from st2reactor.rules.filter import RuleFilter
from st2tests import DbTestCase
MOCK_TRIGGER = TriggerDB(pack="dummy_pack_1",
name="trigger-test.name",
type="system.test")
MOCK_TRIGGER_INSTANCE = TriggerInstanceDB(
trigger=MOCK_TRIGGER.get_reference().ref,
occurrence_time=date_utils.get_datetime_utc_now(),
payload={
"p1":
"v1",
"p2":
"preYYYpost",
"bool":
True,
"int":
1,
"float":
