alita-sdk 0.3.257__py3-none-any.whl → 0.3.562__py3-none-any.whl

alita_sdk/configurations/sharepoint.py

@@ -0,0 +1,167 @@
+import requests
+from office365.onedrive.sharepoint_settings import SharepointSettings
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SharepointConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "SharePoint",
+                "icon_url": "sharepoint.svg",
+                "section": "credentials",
+                "type": "sharepoint",
+                "categories": ["office"],
+                "extra_categories": ["sharepoint", "microsoft", "documents", "collaboration"],
+            }
+        }
+    )
+    client_id: str = Field(description="SharePoint Client ID")
+    client_secret: SecretStr = Field(description="SharePoint Client Secret")
+    site_url: str = Field(description="SharePoint Site URL")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Test the connection to SharePoint API using OAuth2 client credentials.
+
+        Args:
+            settings: Dictionary containing 'client_id', 'client_secret', and 'site_url' (all required)
+
+        Returns:
+            None if connection is successful, error message string otherwise
+        """
+        # Validate client_id
+        client_id = settings.get("client_id")
+        if client_id is None or client_id == "":
+            if client_id == "":
+                return "Client ID cannot be empty"
+            return "Client ID is required"
+
+        if not isinstance(client_id, str):
+            return "Client ID must be a string"
+
+        client_id = client_id.strip()
+        if not client_id:
+            return "Client ID cannot be empty"
+
+        # Validate client_secret
+        client_secret = settings.get("client_secret")
+        if client_secret is None:
+            return "Client secret is required"
+
+        # Extract secret value if it's a SecretStr
+        if hasattr(client_secret, "get_secret_value"):
+            client_secret = client_secret.get_secret_value()
+
+        if not client_secret or not client_secret.strip():
+            return "Client secret cannot be empty"
+
+        # Validate site_url
+        site_url = settings.get("site_url")
+        if site_url is None or site_url == "":
+            if site_url == "":
+                return "Site URL cannot be empty"
+            return "Site URL is required"
+
+        if not isinstance(site_url, str):
+            return "Site URL must be a string"
+
+        site_url = site_url.strip()
+        if not site_url:
+            return "Site URL cannot be empty"
+
+        if not site_url.startswith(("http://", "https://")):
+            return "Site URL must start with http:// or https://"
+
+        # Remove trailing slash for consistency
+        site_url = site_url.rstrip("/")
+
+        # Extract tenant and resource from site URL
+        # Expected format: https://<tenant>.sharepoint.com/sites/<site>
+        try:
+            if ".sharepoint.com" not in site_url:
+                return "Site URL must be a valid SharePoint URL (*.sharepoint.com)"
+
+            # Extract tenant (e.g., "contoso" from "contoso.sharepoint.com")
+            parts = site_url.split("//")[1].split(".")
+            if len(parts) < 3:
+                return "Invalid SharePoint URL format"
+            tenant = parts[0]
+
+            # Build token endpoint
+            token_url = f"https://accounts.accesscontrol.windows.net/{tenant}.onmicrosoft.com/tokens/OAuth/2"
+
+            # Build resource (the site URL with /_api appended)
+            resource = f"{site_url.split('/sites/')[0]}@{site_url.split('//')[1].split('/')[0].split('.')[0]}"
+
+        except Exception:
+            return "Failed to parse SharePoint URL - ensure it's in format: https://<tenant>.sharepoint.com/sites/<site>"
+
+        try:
+            # Step 1: Get OAuth2 access token using client credentials
+            token_response = requests.post(
+                token_url,
+                data={
+                    "grant_type": "client_credentials",
+                    "client_id": f"{client_id}@{tenant}.onmicrosoft.com",
+                    "client_secret": client_secret,
+                    "resource": f"00000003-0000-0ff1-ce00-000000000000/{site_url.split('//')[1].split('/')[0]}@{tenant}.onmicrosoft.com"
+                },
+                timeout=10,
+            )
+
+            if token_response.status_code == 400:
+                try:
+                    error_data = token_response.json()
+                    error_desc = error_data.get("error_description", "")
+                    if "not found in the directory" in error_desc.lower():
+                        return "Invalid client ID. Please check if you provide a correct client ID and try again."
+                    elif "client_secret" in error_desc.lower():
+                        return "Invalid client secret"
+                    else:
+                        return f"OAuth2 authentication failed: {error_desc}"
+                except Exception:
+                    return "Invalid client credentials"
+
+            elif token_response.status_code == 401:
+                return "Invalid client secret provided. Please check if you provide a correct client secret and try again."
+            elif token_response.status_code != 200:
+                return f"Failed to obtain access token (status {token_response.status_code})"
+
+            # Extract access token
+            try:
+                token_data = token_response.json()
+                access_token = token_data.get("access_token")
+                if not access_token:
+                    return "No access token received from SharePoint"
+            except Exception:
+                return "Failed to parse token response"
+
+            # Step 2: Test the access token by calling SharePoint API
+            api_url = f"{site_url}/_api/web"
+            api_response = requests.get(
+                api_url,
+                headers={"Authorization": f"Bearer {access_token}"},
+                timeout=10,
+            )
+
+            if api_response.status_code == 200:
+                return None  # Connection successful
+            elif api_response.status_code == 401:
+                return "Access token is invalid or expired"
+            elif api_response.status_code == 403:
+                return "Access forbidden - client may lack required permissions for this site"
+            elif api_response.status_code == 404:
+                return f"Site not found or not accessible: {site_url}"
+            else:
+                return f"SharePoint API request failed with status {api_response.status_code}"
+
+        except requests.exceptions.Timeout:
+            return "Connection timeout - SharePoint is not responding"
+        except requests.exceptions.ConnectionError:
+            return "Connection error - unable to reach SharePoint"
+        except requests.exceptions.RequestException as e:
+            return f"Request failed: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/sonar.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SonarConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Sonar",
+                "icon_url": "sonar-icon.svg",
+                "section": "credentials",
+                "type": "sonar",
+                "categories": ["development"],
+                "extra_categories": ["code quality", "code security", "code coverage", "quality", "sonarqube"],
+            }
+        }
+    )
+    url: str = Field(description="SonarQube Server URL")
+    sonar_token: SecretStr = Field(description="SonarQube user token for authentication")

alita_sdk/configurations/sql.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SqlConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "SQL",
+                "icon_url": "sql.svg",
+                "section": "credentials",
+                "type": "sql",
+                "categories": ["development"],
+                "extra_categories": ["sql", "database", "data", "query"],
+            }
+        }
+    )
+    host: str = Field(description="Database host")
+    port: int = Field(description="Database port", default=None)
+    username: str = Field(description="Database username")
+    password: SecretStr = Field(description="Database password", json_schema_extra={'secret': True})

alita_sdk/configurations/testio.py

@@ -0,0 +1,101 @@
+import requests
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class TestIOConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "TestIO",
+                "icon_url": "testio.svg",
+                "section": "credentials",
+                "type": "testio",
+                "categories": ["testing"],
+                "extra_categories": ["testio", "testing", "crowd testing", "qa"],
+            }
+        }
+    )
+    endpoint: str = Field(description="TestIO endpoint")
+    api_key: SecretStr = Field(description="TestIO API Key")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Test the connection to TestIO API.
+
+        Args:
+            settings: Dictionary containing 'endpoint' and 'api_key' (both required)
+
+        Returns:
+            None if connection is successful, error message string otherwise
+        """
+        endpoint = settings.get("endpoint")
+        if endpoint is None or endpoint == "":
+            if endpoint == "":
+                return "Endpoint cannot be empty"
+            return "Endpoint is required"
+
+        # Validate endpoint format
+        if not isinstance(endpoint, str):
+            return "Endpoint must be a string"
+        
+        endpoint = endpoint.strip()
+        if not endpoint:
+            return "Endpoint cannot be empty"
+        if not endpoint.startswith(("http://", "https://")):
+            return "Endpoint must start with http:// or https://"
+
+        # Remove trailing slash for consistency
+        endpoint = endpoint.rstrip("/")
+
+        api_key = settings.get("api_key")
+        if api_key is None:
+            return "API key is required"
+
+        # Extract secret value if it's a SecretStr
+        if hasattr(api_key, "get_secret_value"):
+            api_key = api_key.get_secret_value()
+
+        # Validate API key is not empty
+        if not api_key or not api_key.strip():
+            return "API key cannot be empty"
+
+        # Verification strategy:
+        # Use an auth-required endpoint and a single, explicit auth scheme:
+        #   Authorization: Token <token>
+        url = f"{endpoint}/customer/v2/products"
+
+        try:
+            resp = TestIOConfiguration._get_with_token(url, api_key)
+
+            if resp.status_code == 200:
+                return None  # Connection successful
+            if resp.status_code == 401:
+                return "Invalid token"
+            if resp.status_code == 403:
+                return "Access forbidden - token has no access to /customer/v2/products"
+            if resp.status_code == 404:
+                return "Invalid endpoint. Verify TestIO base endpoint."
+            if resp.status_code == 429:
+                return "Rate limited - please try again later"
+            if 500 <= resp.status_code <= 599:
+                return f"TestIO service error (HTTP {resp.status_code})"
+            return f"Connection failed (HTTP {resp.status_code})"
+
+        except requests.exceptions.Timeout:
+            return "Connection timeout - TestIO did not respond within 10 seconds"
+        except requests.exceptions.ConnectionError:
+            return "Connection error - unable to reach TestIO. Check endpoint URL and network."
+        except requests.exceptions.RequestException as e:
+            return f"Request failed: {str(e)}"
+        except Exception:
+            return "Unexpected error during TestIO connection check"
+
+    @staticmethod
+    def _get_with_token(url: str, token: str) -> requests.Response:
+        """Perform an authenticated GET using `Authorization: Token <token>`."""
+        return requests.get(
+            url,
+            headers={"Authorization": f"Token {token}"},
+            timeout=10,
+        )

