cloudbeat-common 0.0.1__py3-none-any.whl

cloudbeat.py

@@ -0,0 +1,8 @@
+from cloudbeat_common.models import TestStatus
+from cloudbeat_common.reporter import CbTestReporter
+
+
+__all__ = [
+    'TestStatus',
+    'CbTestReporter'
+]

cloudbeat_common/json_util.py

@@ -0,0 +1,82 @@
+import json
+
+from cloudbeat_common.models import TestResult, SuiteResult, CaseResult, StepResult
+
+
+def to_json(result: TestResult):
+    return json.dumps(result, cls=CbResultEncoder, indent=4)
+
+
+def _test_result_to_json(tr: TestResult):
+    if not isinstance(tr, TestResult):
+        return None
+    return {
+        "runId": tr.run_id,
+        "instanceId": tr.instance_id,
+        "startTime": tr.start_time,
+        "endTime": tr.end_time,
+        "duration": tr.duration,
+        "capabilities": tr.capabilities,
+        "options": tr.options,
+        "metaData": tr.meta_data,
+        "environmentVariables": tr.environment_variables,
+        "testAttributes": tr.test_attributes,
+        "suites": list(map(lambda s: _suite_result_to_json(s), tr.suites))
+    }
+
+
+def _suite_result_to_json(r: SuiteResult):
+    if not isinstance(r, SuiteResult):
+        return None
+    return {
+        "id": r.id,
+        "name": r.name,
+        "fqn": r.fqn,
+        "startTime": r.start_time,
+        "endTime": r.end_time,
+        "duration": r.duration,
+        "status": r.status,
+        "cases": list(map(lambda c: _case_result_to_json(c), r.cases))
+    }
+
+
+def _case_result_to_json(r: CaseResult):
+    if not isinstance(r, CaseResult):
+        return None
+    return {
+        "id": r.id,
+        "name": r.name,
+        "display_name": r.display_name,
+        "description": r.description,
+        "fqn": r.fqn,
+        "startTime": r.start_time,
+        "endTime": r.end_time,
+        "duration": r.duration,
+        "status": r.status,
+        "context": r.context,
+        "arguments": r.arguments,
+        "steps": list(map(lambda s: _step_result_to_json(s), r.steps)),
+        "hooks": list(map(lambda s: _step_result_to_json(s), r.hooks))
+    }
+
+
+def _step_result_to_json(r: StepResult):
+    if not isinstance(r, StepResult):
+        return None
+    return {
+        "id": r.id,
+        "name": r.name,
+        "fqn": r.fqn,
+        "startTime": r.start_time,
+        "endTime": r.end_time,
+        "duration": r.duration,
+        "status": r.status,
+        "steps": list(map(lambda s: _step_result_to_json(s), r.steps))
+    }
+
+
+class CbResultEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, TestResult):
+            return _test_result_to_json(obj)
+        return super().default(obj)

cloudbeat_common/models.py

