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 }}")