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

testit_adapter_nose/listener.py

@@ -0,0 +1,74 @@
+import testit_python_commons.services as adapter
+from testit_python_commons.services import (
+    AdapterManager,
+    StepManager)
+from .utils import (
+    form_test,
+    get_outcome,
+    convert_executable_test_to_test_result_model,
+    STATUS_TYPE,
+)
+
+
+class AdapterListener(object):
+    __executable_test = None
+
+    def __init__(self, adapter_manager: AdapterManager, step_manager: StepManager, top_level_directory: str):
+        self.__adapter_manager = adapter_manager
+        self.__step_manager = step_manager
+        self.__top_level_directory = top_level_directory
+
+    def start_launch(self):
+        test_run_id = self.__adapter_manager.get_test_run_id()
+
+        self.__adapter_manager.set_test_run_id(test_run_id)
+        self.__adapter_manager.on_running_started()
+
+    def stop_launch(self):
+        self.__adapter_manager.on_block_completed()
+        self.__adapter_manager.write_tests()
+
+    def get_tests_for_launch(self):
+        self.__adapter_manager.on_running_started()
+        return self.__adapter_manager.get_autotests_for_launch()
+
+    def start_test(self, test):
+        self.__executable_test = form_test(test, self.__top_level_directory)
+
+    def set_outcome(self, event):
+        outcome, message, trace = get_outcome(event)
+
+        self.__executable_test['outcome'] = outcome
+        self.__executable_test['status_type'] = STATUS_TYPE[outcome]
+        self.__executable_test['traces'] = trace
+
+        if not self.__executable_test['message']:
+            self.__executable_test['message'] = message
+
+    def stop_test(self):
+        test_results_steps = self.__step_manager.get_steps_tree()
+        self.__executable_test['stepResults'] = test_results_steps
+
+        self.__adapter_manager.write_test(
+            convert_executable_test_to_test_result_model(self.__executable_test))
+        self.__executable_test = None
+
+    @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_nose/plugin.py

@@ -0,0 +1,43 @@
+from nose2.events import Plugin
+
+from testit_python_commons.services import TmsPluginManager
+
+from .listener import AdapterListener
+
+
+class TmsPlugin(Plugin):
+    configSection = 'testit'
+    commandLineSwitch = (None, 'testit', 'TMS adapter for Nose')
+    __listener = None
+    __tests_for_launch = None
+    __top_level_directory = None
+
+    def __init__(self, *args, **kwargs):
+        super(TmsPlugin, self).__init__(*args, **kwargs)
+
+    def handleDir(self, event):
+        if not self.__top_level_directory:
+            self.__top_level_directory = event.topLevelDirectory
+
+    def startTestRun(self, event):
+        self.__listener = AdapterListener(
+            TmsPluginManager.get_adapter_manager(),
+            TmsPluginManager.get_step_manager(),
+            self.__top_level_directory)
+
+        TmsPluginManager.get_plugin_manager().register(self.__listener)
+
+        self.__listener.start_launch()
+        self.__tests_for_launch = self.__listener.get_tests_for_launch()
+
+    def afterTestRun(self, event):
+        self.__listener.stop_launch()
+
+    def startTest(self, event):
+        self.__listener.start_test(event.test)
+
+    def stopTest(self, event):
+        self.__listener.stop_test()
+
+    def testOutcome(self, event):
+        self.__listener.set_outcome(event)

testit_adapter_nose/utils.py

