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 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 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())
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":