feat(structure_handler): initialize conditional steps logic

tests/test_conditional_steps.py

@@ -0,0 +1,66 @@
+import re
+import inspect
+import pytest
+
+from universum import __main__
+
+
+true_branch_step_name = "true_branch"
+false_branch_step_name = "false_branch"
+
+
+def test_conditional_true_branch(tmpdir, capsys):
+    check_conditional_step_success(tmpdir, capsys, conditional_step_passed=True)
+
+
+def test_conditional_false_branch(tmpdir, capsys):
+    check_conditional_step_success(tmpdir, capsys, conditional_step_passed=False)
+
+
+def check_conditional_step_success(tmpdir, capsys, conditional_step_passed):
+    config_file = build_config_file(tmpdir, conditional_step_passed)
+    check_conditional_step(tmpdir, capsys, config_file, conditional_step_passed)
+
+
+def build_config_file(tmpdir, conditional_step_passed):
+    conditional_step_exit_code = 0 if conditional_step_passed else 1
+
+    config = inspect.cleandoc(f'''
+        from universum.configuration_support import Configuration, Step
+
+        true_branch_step = Step(name='{true_branch_step_name}', command=['touch', '{true_branch_step_name}'])
+        false_branch_step = Step(name='{false_branch_step_name}', command=['touch', '{false_branch_step_name}'])
+        conditional_step = Configuration([dict(name='conditional',
+            command=['bash', '-c', 'exit {conditional_step_exit_code}'],
+            if_succeeded=true_branch_step, if_failed=false_branch_step)])
+
+        configs = conditional_step
+    ''')
+
+    config_file = tmpdir.join("configs.py")
+    config_file.write_text(config, "utf-8")
+
+    return config_file
+
+
+def check_conditional_step(tmpdir, capsys, config_file, conditional_step_passed):
+    artifacts_dir = tmpdir.join("artifacts")
+    params = ["-vt", "none",
+              "-fsd", str(tmpdir),
+              "-ad", str(artifacts_dir),
+              "--clean-build",
+              "-o", "console"]
+    params.extend(["-cfg", str(config_file)])
+
+    return_code = __main__.main(params)
+    assert return_code == 0
+
+    captured = capsys.readouterr()
+    print(captured.out)
+    conditional_succeeded_regexp = r"\] conditional.*Success.*\|   5\.2"
+    assert re.search(conditional_succeeded_regexp, captured.out, re.DOTALL)
+
+    expected_log = true_branch_step_name if conditional_step_passed else false_branch_step_name
+    unexpected_log = false_branch_step_name if conditional_step_passed else true_branch_step_name
+    assert expected_log in captured.out
+    assert not unexpected_log in captured

universum/configuration_support.py

@@ -170,6 +170,8 @@ def __init__(self,
                  pass_tag: str = '',
                  fail_tag: str = '',
                  if_env_set: str = '',
+                 if_succeeded = None,
+                 if_failed = None,
                  **kwargs) -> None:
         self.name: str = name
         self.directory: str = directory
@@ -185,6 +187,9 @@ def __init__(self,
         self.pass_tag: str = pass_tag
         self.fail_tag: str = fail_tag
         self.if_env_set: str = if_env_set
+        self.if_succeeded = if_succeeded
+        self.if_failed = if_failed
+        self.is_conditional = self.if_succeeded or self.if_failed
         self.children: Optional['Configuration'] = None
         self._extras: Dict[str, str] = {}
         for key, value in kwargs.items():
@@ -391,6 +396,9 @@ def __add__(self, other: 'Step') -> 'Step':
             pass_tag=self.pass_tag + other.pass_tag,
             fail_tag=self.fail_tag + other.fail_tag,
             if_env_set=self.if_env_set + other.if_env_set,
+            # FIXME: This is a dummy implementation. Define addition logic and implement it.
+            if_succeeded=other.if_succeeded,
+            if_failed=other.if_failed,
             **combine(self._extras, other._extras)
         )
 

universum/modules/launcher.py

@@ -282,8 +282,9 @@ def finalize(self) -> None:
                 text = utils.trim_and_convert_to_unicode(text)
                 if self.file:
                     self.file.write(text + "\n")
-                self.add_tag(self.configuration.fail_tag)
-                self._error = text
+                if not self.configuration.is_conditional:
+                    self.add_tag(self.configuration.fail_tag)
+                    self._error = text
                 return
 
             self.add_tag(self.configuration.pass_tag)

universum/modules/structure_handler.py

@@ -148,10 +148,10 @@ def block(self, *, block_name: str, pass_errors: bool) -> Generator:
             yield
         except SilentAbortException:
             raise
-        except CriticalCiException as e:
+        except CriticalCiException as e:  # system/environment step failed
             self.fail_current_block(str(e))
             raise SilentAbortException() from e
-        except Exception as e:
+        except Exception as e:  # unexpected failure, should not occur
             if pass_errors is True:
                 raise
             self.fail_current_block(str(e))
@@ -244,12 +244,13 @@ def execute_steps_recursively(self, parent: Step,
                 with self.block(block_name=step_label, pass_errors=True):
                     current_step_failed = not self.execute_steps_recursively(merged_item, child.children, step_executor,
                                                                              skip_execution)
+            elif child.is_conditional:
+                current_step_failed = not self.execute_conditional_step(merged_item, step_executor)
             else:
                 if merged_item.finish_background and self.active_background_steps:
                     self.out.log("All ongoing background steps should be finished before next step execution")
                     if not self.report_background_steps():
                         skip_execution = True
-
                 current_step_failed = not self.process_one_step(merged_item, step_executor, skip_execution)
 
             if current_step_failed:
@@ -264,6 +265,20 @@ def execute_steps_recursively(self, parent: Step,
 
         return not some_step_failed
 
+
+    def execute_conditional_step(self, step, step_executor):
+        self.configs_current_number += 1
+        step_name = self._build_step_name(step.name)
+        conditional_step_succeeded = False
+        with self.block(block_name=step_name, pass_errors=True):
+            process = self.execute_one_step(step, step_executor);
+            conditional_step_succeeded = not process.get_error()
+        step_to_execute = step.if_succeeded if conditional_step_succeeded else step.if_failed
+        return self.execute_steps_recursively(parent=Step(),
+                                              children=Configuration([step_to_execute]),
+                                              step_executor=step_executor,
+                                              skip_execution=False)
+
     def report_background_steps(self) -> bool:
         result: bool = True
         for item in self.active_background_steps:
@@ -282,7 +297,10 @@ def report_background_steps(self) -> bool:
         return result
 
     def execute_step_structure(self, configs: Configuration, step_executor) -> None:
-        self.configs_total_count = sum(1 for _ in configs.all())
+        for config in configs.all():
+            self.configs_total_count += 1
+            if config.if_succeeded or config.if_failed:
+                self.configs_total_count += 1
         self.step_num_len = len(str(self.configs_total_count))
         self.group_numbering = f" [ {'':{self.step_num_len}}+{'':{self.step_num_len}} ] "
 
@@ -292,6 +310,11 @@ def execute_step_structure(self, configs: Configuration, step_executor) -> None:
             with self.block(block_name="Reporting background steps", pass_errors=False):
                 self.report_background_steps()
 
+    def _build_step_name(self, name):
+        step_num_len = len(str(self.configs_total_count))
+        numbering = f" [ {self.configs_current_number:>{step_num_len}}/{self.configs_total_count} ] "
+        return numbering + name
+
 
 class HasStructure(Module):
     structure_factory: ClassVar = Dependency(StructureHandler)