def test_empty_payload(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.p1": {"type": "equals", "pattern": "v1"}}
trigger_instance = copy.deepcopy(MOCK_TRIGGER_INSTANCE)
trigger_instance.payload = None
f = RuleFilter(trigger_instance, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), "equals check should have failed.")
def test_empty_payload(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': 'v1'}}
trigger_instance = copy.deepcopy(MOCK_TRIGGER_INSTANCE)
trigger_instance.payload = None
f = RuleFilter(trigger_instance, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
def test_empty_criteria_and_empty_payload(self):
rule = MOCK_RULE_1
rule.criteria = {}
trigger_instance = copy.deepcopy(MOCK_TRIGGER_INSTANCE)
trigger_instance.payload = None
f = RuleFilter(trigger_instance, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have failed.')
def test_empty_payload(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.p1": {"type": "equals", "pattern": "v1"}}
trigger_instance = copy.deepcopy(MOCK_TRIGGER_INSTANCE)
trigger_instance.payload = None
f = RuleFilter(trigger_instance, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), "equals check should have failed.")
def test_empty_payload(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': 'v1'}}
trigger_instance = copy.deepcopy(MOCK_TRIGGER_INSTANCE)
trigger_instance.payload = None
f = RuleFilter(trigger_instance, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
def test_empty_criteria_and_empty_payload(self):
rule = MOCK_RULE_1
rule.criteria = {}
trigger_instance = copy.deepcopy(MOCK_TRIGGER_INSTANCE)
trigger_instance.payload = None
f = RuleFilter(trigger_instance, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have failed.')
def test_nexists(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.float': {'type': 'nexists'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), '"float" key exists in trigger. Should return false.')
rule.criteria = {'trigger.floattt': {'type': 'nexists'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), '"floattt" key ain\'t exist in trigger. Should return true.')
def test_matchregex_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
"trigger.p1": {
"type": "matchregex",
"pattern": "v1$"
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "Failed to pass evaluation.")
def test_matchregex_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
'trigger.p1': {
'type': 'matchregex',
'pattern': 'v1$'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'Failed to pass evaluation.')
def test_equals_float_value(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.float': {'type': 'equals', 'pattern': 0.8}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
rule = MOCK_RULE_1
rule.criteria = {'trigger.float': {'type': 'equals', 'pattern': '{{trigger.float}}'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
def test_hash_strip_int_value(self):
rule = MOCK_RULE_1
rule.criteria = {
"trigger.int": {
"type": "gt",
"pattern": 0
},
"trigger.int#2": {
"type": "lt",
"pattern": 2
},
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
rule = MOCK_RULE_1
rule.criteria = {
"trigger.int": {
"type": "gt",
"pattern": 2
},
"trigger.int#2": {
"type": "lt",
"pattern": 3
},
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(),
"trigger value is gt than 0 but didn't match.")
rule = MOCK_RULE_1
rule.criteria = {"trigger.int#1": {"type": "lt", "pattern": 2}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(),
"trigger value is gt than 0 but didn't match.")
def test_equals_bool_value(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.bool": {"type": "equals", "pattern": True}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
rule = MOCK_RULE_1
rule.criteria = {
"trigger.bool": {
"type": "equals",
"pattern": "{{trigger.bool}}"
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
rule = MOCK_RULE_1
rule.criteria = {
"trigger.bool": {
"type": "equals",
"pattern": "{{ trigger.bool }}"
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
def test_equals_bool_value(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.bool': {'type': 'equals', 'pattern': True}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
rule = MOCK_RULE_1
rule.criteria = {
'trigger.bool': {
'type': 'equals',
'pattern': '{{trigger.bool}}'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
rule = MOCK_RULE_1
rule.criteria = {
'trigger.bool': {
'type': 'equals',
'pattern': '{{ trigger.bool }}'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
def test_criteria_pattern_references_a_datastore_item(self, mock_KeyValueLookup):
class MockResultLookup(object):
pass
class MockSystemLookup(object):
system = MockResultLookup()
rule = MOCK_RULE_2
# Using a variable in pattern, referencing an inexistent datastore value
rule.criteria = {'trigger.p1': {
'type': 'equals',
'pattern': '{{ system.inexistent_value }}'}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which doesn't match
mock_result = MockSystemLookup()
mock_result.test_value_1 = 'non matching'
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': '{{ system.test_value_1 }}'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which does match
mock_result = MockSystemLookup()
mock_result.test_value_2 = 'v1'
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': '{{ system.test_value_2 }}'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter())
# Using a variable in pattern, referencing an existing value which matches partially
mock_result = MockSystemLookup()
mock_result.test_value_3 = 'YYY'
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {'trigger.p2': {'type': 'equals', 'pattern': '{{ system.test_value_3 }}'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which matches partially
mock_result = MockSystemLookup()
mock_result.test_value_3 = 'YYY'
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {'trigger.p2': {
'type': 'equals',
'pattern': 'pre{{ system.test_value_3 }}post'}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter())
def test_equals_operator_fail_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': 'v'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
rule = MOCK_RULE_1
rule.criteria = {
'trigger.p1': {
'type': 'equals',
'pattern': '{{trigger.p2}}'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
rule = MOCK_RULE_1
rule.criteria = {
'trigger.list': {
'type':
'equals',
'pattern':
"""
[
{% for item in trigger.list %}
{{item}}
{% endfor %}
]
"""
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
def test_equals_operator_fail_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.p1": {"type": "equals", "pattern": "v"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), "equals check should have failed.")
rule = MOCK_RULE_1
rule.criteria = {
"trigger.p1": {
"type": "equals",
"pattern": "{{trigger.p2}}"
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), "equals check should have failed.")
rule = MOCK_RULE_1
rule.criteria = {
"trigger.list": {
"type":
"equals",
"pattern":
"""
[
{% for item in trigger.list %}
{{item}}
{% endfor %}
]
""",
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), "equals check should have failed.")
def test_gt_lt_falsy_pattern(self):
# Make sure that the falsy value (number 0) is handled correctly
rule = MOCK_RULE_1
rule.criteria = {'trigger.int': {'type': 'gt', 'pattern': 0}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'trigger value is gt than 0 but didn\'t match')
rule.criteria = {'trigger.int': {'type': 'lt', 'pattern': 0}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'trigger value is gt than 0 but didn\'t fail')
def test_criteria_pattern_references_a_datastore_item(self, mock_KeyValueLookup):
class MockResultLookup(object):
pass
class MockSystemLookup(object):
system = MockResultLookup()
rule = MOCK_RULE_2
# Using a variable in pattern, referencing an inexistent datastore value
rule.criteria = {"trigger.p1": {"type": "equals", "pattern": "{{ system.inexistent_value }}"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which doesn't match
mock_result = MockSystemLookup()
mock_result.test_value_1 = "non matching"
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {"trigger.p1": {"type": "equals", "pattern": "{{ system.test_value_1 }}"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which does match
mock_result = MockSystemLookup()
mock_result.test_value_2 = "v1"
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {"trigger.p1": {"type": "equals", "pattern": "{{ system.test_value_2 }}"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter())
# Using a variable in pattern, referencing an existing value which matches partially
mock_result = MockSystemLookup()
mock_result.test_value_3 = "YYY"
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {"trigger.p2": {"type": "equals", "pattern": "{{ system.test_value_3 }}"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which matches partially
mock_result = MockSystemLookup()
mock_result.test_value_3 = "YYY"
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {"trigger.p2": {"type": "equals", "pattern": "pre{{ system.test_value_3 }}post"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter())
def test_search_operator_pass_all_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
'trigger.recursive_list': {
'type': 'search',
'condition': 'all',
'pattern': {
'item.field_name': {
'type': 'startswith',
'pattern': 'S',
}
}
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'Failed evaluation')
def test_search_operator_pass_all_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
"trigger.recursive_list": {
"type": "search",
"condition": "all",
"pattern": {
"item.field_name": {
"type": "startswith",
"pattern": "S",
}
},
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "Failed evaluation")
def test_search_operator_pass_all_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
'trigger.recursive_list': {
'type': 'search',
'condition': 'all',
'pattern': {
'item.field_name': {
'type': 'startswith',
'pattern': 'S',
}
}
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'Failed evaluation')
def get_matching_rules(self):
first_pass, second_pass = self._split_rules_into_passes()
# first pass
rule_filters = [
RuleFilter(trigger_instance=self.trigger_instance,
trigger=self.trigger,
rule=rule,
extra_info=self.extra_info) for rule in first_pass
]
matched_rules = [
rule_filter.rule for rule_filter in rule_filters
if rule_filter.filter()
]
LOG.debug('[1st_pass] %d rule(s) found to enforce for %s.',
len(matched_rules), self.trigger['name'])
# second pass
rule_filters = [
SecondPassRuleFilter(self.trigger_instance, self.trigger, rule,
matched_rules) for rule in second_pass
]
matched_in_second_pass = [
rule_filter.rule for rule_filter in rule_filters
if rule_filter.filter()
]
LOG.debug('[2nd_pass] %d rule(s) found to enforce for %s.',
len(matched_in_second_pass), self.trigger['name'])
matched_rules.extend(matched_in_second_pass)
LOG.info('%d rule(s) found to enforce for %s.', len(matched_rules),
self.trigger['name'])
return matched_rules
def test_search_operator_fail_all_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
'trigger.recursive_list': {
'type': 'search',
'condition': 'all',
'pattern': {
'item.field_name': {
'type': 'equals',
'pattern': 'Status',
},
'item.to_value': {
'type': 'equals',
'pattern': 'Denied',
}
}
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'Passed evaluation')
def test_search_operator_fail_all_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
'trigger.recursive_list': {
'type': 'search',
'condition': 'all',
'pattern': {
'item.field_name': {
'type': 'equals',
'pattern': 'Status',
},
'item.to_value': {
'type': 'equals',
'pattern': 'Denied',
}
}
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'Passed evaluation')
def test_search_operator_pass_any_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
'trigger.recursive_list': {
'type': 'search',
'condition': 'any',
'pattern': {
'item.field_name': {
'type': 'equals',
'pattern': 'Status',
},
'item.to_value': {
'type': 'equals',
'pattern': 'Approved'
}
}
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'Failed evaluation')
def test_search_operator_pass_any_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
"trigger.recursive_list": {
"type": "search",
"condition": "any",
"pattern": {
"item.field_name": {
"type": "equals",
"pattern": "Status",
},
"item.to_value": {
"type": "equals",
"pattern": "Approved"
},
},
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "Failed evaluation")
def test_search_operator_fail_all_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
"trigger.recursive_list": {
"type": "search",
"condition": "all",
"pattern": {
"item.field_name": {
"type": "equals",
"pattern": "Status",
},
"item.to_value": {
"type": "equals",
"pattern": "Denied",
},
},
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), "Passed evaluation")
def test_search_operator_pass_any_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {
'trigger.recursive_list': {
'type': 'search',
'condition': 'any',
'pattern': {
'item.field_name': {
'type': 'equals',
'pattern': 'Status',
},
'item.to_value': {
'type': 'equals',
'pattern': 'Approved'
}
}
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'Failed evaluation')
def get_matching_rules(self):
rule_filters = [
RuleFilter(self.trigger_instance, self.trigger, rule)
for rule in self.rules
]
matched_rules = [
rule_filter.rule for rule_filter in rule_filters
if rule_filter.filter()
]
LOG.info('%d rule(s) found to enforce for %s.', len(matched_rules),
self.trigger['name'])
return matched_rules
def test_equals_operator_fail_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': 'v'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': '{{trigger.p2}}'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
rule = MOCK_RULE_1
rule.criteria = {
'trigger.list': {
'type': 'equals',
'pattern': """
[
{% for item in trigger.list %}
{{item}}
{% endfor %}
]
"""
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
def test_nexists(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.float': {'type': 'nexists'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), '"float" key exists in trigger. Should return false.')
rule.criteria = {'trigger.floattt': {'type': 'nexists'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), '"floattt" key ain\'t exist in trigger. Should return true.')
def test_gt_lt_falsy_pattern(self):
# Make sure that the falsy value (number 0) is handled correctly
rule = MOCK_RULE_1
rule.criteria = {"trigger.int": {"type": "gt", "pattern": 0}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(),
"trigger value is gt than 0 but didn't match")
rule.criteria = {"trigger.int": {"type": "lt", "pattern": 0}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(),
"trigger value is gt than 0 but didn't fail")
def test_gt_lt_falsy_pattern(self):
# Make sure that the falsy value (number 0) is handled correctly
rule = MOCK_RULE_1
rule.criteria = {'trigger.int': {'type': 'gt', 'pattern': 0}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(),
'trigger value is gt than 0 but didn\'t match')
rule.criteria = {'trigger.int': {'type': 'lt', 'pattern': 0}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(),
'trigger value is gt than 0 but didn\'t fail')
def test_equals_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': 'v1'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': '{{trigger.p1}}'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
rule = MOCK_RULE_1
rule.criteria = {
'trigger.p1': {
'type': 'equals',
'pattern': "{{'%s' % trigger.p1 if trigger.int}}"
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
# Test our filter works if proper JSON is returned from user pattern
rule = MOCK_RULE_1
rule.criteria = {
'trigger.list': {
'type': 'equals',
'pattern': """
[
{% for item in trigger.list %}
{{item}}{% if not loop.last %},{% endif %}
{% endfor %}
]
"""
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
def test_matchregex_operator_fail_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.p1": {"type": "matchregex", "pattern": "v$"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), "regex check should have failed.")
def test_matchregex_operator_fail_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.p1": {"type": "matchregex", "pattern": "v$"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), "regex check should have failed.")
def test_criteria_pattern_references_a_datastore_item(
self, mock_KeyValueLookup):
class MockResultLookup(object):
pass
class MockSystemLookup(object):
system = MockResultLookup()
rule = MOCK_RULE_2
# Using a variable in pattern, referencing an inexistent datastore value
rule.criteria = {
'trigger.p1': {
'type': 'equals',
'pattern': '{{ st2kv.system.inexistent_value }}'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which doesn't match
mock_result = MockSystemLookup()
mock_result.test_value_1 = 'non matching'
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {
'trigger.p1': {
'type': 'equals',
'pattern': '{{ st2kv.system.test_value_1 }}'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which does match
mock_result = MockSystemLookup()
mock_result.test_value_2 = 'v1'
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {
'trigger.p1': {
'type': 'equals',
'pattern': '{{ st2kv.system.test_value_2 }}'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter())
# Using a variable in pattern, referencing an existing value which matches partially
mock_result = MockSystemLookup()
mock_result.test_value_3 = 'YYY'
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {
'trigger.p2': {
'type': 'equals',
'pattern': '{{ st2kv.system.test_value_3 }}'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which matches partially
mock_result = MockSystemLookup()
mock_result.test_value_3 = 'YYY'
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {
'trigger.p2': {
'type': 'equals',
'pattern': 'pre{{ st2kv.system.test_value_3 }}post'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter())
def test_empty_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have failed.')
def test_equals_float_value(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.float': {'type': 'equals', 'pattern': 0.8}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
def test_equals_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.p1": {"type": "equals", "pattern": "v1"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
rule = MOCK_RULE_1
rule.criteria = {
"trigger.p1": {
"type": "equals",
"pattern": "{{trigger.p1}}"
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
rule = MOCK_RULE_1
rule.criteria = {
"trigger.p1": {
"type": "equals",
"pattern": "{{'%s' % trigger.p1 if trigger.int}}",
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
# Test our filter works if proper JSON is returned from user pattern
rule = MOCK_RULE_1
rule.criteria = {
"trigger.list": {
"type":
"equals",
"pattern":
"""
[
{% for item in trigger.list %}
{{item}}{% if not loop.last %},{% endif %}
{% endfor %}
]
""",
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
def test_equals_float_value(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.float": {"type": "equals", "pattern": 0.8}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "equals check should have passed.")
def test_equals_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': 'v1'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'regex check should have failed.')
def test_empty_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have failed.')
def test_equals_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.p1": {"type": "equals", "pattern": "v1"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "regex check should have failed.")
def test_equals_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': 'v1'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
rule = MOCK_RULE_1
rule.criteria = {
'trigger.p1': {
'type': 'equals',
'pattern': '{{trigger.p1}}'
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
rule = MOCK_RULE_1
rule.criteria = {
'trigger.p1': {
'type': 'equals',
'pattern': "{{'%s' % trigger.p1 if trigger.int}}"
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
# Test our filter works if proper JSON is returned from user pattern
rule = MOCK_RULE_1
rule.criteria = {
'trigger.list': {
'type':
'equals',
'pattern':
"""
[
{% for item in trigger.list %}
{{item}}{% if not loop.last %},{% endif %}
{% endfor %}
]
"""
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
def test_matchregex_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {"trigger.p1": {"type": "matchregex", "pattern": "v1$"}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), "Failed to pass evaluation.")
def test_matchregex_operator_pass_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'matchregex', 'pattern': 'v1$'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'Failed to pass evaluation.')
def test_equals_operator_fail_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'equals', 'pattern': 'v'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'equals check should have failed.')
def test_equals_bool_value(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.bool': {'type': 'equals', 'pattern': True}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have passed.')
def test_matchregex_operator_fail_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {'trigger.p1': {'type': 'matchregex', 'pattern': 'v$'}}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter(), 'regex check should have failed.')
def test_criteria_pattern_references_a_datastore_item(
self, mock_KeyValueLookup):
class MockResultLookup(object):
pass
class MockSystemLookup(object):
system = MockResultLookup()
rule = MOCK_RULE_2
# Using a variable in pattern, referencing an inexistent datastore value
rule.criteria = {
"trigger.p1": {
"type": "equals",
"pattern": "{{ st2kv.system.inexistent_value }}",
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which doesn't match
mock_result = MockSystemLookup()
mock_result.test_value_1 = "non matching"
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {
"trigger.p1": {
"type": "equals",
"pattern": "{{ st2kv.system.test_value_1 }}",
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which does match
mock_result = MockSystemLookup()
mock_result.test_value_2 = "v1"
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {
"trigger.p1": {
"type": "equals",
"pattern": "{{ st2kv.system.test_value_2 }}",
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter())
# Using a variable in pattern, referencing an existing value which matches partially
mock_result = MockSystemLookup()
mock_result.test_value_3 = "YYY"
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {
"trigger.p2": {
"type": "equals",
"pattern": "{{ st2kv.system.test_value_3 }}",
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertFalse(f.filter())
# Using a variable in pattern, referencing an existing value which matches partially
mock_result = MockSystemLookup()
mock_result.test_value_3 = "YYY"
mock_KeyValueLookup.return_value = mock_result
rule.criteria = {
"trigger.p2": {
"type": "equals",
"pattern": "pre{{ st2kv.system.test_value_3 }}post",
}
}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter())
