update code to have single try-catch

Author: devership16

bzt/modules/_apiritif/generator.py

@@ -72,7 +72,7 @@ def _gen_class_actionid_tracking(self):
         ]
 
     def _gen_action_start_with_tracking(self, actionId):
-        # Assign actionId to self._current_actionId before action_start
+        # Assign actionId (or None) to self._current_actionId before each action
         return [
             ast.Assign(
                 targets=[ast_attr("self._current_actionId")],
@@ -136,21 +136,7 @@ def _gen_teardown_with_actionid(self):
                             )
                         ]
                     ),
-                    body=[
-                        ast.Expr(ast_call(
-                            func=ast.Name(id="print", ctx=ast.Load()),
-                            args=[ast.BinOp(
-                                left=ast.Constant("[TAURUS][actionId] ", kind=""),
-                                op=ast.Add(),
-                                right=ast.Call(
-                                    func=ast.Name(id="str", ctx=ast.Load()),
-                                    args=[ast_attr("self._current_actionId")],
-                                    keywords=[]
-                                )
-                            )],
-                            keywords=[]
-                        ))
-                    ],
+                    body=[],
                     orelse=[]
                 ),
             ],
@@ -257,6 +243,7 @@ def __init__(self, scenario, label, wdlog=None, executor=None, ignore_unknown_ac
         self.replace_dialogs = True
         self.bzm_tdo_settings = bzm_tdo_settings
         self.do_testdata_orchestration = False
+        self.has_action_ids = False
 
     def _parse_action_params(self, expr, name):
         res = expr.match(name)
@@ -338,6 +325,8 @@ def _parse_dict_action(self, action_config):
         # the action in the generated code and logs. It is passed through multiple layers of the
         # code generation process to maintain traceability of actions.
         actionId = action_config.get("actionId")
+        if actionId is not None:
+            self.has_action_ids = True
         selectors = []
         if action_config.get("locators"):
             selectors = action_config.get("locators")
@@ -791,7 +780,7 @@ def _gen_action(self, action_config, parent_request=None, index_label=""):
         wrapInTransaction = self._is_report_inside_actions(parent_request)
 
         action_tracking = []
-        if actionId:
+        if self.has_action_ids:
             action_tracking.extend(self._gen_action_start_with_tracking(actionId))
 
         action_elements = []
@@ -880,50 +869,6 @@ def _gen_action(self, action_config, parent_request=None, index_label=""):
             action_elements.append(ast_call(func=ast_attr("waiter"), args=[]))
 
         action_body = [ast.Expr(element) for element in action_elements]
-        if actionId:
-            prefixed_error = ast.BinOp(
-                left=ast.BinOp(
-                    left=ast.Constant("[TAURUS][actionId] ", kind=""),
-                    op=ast.Add(),
-                    right=ast.Call(
-                        func=ast.Name(id="str", ctx=ast.Load()),
-                        args=[ast_attr("self._current_actionId")],
-                        keywords=[]
-                    )
-                ),
-                op=ast.Add(),
-                right=ast.BinOp(
-                    left=ast.Constant(" | ", kind=""),
-                    op=ast.Add(),
-                    right=ast.Call(
-                        func=ast.Name(id="str", ctx=ast.Load()),
-                        args=[ast.Name(id="exc", ctx=ast.Load())],
-                        keywords=[]
-                    )
-                )
-            )
-
-            action_body = [ast.Try(
-                body=action_body,
-                handlers=[ast.ExceptHandler(
-                    type=ast.Name(id="Exception", ctx=ast.Load()),
-                    name="exc",
-                    body=[ast.Raise(
-                        exc=ast.Call(
-                            func=ast.Call(
-                                func=ast.Name(id="type", ctx=ast.Load()),
-                                args=[ast.Name(id="exc", ctx=ast.Load())],
-                                keywords=[]
-                            ),
-                            args=[prefixed_error],
-                            keywords=[]
-                        ),
-                        cause=ast.Name(id="exc", ctx=ast.Load())
-                    )]
-                )],
-                orelse=[],
-                finalbody=[]
-            )]
 
         if wrapInTransaction:
             label = self._create_action_label(parent_request.label, index_label, action)
@@ -1851,7 +1796,8 @@ def _gen_classdef(self):
 
     def _gen_class_setup(self):
         data_sources = [self._gen_default_vars()]
-        data_sources.extend(self._gen_class_actionid_tracking())
+        if self.has_action_ids:
+            data_sources.extend(self._gen_class_actionid_tracking())
         for idx in range(len(self.data_sources)):
             data_sources.append(ast.Expr(ast_call(func=ast_attr("reader_%s.read_vars" % (idx + 1)))))
 
@@ -1929,7 +1875,17 @@ def _gen_class_setup(self):
         return [setup, gen_empty_line_stmt()]
 
     def _gen_class_teardown(self):
-        return self._gen_teardown_with_actionid()
+        if self.has_action_ids:
+            return self._gen_teardown_with_actionid()
+
+        body = [
+            ast.If(
+                test=ast_attr("self.driver"),
+                body=[ast.Expr(ast_call(func=ast_attr("self.driver.quit")))],
+                orelse=[]
+            )
+        ]
+        return ast.FunctionDef(name="tearDown", args=[ast_attr("self")], body=body, decorator_list=[])
 
     def _nfc_preprocess(self, requests):
         setup = []
@@ -2021,18 +1977,86 @@ def _gen_master_test_method(self, try_block, finally_block):
         if not try_block:
             raise TaurusConfigError("Supported transactions not found, test is empty")
 
-        body = []
-        for slave_name in try_block:
-            body.append(ast.Expr(ast_call(func=ast_attr("self." + slave_name))))
+        main_body = []
+        for step_method_name in try_block:
+            main_body.append(ast.Expr(ast_call(func=ast_attr("self." + step_method_name))))
 
         finally_body = []
-        for slave_name in finally_block:
-            finally_body.append(ast.Expr(ast_call(func=ast_attr("self." + slave_name))))
+        for step_method_name in finally_block:
+            finally_body.append(ast.Expr(ast_call(func=ast_attr("self." + step_method_name))))
 
         if finally_body:
             teardown_marker = ast.Expr(ast_call(func=ast_attr("apiritif.set_stage"), args=[self._gen_expr("teardown")]))
             finally_body.insert(0, teardown_marker)
-            body = [gen_try_except(try_body=body, final_body=finally_body)]
+
+        if self.has_action_ids:
+            prefixed_error = ast.BinOp(
+                left=ast.BinOp(
+                    left=ast.BinOp(
+                        left=ast.Constant("actionId: ", kind=""),
+                        op=ast.Add(),
+                        right=ast.Call(
+                            func=ast.Name(id="str", ctx=ast.Load()),
+                            args=[ast_attr("self._current_actionId")],
+                            keywords=[]
+                        )
+                    ),
+                    op=ast.Add(),
+                    right=ast.Constant(" | ", kind="")
+                ),
+                op=ast.Add(),
+                right=ast.Call(
+                    func=ast.Name(id="str", ctx=ast.Load()),
+                    args=[ast.Name(id="exc", ctx=ast.Load())],
+                    keywords=[]
+                )
+            )
+
+            final_error = ast.IfExp(
+                test=ast.Compare(
+                    left=ast_attr("self._current_actionId"),
+                    ops=[ast.IsNot()],
+                    comparators=[ast.Constant(value=None, kind="")]
+                ),
+                body=prefixed_error,
+                orelse=ast.Call(
+                    func=ast.Name(id="str", ctx=ast.Load()),
+                    args=[ast.Name(id="exc", ctx=ast.Load())],
+                    keywords=[]
+                )
+            )
+
+            body = [ast.Try(
+                body=main_body,
+                handlers=[ast.ExceptHandler(
+                    type=ast.Name(id="Exception", ctx=ast.Load()),
+                    name="exc",
+                    body=[ast.Raise(
+                        exc=ast.Call(
+                            func=ast.Call(
+                                func=ast.Name(id="type", ctx=ast.Load()),
+                                args=[ast.Name(id="exc", ctx=ast.Load())],
+                                keywords=[]
+                            ),
+                            args=[final_error],
+                            keywords=[]
+                        ),
+                        cause=ast.Name(id="exc", ctx=ast.Load())
+                    )]
+                )],
+                orelse=[],
+                finalbody=finally_body
+            )]
+        else:
+            if finally_body:
+                body = [ast.Try(
+                    body=main_body,
+                    handlers=[],
+                    orelse=[],
+                    finalbody=finally_body
+                )]
+            else:
+                body = main_body
 
         name = 'test_' + create_method_name(self.label)
         return self._gen_test_method(name=name, body=body)