qastudio-pytest 1.0.2__tar.gz → 1.0.3__tar.gz

{qastudio_pytest-1.0.2/src/qastudio_pytest.egg-info → qastudio_pytest-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qastudio-pytest
-Version: 1.0.2
+Version: 1.0.3
 Summary: pytest plugin for QAStudio.dev test management platform
 Author-email: QAStudio <ben@qastudio.dev>
 License: MIT
@@ -243,6 +243,36 @@ test:
     QASTUDIO_ENVIRONMENT: CI
 ```
 
+## Examples
+
+### Playwright Example
+
+A complete Playwright test framework example is available in `examples/playwright_tests/`:
+
+```bash
+# Navigate to example directory
+cd examples/playwright_tests
+
+# Install dependencies
+pip install -r requirements.txt
+playwright install chromium
+
+# Run the tests
+./run_tests.sh
+
+# Or run directly with pytest
+pytest -v
+```
+
+The example demonstrates:
+- ✅ Testing the QAStudio.dev website
+- ✅ Automatic screenshot capture
+- ✅ Playwright trace recording (`.zip` files)
+- ✅ Integration with qastudio-pytest reporter
+- ✅ Test case linking with `@pytest.mark.qastudio_id()`
+
+See [`examples/playwright_tests/README.md`](examples/playwright_tests/README.md) for detailed documentation.
+
 ## Development
 
 ```bash

{qastudio_pytest-1.0.2 → qastudio_pytest-1.0.3}/README.md

@@ -206,6 +206,36 @@ test:
     QASTUDIO_ENVIRONMENT: CI
 ```
 
+## Examples
+
+### Playwright Example
+
+A complete Playwright test framework example is available in `examples/playwright_tests/`:
+
+```bash
+# Navigate to example directory
+cd examples/playwright_tests
+
+# Install dependencies
+pip install -r requirements.txt
+playwright install chromium
+
+# Run the tests
+./run_tests.sh
+
+# Or run directly with pytest
+pytest -v
+```
+
+The example demonstrates:
+- ✅ Testing the QAStudio.dev website
+- ✅ Automatic screenshot capture
+- ✅ Playwright trace recording (`.zip` files)
+- ✅ Integration with qastudio-pytest reporter
+- ✅ Test case linking with `@pytest.mark.qastudio_id()`
+
+See [`examples/playwright_tests/README.md`](examples/playwright_tests/README.md) for detailed documentation.
+
 ## Development
 
 ```bash

{qastudio_pytest-1.0.2 → qastudio_pytest-1.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qastudio-pytest"
-version = "1.0.2"
+version = "1.0.3"
 description = "pytest plugin for QAStudio.dev test management platform"
 authors = [{name = "QAStudio", email = "ben@qastudio.dev"}]
 license = {text = "MIT"}
@@ -62,10 +62,24 @@ max-line-length = 100
 extend-ignore = ["E203", "W503"]
 
 [tool.mypy]
-python_version = "1.0.2"
+python_version = "1.0.3"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true
+exclude = [
+    "venv/",
+    ".venv/",
+    "build/",
+    "dist/",
+]
+
+# Ignore errors in installed packages
+[[tool.mypy.overrides]]
+module = [
+    "pytest.*",
+    "_pytest.*",
+]
+ignore_errors = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{qastudio_pytest-1.0.2 → qastudio_pytest-1.0.3}/src/qastudio_pytest/__init__.py

@@ -4,7 +4,7 @@ QAStudio pytest plugin for test management integration.
 This plugin automatically reports pytest test results to QAStudio.dev platform.
 """
 
-__version__ = "1.0.2"
+__version__ = "1.0.3"
 __author__ = "QAStudio"
 __email__ = "support@qastudio.dev"
 

qastudio_pytest-1.0.3/src/qastudio_pytest/api_client.py

@@ -0,0 +1,379 @@
+"""API client for QAStudio.dev integration."""
+
+from typing import Any, Dict, List, Optional
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from .models import ReporterConfig, TestResult, TestRunSummary
+from .utils import sanitize_string
+
+
+class APIError(Exception):
+    """Custom exception for API errors."""
+
+    def __init__(self, status_code: int, message: str):
+        self.status_code = status_code
+        super().__init__(f"API Error {status_code}: {message}")
+
+
+class QAStudioAPIClient:
+    """Client for communicating with QAStudio.dev API."""
+
+    def __init__(self, config: ReporterConfig):
+        """Initialize API client with configuration."""
+        self.config = config
+        self.session = self._create_session()
+        self.base_url = sanitize_string(config.api_url) or ""
+        self.api_key = sanitize_string(config.api_key) or ""
+        self.project_id = sanitize_string(config.project_id) or ""
+
+    def _create_session(self) -> requests.Session:
+        """Create requests session with retry logic."""
+        session = requests.Session()
+
+        # Configure retry strategy
+        retry_strategy = Retry(
+            total=self.config.max_retries,
+            backoff_factor=1,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["HEAD", "GET", "POST", "PUT", "DELETE", "OPTIONS", "TRACE"],
+        )
+
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+
+        return session
+
+    def _make_request(
+        self,
+        method: str,
+        path: str,
+        json_data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make HTTP request to API with error handling.
+
+        Args:
+            method: HTTP method
+            path: API endpoint path
+            json_data: JSON data to send
+
+        Returns:
+            Response JSON data
+
+        Raises:
+            APIError: If request fails
+        """
+        url = f"{self.base_url}{path}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "qastudio-pytest/1.0.0",
+        }
+
+        try:
+            self._log(f"Making {method} request to {path}")
+
+            response = self.session.request(
+                method=method,
+                url=url,
+                json=json_data,
+                headers=headers,
+                timeout=self.config.timeout,
+            )
+
+            # Raise for 4xx/5xx status codes
+            if not response.ok:
+                error_msg = response.text or response.reason
+                raise APIError(response.status_code, error_msg)
+
+            # Return JSON if present
+            if response.content:
+                json_response: Dict[str, Any] = response.json()
+                return json_response
+            return {}
+
+        except requests.exceptions.Timeout as e:
+            raise APIError(408, f"Request timeout: {str(e)}")
+        except requests.exceptions.ConnectionError as e:
+            raise APIError(503, f"Connection error: {str(e)}")
+        except requests.exceptions.RequestException as e:
+            raise APIError(500, f"Request failed: {str(e)}")
+
+    def create_test_run(
+        self,
+        name: str,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new test run.
+
+        Args:
+            name: Test run name
+            description: Optional description
+
+        Returns:
+            Test run data with 'id' field
+        """
+        self._log(f"Creating test run: {name}")
+
+        data = {
+            "projectId": self.project_id,
+            "name": name,
+            "environment": self.config.environment,
+        }
+
+        if description:
+            data["description"] = description
+
+        response = self._make_request("POST", "/runs", json_data=data)
+
+        self._log(f"Created test run with ID: {response.get('id')}")
+        return response
+
+    def submit_test_results(
+        self,
+        test_run_id: str,
+        results: List[TestResult],
+    ) -> Dict[str, Any]:
+        """
+        Submit test results to a test run.
+
+        Args:
+            test_run_id: Test run ID
+            results: List of test results
+
+        Returns:
+            Response data
+        """
+        self._log(f"Submitting {len(results)} test results to run {test_run_id}")
+
+        data = {
+            "testRunId": test_run_id,
+            "results": [result.to_dict() for result in results],
+        }
+
+        response = self._make_request("POST", "/results", json_data=data)
+
+        self._log(f"Successfully submitted {len(results)} results")
+        return response
+
+    def complete_test_run(
+        self,
+        test_run_id: str,
+        summary: TestRunSummary,
+    ) -> Dict[str, Any]:
+        """
+        Mark test run as complete with summary.
+
+        Args:
+            test_run_id: Test run ID
+            summary: Test run summary
+
+        Returns:
+            Response data
+        """
+        self._log(f"Completing test run {test_run_id}")
+
+        data = {
+            "testRunId": test_run_id,
+            "summary": summary.to_dict(),
+        }
+
+        response = self._make_request("POST", f"/runs/{test_run_id}/complete", json_data=data)
+
+        self._log("Test run completed successfully")
+        return response
+
+    def upload_attachment(
+        self,
+        test_result_id: str,
+        file_path: str,
+        attachment_type: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Upload an attachment file to a test result.
+
+        Args:
+            test_result_id: Test result ID to attach file to
+            file_path: Path to file to upload
+            attachment_type: Optional type (e.g., 'screenshot', 'video', 'log')
+
+        Returns:
+            Response data with attachment info
+
+        Raises:
+            APIError: If upload fails
+        """
+        import os
+        import mimetypes
+
+        if not os.path.exists(file_path):
+            raise APIError(400, f"File not found: {file_path}")
+
+        filename = os.path.basename(file_path)
+        content_type = mimetypes.guess_type(file_path)[0] or "application/octet-stream"
+
+        self._log(f"Uploading attachment: {filename} ({content_type})")
+
+        with open(file_path, "rb") as f:
+            file_data = f.read()
+
+        # Prepare multipart form data
+        fields = {
+            "testResultId": test_result_id,
+        }
+
+        if attachment_type:
+            fields["type"] = attachment_type
+
+        return self._upload_multipart("/attachments", fields, filename, content_type, file_data)
+
+    def _upload_multipart(
+        self,
+        path: str,
+        fields: Dict[str, str],
+        filename: str,
+        content_type: str,
+        file_data: bytes,
+    ) -> Dict[str, Any]:
+        """
+        Upload multipart/form-data request with retry logic.
+
+        Args:
+            path: API endpoint path
+            fields: Form fields
+            filename: Name of file being uploaded
+            content_type: MIME type of file
+            file_data: File content as bytes
+
+        Returns:
+            Response JSON data
+
+        Raises:
+            APIError: If request fails
+        """
+        url = f"{self.base_url}{path}"
+        last_error: Optional[Exception] = None
+
+        for attempt in range(self.config.max_retries):
+            try:
+                if attempt > 0:
+                    self._log(f"Retry attempt {attempt + 1}/{self.config.max_retries}")
+                    import time
+
+                    time.sleep(min(1 * (2**attempt), 10))  # Exponential backoff
+
+                return self._make_multipart_request(url, fields, filename, content_type, file_data)
+
+            except APIError as e:
+                last_error = e
+                self._log(f"Upload failed (attempt {attempt + 1}/{self.config.max_retries}): {e}")
+
+                # Don't retry on 4xx errors (client errors)
+                if 400 <= e.status_code < 500:
+                    raise
+
+            except Exception as e:
+                last_error = e
+                self._log(f"Upload failed (attempt {attempt + 1}/{self.config.max_retries}): {e}")
+
+        if last_error:
+            raise last_error
+        raise APIError(500, "Upload failed after all retries")
+
+    def _make_multipart_request(
+        self,
+        url: str,
+        fields: Dict[str, str],
+        filename: str,
+        content_type: str,
+        file_data: bytes,
+    ) -> Dict[str, Any]:
+        """
+        Make a multipart/form-data HTTP request.
+
+        Args:
+            url: Full URL to request
+            fields: Form fields (non-file)
+            filename: Name of file being uploaded
+            content_type: MIME type of file
+            file_data: File content as bytes
+
+        Returns:
+            Response JSON data
+
+        Raises:
+            APIError: If request fails
+        """
+        import uuid
+
+        # Generate boundary
+        boundary = f"----FormBoundary{uuid.uuid4().hex}"
+
+        # Build multipart body
+        body_parts = []
+
+        # Add form fields
+        for key, value in fields.items():
+            body_parts.append(f"--{boundary}\r\n".encode())
+            body_parts.append(f'Content-Disposition: form-data; name="{key}"\r\n\r\n'.encode())
+            body_parts.append(f"{value}\r\n".encode())
+
+        # Add file field
+        body_parts.append(f"--{boundary}\r\n".encode())
+        body_parts.append(
+            f'Content-Disposition: form-data; name="file"; filename="{filename}"\r\n'.encode()
+        )
+        body_parts.append(f"Content-Type: {content_type}\r\n\r\n".encode())
+        body_parts.append(file_data)
+        body_parts.append(b"\r\n")
+
+        # Add closing boundary
+        body_parts.append(f"--{boundary}--\r\n".encode())
+
+        body = b"".join(body_parts)
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": f"multipart/form-data; boundary={boundary}",
+            "User-Agent": "qastudio-pytest/1.0.0",
+        }
+
+        try:
+            response = self.session.request(
+                method="POST",
+                url=url,
+                data=body,
+                headers=headers,
+                timeout=self.config.timeout,
+            )
+
+            # Raise for 4xx/5xx status codes
+            if not response.ok:
+                error_msg = response.text or response.reason
+                raise APIError(response.status_code, error_msg)
+
+            # Return JSON if present
+            if response.content:
+                json_response: Dict[str, Any] = response.json()
+                return json_response
+            return {}
+
+        except requests.exceptions.Timeout as e:
+            raise APIError(408, f"Request timeout: {str(e)}")
+        except requests.exceptions.ConnectionError as e:
+            raise APIError(503, f"Connection error: {str(e)}")
+        except requests.exceptions.RequestException as e:
+            raise APIError(500, f"Request failed: {str(e)}")
+
+    def _log(self, message: str) -> None:
+        """Log message if verbose mode is enabled."""
+        if self.config.verbose:
+            print(f"[QAStudio] {message}")
+
+    def close(self) -> None:
+        """Close the session."""
+        self.session.close()

{qastudio_pytest-1.0.2 → qastudio_pytest-1.0.3}/src/qastudio_pytest/models.py

@@ -35,7 +35,9 @@ class TestResult:
     file_path: Optional[str] = None
     line_number: Optional[int] = None
     attachments: Optional[List[Dict[str, Any]]] = None
+    attachment_paths: List[str] = field(default_factory=list)
     metadata: Dict[str, Any] = field(default_factory=dict)
+    result_id: Optional[str] = None  # API result ID for uploading attachments
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for API submission."""
@@ -205,6 +207,8 @@ class ReporterConfig:
     include_error_location: bool = True
     include_test_steps: bool = True
     include_console_output: bool = False
+    upload_attachments: bool = True
+    attachments_dir: Optional[str] = None
 
     @classmethod
     def from_pytest_config(cls, config: Any) -> "ReporterConfig":
@@ -259,4 +263,6 @@ class ReporterConfig:
             include_error_location=get_option("qastudio_include_error_location", True),
             include_test_steps=get_option("qastudio_include_test_steps", True),
             include_console_output=get_option("qastudio_include_console_output", False),
+            upload_attachments=get_option("qastudio_upload_attachments", True),
+            attachments_dir=get_option("qastudio_attachments_dir"),
         )

{qastudio_pytest-1.0.2 → qastudio_pytest-1.0.3}/src/qastudio_pytest/plugin.py

@@ -76,6 +76,11 @@ class QAStudioPlugin:
         if report.when == "call":
             try:
                 result = TestResult.from_pytest_report(item, report, self.config)
+
+                # Collect attachments if enabled
+                if self.config.upload_attachments:
+                    result.attachment_paths = self._collect_attachments(item)
+
                 self.results.append(result)
 
                 # Update counters
@@ -142,7 +147,7 @@ class QAStudioPlugin:
             self.api_client.close()
 
     def _submit_results(self) -> None:
-        """Submit test results in batches."""
+        """Submit test results in batches and upload attachments."""
         if not self.results:
             self._log("No results to submit")
             return
@@ -153,13 +158,122 @@ class QAStudioPlugin:
         for i, batch in enumerate(batches, 1):
             try:
                 self._log(f"Submitting batch {i}/{len(batches)} ({len(batch)} results)")
-                self.api_client.submit_test_results(
+                response = self.api_client.submit_test_results(
                     self.test_run_id,  # type: ignore
                     batch,
                 )
+
+                # Store result IDs for attachment uploads
+                if response and "results" in response:
+                    for j, result_data in enumerate(response["results"]):
+                        if j < len(batch):
+                            batch[j].result_id = result_data.get("id")
+
+                # Upload attachments if enabled
+                if self.config.upload_attachments:
+                    for result in batch:
+                        if result.result_id and result.attachment_paths:
+                            self._upload_attachments(result)
+
             except APIError as e:
                 self._handle_error(f"Failed to submit batch {i}", e)
 
+    def _collect_attachments(self, item: Any) -> List[str]:
+        """
+        Collect attachment file paths for a test.
+
+        Looks for attachments in:
+        1. Custom attachments directory (if configured)
+        2. pytest-html plugin screenshots
+        3. Test fixtures that store attachment paths
+
+        Args:
+            item: pytest test item
+
+        Returns:
+            List of file paths to attach
+        """
+        import os
+        import glob
+
+        attachments = []
+
+        # Check if test has attachment paths stored in stash or fixtures
+        if hasattr(item, "stash"):
+            # pytest >= 7.0 uses stash API
+            from pytest import StashKey
+
+            attachment_key = StashKey[List[str]]()
+            stored_attachments = item.stash.get(attachment_key, [])
+            attachments.extend(stored_attachments)
+
+        # Check custom attachments directory
+        if self.config.attachments_dir:
+            test_name = item.name.replace("[", "_").replace("]", "_")
+            attachment_dir = os.path.join(self.config.attachments_dir, test_name)
+
+            if os.path.exists(attachment_dir):
+                # Find common attachment types
+                patterns = [
+                    "*.png",
+                    "*.jpg",
+                    "*.jpeg",
+                    "*.gif",
+                    "*.mp4",
+                    "*.webm",
+                    "*.txt",
+                    "*.log",
+                    "*.zip",
+                ]
+                for pattern in patterns:
+                    files = glob.glob(os.path.join(attachment_dir, pattern))
+                    attachments.extend(files)
+
+        return attachments
+
+    def _upload_attachments(self, result: TestResult) -> None:
+        """
+        Upload attachments for a test result.
+
+        Args:
+            result: TestResult with attachment_paths and result_id
+        """
+        if not result.result_id or not result.attachment_paths:
+            return
+
+        self._log(f"Uploading {len(result.attachment_paths)} attachment(s) for {result.title}")
+
+        for file_path in result.attachment_paths:
+            try:
+                # Determine attachment type from file extension
+                import os
+
+                ext = os.path.splitext(file_path)[1].lower()
+                filename = os.path.basename(file_path)
+                attachment_type = None
+
+                if ext in [".png", ".jpg", ".jpeg", ".gif"]:
+                    attachment_type = "screenshot"
+                elif ext in [".mp4", ".webm", ".avi", ".mov"]:
+                    attachment_type = "video"
+                elif ext in [".log", ".txt"]:
+                    attachment_type = "log"
+                elif ext == ".zip" and "trace" in filename.lower():
+                    attachment_type = "trace"
+
+                self.api_client.upload_attachment(
+                    test_result_id=result.result_id,
+                    file_path=file_path,
+                    attachment_type=attachment_type,
+                )
+
+                self._log(f"  Uploaded: {os.path.basename(file_path)}")
+
+            except APIError as e:
+                self._handle_error(f"Failed to upload attachment {file_path}", e)
+            except Exception as e:
+                self._log(f"  Error uploading {file_path}: {e}")
+
     def _log(self, message: str) -> None:
         """Log message if verbose mode is enabled."""
         if self.config.verbose:
@@ -269,6 +383,21 @@ def pytest_addoption(parser: Any) -> None:
         help="Include console output (default: False)",
     )
 
+    group.addoption(
+        "--qastudio-upload-attachments",
+        action="store_true",
+        dest="qastudio_upload_attachments",
+        default=True,
+        help="Upload test attachments (default: True)",
+    )
+
+    group.addoption(
+        "--qastudio-attachments-dir",
+        action="store",
+        dest="qastudio_attachments_dir",
+        help="Directory containing test attachments",
+    )
+
     # Add pytest.ini configuration
     parser.addini("qastudio_api_url", "QAStudio.dev API URL")
     parser.addini("qastudio_api_key", "QAStudio.dev API key")
@@ -299,6 +428,14 @@ def pytest_addoption(parser: Any) -> None:
         "qastudio_include_console_output",
         "Include console output (true/false)",
     )
+    parser.addini(
+        "qastudio_upload_attachments",
+        "Upload test attachments (true/false)",
+    )
+    parser.addini(
+        "qastudio_attachments_dir",
+        "Directory containing test attachments",
+    )
 
 
 def pytest_configure(config: Any) -> None:

{qastudio_pytest-1.0.2 → qastudio_pytest-1.0.3/src/qastudio_pytest.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qastudio-pytest
-Version: 1.0.2
+Version: 1.0.3
 Summary: pytest plugin for QAStudio.dev test management platform
 Author-email: QAStudio <ben@qastudio.dev>
 License: MIT
@@ -243,6 +243,36 @@ test:
     QASTUDIO_ENVIRONMENT: CI
 ```
 
+## Examples
+
+### Playwright Example
+
+A complete Playwright test framework example is available in `examples/playwright_tests/`:
+
+```bash
+# Navigate to example directory
+cd examples/playwright_tests
+
+# Install dependencies
+pip install -r requirements.txt
+playwright install chromium
+
+# Run the tests
+./run_tests.sh
+
+# Or run directly with pytest
+pytest -v
+```
+
+The example demonstrates:
+- ✅ Testing the QAStudio.dev website
+- ✅ Automatic screenshot capture
+- ✅ Playwright trace recording (`.zip` files)
+- ✅ Integration with qastudio-pytest reporter
+- ✅ Test case linking with `@pytest.mark.qastudio_id()`
+
+See [`examples/playwright_tests/README.md`](examples/playwright_tests/README.md) for detailed documentation.
+
 ## Development
 
 ```bash

qastudio_pytest-1.0.2/src/qastudio_pytest/api_client.py

@@ -1,205 +0,0 @@
-"""API client for QAStudio.dev integration."""
-
-from typing import Any, Dict, List, Optional
-import requests
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
-
-from .models import ReporterConfig, TestResult, TestRunSummary
-from .utils import sanitize_string
-
-
-class APIError(Exception):
-    """Custom exception for API errors."""
-
-    def __init__(self, status_code: int, message: str):
-        self.status_code = status_code
-        super().__init__(f"API Error {status_code}: {message}")
-
-
-class QAStudioAPIClient:
-    """Client for communicating with QAStudio.dev API."""
-
-    def __init__(self, config: ReporterConfig):
-        """Initialize API client with configuration."""
-        self.config = config
-        self.session = self._create_session()
-        self.base_url = sanitize_string(config.api_url) or ""
-        self.api_key = sanitize_string(config.api_key) or ""
-        self.project_id = sanitize_string(config.project_id) or ""
-
-    def _create_session(self) -> requests.Session:
-        """Create requests session with retry logic."""
-        session = requests.Session()
-
-        # Configure retry strategy
-        retry_strategy = Retry(
-            total=self.config.max_retries,
-            backoff_factor=1,
-            status_forcelist=[429, 500, 502, 503, 504],
-            allowed_methods=["HEAD", "GET", "POST", "PUT", "DELETE", "OPTIONS", "TRACE"],
-        )
-
-        adapter = HTTPAdapter(max_retries=retry_strategy)
-        session.mount("http://", adapter)
-        session.mount("https://", adapter)
-
-        return session
-
-    def _make_request(
-        self,
-        method: str,
-        path: str,
-        json_data: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """
-        Make HTTP request to API with error handling.
-
-        Args:
-            method: HTTP method
-            path: API endpoint path
-            json_data: JSON data to send
-
-        Returns:
-            Response JSON data
-
-        Raises:
-            APIError: If request fails
-        """
-        url = f"{self.base_url}{path}"
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "User-Agent": "qastudio-pytest/1.0.0",
-        }
-
-        try:
-            self._log(f"Making {method} request to {path}")
-
-            response = self.session.request(
-                method=method,
-                url=url,
-                json=json_data,
-                headers=headers,
-                timeout=self.config.timeout,
-            )
-
-            # Raise for 4xx/5xx status codes
-            if not response.ok:
-                error_msg = response.text or response.reason
-                raise APIError(response.status_code, error_msg)
-
-            # Return JSON if present
-            if response.content:
-                json_response: Dict[str, Any] = response.json()
-                return json_response
-            return {}
-
-        except requests.exceptions.Timeout as e:
-            raise APIError(408, f"Request timeout: {str(e)}")
-        except requests.exceptions.ConnectionError as e:
-            raise APIError(503, f"Connection error: {str(e)}")
-        except requests.exceptions.RequestException as e:
-            raise APIError(500, f"Request failed: {str(e)}")
-
-    def create_test_run(
-        self,
-        name: str,
-        description: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """
-        Create a new test run.
-
-        Args:
-            name: Test run name
-            description: Optional description
-
-        Returns:
-            Test run data with 'id' field
-        """
-        self._log(f"Creating test run: {name}")
-
-        data = {
-            "projectId": self.project_id,
-            "name": name,
-            "environment": self.config.environment,
-        }
-
-        if description:
-            data["description"] = description
-
-        response = self._make_request("POST", "/test-runs", json_data=data)
-
-        self._log(f"Created test run with ID: {response.get('id')}")
-        return response
-
-    def submit_test_results(
-        self,
-        test_run_id: str,
-        results: List[TestResult],
-    ) -> Dict[str, Any]:
-        """
-        Submit test results to a test run.
-
-        Args:
-            test_run_id: Test run ID
-            results: List of test results
-
-        Returns:
-            Response data
-        """
-        self._log(f"Submitting {len(results)} test results to run {test_run_id}")
-
-        data = {
-            "testRunId": test_run_id,
-            "results": [result.to_dict() for result in results],
-        }
-
-        response = self._make_request(
-            "POST",
-            f"/test-runs/{test_run_id}/results",
-            json_data=data,
-        )
-
-        self._log(f"Successfully submitted {len(results)} results")
-        return response
-
-    def complete_test_run(
-        self,
-        test_run_id: str,
-        summary: TestRunSummary,
-    ) -> Dict[str, Any]:
-        """
-        Mark test run as complete with summary.
-
-        Args:
-            test_run_id: Test run ID
-            summary: Test run summary
-
-        Returns:
-            Response data
-        """
-        self._log(f"Completing test run {test_run_id}")
-
-        data = {
-            "testRunId": test_run_id,
-            "summary": summary.to_dict(),
-        }
-
-        response = self._make_request(
-            "POST",
-            f"/test-runs/{test_run_id}/complete",
-            json_data=data,
-        )
-
-        self._log("Test run completed successfully")
-        return response
-
-    def _log(self, message: str) -> None:
-        """Log message if verbose mode is enabled."""
-        if self.config.verbose:
-            print(f"[QAStudio] {message}")
-
-    def close(self) -> None:
-        """Close the session."""
-        self.session.close()