ApiLogicServer 15.0.61__py3-none-any.whl → 15.1.0__py3-none-any.whl

api_logic_server_cli/prototypes/manager/samples/basic_demo/test/api_logic_server_behave/behave_logic_report.py

@@ -0,0 +1,256 @@
+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
+        for each_logic_line in logic_lines:
+            each_logic_line = remove_trailer(each_logic_line)
+            if is_logic_log:
+                if "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 + "  ")
+        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:
+        if just_saw_then and each_line == "\n":
+            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"):
+            each_line = tab + each_line
+        if each_line.startswith("    Given") or \
+                each_line.startswith("    When") or \
+                each_line.startswith("    Then"):
+            if each_line.startswith("    Then"):
+                just_saw_then = True
+            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()
+        if "Scenario" in each_line:
+            current_scenario = each_line[18:]
+            wiki_data.append("&nbsp;")
+            wiki_data.append("&nbsp;")
+            wiki_data.append("### " + each_line[8:])
+
+        each_line = each_line + "  "  # wiki for "new line"
+        
+        wiki_data.append(each_line)
+
+    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/manager/samples/basic_demo/test/api_logic_server_behave/behave_run.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+# -*- coding: utf-8 -*-
+# ASSUMPTION: behave is installed.
+
+# presumes cwd is at ${workspaceFolder}/test/api_logic_server_behave
+# if not, sets cwd to __file__.parent (5/29/2024)
+
+# 9/2/2021: added log file check to force fail if 'Assertion Failed' in log file
+
+# shoutout: https://github.com/behave/behave/issues/709
+
+import sys, os
+import datetime
+from pathlib import Path
+
+try:
+    from behave.__main__ import main as behave_main  # behave is pip'd...
+except:
+    python_path = ""
+    for p in sys.path:
+        python_path += f'..{p}\n'
+    raise Exception(f"\nbehave_run - unable to find behave.  PYTHONPATH..\n{python_path}") 
+
+if __name__ == "__main__":
+    # uses cwd, eg, ${workspaceFolder}/test/api_logic_server_behave
+    print("\nbehave_run 1.0 started at:", os.getcwd())
+    cwd = Path(os.getcwd())
+    features_path = cwd.joinpath('features')
+    if not features_path.exists():
+        api_logic_server_behave_path = (Path(__file__).parent).absolute()
+        print(f".. Fixing CWD to parent of: {__file__}...")
+        print(f".. .. {api_logic_server_behave_path}")
+        os.chdir(str(api_logic_server_behave_path))  # fails if does not exist
+    pass
+
+    behave_result = behave_main()
+
+    log_file_name = None
+    n = len(sys.argv)
+    for i in range(1, n):
+        arg = sys.argv[i]
+        if sys.argv[i].startswith("--outfile"):
+            log_file_name = sys.argv[i][10:]
+        
+    date_time = str(datetime.datetime.now().strftime("%B %d, %Y %H:%M:%S"))
+    if log_file_name is None:
+        sys.stdout.write(f'\n{__file__} completed at {date_time} (no log)')
+    else:
+        with open(log_file_name, 'a') as log_file:
+            log_file.write(f'')
+            log_file.write(f'  ')
+            log_file.write(f'')
+            log_file.write(f'\n{__file__} completed at {date_time}')
+        with open(log_file_name, 'r') as log_file:
+            """ force a fail if 'Assertion Failed' in log file
+            evidently behave eats the exceptions, so we need to check the log file
+            """
+            log_file_data = log_file.read()
+            if behave_result == 0 and 'Assertion Failed' in log_file_data:  
+                print(f'\nBehave Run detects Assertion Failed in log file: {log_file_name}\n')
+                behave_result = 1
+    print(f'\nBehave Run Exit -- {__file__} at {date_time}, result: {behave_result}\n\n')
+    sys.exit(behave_result)

api_logic_server_cli/prototypes/manager/samples/basic_demo/test/api_logic_server_behave/features/about.feature

@@ -0,0 +1,12 @@
+# Create 1 or more .feature files here, and corresponding /steps/<feature>.py files
+# Run Launch Configuration:
+#   - Behave Run - runs your test suite
+#   - Behave Logic Report - produces wiki for Behave Run, including Logic
+
+Feature: About Sample
+
+  Scenario: Transaction Processing
+     Given Sample Database
+      When Transactions are submitted
+      Then Enforce business policies with Logic (rules + code)
+

api_logic_server_cli/prototypes/manager/samples/basic_demo/test/api_logic_server_behave/features/steps/about.py