@@ -0,0 +1,212 @@
+import time
+from typing import List
+
+from attr import attrs, attrib
+from attr import Factory
+from collections import OrderedDict, defaultdict
+import uuid
+
+
+class TestStatus:
+    FAILED = 'failed'
+    BROKEN = 'broken'
+    PASSED = 'passed'
+    SKIPPED = 'skipped'
+    UNKNOWN = 'unknown'
+
+
+class StepType:
+    GENERAL = 'general'
+    HOOK = 'hook'
+    TRANSACTION = 'transaction'
+    HTTP = 'http'
+    ASSERT = 'assert'
+
+
+@attrs
+class CbConfig:
+    is_ready = attrib(default=False)
+    run_id = attrib(default=None)
+    run_group = attrib(default=None)
+    instance_id = attrib(default=None)
+    project_id = attrib(default=None)
+    api_token = attrib(default=None)
+    api_endpoint_url = attrib(default=None)
+    selenium_url = attrib(default=None)
+    appium_url = attrib(default=None)
+    capabilities = attrib(default=defaultdict(OrderedDict))
+    options = attrib(default=defaultdict(OrderedDict))
+    metadata = attrib(default=defaultdict(OrderedDict))
+    env_vars = attrib(default=defaultdict(OrderedDict))
+
+
+@attrs
+class TestResult:
+    start_time = attrib(default=None)
+    end_time = attrib(default=None)
+    duration = attrib(default=None)
+
+    run_id = attrib(default=None)
+    instance_id = attrib(default=None)
+    capabilities = attrib(default=defaultdict(OrderedDict))
+    options = attrib(default=defaultdict(OrderedDict))
+    meta_data = attrib(default=defaultdict(OrderedDict))
+    environment_variables = attrib(default=defaultdict(OrderedDict))
+    test_attributes = attrib(default=defaultdict(OrderedDict))
+
+    hooks = attrib(default=Factory(list))
+    suites = attrib(default=Factory(list))
+    failures = attrib(default=Factory(list))
+    status: TestStatus = attrib(default=None)
+
+    def __iter__(self):
+        yield from {
+            "startTime": self.start_time,
+            "endTime": self.end_time,
+            "duration": self.duration,
+            "runId": self.run_id,
+            "instanceId": self.instance_id
+        }.items()
+
+    def __str__(self):
+        return json.dumps(dict(self), cls=MyJSONEncoder, ensure_ascii=False)
+
+    def start(self, run_id, instance_id, options, caps, metadata, env_vars):
+        self.run_id = run_id
+        self.instance_id = instance_id
+        self.start_time = int(time.time() * 1000)
+        self.options = options
+        self.capabilities = caps
+        self.meta_data = metadata
+        self.environment_variables = env_vars
+
+    def end(self):
+        self.end_time = int(time.time() * 1000)
+        self.duration = self.end_time - self.start_time
+
+
+@attrs
+class TestableResultBase:
+    id = attrib(default=str(uuid.uuid4()))
+    name = attrib(default=None)
+    display_name = attrib(default=None)
+    description = attrib(default=None)
+    fqn = attrib(default=None)
+    status = attrib(default=TestStatus.PASSED)
+    attachments = attrib(default=Factory(list))
+    arguments = attrib(default=Factory(list))
+    hooks = attrib(default=Factory(list))
+    start_time = attrib(default=None)
+    end_time = attrib(default=None)
+    duration = attrib(default=None)
+
+
+@attrs
+class SuiteResult(TestableResultBase):
+    cases = attrib(default=Factory(list))
+
+    def start(self, name, fqn=None):
+        self.name = name
+        self.fqn = fqn
+        self.start_time = int(time.time() * 1000)
+
+    def end(self, status=None):
+        self.end_time = int(time.time() * 1000)
+        self.duration = self.end_time - self.start_time
+        # Mark suite as FAILED if at least one of the test case has failed
+        has_failed_cases = any(c.status == TestStatus.FAILED for c in self.cases)
+        if has_failed_cases and status is None:
+            self.status = TestStatus.FAILED
+        elif status is not None:
+            self.status = status
+
+    def add_case(self, case_result):
+        self.cases.append(case_result)
+
+
+@attrs
+class StepResult(TestableResultBase):
+    type: StepType = attrib(default=None)
+    steps = attrib(default=Factory(list))
+    logs = attrib(default=Factory(list))
+
+    def start(self, name, fqn=None):
+        self.name = name
+        self.fqn = fqn
+        self.start_time = int(time.time() * 1000)
+
+    def end(self, status=TestStatus.PASSED):
+        self.end_time = int(time.time() * 1000)
+        self.duration = self.end_time - self.start_time
+        self.status = status if status is not None else TestStatus.PASSED
+
+
+@attrs
+class CaseResult(TestableResultBase):
+    context = defaultdict(OrderedDict)
+    steps = attrib(default=Factory(list))
+    _started_steps_stack: List[StepResult] = []
+
+    def start(self, name, fqn=None):
+        self.name = name
+        self.fqn = fqn
+        self.start_time = int(time.time() * 1000)
+
+    def end(self, status=None):
+        # End all unfinished steps
+        for _ in range(len(self._started_steps_stack)):
+            step_result = self._started_steps_stack.pop()
+            step_result.end()
+        # Do not override the calculated FAILED status by the status function argument
+        if status is not None and self.status != TestStatus.FAILED:
+            self.status = status
+        self.end_time = int(time.time() * 1000)
+        self.duration = self.end_time - self.start_time
+
+    def start_hook(self, name):
+        hook_result = StepResult()
+        hook_result.start(name)
+        hook_result.type = StepType.HOOK
+        self.hooks.append(hook_result)
+        self._started_steps_stack.append(hook_result)
+        return hook_result
+
+    def end_hook(self, status=TestStatus.PASSED):
+        if len(self.hooks) == 0:
+            return None
+        last_hook = self.hooks[len(self.hooks) - 1]
+        # End hook's child steps, if remain open
+        if len(self._started_steps_stack) > 0:
+            while last_step := self._started_steps_stack.pop():
+                if last_step == last_hook:
+                    break
+                last_step.end()
+        last_hook.end(status)
+        return last_hook
+
+    def start_step(self, name, fqn=None):
+        # Check if there is a started step
+        parent_step = self._started_steps_stack[len(self._started_steps_stack) - 1] \
+            if len(self._started_steps_stack) > 0 else None
+        step_result = StepResult()
+        step_result.start(name, fqn)
+        if parent_step is None:
+            self.steps.append(step_result)
+        else:
+            parent_step.steps.append(step_result)
+        self._started_steps_stack.append(step_result)
+        return step_result
+
+    def end_step(self, status=TestStatus.PASSED):
+        if len(self._started_steps_stack) == 0 or len(self.steps) == 0:
+            return None
+        last_step = self._started_steps_stack.pop() \
+            if len(self._started_steps_stack) > 0 else self.steps[len(self.steps) - 1]
+        last_step.end(status)
+        if status == TestStatus.FAILED:
+            self.status = TestStatus.FAILED
+        return last_step
+
+    def add_parameters(self, parameters):
+        # TODO: merge with the existing parameters
+        self.context["params"] = parameters

