testit-adapter-behave 4.2.8__py3-none-any.whl

testit_adapter_behave/formatter.py

@@ -0,0 +1,49 @@
+from behave.formatter.base import Formatter
+
+from testit_python_commons.services import TmsPluginManager
+
+from .listener import AdapterListener
+from .utils import filter_out_scenarios, parse_userdata
+
+
+class AdapterFormatter(Formatter):
+    __adapter_launch_is_started = False
+    __tests_for_launch = None
+
+    def __init__(self, stream_opener, config):
+        super(AdapterFormatter, self).__init__(stream_opener, config)
+
+        option = parse_userdata(config.userdata)
+
+        self.__listener = AdapterListener(
+            TmsPluginManager.get_adapter_manager(option),
+            TmsPluginManager.get_step_manager())
+
+        TmsPluginManager.get_plugin_manager().register(self.__listener)
+
+    def start_adapter_launch(self):
+        self.__listener.start_launch()
+
+        self.__tests_for_launch = self.__listener.get_tests_for_launch()
+        self.__adapter_launch_is_started = True
+
+    def uri(self, uri):
+        if not self.__adapter_launch_is_started:
+            self.start_adapter_launch()
+
+    def feature(self, feature):
+        feature.scenarios = filter_out_scenarios(
+            self.__tests_for_launch,
+            feature.scenarios)
+
+    def scenario(self, scenario):
+        self.__listener.get_scenario(scenario)
+
+    def match(self, match):
+        self.__listener.get_step_parameters(match)
+
+    def result(self, step):
+        self.__listener.get_step_result(step)
+
+    def close_stream(self):
+        self.__listener.stop_launch()

testit_adapter_behave/listener.py

@@ -0,0 +1,141 @@
+import testit_python_commons.services as adapter
+from testit_python_commons.models.outcome_type import OutcomeType
+from testit_python_commons.services import (
+    AdapterManager,
+    StepManager)
+
+from .models.test_result_step import get_test_result_step_model
+from .scenario_parser import (
+    parse_scenario,
+    parse_step_status,
+    parse_status_type)
+from .utils import (
+    convert_step_to_step_result_model,
+    convert_executable_test_to_test_result_model)
+import logging
+
+# on_block_completed must be called AFTER other actions
+# on_running_started must be called BEFORE other actions
+
+class AdapterListener(object):
+    __executable_test = None
+    __background_steps_count = 0
+    __steps_count = 0
+
+    def __init__(self, adapter_manager: AdapterManager, step_manager: StepManager):
+        self.__adapter_manager = adapter_manager
+        self.__step_manager = step_manager
+
+    def start_launch(self):
+        self.__adapter_manager.on_running_started()
+        test_run_id = self.__adapter_manager.get_test_run_id()
+
+        self.__adapter_manager.set_test_run_id(test_run_id)
+        logging.debug("start_launch")
+
+    def stop_launch(self):
+        logging.debug("BEHAVE stop_launch")
+        self.__adapter_manager.write_tests()
+        self.__adapter_manager.on_block_completed()
+
+
+    def get_tests_for_launch(self):
+        logging.debug("get_tests_for_launch")
+        self.__adapter_manager.on_running_started()
+        return self.__adapter_manager.get_autotests_for_launch()
+
+    def get_scenario(self, scenario):
+        logging.debug("get_scenario")
+        self.__adapter_manager.on_running_started()
+        self.__executable_test = parse_scenario(scenario)
+        self.__background_steps_count = len(scenario.background_steps)
+        self.__steps_count = len(scenario.steps)
+        
+        
+
+    def set_scenario(self):
+        logging.debug("BEHAVE set_scenario")
+        self.__adapter_manager.write_test(
+            convert_executable_test_to_test_result_model(self.__executable_test))
+        # must depend on the current adapter mode
+        # if it's realtime -> call
+        if self.__adapter_manager.is_realtime():
+            self.__adapter_manager.on_block_completed()
+
+    def get_step_parameters(self, match):
+        scope = self.get_scope()
+
+        executable_step = get_test_result_step_model()
+
+        for argument in match.arguments:
+            name = argument.name if argument.name else 'param' + str(match.arguments.index(argument))
+            executable_step['description'] += f'{name} = {argument.original} '
+            executable_step['parameters'][name] = argument.original
+
+        self.__executable_test[scope].append(executable_step)
+
+    def get_step_result(self, result):
+        logging.debug("get_step_result")
+        self.__adapter_manager.on_running_started()
+        scope = self.get_scope()
+        outcome = parse_step_status(result.status)
+
+        self.__executable_test[scope][-1]['title'] = result.name
+        self.__executable_test[scope][-1]['outcome'] = outcome
+        self.__executable_test[scope][-1]['duration'] = round(result.duration * 1000)
+        self.__executable_test['duration'] += result.duration * 1000
+
+        # TODO: Add to python-commons
+        nested_step_results = self.__step_manager.get_steps_tree()
+        executable_step = self.__executable_test[scope][-1]
+        # TODO: Fix in python-commons
+        result_scope = f'{scope}Results' if scope == 'setUp' else 'stepResults'
+        self.__executable_test[result_scope].append(
+            convert_step_to_step_result_model(
+                executable_step,
+                nested_step_results))
+
+        if outcome != OutcomeType.PASSED:
+            self.__executable_test['traces'] = result.error_message
+            self.__executable_test['outcome'] = result.status.name
+            self.__executable_test['status_type'] = parse_status_type(result.status)
+            self.set_scenario()
+            return
+
+        if scope == 'setUp':
+            self.__background_steps_count -= 1
+            return
+
+        self.__steps_count -= 1
+
+        if self.__steps_count == 0:
+            self.__executable_test['outcome'] = result.status.name
+            self.__executable_test['status_type'] = parse_status_type(result.status)
+            self.set_scenario()
+
+    def get_scope(self):
+        self.__adapter_manager.on_running_started()
+        if self.__background_steps_count != 0:
+            return 'setUp'
+
+        return 'steps'
+
+    @adapter.hookimpl
+    def add_link(self, link):
+        if self.__executable_test:
+            self.__executable_test['resultLinks'].append(link)
+
+    @adapter.hookimpl
+    def add_message(self, test_message):
+        if self.__executable_test:
+            self.__executable_test['message'] = str(test_message)
+
+    @adapter.hookimpl
+    def add_attachments(self, attach_paths: list or tuple):
+        if self.__executable_test:
+            self.__executable_test['attachments'] += self.__adapter_manager.load_attachments(attach_paths)
+
+    @adapter.hookimpl
+    def create_attachment(self, body, name: str):
+        if self.__executable_test:
+            self.__executable_test['attachments'] += self.__adapter_manager.create_attachment(body, name)

