ApiLogicServer 15.1.3__py3-none-any.whl → 15.2.3__py3-none-any.whl

api_logic_server_cli/prototypes/base/test/api_logic_server_behave/behave_logic_report.py

@@ -92,19 +92,63 @@ def show_logic(scenario: str, logic_logs_dir: str):
         with open(logic_file_name) as logic:
             logic_lines = logic.readlines()
         is_logic_log = True
-        for each_logic_line in logic_lines:
+        last_rules_start = -1
+        last_rules_end = -1
+        
+        # Find ALL "These Rules Fired" sections and choose the one with the most rules
+        rules_sections = []
+        i = 0
+        while i < len(logic_lines):
+            if "These Rules Fired" in logic_lines[i]:
+                start_pos = i + 1
+                # Find the end of this rules section
+                end_pos = start_pos
+                while end_pos < len(logic_lines):
+                    if 'Logic Phase:' in logic_lines[end_pos] and 'COMPLETE' in logic_lines[end_pos]:
+                        break
+                    end_pos += 1
+                
+                # Count non-empty rule lines in this section (after removing trailers)
+                rule_count = 0
+                for j in range(start_pos, end_pos):
+                    line = remove_trailer(logic_lines[j]).strip()
+                    if line and not line.startswith('Logic Phase:'):
+                        rule_count += 1
+                
+                rules_sections.append({
+                    'start': start_pos,
+                    'end': end_pos,
+                    'rule_count': rule_count
+                })
+                i = end_pos
+            else:
+                i += 1
+        
+        # Choose the section with the most rules
+        if rules_sections:
+            best_section = max(rules_sections, key=lambda x: x['rule_count'])
+            last_rules_start = best_section['start']
+            last_rules_end = best_section['end']
+        else:
+            last_rules_start = -1
+            last_rules_end = -1
+                    
+        # Now process the file, collecting logic log and extracting the last rules section
+        for i, each_logic_line in enumerate(logic_lines):
             each_logic_line = remove_trailer(each_logic_line)
+            
             if is_logic_log:
-                if "Rules Fired" in each_logic_line:
+                if "These Rules Fired" in each_logic_line:
                     is_logic_log = False
-                    continue
                 else:
                     logic_log.append(each_logic_line)
-            else:
-                if 'logic_logger - INFO' in each_logic_line:
-                    pass
-                    break
-                wiki_data.append(each_logic_line + "  ")
+            
+            # Extract rules from the last "These Rules Fired" section
+            if last_rules_start <= i < last_rules_end:
+                # Skip empty lines
+                if each_logic_line.strip():
+                    wiki_data.append(each_logic_line + "  ")
+        
         wiki_data.append("```")
         wiki_data.append(f'**Logic Log** in Scenario: {scenario}')
         wiki_data.append("```")
@@ -167,15 +211,21 @@ def main(behave_log: str, scenario_logs: str, wiki: str, prepend_wiki: str):
 
     just_saw_then = False
     current_scenario = ""
+    previous_scenario = ""
     for each_line in contents:
         if just_saw_then and each_line == "\n":
             show_logic(scenario=current_scenario, logic_logs_dir=scenario_logs)
-        just_saw_then = False
+            just_saw_then = False
+            previous_scenario = ""
         if each_line.startswith("Feature"):
             wiki_data.append("&nbsp;")
             wiki_data.append("&nbsp;")
             each_line = "## " + each_line
         if each_line.startswith("  Scenario"):
+            # Before starting new scenario, show logic for previous one if we saw Then
+            if just_saw_then and previous_scenario:
+                show_logic(scenario=previous_scenario, logic_logs_dir=scenario_logs)
+            just_saw_then = False
             each_line = tab + each_line
         if each_line.startswith("    Given") or \
                 each_line.startswith("    When") or \
@@ -191,6 +241,7 @@ def main(behave_log: str, scenario_logs: str, wiki: str, prepend_wiki: str):
         each_line = each_line.rstrip()
         if "Scenario" in each_line:
             current_scenario = each_line[18:]
+            previous_scenario = current_scenario
             wiki_data.append("&nbsp;")
             wiki_data.append("&nbsp;")
             wiki_data.append("### " + each_line[8:])