cloudbeat_common/reporter.py

@@ -0,0 +1,151 @@
+import threading
+from collections import OrderedDict, defaultdict
+import platform
+
+from cloudbeat_common.models import TestResult, CbConfig, SuiteResult, CaseResult, StepResult
+from cloudbeat_common.json_util import to_json
+
+
+class ThreadContext:
+    _thread_context = defaultdict(OrderedDict)
+    _init_thread: threading.Thread
+
+    @property
+    def thread_context(self):
+        context = self._thread_context[threading.current_thread()]
+        if not context and threading.current_thread() is not self._init_thread:
+            uuid, last_item = next(reversed(self._thread_context[self._init_thread].items()))
+            context[uuid] = last_item
+        return context
+
+    def __init__(self, *args, **kwargs):
+        self._init_thread = threading.current_thread()
+        super().__init__(*args, **kwargs)
+
+    def __setitem__(self, key, value):
+        self.thread_context.__setitem__(key, value)
+
+    def __getitem__(self, item):
+        return self.thread_context.__getitem__(item)
+
+    def __iter__(self):
+        return self.thread_context.__iter__()
+
+    def __reversed__(self):
+        return self.thread_context.__reversed__()
+
+    def get(self, key):
+        return self.thread_context.get(key)
+
+    def pop(self, key):
+        return self.thread_context.pop(key)
+
+    def cleanup(self):
+        stopped_threads = []
+        for thread in self._thread_context.keys():
+            if not thread.is_alive():
+                stopped_threads.append(thread)
+        for thread in stopped_threads:
+            del self._thread_context[thread]
+
+
+class CbTestReporter:
+    _result: TestResult = None
+    _config: CbConfig = None
+
+    def __init__(self, config: CbConfig):
+        self._context = ThreadContext()
+        self._config = config
+
+    def start_instance(self):
+        self._result = TestResult()
+        self._result.start(
+            self._config.run_id,
+            self._config.instance_id,
+            self._config.options,
+            self._config.capabilities,
+            self._config.metadata,
+            self._config.env_vars)
+        self._add_system_attributes()
+
+    def end_instance(self) -> None:
+        if self._result is None:
+            return
+        self._result.end()
+        # Serializing json
+        json_str = to_json(self._result)
+
+        # Writing to sample.json
+        with open(".CB_TEST_RESULTS.json", "w") as outfile:
+            outfile.write(json_str)
+
+    def start_suite(self, name, fqn=None):
+        if self._result is None:
+            return None
+        suite_result = SuiteResult()
+        suite_result.start(name, fqn)
+        self._result.suites.append(suite_result)
+        self._context["suite"] = suite_result
+        self._context["case"] = None
+        return suite_result
+
+    def end_suite(self):
+        if self._context["suite"] is None:
+            return None
+        suite_result: SuiteResult = self._context["suite"]
+        suite_result.end()
+        return suite_result
+
+    def start_case(self, name, fqn=None):
+        if self._context["suite"] is None:
+            return None
+        case_result = CaseResult()
+        case_result.start(name, fqn)
+        suite_result: SuiteResult = self._context["suite"]
+        suite_result.add_case(case_result)
+        self._context["case"] = case_result
+        return case_result
+
+    def end_case(self, status=None):
+        case_result: CaseResult = self._context["case"] if "case" in self._context else None
+        if case_result is None:
+            return None
+        # TODO: end started steps of the case
+        case_result.end(status)
+        return case_result
+
+    def start_case_hook(self, name):
+        case_result: CaseResult = self._context["case"] if "case" in self._context else None
+        if case_result is None:
+            return None
+        return case_result.start_hook(name)
+
+    def end_case_hook(self, status=None):
+        case_result: CaseResult = self._context["case"] if "case" in self._context else None
+        if case_result is None:
+            return None
+        return case_result.end_hook(status)
+
+    def start_step(self, name, fqn=None):
+        if self._context["case"] is None:
+            return None
+        case_result: CaseResult = self._context["case"]
+        step_result = case_result.start_step(name, fqn)
+        return step_result
+
+    def end_step(self):
+        if self._context["case"] is None:
+            return None
+        case_result: CaseResult = self._context["case"]
+        return case_result.end_step()
+
+    def _add_system_attributes(self):
+        self._result.test_attributes["agent.hostname"] = platform.node()
+        self._result.test_attributes["agent.os.name"] = platform.system()
+        # Determine OS version
+        os_version = platform.version() if platform.system() != "Darwin" else platform.mac_ver()[0]
+        self._result.test_attributes["agent.os.version"] = os_version
+
+    @property
+    def result(self):
+        return self._result

