qase-python-commons 3.0.3__tar.gz → 3.1.0b2__tar.gz

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qase-python-commons
-Version: 3.0.3
+Version: 3.1.0b2
 Summary: A library for Qase TestOps and Qase Report
 Author-email: Qase Team <support@qase.io>
 Project-URL: Homepage, https://github.com/qase-tms/qase-python/tree/master/qase-python-commons
@@ -22,7 +22,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: attrs>=23.2.0
-Requires-Dist: qase-api-client~=1.0.0
+Requires-Dist: qase-api-client~=1.0.1
 Requires-Dist: qase-api-v2-client~=1.0.0
 Requires-Dist: more_itertools
 Provides-Extra: testing

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qase-python-commons"
-version = "3.0.3"
+version = "3.1.0b2"
 description = "A library for Qase TestOps and Qase Report"
 readme = "README.md"
 authors = [{name = "Qase Team", email = "support@qase.io"}]
@@ -30,7 +30,7 @@ requires-python = ">=3.7"
 dependencies = [
     "certifi>=2024.2.2",
     "attrs>=23.2.0",
-    "qase-api-client~=1.0.0",
+    "qase-api-client~=1.0.1",
     "qase-api-v2-client~=1.0.0",
     "more_itertools"
 ]

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/src/qase/commons/client/api_v1_client.py

@@ -4,30 +4,31 @@ import certifi
 from qase.api_client_v1 import ApiClient, ProjectsApi, Project, EnvironmentsApi, RunsApi, AttachmentsApi, \
     AttachmentGet, RunCreate, ResultsApi, ResultcreateBulk
 from qase.api_client_v1.configuration import Configuration
-from .. import ConfigManager, Logger
+from .. import Logger
 from .base_api_client import BaseApiClient
 from ..exceptions.reporter import ReporterException
 from ..models import Attachment, Result, Step
+from ..models.config.qaseconfig import QaseConfig
 from ..models.step import StepType
 
 
 class ApiV1Client(BaseApiClient):
-    def __init__(self, config: ConfigManager, logger: Logger):
+    def __init__(self, config: QaseConfig, logger: Logger):
         self.logger = logger
         self.config = config
 
         try:
             self.logger.log_debug("Preparing API client")
             configuration = Configuration()
-            configuration.api_key['TokenAuth'] = self.config.get('testops.api.token')
+            configuration.api_key['TokenAuth'] = self.config.testops.api.token
             configuration.ssl_ca_cert = certifi.where()
-            host = self.config.get('testops.api.host', 'qase.io')
-            if self.config.get('testops.api.enterprise', False, bool):
-                configuration.host = f'https://api-{host}/v1'
-                self.web = f'https://{host}'
-            else:
+            host = self.config.testops.api.host
+            if host == 'qase.io':
                 configuration.host = f'https://api.{host}/v1'
                 self.web = f'https://app.{host}'
+            else:
+                configuration.host = f'https://api-{host}/v1'
+                self.web = f'https://{host}'
 
             self.client = ApiClient(configuration)
             self.logger.log_debug("API client prepared")
@@ -165,8 +166,16 @@ class ApiV1Client(BaseApiClient):
         if result.get_field('layer'):
             case_data["layer"] = result.get_field('layer')
 
+        suite = None
         if result.get_suite_title():
-            case_data["suite_title"] = "\t".join(result.get_suite_title().split("."))
+            suite = "\t".join(result.get_suite_title().split("."))
+
+        root_suite = self.config.root_suite
+        if root_suite:
+            suite = f"{root_suite}\t{suite}"
+
+        if suite:
+            case_data["suite"] = suite
 
         result_model = {
             "status": result.execution.status,
@@ -176,7 +185,7 @@ class ApiV1Client(BaseApiClient):
             "attachments": [attach.hash for attach in attached],
             "steps": steps,
             "param": result.params,
-            "defect": self.config.get('testops.defect', False, bool),
+            "defect": self.config.testops.defect,
         }
 
         test_ops_id = result.get_testops_id()

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/src/qase/commons/client/api_v2_client.py

@@ -14,26 +14,29 @@ from qase.api_client_v2.models.result_step_status import ResultStepStatus
 from qase.api_client_v2.models.result_steps_type import ResultStepsType
 
 from .api_v1_client import ApiV1Client
