opentf-toolkit-nightly 0.55.0.dev921__py3-none-any.whl → 0.55.0.dev938__py3-none-any.whl

opentf/commons/datasources.py

@@ -24,11 +24,48 @@ from opentf.toolkit.core import warning
 ########################################################################
 # Constants
 
+SUCCESS = 'SUCCESS'
+FAILURE = 'FAILURE'
+ERROR = 'ERROR'
+SKIPPED = 'SKIPPED'
+TOTAL = 'total count'
+
 DETAILS_KEYS = ('failureDetails', 'errorDetails', 'warningDetails')
-FAILURE_STATUSES = ('FAILURE', 'ERROR')
+STATUSES_ORDER = (SUCCESS, FAILURE, ERROR, SKIPPED)
+FAILURE_STATUSES = (FAILURE, ERROR)
+
+########################################################################
+## Helpers
+
+
+def _get_path(src: Dict[str, Any], path: List[str]) -> Any:
+    if not path:
+        return src
+    try:
+        return _get_path(src[path[0]], path[1:])
+    except KeyError:
+        return 'KeyError'
+
+
+def _get_sorted_testcases(
+    testcase_metadata: Dict[str, Any], path: List[str]
+) -> Dict[str, Any]:
+    sorted_testcases = {}
+    for testcase, data in testcase_metadata.items():
+        sorted_testcases.setdefault(_get_path(data, path), {})[testcase] = data
+    return sorted_testcases
+
+
+def _get_sum_for_status(testcases: Dict[str, Any], status: str) -> int:
+    return sum(1 for testcase in testcases.values() if testcase['status'] == status)
+
+
+def _as_list(what) -> List[str]:
+    return [what] if isinstance(what, str) else what
+
 
 ########################################################################
-## Test results handling
+## Datasource: Testcases
 
 
 def in_scope(expr: str, contexts: Dict[str, Any], scopes_errors: Set[str]) -> bool:
@@ -44,26 +81,58 @@ def in_scope(expr: str, contexts: Dict[str, Any], scopes_errors: Set[str]) -> bo
     return False
 
 