@@ -198,6 +249,10 @@ def main(behave_log: str, scenario_logs: str, wiki: str, prepend_wiki: str):
         each_line = each_line + "  "  # wiki for "new line"
         
         wiki_data.append(each_line)
+    
+    # Show logic for the last scenario if we saw Then
+    if just_saw_then and current_scenario:
+        show_logic(scenario=current_scenario, logic_logs_dir=scenario_logs)
 
     with open(wiki, 'w') as rpt:
         rpt.write('\n'.join(wiki_data))

api_logic_server_cli/prototypes/base/test/api_logic_server_behave/behave_logic_report.py.bak

@@ -0,0 +1,285 @@
+import requests
+from pathlib import Path
+import os
+import ast
+import sys
+import click
+
+"""
+Creates wiki file from test/behave/behave.log, with rule use.
+
+Tips
+* use 2 spaces (at end) for newline
+* for tab: & emsp;
+
+"""
+
+tab = " "
+behave_debug_info = " # "
+wiki_data = []
+debug_scenario = "XXGood Order Custom Service"
+
+scenario_doc_strings = {}
+""" dict of scenario_name, array of strings """
+
+
+def remove_trailer(line: str) -> str:
+    """ remove everything after the ## """
+    end_here = line.find("\t\t##")
+    result = line[0:end_here]
+    return result
+
+def line_spacer():
+    wiki_data.append("\n")
+    wiki_data.append(" ")
+    wiki_data.append(" ")
+    wiki_data.append("\n")
+
+
+def get_current_readme(prepend_wiki: str):
+    """ initialize wiki_data with readme up to {report_name} """
+    report_name = "Behave Logic Report"
+    with open(prepend_wiki) as readme:
+        readme_lines = readme.readlines()
+    need_spacer = True
+    for each_readme_line in readme_lines:
+        if '# ' + report_name in each_readme_line:
+            need_spacer = False
+            break
+        wiki_data.append(each_readme_line[0:-1])
+    if need_spacer:
+        line_spacer()
+    wiki_data.append(f'# {report_name}')
+
+def get_truncated_scenario_name(scenario_name: str) -> str:
+    """ address max file length (chop at 26), illegal characters """
+    scenario_trunc = scenario_name
+    if scenario_trunc is not None and len(scenario_trunc) >= 26:
+        scenario_trunc = scenario_name[0:25]
+    scenario_trunc = f'{str(scenario_trunc).replace(" ", "_")}'
+    return scenario_trunc
+
+
+def show_logic(scenario: str, logic_logs_dir: str):
+    """ insert s{logic_logs_dir}/scenario.log into wiki_data as disclosure area """
+    scenario_trunc = get_truncated_scenario_name(scenario)
+    logic_file_name = f'{logic_logs_dir}/{scenario_trunc}.log'
+    logic_file_name_path = Path(logic_file_name)
+    if not logic_file_name_path.is_file():  # debug code
+        # wiki_data.append(f'unable to find Logic Log file: {logic_file_name}')
+        if scenario == debug_scenario:
+            print(f'RELATIVE: {logic_file_name} in {os.getcwd()}')
+            full_name = f'{os.getcwd()}/{logic_file_name}'
+            print(f'..FULL: {os.getcwd()}/{logic_file_name}')
+            logic_file_name = '{logic_logs_dir}/test.log'
+            with open(logic_file_name) as logic:
+                logic_lines = logic.readlines()
+    else:
+        logic_log = []
+        rules_used = []
+        wiki_data.append("<details markdown>")
+        wiki_data.append("<summary>Tests - and their logic - are transparent.. click to see Logic</summary>")
+        line_spacer()
+        scenario_trunc = get_truncated_scenario_name(scenario)
+        if scenario_trunc in scenario_doc_strings:
+            wiki_data.append(f'**Logic Doc** for scenario: {scenario}')
+            wiki_data.append("   ")
+            for each_doc_string_line in scenario_doc_strings[scenario_trunc]:
+                wiki_data.append(each_doc_string_line[0: -1])
+            line_spacer()
+        wiki_data.append(f'**Rules Used** in Scenario: {scenario}')
+        wiki_data.append("```")
+        with open(logic_file_name) as logic:
+            logic_lines = logic.readlines()
+        is_logic_log = True
+        last_rules_start = -1
+        last_rules_end = -1
+        
+        # First, find the LAST "These Rules Fired" section
+        for i, each_logic_line in enumerate(logic_lines):
+            if "These Rules Fired" in each_logic_line:
+                last_rules_start = i + 1  # Start collecting from next line
+                last_rules_end = -1  # Reset end marker to find the next COMPLETE
+            elif last_rules_start > 0 and last_rules_end == -1:
+                if 'Logic Phase:' in each_logic_line and 'COMPLETE' in each_logic_line:
+                    last_rules_end = i
+                    
+        # Now process the file, collecting logic log and extracting the last rules section
+        for i, each_logic_line in enumerate(logic_lines):
+            each_logic_line = remove_trailer(each_logic_line)
+            
+            if is_logic_log:
+                if "These Rules Fired" in each_logic_line:
+                    is_logic_log = False
+                else:
+                    logic_log.append(each_logic_line)
+            
+            # Extract rules from the last "These Rules Fired" section
+            if last_rules_start <= i < last_rules_end:
+                # Skip empty lines
+                if each_logic_line.strip():
+                    wiki_data.append(each_logic_line + "  ")
+        
+        wiki_data.append("```")
+        wiki_data.append(f'**Logic Log** in Scenario: {scenario}')
+        wiki_data.append("```")
+        for each_logic_log in logic_log:
+            each_line = remove_trailer(each_logic_log)
+            wiki_data.append(each_line)
+        wiki_data.append("```")
+        wiki_data.append("</details>")
+
+
+def get_docStrings(steps_dir: str):
+    steps_dir_files = os.listdir(steps_dir)
+    indent = 4  # skip leading blanks
+    for each_steps_dir_file in steps_dir_files:
+        each_steps_dir_file_path = Path(steps_dir).joinpath(each_steps_dir_file)
+        if each_steps_dir_file_path.is_file():
+            with open(each_steps_dir_file_path) as f:
+                step_code = f.readlines()
+            # print(f'Found File: {str(each_steps_dir_file_path)}')
+            for index, each_step_code_line in enumerate(step_code):
+                if each_step_code_line.startswith('@when'):
+                    comment_start = index + 2
+                    if '"""' in step_code[comment_start]:
+                        # print(".. found doc string")
+                        doc_string_line = comment_start+1
+                        doc_string = []
+                        while (True):
+                            if '"""' in step_code[doc_string_line]:
+                                break
+                            doc_string.append(step_code[doc_string_line][indent:])
+                            doc_string_line += 1
+                        scenario_line = doc_string_line+1
+                        if 'scenario_name' not in step_code[scenario_line]:
+                            print(f'\n** Warning - scenario_name not found '\
+                                f'in file {str(each_steps_dir_file_path)}, '\
+                                f'after line {scenario_line} -- skipped')
+                        else:
+                            scenario_code_line = step_code[scenario_line]
+                            scenario_name_start = scenario_code_line.find("'") + 1
+                            scenario_name_end = scenario_code_line[scenario_name_start+1:].find("'")
+                            scenario_name = scenario_code_line[scenario_name_start: 
+                                scenario_name_end + scenario_name_start+1]
+                            if scenario_name == debug_scenario:
+                                print(f'got {debug_scenario}')
+                            scenario_trunc = get_truncated_scenario_name(scenario_name)
+                            # print(f'.... truncated scenario_name: {scenario_trunc} in {scenario_code_line}')
+                            scenario_doc_strings[scenario_trunc] = doc_string
+    # print("that's all, folks")
+
+
+def main(behave_log: str, scenario_logs: str, wiki: str, prepend_wiki: str):
+    """ main driver """
+    get_docStrings(steps_dir="features/steps")
+
+    get_current_readme(prepend_wiki=prepend_wiki)
+
+    contents = None
+    with open(behave_log) as f:
+        contents = f.readlines()
+
+    just_saw_then = False
+    current_scenario = ""
+    for each_line in contents:
+        # Show logic when we hit a blank line after assertions OR when starting a new scenario
+        if just_saw_then and (each_line == "\n" or each_line.startswith("  Scenario")):
+            show_logic(scenario=current_scenario, logic_logs_dir=scenario_logs)
+            just_saw_then = False
+            
+        if each_line.startswith("Feature"):
+            wiki_data.append("&nbsp;")
+            wiki_data.append("&nbsp;")
+            each_line = "## " + each_line
+            
+        if each_line.startswith("  Scenario"):
+            # Extract scenario name for logic lookup
+            current_scenario = each_line.strip().replace("Scenario: ", "").replace("  ", " ").strip()
+            wiki_data.append("&nbsp;")
+            wiki_data.append("&nbsp;")
+            wiki_data.append("### " + each_line[2:])  # Add scenario header
+            each_line = tab + each_line
+            
+        if each_line.startswith("    Given") or \
+                each_line.startswith("    When") or \
+                each_line.startswith("    Then") or \
+                each_line.startswith("    And"):
+            if each_line.startswith("    Then") or each_line.startswith("    And"):
+                just_saw_then = True
+            # Add subtle formatting to keywords
+            for keyword in ["Given", "When", "Then", "And"]:
+                if f"    {keyword} " in each_line:
+                    each_line = each_line.replace(f"    {keyword} ", f"    **{keyword}** ")
+                    break
+            each_line = tab + tab + each_line
+
+        each_line = each_line[:-1]
+        debug_loc = each_line.find(behave_debug_info)
+        if debug_loc > 0:
+            each_line = each_line[0 : debug_loc]
+        each_line = each_line.rstrip()
+
+        each_line = each_line + "  "  # wiki for "new line"
+        
+        wiki_data.append(each_line)
+
+    # Show logic for the last scenario
+    if current_scenario and just_saw_then:
+        show_logic(scenario=current_scenario, logic_logs_dir=scenario_logs)
+
+    with open(wiki, 'w') as rpt:
+        rpt.write('\n'.join(wiki_data))
+    wiki_full_path = Path(wiki).absolute()
+    print(f'Wiki Output: {wiki_full_path}\n\n')
+
+
+
+def print_args(args, msg):
+    print(msg)
+    for each_arg in args:
+        print(f'  {each_arg}')
+    print(" ")
+
+
+@click.group()
+@click.pass_context
+def cli(ctx):
+    """
+    Combine behave.log and scenario_logic_logs to create Behave Logic Report
+
+    """
+    pass
+
+
+@cli.command("run")
+@click.pass_context
+@click.option('--behave_log',
+              default=f'logs/behave.log',  # cwd set to test/api_logic_server_behave
+              # prompt="Log from behave test suite run [behave.log]",
+              help="Help")
+@click.option('--scenario_logs',
+              default=f'logs/scenario_logic_logs',
+              # prompt="Logic Log directory from ",
+              help="Help")
+@click.option('--wiki',
+              default=f'reports/Behave Logic Report.md',
+              # prompt="Log from behave test suite run [api_logic_server_behave]",
+              help="Help")
+@click.option('--prepend_wiki',
+              default=f'reports/Behave Logic Report Intro micro.md',
+              # prompt="Log from behave test suite run [Behave Logic Report Intro]",
+              help="Help")
+def run(ctx, behave_log: str, scenario_logs: str, wiki: str, prepend_wiki: str):
+    main(behave_log = behave_log, scenario_logs = scenario_logs, wiki = wiki, prepend_wiki = prepend_wiki)
+
+
+if __name__ == '__main__':  # debugger & python command line start here
+    # eg: python api_logic_server_cli/cli.py create --project_name=~/Desktop/test_project
+    # unix: python api_logic_server_cli/cli.py create --project_name=/home/ApiLogicProject
+
+    print(f'\nBehave Logic Report 1.1, started at {os.getcwd()}')
+    commands = sys.argv
+    if len(sys.argv) > 1:
+        print_args(commands, f'\n\nCommand Line Arguments:')
+    cli()