alita_sdk/configurations/testrail.py

@@ -19,3 +19,91 @@ class TestRailConfiguration(BaseModel):
     url: str = Field(description="Testrail URL")
     email: str = Field(description="TestRail Email")
     password: SecretStr = Field(description="TestRail Password")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to TestRail.
+        
+        Args:
+            settings: Dictionary containing TestRail configuration
+                - url: TestRail instance URL (required)
+                - email: User email for authentication (required)
+                - password: Password or API key for authentication (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        from requests.auth import HTTPBasicAuth
+        
+        # Validate url
+        url = settings.get("url", "").strip()
+        if not url:
+            return "TestRail URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        url = url.rstrip("/")
+        
+        # Basic URL validation
+        if not url.startswith(("http://", "https://")):
+            return "TestRail URL must start with http:// or https://"
+        
+        # Validate email
+        email = settings.get("email", "").strip()
+        if not email:
+            return "TestRail email is required"
+        
+        # Validate password
+        password = settings.get("password")
+        if not password:
+            return "TestRail password is required"
+        
+        # Extract password value if it's a SecretStr
+        password_value = password.get_secret_value() if hasattr(password, 'get_secret_value') else password
+        
+        if not password_value or not password_value.strip():
+            return "TestRail password cannot be empty"
+        
+        # Test connection using /index.php?/api/v2/get_user_by_email endpoint
+        # This endpoint returns user info and validates authentication
+        test_url = f"{url}/index.php?/api/v2/get_user_by_email&email={email}"
+        
+        try:
+            response = requests.get(
+                test_url,
+                auth=HTTPBasicAuth(email, password_value),
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected and authenticated
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid email or password"
+            elif response.status_code == 403:
+                return "Access forbidden: check user permissions"
+            elif response.status_code == 404:
+                return "TestRail API endpoint not found: verify the TestRail URL"
+            elif response.status_code == 400:
+                # Could be invalid email format or other bad request
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", "Bad request")
+                    return f"Bad request: {error_msg}"
+                except:
+                    return "Bad request: check email format and URL"
+            else:
+                return f"TestRail API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to TestRail at {url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to TestRail at {url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to TestRail: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/xray.py

@@ -7,7 +7,7 @@ class XrayConfiguration(BaseModel):
     model_config = ConfigDict(
         json_schema_extra={
             "metadata": {
-                "label": "Xray",
+                "label": "Xray Cloud",
                 "icon_url": "xray.svg",
                 "sections": {
                     "auth": {
@@ -30,3 +30,96 @@ class XrayConfiguration(BaseModel):
     base_url: str = Field(description="Xray URL")
     client_id: Optional[str] = Field(description="Client ID")
     client_secret: Optional[SecretStr] = Field(description="Client secret")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Xray Cloud.
+        
+        Args:
+            settings: Dictionary containing Xray configuration
+                - base_url: Xray Cloud URL (required)
+                - client_id: OAuth2 Client ID (required)
+                - client_secret: OAuth2 Client Secret (required)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Validate base_url
+        base_url = settings.get("base_url", "").strip()
+        if not base_url:
+            return "Xray URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        base_url = base_url.rstrip("/")
+        
+        # Basic URL validation
+        if not base_url.startswith(("http://", "https://")):
+            return "Xray URL must start with http:// or https://"
+        
+        # Validate client_id
+        client_id = settings.get("client_id", "").strip() if settings.get("client_id") else ""
+        if not client_id:
+            return "Xray client ID is required"
+        
+        # Validate client_secret
+        client_secret = settings.get("client_secret")
+        if not client_secret:
+            return "Xray client secret is required"
+        
+        # Extract client_secret value if it's a SecretStr
+        client_secret_value = client_secret.get_secret_value() if hasattr(client_secret, 'get_secret_value') else client_secret
+        
+        if not client_secret_value or not str(client_secret_value).strip():
+            return "Xray client secret cannot be empty"
+        
+        # Test connection using /api/v2/authenticate endpoint
+        # This is the OAuth2 token generation endpoint for Xray Cloud
+        auth_url = f"{base_url}/api/v2/authenticate"
+        
+        auth_payload = {
+            "client_id": client_id,
+            "client_secret": str(client_secret_value).strip()
+        }
+        
+        try:
+            response = requests.post(
+                auth_url,
+                json=auth_payload,
+                headers={"Content-Type": "application/json"},
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully authenticated and got token
+                return None
+            elif response.status_code == 401:
+                return "Authentication failed: invalid client ID or secret"
+            elif response.status_code == 403:
+                return "Access forbidden: check client credentials"
+            elif response.status_code == 400:
+                # Bad request - could be invalid format
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", "Bad request")
+                    return f"Bad request: {error_msg}"
+                except:
+                    return "Bad request: check client ID and secret format"
+            elif response.status_code == 404:
+                return "Xray API endpoint not found: verify the Xray URL"
+            else:
+                return f"Xray API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Xray at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Xray at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Xray: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"

alita_sdk/configurations/zephyr_enterprise.py

@@ -10,7 +10,7 @@ class ZephyrEnterpriseConfiguration(BaseModel):
                 "label": "Zephyr Enterprise",
                 "icon_url": "zephyr.svg",
                 "section": "credentials",
-                "type": "zephyr-enterprise",
+                "type": "zephyr_enterprise",
                 "categories": ["test management"],
                 "extra_categories": ["zephyr", "test automation", "test case management", "test planning"],
             }
@@ -18,3 +18,96 @@ class ZephyrEnterpriseConfiguration(BaseModel):
     )
     base_url: str = Field(description="Zephyr base URL")
     token: Optional[SecretStr] = Field(description="API token")
+
+    @staticmethod
+    def check_connection(settings: dict) -> str | None:
+        """
+        Check the connection to Zephyr Enterprise.
+        
+        Args:
+            settings: Dictionary containing Zephyr Enterprise configuration
+                - base_url: Zephyr Enterprise instance URL (required)
+                - token: API token for authentication (optional, anonymous access possible)
+        
+        Returns:
+            None if connection successful, error message string if failed
+        """
+        import requests
+        
+        # Validate base_url
+        base_url = settings.get("base_url", "").strip()
+        if not base_url:
+            return "Zephyr Enterprise URL is required"
+        
+        # Normalize URL - remove trailing slashes
+        base_url = base_url.rstrip("/")
+        
+        # Basic URL validation
+        if not base_url.startswith(("http://", "https://")):
+            return "Zephyr Enterprise URL must start with http:// or https://"
+        
+        # Get token (optional)
+        token = settings.get("token")
+        
+        # Prepare headers
+        headers = {}
+        has_token = False
+        if token:
+            # Extract token value if it's a SecretStr
+            token_value = token.get_secret_value() if hasattr(token, 'get_secret_value') else token
+            if token_value and str(token_value).strip():
+                headers["Authorization"] = f"Bearer {str(token_value).strip()}"
+                has_token = True
+        
+        # Use different endpoints based on whether authentication is provided
+        # Note: /healthcheck may allow anonymous access, so we use authenticated endpoints when token is provided
+        if has_token:
+            # Test with an endpoint that requires authentication: /flex/services/rest/latest/project
+            # This endpoint lists projects and requires proper authentication
+            test_url = f"{base_url}/flex/services/rest/latest/user/current"
+        else:
+            # Without token, test basic connectivity with healthcheck
+            test_url = f"{base_url}/flex/services/rest/latest/healthcheck"
+        
+        try:
+            response = requests.get(
+                test_url,
+                headers=headers,
+                timeout=10
+            )
+            
+            # Check response status
+            if response.status_code == 200:
+                # Successfully connected
+                return None
+            elif response.status_code == 401:
+                if has_token:
+                    return "Authentication failed: invalid API token"
+                else:
+                    return "Authentication required: provide API token"
+            elif response.status_code == 403:
+                return "Access forbidden: check token permissions"
+            elif response.status_code == 404:
+                # If user endpoint not found, try healthcheck as fallback
+                if has_token:
+                    try:
+                        fallback_url = f"{base_url}/flex/services/rest/latest/healthcheck"
+                        fallback_response = requests.get(fallback_url, headers=headers, timeout=10)
+                        if fallback_response.status_code == 200:
+                            return None
+                    except:
+                        pass
+                return "Zephyr Enterprise API endpoint not found: verify the Zephyr URL"
+            else:
+                return f"Zephyr Enterprise API returned status code {response.status_code}"
+
+        except requests.exceptions.SSLError as e:
+            return f"SSL certificate verification failed: {str(e)}"
+        except requests.exceptions.ConnectionError:
+            return f"Cannot connect to Zephyr Enterprise at {base_url}: connection refused"
+        except requests.exceptions.Timeout:
+            return f"Connection to Zephyr Enterprise at {base_url} timed out"
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to Zephyr Enterprise: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"