@@ -0,0 +1,20 @@
+from behave import *
+import requests, pdb
+import test_utils
+import json
+
+# Implement Behave Tests -- your code goes here
+
+@given('Sample Database')
+def step_impl(context):
+    assert True
+
+@when('Transactions are submitted')
+def step_impl(context):
+    assert True is not False
+
+@then('Enforce business policies with Logic (rules + code)')
+def step_impl(context):
+    scenario = "Transaction Processing"
+    test_utils.prt(f'Rules Report', scenario)
+    assert True

api_logic_server_cli/prototypes/manager/samples/basic_demo/test/api_logic_server_behave/features/steps/test_utils.py

@@ -0,0 +1,133 @@
+import requests
+import json
+from dotmap import DotMap
+import sys, os
+from pathlib import Path
+
+__version__ = '0.0.1'  # keycloak support
+
+
+def prt(msg: any, test: str= None) -> None:
+    """
+    Prints msg to...
+
+    1. Server console, and 
+    
+    2. <test>.log in test/api_logic_server_behave/logs/scenario_logic_logs
+
+            * This creates the log file
+            * Log file is appended with subsequent logic logging
+
+    @see api/customize_api/py for implementation.
+
+    :param msg: message to be written to logs.  Value "Rules Report" writes rules report to logs
+    :param test: name of test (scenario) - directs output to ...logs/test.log
+    :return:
+    """
+    test_val = test
+    if test is not None and len(test) >= 26:
+        test_val = test[0:25]
+    if "Server Log: Behave Run Successfully Completed" in msg:
+        debug_stop = 'good breakpoint'
+    msg_url = f'http://localhost:5656/server_log?msg={msg}&test={test}&dir=test/api_logic_server_behave/logs/scenario_logic_logs'
+    r = requests.get(msg_url)
+
+
+""" Using Config directly, not config.args / environment variables
+
+We are *not* able to use the config.args class here, since it's contructor requires Flask.
+
+This is a stand-alone app - Flask is not available.
+
+That means the config settings are *not* overridden by environment variables.
+"""
+current_path = Path(__file__).parent
+project_path = current_path.parent.parent.parent.parent
+# project_path = os.path.abspath(os.path.join(current_path, os.pardir))
+sys.path.append(str(project_path))
+
+try:
+    from config.config import Config
+except ImportError:
+    raise Exception(f'login: ImportError: config.config.Args')
+
+
+def login(user: str = 'aneu') -> dict:
+    """ login (default aneu), return header with token
+
+    Note different api for sql vs. keycloak
+
+    Raises:
+        Exception: _description_
+
+    Returns:
+        _type_: dict header with token
+    """
+
+    if Config.SECURITY_ENABLED == False:  # throw exception
+        return {}
+        # raise Exception(f'login: SECURITY_ENABLED is False (required for these tests)')
+    elif 'sql' in str(Config.SECURITY_PROVIDER):
+        server = \
+            f'{Config.CREATED_HTTP_SCHEME}://{Config.CREATED_SWAGGER_HOST}:{Config.CREATED_SWAGGER_PORT}{Config.CREATED_API_PREFIX}'
+
+        post_uri = f'{server}/auth/login'
+        post_data = {"username": user, "password": "p"}
+        r = requests.post(url=post_uri, json = post_data)
+        status_code = r.status_code
+        if status_code > 300:
+            raise Exception(f'POST login failed with {r.text}')
+        response_text = r.text
+        result_data = json.loads(response_text)
+        result_map = DotMap(result_data)
+        token = result_map.access_token
+    elif 'keycloak' in str(Config.SECURITY_PROVIDER):
+        """ different with kc
+        TOKEN_ENDPOINT: http://localhost:8080/realms/kcals/protocol/openid-connect/token 
+        TOKEN=$(curl ${TOKEN_ENDPOINT} -d 'grant_type=password&client_id=alsclient' -d 'username=u1' -d 'password=p' | jq -r .access_token)
+        """
+        # Correctly separate the URL from the data
+        post_uri = f"{Config.KEYCLOAK_BASE}/protocol/openid-connect/token"
+        post_data = {
+            'grant_type': 'password',
+            'client_id': 'alsclient',
+            'username': user,
+            'password': 'p'
+        }
+    
+        # Explicitly setting headers to ensure application/json Content-Type
+        headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+        
+        r = requests.post(post_uri, data=post_data)
+        status_code = r.status_code
+        if status_code > 300:
+            print(f'POST login: {post_uri}')  # Corrected string formatting
+            print(f'..failed with: {r.text}')
+            raise Exception(f'POST login: failed with {r.text}')  
+        token = r.json()['access_token']
+    else:
+        raise Exception(f'login: SECURITY_PROVIDER is not sql or keycloak')
+
+    # https://stackoverflow.com/questions/19069701/python-requests-library-how-to-pass-authorization-header-with-single-token
+    header = {'Authorization': 'Bearer {}'.format(f'{token}')}
+    save_for_session = True
+    if save_for_session:
+        s = requests.Session()
+        s.headers.update(header)
+    return header
+        
+
+def does_file_contain(search_for: str, in_file: str) -> bool:
+    """ returns True if <search_for> is <in_file> """
+    with open(Path(in_file), 'r+') as fp:
+        file_lines = fp.readlines()  # lines is list of lines, each element '...\n'
+        found = False
+        insert_line = 0
+        for each_line in file_lines:
+            if search_for in each_line:
+                found = True
+                break
+        return found
+
+if __name__ == "__main__":
+    print(f'\n test_services.py, starting')

