def test_system_transform(self):
k5 = KeyValuePair.add_or_update(KeyValuePairDB(name='k5', value='v5'))
k6 = KeyValuePair.add_or_update(KeyValuePairDB(name='k6', value='v6'))
k7 = KeyValuePair.add_or_update(KeyValuePairDB(name='k7', value='v7'))
k8 = KeyValuePair.add_or_update(
KeyValuePairDB(name='k8', value='v8', scope=FULL_SYSTEM_SCOPE))
try:
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {
'ip5': '{{trigger.k2}}-static',
'ip6': '{{st2kv.system.k6}}-static',
'ip7': '{{st2kv.system.k7}}-static'
}
result = transformer(mapping)
expected = {
'ip5': 'v2-static',
'ip6': 'v6-static',
'ip7': 'v7-static'
}
self.assertEqual(result, expected)
finally:
KeyValuePair.delete(k5)
KeyValuePair.delete(k6)
KeyValuePair.delete(k7)
KeyValuePair.delete(k8)
def filter(self):
LOG.info('Validating rule %s for %s.', self.rule.id,
self.trigger['name'])
if not self.rule.enabled:
return False
criteria = self.rule.criteria
is_rule_applicable = True
if criteria and not self.trigger_instance.payload:
return False
transform = get_transformer(self.trigger_instance.payload)
LOG.debug('Trigger payload: %s', self.trigger_instance.payload)
for criterion_k in criteria.keys():
criterion_v = criteria[criterion_k]
is_rule_applicable = self._check_criterion(criterion_k,
criterion_v, transform)
if not is_rule_applicable:
break
if not is_rule_applicable:
LOG.debug('Rule %s not applicable for %s.', self.rule.id,
self.trigger['name'])
return is_rule_applicable
def test_hypenated_payload_transform(self):
payload = {'headers': {'hypenated-header': 'dont-care'}, 'k2': 'v2'}
transformer = datatransform.get_transformer(payload)
mapping = {'ip1': '{{trigger.headers[\'hypenated-header\']}}-static',
'ip2': '{{trigger.k2}} static'}
result = transformer(mapping)
self.assertEqual(result, {'ip1': 'dont-care-static', 'ip2': 'v2 static'})
def test_hypenated_payload_transform(self):
payload = {'headers': {'hypenated-header': 'dont-care'}, 'k2': 'v2'}
transformer = datatransform.get_transformer(payload)
mapping = {'ip1': '{{trigger.headers[\'hypenated-header\']}}-static',
'ip2': '{{trigger.k2}} static'}
result = transformer(mapping)
self.assertEqual(result, {'ip1': 'dont-care-static', 'ip2': 'v2 static'})
def filter(self):
LOG.info('Validating rule %s for %s.', self.rule.id, self.trigger['name'])
if not self.rule.enabled:
return False
criteria = RuleAPI.from_model(self.rule).criteria
is_rule_applicable = True
if criteria and not self.trigger_instance.payload:
return False
transform = get_transformer(self.trigger_instance.payload)
LOG.debug('Trigger payload: %s', self.trigger_instance.payload)
for criterion_k in criteria.keys():
criterion_v = criteria[criterion_k]
is_rule_applicable = self._check_criterion(criterion_k, criterion_v, transform)
if not is_rule_applicable:
break
if not is_rule_applicable:
LOG.debug('Rule %s not applicable for %s.', self.rule.id,
self.trigger['name'])
return is_rule_applicable
def test_payload_transform(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {
'ip1': '{{trigger.k1}}-static',
'ip2': '{{trigger.k2}} static'
}
result = transformer(mapping)
self.assertEqual(result, {'ip1': 'v1-static', 'ip2': 'v2 static'})
def test_payload_transform_complex_type(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {"complex_dict": {"bool": True, "int": 666, "str": "{{trigger.k1}}-string"}}
result = transformer(mapping)
expected = {"complex_dict": {"bool": True, "int": 666, "str": "v1-string"}}
self.assertEqual(result, expected)
mapping = {"simple_list": [1, 2, 3]}
result = transformer(mapping)
self.assertEqual(result, mapping)
def test_payload_transform_complex_type(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {'complex_dict': {'bool': True, 'int': 666, 'str': '{{trigger.k1}}-string'}}
result = transformer(mapping)
expected = {'complex_dict': {'bool': True, 'int': 666, 'str': 'v1-string'}}
self.assertEqual(result, expected)
mapping = {'simple_list': [1, 2, 3]}
result = transformer(mapping)
self.assertEqual(result, mapping)
def __init__(self, trigger_instance, rule):
self.trigger_instance = trigger_instance
self.rule = rule
try:
self.data_transformer = get_transformer(trigger_instance.payload)
except Exception as e:
message = ('Failed to template-ize trigger payload: %s. If the payload contains '
'special characters such as "{{" which dont\'t reference value in '
'a datastore, those characters need to be escaped' % (str(e)))
raise ValueError(message)
def __init__(self, trigger_instance, rule):
self.trigger_instance = trigger_instance
self.rule = rule
try:
self.data_transformer = get_transformer(trigger_instance.payload)
except Exception as e:
message = (
'Failed to template-ize trigger payload: %s. If the payload contains '
'special characters such as "{{" which dont\'t reference value in '
'a datastore, those characters need to be escaped' % (str(e)))
raise ValueError(message)
def test_system_transform(self):
k5 = KeyValuePair.add_or_update(KeyValuePairDB(name="k5", value="v5"))
k6 = KeyValuePair.add_or_update(KeyValuePairDB(name="k6", value="v6"))
k7 = KeyValuePair.add_or_update(KeyValuePairDB(name="k7", value="v7"))
try:
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {"ip5": "{{trigger.k2}}-static", "ip6": "{{system.k6}}-static", "ip7": "{{system.k7}}-static"}
result = transformer(mapping)
expected = {"ip5": "v2-static", "ip6": "v6-static", "ip7": "v7-static"}
self.assertEqual(result, expected)
finally:
KeyValuePair.delete(k5)
KeyValuePair.delete(k6)
KeyValuePair.delete(k7)
def test_system_transform(self):
k5 = KeyValuePair.add_or_update(KeyValuePairDB(name='k5', value='v5'))
k6 = KeyValuePair.add_or_update(KeyValuePairDB(name='k6', value='v6'))
k7 = KeyValuePair.add_or_update(KeyValuePairDB(name='k7', value='v7'))
try:
transformer = datatransform.get_transformer(PAYLOAD_WITH_KVP)
mapping = {'ip5': '{{trigger.k5}}-static',
'ip6': '{{system.k6}}-static',
'ip7': '{{system.k7}}-static'}
result = transformer(mapping)
expected = {'ip5': 'v5-static',
'ip6': 'v6-static',
'ip7': 'v7-static'}
self.assertEqual(result, expected)
finally:
KeyValuePair.delete(k5)
KeyValuePair.delete(k6)
KeyValuePair.delete(k7)
def test_system_transform(self):
k5 = KeyValuePair.add_or_update(KeyValuePairDB(name='k5', value='v5'))
k6 = KeyValuePair.add_or_update(KeyValuePairDB(name='k6', value='v6'))
k7 = KeyValuePair.add_or_update(KeyValuePairDB(name='k7', value='v7'))
try:
transformer = datatransform.get_transformer(PAYLOAD_WITH_KVP)
mapping = {'ip5': '{{trigger.k5}}-static',
'ip6': '{{system.k6}}-static',
'ip7': '{{system.k7}}-static'}
result = transformer(mapping)
expected = {'ip5': 'v5-static',
'ip6': 'v6-static',
'ip7': 'v7-static'}
self.assertEqual(result, expected)
finally:
KeyValuePair.delete(k5)
KeyValuePair.delete(k6)
KeyValuePair.delete(k7)
def test_payload_transform_complex_type(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {
'complex_dict': {
'bool': True,
'int': 666,
'str': '{{trigger.k1}}-string'
}
}
result = transformer(mapping)
expected = {
'complex_dict': {
'bool': True,
'int': 666,
'str': 'v1-string'
}
}
self.assertEqual(result, expected)
mapping = {'simple_list': [1, 2, 3]}
result = transformer(mapping)
self.assertEqual(result, mapping)
def test_system_transform(self):
k5 = KeyValuePair.add_or_update(KeyValuePairDB(name='k5', value='v5'))
k6 = KeyValuePair.add_or_update(KeyValuePairDB(name='k6', value='v6'))
k7 = KeyValuePair.add_or_update(KeyValuePairDB(name='k7', value='v7'))
k8 = KeyValuePair.add_or_update(KeyValuePairDB(name='k8', value='v8',
scope=FULL_SYSTEM_SCOPE))
try:
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {'ip5': '{{trigger.k2}}-static',
'ip6': '{{st2kv.system.k6}}-static',
'ip7': '{{st2kv.system.k7}}-static',
'ip8': '{{system.k8}}-static'}
result = transformer(mapping)
expected = {'ip5': 'v2-static',
'ip6': 'v6-static',
'ip7': 'v7-static',
'ip8': 'v8-static'}
self.assertEqual(result, expected)
finally:
KeyValuePair.delete(k5)
KeyValuePair.delete(k6)
KeyValuePair.delete(k7)
KeyValuePair.delete(k8)
def test_payload_transform(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {'ip1': '{{trigger.k1}}-static',
'ip2': '{{trigger.k2}} static'}
result = transformer(mapping)
self.assertEqual(result, {'ip1': 'v1-static', 'ip2': 'v2 static'})
def test_payload_transform_bool_type(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {'bool': True}
result = transformer(mapping)
self.assertEqual(result, {'bool': True})
def test_payload_transofrm_int_type(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {'int': 666}
result = transformer(mapping)
self.assertEqual(result, {'int': 666})
def __init__(self, trigger_instance, rule):
self.trigger_instance = trigger_instance
self.rule = rule
self.data_transformer = get_transformer(trigger_instance.payload)
def test_payload_transform(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {"ip1": "{{trigger.k1}}-static", "ip2": "{{trigger.k2}} static"}
result = transformer(mapping)
self.assertEqual(result, {"ip1": "v1-static", "ip2": "v2 static"})
def test_hypenated_payload_transform(self):
payload = {"headers": {"hypenated-header": "dont-care"}, "k2": "v2"}
transformer = datatransform.get_transformer(payload)
mapping = {"ip1": "{{trigger.headers['hypenated-header']}}-static", "ip2": "{{trigger.k2}} static"}
result = transformer(mapping)
self.assertEqual(result, {"ip1": "dont-care-static", "ip2": "v2 static"})
def test_payload_transform_bool_type(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {'bool': True}
result = transformer(mapping)
self.assertEqual(result, {'bool': True})
def __init__(self, trigger_instance, rule):
self.trigger_instance = trigger_instance
self.rule = rule
self.data_transformer = get_transformer(trigger_instance.payload)
def test_payload_transofrm_int_type(self):
transformer = datatransform.get_transformer(PAYLOAD)
mapping = {'int': 666}
result = transformer(mapping)
self.assertEqual(result, {'int': 666})
