amsdal_cli 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

amsdal_cli/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2023-present
 #
 # SPDX-License-Identifier: AMSDAL End User License Agreement
-__version__ = '0.5.2'
+__version__ = '0.5.4'

amsdal_cli/commands/api_check/command.py

@@ -0,0 +1,118 @@
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from amsdal_cli.app import app
+from amsdal_cli.commands.api_check.config import ApiCheckConfig
+from amsdal_cli.commands.api_check.services.comparison import check
+from amsdal_cli.commands.api_check.services.loader import load_operation_logs
+from amsdal_cli.commands.api_check.services.runner import ApiRunner
+from amsdal_cli.commands.api_check.services.storage import save
+
+
+@app.command(name='api-check')
+def api_check(
+    target_url: str = typer.Argument(  # noqa: B008
+        ...,
+        help='Target API base URL to test',
+    ),
+    config_file: Path = typer.Option(  # noqa: B008
+        Path('api-check-config.json'),
+        '--config',
+        '-c',
+        help='Path to configuration file (YAML or JSON) with test cases and auth settings',
+        exists=True,
+    ),
+    compare_url: Optional[str] = typer.Option(  # noqa: B008
+        None,
+        '--compare-url',
+        help='Second API base URL to compare against',
+    ),
+    compare_logs: Optional[Path] = typer.Option(  # noqa: B008
+        None,
+        '--compare-logs',
+        help='Path to existing logs file to compare against',
+        exists=True,
+    ),
+    output_logs: Optional[Path] = typer.Option(  # noqa: B008
+        None,
+        '--output',
+        '-o',
+        help='Path to save output logs',
+    ),
+) -> None:
+    """
+    Run API tests against target URL and compare results with another endpoint or saved logs.
+
+    The command requires a configuration file (in YAML or JSON format) that defines:
+    - Test cases with inputs and expected outputs
+    - Authentication settings
+    - Endpoints to test
+
+    Authentication can be configured using environment variables:
+    - AMSDAL_API_CHECK_AUTHORIZATION: Authorization token
+    - AMSDAL_API_CHECK_EMAIL: Email for authentication
+    - AMSDAL_API_CHECK_PASSWORD: Password for authentication
+
+    If the token is invalid and no credentials are provided, the command will exit with an error.
+
+    Examples:
+
+    1. Save logs to a file without comparison:
+       ```
+       amsdal api-check https://api.example.com --compare-url https://api.example.com --output logs.json
+       ```
+       This uses the same URL for both target and comparison, which skips the comparison
+       but still runs the API checks and saves the logs.
+
+    2. Compare a URL with previously saved logs:
+       ```
+       amsdal api-check https://api.example.com --compare-logs previous-logs.json
+       ```
+       This runs API checks against the target URL and compares the results with
+       the logs stored in previous-logs.json.
+
+    3. Compare two different URLs:
+       ```
+       amsdal api-check https://api-prod.example.com --compare-url https://api-staging.example.com
+       ```
+       This runs API checks against both URLs and compares the results.
+
+    You can combine these options as needed:
+       ```
+       amsdal api-check https://api-prod.example.com --compare-url https://api-staging.example.com \
+           --output comparison.json
+       ```
+       This compares the two URLs and also saves the logs from the target URL.
+    """
+    if not compare_url and not compare_logs:
+        msg = 'Either --compare-url or --compare-logs must be provided'
+        raise typer.BadParameter(msg)
+
+    if compare_url and compare_logs:
+        msg = 'Cannot use both --compare-url and --compare-logs simultaneously'
+        raise typer.BadParameter(msg)
+
+    # Load configuration using the class method
+    config = ApiCheckConfig.load_from_file(config_file)
+
+    # Create runner with the loaded config
+    target_runner = ApiRunner(target_url, config)
+    target_logs_data = target_runner.run()
+    has_errors = False
+
+    if compare_url != target_url:
+        if compare_url:
+            compare_runner = ApiRunner(compare_url, config)
+            compare_logs_data = compare_runner.run()
+        else:
+            compare_logs_data = load_operation_logs(compare_logs)  # type: ignore[arg-type]
+
+        has_errors = check(target_logs_data, compare_logs_data)
+
+    if output_logs:
+        save(target_logs_data, destination=output_logs)
+
+    if has_errors:
+        raise typer.Exit(code=1)