-from .. import ConfigManager, Logger
+from .. import Logger
 from ..exceptions.reporter import ReporterException
 from ..models import Attachment, Result
+from ..models.config.qaseconfig import QaseConfig
 from ..models.step import StepType, Step
 
 
 class ApiV2Client(ApiV1Client):
-    def __init__(self, config: ConfigManager, logger: Logger):
+    def __init__(self, config: QaseConfig, logger: Logger):
         ApiV1Client.__init__(self, config, logger)
 
         try:
             self.logger.log_debug("Preparing API V2 client")
             configuration = Configuration()
-            configuration.api_key['TokenAuth'] = self.config.get('testops.api.token')
+            configuration.api_key['TokenAuth'] = self.config.testops.api.token
             configuration.ssl_ca_cert = certifi.where()
-            host = self.config.get('testops.api.host', 'qase.io')
-            if self.config.get('testops.api.enterprise', False, bool):
-                configuration.host = f'https://api-{host}/v2'
-            else:
+            host = self.config.testops.api.host
+            if host == 'qase.io':
                 configuration.host = f'https://api.{host}/v2'
+                self.web = f'https://app.{host}'
+            else:
+                configuration.host = f'https://api-{host}/v2'
+                self.web = f'https://{host}'
 
             self.client_v2 = ApiClient(configuration)
             self.logger.log_debug("API V2 client prepared")
@@ -83,6 +86,9 @@ class ApiV2Client(ApiV1Client):
 
         if result.get_suite_title():
             data = []
+            root_suite = self.config.root_suite
+            if root_suite:
+                data.append(RelationSuiteItem(title=root_suite))
 
             for suite in result.get_suite_title().split("."):
                 data.append(RelationSuiteItem(title=suite))

qase_python_commons-3.1.0b2/src/qase/commons/config.py

