behavex 4.2.2__tar.gz → 4.2.4__tar.gz

{behavex-4.2.2/behavex.egg-info → behavex-4.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: behavex
-Version: 4.2.2
+Version: 4.2.4
 Summary: Agile testing framework on top of Behave (BDD).
 Home-page: https://github.com/hrcorval/behavex
 Author: Hernan Rey
@@ -29,7 +29,7 @@ Requires-Python: >=3.5
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: behave==1.2.6
-Requires-Dist: behavex-images>=3.0.10
+Requires-Dist: behavex-images>=3.2.1
 Requires-Dist: allure-python-commons
 Requires-Dist: jinja2
 Requires-Dist: configobj

{behavex-4.2.2 → behavex-4.2.4}/behavex/arguments.py

@@ -333,7 +333,6 @@ def parse_arguments(args):
         '--formatter-outdir',
         help="Specify the output directory for the custom formatter relative to the output folder",
         metavar='DIR',
-        default='report_artifacts',
         required=False,
     )
 

{behavex-4.2.2 → behavex-4.2.4}/behavex/conf_logging.cfg

@@ -11,12 +11,12 @@ keys=simpleFormatter
 encoding=utf-8-sig
 
 [logger_root]
-level=DEBUG
+level=INFO
 handlers=consoleHandler
 
 [handler_consoleHandler]
 class=StreamHandler
-level=DEBUG
+level=INFO
 encoding=utf-8-sig
 formatter=simpleFormatter
 args=(sys.stdout, )

{behavex-4.2.2 → behavex-4.2.4}/behavex/environment.py

@@ -11,18 +11,18 @@ from datetime import datetime
 
 from behave.contrib.scenario_autoretry import patch_scenario_with_autoretry
 from behave.log_capture import capture
-from behave.model import ScenarioOutline
+from behave.model import ScenarioOutline  # pyright: ignore[reportUnusedImport]
 from behave.runner import Context, ModelRunner
 
 from behavex import conf_mgr
 from behavex.conf_mgr import get_env, get_param
 from behavex.global_vars import global_vars
 from behavex.outputs import report_json, report_xml
-from behavex.outputs.report_utils import create_log_path, strip_ansi_codes
+from behavex.outputs.report_utils import (create_log_path, get_string_hash,
+                                          strip_ansi_codes)
 from behavex.utils import (LOGGING_CFG, create_custom_log_when_called,
                            get_autoretry_attempts, get_logging_level,
-                           get_scenario_tags, get_scenarios_instances,
-                           get_string_hash)
+                           get_scenario_tags, get_scenarios_instances)
 
 Context.__getattribute__ = create_custom_log_when_called
 
@@ -186,19 +186,19 @@ def before_scenario(context, scenario):
         scenario.start = _get_current_timestamp_ms()
 
 
-def before_step(context, step):
+def before_step(context, step):  # pyright: ignore[reportUnusedParameter]
     step.start = _get_current_timestamp_ms()
 
 
-def before_tag(context, tag):
+def before_tag(context, tag):  # pyright: ignore[reportUnusedParameter]
     pass
 
 
-def after_tag(context, tag):
+def after_tag(context, tag):  # pyright: ignore[reportUnusedParameter]
     pass
 
 
-def after_step(context, step):
+def after_step(context, step):  # pyright: ignore[reportUnusedParameter]
     step.stop = _get_current_timestamp_ms()
     try:
         if step.exception:
@@ -230,7 +230,7 @@ def after_scenario(context, scenario):
 
 
 # noinspection PyUnusedLocal
-def after_feature(context, feature):
+def after_feature(context, feature):  # pyright: ignore[reportUnusedParameter]
     try:
         if get_env('multiprocessing') and get_param('parallel_scheme') == 'scenario':
             return

{behavex-4.2.2 → behavex-4.2.4}/behavex/outputs/formatter_manager.py

@@ -9,16 +9,20 @@ Formatter manager module to handle custom formatters.
 import importlib
 import os
 import sys