@@ -0,0 +1,410 @@
+import hashlib
+import logging
+import re
+import os
+from typing import List
+from traceback import format_exception_only
+from nose2 import (
+    util,
+    result
+)
+import inspect
+
+from testit_python_commons.models.link import Link
+from testit_python_commons.models.link_type import LinkType
+from testit_python_commons.models.test_result import TestResult
+from testit_python_commons.models.status_type import StatusType
+
+
+__ARRAY_TYPES = (frozenset, list, set, tuple,)
+STATUS_TYPE = {
+    result.PASS: StatusType.SUCCEEDED,
+    result.FAIL: StatusType.FAILED,
+    result.ERROR: StatusType.FAILED,
+    result.SKIP: StatusType.INCOMPLETE,
+}
+
+def status_details(event):
+    message, trace = None, None
+    if event.exc_info:
+        exc_type, value, _ = event.exc_info
+        message = '\n'.join(format_exception_only(exc_type, value)) if exc_type or value else None
+        trace = ''.join(util.exc_info_to_string(event.exc_info, event.test))
+    elif event.reason:
+        message = event.reason
+
+    return message, trace
+
+
+def get_outcome(event):
+    outcome = event.outcome
+    message = None
+    trace = None
+
+    if outcome == result.PASS and not event.expected:
+        message = "test passes unexpectedly"
+    elif outcome == result.FAIL and not event.expected:
+        message, trace = status_details(event)
+    elif outcome == result.ERROR:
+        message, trace = status_details(event)
+    elif outcome == result.SKIP:
+        message, trace = status_details(event)
+
+    return outcome, message, trace
+
+
+def form_test(item, top_level_directory):
+    if hasattr(item, '_testFunc'):
+        function = item._testFunc
+    elif hasattr(item, '_testMethodName'):
+        function = getattr(item.__class__, item._testMethodName)
+    else:
+        raise Exception('')
+
+    return {
+        'externalID': __get_external_id_from(item, function),
+        'autoTestName': __get_display_name_from(item, function),
+        'steps': [],
+        'stepResults': [],
+        'setUp': [],
+        'setUpResults': [],
+        'tearDown': [],
+        'tearDownResults': [],
+        'resultLinks': [],
+        'duration': 0,
+        'outcome': None,
+        'status_type': None,
+        'failureReasonName': None,
+        'traces': None,
+        'attachments': [],
+        'parameters': get_all_parameters(item),
+        'properties': __get_properties_from(function),
+        'namespace': __get_namespace_from(item, function),
+        'classname': __get_class_name_from(item, function),
+        'title': __get_title_from(item, function),
+        'description': __get_description_from(item, function),
+        'links': __get_links_from(item, function),
+        'labels': __get_labels_from(item, function),
+        'tags': __get_tags_from(item, function),
+        'workItemsID': __get_work_item_ids_from(item, function),
+        'message': None,
+        'externalKey': __get_fullname(function, top_level_directory)
+    }
+
+
+def __get_display_name_from(item, function):
+    display_name = __search_attribute(function, 'test_displayname')
+
+    if not display_name:
+        return function.__doc__ if \
+            function.__doc__ else function.__name__
+
+    return collect_parameters_in_string_attribute(display_name, get_all_parameters(item))
+
+
+def __get_external_id_from(item, function):
+    external_id = __search_attribute(function, 'test_external_id')
+
+    if not external_id:
+        return get_hash(function.__qualname__ + function.__name__)
+
+    return collect_parameters_in_string_attribute(external_id, get_all_parameters(item))
+
+
+def __get_title_from(item, function):
+    title = __search_attribute(function, 'test_title')
+
+    if not title:
+        return None
+
+    return collect_parameters_in_string_attribute(title, get_all_parameters(item))
+
+
+def __get_description_from(item, function):
+    description = __search_attribute(function, 'test_description')
+
+    if not description:
+        return None
+
+    return collect_parameters_in_string_attribute(description, get_all_parameters(item))
+
+
+def __get_namespace_from(item, function):
+    namespace = __search_attribute(function, 'test_namespace')
+
+    if not namespace:
+        return function.__module__
+
+    return collect_parameters_in_string_attribute(namespace, get_all_parameters(item))
+
+
+def __get_class_name_from(item, function):
+    class_name = __search_attribute(function, 'test_classname')
+
+    if not class_name:
+        i = function.__qualname__.find('.')
+
+        if i != -1:
+            return function.__qualname__[:i]
+
+        return None
+
+    return collect_parameters_in_string_attribute(class_name, get_all_parameters(item))
+
+
+def __get_links_from(item, function):
+    links = __search_attribute(function, 'test_links')
+
+    if not links:
+        return []
+
+    return __set_parameters_to_links(links, get_all_parameters(item))
+
+
+def __get_properties_from(function):
+    return __search_attribute(function, 'test_properties')
+
+
+def __set_parameters_to_links(links, all_parameters):
+    if not all_parameters:
+        return links
+
+    links_with_parameters = []
+
+    for link in links:
+        links_with_parameters.append(
+            Link()
+            .set_url(
+                collect_parameters_in_string_attribute(
+                    link.get_url(),
+                    all_parameters))
+            .set_title(
+                collect_parameters_in_string_attribute(
+                    link.get_title(),
+                    all_parameters) if link.get_title() else None)
+            .set_link_type(
+                collect_parameters_in_string_attribute(
+                    link.get_link_type(),
+                    all_parameters) if link.get_link_type() else LinkType.RELATED)
+            .set_description(
+                collect_parameters_in_string_attribute(
+                    link.get_description(),
+                    all_parameters) if link.get_description() else None))
+
+    return links_with_parameters
+
+
+def __get_labels_from(item, function) -> List[dict]:
+    test_labels = __search_attribute(function, 'test_labels')
+
+    if not test_labels:
+        return []
+
+    labels = []
+
+    for label in test_labels:
+        result = collect_parameters_in_mass_attribute(
+            label,
+            get_all_parameters(item))
+
+        if isinstance(result, __ARRAY_TYPES):
+            for l in result:
+                labels.append({
+                    'name': str(l)
+                })
+        else:
+            labels.append({
+                'name': str(result)
+            })
+
+    return labels
+
+
+def __get_tags_from(item, function) -> List[str]:
+    test_tags = __search_attribute(function, 'test_tags')
+
+    if not test_tags:
+        return []
+
+    tags = []
+
+    for tag in test_tags:
+        result = collect_parameters_in_mass_attribute(
+            tag,
+            get_all_parameters(item))
+
+        if isinstance(result, __ARRAY_TYPES):
+            for t in result:
+                tags.append(str(t))
+        else:
+            tags.append(str(result))
+
+    return tags
+
+
+def __get_work_item_ids_from(item, function):
+    test_workitems_id = __search_attribute(function, 'test_workitems_id')
+
+    if not test_workitems_id:
+        return []
+
+    all_parameters = get_all_parameters(item)
+
+    if not all_parameters:
+        return test_workitems_id
+
+    result = collect_parameters_in_mass_attribute(test_workitems_id[0], all_parameters)
+
+    return map(str, result) if isinstance(result, __ARRAY_TYPES) else [str(result)]
+
+
+def __get_fullname(function, top_level_directory: str):
+    module_file_name = __get_module_file_name_by_test_function(function)
+
+    if not module_file_name:
+        return __join_nose_test_node([function.__module__, function.__qualname__])
+
+    absolute_module_path = __get_absolute_module_path_by_file_name(module_file_name)
+    module_node = __convert_absolute_module_path_to_nose_module_node(absolute_module_path, top_level_directory)
+
+    return __join_nose_test_node([module_node, function.__module__, function.__qualname__])
+
+
+def __get_module_file_name_by_test_function(test_function):
+    return __import__(test_function.__module__).__file__
+
+
+def __get_absolute_module_path_by_file_name(module_file_name: str):
+    return os.path.dirname(module_file_name)
+
+
+def __convert_absolute_module_path_to_nose_module_node(absolute_module_path: str, top_level_directory: str):
+    directories_in_project = absolute_module_path.replace(top_level_directory + os.sep, '')
+
+    return directories_in_project.replace(os.sep, '.')
+
+
+def __join_nose_test_node(test_node_parts: List[str]):
+    return ".".join(test_node_parts)
+
+
+def __search_attribute(function, attribute):
+    if hasattr(function, attribute):
+        return getattr(function, attribute)
+
+    return
+
+
+def get_all_parameters(item):
+    def _params(names, values):
+        return {name: str(value) for name, value in zip(names, values)}
+
+    test_id = item.id()
+
+    if len(test_id.split("\n")) > 1:
+        if hasattr(item, "_testFunc"):
+            wrapper_arg_spec = inspect.getfullargspec(item._testFunc)
+            arg_set, obj = wrapper_arg_spec.defaults
+            args = inspect.signature(obj).parameters.keys()
+
+            return _params(args, arg_set)
+        elif hasattr(item, "_testMethodName"):
+            method = getattr(item, item._testMethodName)
+            wrapper_arg_spec = inspect.getfullargspec(method)
+            obj, arg_set = wrapper_arg_spec.defaults
+            test_arg_spec = inspect.getfullargspec(obj)
+            args = test_arg_spec.args
+
+            return _params(args[1:], arg_set)
+
+
+def collect_parameters_in_string_attribute(attribute, all_parameters):
+    param_keys = re.findall(r"\{(.*?)\}", attribute)
+
+    if len(param_keys) > 0:
+        for param_key in param_keys:
+            parameter = get_parameter(param_key, all_parameters)
+
+            if parameter is not None:
+                attribute = attribute.replace("{" + param_key + "}", str(parameter))
+
+    return attribute
+
+
+def collect_parameters_in_mass_attribute(attribute, all_parameters):
+    param_keys = re.findall(r"\{(.*?)\}", attribute)
+
+    if len(param_keys) == 1:
+        parameter = get_parameter(param_keys[0], all_parameters)
+
+        if parameter is not None:
+            return parameter
+
+    if len(param_keys) > 1:
+        logging.error(f'(For type tuple, list, set) support only one key!')
+
+    return attribute
+
+
+def get_parameter(key_for_parameter, all_parameters):
+    id_keys_in_parameter = re.findall(r'\[(.*?)\]', key_for_parameter)
+
+    if len(id_keys_in_parameter) > 1:
+        logging.error("(For type tuple, list, set, dict) support only one level!")
+
+        return
+
+    if len(id_keys_in_parameter) == 0:
+        if key_for_parameter not in all_parameters:
+            logging.error(f"Key for parameter {key_for_parameter} not found")
+
+            return
+
+        return all_parameters[key_for_parameter]
+
+    parameter_key = key_for_parameter.replace("[" + id_keys_in_parameter[0] + "]", "")
+    id_key_in_parameter = id_keys_in_parameter[0].strip("\'\"")
+
+    nested = all_parameters.get(parameter_key)
+
+    if id_key_in_parameter.isdigit() and isinstance(nested, (list, tuple)):
+        index = int(id_key_in_parameter)
+        if index in range(len(nested)):
+            return nested[index]
+
+    if isinstance(nested, dict) and id_key_in_parameter in nested:
+        return nested[id_key_in_parameter]
+
+    logging.error(f"Not key: {key_for_parameter} in run parameters or other keys problem")
+
+
+def get_hash(value: str):
+    md = hashlib.sha256(bytes(value, encoding='utf-8'))
+    return md.hexdigest()
+
+
+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'])

