opentf-toolkit-nightly 0.55.0.dev941__py3-none-any.whl → 0.55.0.dev962__py3-none-any.whl

opentf/commons/__init__.py

@@ -585,7 +585,10 @@ def is_uuid(uuid: str) -> bool:
 
 
 def make_status_response(
-    reason: str, message: str, details: Optional[Dict[str, Any]] = None
+    reason: str,
+    message: str,
+    details: Optional[Dict[str, Any]] = None,
+    silent: bool = False,
 ) -> Response:
     """Return a new status response object.
 
@@ -597,6 +600,7 @@ def make_status_response(
     # Optional parameters:
 
     - details: a dictionary or None (None by default)
+    - silent: a boolean (False by default)
 
     # Returned value
 
@@ -613,10 +617,11 @@ def make_status_response(
     - code: an integer (derived from `reason`)
     """
     code = REASON_STATUS[reason]
-    if code // 100 == 4:
-        logging.warning(message)
-    elif code // 100 == 5:
-        logging.error(message)
+    if not silent:
+        if code // 100 == 4:
+            logging.warning(message)
+        elif code // 100 == 5:
+            logging.error(message)
     return make_response(
         {
             'kind': 'Status',

opentf/commons/datasources.py

@@ -12,13 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Test case metadata retrieval helpers"""
+"""Datasources (testcases, tags and jobs) retrieval helpers"""
 
-from typing import Any, Dict, Generator, List, Optional, Set
-from collections import defaultdict
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
+
+from datetime import datetime
+
+
+from flask import current_app
 
 from opentf.commons.expressions import evaluate_bool
-from opentf.toolkit.core import warning
 
 
 ########################################################################
@@ -34,51 +37,76 @@ DETAILS_KEYS = ('failureDetails', 'errorDetails', 'warningDetails')
 STATUSES_ORDER = (SUCCESS, FAILURE, ERROR, SKIPPED)
 FAILURE_STATUSES = (FAILURE, ERROR)
 
+PROVIDERCOMMAND = 'ProviderCommand'
+EXECUTIONCOMMAND = 'ExecutionCommand'
+EXECUTIONRESULT = 'ExecutionResult'
+WORKFLOW = 'Workflow'
+GENERATORRESULT = 'GeneratorResult'
+CREATION_TIMESTAMP = 'creationTimestamp'
+
 ########################################################################
 ## 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 _merge_dicts(dict1: Dict[str, Any], dict2: Dict[str, Any]) -> Dict[str, Any]:
+    for k, v in dict1.items():
+        if k in dict2:
+            dict2[k] = _merge_dicts(v.copy(), dict2[k])
+    dict3 = dict1.copy()
+    dict3.update(dict2)
+    return dict3
 
 
-def _get_sorted_testcases(
-    testcase_metadata: Dict[str, Any], path: List[str]
+def _as_list(what) -> List[str]:
+    return [what] if isinstance(what, str) else what
+
+
+def _get_metadata(
+    filter_: Callable, events: Iterable[Dict[str, Any]], kind_: 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
+    """Get metadata of the first workflow event that satisfies filter.
+
+    # Required parameters
 
+    - filter_: a callable, filtering fuction
+    - events: a list of events or iterator
+    - kind_: a string, considered events kind
 
-def _get_sum_for_status(testcases: Dict[str, Any], status: str) -> int:
-    return sum(1 for testcase in testcases.values() if testcase['status'] == status)
+    # Returned value
 
+    A possibly empty dictionary, the `.metadata` part of the
+    first event that satisfies kind and filter conditions.
+    """
+    src = (event for event in events if event['kind'] == kind_)
+    return next(filter(filter_, src), {}).get('metadata', {})
 
-def _as_list(what) -> List[str]:
-    return [what] if isinstance(what, str) else what
+
+def parse_testcase_name(full_name: str) -> Tuple[str, str]:
+    """Parse test case name from testResults notification.
+
+    full_name is a string: classname#testcase name
+
+    # Returned value
+
+    A tuple of two strings: suite and test case name. If one
+    of strings is empty, returns not empty element value instead.
+    """
+    suite, _, name = full_name.partition('#')
+    return suite or name, name or suite
 
 
 ########################################################################
 ## Datasource: Testcases
 
 
-def in_scope(expr: str, contexts: Dict[str, Any], scopes_errors: Set[str]) -> bool:
-    """Safely evaluate quality gate scope."""
+def in_scope(expr: str, contexts: Dict[str, Any]) -> bool:
+    """Safely evaluate datasource scope."""
     try:
         return evaluate_bool(expr, contexts)
     except ValueError as err:
-        msg = f'Invalid conditional {expr}: {err}.'
-        scopes_errors.add(msg)
+        raise ValueError(f'Invalid conditional {expr}: {err}.')
     except KeyError as err:
-        msg = f'Nonexisting context entry in expression {expr}: {err}.'
-        scopes_errors.add(msg)
-    return False
+        raise ValueError(f'Nonexisting context entry in expression {expr}: {err}.')
 
 
 def get_testresults(events: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
@@ -97,10 +125,31 @@ def _has_testresult(item: Dict[str, Any]) -> bool:
     )
 
 
+def _get_workflow_jobs(events: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """yada
+
+    # Required parameters
+
+    - events: a list of events
+
+    # Returned value
+
+    A dictionary.  Keys are job names, values are a (dict, event) pair.
+
+    _event_ is either a workflow or a generatorresult event.
+    """
+    return {
+        job_name + ' ' + event['metadata'].get('job_id', ''): (job, event)
+        for event in filter(lambda x: x['kind'] in (WORKFLOW, GENERATORRESULT), events)
+        for job_name, job in event.get('jobs', {}).items()
+        if job.get('steps')
+    }
+
+
 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
+        (event for event in events if event['kind'] == WORKFLOW), None
     )
     if not workflow_event:
         raise ValueError('No Workflow event in workflow events...')
@@ -156,49 +205,44 @@ def _get_testresult_params(param_step_id: str, job: Dict[str, Any]) -> Dict[str,
     ].pop()
 
 
-def _create_testresult_labels(
-    exec_step: Dict[str, Any],
-    job_name: str,
-    job: Dict[str, Any],
-    parent: Dict[str, Any],
-) -> Dict[str, Any]:
-    """Create labels for test result.
+def _get_testcase_timestamps_and_job_id(step_origin: str, events: List[Dict[str, Any]]):
+    def _is_origin_provider(event: Dict[str, Any]) -> bool:
+        return event['metadata']['step_id'] == step_origin
 
-    # Required parameters
+    def _is_origin_execution(event: Dict[str, Any]) -> bool:
+        return step_origin in event['metadata']['step_origin']
 
-    - exec_step: a dictionary, the 'execute' step
-    - job_name: a string (the name of the job containing exec_step)
-    - job: a dictionary, the job containing exec_step
-    - parent: a dictionary, the event defining the job
-
-    # Returned value
+    creation = _get_metadata(_is_origin_provider, events, PROVIDERCOMMAND)
+    start = _get_metadata(_is_origin_execution, events, EXECUTIONCOMMAND)
+    end = _get_metadata(_is_origin_execution, reversed(events), EXECUTIONRESULT)
 
-    A labels dictionary.
-    """
-    exec_step_id = exec_step['id']
-    labels = {
-        'job': job_name.split()[0],
-        'uses': exec_step['uses'],
-        'technology': exec_step['uses'].partition('/')[0],
-        'runs-on': _as_list(job['runs-on']),
-        'managed': False,
+    return {
+        'creationTimestamp': creation.get(CREATION_TIMESTAMP, None),
+        'startTime': start.get(CREATION_TIMESTAMP, None),
+        'endTime': end.get(CREATION_TIMESTAMP, None),
+        'job_id': creation.get('job_id', None),
     }
 
-    if not (managedtests := parent['metadata'].get('managedTests')):
-        return labels
+
+def _complete_labels(
+    labels: Dict[str, Any],
+    exec_step_id: str,
+    managedtests: Dict[str, Any],
+    job: Dict[str, Any],
+) -> Dict[str, Any]:
     testcases = managedtests.get('testCases')
     if not testcases or exec_step_id not in testcases:
         if not testcases:
-            warning(
+            current_app.logger.warning(
                 f'Was expecting a "testCases" part in parent of step {exec_step_id}, ignoring.'
             )
         return labels
 
-    labels['managed'] = True
+    labels['test']['managed'] = True
     testcase_metadata = testcases[exec_step_id]
-    labels['technology-name'] = testcase_metadata['technology']
-    labels['collection'] = managedtests.get('testPlan', {})
-    labels.update(
+    labels['test']['technology-name'] = testcase_metadata['technology']
+    labels['test']['collection'] = managedtests.get('testPlan', {})
+    labels['test'].update(
         {
             key: value
             for key, value in testcase_metadata.items()
@@ -216,15 +260,68 @@ def _create_testresult_labels(
     )
     try:
         params = _get_testresult_params(testcase_metadata['param_step_id'], job)
-        labels['global'] = params.get('global', {})
-        labels['data'] = params.get('test', {})
+        labels['test']['global'] = params.get('global', {})
+        labels['test']['data'] = params.get('test', {})
     except IndexError:
-        warning(
+        current_app.logger.warning(
             f'Could not find "params" step associated to "execute" step {exec_step_id}, ignoring.'
         )
     return labels
 
 
+def _create_testresult_labels(
+    events: List[Dict[str, Any]],
+    step_origin: str,
+    exec_step: Dict[str, Any],
+    job_name: str,
+    job: Dict[str, Any],
+    parent: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Create labels for test result.
+
+    # Required parameters
+
+    - events: a list, workflow events
+    - step_origin: a string, the 'execute' step uuid
+    - exec_step: a dictionary, the 'execute' step
+    - job_name: a string (the name of the job containing exec_step)
+    - job: a dictionary, the job containing exec_step
+    - parent: a dictionary, the event defining the job
+
+    # Returned value
+
+    A labels dictionary.
+    """
+    exec_step_id = exec_step['id']
+    times_jobid = _get_testcase_timestamps_and_job_id(step_origin, events)
+    labels = {
+        'apiVersion': 'testing.opentestfactory.org/v1alpha1',
+        'kind': 'TestCase',
+        'metadata': {
+            'creationTimestamp': times_jobid[CREATION_TIMESTAMP],
+            'execution_id': exec_step_id,
+            'job_id': times_jobid['job_id'],
+            'namespace': parent['metadata']['namespace'],
+            'workflow_id': parent['metadata']['workflow_id'],
+        },
+        'test': {
+            'job': job_name.split()[0],
+            'managed': False,
+            'runs-on': _as_list(job['runs-on']),
+            'technology': exec_step['uses'].partition('/')[0],
+            'test': exec_step.get('with', {}).get('test'),
+            'uses': exec_step['uses'],
+        },
+        'execution': {
+            'startTime': times_jobid['startTime'],
+            'endTime': times_jobid['endTime'],
+        },
+    }
+    if not (managedtests := parent['metadata'].get('managedTests')):
+        return labels
+    return _complete_labels(labels, exec_step_id, managedtests, job)
+
+
 def _get_testresult_steporigin(
     attachment_origin: str, events: List[Dict[str, Any]]
 ) -> Optional[str]:
@@ -240,7 +337,9 @@ def _get_testresult_steporigin(
     A step ID (a string) or None.
     """
     for event in events:
-        if not (event['kind'] == 'ExecutionResult' and event.get('attachments')):
+        if not (
+            event['kind'] == EXECUTIONRESULT and event['metadata'].get('attachments')
+        ):
             continue
         metadata = event['metadata']
         for value in metadata.get('attachments', {}).values():
@@ -269,64 +368,55 @@ def _get_testresult_labels(
     A _labels_ dictionary or None.
     """
     if step_origin := _get_testresult_steporigin(attachment_origin, events):
-        jobs_with_steps = {
-            job_name + ' ' + event['metadata'].get('job_id', ''): (job, event)
-            for event in events
-            for job_name, job in event.get('jobs', {}).items()
-            if event['kind'] in ('Workflow', 'GeneratorResult') and job.get('steps')
-        }
+        jobs_with_steps = _get_workflow_jobs(events)
         for job_name, (job, parent) in jobs_with_steps.items():
             for exec_step in job['steps']:
                 if exec_step.get('id') == step_origin:
-                    return _create_testresult_labels(exec_step, job_name, job, parent)
+                    return _create_testresult_labels(
+                        events, step_origin, exec_step, job_name, job, parent
+                    )
     return None
 
 
-def _get_timestamp(
-    event: Dict[str, Any], providerid_creationtimestamps: Dict[str, str]
-) -> str:
-    """Return first provider creationtimestamp or ''.
-
-    # Required parameters
-
-    - event: an ExecutionResult object
-    - providerid_creationtimestamps: a dictionary
-    """
-    for origin_id in event['metadata'].get('step_origin', []):
-        if origin_id in providerid_creationtimestamps:
-            return providerid_creationtimestamps[origin_id]
-    return ''
-
-
-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.
-
-    The timestamp is the one of the originating ProviderResult.
-    """
-    providerid_creationtimestamps = {
-        event['metadata']['step_id']: event['metadata'].get('creationTimestamp', '')
-        for event in events
-        if event['kind'] == 'ProviderResult'
+def _make_testcase_from_testresult(
+    item: Dict[str, Any],
+    labels: Dict[str, Any],
+    scope: str,
+) -> Dict[str, Any]:
+    suite_name, testcase_name = parse_testcase_name(item['name'])
+    item_data = {
+        'metadata': {
+            'name': item['name'],
+            'id': item['id'],
+        },
+        'test': {
+            'outcome': item['status'].lower(),
+            'suiteName': suite_name,
+            'testCaseName': testcase_name,
+        },
+        'status': item['status'],
+        'execution': {
+            'duration': item.get('duration', 0),
+        },
     }
-
-    origins_results = defaultdict(list)
-    for item in testresults:
-        for result in item['spec']['testResults']:
-            origins_results[result['attachment_origin']].append(result['id'])
-
-    for event in filter(lambda event: event['kind'] == 'ExecutionResult', events):
-        for attachment in event['metadata'].get('attachments', {}).values():
-            if attachment['uuid'] in origins_results:
-                timestamp = _get_timestamp(event, providerid_creationtimestamps)
-                for result_id in origins_results[attachment['uuid']]:
-                    testcase_metadata[result_id]['timestamp'] = timestamp
+    if item['status'] in FAILURE_STATUSES:
+        for key in DETAILS_KEYS:
+            if item.get(key):
+                item_data['execution'][key] = item[key]
+    if item.get('errorsList'):
+        item_data['execution']['errorsList'] = item['errorsList']
+    testcase = _merge_dicts(labels, item_data)
+    try:
+        if not in_scope(scope, testcase):
+            return {}
+    except ValueError as err:
+        raise ValueError(f'[SCOPE ERROR] {err}')
+    return testcase
 
 
-def get_testcases(events: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+def get_testcases(
+    events: List[Dict[str, Any]], scope: str = 'true'
+) -> Dict[str, Dict[str, Any]]:
     """Extract metadata for each test result.
 
     Test results are Notification events with a `.spec.testResults`
@@ -338,85 +428,66 @@ def get_testcases(events: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
 
     # Returned value
 
-    A possibly empty dictionary.  Keys are the testresult IDs, values
-    are dictionaries with the following entries:
-
-    - 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
+    A possibly empty dictionary.  Keys are the test result IDs, values
+    are dictionaries with test case metadata, labels, status, and
+    execution info.
 
     `testcases` is a dictionary of entries like:
 
     ```
-    "<<<testcase_uuid>>>": {
-        "name": "<<<[Test suite#]Test case name>>>",
-        "status": "<<<SUCCESS|FAILURE|ERROR|SKIPPED>>>",
-        "duration": "<<<test execution time in ms>>>",
-        "timestamp": "<<<provider creation timestamp>>>"
-        "test": {
-            "job": "<<<job name>>>",
-            "uses": "<<<provider function>>>",
-            "technology": "<<<test technology>>>",
-            "runs-on": [<<<list of execution environment tags>>>],
-            "managed": boolean, True for test cases managed by a test referential
-            "status": "<<<SUCCESS|FAILURE|ERROR|SKIPPED>>>"
-        },
-        "failureDetails"|"errorDetails"|"warningDetails": {
-            "message": "<<<error message>>>",
-            "type": "<<<error type>>>",
-            "text": "<<<error trace>>>"
-        },
-        "errorsList": [
-            {
-                "message": "<<<Robot Framework general error message>>>",
-                "timestamp": "<<<Robot Framework error message timestamp>>>"
-            }
-        ]
-    }
+    apiVersion: testing.opentestfactory.org/v1alpha1
+    kind: TestCase
+    metadata:
+      name: <<<Test case full name>>>
+      id: <<<Test case uuid>>>
+      job_id: <<<Test case job uuid>>>
+      execution_id: <<<Test case attachment origin uuid>>>
+      workflow_id: <<<Test case workflow uuid>>>
+      namespace: <<<Test case namespace>>>
+      creationTimestamp: <<<Test case provider creation timestamp>>>
+    test:
+      runs-on: <<<Test case execution environment tags>>>
+      uses: <<<Test case provider>>>
+      technology: <<<Test case technology>>>
+      managed: bool <<<True for test referential managed test cases>>>
+      job: <<<Test case job name>>>
+      test: <<<Test case test reference>>>
+      suiteName: <<<Test case suite>>>
+      testCaseName: <<<Test case short name>>>
+      outcome: <<<success|failure|skipped|error>>>
+    status: <<<SUCCESS|FAILURE|SKIPPED|ERROR>>>
+    execution:
+      startTime: <<<Test case execution start time>>>
+      endTime: <<<Test case execution end time>>>
+      duration: <<<Test case execution duration (from result notification)>>>
+      errorsList: [<<<Test case general execution errors>>>]
+      (failure|warning|error)Details: {<<<Test case failure details>>>}
     ```
 
     # Raised exceptions
 
     A _ValueError_ exception is raised if there were no test results in
-    `events`.
+    `events` or some scope errors occured retrieving test results.
     """
-    testcases = {}
-    results = False
     if _uses_inception(events):
         testresults = _get_inception_testresults(events)
     else:
         testresults = get_testresults(events)
 
+    if not testresults:
+        raise ValueError('No test results in events.')
+
+    testcases = {}
     for testresult in testresults:
-        results = True
-        labels = _get_testresult_labels(
-            testresult['metadata']['attachment_origin'][0], events
-        )
+        execution_id = testresult['metadata']['attachment_origin'][0]
+        labels = _get_testresult_labels(execution_id, events)
         if not labels:
             continue
-        for testcase in testresult['spec']['testResults']:
-            testcases[testcase['id']] = {
-                'name': testcase['name'],
-                'status': testcase['status'],
-                'duration': testcase.get('duration', 0),
-                'test': labels.copy(),
-            }
-            testcases[testcase['id']]['test']['status'] = testcase['status']
-            data = {}
-            if testcase['status'] in FAILURE_STATUSES:
-                data = {key: testcase[key] for key in DETAILS_KEYS if testcase.get(key)}
-            if testcase.get('errorsList'):
-                data['errorsList'] = testcase['errorsList']
-            testcases[testcase['id']].update(data)
-    if not results:
-        raise ValueError('No test results in events.')
-    _get_testresult_timestamps(events, testresults, testcases)
+        for item in testresult['spec']['testResults']:
+            if testcase := _make_testcase_from_testresult(item, labels, scope):
+                testcases[item['id']] = testcase
+    if not testcases:
+        raise ValueError(f'No test cases matching scope `{scope}`.')
     return testcases
 
 
@@ -424,9 +495,30 @@ def get_testcases(events: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
 ## Datasource: Tags
 
 
-def get_tags(
-    events: List[Dict[str, Any]], testcase_metadata: Optional[Dict[str, Any]] = None
-) -> Dict[str, Any]:
+def _make_tag_datasource(tag: str, parent: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        'apiVersion': 'opentestfactory.org/v1alpha1',
+        'kind': 'Tag',
+        'metadata': {
+            'name': tag,
+            'workflow_id': parent['metadata']['workflow_id'],
+            'namespace': parent['metadata']['namespace'],
+        },
+        'status': {
+            'jobCount': 0,
+            'testCaseCount': 0,
+            'testCaseStatusSummary': {
+                'success': 0,
+                'failure': 0,
+                'error': 0,
+                'skipped': 0,
+                'cancelled': 0,
+            },
+        },
+    }
+
+
+def get_tags(events: List[Dict[str, Any]], scope: str = 'true') -> Dict[str, Any]:
     """Extract metadata for each execution environment tag.
 
     # Required parameters:
@@ -435,35 +527,51 @@ def get_tags(
 
     # Returned value:
 
-    A dictionary. Keys are tags names, values are dictionaries with testcase
-    by tag status counters.
+    A dictionary. Keys are tags names, values are dictionaries with tag metadata and status.
 
     `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>>>
-    }
+    apiVersion: opentestfactory.org/v1alpha1
+    kind: Tag
+    metadata:
+      name: <<<Tag name>>>
+      workflow_id: <<<Tag workflow id>>>
+      namespace: <<<Tag namespace>>>
+    status:
+      jobCount: <<<Tag related jobs count>>>
+      testCaseCount: <<<Tag related test cases count>>>
+      testCaseStatusSummary: <<<Tag test case count by status>>>
+        success: N
+        failure: N
+        error: N
+        skipped: N
+        cancelled: N
     ```
     """
+    if not (jobs := _get_workflow_jobs(events)):
+        raise ValueError(
+            'No job events found in workflow. Cannot extract data for tags.'
+        )
     try:
-        testcase_metadata = testcase_metadata or get_testcases(events)
+        testcases = get_testcases(events, scope)
     except ValueError as err:
-        raise ValueError(str(err) + ' Cannot extract metadata for tags.')
+        if str(err).startswith('[SCOPE ERROR] '):
+            raise ValueError(str(err))
+        current_app.logger.debug(str(err))
+        testcases = {}
     tags = {}
-    for testcase in testcase_metadata.values():
+    for job, parent in jobs.values():
+        for tag in job['runs-on']:
+            tags.setdefault(tag, _make_tag_datasource(tag, parent))
+            tags[tag]['status']['jobCount'] += 1
+
+    for testcase in testcases.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()}
+            tags[tag]['status']['testCaseCount'] += 1
+            tags[tag]['status']['testCaseStatusSummary'][
+                testcase['test']['outcome']
+            ] += 1
     return tags
 
 
@@ -471,32 +579,119 @@ def get_tags(
 ## Datasource: Jobs
 
 
-def _evaluate_test_results(jobs_testcases: Dict[str, Any]) -> Dict[str, Any]:
-    """Summarize job testcases.
+def _collect_job_times_and_id(
+    events: List[Dict[str, Any]], request_metadata: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Collect job start and end time, if available.
+
+    # Required parameters
 
-    # Returned value
+    - events: a list of events
+    - request_metadata: the channel request metadata for the job
+
+    # Returned object
 
-    A dictionary with one entry per job (a dictionary with keys being
-    statuses and values being counts).
+    A dictionary with the following entries:
+
+    - job_id
+    - requestTime
+
+    If the job started, it contains the additional entries:
+
+    - startTime
+    - endTime
+    - duration
     """
-    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
+    job_id = request_metadata['job_id']
+    request_time = request_metadata[CREATION_TIMESTAMP]
+
+    start = end = None
+    for event in events:
+        metadata = event['metadata']
+        kind_step_id = (event['kind'], metadata['step_sequence_id'], metadata['job_id'])
+        if kind_step_id == (EXECUTIONCOMMAND, 0, job_id):
+            start = metadata[CREATION_TIMESTAMP]
+        elif kind_step_id == (EXECUTIONRESULT, -2, job_id):
+            end = metadata[CREATION_TIMESTAMP]
+        if start and end:
+            break
+    else:
+        return {'job_id': job_id, 'requestTime': request_time}
+
+    return {
+        'requestTime': request_time,
+        'startTime': start,
+        'endTime': end,
+        'duration': (
+            datetime.fromisoformat(end) - datetime.fromisoformat(start)
+        ).total_seconds()
+        * 1000,
+        'job_id': job_id,
+    }
 
 
-def get_jobs(
-    events: List[Dict[str, Any]], testcase_metadata: Optional[Dict[str, Any]] = None
+def _make_job_datasource(
+    job_name: str,
+    request_metadata: Dict[str, Any],
+    job: Dict[str, Any],
+    parent: Dict[str, Any],
+    events: List[Dict[str, Any]],
 ) -> Dict[str, Any]:
+    """Make datasource object for job.
+
+    # Required parameters
+
+    - job_name: a string, the 'short' job name
+    - request_metadata: the channel request metadata for the job or {}
+    - job: a dictionary, the job definition
+    - parent: a workflow or a generatorresult event
+    - events: a list of events
+
+    # Returned value
+
+    A 'Job' datasource object.
+    """
+    if request_metadata:
+        job_times_id = _collect_job_times_and_id(events, request_metadata)
+    else:
+        job_times_id = {}
+
+    return {
+        'apiVersion': 'opentestfactory.org/v1alpha1',
+        'kind': 'Job',
+        'metadata': {
+            'name': job_name,
+            'id': job_times_id.get('job_id'),
+            'namespace': parent['metadata']['namespace'],
+            'workflow_id': parent['metadata']['workflow_id'],
+            'creationTimestamp': parent['metadata'][CREATION_TIMESTAMP],
+        },
+        'spec': {
+            'runs-on': job['runs-on'],
+            'variables': {
+                **parent.get('variables', {}),
+                **job.get('variables', {}),
+            },
+        },
+        'status': {
+            'phase': 'SUCCEEDED',
+            'requestTime': job_times_id.get('requestTime'),
+            'startTime': job_times_id.get('startTime'),
+            'endTime': job_times_id.get('endTime'),
+            'duration': job_times_id.get('duration'),
+            'testCaseCount': 0,
+            'testCaseStatusSummary': {
+                'success': 0,
+                'failure': 0,
+                'error': 0,
+                'skipped': 0,
+                'cancelled': 0,
+            },
+        },
+    }
+
+
+def get_jobs(events: List[Dict[str, Any]], scope: str = 'true') -> Dict[str, Any]:
     """Extract metadata for each job.
 
     # Required parameters:
@@ -505,60 +700,88 @@ def get_jobs(
 
     # 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
+    A dictionary. Keys are job names, values are dictionaries with
+    job metadata, spec, and status.
 
     `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>>>",
-            ...
-        }
-    }
+    apiVersion: opentestfactory.org/v1alpha1
+    kind: Job
+    metadata:
+      name: <<<Job name>>
+      id: <<<Job uuid>>>
+      namespace: <<<Job namespace>>>
+      workflow_id: <<<Job workflow id>>>
+      creationTimestamp: <<<Job creation timestamp>>>
+    spec:
+      runs-on: <<<Job execution environment tags>>>
+      variables: <<<Workflow and job specific environment variables>>>
+    status:
+      phase: <<<Job phase>>>
+      requestTime: <<<Job execution environment request time>>>
+      startTime: <<<Job start time>>>
+      endTime: <<<Job end time>>>
+      duration: <<<Job duration (endTime - startTime)>>>
+      testCaseCount: <<<Job test case count>>>
+      testCaseStatusSummary: <<<Job test case count by status>>>
+        success: N
+        failure: N
+        error: N
+        skipped: N
+        cancelled: N
     ```
     """
+
+    def _matches(item, items):
+        if item and items:
+            return items[-1] == item
+        return not item and not items
+
+    if not (workflow_jobs := _get_workflow_jobs(events)):
+        raise ValueError(
+            'No job events found in workflow. Cannot extract data for jobs.'
+        )
+
     try:
-        testcase_metadata = testcase_metadata or get_testcases(events)
+        testcases = get_testcases(events, scope)
     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)
+        if str(err).startswith('[SCOPE ERROR] '):
+            raise ValueError(str(err))
+        current_app.logger.debug(str(err))
+        testcases = {}
+
+    jobs_events = list(
+        filter(
+            lambda event: event['kind'] in (EXECUTIONCOMMAND, EXECUTIONRESULT)
+            and event['metadata']['step_sequence_id'] in (0, -1, -2),
+            events,
+        )
+    )
     jobs = {}
-    for job in job_events:
-        job_name = job['metadata']['name']
-        jobs.setdefault(
-            job['metadata']['name'],
-            {
-                'runs-on': job['runs-on'],
-                'counts': results[job_name],
-                'variables': {
-                    name: value for name, value in job.get('variables', {}).items()
-                },
-            },
+    for job_name, (job, parent) in workflow_jobs.items():
+        name, _, uuid = job_name.partition(' ')
+        channel_request_metadata = next(
+            (
+                event
+                for event in jobs_events
+                if event['kind'] == EXECUTIONCOMMAND
+                and event['metadata']['step_sequence_id'] == -1
+                and event['metadata']['name'] == name
+                and _matches(uuid, event['metadata']['job_origin'])
+            ),
+            {'metadata': {}},
+        )['metadata']
+
+        data = _make_job_datasource(
+            name, channel_request_metadata, job, parent, jobs_events
         )
+        jobs[data['metadata']['id']] = data
+
+    for testcase in testcases.values():
+        jobs[testcase['metadata']['job_id']]['status']['testCaseCount'] += 1
+        jobs[testcase['metadata']['job_id']]['status']['testCaseStatusSummary'][
+            testcase['test']['outcome']
+        ] += 1
+
     return jobs

{opentf_toolkit_nightly-0.55.0.dev941.dist-info → opentf_toolkit_nightly-0.55.0.dev962.dist-info}/METADATA

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

{opentf_toolkit_nightly-0.55.0.dev941.dist-info → opentf_toolkit_nightly-0.55.0.dev962.dist-info}/RECORD

@@ -1,7 +1,7 @@
-opentf/commons/__init__.py,sha256=ITzg1zfZgA5-4wvmJfjLN94_Z06HeMl0szd6dalrrKY,21839
+opentf/commons/__init__.py,sha256=KRY8ShQw_0ZZ0oEOiKi4-xnWofE_QsFjEe1T8wUxJ-w,21952
 opentf/commons/auth.py,sha256=bM2Z3kxm2Wku1lKXaRAIg37LHvXWAXIZIqjplDfN2P8,15899
 opentf/commons/config.py,sha256=GmvInVnUsXIwlNfgTQeQ_pPs97GeGTGn2S2QZEFwss8,7828
-opentf/commons/datasources.py,sha256=IKljfR59JSRutXF1Q10MwCuhH5bnVLjo0h7IteNFn_U,18191
+opentf/commons/datasources.py,sha256=8qWC6KFiFGiIOEH7FGdbP_4hd_gVJFxbpR-051rhNZI,24452
 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.dev941.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-opentf_toolkit_nightly-0.55.0.dev941.dist-info/METADATA,sha256=Z6JJRflN4y9tRp6aCn8WWhNF3b6J6PIU1jbndC5ys_4,1945
-opentf_toolkit_nightly-0.55.0.dev941.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-opentf_toolkit_nightly-0.55.0.dev941.dist-info/top_level.txt,sha256=_gPuE6GTT6UNXy1DjtmQSfCcZb_qYA2vWmjg7a30AGk,7
-opentf_toolkit_nightly-0.55.0.dev941.dist-info/RECORD,,
+opentf_toolkit_nightly-0.55.0.dev962.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opentf_toolkit_nightly-0.55.0.dev962.dist-info/METADATA,sha256=0kY47GzqpwhnPRyFp-IcSB_fDNh0tIIcgwKgH9IRnck,1945
+opentf_toolkit_nightly-0.55.0.dev962.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+opentf_toolkit_nightly-0.55.0.dev962.dist-info/top_level.txt,sha256=_gPuE6GTT6UNXy1DjtmQSfCcZb_qYA2vWmjg7a30AGk,7
+opentf_toolkit_nightly-0.55.0.dev962.dist-info/RECORD,,