-def get_testresults(
-    events: List[Dict[str, Any]]
-) -> Generator[Dict[str, Any], None, None]:
+def get_testresults(events: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Return a possibly empty list of Notifications.
 
     Each notification in the list is guaranteed to have a
     `spec.testResults` entry.
     """
-    return (item for item in events if _has_testresult(item))
+    return [item for item in events if _has_testresult(item)]
 
 
 def _has_testresult(item: Dict[str, Any]) -> bool:
-    """..."""
+    """Determine if a workflow notification has a testResults element."""
     return item.get('kind') == 'Notification' and item.get('spec', {}).get(
         'testResults', False
     )
 
 
-def _as_list(what) -> List[str]:
-    return [what] if isinstance(what, str) else what
+def _uses_inception(events: List[Dict[str, Any]]) -> bool:
+    """Determine if a workflow is the inception workflow."""
+    workflow_event = next(
+        (event for event in events if event['kind'] == 'Workflow'), None
+    )
+    if not workflow_event:
+        raise ValueError('No Workflow event in workflow events...')
+    return any(
+        'inception' in _as_list(job['runs-on'])
+        for job in workflow_event['jobs'].values()
+    )
+
+
+def _get_inception_testresults(events: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Get unique testResults notifications for inception workflow.
+
+    Note: This is a kludge until we find a reliable way to map such results
+    to the executed tests list.
+    """
+    unique_results = set()
+    unique_events = []
+    for event in get_testresults(events):
+        event_results = []
+        for result in event['spec']['testResults']:
+            event_results.append(
+                (
+                    result['attachment_origin'],
+                    result['name'],
+                    result['duration'],
+                    result['status'],
+                )
+            )
+        if tuple(event_results) not in unique_results:
+            unique_results.add(tuple(event_results))
+            unique_events.append(event)
+    return unique_events
 
 
 def _get_testresult_params(param_step_id: str, job: Dict[str, Any]) -> Dict[str, Any]:
@@ -156,7 +225,9 @@ def _create_testresult_labels(
     return labels
 
 
-def _get_testresult_steporigin(attachment_origin, events) -> Optional[str]:
+def _get_testresult_steporigin(
+    attachment_origin: str, events: List[Dict[str, Any]]
+) -> Optional[str]:
     """Find the step that produced the attachment.
 
     # Required parameters
@@ -229,6 +300,7 @@ def _get_timestamp(
 
 def _get_testresult_timestamps(
     events: List[Dict[str, Any]],
+    testresults: List[Dict[str, Any]],
     testcase_metadata: Dict[str, Any],
 ):
     """Set timestamp for each testcase in testcase_metadata.
@@ -242,7 +314,7 @@ def _get_testresult_timestamps(
     }
 
     origins_results = defaultdict(list)
-    for item in get_testresults(events):
+    for item in testresults:
         for result in item['spec']['testResults']:
             origins_results[result['attachment_origin']].append(result['id'])
 
@@ -271,7 +343,13 @@ def get_testcases(events: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
 
     - name: a string, the test case name
     - status: a string, the test case status
+    - duration: a string, the test case execution time in ms
+    - timestamp: a string, provider creation timestamp
     - test: a dictionary, the test case metadata
+    - failureDetails|errorDetails|warningDetails: a dictionary with test
+      case failure details
+    - errorsList: a Robot Framework specific list with execution general
+      errors
 
     `testcases` is a dictionary of entries like:
 
@@ -310,7 +388,12 @@ def get_testcases(events: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
     """
     testcases = {}
     results = False
-    for testresult in get_testresults(events):
+    if _uses_inception(events):
+        testresults = _get_inception_testresults(events)
+    else:
+        testresults = get_testresults(events)
+
+    for testresult in testresults:
         results = True
         labels = _get_testresult_labels(
             testresult['metadata']['attachment_origin'][0], events
@@ -320,7 +403,7 @@ def get_testcases(events: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
         for testcase in testresult['spec']['testResults']:
             testcases[testcase['id']] = {
                 'name': testcase['name'],
-                'status': testcase['status'],
+                'status': testcase['status'].lower(),
                 'duration': testcase.get('duration', 0),
                 'test': labels.copy(),
             }
@@ -333,5 +416,149 @@ def get_testcases(events: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
             testcases[testcase['id']].update(data)
     if not results:
         raise ValueError('No test results in events.')
-    _get_testresult_timestamps(events, testcases)
+    _get_testresult_timestamps(events, testresults, testcases)
     return testcases
+
+
+########################################################################
+## Datasource: Tags
+
+
+def get_tags(
+    events: List[Dict[str, Any]], testcase_metadata: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """Extract metadata for each execution environment tag.
+
+    # Required parameters:
+
+    - events: a list of events
+
+    # Returned value:
+
+    A dictionary. Keys are tags names, values are dictionaries with testcase
+    by tag status counters.
+
+    `tags` is a dictionary of entries like:
+
+    ```
+    "<<<tag name>>>": {
+        "FAILURE": <<<failed tests count>>>,
+        "SUCCESS": <<<passed tests count>>>,
+        "SKIPPED": <<<skipped tests count>>>,
+        "ERROR": <<<technical KO tests count>>>,
+        'total': <<<total tests count>>>,
+        'other': <<<SKIPPED + ERROR tests count>>>
+    }
+    ```
+    """
+    try:
+        testcase_metadata = testcase_metadata or get_testcases(events)
+    except ValueError as err:
+        raise ValueError(str(err) + ' Cannot extract metadata for tags.')
+    tags = {}
+    for testcase in testcase_metadata.values():
+        for tag in testcase['test']['runs-on']:
+            tags.setdefault(tag, {SUCCESS: 0, FAILURE: 0, ERROR: 0, SKIPPED: 0})
+            tags[tag][testcase['status']] += 1
+    for tag, counts in tags.items():
+        counts['total'] = sum(counts[status] for status in STATUSES_ORDER)
+        counts['other'] = sum(counts[status] for status in (SKIPPED, ERROR))
+        tags[tag] = {k.lower(): v for k, v in counts.items()}
+    return tags
+
+
+########################################################################
+## Datasource: Jobs
+
+
+def _evaluate_test_results(jobs_testcases: Dict[str, Any]) -> Dict[str, Any]:
+    """Summarize job testcases.
+
+    # Returned value
+
+    A dictionary with one entry per job (a dictionary with keys being
+    statuses and values being counts).
+    """
+    summaries = {}
+    for job, testcases in jobs_testcases.items():
+        successes, failures, errors, skipped = [
+            _get_sum_for_status(testcases, status) for status in STATUSES_ORDER
+        ]
+        summaries[job] = {
+            SUCCESS: successes,
+            FAILURE: failures,
+            ERROR: errors,
+            SKIPPED: skipped,
+            TOTAL: len(testcases),
+        }
+    return summaries
+
+
+def get_jobs(
+    events: List[Dict[str, Any]], testcase_metadata: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """Extract metadata for each job.
+
+    # Required parameters:
+
+    - events: a list of events
+
+    # Returned value:
+
+    A dictionary. Keys are job names, values are dictionaries with the
+    following entries:
+
+    - name: a string, job name
+    - runs-on: a list, execution environment tags
+    - testcases: a dictionary, job-related test cases
+    - counts: a dictionary, tests statuses count by job
+    - variables: a dictionary, job-related environment variables
+
+    `jobs_testcases` is a dictionary of entries like:
+
+    ```
+    "<<<job_name>>>": {
+        "runs-on": [<<<execution environment tags>>>],
+        "counts": {
+            "FAILURE": <<<failed tests count>>>,
+            "SUCCESS": <<<passed tests count>>>,
+            "ERROR": <<<technical KOs count>>>,
+            "SKIPPED": <<<skipped tests count>>>,
+            "total count": <<<total tests count>>>
+        },
+        "variables": {
+            "<<<variable name>>>": "<<<variable value>>>",
+            ...
+        }
+    }
+    ```
+    """
+    try:
+        testcase_metadata = testcase_metadata or get_testcases(events)
+    except ValueError as err:
+        raise ValueError(str(err) + ' Cannot extract metadata for jobs.')
+    jobs_testcases = _get_sorted_testcases(testcase_metadata, ['test', 'job'])
+    if 'KeyError' in jobs_testcases:
+        raise ValueError('Cannot get jobs-ordered dataset from testcases.')
+    job_events = [
+        event
+        for event in events
+        if event['kind'] == 'ExecutionCommand'
+        and event['metadata']['step_sequence_id'] == -1
+        and event['metadata']['name'] in jobs_testcases
+    ]
+    results = _evaluate_test_results(jobs_testcases)
+    jobs = {}
+    for job in job_events:
+        job_name = job['metadata']['name']
+        jobs.setdefault(
+            job['metadata']['name'],
+            {
+                'runs-on': job['runs-on'],
+                'counts': {k.lower(): v for k, v in results[job_name].items()},
+                'variables': {
+                    name: value for name, value in job.get('variables', {}).items()
+                },
+            },
+        )
+    return jobs

{opentf_toolkit_nightly-0.55.0.dev921.dist-info → opentf_toolkit_nightly-0.55.0.dev938.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentf-toolkit-nightly
-Version: 0.55.0.dev921
+Version: 0.55.0.dev938
 Summary: OpenTestFactory Orchestrator Toolkit
 Home-page: https://gitlab.com/henixdevelopment/open-source/opentestfactory/python-toolkit
 Author: Martin Lafaix

{opentf_toolkit_nightly-0.55.0.dev921.dist-info → opentf_toolkit_nightly-0.55.0.dev938.dist-info}/RECORD

@@ -1,7 +1,7 @@
 opentf/commons/__init__.py,sha256=ITzg1zfZgA5-4wvmJfjLN94_Z06HeMl0szd6dalrrKY,21839
 opentf/commons/auth.py,sha256=bM2Z3kxm2Wku1lKXaRAIg37LHvXWAXIZIqjplDfN2P8,15899
 opentf/commons/config.py,sha256=GmvInVnUsXIwlNfgTQeQ_pPs97GeGTGn2S2QZEFwss8,7828
-opentf/commons/datasources.py,sha256=Ux7DIo1Bd4qKTB8JOPYSBHtUjtS93Lgxz_Y0K3Dd1uY,10925
+opentf/commons/datasources.py,sha256=OkPp0allFp-G9qBkU4Fxc6aGiytkMO3Xr3KLl4E5zWM,18234
 opentf/commons/expressions.py,sha256=A68F27Our8oVVphUrRvB5haSlqj2YCrH2OxHPNLBio4,19251
 opentf/commons/pubsub.py,sha256=7khxAHVZiwJRcwIBJ6MPR-f3xY9144-2eNLROwq5F-4,5894
 opentf/commons/schemas.py,sha256=lokZCU-wmsIkzVA-TVENtC7Io_GmYxrP-FQaOOowg4s,4044
@@ -48,8 +48,8 @@ opentf/scripts/startup.py,sha256=Da2zo93pBWbdRmj-wgekgLcF94rpNc3ZkbvR8R0w8XY,212
 opentf/toolkit/__init__.py,sha256=g3DiTZlSvvzZWKgM8qU47muLqjQrpWZ6M6PWZ-sBsvQ,19610
 opentf/toolkit/channels.py,sha256=Cng3b4LUsxvCHUbp_skys9CFcKZMfcKhA_ODg_EAlIE,17156
 opentf/toolkit/core.py,sha256=L1fT4YzwZjqE7PUXhJL6jSVQge3ohBQv5UBb9DAC6oo,9320
-opentf_toolkit_nightly-0.55.0.dev921.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-opentf_toolkit_nightly-0.55.0.dev921.dist-info/METADATA,sha256=BhP_cydTKTO1fEMwhaJY1gUGwO155pD_7QOgp-krb7o,1945
-opentf_toolkit_nightly-0.55.0.dev921.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-opentf_toolkit_nightly-0.55.0.dev921.dist-info/top_level.txt,sha256=_gPuE6GTT6UNXy1DjtmQSfCcZb_qYA2vWmjg7a30AGk,7
-opentf_toolkit_nightly-0.55.0.dev921.dist-info/RECORD,,
+opentf_toolkit_nightly-0.55.0.dev938.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opentf_toolkit_nightly-0.55.0.dev938.dist-info/METADATA,sha256=1FipCBdX1nal-7wQEMhR1QrdYvJUuPMAGcEPjLAzDco,1945
+opentf_toolkit_nightly-0.55.0.dev938.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+opentf_toolkit_nightly-0.55.0.dev938.dist-info/top_level.txt,sha256=_gPuE6GTT6UNXy1DjtmQSfCcZb_qYA2vWmjg7a30AGk,7
+opentf_toolkit_nightly-0.55.0.dev938.dist-info/RECORD,,