def test_convert_task_transitions_empty(self):
converter = WorkflowConverter()
task_spec = OrderedMap([])
expr_converter = JinjaExpressionConverter()
result = converter.convert_task_transitions("task_name", task_spec,
expr_converter, set())
self.assertEqual(result, OrderedMap([]))
def test_convert_tasks(self):
converter = WorkflowConverter()
expr_converter = JinjaExpressionConverter()
mistral_tasks = OrderedMap([('jinja_task',
OrderedMap([
('action', 'mypack.actionname'),
('input',
OrderedMap([
('cmd', '{{ _.test }}'),
])),
('on-success', ['next_task']),
]))])
result = converter.convert_tasks(mistral_tasks, expr_converter, set())
self.assertEqual(
result,
OrderedMap([('jinja_task',
OrderedMap([
('action', 'mypack.actionname'),
('input',
OrderedMap([
('cmd', '{{ ctx().test }}'),
])),
('next', [
OrderedMap([('when', '{{ succeeded() }}'),
('do', [
'next_task',
])]),
]),
]))]))
def expr_type_converter(self, expr_type):
if expr_type is None:
expr_converter = JinjaExpressionConverter()
elif isinstance(expr_type, six.string_types):
expr_type = expr_type.lower()
if expr_type == 'jinja':
expr_converter = JinjaExpressionConverter()
elif expr_type == 'yaql':
expr_converter = YaqlExpressionConverter()
else:
raise TypeError("Unknown expression type: {}".format(expr_type))
elif isinstance(expr_type, BaseExpressionConverter):
expr_converter = expr_type
else:
raise TypeError("Unknown expression class type: {}".format(type(expr_type)))
return expr_converter
def test_convert_task_transitions(self):
converter = WorkflowConverter()
task_spec = OrderedMap([
('publish', OrderedMap([
('good_data', '{{ _.good }}'),
])),
('publish-on-error', OrderedMap([
('bad_data', '{{ _.bad }}'),
])),
('on-success', [
OrderedMap([('do_thing_a', '{{ _.x }}')]),
OrderedMap([('do_thing_b', '{{ _.x }}')])
]),
('on-error', [
OrderedMap([('do_thing_error', '{{ _.e }}')]),
]),
('on-complete', [
OrderedMap([('do_thing_sometimes', '{{ _.d }}')]),
'do_thing_always'
]),
])
expr_converter = JinjaExpressionConverter()
result = converter.convert_task_transitions(task_spec, expr_converter,
set())
self.assertEquals(
result,
OrderedMap([
('next', [
OrderedMap([('when', '{{ succeeded() and (ctx().x) }}'),
('publish', [{
'good_data': '{{ ctx().good }}'
}]), ('do', [
'do_thing_a',
'do_thing_b',
])]),
OrderedMap([('when', '{{ failed() and (ctx().e) }}'),
('publish', [{
'bad_data': '{{ ctx().bad }}'
}]), ('do', [
'do_thing_error',
])]),
OrderedMap([('do', [
'do_thing_always',
])]),
OrderedMap([('when', '{{ ctx().d }}'),
('do', [
'do_thing_sometimes',
])]),
]),
]))
def test_convert_task_transition_simple_no_publish(self):
converter = WorkflowConverter()
transitions = ['a', 'b', 'c']
publish = None
orquesta_expr = 'succeeded()'
expr_converter = JinjaExpressionConverter()
result = converter.convert_task_transition_simple(
transitions, publish, orquesta_expr, expr_converter)
expected = OrderedMap([
('when', '{{ succeeded() }}'),
('do', ['a', 'b', 'c']),
])
self.assertEqual(result, expected)
def test_convert_task_transitions_common_publish_keys_same_values(self):
converter = WorkflowConverter()
task_spec = OrderedMap([
('publish',
OrderedMap([
('good_data', '{{ _.good }}'),
('common_data_1', '{{ _.common_1 }}'),
('common_data_2', '{{ _.common_2 }}'),
])),
('publish-on-error',
OrderedMap([
('bad_data', '{{ _.bad }}'),
('common_data_1', '{{ _.common_1 }}'),
('common_data_2', '{{ _.common_2 }}'),
])),
('on-complete', ['do_thing_always']),
])
expr_converter = JinjaExpressionConverter()
result = converter.convert_task_transitions("task_name", task_spec,
expr_converter, set())
self.assertDictEqual(
result,
OrderedMap([
('next', [
OrderedMap([
('publish', [
{
'good_data': '{{ ctx().good }}'
},
{
'common_data_1': '{{ ctx().common_1 }}'
},
{
'common_data_2': '{{ ctx().common_2 }}'
},
{
'bad_data': '{{ ctx().bad }}'
},
]),
('do', [
'do_thing_always',
]),
]),
]),
]))
def test_convert_task_transition_simple_no_transitions(self):
converter = WorkflowConverter()
transitions = None
publish = OrderedMap([('key_plain', 'data'),
('key_expr', '{{ _.test }}')])
orquesta_expr = 'succeeded()'
expr_converter = JinjaExpressionConverter()
result = converter.convert_task_transition_simple(
transitions, publish, orquesta_expr, expr_converter)
expected = OrderedMap([
('when', '{{ succeeded() }}'),
('publish', [{
'key_plain': 'data'
}, {
'key_expr': '{{ ctx().test }}'
}]),
])
self.assertEqual(result, expected)
def test_convert_task_transition_simple_no_orquesta_expr(self):
converter = WorkflowConverter()
transitions = ['a', 'b', 'c']
publish = OrderedMap([('key_plain', 'data'),
('key_expr', '{{ _.test }}')])
orquesta_expr = None
expr_converter = JinjaExpressionConverter()
result = converter.convert_task_transition_simple(
transitions, publish, orquesta_expr, expr_converter)
expected = OrderedMap([
('publish', [{
'key_plain': 'data'
}, {
'key_expr': '{{ ctx().test }}'
}]),
('do', ['a', 'b', 'c']),
])
self.assertEquals(result, expected)
def test_convert_task_transitions_common_publish_keys_different_values(
self):
converter = WorkflowConverter()
task_spec = OrderedMap([
('publish',
OrderedMap([
('good_data', '{{ _.good }}'),
('common_key_1', '{{ _.common_data }}'),
('common_key_2', '{{ _.different_data_1_1 }}'),
('common_key_3', '{{ _.different_data_1_2 }}'),
])),
('publish-on-error',
OrderedMap([
('bad_data', '{{ _.bad }}'),
('common_key_1', '{{ _.common_data }}'),
('common_key_2', '{{ _.different_data_2_1 }}'),
('common_key_3', '{{ _.different_data_2_2 }}'),
])),
('on-complete', [
OrderedMap([('do_thing_sometimes', '{{ _.d }}')]),
'do_thing_always'
]),
])
expr_converter = JinjaExpressionConverter()
with self.assertRaises(NotImplementedError) as ctx_m:
converter.convert_task_transitions("tsk_name", task_spec,
expr_converter, set())
rgx = re.compile(
r"Task 'tsk_name' contains one or more keys "
r"\((?:common_key_2, common_key_3|common_key_3, common_key_2)\) "
r"in both publish and publish-on-error dictionaries that have different "
r"values\. Please either remove the common keys, or ensure that the "
r"values of any common keys are the same\.")
self.assertRegex(str(ctx_m.exception), rgx)
def test_convert_expression_jinja_item_vars(self):
expr = "{{ _.test }}"
result = JinjaExpressionConverter.convert_string(expr, item_vars=['test'])
self.assertEquals(result, "{{ item(test) }}")
def test_unwrap_expression(self):
expr = "{{ _.test }}"
result = JinjaExpressionConverter.unwrap_expression(expr)
self.assertEquals(result, "_.test")
def test_convert_expression_jinja_st2kv_user(self):
expr = '{{ st2kv.user.test.kv }}'
result = JinjaExpressionConverter.convert_string(expr)
self.assertEquals(result, "{{ st2kv('user.test.kv') }}")
def test_convert_expression_jinja_task_result_double_quotes(self):
expr = '{{ task("abc").result.double_quote }}'
result = JinjaExpressionConverter.convert_string(expr)
self.assertEquals(result, "{{ result().double_quote }}")
def test_convert_expression_jinja_task_result(self):
expr = "{{ task('abc').result.result }}"
result = JinjaExpressionConverter.convert_string(expr)
self.assertEquals(result, "{{ result().result }}")
def test_convert_expression_jinja_context_vars_with_underscore(self):
expr = "{{ _.test_.other }}"
result = JinjaExpressionConverter.convert_string(expr)
self.assertEquals(result, "{{ ctx().test_.other }}")
def test_convert_expression_jinja_context_vars(self):
expr = "{{ _.test }}"
result = JinjaExpressionConverter.convert_string(expr)
self.assertEquals(result, "{{ ctx().test }}")
def test_expr_type_converter_class_jinja(self):
expr_type = JinjaExpressionConverter()
converter = WorkflowConverter()
result = converter.expr_type_converter(expr_type)
self.assertIs(result, expr_type)
def test_convert_expression_jinja_function_context_vars(self):
expr = "{{ list(range(0, _.count)) }}"
result = JinjaExpressionConverter.convert_string(expr)
self.assertEquals(result, "{{ list(range(0, ctx().count)) }}")
def test_convert_expression_jinja_context_and_item_vars(self):
expr = "{{ _.test + _.test2 - _.long_var }}"
result = JinjaExpressionConverter.convert_string(expr, item_vars=['test'])
self.assertEquals(result, "{{ item(test) + ctx().test2 - ctx().long_var }}")
def test_convert_expression_jinja_complex_function_context_vars(self):
expr = "{{ zip([0, 1, 2], [3, 4, 5], _.all_the_things) }}"
result = JinjaExpressionConverter.convert_string(expr)
self.assertEquals(result, "{{ zip([0, 1, 2], [3, 4, 5], ctx().all_the_things) }}")
def test_convert_expression_jinja_st2_api_url(self):
expr = '{{ env().st2_action_api_url }}'
result = JinjaExpressionConverter.convert_string(expr)
self.assertEquals(result, "{{ ctx().st2.api_url }}")