-from typing import Optional, Type
+from typing import (Any, Dict, Optional,  # pyright: ignore[reportDeprecated]
+                    Type)
 
 from behavex.conf_mgr import get_env, get_param
 
+# Formatter Constants
+DEFAULT_FORMATTER_DIR = 'report-artifacts'
+
 
 class FormatterManager:
     """Manager class for handling custom formatters in BehaveX."""
 
     @staticmethod
-    def load_formatter(formatter_spec: str) -> Optional[Type]:
+    def load_formatter(formatter_spec: str) -> Optional[Type[Any]]: #pyright: ignore[reportDeprecated]
         """
         Load a formatter class from a module path specification.
 
@@ -64,25 +68,27 @@ class FormatterManager:
             return None
 
     @staticmethod
-    def get_formatter_output_dir() -> str:
+    def get_formatter_output_dir(formatter_spec: str) -> Optional[str]: #pyright: ignore[reportDeprecated]
         """
-        Get the output directory for the custom formatter.
+        Get the preferred output directory from a formatter class.
+
+        Args:
+            formatter_spec: String in format "module_path:FormatterClass"
 
         Returns:
-            Absolute path to the formatter output directory, or None if no custom directory is specified
+            The formatter's preferred output directory, or None if not found
         """
-        base_output = get_env('OUTPUT', 'output')
-        formatter_outdir = get_param('formatter_outdir', '')
-
-        # Return None if no custom formatter output directory is specified
-        # This allows formatters to use their own default directories
-        if not formatter_outdir or formatter_outdir == 'report_artifacts':
-            return None
+        try:
+            formatter_class = FormatterManager.load_formatter(formatter_spec)
+            if formatter_class and hasattr(formatter_class, 'DEFAULT_OUTPUT_DIR'):
+                return formatter_class.DEFAULT_OUTPUT_DIR
+        except Exception as e:
+            print(f"Warning: Could not load formatter {formatter_spec} to get output directory: {str(e)}")
 
-        return os.path.join(base_output, formatter_outdir)
+        return None
 
     @staticmethod
-    def format_results(json_output: dict) -> None:
+    def format_results(json_output: Dict[str, Any]) -> None: #pyright: ignore[reportDeprecated]
         """
         Format test results using the specified custom formatter.
 
@@ -97,20 +103,17 @@ class FormatterManager:
         if not formatter_class:
             return
 
-        output_dir = FormatterManager.get_formatter_output_dir()
-
-        # Create the output directory only if a custom one is specified
-        if output_dir:
-            os.makedirs(output_dir, exist_ok=True)
+        # The formatter will handle its own output directory setup
+        # No need to create directories here since formatters manage their own paths
 
         try:
             formatter = formatter_class()
             # Check if the formatter has the expected method
-            if not hasattr(formatter, 'parse_json_to_allure'):
-                print(f"Formatter {formatter_class.__name__} does not implement required method 'parse_json_to_allure'")
+            if not hasattr(formatter, 'launch_json_formatter'):
+                print(f"Formatter {formatter_class.__name__} does not implement required method 'launch_json_formatter'")
                 return
 
-            formatter.parse_json_to_allure(json_output)
+            formatter.launch_json_formatter(json_output)
         except Exception as e:
             print(f"Error running formatter {formatter_spec}: {str(e)}")
             import traceback

{behavex-4.2.2 → behavex-4.2.4}/behavex/outputs/formatters/allure_behavex_formatter.py

@@ -31,7 +31,6 @@ import os
 import re
 import sys
 import uuid