cloudbeat_common-0.0.1.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: cloudbeat-common
+Version: 0.0.1
+Summary: Contains the common types and API client for CloudBeat
+Home-page: https://cloudbeat.io/
+Author: CBNR Cloud Solutions LTD
+Author-email: info@cloudbeat.io
+License: Apache-2.0
+Project-URL: Source, https://github.com/cloudbeat-io/cb-kit-python
+Keywords: cloudbeat testing reporting python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: attrs>=16.0.0
+Requires-Dist: pluggy>=0.4.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

cloudbeat_common-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+cloudbeat.py,sha256=xoOOX7taBh6JFaZD0GkhhLZ6D_YDZBkxW-9AltftrEY,154
+cloudbeat_common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cloudbeat_common/json_util.py,sha256=HK7PKx29do4-9Ag9v5p92-N_1PCk4CWbfEvFq-jMh2M,2324
+cloudbeat_common/models.py,sha256=ZO-UItGQplnUVGI0dcStrSUqBosrueB3wTkpcSxKyEM,6975
+cloudbeat_common/reporter.py,sha256=on3r0LNce-LqciUnXzW_SXqbunE9bWAg3eK5SMC69vc,4955
+cloudbeat_common-0.0.1.dist-info/METADATA,sha256=02-nRkXKZpXN0-IHc8gxqddp2v0Z1CVeGa8Gs6D_dqQ,1431
+cloudbeat_common-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cloudbeat_common-0.0.1.dist-info/top_level.txt,sha256=hBP28A3_p63b7ge819viyVcCd0QajP-CEJJVrWp-QrA,27
+cloudbeat_common-0.0.1.dist-info/RECORD,,

cloudbeat_common-0.0.1.dist-info/WHEEL

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

cloudbeat_common-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+cloudbeat
+cloudbeat_common