@@ -0,0 +1,219 @@
+import os
+import json
+from .logger import Logger
+from .models.config.qaseconfig import QaseConfig, Mode
+
+
+class ConfigManager:
+
+    def __init__(self, config_file='./qase.config.json'):
+        self.logger = Logger()
+        self.__config_file = config_file
+        self.config = QaseConfig()
+        self.parse_bool = lambda d: d in ("y", "yes", "true", "1", 1, True)
+
+        self.__load_file_config()
+        self.__load_env_config()
+
+    def validate_config(self):
+        errors: list[str] = []
+        if self.config.mode is Mode.testops or self.config.fallback is Mode.testops:
+            if self.config.testops.api.token is None:
+                errors.append("Testops token is not set")
+
+            if self.config.testops.project is None:
+                errors.append("Testops project is not set")
+
+        if len(errors) > 0:
+            self.logger.log("Config validation failed", "error")
+            for error in errors:
+                self.logger.log(error, "error")
+            raise Exception("Config validation failed")
+
+    def __str__(self):
+        return json.dumps(self.config, indent=4, sort_keys=True)
+
+    def __load_file_config(self):
+        try:
+            if os.path.exists(self.__config_file):
+                with open(self.__config_file, "r") as file:
+                    config = json.load(file)
+
+                    if config.get("mode"):
+                        self.config.set_mode(config.get("mode"))
+
+                    if config.get("fallback"):
+                        self.config.set_fallback(config.get("fallback"))
+
+                    if config.get("environment"):
+                        self.config.set_environment(config.get("environment"))
+
+                    if config.get("rootSuite"):
+                        self.config.set_root_suite(config.get("rootSuite"))
+
+                    if config.get("profilers"):
+                        self.config.set_profilers(config.get("profilers"))
+
+                    if config.get("debug"):
+                        self.config.set_debug(
+                            self.parse_bool(config.get("debug"))
+                        )
+
+                    if config.get("executionPlan"):
+                        execution_plan = config.get("executionPlan")
+                        if execution_plan.get("path"):
+                            self.config.execution_plan.set_path(execution_plan.get("path"))
+
+                    if config.get("testops"):
+                        testops = config.get("testops")
+
+                        if testops.get("api"):
+                            api = testops.get("api")
+
+                            if api.get("host"):
+                                self.config.testops.api.set_host(api.get("host"))
+
+                            if api.get("token"):
+                                self.config.testops.api.set_token(api.get("token"))
+
+                        if testops.get("project"):
+                            self.config.testops.set_project(testops.get("project"))
+
+                        if testops.get("defect"):
+                            self.config.testops.set_defect(
+                                self.parse_bool(testops.get("defect"))
+                            )
+
+                        if testops.get("useV2"):
+                            self.config.testops.set_use_v2(
+                                self.parse_bool(testops.get("useV2"))
+                            )
+
+                        if testops.get("plan"):
+                            plan = testops.get("plan")
+
+                            if plan.get("id"):
+                                self.config.testops.plan.set_id(plan.get("id"))
+
+                        if testops.get("run"):
+                            run = testops.get("run")
+
+                            if run.get("id"):
+                                self.config.testops.run.set_id(run.get("id"))
+
+                            if run.get("title"):
+                                self.config.testops.run.set_title(run.get("title"))
+
+                            if run.get("description"):
+                                self.config.testops.run.set_description(run.get("description"))
+
+                            if run.get("complete"):
+                                self.config.testops.run.set_complete(
+                                    self.parse_bool(run.get("complete"))
+                                )
+
+                        if testops.get("batch"):
+                            batch = testops.get("batch")
+
+                            if batch.get("size"):
+                                self.config.testops.batch.set_size(batch.get("size"))
+
+                    if config.get("report"):
+                        report = config.get("report")
+
+                        if report.get("driver"):
+                            self.config.report.set_driver(report.get("driver"))
+
+                        if report.get("connection"):
+                            connection = report.get("connection")
+
+                            if connection.get("path"):
+                                self.config.report.connection.set_path(connection.get("path"))
+
+                            if connection.get("format"):
+                                self.config.report.connection.set_format(
+                                    connection.get("format")
+                                )
+
+                    if config.get("framework"):
+                        framework = config.get("framework")
+
+                        if framework.get("pytest"):
+                            pytest = framework.get("pytest")
+
+                            if pytest.get("captureLogs"):
+                                self.config.framework.pytest.set_capture_logs(
+                                    self.parse_bool(pytest.get("captureLogs"))
+                                )
+
+        except Exception as e:
+            self.logger.log("Failed to load config from file", "error")
+
+    def __load_env_config(self):
+        try:
+            for key, value in os.environ.items():
+                if key == 'QASE_MODE':
+                    self.config.set_mode(value)
+
+                if key == 'QASE_FALLBACK':
+                    self.config.set_fallback(value)
+
+                if key == 'QASE_ENVIRONMENT':
+                    self.config.set_environment(value)
+
+                if key == 'QASE_ROOT_SUITE':
+                    self.config.set_root_suite(value)
+
+                if key == 'QASE_PROFILERS':
+                    self.config.set_profilers(value.split(','))
+
+                if key == 'QASE_DEBUG':
+                    self.config.set_debug(self.parse_bool(value))
+
+                if key == 'QASE_EXECUTION_PLAN_PATH':
+                    self.config.execution_plan.set_path(value)
+
+                if key == 'QASE_TESTOPS_API_HOST':
+                    self.config.testops.api.set_host(value)
+
+                if key == 'QASE_TESTOPS_API_TOKEN':
+                    self.config.testops.api.set_token(value)
+
+                if key == 'QASE_TESTOPS_PROJECT':
+                    self.config.testops.set_project(value)
+
+                if key == 'QASE_TESTOPS_DEFECT':
+                    self.config.testops.set_defect(self.parse_bool(value))
+
+                if key == 'QASE_TESTOPS_PLAN_ID':
+                    self.config.testops.plan.set_id(value)
+
+                if key == 'QASE_TESTOPS_RUN_ID':
+                    self.config.testops.run.set_id(value)
+
+                if key == 'QASE_TESTOPS_RUN_TITLE':
+                    self.config.testops.run.set_title(value)
+
+                if key == 'QASE_TESTOPS_RUN_DESCRIPTION':
+                    self.config.testops.run.set_description(value)
+
+                if key == 'QASE_TESTOPS_RUN_COMPLETE':
+                    self.config.testops.run.set_complete(self.parse_bool(value))
+
+                if key == 'QASE_TESTOPS_BATCH_SIZE':
+                    self.config.testops.batch.set_size(value)
+
+                if key == 'QASE_REPORT_DRIVER':
+                    self.config.report.set_driver(value)
+
+                if key == 'QASE_REPORT_CONNECTION_PATH':
+                    self.config.report.connection.set_path(value)
+
+                if key == 'QASE_REPORT_CONNECTION_FORMAT':
+                    self.config.report.connection.set_format(value)
+
+                if key == 'QASE_PYTEST_CAPTURE_LOGS':
+                    self.config.framework.pytest.set_capture_logs(self.parse_bool(value))
+
+        except Exception as e:
+            self.logger.log("Failed to load config from env vars {e}", "error")