testit_adapter_behave/models/label.py

@@ -0,0 +1,5 @@
+# TODO: Add model to python-commons; implement via attrs
+def get_label_model(label):
+    return {
+        'name': label
+    }

testit_adapter_behave/models/option.py

@@ -0,0 +1,19 @@
+from attr import attrib, attrs
+
+
+# TODO: Add model to python-commons
+@attrs(kw_only=True)
+class Option(object):
+    set_url = attrib(default=None)
+    set_private_token = attrib(default=None)
+    set_project_id = attrib(default=None)
+    set_configuration_id = attrib(default=None)
+    set_test_run_id = attrib(default=None)
+    set_test_run_name = attrib(default=None)
+    set_tms_proxy = attrib(default=None)
+    set_adapter_mode = attrib(default=None)
+    set_config_file = attrib(default=None)
+    set_cert_validation = attrib(default=None)
+    set_automatic_creation_test_cases = attrib(default=None)
+    set_automatic_updation_links_to_test_cases = attrib(default=None)
+    set_import_realtime = attrib(default=None)

testit_adapter_behave/models/tags.py

@@ -0,0 +1,11 @@
+class TagType:
+    EXTERNAL_ID = 'ExternalId='
+    DISPLAY_NAME = 'DisplayName='
+    LINKS = 'Links='
+    TITLE = 'Title='
+    WORK_ITEM_IDS = 'WorkItemIds='
+    DESCRIPTION = 'Description='
+    LABELS = 'Labels='
+    TAGS = 'Tags='
+    NAMESPACE = 'NameSpace='
+    CLASSNAME = 'ClassName='

testit_adapter_behave/models/test_result_step.py

@@ -0,0 +1,14 @@
+# TODO: Add model to python-commons; implement via attrs
+def get_test_result_step_model():
+    return {
+        'title': None,
+        'description': '',
+        'outcome': None,
+        'duration': 0,
+        'steps': [],
+        'parameters': {},
+        'attachments': [],
+        # TODO: Add to python-commons
+        # 'started_on': '',
+        # 'completed_on': None
+    }

testit_adapter_behave/models/url_link.py

@@ -0,0 +1,17 @@
+from testit_python_commons.models.link import Link
+from testit_python_commons.models.link_type import LinkType
+
+
+
+def get_url_to_link_model(url: str) -> Link:
+    return Link() \
+        .set_url(url) \
+        .set_link_type(LinkType.RELATED)
+
+
+def get_dict_to_link_model(link: dict) -> Link:
+    return Link() \
+        .set_url(link['url']) \
+        .set_title(link.get('title', None)) \
+        .set_link_type(link.get('type', LinkType.RELATED)) \
+        .set_description(link.get('description', None))

testit_adapter_behave/scenario_parser.py

