def test_to_xml_error(self):
flags = [Flag(action='Top Flag'), Flag(action='mod1_flag1')]
next_step = NextStep(name='name', flags=flags)
xml = next_step.to_xml(tag='error')
self.assertEqual(xml.tag, 'error')
self.assertEqual(xml.get('step'), 'name')
self.assertEqual(len(xml.findall('flag')), 2)
def test_create_flag(self):
def test_help(_next_step, _expected):
self.assertEqual(len(_next_step.flags), len(_expected))
self.assertListEqual([flag.action for flag in _next_step.flags],
[flag['action'] for flag in _expected])
for flag, expected_flag in zip(_next_step.flags, _expected):
self.assertDictEqual(flag.as_json(), expected_flag)
self.assertEqual(flag.parent_name, 'name')
expected_ancestry = list(_next_step.ancestry)
expected_ancestry.append(flag.name)
self.assertListEqual(flag.ancestry, expected_ancestry)
next_step = NextStep(name='name')
next_step.create_flag('1')
expected = [Flag(action='1').as_json()]
test_help(next_step, expected)
filters = [Filter(action='test_filter_action'), Filter()]
next_step.create_flag('2', filters=filters)
expected.append(Flag(action='2', filters=filters).as_json())
test_help(next_step, expected)
args = {'arg1': 'a', 'arg2': 3, 'arg3': u'abc'}
args = {
arg_name: Argument(key=arg_name,
value=arg_value,
format=type(arg_value).__name__)
for arg_name, arg_value in args.items()
}
next_step.create_flag('3', filters=filters, args=args)
expected.append(Flag(action='3', filters=filters, args=args).as_json())
test_help(next_step, expected)
def test_to_from_json(self):
filter_params = ['test_filter_action', '']
flags_params = [('', []), ('test_action', []),
('test_action', filter_params)]
input_params = [('', '', None, []), ('test_name', '', None, []),
('test_name', 'test_parent', None, []),
('test_name', 'test_parent', ['a', 'b'], []),
('test_name', 'test_parent', ['a', 'b'], flags_params)]
for (name, parent_name, ancestry, flag_params) in input_params:
next_step = NextStep(name=name,
parent_name=parent_name,
ancestry=ancestry)
if flag_params:
flags = []
for flag_action, flag_filter_params in flag_params:
flag = Flag(action=flag_action,
parent_name=next_step.name,
ancestry=next_step.ancestry)
if filter_params:
flag.filters = [
Filter(action=flag_action,
parent_name=flag.name,
ancestry=flag.ancestry)
for flag_action in flag_filter_params
]
flags.append(flag)
next_step.flags = flags
next_step_json = next_step.as_json()
derived_next_step = NextStep.from_json(next_step_json,
parent_name=parent_name,
ancestry=ancestry)
self.assertDictEqual(derived_next_step.as_json(), next_step_json)
self.assertEqual(next_step.parent_name,
derived_next_step.parent_name)
self.assertListEqual(next_step.ancestry,
derived_next_step.ancestry)
derived_json_without_children = next_step_json
derived_json_without_children['flags'] = [
flag['action']
for flag in derived_json_without_children['flags']
]
self.assertDictEqual(
derived_next_step.as_json(with_children=False),
derived_json_without_children)
# check the ancestry of the flags
original_flag_ancestries = [
list(flag.ancestry) for flag in next_step.flags
]
derived_flag_ancestries = [
list(flag.ancestry) for flag in derived_next_step.flags
]
self.assertEqual(len(original_flag_ancestries),
len(derived_flag_ancestries))
for original_flag_ancestry, derived_flag_ancestry in zip(
original_flag_ancestries, derived_flag_ancestries):
self.assertListEqual(derived_flag_ancestry,
original_flag_ancestry)
def test_get_children(self):
next_step1 = NextStep()
names = ['', 'action1', 'action2']
for name in names:
self.assertIsNone(next_step1.get_children([name]))
self.assertDictEqual(next_step1.get_children([]),
next_step1.as_json(with_children=False))
flags = [Flag(), Flag(action='action1'), Flag(action='action2')]
next_step2 = NextStep(flags=flags)
for i, name in enumerate(names):
self.assertDictEqual(next_step2.get_children([name]),
flags[i].as_json())
self.assertDictEqual(next_step2.get_children([]),
next_step2.as_json(with_children=False))
filters = [
Filter(action='filter1'),
Filter(),
Filter(action='filter2')
]
flags = [Flag(action='action1', filters=filters)]
names = ['filter1', '', 'filter2']
next_step3 = NextStep(flags=flags)
ancestries = [[name, 'action1'] for name in names]
for i, ancestry in enumerate(ancestries):
self.assertDictEqual(next_step3.get_children(ancestry),
filters[i].as_json())
self.assertDictEqual(next_step3.get_children([]),
next_step3.as_json(with_children=False))
def test_get_next_step_error_with_next_steps(self):
flag1 = [
Flag(action='mod1_flag2', args={'arg1': '3'}),
Flag(action='mod1_flag2', args={'arg1': '-1'})
]
flag2 = [
Flag(action='mod1_flag2', args={'arg1': '-1'}),
Flag(action='mod1_flag2', args={'arg1': '3'})
]
next_steps = [
NextStep(flags=flag1, name='name1'),
NextStep(name='name2')
]
error_steps = [
NextStep(flags=flag2, name='error1'),
NextStep(name='error2')
]
step = Step(app='HelloWorld',
action='helloWorld',
next_steps=next_steps,
errors=error_steps)
step.output = 2
self.assertEqual(step.get_next_step({}, error=True), 'error2')
step.output = 1
self.assertEqual(step.get_next_step({}, error=True), 'error1')
def test_get_children_with_filters_no_ancestry(self):
filters = [
Filter(action='mod1_filter2', args={'arg1': '5.4'}),
Filter(action='Top Filter')
]
flag = Flag(action='Top Flag', filters=filters)
self.assertDictEqual(flag.get_children([]),
flag.as_json(with_children=False))
def test_get_children_with_filters_invalid_ancestry(self):
filters = [
Filter(action='mod1_filter2', args={'arg1': '5.4'}),
Filter(action='Top Filter')
]
flag = Flag(action='Top Flag', filters=filters)
for ancestry in [['a'], ['a', 'b']]:
self.assertIsNone(flag.get_children(ancestry))
def test_as_json_without_children_full(self):
flags = [Flag(action='Top Flag'), Flag(action='mod1_flag1')]
expected_flag_json = ['Top Flag', 'mod1_flag1']
self.assertDictEqual(
NextStep(name='name1', flags=flags).as_json(with_children=False), {
'name': 'name1',
'flags': expected_flag_json
})
def test_get_children_with_filters_ancestry_too_deep(self):
filters = [
Filter(action='mod1_filter2', args={'arg1': '5.4'}),
Filter(action='Top Filter')
]
flag = Flag(action='Top Flag', filters=filters)
for name in ['mod1_filter2', 'Top Filter']:
self.assertIsNone(flag.get_children([name, 'too deep']))
def test_to_xml_with_args_with_routing(self):
xml = Flag(action='mod1_flag2', args={'arg1': '@step1'}).to_xml()
self.assertEqual(xml.tag, 'flag')
self.assertEqual(xml.get('action'), 'mod1_flag2')
arg_xml = xml.findall('args/*')
self.assertEqual(len(arg_xml), 1)
self.assertEqual(arg_xml[0].tag, 'arg1')
self.assertEqual(arg_xml[0].text, '@step1')
self.assertListEqual(xml.findall('filters/*'), [])
def test_get_children_with_filters_valid_ancestry(self):
filters = [
Filter(action='mod1_filter2', args={'arg1': '5.4'}),
Filter(action='Top Filter')
]
flag = Flag(action='Top Flag', filters=filters)
self.assertDictEqual(flag.get_children(['mod1_filter2']),
filters[0].as_json())
self.assertDictEqual(flag.get_children(['Top Filter']),
filters[1].as_json())
def test_name_parent_filter_rename(self):
flag = Flag(ancestry=['flag_parent'], action='test_flag')
filter_element = Filter(action="test_filter", ancestry=flag.ancestry)
flag.filters = [filter_element]
new_ancestry = ["flag_parent_update"]
flag.reconstruct_ancestry(new_ancestry)
new_ancestry.append("test_flag")
new_ancestry.append("test_filter")
self.assertListEqual(new_ancestry, flag.filters[0].ancestry)
def test_get_children(self):
step = Step()
names = ['step1', 'step2', 'step3']
for name in names:
self.assertIsNone(step.get_children([name]))
self.assertDictEqual(step.get_children([]),
step.as_json(with_children=False))
next_steps = [
NextStep(name='name1'),
NextStep(name='name2'),
NextStep(name='name3')
]
names = ['name1', 'name2', 'name3']
step = Step(next_steps=next_steps)
for i, name in enumerate(names):
self.assertDictEqual(step.get_children([name]),
next_steps[i].as_json())
step = Step(errors=next_steps)
for i, name in enumerate(names):
self.assertDictEqual(step.get_children([name]),
next_steps[i].as_json())
errors = [
NextStep(name='name1'),
NextStep(name='error1'),
NextStep(name='error2'),
NextStep(name='name2')
]
next_names = list(names)
error_names = ['error1', 'error2']
all_names = list(next_names)
all_names.extend(error_names)
step = Step(next_steps=next_steps, errors=errors)
for i, name in enumerate(all_names):
if not name.startswith('error'):
self.assertDictEqual(step.get_children([name]),
next_steps[i].as_json())
else:
self.assertDictEqual(step.get_children([name]),
errors[i - 2].as_json())
flags = [Flag(), Flag(action='action1'), Flag(action='action2')]
next_steps = [NextStep(name='name1', flags=flags)]
names = ['', 'action1', 'action2']
step = Step(next_steps=next_steps)
ancestries = [[name, 'name1'] for name in names]
for i, ancestry in enumerate(ancestries):
self.assertDictEqual(step.get_children(ancestry),
flags[i].as_json())
def test_to_from_xml(self):
filters = [Filter(action='test_filter_action'), Filter()]
args = {'arg1': 'a', 'arg2': 3, 'arg3': u'abc'}
args = {
arg_name: Argument(key=arg_name,
value=arg_value,
format=type(arg_value).__name__)
for arg_name, arg_value in args.items()
}
flags = [
Flag(),
Flag(parent_name='test_parent'),
Flag(action='test_action'),
Flag(parent_name='test_parent',
action='test_action',
ancestry=['a', 'b']),
Flag(action='test_action', filters=filters),
Flag(action='test_action', args=args),
Flag(parent_name='test_parent',
action='test_action',
ancestry=['a', 'b'],
filters=filters,
args=args)
]
for flag in flags:
original_flag = flag.as_json()
derived_flag = Flag(xml=flag.to_xml()).as_json()
self.assertDictEqual(derived_flag, original_flag)
def test_as_json_with_args_with_children(self):
flag = Flag(action='mod1_flag2', args={'arg1': '11113'})
expected = {
'action': 'mod1_flag2',
'args': {
'arg1': {
'format': 'integer',
'key': 'arg1',
'value': 11113
}
},
'filters': []
}
self.assertDictEqual(flag.as_json(), expected)
def test_name_parent_multiple_filter_rename(self):
flag = Flag(ancestry=['flag_parent'], action='test_flag')
filter_one = Filter(action="test_filter_one", ancestry=flag.ancestry)
filter_two = Filter(action="test_filter_two", ancestry=flag.ancestry)
flag.filters = [filter_one, filter_two]
new_ancestry = ["flag_parent_update"]
flag.reconstruct_ancestry(new_ancestry)
new_ancestry.append("test_flag")
new_ancestry.append("test_filter_one")
self.assertListEqual(new_ancestry, flag.filters[0].ancestry)
new_ancestry.remove("test_filter_one")
new_ancestry.append("test_filter_two")
self.assertListEqual(new_ancestry, flag.filters[1].ancestry)
def test_name_parent_multiple_flag_rename(self):
next_step = NextStep(ancestry=['nextstep_parent'], name='mod1_flag1')
flag_one = Flag(action="Top Flag", ancestry=next_step.ancestry)
flag_two = Flag(action="mod1_flag1", ancestry=next_step.ancestry)
next_step.flags = [flag_one, flag_two]
new_ancestry = ["nextstep_parent_update"]
next_step.reconstruct_ancestry(new_ancestry)
new_ancestry.append("mod1_flag1")
new_ancestry.append("Top Flag")
self.assertListEqual(new_ancestry, next_step.flags[0].ancestry)
new_ancestry.remove("Top Flag")
new_ancestry.append("mod1_flag1")
self.assertListEqual(new_ancestry, next_step.flags[1].ancestry)
def __execute_trigger(conditional, data_in):
filters = [Filter(action=filter_element['action'],
args=Triggers.__to_new_input_format(filter_element['args']))
for filter_element in conditional['filters']]
return Flag(action=conditional['flag'],
args=Triggers.__to_new_input_format(conditional['args']),
filters=filters)(data_in, {})
def test_reconstruct_ancestry_with_filters(self):
filters = [
Filter(action='mod1_filter2', args={'arg1': '5.4'}),
Filter(action='Top Filter')
]
flag = Flag(action='Top Flag',
filters=filters,
ancestry=['flag_parent'])
new_ancestry = ['new_parent']
flag.reconstruct_ancestry(new_ancestry)
new_ancestry.append('Top Flag')
self.assertListEqual(flag.ancestry, new_ancestry)
for filter_element in filters:
ancestry = list(new_ancestry)
ancestry.append(filter_element.action)
self.assertEqual(filter_element.ancestry, ancestry)
def test_eq(self):
flags = [Flag(action='mod1_flag1'), Flag(action='Top Flag')]
next_steps = [
NextStep(),
NextStep(name='name'),
NextStep(name='name',
parent_name='parent',
flags=flags,
ancestry=['a', 'b'])
]
for i in range(len(next_steps)):
for j in range(len(next_steps)):
if i == j:
self.assertEqual(next_steps[i], next_steps[j])
else:
self.assertNotEqual(next_steps[i], next_steps[j])
def test_to_from_xml_is_same_with_args_and_filters(self):
filters = [
Filter(action='mod1_filter2', args={'arg1': '5.4'}),
Filter(action='Top Filter')
]
self.__assert_xml_is_convertible(
Flag(action='mod1_flag2', args={'arg1': '5'}, filters=filters))
def test_from_json_action_only_with_parent_and_ancestry(self):
json_in = {'action': 'Top Flag', 'args': {}, 'filters': []}
flag = Flag.from_json(json_in,
parent_name='parent',
ancestry=['a', 'b'])
self.__compare_init(flag, 'Top Flag', 'parent', ['a', 'b', 'Top Flag'],
[], {})
def from_json(json, parent_name='', ancestry=None):
"""Forms a NextStep object from the provided JSON object.
Args:
json (JSON object): The JSON object to convert from.
parent_name (str, optional): The name of the parent for ancestry purposes. Defaults to an empty string.
ancestry (list[str], optional): The ancestry for the new NextStep object. Defaults to None.
Returns:
The NextStep object parsed from the JSON object.
"""
name = json['name'] if 'name' in json else ''
status = json['status'] if 'status' in json else 'Success'
next_step = NextStep(name=name,
status=status,
parent_name=parent_name,
ancestry=ancestry)
if json['flags']:
next_step.flags = [
Flag.from_json(flag,
parent_name=next_step.parent_name,
ancestry=next_step.ancestry)
for flag in json['flags']
]
return next_step
def create_flag(self, action="", args=None, filters=None):
new_flag = Flag(action=action,
args=(args if args is not None else {}),
filters=(filters if filters is not None else []),
parent_name=self.name,
ancestry=self.ancestry)
self.flags.append(new_flag)
def test_as_json_with_children_full(self):
flags = [Flag(action='Top Flag'), Flag(action='mod1_flag1')]
expected_flag_json = [{
'action': 'Top Flag',
'args': {},
'filters': []
}, {
'action': 'mod1_flag1',
'args': {},
'filters': []
}]
self.assertDictEqual(
NextStep(name='name1', flags=flags).as_json(), {
'name': 'name1',
'flags': expected_flag_json
})
def test_get_next_step(self):
flag1 = [
Flag(action='mod1_flag2', args={'arg1': '3'}),
Flag(action='mod1_flag2', args={'arg1': '-1'})
]
next_steps = [
NextStep(flags=flag1, name='name1'),
NextStep(name='name2')
]
step = Step(app='HelloWorld',
action='helloWorld',
next_steps=next_steps)
step.output = ActionResult(2, 'Success')
self.assertEqual(step.get_next_step({}), 'name2')
step.output = ActionResult(1, 'Success')
self.assertEqual(step.get_next_step({}), 'name1')
def test_init_with_filters(self):
filters = [
Filter(action='mod1_filter2', args={'arg1': '5.4'}),
Filter(action='Top Filter')
]
flag = Flag(action='Top Flag', filters=filters)
self.__compare_init(flag, 'Top Flag', '', ['', 'Top Flag'], filters,
{})
def test_set_non_existent(self):
filters = [Filter(action='test_filter_action'), Filter()]
args = {'arg1': 'a', 'arg2': 3, 'arg3': u'abc'}
args = {
arg_name: Argument(key=arg_name,
value=arg_value,
format=type(arg_value).__name__)
for arg_name, arg_value in args.items()
}
flag = Flag(parent_name='test_parent',
action='test_action',
ancestry=['a', 'b'],
filters=filters,
args=args)
flag.set('junkfield', 'junk')
self.assertEqual(flag.junkfield, 'junk')
def test_from_json_with_args(self):
args = {'arg1': {'format': 'integer', 'key': 'arg1', 'value': 3}}
json_in = {'action': 'mod1_flag2', 'args': args, 'filters': []}
flag = Flag.from_json(json_in,
parent_name='parent',
ancestry=['a', 'b'])
self.__compare_init(flag, 'mod1_flag2', 'parent',
['a', 'b', 'mod1_flag2'], [], {'arg1': 3})
def test_init_with_flags(self):
flags = [Flag(action='Top Flag'), Flag(action='mod1_flag1')]
expected_flag_json = [{
'action': 'Top Flag',
'args': {},
'filters': []
}, {
'action': 'mod1_flag1',
'args': {},
'filters': []
}]
next_step = NextStep(name='name',
parent_name='parent',
flags=flags,
ancestry=['a', 'b'])
self.__compare_init(next_step, 'name', 'parent', expected_flag_json,
['a', 'b', 'name'])