qase_python_commons-3.1.0b2/src/qase/commons/models/config/api.py

@@ -0,0 +1,15 @@
+from ..basemodel import BaseModel
+
+
+class ApiConfig(BaseModel):
+    token: str = None
+    host: str = None
+
+    def __init__(self):
+        self.host = "qase.io"
+
+    def set_token(self, token: str):
+        self.token = token
+
+    def set_host(self, host: str):
+        self.host = host

qase_python_commons-3.1.0b2/src/qase/commons/models/config/batch.py

@@ -0,0 +1,13 @@
+from ..basemodel import BaseModel
+
+
+class BatchConfig(BaseModel):
+    size: int = None
+
+    def __init__(self):
+        self.size = 200
+
+    def set_size(self, size: int):
+        if size > 2000 or size == 0:
+            raise ValueError("Batch size should be greater than 0 and less than 2000")
+        self.size = size

qase_python_commons-3.1.0b2/src/qase/commons/models/config/connection.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+from ..basemodel import BaseModel
+
+
+class Format(Enum):
+    json = "json"
+    jsonp = "jsonp"
+
+
+class ConnectionConfig(BaseModel):
+    path: str = None
+    format: Format = None
+
+    def __init__(self):
+        self.format = Format.json
+        self.path = "./build/qase-report"
+
+    def set_path(self, path: str):
+        self.path = path
+
+    def set_format(self, format: str):
+        if any(format == e.value for e in Format.__members__.values()):
+            self.format = Format[format]

qase_python_commons-3.1.0b2/src/qase/commons/models/config/framework.py

@@ -0,0 +1,18 @@
+from ..basemodel import BaseModel
+
+
+class PytestConfig(BaseModel):
+    capture_logs: bool = None
+
+    def __init__(self):
+        self.capture_logs = False
+
+    def set_capture_logs(self, capture_logs: bool):
+        self.capture_logs = capture_logs
+
+
+class Framework(BaseModel):
+    pytest: PytestConfig = None
+
+    def __init__(self):
+        self.pytest = PytestConfig()

qase_python_commons-3.1.0b2/src/qase/commons/models/config/plan.py

@@ -0,0 +1,8 @@
+from ..basemodel import BaseModel
+
+
+class PlanConfig(BaseModel):
+    id: int = None
+
+    def set_id(self, id: int):
+        self.id = id

qase_python_commons-3.1.0b2/src/qase/commons/models/config/qaseconfig.py

@@ -0,0 +1,65 @@
+from enum import Enum
+
+from .framework import Framework
+from .report import ReportConfig
+from .testops import TestopsConfig
+from ..basemodel import BaseModel
+
+
+class Mode(Enum):
+    testops = "testops"
+    report = "report"
+    off = "off"
+
+
+class ExecutionPlan(BaseModel):
+    path: str = None
+
+    def __init__(self):
+        self.path = "./build/qase-execution-plan.json"
+
+    def set_path(self, path: str):
+        self.path = path
+
+
+class QaseConfig(BaseModel):
+    mode: Mode = None
+    fallback: Mode = None
+    environment: str = None
+    root_suite: str = None
+    debug: bool = None
+    execution_plan: ExecutionPlan = None
+    testops: TestopsConfig = None
+    report: ReportConfig = None
+    profilers: list = None
+    framework: Framework = None
+
+    def __init__(self):
+        self.mode = Mode.off
+        self.fallback = Mode.off
+        self.debug = False
+        self.testops = TestopsConfig()
+        self.report = ReportConfig()
+        self.execution_plan = ExecutionPlan()
+        self.framework = Framework()
+        self.profilers = []
+
+    def set_mode(self, mode: str):
+        if any(mode == e.value for e in Mode.__members__.values()):
+            self.mode = Mode[mode]
+
+    def set_fallback(self, fallback: str):
+        if any(fallback == e.value for e in Mode.__members__.values()):
+            self.fallback = Mode[fallback]
+
+    def set_environment(self, environment: str):
+        self.environment = environment
+
+    def set_profilers(self, profilers: list):
+        self.profilers = profilers
+
+    def set_root_suite(self, root_suite: str):
+        self.root_suite = root_suite
+
+    def set_debug(self, debug: bool):
+        self.debug = debug