@@ -0,0 +1,164 @@
+import traceback
+from enum import Enum
+
+from testit_python_commons.models.outcome_type import OutcomeType
+from testit_python_commons.models.status_type import StatusType
+
+from .models.tags import TagType
+from .tags_parser import parse_test_tags
+
+STATUS_TYPE = {
+    'passed': StatusType.SUCCEEDED,
+    'failed': StatusType.FAILED,
+    'error': StatusType.FAILED,
+    'skipped': StatusType.INCOMPLETE,
+    'untested': StatusType.INCOMPLETE,
+    'undefined': StatusType.INCOMPLETE
+}
+STEP_STATUS = {
+    'passed': OutcomeType.PASSED,
+    'failed': OutcomeType.FAILED,
+    'error': OutcomeType.FAILED,
+    'skipped': OutcomeType.SKIPPED,
+    'untested': OutcomeType.SKIPPED,
+    'undefined': OutcomeType.BLOCKED
+}
+
+
+def parse_scenario(scenario):
+    tags = parse_test_tags(scenario.tags + scenario.feature.tags)
+
+    # TODO: Add model to python-commons; implement via attrs
+    executable_test = {
+        'externalID': tags[TagType.EXTERNAL_ID] if
+        TagType.EXTERNAL_ID in tags and tags[TagType.EXTERNAL_ID] else get_scenario_external_id(scenario),
+        'autoTestName': tags[TagType.DISPLAY_NAME] if
+        TagType.DISPLAY_NAME in tags and tags[TagType.DISPLAY_NAME] else get_scenario_name(scenario),
+        'outcome': None,
+        'status_type': None,
+        'steps': [],
+        'stepResults': [],
+        'setUp': [],
+        'setUpResults': [],
+        'tearDown': [],
+        'tearDownResults': [],
+        'resultLinks': [],
+        'duration': 0,
+        'traces': None,
+        'message': None,
+        'namespace': get_scenario_namespace(scenario),
+        'classname': None,
+        'attachments': [],
+        'parameters': get_scenario_parameters(scenario),
+        # TODO: Make optional in Converter python-commons
+        'properties': {},
+        'title': None,
+        'description': None,
+        'links': [],
+        'labels': [],
+        'tags': [],
+        'workItemsID': [],
+        "externalKey": get_scenario_name(scenario)
+        # TODO: Add to python-commons
+        # 'started_on': '',
+        # 'completed_on': None
+    }
+
+    if TagType.TITLE in tags:
+        executable_test['title'] = tags[TagType.TITLE]
+
+    if TagType.DESCRIPTION in tags:
+        executable_test['description'] = tags[TagType.DESCRIPTION]
+
+    if TagType.LINKS in tags:
+        executable_test['links'] = tags[TagType.LINKS]
+
+    if TagType.LABELS in tags:
+        executable_test['labels'] = tags[TagType.LABELS]
+
+    if TagType.TAGS in tags:
+        executable_test['tags'] = tags[TagType.TAGS]
+
+    if TagType.NAMESPACE in tags:
+        executable_test['namespace'] = tags[TagType.NAMESPACE]
+
+    if TagType.CLASSNAME in tags:
+        executable_test['classname'] = tags[TagType.CLASSNAME]
+
+    if TagType.WORK_ITEM_IDS in tags:
+        # TODO: Fix in python-commons to "workItemIds"
+        executable_test['workItemsID'] = tags[TagType.WORK_ITEM_IDS]
+
+    return executable_test
+
+
+def parse_step_status(status):
+    return STEP_STATUS[status.name]
+
+
+def parse_status_type(status):
+    return STATUS_TYPE[status.name]
+
+
+def get_scenario_name(scenario):
+    return scenario.name if scenario.name else scenario.keyword
+
+
+def get_scenario_external_id(scenario):
+    from .utils import get_hash
+
+    return get_hash(scenario.feature.filename + scenario.name)
+
+
+def get_scenario_namespace(scenario):
+    return scenario.feature.filename
+
+
+def get_scenario_parameters(scenario):
+    row = scenario._row
+
+    return {name: value for name, value in zip(row.headings, row.cells)} if row else {}
+
+
+def get_scenario_status(scenario):
+    for step in scenario.all_steps:
+        if get_step_status(step) != 'passed':
+            return get_step_status(step)
+    return OutcomeType.PASSED
+
+
+def get_scenario_status_details(scenario):
+    for step in scenario.all_steps:
+        if get_step_status(step) != 'passed':
+            return get_step_status_details(step)
+
+
+def get_step_status(result):
+    if result.exception:
+        return get_status(result.exception)
+    else:
+        if isinstance(result.status, Enum):
+            return STEP_STATUS.get(result.status.name, None)
+        else:
+            return STEP_STATUS.get(result.status, None)
+
+
+def get_status(exception):
+    if exception and isinstance(exception, AssertionError):
+        return OutcomeType.FAILED
+    elif exception:
+        return OutcomeType.BLOCKED
+    return OutcomeType.PASSED
+
+
+def get_step_status_details(result):
+    if result.exception:
+        trace = "\n".join(result.exc_traceback) if type(result.exc_traceback) == list else \
+            ''.join(traceback.format_tb(result.exc_traceback))
+        return trace
+
+
+def get_step_table(step):
+    table = [','.join(step.table.headings)]
+    [table.append(','.join(list(row))) for row in step.table.rows]
+    return '\n'.join(table)

testit_adapter_behave/tags_parser.py