-from datetime import datetime
 from pathlib import Path
 
 from allure_commons.model2 import (Attachment, Parameter, TestResult,
@@ -40,13 +39,15 @@ from allure_commons.types import AttachmentType
 from allure_commons.utils import now
 
 from behavex.conf_mgr import get_env, get_param
-from behavex.outputs.formatter_manager import FormatterManager
 from behavex.outputs.report_utils import get_string_hash
 
 
 class AllureBehaveXFormatter:
     """Allure formatter for BehaveX test results."""
 
+    # Default output directory for this formatter
+    DEFAULT_OUTPUT_DIR = 'allure-results'
+
     def _get_step_line_from_image(self, filename):
         """Extract step line number from image filename.
 
@@ -243,7 +244,11 @@ class AllureBehaveXFormatter:
             TestResult: The updated test case with evidence attachments
         """
 
-        evidence_dir = os.path.join(get_env('logs', 'output/allure-results'), str(scenario_hash), 'evidence')
+        logs_dir = get_env('logs')
+        if logs_dir is None:
+            # Handle standalone script execution case
+            logs_dir = os.path.join(os.path.dirname(output_dir), 'outputs', 'logs')
+        evidence_dir = os.path.join(logs_dir, str(scenario_hash), 'evidence')
 
         if not os.path.exists(evidence_dir):
             return test_case
@@ -297,19 +302,20 @@ class AllureBehaveXFormatter:
 
         return test_case
 
-    def parse_json_to_allure(self, json_data):
+    def launch_json_formatter(self, json_data):
         """
-        Parses the JSON report data and converts it into Allure-compatible results.
+        Generic method to launch the formatter and process JSON test results.
 
         Args:
             json_data (dict): Dictionary containing the test results data.
         """
-        # Get the formatter output directory from FormatterManager
-        formatter_output_dir = FormatterManager.get_formatter_output_dir()
+        # Use the LOGS environment variable which is set consistently by the runner
+        # This ensures evidence, logs, and allure results are all in the same location
+        output_dir = get_env('logs')
 
-        # If a custom output directory is specified, use it.
-        # Otherwise, default to 'output/allure-results'.
-        output_dir = formatter_output_dir or os.path.join(get_env('OUTPUT', 'output'), 'allure-results')
+        # Fallback if LOGS is not set (for standalone script execution)
+        if not output_dir:
+            output_dir = os.path.join(get_env('OUTPUT') or 'output', self.DEFAULT_OUTPUT_DIR)
 
         os.makedirs(output_dir, exist_ok=True)
 
@@ -487,7 +493,11 @@ class AllureBehaveXFormatter:
                 # Process scenario logs as attachment
                 if get_param('formatter_attach_logs'):
                     scenario_hash = scenario.get('identifier_hash', get_string_hash(f"{str(feature['filename'])}-{str(scenario['line'])}"))
-                    log_path = os.path.join(get_env('logs', 'output/allure-results'), str(scenario_hash), 'scenario.log')
+                    logs_dir_for_log = get_env('logs')
+                    if logs_dir_for_log is None:
+                        # Handle standalone script execution case
+                        logs_dir_for_log = os.path.join(os.path.dirname(output_dir), 'outputs', 'logs')
+                    log_path = os.path.join(logs_dir_for_log, str(scenario_hash), 'scenario.log')
                     if os.path.exists(log_path):
                         # Use relative path for the source if possible to avoid duplication
                         rel_path = os.path.relpath(log_path, output_dir) if output_dir in log_path else log_path
@@ -637,7 +647,6 @@ class AllureBehaveXFormatter:
             with open(os.path.join(output_dir, "environment-categories.json"), "w") as f:
                 json.dump(env_categories, f, indent=2)
 
-
 def main():
     parser = argparse.ArgumentParser(description='Parse BehaveX report.json into Allure format')
     parser.add_argument('--report-path',
@@ -651,7 +660,7 @@ def main():
 
     try:
         with open(args.report_path) as f:
-            formatter.parse_json_to_allure(json.load(f))
+            formatter.launch_json_formatter(json.load(f))
     except FileNotFoundError:
         print(f"Error: Could not find report file at {args.report_path}")
         sys.exit(1)

{behavex-4.2.2 → behavex-4.2.4}/behavex/outputs/output_strings.py

@@ -45,8 +45,8 @@ TEXTS = {
         'description': '',
         'modal': {
             'title': '',
-            'body': '<b>Test Automation Rate:</b> % of automated scenarios.<br>'
-            '<b>Pass Rate:</b>: % of passed scenarios.<br>',
+            'body': ('<b>Test Automation Rate:</b> % of automated scenarios.<br>'
+                    '<b>Pass Rate:</b>: % of passed scenarios.<br>'),
         },
     },
     'joined': {'title': '', 'description': '', 'modal': {'title': '', 'modal': 'the'}},
@@ -61,9 +61,9 @@ TEXTS = {
         'serial_execution': u'\n{0}\nRunning serial scenarios (tagged as @SERIAL).\n{0}\n'.format('*' * 60),
         'running_parallels': u'\n{0}\nRunning parallel scenarios\n{0}\n'.format('*' * 60),
         'run_behave': u"Running feature '{}' with scenario '{}'.",
-        'duplicated_scenarios': '{0}\nThere are duplicate scenario names to run.\n'
-        'Parallel test execution by scenario cannot be performed.\n'
-        'Duplicated scenario names: \n{1}.\n{0}\n'.format('*' * 60, {}),
+        'duplicated_scenarios': ('{0}\nThere are duplicate scenario names to run.\n'
+                                'Parallel test execution by scenario cannot be performed.\n'
+                                'Duplicated scenario names: \n{1}.\n{0}\n').format('*' * 60, {}),
         'execution_crashed': 'Execution crashed or was interrupted when executing the scenario. No outputs could be generated.'
     },
     'folder': {'run_behave': u"Running folder: '{}' and feature '{}'."},
@@ -77,6 +77,9 @@ TEXTS = {
     'execution': {
         'callback': {
             'error': u'\nError occurred during execution callback: {}'
+        },
+        'dry_run': {
+            'completed': u'\nDry run completed. Please, see the report in {0} folder.\n\n'
         }
     },
     'parallel': {

{behavex-4.2.2 → behavex-4.2.4}/behavex/runner.py

@@ -12,37 +12,39 @@ including setup, execution, and reporting.
 from __future__ import absolute_import, print_function
 
 import codecs
-import concurrent
+import concurrent  # pyright: ignore[reportUnusedImport]
 import copy
 import io
 import json
-import logging.config
+import logging.config  # pyright: ignore[reportUnusedImport]
 import multiprocessing
 import os
 import os.path
 import platform
-import re
 import signal
 import sys
 import time
 import traceback
 from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures.process import BrokenProcessPool
 from multiprocessing import active_children
 from multiprocessing.managers import DictProxy
 from tempfile import gettempdir
+from typing import Any, Dict
 
 from behave import __main__ as behave_script
 from behave.model import Feature, Scenario, ScenarioOutline
 
 # noinspection PyUnresolvedReferences
-import behavex.outputs.report_json
 from behavex import conf_mgr
 from behavex.arguments import BEHAVE_ARGS, BEHAVEX_ARGS, parse_arguments
-from behavex.conf_mgr import ConfigRun, get_env, get_param, set_env
+from behavex.conf_mgr import ConfigRun, get_env, get_param
 from behavex.environment import extend_behave_hooks
 from behavex.execution_singleton import ExecutionSingleton
 from behavex.global_vars import global_vars
 from behavex.outputs import report_xml
+from behavex.outputs.formatter_manager import (DEFAULT_FORMATTER_DIR,
+                                               FormatterManager)
 from behavex.outputs.report_json import generate_execution_info
 from behavex.outputs.report_utils import (get_overall_status,
                                           match_for_execution,
@@ -53,13 +55,12 @@ from behavex.utils import (IncludeNameMatch, IncludePathsMatch, MatchInclude,
                            cleanup_folders, configure_logging,
                            copy_bootstrap_html_generator,
                            create_execution_complete_callback_function,
-                           expand_paths, explore_features, generate_hash,
-                           generate_reports, get_feature_and_scenario_line,
-                           get_json_results, get_logging_level,
-                           get_scenario_tags, get_scenarios_instances,
-                           get_text, join_feature_reports,
-                           join_scenario_reports, len_scenarios,
-                           print_env_variables, print_parallel,
+                           expand_paths, explore_features, generate_reports,
+                           get_feature_and_scenario_line, get_json_results,
+                           get_logging_level, get_scenario_tags,
+                           get_scenarios_instances, get_text,
+                           join_feature_reports, join_scenario_reports,
+                           len_scenarios, print_env_variables, print_parallel,
                            set_behave_tags, set_env_variable,
                            set_environ_config, set_system_paths)
 
@@ -136,8 +137,8 @@ def run(args):
         # Handle include_paths parameter
         if len(get_param('include_paths')) > 0:
             include_paths = ",".join(expand_paths(get_param('include_paths'))).replace('\n', '')
-            features_path = os.environ.get('FEATURES_PATH')
-            if features_path == '' or features_path is None or not os.path.exists(features_path):
+            features_path = os.environ.get('FEATURES_PATH', '')
+            if features_path == '' or not os.path.exists(features_path):
                 os.environ['FEATURES_PATH'] = include_paths
             else:
                 os.environ['FEATURES_PATH'] = features_path + ',' + include_paths
@@ -210,7 +211,7 @@ def launch_behavex():
     execution_codes = []
     results = None
     config = conf_mgr.get_config()
-    features_path = os.environ.get('FEATURES_PATH')
+    features_path = os.environ.get('FEATURES_PATH', '')
     parallel_scheme = get_param('parallel_scheme')
     if get_param('dry_run'):
         parallel_processes = 1
@@ -221,7 +222,7 @@ def launch_behavex():
         show_progress_bar = get_param('show_progress_bar')
     multiprocess = (
         True
-        if get_param('parallel_processes') > 1 and not get_param('dry_run')
+        if parallel_processes > 1 and not get_param('dry_run')
         else False
     )
     set_behave_tags()
@@ -283,11 +284,9 @@ def launch_behavex():
                                                             lock,
                                                             show_progress_bar)
         wrap_up_process_pools(process_pool, json_reports, scenario)
-        time_end = global_vars.execution_end_time
 
         if get_param('dry_run'):
-            msg = '\nDry run completed. Please, see the report in {0}' ' folder.\n\n'
-            print(msg.format(get_env('OUTPUT')))
+            print_parallel('execution.dry_run.completed', get_env('OUTPUT'))
 
         remove_temporary_files(parallel_processes, json_reports)
 
@@ -397,7 +396,6 @@ def create_scenario_line_references(features):
     updated_features = {}
     for feature_path, scenarios in features.items():
         for scenario in scenarios:
-            scenario_filename = text(scenario.filename)
             if global_vars.rerun_failures or ".feature:" in feature_path:
                 if feature_path not in updated_features:
                     updated_features[feature_path] = []
@@ -502,8 +500,10 @@ def launch_by_feature(features,
     for parallel_process in parallel_processes:
         try:
             parallel_process.result()
+        except (KeyboardInterrupt, SystemExit):
+            # Allow KeyboardInterrupt (Ctrl+C) and SystemExit to propagate to top level
+            raise
         except:
-            from concurrent.futures.process import BrokenProcessPool
             e = sys.exc_info()[1]
             if isinstance(e, BrokenProcessPool):
                 print_parallel('process.pool.broken.main', str(e))
@@ -625,8 +625,10 @@ def launch_by_scenario(features,
         for parallel_process in parallel_processes:
             try:
                 parallel_process.result()
+            except (KeyboardInterrupt, SystemExit):
+                # Allow KeyboardInterrupt (Ctrl+C) and SystemExit to propagate to top level
+                raise
             except:
-                from concurrent.futures.process import BrokenProcessPool
                 e = sys.exc_info()[1]
                 if isinstance(e, BrokenProcessPool):
                     print_parallel('process.pool.broken.main', str(e))
@@ -772,21 +774,57 @@ def _launch_behave(behave_args):
 
         # Use a custom output capture class that mirrors to console and captures
         class TeePrint:
+            """A complete wrapper for stdout that captures output while maintaining all stdout functionality."""
+
             def __init__(self, original_stdout):
-                self.original_stdout = original_stdout
-                self.captured = io.StringIO()
+                # Use object.__setattr__ to avoid recursion with __setattr__
+                object.__setattr__(self, 'original_stdout', original_stdout)
+                object.__setattr__(self, 'captured', io.StringIO())
 
             def write(self, data):
+                """Override write to capture output while maintaining original behavior."""
                 self.original_stdout.write(data)
                 self.captured.write(data)
+                return len(data) if hasattr(data, '__len__') else None
 
             def flush(self):
+                """Override flush to flush both original and captured streams."""
                 self.original_stdout.flush()
                 self.captured.flush()
 
             def getvalue(self):
+                """Custom method to get captured output."""
                 return self.captured.getvalue()
 
+            def __getattr__(self, name):
+                """Delegate all other attributes/methods to the original stdout."""
+                try:
+                    return getattr(self.original_stdout, name)
+                except AttributeError:
+                    raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+            def __setattr__(self, name, value):
+                """Delegate attribute setting to original stdout (except for our internal attributes)."""
+                if name in ('original_stdout', 'captured'):
+                    object.__setattr__(self, name, value)
+                else:
+                    setattr(self.original_stdout, name, value)
+
+            def __getattribute__(self, name):
+                """Handle attribute access with proper delegation."""
+                # Handle our own methods and attributes first
+                if name in ('original_stdout', 'captured', 'write', 'flush', 'getvalue',
+                           '__class__', '__dict__', '__getattr__', '__setattr__'):
+                    return object.__getattribute__(self, name)
+
+                # For common stdout properties, delegate to original_stdout
+                try:
+                    original_stdout = object.__getattribute__(self, 'original_stdout')
+                    return getattr(original_stdout, name)
+                except (AttributeError, KeyError):
+                    # Fallback to our own implementation
+                    return object.__getattribute__(self, name)
+
         # Create the tee capture object
         tee = TeePrint(sys.__stdout__)
 
@@ -867,7 +905,7 @@ def wrap_up_process_pools(process_pool,
     output = os.path.join(get_env('OUTPUT'))
     try:
         process_pool.shutdown(wait=True)
-    except Exception as ex:
+    except Exception:
         process_pool.shutdown(wait=False, cancel_futures=True)
     if type(json_reports) is list:
         if scenario:
@@ -1049,8 +1087,25 @@ def _set_env_variables(args):
     if get_param('name'):
         set_env_variable('NAME', args.name)
     if get_param('formatter'):
-        formatter_outdir = get_param('formatter_outdir')
-        set_env_variable('LOGS', os.path.join(get_env('output'), formatter_outdir))
+        formatter_outdir = get_param('formatter_outdir', '')
+        formatter_spec = get_param('formatter')
+
+        # If no formatter output directory is specified, use the default
+        if not formatter_outdir:
+            formatter_outdir = DEFAULT_FORMATTER_DIR
+
+        # Special handling for custom formatters with default settings
+        if formatter_outdir == DEFAULT_FORMATTER_DIR and formatter_spec:
+            # Try to dynamically get the formatter's preferred output directory
+            custom_formatter_dir = FormatterManager.get_formatter_output_dir(formatter_spec)
+            if custom_formatter_dir:
+                # Use the formatter's preferred directory to maintain consistency
+                set_env_variable('LOGS', os.path.join(get_env('output'), custom_formatter_dir))
+            else:
+                # Fallback to default formatter directory
+                set_env_variable('LOGS', os.path.join(get_env('output'), formatter_outdir))
+        else:
+            set_env_variable('LOGS', os.path.join(get_env('output'), formatter_outdir))
     else:
         set_env_variable('LOGS', os.path.join(get_env('output'), 'outputs', 'logs'))
     for arg in BEHAVEX_ARGS[4:]:
@@ -1267,8 +1322,9 @@ def dump_json_results():
         process_name = multiprocessing.current_process().name.split('-')[-1]
         path_info = os.path.join(gettempdir(), 'result{}.tmp'.format(process_name))
 
-    def _load_json():
+    def _load_json() -> Dict[str, Any]:
         """this function load from file"""
+        json_output_converted = {}
         with open(path_info, 'r') as info_file:
             json_output_file = info_file.read()
             json_output_converted = json.loads(json_output_file)