cloudbeat-common 0.0.1__tar.gz

cloudbeat_common-0.0.1/PKG-INFO

@@ -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/cloudbeat.py

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

cloudbeat_common-0.0.1/cloudbeat_common.egg-info/PKG-INFO

@@ -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/cloudbeat_common.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+cloudbeat.py
+setup.py
+cloudbeat_common.egg-info/PKG-INFO
+cloudbeat_common.egg-info/SOURCES.txt
+cloudbeat_common.egg-info/dependency_links.txt
+cloudbeat_common.egg-info/requires.txt
+cloudbeat_common.egg-info/top_level.txt
+src/__init__.py
+src/json_util.py
+src/models.py
+src/reporter.py
+tests/test_reporter.py

cloudbeat_common-0.0.1/cloudbeat_common.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cloudbeat_common-0.0.1/cloudbeat_common.egg-info/requires.txt

@@ -0,0 +1,2 @@
+attrs>=16.0.0
+pluggy>=0.4.0

cloudbeat_common-0.0.1/cloudbeat_common.egg-info/top_level.txt

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

cloudbeat_common-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cloudbeat_common-0.0.1/setup.py

@@ -0,0 +1,59 @@
+import os
+from setuptools import setup
+
+PACKAGE = "cloudbeat-common"
+
+classifiers = [
+    'Development Status :: 5 - Production/Stable',
+    'Intended Audience :: Developers',
+    'License :: OSI Approved :: Apache Software License',
+    'Topic :: Software Development :: Quality Assurance',
+    'Topic :: Software Development :: Testing',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3 :: Only',
+    'Programming Language :: Python :: 3.7',
+    'Programming Language :: Python :: 3.8',
+    'Programming Language :: Python :: 3.9',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12',
+]
+
+install_requires = [
+    "attrs>=16.0.0",
+    "pluggy>=0.4.0",
+]
+
+
+def get_readme(fname):
+    return open(os.path.join(os.path.dirname(__file__), fname)).read()
+
+
+def main():
+    setup(
+        name=PACKAGE,
+        version="0.0.1",
+        use_scm_version={"root": "..", "relative_to": __file__},
+        setup_requires=['setuptools_scm'],
+        description="Contains the common types and API client for CloudBeat",
+        url="https://cloudbeat.io/",
+        project_urls={
+            "Source": "https://github.com/cloudbeat-io/cb-kit-python",
+        },
+        author="CBNR Cloud Solutions LTD",
+        author_email="info@cloudbeat.io",
+        license="Apache-2.0",
+        classifiers=classifiers,
+        keywords="cloudbeat testing reporting python",
+        #        long_description=get_readme("README.md"),
+        long_description_content_type="text/markdown",
+        packages=["cloudbeat_common"],
+        package_dir={"cloudbeat_common": 'src'},
+        install_requires=install_requires,
+        py_modules=['cloudbeat', 'cloudbeat_common'],
+        python_requires='>=3.6'
+    )
+
+
+if __name__ == '__main__':
+    main()

cloudbeat_common-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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/tests/test_reporter.py

@@ -0,0 +1,64 @@
+from src.reporter import CbTestReporter
+from src.models import SuiteResult, CaseResult, StepResult
+
+
+def test_init(cb_reporter: CbTestReporter):
+    assert cb_reporter._config is not None
+    assert cb_reporter.result is None
+
+
+def test_start_instance(cb_reporter: CbTestReporter):
+    cb_reporter.start_instance()
+    assert cb_reporter.result is not None
+
+
+def test_start_suite(cb_reporter: CbTestReporter):
+    # cb_reporter.start_instance()
+    # assert cb_reporter.result is not None
+    cb_reporter.start_suite("my suite", "cb.python.suite")
+    assert len(cb_reporter.result.suites) > 0
+    assert cb_reporter.result.suites[0].name == "my suite"
+
+
+def test_start_case(cb_reporter: CbTestReporter):
+    case_name = "my case"
+    case_fqn = "cb.python.suite.case"
+    case_result: CaseResult = cb_reporter.start_case(case_name, case_fqn)
+    assert len(cb_reporter.result.suites[0].cases) > 0
+    assert case_result is not None
+    assert cb_reporter.result.suites[0].cases[0] == case_result
+    assert case_result.name == case_name
+    assert case_result.fqn == case_fqn
+
+
+def test_start_step(cb_reporter: CbTestReporter):
+    step_name = "my step"
+    step_result: StepResult = cb_reporter.start_step(step_name)
+    assert len(cb_reporter.result.suites[0].cases[0].steps) > 0
+    assert step_result is not None
+    assert cb_reporter.result.suites[0].cases[0].steps[0] == step_result
+    assert step_result.name == step_name
+
+
+def test_start_sub_step(cb_reporter: CbTestReporter):
+    step_name = "my sub step"
+    step_result: StepResult = cb_reporter.start_step(step_name)
+    assert step_result is not None
+    assert len(cb_reporter.result.suites[0].cases[0].steps[0].steps) > 0, \
+        "Sub step must be created"
+
+
+def test_end_sub_step(cb_reporter: CbTestReporter):
+    step_result: StepResult = cb_reporter.end_step()
+
+
+def test_end_case(cb_reporter: CbTestReporter):
+    case_result: CaseResult = cb_reporter.end_case()
+
+
+def test_end_suite(cb_reporter: CbTestReporter):
+    suite_result: SuiteResult = cb_reporter.end_suite()
+
+
+def test_end_instance(cb_reporter: CbTestReporter):
+    cb_reporter.end_instance()