@@ -0,0 +1,106 @@
+from .models.label import get_label_model
+from .models.tags import TagType
+from .models.url_link import get_url_to_link_model, get_dict_to_link_model
+
+
+def parse_test_tags(tags):
+    parsed_tags = {
+        TagType.EXTERNAL_ID: None,
+        TagType.DISPLAY_NAME: None,
+        TagType.LINKS: [],
+        TagType.TITLE: None,
+        TagType.WORK_ITEM_IDS: [],
+        TagType.DESCRIPTION: None,
+        TagType.LABELS: [],
+        TagType.TAGS: [],
+        TagType.NAMESPACE: None,
+        TagType.CLASSNAME: None,
+    }
+
+    for tag in tags:
+        if TagType.EXTERNAL_ID in tag:
+            parsed_tags[TagType.EXTERNAL_ID] = __parse_space_in_tag(tag[len(TagType.EXTERNAL_ID):])
+
+        elif TagType.DISPLAY_NAME in tag:
+            parsed_tags[TagType.DISPLAY_NAME] = __parse_space_in_tag(tag[len(TagType.DISPLAY_NAME):])
+
+        elif TagType.LINKS in tag:
+            parsed_tags[TagType.LINKS].extend(
+                __parse_links(tag[len(TagType.LINKS):]))
+
+        elif TagType.TITLE in tag:
+            parsed_tags[TagType.TITLE] = __parse_space_in_tag(tag[len(TagType.TITLE):])
+
+        elif TagType.WORK_ITEM_IDS in tag:
+            parsed_tags[TagType.WORK_ITEM_IDS].extend(
+                __parse_massive(tag[len(TagType.WORK_ITEM_IDS):]))
+
+        elif TagType.DESCRIPTION in tag:
+            parsed_tags[TagType.DESCRIPTION] = __parse_space_in_tag(tag[len(TagType.DESCRIPTION):])
+
+        elif TagType.LABELS in tag:
+            parsed_tags[TagType.LABELS].extend(
+                __parse_labels(tag[len(TagType.LABELS):]))
+
+        elif TagType.TAGS in tag:
+            parsed_tags[TagType.TAGS].extend(
+                __parse_tags(tag[len(TagType.TAGS):]))
+
+        elif TagType.NAMESPACE in tag:
+            parsed_tags[TagType.NAMESPACE] = __parse_space_in_tag(tag[len(TagType.NAMESPACE):])
+
+        elif TagType.CLASSNAME in tag:
+            parsed_tags[TagType.CLASSNAME] = __parse_space_in_tag(tag[len(TagType.CLASSNAME):])
+
+    return parsed_tags
+
+
+def __parse_massive(tag: str):
+    return tag.split(',')
+
+
+def __parse_labels(tag):
+    parsed_labels = []
+
+    for label in __parse_massive(tag):
+        parsed_labels.append(get_label_model(label))
+
+    return parsed_labels
+
+
+def __parse_tags(tag):
+    parsed_tags = []
+
+    for tms_tag in __parse_massive(tag):
+        parsed_tags.append(tms_tag)
+
+    return parsed_tags
+
+
+def __parse_links(tag: str):
+    parsed_links = []
+    json_links = __parse_json(tag)
+
+    if not json_links:
+        for url in __parse_massive(tag):
+            parsed_links.append(get_url_to_link_model(url))
+
+    if isinstance(json_links, tuple):
+        for url in json_links:
+            parsed_links.append(get_url_to_link_model(url))
+
+    if isinstance(json_links, dict):
+        parsed_links.append(get_dict_to_link_model(json_links))
+
+    return parsed_links
+
+
+def __parse_json(json_string: str):
+    try:
+        return eval(json_string)
+    except Exception:
+        return
+
+
+def __parse_space_in_tag(tag: str) -> str:
+    return tag.replace('\\_', ' ')

testit_adapter_behave/utils.py