qase_python_commons-3.1.0b2/src/qase/commons/models/config/report.py

@@ -0,0 +1,21 @@
+from enum import Enum
+
+from .connection import ConnectionConfig
+from ..basemodel import BaseModel
+
+
+class Driver(Enum):
+    local = "local"
+
+
+class ReportConfig(BaseModel):
+    driver: Driver = None
+    connection: ConnectionConfig = None
+
+    def __init__(self):
+        self.driver = Driver.local
+        self.connection = ConnectionConfig()
+
+    def set_driver(self, driver: str):
+        if any(driver == e.value for e in Driver.__members__.values()):
+            self.driver = Driver[driver]

qase_python_commons-3.1.0b2/src/qase/commons/models/config/run.py

@@ -0,0 +1,23 @@
+from ..basemodel import BaseModel
+
+
+class RunConfig(BaseModel):
+    title: str = None
+    description: str = None
+    complete: bool = None
+    id: int = None
+
+    def __init__(self):
+        self.complete = True
+
+    def set_title(self, title: str):
+        self.title = title
+
+    def set_description(self, description: str):
+        self.description = description
+
+    def set_complete(self, complete: bool):
+        self.complete = complete
+
+    def set_id(self, id: int):
+        self.id = id

qase_python_commons-3.1.0b2/src/qase/commons/models/config/testops.py

@@ -0,0 +1,31 @@
+from .api import ApiConfig
+from .batch import BatchConfig
+from .plan import PlanConfig
+from .run import RunConfig
+from ..basemodel import BaseModel
+
+
+class TestopsConfig(BaseModel):
+    project: str = None
+    defect: bool = None
+    api: ApiConfig = None
+    run: RunConfig = None
+    plan: PlanConfig = None
+    batch: BatchConfig = None
+
+    def __init__(self):
+        self.api = ApiConfig()
+        self.run = RunConfig()
+        self.batch = BatchConfig()
+        self.plan = PlanConfig()
+        self.defect = False
+        self.use_v2 = False
+
+    def set_project(self, project: str):
+        self.project = project
+
+    def set_defect(self, defect: bool):
+        self.defect = defect
+
+    def set_use_v2(self, use_v2: bool):
+        self.use_v2 = use_v2

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/src/qase/commons/reporters/core.py

@@ -2,13 +2,14 @@ import os
 import json
 import time
 
-from ..config import ConfigManager as Config
+from ..config import ConfigManager
 from ..logger import Logger
 
 from .report import QaseReport
 from .testops import QaseTestOps
 
 from ..models import Result, Attachment, Runtime