api_logic_server_cli/prototypes/manager/samples/basic_demo/test/api_logic_server_behave/reports/Behave Logic Report Intro micro.md

@@ -0,0 +1,4 @@
+This report combines:
+* Behave log (lists Features, test Scenarios, results), with embedded
+* Logic showing rules executed, and how they operated
+

api_logic_server_cli/prototypes/manager/samples/basic_demo/test/api_logic_server_behave/reports/Behave Logic Report Intro.md

@@ -0,0 +1,75 @@
+# Behave Creates Executable Test Suite, Documentation
+
+You can optionally use the Behave test framework to:
+
+1. **Create and Run an Executable Test Suite:** in your IDE, create test definitions (similar to what is shown in the report below), and Python code to execute tests.  You can then execute your test suite with 1 command.
+
+2. **Requirements and Test Documentation:** as shown below, you can then create a wiki report that documents your requirements, and the tests (**Scenarios**) that confirm their proper operation.
+
+   * **Logic Documentation:** the report integrates your logic, including a logic report showing your logic (rules and Python), and a Logic Log that shows exactly how the rules executed.  Logic Doc can further contribute to Agile Collaboration.
+
+<figure><img src="https://raw.githubusercontent.com/ApiLogicServer/Docs/main/docs/images/behave/behave-summary.png"  height="600"></figure>
+
+
+
+[Behave](https://behave.readthedocs.io/en/stable/tutorial.html) is a framework for defining and executing tests.  It is based on [TDD (Test Driven Development)](http://dannorth.net/introducing-bdd/), an Agile approach for defining system requirements as executable tests.
+
+&nbsp;&nbsp;
+
+# Using Behave
+
+<figure><img src="https://raw.githubusercontent.com/ApiLogicServer/Docs/main/docs/images/behave/TDD-ide.png?raw=true"></figure>
+
+Behave is pre-installed with API Logic Server.  Use it as shown above:
+
+1. Create `.feature` files to define ***Scenarios*** (aka tests) for ***Features*** (aka Stories)
+
+2. Code `.py` files to implement Scenario tests
+
+3. Run Test Suite: Launch Configuration `Behave Run`.  This runs all your Scenarios, and produces a summary report of your Features and the test results.
+
+4. Report: Launch Configuration `Behave Report` to create the wiki file shown at the top of this page.
+
+These steps are further defined, below.  Explore the samples in the sample project.
+
+&nbsp;&nbsp;
+
+## 1. Create `.feature` file to define Scenario
+
+Feature (aka Story) files are designed to promote IT / business user collaboration.  
+
+&nbsp;&nbsp;
+
+## 2. Code `.py` file to implement test
+
+Implement your tests in Python.  Here, the tests are largely _read existing data_, _run transaction_, and _test results_, using the API.  You can obtain the URLs from the swagger.
+
+Key points:
+
+* Link your scenario / implementations with annotations, as shown for _Order Placed with excessive quantity_.
+
+* Include the `test_utils.prt()` call; be sure to use specify the scenario name as the 2nd argument.  This is what drives the name of the Logic Log file, discussed below.
+
+* Optionally, include a Python docstring on your `when` implementation as shown above, delimited by `"""` strings (see _"Familiar logic pattern"_ in the screen shot, above). If provided, this will be written into the wiki report.
+
+* Important: the system assumes the following line identifies the scenario_name; be sure to include it.
+
+&nbsp;&nbsp;
+
+## 3. Run Test Suite: Launch Configuration `Behave Run`
+
+You can now execute your Test Suite.  Run the `Behave Run` Launch Configuration, and Behave will run all of the tests, producing the outputs (`behave.log` and `<scenario.logs>` shown above.
+
+* Windows users will need to run `Windows Behave Run`
+
+* You can run just 1 scenario using `Behave Scenario`
+
+* You can set breakpoints in your tests
+
+The server must be running for these tests.  Use the Launch Configuration `ApiLogicServer`, or `python api_logic_server_run.py`.  The latter does not run the debugger, which you may find more convenient since changes to your test code won't restart the server.
+
+&nbsp;&nbsp;
+
+## 4. Report: Launch Configuration `Behave Report'
+
+Run this to create the wiki reports from the logs in step 3.