testit_adapter_nose-4.2.8.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: testit-adapter-nose
+Version: 4.2.8
+Summary: Nose 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: attrs
+Requires-Dist: nose2
+Requires-Dist: testit-python-commons==4.2.8
+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 Nose
+
+![Test IT](https://raw.githubusercontent.com/testit-tms/adapters-python/master/images/banner.png)
+
+[![Release
+Status](https://img.shields.io/pypi/v/testit-adapter-nose?style=plastic)](https://pypi.python.org/pypi/testit-adapter-nose)
+[![Downloads](https://img.shields.io/pypi/dm/testit-adapter-nose?style=plastic)](https://pypi.python.org/pypi/testit-adapter-nose)
+[![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-nose
+```
+
+## Usage
+
+### Configuration
+
+| Description                                                                                                                                                                                                                                                                                                         | File property                     | Environment variable                       |
+|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------|--------------------------------------------|
+| Location of the TMS instance                                                                                                                                                                                                                                                                                        | url                               | TMS_URL                                    |
+| API secret key [How to getting API secret key?](https://github.com/testit-tms/.github/tree/main/configuration#privatetoken)                                                                                                                                                                                         | privateToken                      | TMS_PRIVATE_TOKEN                          |
+| 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                             |
+| 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                       |
+| ID of the created test run in TMS instance.<br/>It's necessary for **adapterMode** 1                                                                                                                                                                                                                                | testRunId                         | TMS_TEST_RUN_ID                            |
+| 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                          |
+| Adapter mode. Default value - 1. The adapter supports following modes:<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                           |
+| It enables/disables certificate validation (**It's optional**). Default value - true                                                                                                                                                                                                                                | certValidation                    | TMS_CERT_VALIDATION                        |
+| 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          |
+| 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 |
+| 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                        |
+| Url of proxy server (**It's optional**)                                                                                                                                                                                                                                                                             | tmsProxy                          | TMS_PROXY                                  |
+| Name (**including extension**) of the configuration file If it is not provided, it is used default file name (**It's optional**)                                                                                                                                                                                    | -                                 | TMS_CONFIG_FILE                            |
+| Sync storage port (**It's optional, 49152 by default**)                                                                                                                                                                                                                                                             | syncStoragePort                   | TMS_SYNC_STORAGE_PORT                      |
+
+#### 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
+
+# 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:
+
+```
+$ nose2 --testit
+```
+
+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 nose \
+  --output tmp/filter.txt
+  
+$ nose2 $(cat tmp/filter.txt) --testit
+```
+
+### Decorators
+
+Decorators can be used to specify information about autotest.
+
+Description of decorators:
+
+- `testit.workItemIds` - a method that links autotests with manual tests. Receives the array of manual tests' IDs
+- `testit.displayName` - internal autotest name (used in Test IT)
+- `testit.externalId` - unique internal autotest ID (used in Test IT)
+- `testit.title` - autotest name specified in the autotest card. If not specified, the name from the displayName method is used
+- `testit.description` - autotest description specified in the autotest card
+- `testit.labels` - labels listed in the autotest card
+- `testit.tags` - tags listed in the autotest card
+- `testit.links` - links listed in the autotest card
+- `testit.step` - the designation of the step called in the body of the test or other step
+- `testit.nameSpace` - directory in the TMS system (default - file's name of test)
+- `testit.className` - subdirectory in the TMS system (default - class's name of test)
+
+All decorators support the use of parameterization attributes
+
+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 pytest
+import testit
+
+
+# Test with a minimal set of decorators
+@testit.externalId('Simple_autotest2')
+def test_2():
+    """Simple autotest 2"""
+    assert oneStep()
+    assert twoStep()
+
+
+@testit.step
+def oneStep():
+    assert oneOneStep()
+    assert oneTwoStep()
+    return True
+
+
+@testit.step
+def twoStep():
+    return True
+
+
+@testit.step('step 1.1', 'description')
+def oneOneStep():
+    return True
+
+
+@testit.step('step 2')
+def oneTwoStep():
+    return True
+```
+
+#### 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
+# Parameterized test with a full set of decorators
+from os.path import join, dirname
+
+import testit
+from nose2.tools import params
+
+@params(1, 2, 3)
+@testit.workItemIds(627)
+@testit.externalId('param {num}')
+@testit.displayName('param {num}')
+@testit.title('Test with params')
+@testit.description('E2E_autotest')
+@testit.tags('parameters', 'test')
+@testit.links(url='https://dumps.example.com/module/JCP-777')
+@testit.links(url='https://dumps.example.com/module/JCP-777',
+              title='JCP-777',
+              type=testit.LinkType.RELATED,
+              description='Description of JCP-777')
+def test_nums(num):
+    assert num < 4
+```
+
+# 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_nose-4.2.8.dist-info/RECORD

@@ -0,0 +1,9 @@
+testit_adapter_nose/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testit_adapter_nose/listener.py,sha256=FoHDxfjhBuP_01fEgC7HLJzbQnjo8Blb2Z4EonuPRPg,2613
+testit_adapter_nose/plugin.py,sha256=WJ9v30T9Bjvn2toK5f1p-YbbyK4T1ByNpghn_qIirks,1284
+testit_adapter_nose/utils.py,sha256=gqvsog1p_4RM2iInrT7J7aBf3OZiKcf_BYGc96k23ug,12906
+testit_adapter_nose-4.2.8.dist-info/METADATA,sha256=Um4-HJfFjhReL-npL2NJx9rFmibLIw26D5ZGtzdtQrU,14438
+testit_adapter_nose-4.2.8.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+testit_adapter_nose-4.2.8.dist-info/entry_points.txt,sha256=v2UoVNaRVZYkCyg8lvcHPQRAznR-C6QCEYsPt-VNhMA,79
+testit_adapter_nose-4.2.8.dist-info/top_level.txt,sha256=aWoMZg9QARCSvZaPfRFCa3EZ6Jnil0viMGk1Cz0moIo,20
+testit_adapter_nose-4.2.8.dist-info/RECORD,,

testit_adapter_nose-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_nose-4.2.8.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[nose.plugins.0.10]
+testit_adapter_nose = testit_adapter_nose.plugin:TmsPlugin

testit_adapter_nose-4.2.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+testit_adapter_nose