amsdal_cli/commands/api_check/config.py

@@ -0,0 +1,192 @@
+import json
+import logging
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+from typing import ClassVar
+from typing import Literal
+from typing import Optional
+
+import yaml
+from pydantic import BaseModel
+from pydantic import Field
+
+logger = logging.getLogger(__name__)
+
+
+class TransactionData(BaseModel):
+    transaction_name: str
+    input_params: dict[str, Any] = Field(default_factory=dict)
+    expected_response: Any = None
+
+
+class ApiCheckConfig(BaseModel):
+    # Class variable to store the config file path
+    _config_file: ClassVar[Optional[Path]] = None
+
+    items_per_list: tuple[int, int, int] = (5, 5, 5)
+    headers: dict[str, str] = Field(default_factory=dict)
+    auth_headers: dict[str, str] = Field(default_factory=dict)
+    request_timeout: int = 600
+    extend_output: bool = True
+
+    # Authentication
+    email: Optional[str] = None
+    password: Optional[str] = None
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        Get the token from auth_headers.
+
+        Returns:
+            Optional[str]: The token or None if not set
+        """
+        if not self.auth_headers or 'Authorization' not in self.auth_headers:
+            return None
+
+        return self.auth_headers['Authorization']
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        """
+        Set the token in auth_headers.
+
+        Args:
+            value: The token value
+        """
+        if value is None:
+            if 'Authorization' in self.auth_headers:
+                del self.auth_headers['Authorization']
+        else:
+            self.auth_headers['Authorization'] = value
+
+    @property
+    def token_expiry(self) -> Optional[int]:
+        """
+        Get the token expiry from the token.
+
+        Returns:
+            Optional[int]: The token expiry timestamp, or None if not available
+        """
+        if not self.token:
+            return None
+
+        try:
+            import jwt
+
+            decoded = jwt.decode(self.token, options={'verify_signature': False})
+            return decoded.get('exp')
+        except Exception as e:
+            logger.warning(f'Failed to decode token: {e}')
+            return None
+
+    @property
+    def env_authorization(self) -> Optional[str]:
+        """Get authorization token from environment variable."""
+        return os.environ.get('AMSDAL_API_CHECK_AUTHORIZATION')
+
+    @property
+    def env_email(self) -> Optional[str]:
+        """Get email from environment variable."""
+        return os.environ.get('AMSDAL_API_CHECK_EMAIL')
+
+    @property
+    def env_password(self) -> Optional[str]:
+        """Get password from environment variable."""
+        return os.environ.get('AMSDAL_API_CHECK_PASSWORD')
+
+    @classmethod
+    def load_from_file(cls, config_file: str | Path) -> 'ApiCheckConfig':
+        """
+        Load configuration from a file.
+
+        Args:
+            config_file: Path to the configuration file (YAML or JSON)
+
+        Returns:
+            ApiCheckConfig: The loaded configuration
+        """
+        config_path = Path(config_file)
+
+        try:
+            with open(config_path) as f:
+                # Determine file format based on extension
+                if config_path.suffix.lower() in ['.yaml', '.yml']:
+                    config_raw = yaml.safe_load(f)
+                elif config_path.suffix.lower() == '.json':
+                    config_raw = json.load(f)
+                else:
+                    # Default to YAML if extension is not recognized
+                    config_raw = yaml.safe_load(f)
+
+            # Create config instance
+            config = cls(**config_raw)
+            # Store the config file path
+            cls._config_file = config_path
+
+            logger.info(f'Configuration loaded from {config_path}')
+            return config
+        except Exception as e:
+            logger.error(f'Failed to load configuration from {config_path}: {e}')
+            raise
+
+    def save(self, config_file: Optional[str | Path] = None) -> None:
+        """
+        Save the current configuration to a file.
+
+        Email and password values provided through environment variables
+        (AMSDAL_API_CHECK_EMAIL, AMSDAL_API_CHECK_PASSWORD) will not be saved to the file.
+        Only the token and other configuration values will be persisted.
+
+        Args:
+            config_file: Path to save the configuration to. If not provided,
+                         uses the path from which the config was loaded.
+        """
+        # Use provided path or fall back to the stored path
+        save_path = Path(config_file) if config_file else self.__class__._config_file
+
+        if not save_path:
+            logger.warning('No config file specified, cannot save configuration')
+            return
+
+        try:
+            # Convert config to dict
+            config_dict = self.model_dump()
+
+            # Don't save email and password if they were provided through environment variables
+            if self.env_email and self.email == self.env_email:
+                config_dict.pop('email', None)
+
+            if self.env_password and self.password == self.env_password:
+                config_dict.pop('password', None)
+
+            # No need to handle token and token_expiry as they are now properties
+            # and not included in the model_dump()
+
+            # Write to file
+            with open(save_path, 'w') as f:
+                json.dump(config_dict, f, indent=2)
+
+            logger.info(f'Configuration saved to {save_path}')
+        except Exception as e:
+            logger.error(f'Failed to save configuration: {e}')
+
+    # classes
+    exclude_classes: list[str] | Literal['ALL'] = Field(default_factory=list)
+
+    # objects
+    exclude_objects_for_classes: list[str] = Field(default_factory=list)
+    objects_list_params_options: list[dict[str, Any]] = Field(default_factory=list)
+    object_detail_params_options: list[dict[str, Any]] = Field(default_factory=list)
+    object_write_operations_enabled: bool = Field(default=False)
+    exclude_object_write_operations_for_classes: list[str] = Field(default_factory=list)
+    pre_object_create_hook: Callable[[dict[str, Any]], dict[str, Any]] | dict[str, Any] = Field(default_factory=dict)
+    pre_object_update_hook: Callable[[dict[str, Any]], dict[str, Any]] | dict[str, Any] = Field(default_factory=dict)
+
+    # transactions
+    ignore_transaction_execution_errors: bool = Field(default=True)
+    exclude_transactions: list[str] | Literal['ALL'] = Field(default_factory=list)
+    exclude_execute_transactions: list[str] | Literal['ALL'] = Field(default_factory=list)
+    transactions_data: list[TransactionData] = Field(default_factory=list)

amsdal_cli/commands/api_check/data_classes.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class ClassItem(BaseModel):
+    class_name: str
+    properties: list[dict[str, Any]]
+
+
+class Transaction(BaseModel):
+    title: str
+    properties: dict[str, Any]

amsdal_cli/commands/api_check/operation_log.py

@@ -0,0 +1,78 @@
+import base64
+import json
+import re
+from json import JSONEncoder
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic import Field
+
+
+class BytesJSONEncoder(JSONEncoder):
+    def default(self, o: Any) -> Any:
+        if isinstance(o, bytes):
+            return base64.b64encode(o).decode('utf-8')
+        return super().default(o)
+
+
+class OperationLog(BaseModel):
+    method: str
+    uri: str
+    headers: dict[str, str] = Field(default_factory=dict)
+    params: dict[str, str] | None = None
+    data: Any
+    status_code: int
+    response_data: Any
+    response_headers: dict[str, str] = Field(default_factory=dict)
+
+    @property
+    def id(self) -> str:
+        _params = json.dumps(self.params, cls=BytesJSONEncoder) if self.params else None
+        _data = json.dumps(self.data, cls=BytesJSONEncoder) if self.data else None
+        return f'{self.method} {self.uri} {_params} {_data}'
+
+    def __str__(self) -> str:
+        _response = (
+            json.dumps(self.response_data, cls=BytesJSONEncoder) if not isinstance(self.response_data, str) else None
+        )
+
+        return f'{self.id} {self.status_code} {_response}'
+
+    @classmethod
+    def from_response(
+        cls,
+        response: Any,
+        auth_headers: dict[str, Any] | None = None,
+        *,
+        ignore_object_version: bool = False,
+        ignore_class_version: bool = False,
+    ) -> 'OperationLog':
+        request_headers = {key.lower(): value for key, value in response.request.headers.items()}
+
+        if auth_headers:
+            request_headers.update({key.lower(): '*****' for key in auth_headers})
+
+        return cls(
+            method=response.request.method,
+            uri=response.request.url.path,
+            headers=request_headers,
+            params=dict(response.request.url.params.items()),
+            data=response.request.content,
+            status_code=response.status_code,
+            response_data=cls._process_response_data(
+                response.text,
+                ignore_object_version=ignore_object_version,
+                ignore_class_version=ignore_class_version,
+            ),
+            response_headers=response.headers,
+        )
+
+    @classmethod
+    def _process_response_data(cls, text: str, *, ignore_object_version: bool, ignore_class_version: bool) -> Any:
+        if ignore_object_version:
+            text = re.sub(r'"object_version": "(?!(?:ALL|LATEST)\b).*?"', '"object_version": "ignore"', text)
+
+        if ignore_class_version:
+            text = re.sub(r'"class_version": "(?!(?:ALL|LATEST)\b).*?"', '"class_version": "ignore"', text)
+
+        return text

amsdal_cli/commands/api_check/services/comparison.py

@@ -0,0 +1,47 @@
+import difflib
+
+from rich import print as rprint
+
+from amsdal_cli.commands.api_check.operation_log import OperationLog
+from amsdal_cli.utils.text import rich_error
+from amsdal_cli.utils.text import rich_success
+
+
+def compare(
+    target_logs: list[OperationLog],
+    compare_logs: list[OperationLog],
+) -> tuple[list[tuple[OperationLog, OperationLog]], bool]:
+    diffs: list[tuple[OperationLog, OperationLog]] = []
+    error: bool = False
+    for idx, log in enumerate(target_logs):
+        if idx >= len(compare_logs):
+            rprint(rich_error(f'Not found: {len(target_logs[idx:])}, rest logs: {target_logs[idx:]}'))
+            error = True
+            break
+
+        if log.id != compare_logs[idx].id:
+            rprint(rich_error(f'Log {log.id} != {compare_logs[idx].id}'))
+            error = True
+            break
+
+        if log != compare_logs[idx]:
+            diffs.append((log, compare_logs[idx]))
+    return diffs, error
+
+
+def check(target_logs: list[OperationLog], compare_logs: list[OperationLog]) -> bool:
+    diffs, error = compare(target_logs, compare_logs)
+    if not diffs and not error:
+        rprint(rich_success('No differences found!'))
+        return False
+
+    differ = difflib.Differ()
+
+    rprint(rich_error('Differences found:'))
+    for log, compare_log in diffs:
+        str1 = str(log)
+        str2 = str(compare_log)
+        diff = list(differ.compare(str1.splitlines(), str2.splitlines()))
+        rprint(rich_error('\n'.join(diff)))
+
+    return True

amsdal_cli/commands/api_check/services/data_factory.py

@@ -0,0 +1,158 @@
+import random
+import string
+from typing import Any
+
+from faker import Faker
+
+from amsdal_cli.commands.api_check.data_classes import ClassItem
+
+
+class DataFactory:
+    _faker = Faker()
+
+    @classmethod
+    def build_data(cls, class_item: ClassItem) -> dict[str, Any]:
+        """
+        Build sample data for a class based on its properties.
+
+        Args:
+            class_item: The class item containing property definitions
+
+        Returns:
+            A dictionary with generated data for each property
+        """
+        result = {'_type': class_item.class_name}
+
+        for prop in class_item.properties:
+            prop_name = prop.get('title', '')
+            prop_type = prop.get('type', 'string')
+
+            # Skip if no name
+            if not prop_name:
+                continue
+
+            # Generate value based on type
+            result[prop_name] = cls.generate_value_for_type(prop_type, prop)
+
+        return result
+
+    @classmethod
+    def build_update_data(cls, class_item: ClassItem, data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Build updated data for an existing object.
+
+        Args:
+            class_item: The class item containing property definitions
+            data: The existing data to update
+
+        Returns:
+            A dictionary with updated data
+        """
+        result = {'_type': class_item.class_name}
+
+        # Copy metadata if present
+        if '_metadata' in data:
+            result['_metadata'] = data['_metadata']
+
+        for prop in class_item.properties:
+            prop_name = prop.get('key', '')
+            prop_type = prop.get('type', 'string')
+
+            # Skip if no name
+            if not prop_name:
+                continue
+
+            # For update, we'll modify some values but keep others
+            threshold = 0.5
+            if prop_name in data and random.random() < threshold:  # noqa: S311
+                # Keep 50% of values the same
+                result[prop_name] = data[prop_name]
+            else:
+                # Generate new values for the rest
+                result[prop_name] = cls.generate_value_for_type(prop_type, prop)
+
+        return result
+
+    @classmethod
+    def generate_value_for_type(
+        cls,
+        type_name: str,
+        prop_info: dict[str, Any],
+    ) -> Any:
+        """
+        Generate a random value for a given type.
+
+        Args:
+            type_name: The type of the property
+            prop_info: Additional property information
+
+        Returns:
+            A randomly generated value appropriate for the type
+        """
+        # Check if there's a default value
+        if 'default' in prop_info:
+            return prop_info['default']
+
+        # Generate based on type
+        type_lower = type_name.lower()
+
+        if type_lower == 'string':
+            return cls._faker.text(max_nb_chars=50)
+
+        elif type_lower == 'integer':
+            return cls._faker.random_int(min=1, max=1000)
+
+        elif type_lower == 'number':
+            return cls._faker.pyfloat(positive=True, right_digits=2, max_value=1000)
+
+        elif type_lower == 'boolean':
+            return cls._faker.boolean()
+
+        elif type_lower == 'date':
+            return cls._faker.date_object().isoformat()
+
+        elif type_lower == 'datetime':
+            return cls._faker.date_time().isoformat()
+
+        elif type_lower == 'array':
+            # Check if items type is specified
+            if 'items' in prop_info and prop_info['items'] is not None:
+                items_info = prop_info['items']
+                item_type = items_info.get('type', 'string')
+                # Generate array with proper item types
+                return [
+                    cls.generate_value_for_type(item_type, items_info)
+                    for _ in range(random.randint(1, 3))  # noqa: S311
+                ]
+            else:
+                # Fallback to array of strings if no items info
+                return [cls._faker.word() for _ in range(random.randint(1, 3))]  # noqa: S311
+
+        elif type_lower in {'dictionary', 'object'}:
+            # Check if key and value types are specified
+            if 'items' in prop_info and prop_info['items'] is not None:
+                items_info = prop_info['items']
+                key_info = items_info.get('key', {'type': 'string'})
+                value_info = items_info.get('value', {'type': 'string'})
+
+                # Generate dictionary with proper key and value types
+                result = {}
+                for _ in range(random.randint(1, 3)):  # noqa: S311
+                    # For keys, we need to ensure they're strings or can be converted to strings
+                    key = cls.generate_value_for_type(key_info.get('type', 'string'), key_info)
+                    if not isinstance(key, str):
+                        key = str(key)
+                    value = cls.generate_value_for_type(value_info.get('type', 'string'), value_info)
+                    result[key] = value
+                return result
+            else:
+                # Fallback to dictionary of strings if no items info
+                return {cls._faker.word(): cls._faker.word() for _ in range(random.randint(1, 3))}  # noqa: S311
+
+        elif type_lower == 'binary':
+            # Generate a small binary string
+            return ''.join(random.choice(string.ascii_letters) for _ in range(10))  # noqa: S311
+
+        # For any other type, it might be a reference to another class
+        # For testing purposes, we'll return a dictionary with a _type field
+        return None

amsdal_cli/commands/api_check/services/loader.py

@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+from amsdal_cli.commands.api_check.operation_log import OperationLog
+
+
+def load_operation_logs(logs_path: Path) -> list[OperationLog]:
+    data_str = logs_path.read_text()
+    data_raw = json.loads(data_str)
+
+    return [OperationLog(**item) for item in data_raw]