api_logic_server_cli/prototypes/base/test/api_logic_server_behave/check_step_order.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Verify Behave step ordering for multi-param patterns.
+
+Usage:
+    cd test/api_logic_server_behave
+    python check_step_order.py
+
+This script checks if Behave step patterns are ordered from most specific
+to most general, preventing Rule #0.5 violations that cause silent test failures.
+
+Rule #0.5: Behave matches steps by FIRST pattern that fits.
+More specific patterns MUST come before general ones.
+"""
+import re
+import sys
+from pathlib import Path
+
+
+def check_step_order(steps_file):
+    """
+    Check if multi-item patterns come before single-item patterns.
+    
+    Returns list of issues found, or empty list if order is correct.
+    """
+    with open(steps_file) as f:
+        lines = f.readlines()
+    
+    issues = []
+    when_patterns = []
+    
+    for i, line in enumerate(lines, 1):
+        # Look for @when patterns with parameters
+        if match := re.match(r"@when\('.*with.*\{", line):
+            # Calculate specificity score
+            param_count = line.count('{')  # More parameters = more specific
+            has_and = ' and ' in line  # "and" keyword = multi-item pattern
+            
+            # Check for special keywords that make patterns more specific
+            special_keywords = ['carbon neutral', 'shipped', 'unshipped']
+            has_special_keyword = any(k in line for k in special_keywords)
+            
+            # Specificity score: higher = more specific
+            specificity = param_count + (2 if has_and else 0) + (3 if has_special_keyword else 0)
+            
+            when_patterns.append((i, specificity, line.strip()))
+    
+    # Check if patterns are in descending specificity order
+    for i in range(len(when_patterns) - 1):
+        curr_line, curr_spec, curr_text = when_patterns[i]
+        next_line, next_spec, next_text = when_patterns[i + 1]
+        
+        # Check if patterns are mutually exclusive (both have unique keywords)
+        curr_has_unique = any(k in curr_text for k in ['carbon neutral', 'shipped'])
+        next_has_unique = any(k in next_text for k in [' and '])
+        mutually_exclusive = curr_has_unique and next_has_unique
+        
+        # If next pattern is MORE specific than current AND not mutually exclusive
+        if next_spec > curr_spec and not mutually_exclusive:
+            issues.append(f"❌ Line {next_line} (specificity={next_spec}) should come BEFORE line {curr_line} (specificity={curr_spec})")
+            issues.append(f"   More specific: {next_text}")
+            issues.append(f"   Less specific: {curr_text}")
+            issues.append(f"   FIX: Move line {next_line} to BEFORE line {curr_line}")
+        
+        # CRITICAL CHECK: Multi-item must come before single-item (same base pattern)
+        curr_has_and = ' and ' in curr_text
+        next_has_and = ' and ' in next_text
+        curr_param_count = curr_text.count('{')
+        next_param_count = next_text.count('{')
+        
+        # If current is single-item (2 params, no 'and') and next is multi-item (4+ params, has 'and')
+        if (not curr_has_and and curr_param_count == 2 and 
+            next_has_and and next_param_count >= 4):
+            issues.append(f"❌ CRITICAL: Line {next_line} (multi-item) MUST come BEFORE line {curr_line} (single-item)")
+            issues.append(f"   This causes silent failures: orders not created, balance=0")
+            issues.append(f"   Multi-item: {next_text}")
+            issues.append(f"   Single-item: {curr_text}")
+            issues.append(f"   FIX: Move line {next_line} to BEFORE line {curr_line}")
+    
+    return issues
+
+
+def main():
+    """Check all step files in features/steps directory."""
+    steps_dir = Path('features/steps')
+    
+    if not steps_dir.exists():
+        print(f"❌ Directory not found: {steps_dir}")
+        print("   Run this script from: test/api_logic_server_behave/")
+        sys.exit(1)
+    
+    all_issues = []
+    files_checked = 0
+    
+    for steps_file in steps_dir.glob('*_steps.py'):
+        files_checked += 1
+        issues = check_step_order(steps_file)
+        if issues:
+            all_issues.extend([f"\n📁 {steps_file}:"] + issues)
+    
+    if all_issues:
+        print("=" * 70)
+        print("Step Ordering Issues Found (Rule #0.5 Violation)")
+        print("=" * 70)
+        print('\n'.join(all_issues))
+        print("\n" + "=" * 70)
+        print("IMPACT: Tests may pass but produce wrong results (e.g., balance=0)")
+        print("ACTION: Reorder @when patterns from most→least specific")
+        print("=" * 70)
+        sys.exit(1)
+    else:
+        print("=" * 70)
+        print(f"✅ All step patterns correctly ordered ({files_checked} files checked)")
+        print("   Rule #0.5: Most specific → Most general ✓")
+        print("=" * 70)
+        sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()