@@ -0,0 +1,172 @@
+import hashlib
+import logging
+import re
+from typing import List
+
+from testit_python_commons.models.step_result import StepResult
+from testit_python_commons.models.test_result import TestResult
+
+from .models.option import Option
+from .models.tags import TagType
+from .scenario_parser import get_scenario_external_id, get_scenario_parameters
+from .tags_parser import parse_test_tags
+
+
+def parse_userdata(userdata):
+    if not userdata:
+        return
+
+    option = Option()
+
+    if 'tmsUrl' in userdata:
+        option.set_url = userdata['tmsUrl']
+
+    if 'tmsPrivateToken' in userdata:
+        option.set_private_token = userdata['tmsPrivateToken']
+
+    if 'tmsProjectId' in userdata:
+        option.set_project_id = userdata['tmsProjectId']
+
+    if 'tmsConfigurationId' in userdata:
+        option.set_configuration_id = userdata['tmsConfigurationId']
+
+    if 'tmsTestRunId' in userdata:
+        option.set_test_run_id = userdata['tmsTestRunId']
+
+    if 'tmsTestRunName' in userdata:
+        option.set_test_run_name = userdata['tmsTestRunName']
+
+    if 'tmsProxy' in userdata:
+        option.set_tms_proxy = userdata['tmsProxy']
+
+    if 'tmsAdapterMode' in userdata:
+        option.set_adapter_mode = userdata['tmsAdapterMode']
+
+    if 'tmsConfigFile' in userdata:
+        option.set_config_file = userdata['tmsConfigFile']
+
+    if 'tmsCertValidation' in userdata:
+        option.set_cert_validation = userdata['tmsCertValidation']
+
+    if 'tmsAutomaticCreationTestCases' in userdata:
+        option.set_automatic_creation_test_cases = userdata['tmsAutomaticCreationTestCases']
+
+    if 'tmsAutomaticUpdationLinksToTestCases' in userdata:
+        option.set_automatic_updation_links_to_test_cases = userdata['tmsAutomaticUpdationLinksToTestCases']
+
+    if 'tmsImportRealtime' in userdata:
+        option.set_import_realtime = userdata['tmsImportRealtime']
+
+    return option
+
+
+def filter_out_scenarios(tests_for_launch, scenarios):
+    if tests_for_launch:
+        included_scenarios = []
+        for i in range(len(scenarios)):
+            if scenarios[i].keyword == 'Scenario Outline' and hasattr(scenarios[i], 'scenarios'):
+                scenarios_outline = filter_out_scenarios(tests_for_launch, scenarios[i].scenarios)
+
+                if len(scenarios_outline) != 0:
+                    for unmatched_scenario in set(scenarios[i].scenarios).symmetric_difference(set(scenarios_outline)):
+                        scenarios[i].scenarios.remove(unmatched_scenario)
+
+                    included_scenarios.append(scenarios[i])
+            else:
+                if validate_scenario(scenarios[i], tests_for_launch):
+                    included_scenarios.append(scenarios[i])
+
+        scenarios = included_scenarios
+
+    return scenarios
+
+
+def validate_scenario(scenario, tests_for_launch) -> bool:
+    tags = parse_test_tags(scenario.tags + scenario.feature.tags)
+    external_id = tags[TagType.EXTERNAL_ID] if \
+        TagType.EXTERNAL_ID in tags and tags[TagType.EXTERNAL_ID] else get_scenario_external_id(scenario)
+
+    if scenario.keyword == 'Scenario Outline':
+        external_id = param_attribute_collector(external_id, get_scenario_parameters(scenario))
+
+    return external_id in tests_for_launch
+
+
+def param_attribute_collector(attribute, run_param):
+    result = attribute
+    param_keys = re.findall(r"\{'<(.*?)>'\}", attribute)
+    if len(param_keys) > 0:
+        for param_key in param_keys:
+            root_key = param_key
+            id_keys = re.findall(r'\[(.*?)\]', param_key)
+            if len(id_keys) == 0:
+                if root_key in run_param:
+                    result = result.replace("{'<" + root_key + ">'}", str(run_param[root_key]))
+                else:
+                    logging.error(f"Parameter {root_key} not found")
+            elif len(id_keys) == 1:
+                base_key = root_key.replace("[" + id_keys[0] + "]", "")
+                id_key = id_keys[0].strip("\'\"")
+                if id_key.isdigit() and int(id_key) in range(len(run_param[base_key])):
+                    val_key = int(id_key)
+                elif id_key.isalnum() and not id_key.isdigit() and id_key in run_param[base_key].keys():
+                    val_key = id_key
+                else:
+                    raise SystemExit(f"Not key: {root_key} in run parameters or other keys problem")
+                result = result.replace("{'<" + root_key + ">'}", str(run_param[base_key][val_key]))
+            else:
+                raise SystemExit("For type tuple, list, dict) support only one level!")
+    elif len(param_keys) == 0:
+        result = attribute
+    else:
+        raise SystemExit("Collecting parameters error!")
+    return result
+
+
+def convert_executable_test_to_test_result_model(executable_test: dict) -> TestResult:
+    return TestResult()\
+        .set_external_id(executable_test['externalID'])\
+        .set_autotest_name(executable_test['autoTestName'])\
+        .set_step_results(executable_test['stepResults'])\
+        .set_setup_results(executable_test['setUpResults'])\
+        .set_teardown_results(executable_test['tearDownResults'])\
+        .set_duration(executable_test['duration'])\
+        .set_outcome(executable_test['outcome'])\
+        .set_status_type(executable_test['status_type'])\
+        .set_traces(executable_test['traces'])\
+        .set_attachments(executable_test['attachments'])\
+        .set_parameters(executable_test['parameters'])\
+        .set_properties(executable_test['properties'])\
+        .set_namespace(executable_test['namespace'])\
+        .set_classname(executable_test['classname'])\
+        .set_title(executable_test['title'])\
+        .set_description(executable_test['description'])\
+        .set_links(executable_test['links'])\
+        .set_result_links(executable_test['resultLinks'])\
+        .set_labels(executable_test['labels']) \
+        .set_tags(executable_test['tags'])\
+        .set_work_item_ids(executable_test['workItemsID'])\
+        .set_message(executable_test['message'])\
+        .set_external_key(executable_test['externalKey'])
+
+
+def convert_step_to_step_result_model(step: dict, nested_step_results: List[StepResult]) -> StepResult:
+    step_result_model = StepResult()\
+        .set_title(step['title'])\
+        .set_description(step['description'])\
+        .set_outcome(step['outcome'])\
+        .set_duration(step['duration'])\
+        .set_attachments(step['attachments'])
+
+    if 'parameters' in step:
+        step_result_model.set_parameters(step['parameters'])
+
+    if nested_step_results:
+        step_result_model.set_step_results(nested_step_results)
+
+    return step_result_model
+
+
+def get_hash(value: str):
+    md = hashlib.sha256(bytes(value, encoding='utf-8'))
+    return md.hexdigest()

testit_adapter_behave-4.2.8.dist-info/METADATA