+from ..models.config.qaseconfig import Mode
 from typing import Union
 
 """
@@ -18,31 +19,32 @@ from typing import Union
 
 
 class QaseCoreReporter:
-    def __init__(self, config: Config):
-        self.config = config
-        self.logger = Logger(self.config.get('debug', False, bool))
+    def __init__(self, config: ConfigManager):
+        config.validate_config()
+        self.config = config.config
+        self.logger = Logger(self.config.debug)
         self.execution_plan = None
         self.profilers = []
         self.overhead = 0
 
-        self._selective_execution_setup()
+        # self._selective_execution_setup()
         self.fallback = self._fallback_setup()
 
         self.logger.log_debug(f"Config: {self.config}")
 
         # Reading reporter mode from config file
-        mode = config.get("mode", "off")
+        mode = self.config.mode
 
-        if mode == 'testops':
+        if mode == Mode.testops:
             try:
                 self._load_testops_plan()
-                self.reporter = QaseTestOps(config=config, logger=self.logger)
+                self.reporter = QaseTestOps(config=self.config, logger=self.logger)
             except Exception as e:
                 self.logger.log('Failed to initialize TestOps reporter. Using fallback.', 'info')
                 self.logger.log(e, 'error')
                 self.reporter = self.fallback
-        elif mode == 'report':
-            self.reporter = QaseReport(config=config, logger=self.logger)
+        elif mode == Mode.report:
+            self.reporter = QaseReport(config=self.config, logger=self.logger)
         else:
             self.reporter = None
 
@@ -103,14 +105,14 @@ class QaseCoreReporter:
                 self._run_fallback()
 
     def setup_profilers(self, runtime: Runtime) -> None:
-        profilers = self.config.get("profilers", [])
+        profilers = self.config.profilers
 
         for profiler in profilers:
             if profiler == "network":
                 # Lazy import
                 from ..profilers import NetworkProfilerSingleton
                 NetworkProfilerSingleton.init(runtime=runtime,
-                                              skip_domain=self.config.get("testops.api.host", "qase.io"))
+                                              skip_domain=self.config.testops.api.host)
                 self.profilers.append(NetworkProfilerSingleton.get_instance())
             if profiler == "sleep":
                 from ..profilers import SleepProfiler
@@ -166,33 +168,33 @@ class QaseCoreReporter:
 
     def _load_testops_plan(self) -> None:
         try:
-            if self.config.get("testops.plan.id", None) is not None:
+            if self.config.testops.plan.id is not None:
                 from .. import TestOpsPlanLoader
 
                 # Load test plan data from Qase TestOps
                 loader = TestOpsPlanLoader(
-                    api_token=self.config.get("testops.api.token"),
-                    host=self.config.get("testops.api.host", "qase.io"),
+                    api_token=self.config.testops.api.token,
+                    host=self.config.testops.api.host
                 )
-                self.execution_plan = loader.load(self.config.get("testops.project"),
-                                                  int(self.config.get("testops.plan.id")))
+                self.execution_plan = loader.load(self.config.testops.project,
+                                                  int(self.config.testops.plan.id))
         except Exception as e:
             self.logger.log('Failed to load test plan from Qase TestOps', 'info')
             self.logger.log(e, 'error')
 
     # TODO: won't work, need to fix
-    def _selective_execution_setup(self) -> list:
-        # Load execution plan from file
-        path = self.config.get("execution_plan.path", "qase_execution_plan.json")
-        if not self.config.get("execution_plan.path", None) and path and os.path.isfile(path):
-            with open('execution_plan.json') as f:
-                return json.load(f)
-
-        # Load execution plan from command line or env variable
-        if self.config.get("execution_plan", None):
-            return [int(n) for n in str(self.config.get("execution_plan").split(","))]
+    # def _selective_execution_setup(self) -> list:
+    #     # Load execution plan from file
+    #     path = self.config.execution_plan.path
+    #     if not self.config.execution_plan.path and path and os.path.isfile(self.config.execution_plan.path):
+    #         with open(self.config.execution_plan.path) as f:
+    #             return json.load(f)
+    #
+    #     # Load execution plan from command line or env variable
+    #     if self.config.self.config.execution_plan.path:
+    #         return [int(n) for n in str(self.config.self.config.execution_plan.path.split(","))]
 
     def _fallback_setup(self) -> Union[QaseReport, None]:
-        if self.config.get("fallback", 'report'):
+        if self.config.fallback == Mode.report:
             return QaseReport(config=self.config, logger=self.logger)
         return None

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/src/qase/commons/reporters/report.py

@@ -4,13 +4,15 @@ import shutil
 import json
 import re
 from ..models import Result, Run, Attachment
-from .. import QaseUtils, ConfigManager, Logger
+from .. import QaseUtils, Logger
+from ..models.config.connection import Format
+from ..models.config.qaseconfig import QaseConfig
 
 
 class QaseReport:
     def __init__(
             self,
-            config: ConfigManager,
+            config: QaseConfig,
             logger: Logger
     ):
         self.duration = 0
@@ -19,13 +21,13 @@ class QaseReport:
         self.config = config
         self.logger = logger
 
-        self.report_path = self.config.get("report.path", "./build/qase-report")
-        self.format = self.config.get("report.format", "json")
+        self.report_path = self.config.report.connection.path
+        self.format = self.config.report.connection.format
 
         self.start_time = None
         self.end_time = None
         self.run_id = None
-        self.environment = self.config.get("environment", None)
+        self.environment = self.config.environment
 
     def start_run(self):
         self._check_report_path()
@@ -118,17 +120,17 @@ class QaseReport:
 
     # Saves a model to a file
     def _store_object(self, object, path, filename):
-        data = object.to_json()
-        if self.format == 'jsonp':
+        data = object.__str__()
+        if self.format == Format.jsonp:
             data = f"qaseJsonp({data});"
-        with open(f"{path}/{filename}.{self.format}", 'w', encoding='utf-8') as f:
+        with open(f"{path}/{filename}.{self.format.value}", 'w', encoding='utf-8') as f:
             f.write(data)
 
     def _read_object(self, source):
         data = source.read()
-        if self.format == 'json':
+        if self.format == Format.json:
             return json.loads(data)
-        elif self.format == 'jsonp':
+        elif self.format == Format.jsonp:
             jsonp_pattern = r'\w+\(\s*({[\s\S]*})\s*\);'
             match = re.search(jsonp_pattern, data)
             if match:

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/src/qase/commons/reporters/testops.py

@@ -2,52 +2,53 @@ import threading
 
 from datetime import datetime
 from typing import List
-from .. import ConfigManager, Logger, ReporterException
+from .. import Logger, ReporterException
 from ..client.api_v1_client import ApiV1Client
 from ..client.base_api_client import BaseApiClient
 from ..models import Result
+from ..models.config.qaseconfig import QaseConfig
 
 DEFAULT_BATCH_SIZE = 200
+DEFAULT_THREAD_COUNT = 4
 
 
 class QaseTestOps:
 
-    def __init__(self, config: ConfigManager, logger: Logger) -> None:
+    def __init__(self, config: QaseConfig, logger: Logger) -> None:
         self.config = config
         self.logger = logger
 
         self.client = self._prepare_client()
 
-        run_id = self.config.get('testops.run.id')
-        plan_id = self.config.get('testops.plan.id')
+        run_id = self.config.testops.run.id
+        plan_id = self.config.testops.plan.id
 
-        self.project_code = self.config.get('testops.project')
+        self.project_code = self.config.testops.project
         self.run_id = int(run_id) if run_id else run_id
         self.plan_id = int(plan_id) if plan_id else plan_id
-        self.defect = self.config.get('testops.defect', False, bool)
-        self.complete_after_run = self.config.get('testops.run.complete', True, bool)
+        self.defect = self.config.testops.defect
+        self.complete_after_run = self.config.testops.run.complete
         self.environment = None
 
-        self.batch_size = min(2000, max(1, int(self.config.get('testops.batch.size', DEFAULT_BATCH_SIZE))))
-        self.send_semaphore = threading.Semaphore(
-            self.config.get('testops.batch.threads', 4))  # Semaphore to limit concurrent sends
+        self.batch_size = min(2000, max(1, int(self.config.testops.batch.size or DEFAULT_BATCH_SIZE)))
+        self.send_semaphore = threading.Semaphore(DEFAULT_THREAD_COUNT)  # Semaphore to limit concurrent sends
         self.lock = threading.Lock()
         self.count_running_threads = 0
 
-        environment = self.config.get('environment', None)
+        environment = self.config.environment
         if environment:
             if isinstance(environment, int) or (isinstance(environment, str) and environment.isnumeric()):
                 self.environment = environment
             elif isinstance(environment, str):
                 self.environment = self.client.get_environment(environment, self.project_code)
 
-        run_title = self.config.get('testops.run.title', None)
+        run_title = self.config.testops.run.title
         if run_title and run_title != '':
             self.run_title = run_title
         else:
             self.run_title = "Automated Run {}".format(str(datetime.now()))
 
-        run_description = self.config.get('testops.run.description', None)
+        run_description = self.config.testops.run.description
         if run_description and run_description != '':
             self.run_description = run_description
         else:
@@ -66,7 +67,7 @@ class QaseTestOps:
         self.client.get_project(self.project_code)
 
     def _prepare_client(self) -> BaseApiClient:
-        if self.config.get('testops.usev2', False, bool):
+        if self.config.testops.use_v2:
             from ..client.api_v2_client import ApiV2Client
             return ApiV2Client(self.config, self.logger)
         return ApiV1Client(self.config, self.logger)

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/src/qase_python_commons.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qase-python-commons
-Version: 3.0.3
+Version: 3.1.0b2
 Summary: A library for Qase TestOps and Qase Report
 Author-email: Qase Team <support@qase.io>
 Project-URL: Homepage, https://github.com/qase-tms/qase-python/tree/master/qase-python-commons
@@ -22,7 +22,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: attrs>=23.2.0
-Requires-Dist: qase-api-client~=1.0.0
+Requires-Dist: qase-api-client~=1.0.1
 Requires-Dist: qase-api-v2-client~=1.0.0
 Requires-Dist: more_itertools
 Provides-Extra: testing

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/src/qase_python_commons.egg-info/SOURCES.txt

@@ -18,6 +18,15 @@ src/qase/commons/models/run.py
 src/qase/commons/models/runtime.py
 src/qase/commons/models/step.py
 src/qase/commons/models/suite.py
+src/qase/commons/models/config/api.py
+src/qase/commons/models/config/batch.py
+src/qase/commons/models/config/connection.py
+src/qase/commons/models/config/framework.py
+src/qase/commons/models/config/plan.py
+src/qase/commons/models/config/qaseconfig.py
+src/qase/commons/models/config/report.py
+src/qase/commons/models/config/run.py
+src/qase/commons/models/config/testops.py
 src/qase/commons/profilers/__init__.py
 src/qase/commons/profilers/db.py
 src/qase/commons/profilers/network.py

{qase_python_commons-3.0.3 → qase_python_commons-3.1.0b2}/src/qase_python_commons.egg-info/requires.txt

@@ -1,6 +1,6 @@
 certifi>=2024.2.2
 attrs>=23.2.0
-qase-api-client~=1.0.0
+qase-api-client~=1.0.1
 qase-api-v2-client~=1.0.0
 more_itertools
 

qase_python_commons-3.0.3/src/qase/commons/config.py

@@ -1,66 +0,0 @@
-import os
-import json
-from .logger import Logger
-
-
-class ConfigManager:
-
-    def __init__(self, config_file='./qase.config.json', env_vars_prefix='QASE_'):
-        self.logger = Logger()
-        self.config = {}
-        self.parseBool = lambda d: d in ("y", "yes", "true", "1", 1, True)
-
-        try:
-            if os.path.exists(config_file):
-                with open(config_file, "r") as file:
-                    def transform_keys(obj):
-                        return {k.lower(): v for k, v in obj.items()}
-                    self.config = json.load(file, object_hook=transform_keys)
-        except Exception as e:
-            self.logger.log("Failed to load config from file", "error")
-
-        # Load from env vars
-        try:
-            for key, value in os.environ.items():
-                if key.startswith(env_vars_prefix):
-                    self._set_config(key[len(env_vars_prefix):].lower().replace('_', '.'), value)
-        except Exception as e:
-            self.logger.log("Failed to load config from env vars {e}", "error")
-
-    def get(self, key, default=None, value_type=None):
-        # Use _get_config method to get the value. If None, return default.
-        value = self._get_config(key)
-        if value is not None and value_type is not None and value_type == bool:
-            return self.parseBool(value)
-        return value or default
-
-    def validate_config(self):
-        if self.validator:
-            self.validator.validate(self.config)
-
-    def set(self, key, value):
-        self._set_config(key, value)
-
-    def _get_keys(self, config, prefix=""):
-        for key, value in config.items():
-            if isinstance(value, dict):
-                yield from self._get_keys(value, f"{prefix}{key}.")
-            else:
-                yield f"{prefix}{key}"
-
-    def _set_config(self, key, value, delimiter="."):
-        keys = key.split(delimiter)
-        config = self.config
-        for key in keys[:-1]:
-            config = config.setdefault(key, {})
-        config[keys[-1]] = value
-
-    def _get_config(self, key):
-        keys = key.split(".")
-        config = self.config
-        for key in keys[:-1]:
-            config = config.get(key, {})
-        return config.get(keys[-1], None)
-
-    def __str__(self):
-        return json.dumps(self.config, indent=4, sort_keys=True)