@@ -0,0 +1,289 @@
+Metadata-Version: 2.4
+Name: testit-adapter-behave
+Version: 4.2.8
+Summary: Behave adapter for Test IT
+Home-page: https://github.com/testit-tms/adapters-python/
+Author: Integration team
+Author-email: integrations@testit.software
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+Requires-Dist: behave
+Requires-Dist: testit-python-commons==4.2.8
+Requires-Dist: attrs
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# Test IT TMS adapter for Behave
+
+![Test IT](https://raw.githubusercontent.com/testit-tms/adapters-python/master/images/banner.png)
+
+[![Release
+Status](https://img.shields.io/pypi/v/testit-adapter-behave?style=plastic)](https://pypi.python.org/pypi/testit-adapter-behave)
+[![Downloads](https://img.shields.io/pypi/dm/testit-adapter-behave?style=plastic)](https://pypi.python.org/pypi/testit-adapter-behave)
+[![GitHub contributors](https://img.shields.io/github/contributors/testit-tms/adapters-python?style=plastic)](https://github.com/testit-tms/adapters-python)
+
+## Getting Started
+
+### Installation
+
+```
+pip install testit-adapter-behave
+```
+
+## Usage
+
+### Configuration
+
+| Description                                                                                                                                                                                                                                                                                                                                                                                                                      | File property                     | Environment variable                       | CLI argument                         |
+|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------|--------------------------------------------|--------------------------------------|
+| Location of the TMS instance                                                                                                                                                                                                                                                                                                                                                                                                     | url                               | TMS_URL                                    | tmsUrl                               |
+| API secret key [How to getting API secret key?](https://github.com/testit-tms/.github/tree/main/configuration#privatetoken)                                                                                                                                                                                                                                                                                                      | privateToken                      | TMS_PRIVATE_TOKEN                          | tmsPrivateToken                      |
+| ID of project in TMS instance [How to getting project ID?](https://github.com/testit-tms/.github/tree/main/configuration#projectid)                                                                                                                                                                                                                                                                                              | projectId                         | TMS_PROJECT_ID                             | tmsProjectId                         |
+| ID of configuration in TMS instance [How to getting configuration ID?](https://github.com/testit-tms/.github/tree/main/configuration#configurationid)                                                                                                                                                                                                                                                                            | configurationId                   | TMS_CONFIGURATION_ID                       | tmsConfigurationId                   |
+| ID of the created test run in TMS instance.<br/>It's necessary for **adapterMode** 0 or 1                                                                                                                                                                                                                                                                                                                                        | testRunId                         | TMS_TEST_RUN_ID                            | tmsTestRunId                         |
+| Parameter for specifying the name of test run in TMS instance (**It's optional**). If it is not provided, it is created automatically                                                                                                                                                                                                                                                                                            | testRunName                       | TMS_TEST_RUN_NAME                          | tmsTestRunName                       |
+| Adapter mode. Default value - 0. The adapter supports following modes:<br/>0 - in this mode, the adapter filters tests by test run ID and configuration ID, and sends the results to the test run<br/>1 - in this mode, the adapter sends all results to the test run without filtering or [with filtering CLI](#run-with-filter)<br/>2 - in this mode, the adapter creates a new test run and sends results to the new test run | adapterMode                       | TMS_ADAPTER_MODE                           | tmsAdapterMode                       |
+| It enables/disables certificate validation (**It's optional**). Default value - true                                                                                                                                                                                                                                                                                                                                             | certValidation                    | TMS_CERT_VALIDATION                        | tmsCertValidation                    |
+| Mode of automatic creation test cases (**It's optional**). Default value - false. The adapter supports following modes:<br/>true - in this mode, the adapter will create a test case linked to the created autotest (not to the updated autotest)<br/>false - in this mode, the adapter will not create a test case                                                                                                              | automaticCreationTestCases        | TMS_AUTOMATIC_CREATION_TEST_CASES          | tmsAutomaticCreationTestCases        |
+| Mode of automatic updation links to test cases (**It's optional**). Default value - false. The adapter supports following modes:<br/>true - in this mode, the adapter will update links to test cases<br/>false - in this mode, the adapter will not update link to test cases                                                                                                                                                   | automaticUpdationLinksToTestCases | TMS_AUTOMATIC_UPDATION_LINKS_TO_TEST_CASES | tmsAutomaticUpdationLinksToTestCases |
+| Mode of import type selection when launching autotests (**It's optional**). Default value - true. The adapter supports following modes:<br/>true - in this mode, the adapter will create/update each autotest in real time<br/>false - in this mode, the adapter will create/update multiple autotests                                                                                                                           | importRealtime                    | TMS_IMPORT_REALTIME                        | tmsImportRealtime                    |
+| Url of proxy server (**It's optional**)                                                                                                                                                                                                                                                                                                                                                                                          | tmsProxy                          | TMS_PROXY                                  | tmsProxy                             |
+| Name (**including extension**) of the configuration file If it is not provided, it is used default file name (**It's optional**)                                                                                                                                                                                                                                                                                                 | -                                 | TMS_CONFIG_FILE                            | tmsConfigFile                        |
+| Sync storage port (**It's optional, 49152 by default**)                                                                                                                                                                                                                                                                                                                                                                          | syncStoragePort                   | TMS_SYNC_STORAGE_PORT                      | syncStoragePort                      |
+
+#### File
+
+Add `[testit]` block to your **pyproject.toml** or create **connection_config.ini** file in the root directory of the project:
+```
+[testit]
+URL = URL
+privateToken = USER_PRIVATE_TOKEN
+projectId = PROJECT_ID
+configurationId = CONFIGURATION_ID
+testRunId = TEST_RUN_ID
+testRunName = TEST_RUN_NAME
+adapterMode = ADAPTER_MODE
+certValidation = CERT_VALIDATION
+automaticCreationTestCases = AUTOMATIC_CREATION_TEST_CASES
+automaticUpdationLinksToTestCases = AUTOMATIC_UPDATION_LINKS_TO_TEST_CASES
+importRealtime = IMPORT_REALTIME
+syncStoragePort = 49152
+
+# This section are optional. It enables debug mode.
+[debug]
+tmsProxy = TMS_PROXY
+```
+
+#### Examples
+
+Launch with a `pyproject.toml` or `connection_config.ini` file in the root directory of the project:
+
+```
+$ behave -f testit_adapter_behave.formatter:AdapterFormatter
+```
+
+Launch with command-line parameters:
+
+```
+$ behave -f testit_adapter_behave.formatter:AdapterFormatter -D tmsUrl=URL -D tmsPrivateToken=USER_PRIVATE_TOKEN -D
+tmsProjectId=PROJECT_ID -D tmsConfigurationId=CONFIGURATION_ID -D tmsTestRunId=TEST_RUN_ID -D tmsAdapterMode=ADAPTER_MODE -D
+tmsTestRunName=TEST_RUN_NAME -D tmsProxy='{"http":"http://localhost:8888","https":"http://localhost:8888"}' -D
+tmsCertValidation=CERT_VALIDATION -D tmsAutomaticCreationTestCases=AUTOMATIC_CREATION_TEST_CASES -D 
+tmsAutomaticUpdationLinksToTestCases=AUTOMATIC_UPDATION_LINKS_TO_TEST_CASES -D tmsImportRealtime=IMPORT_REALTIME
+```
+
+Logging level:
+```
+$ behave ... --logging-level=DEBUG
+```
+
+If you want to enable debug mode then
+see [How to enable debug logging?](https://github.com/testit-tms/adapters-python/tree/main/testit-python-commons)
+
+#### Run with filter
+To create filter by autotests you can use the Test IT CLI (use adapterMode 1 for run with filter):
+
+```
+$ export TMS_TOKEN=<YOUR_TOKEN>
+$ testit autotests_filter 
+  --url https://tms.testit.software \
+  --configuration-id 5236eb3f-7c05-46f9-a609-dc0278896464 \
+  --testrun-id 6d4ac4b7-dd67-4805-b879-18da0b89d4a8 \
+  --framework behave \
+  --output tmp/filter.txt
+  
+$ behave "$(cat tmp/filter.txt)" -D tmsTestRunId=6d4ac4b7-dd67-4805-b879-18da0b89d4a8 -D tmsAdapterMode=1 -f testit_adapter_behave.formatter:AdapterFormatter
+```
+
+### Tags
+
+Use tags to specify information about autotest.
+
+Description of tags:
+
+- `WorkItemIds` - a method that links autotests with manual tests. Receives the array of manual tests' IDs
+- `DisplayName` - internal autotest name (used in Test IT)
+- `ExternalId` - unique internal autotest ID (used in Test IT)
+- `Title` - autotest name specified in the autotest card. If not specified, the name from the displayName method is used
+- `Description` - autotest description specified in the autotest card
+- `Labels` - labels listed in the autotest card
+- `Tags` - tags listed in the autotest card
+- `Links` - links listed in the autotest card
+- `NameSpace` - directory in the TMS system (default - file's name of test)
+- `ClassName` - subdirectory in the TMS system (default - class's name of test)
+
+If you want to insert a space in the tags, use the "\\_" character combination.
+
+Description of methods:
+
+- `testit.addWorkItemIds` - a dynamic method that links autotests with manual tests. Receives the array of manual tests' IDs
+- `testit.addDisplayName` - a dynamic method for adding internal autotest name (used in Test IT)
+- `testit.addExternalId` - a dynamic method for adding unique internal autotest ID (used in Test IT)
+- `testit.addTitle` - a dynamic method for adding autotest name specified in the autotest card. If not specified, the name from the displayName method is used
+- `testit.addDescription` - a dynamic method for adding autotest description specified in the autotest card
+- `testit.addLabels` - a dynamic method for adding labels listed in the autotest card
+- `testit.addTags` - a dynamic method for adding tags listed in the autotest card
+- `testit.addLinks` - links in the autotest result
+- `testit.addAttachments` - uploading files in the autotest result
+- `testit.addMessage` - information about autotest in the autotest result
+- `testit.addNameSpace` - a dynamic method for adding directory in the TMS system (default - file's name of test)
+- `testit.addClassName` - a dynamic method for adding subdirectory in the TMS system (default - class's name of test)
+- `testit.addParameter` - a dynamic method for adding parameter in the autotest result
+- `testit.step` - usage in the "with" construct to designation a step in the body of the test
+
+### Examples
+
+#### Simple Test
+
+```py
+import testit
+from behave import given
+from behave import then
+from behave import when
+
+
+@given("I authorize on the portal")
+def authorization(context):
+    with testit.step("I set login"):
+        pass
+    with testit.step("I set password"):
+        pass
+
+
+@when("I create a project")
+def create_project(context):
+    pass
+
+
+@when("I open the project")
+def enter_project(context):
+    pass
+
+
+@when("I create a section")
+def create_section(context):
+    testit.addLinks(
+        title='component_dump.dmp',
+        type=testit.LinkType.RELATED,
+        url='https://dumps.example.com/module/some_module_dump',
+        description='Description'
+    )
+
+
+@then("I create a test case")
+def create_test_case(context):
+    testit.addAttachments('pictures/picture.jpg')
+```
+
+```buildoutcfg
+Feature: Sample
+
+  Background:
+    Given I authorize on the portal
+
+  @ExternalId=failed_with_all_annotations
+  @DisplayName=Failed_test_with_all_annotations
+  @WorkItemIds=123
+  @Title=Title_in_the_autotest_card
+  @Description=Test_with_all_annotations
+  @Tags=Tag1,Tag2
+  @Links={"url":"https://dumps.example.com/module/repository","title":"Repository","description":"Example_of_repository","type":"Repository"}
+  Scenario: Create new project, section and test case
+    When I create a project
+    And I open the project
+    And I create a section
+    Then I create a test case
+```
+
+#### Parameterized test
+
+> [!WARNING]
+> When linking a parameterized autotest to a parameterized test case, please consider the problematic points:
+> - In TMS test cases have a table with parameters, but autotests do not. They are not equal entities, so there may be incompatibility in terms of parameters
+> - Running a parameterized test case, TMS expects the results of all related autotests with all the parameters specified in the test case table
+> - In TMS, the parameters are limited to the string type, so the adapter transmits absolutely all the autotest parameters as a string. This implies the following problematic point for the test case table
+> - TMS expects a complete **textual** match of the name and value of the parameters of the test case table with the autotest parameters
+
+```py
+from behave import when
+from behave import then
+
+
+@when("Summing {left:d}+{right:d}")
+def step_impl(context, left, right):
+    context.sum = left + right
+
+
+@then("Result is {result:d}")
+def step_impl(context, result):
+    assert context.sum == result
+
+```
+
+```buildoutcfg
+Feature: Rule
+  Tests that use Rule
+
+  Scenario Outline: Summing
+    When Summing <left>+<right>
+    Then Result is <result>
+
+    Examples:
+      | left | right | result |
+      | 1    | 1     | 3      |
+      | 9    | 9     | 18     |
+```
+
+# Contributing
+
+You can help to develop the project. Any contributions are **greatly appreciated**.
+
+* If you have suggestions for adding or removing projects, feel free
+  to [open an issue](https://github.com/testit-tms/adapters-python/issues/new) to discuss it, or directly create a pull
+  request after you edit the *README.md* file with necessary changes.
+* Please make sure you check your spelling and grammar.
+* Create individual PR for each suggestion.
+* Please also read through
+  the [Code Of Conduct](https://github.com/testit-tms/adapters-python/blob/master/CODE_OF_CONDUCT.md) before posting
+  your first idea as well.
+
+# License
+
+Distributed under the Apache-2.0 License.
+See [LICENSE](https://github.com/testit-tms/adapters-python/blob/master/LICENSE.md) for more information.
+

testit_adapter_behave-4.2.8.dist-info/RECORD

@@ -0,0 +1,16 @@
+testit_adapter_behave/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testit_adapter_behave/formatter.py,sha256=3bvCs_3ISshs4uUQiIHBTnLWgO4d0AAp8ww56qOEUX8,1466
+testit_adapter_behave/listener.py,sha256=ePojZW8oHaKWWIwCQhrTc1hPK3ufFHbC_uMcryVlqLI,5255
+testit_adapter_behave/scenario_parser.py,sha256=XcI3feZrvrj0Gb5YWU0JhmltwrRqE2i_AR7hN_1rjgk,4767
+testit_adapter_behave/tags_parser.py,sha256=Y_iyK7jUEc0RqOnT3j0Zo8C8mb6aBg71OXrvwh-wrDw,3019
+testit_adapter_behave/utils.py,sha256=HRsAgk0UP8d0CoyAQWehn5WLJ5Y39WESSXQ1mz_-Y-E,6718
+testit_adapter_behave/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testit_adapter_behave/models/label.py,sha256=RejlJc1rN33pUAXw0wghOleFK2URGIdMEObXBsCRGkE,126
+testit_adapter_behave/models/option.py,sha256=RqcCgV_Tbl-FxASXzeAVFs-2XeGBkRzxibaeme0Q__Y,723
+testit_adapter_behave/models/tags.py,sha256=lTdcMs71xFaJfR6w6wo09TIwlPiSaFXPLST-WS-rpxw,291
+testit_adapter_behave/models/test_result_step.py,sha256=OXFY0ZiBeb5OK7sk1Z0rHrfwnCPm5z4wmOqiCNph9Pc,379
+testit_adapter_behave/models/url_link.py,sha256=qMKOi2yVkPI_hHO2MV2YZlSlzw7JJHkCe8X5xqNT8WA,509
+testit_adapter_behave-4.2.8.dist-info/METADATA,sha256=3RMVvCAAZDZJ38EJLnUuG81KlcI1I47k0EmZEyq3d1c,18280
+testit_adapter_behave-4.2.8.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+testit_adapter_behave-4.2.8.dist-info/top_level.txt,sha256=T3XswPnkdP_wek99JR9BBOq9FiVWv6-ucmFezMrmT0Q,22
+testit_adapter_behave-4.2.8.dist-info/RECORD,,

testit_adapter_behave-4.2.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

testit_adapter_behave-4.2.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+testit_adapter_behave