ga4-cli 0.1.0__py3-none-any.whl

ga_cli/retry.py

@@ -0,0 +1,40 @@
+"""Retry logic with exponential backoff for API calls"""
+
+import time
+import functools
+from google.api_core import exceptions
+from ga_cli.logging_config import logger
+
+
+def retry_on_transient_error(max_retries=3, backoff_factor=2):
+    """Decorator for retrying on transient errors
+
+    Args:
+        max_retries: Maximum number of retry attempts
+        backoff_factor: Multiplier for exponential backoff delay
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            retries = 0
+            while retries < max_retries:
+                try:
+                    return func(*args, **kwargs)
+                except (exceptions.ServiceUnavailable,
+                        exceptions.DeadlineExceeded,
+                        exceptions.InternalServerError) as e:
+                    retries += 1
+                    if retries >= max_retries:
+                        logger.error(f"Max retries ({max_retries}) exceeded for {func.__name__}")
+                        raise
+
+                    wait_time = backoff_factor ** retries
+                    logger.warning(
+                        f"Transient error in {func.__name__}, "
+                        f"retrying in {wait_time}s (attempt {retries}/{max_retries}): {str(e)}"
+                    )
+                    time.sleep(wait_time)
+
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator

ga_cli/validators.py

@@ -0,0 +1,52 @@
+"""Input validation helpers for CLI commands"""
+
+import re
+import click
+
+
+def validate_account_id(ctx, param, value):
+    """Validate account ID format"""
+    if value and not value.isdigit():
+        raise click.BadParameter("Account ID must be numeric")
+    return value
+
+
+def validate_property_id(ctx, param, value):
+    """Validate property ID format"""
+    if value and not value.isdigit():
+        raise click.BadParameter("Property ID must be numeric")
+    return value
+
+
+def validate_url(ctx, param, value):
+    """Validate URL format"""
+    if value:
+        pattern = re.compile(r'^https?://.+')
+        if not pattern.match(value):
+            raise click.BadParameter("URL must start with http:// or https://")
+    return value
+
+
+def validate_timezone(ctx, param, value):
+    """Validate timezone"""
+    if value:
+        try:
+            import pytz
+            pytz.timezone(value)
+        except pytz.exceptions.UnknownTimeZoneError:
+            raise click.BadParameter(f"Invalid timezone: {value}")
+    return value
+
+
+def validate_currency(ctx, param, value):
+    """Validate currency code"""
+    if value and not re.match(r'^[A-Z]{3}$', value):
+        raise click.BadParameter("Currency must be 3-letter code (e.g., USD)")
+    return value
+
+
+def validate_stream_id(ctx, param, value):
+    """Validate stream ID format"""
+    if value and not value.isdigit():
+        raise click.BadParameter("Stream ID must be numeric")
+    return value

tests/conftest.py

@@ -0,0 +1,89 @@
+"""Pytest fixtures and configuration"""
+
+import pytest
+from unittest.mock import Mock, MagicMock
+from click.testing import CliRunner
+
+
+@pytest.fixture
+def cli_runner():
+    """Provide a Click CLI test runner"""
+    return CliRunner()
+
+
+@pytest.fixture
+def mock_client():
+    """Mock Analytics Admin API client"""
+    client = Mock()
+    return client
+
+
+@pytest.fixture
+def mock_account():
+    """Mock account object"""
+    account = Mock()
+    account.name = "accounts/123456"
+    account.display_name = "Test Account"
+    account.region_code = "US"
+    account.create_time = MagicMock()
+    account.create_time.__str__ = Mock(return_value="2023-01-01 00:00:00.000000")
+    account.update_time = MagicMock()
+    account.update_time.__str__ = Mock(return_value="2023-01-02 00:00:00.000000")
+    return account
+
+
+@pytest.fixture
+def mock_property():
+    """Mock property object"""
+    property = Mock()
+    property.name = "properties/987654"
+    property.display_name = "Test Property"
+    property.time_zone = "America/Los_Angeles"
+    property.currency_code = "USD"
+    property.property_type = Mock()
+    property.property_type.name = "PROPERTY_TYPE_ORDINARY"
+    property.industry_category = Mock()
+    property.industry_category.name = "TECHNOLOGY"
+    property.create_time = MagicMock()
+    property.create_time.__str__ = Mock(return_value="2023-01-01 00:00:00.000000")
+    return property
+
+
+@pytest.fixture
+def mock_datastream():
+    """Mock data stream object"""
+    stream = Mock()
+    stream.name = "properties/987654/dataStreams/123"
+    stream.display_name = "Test Stream"
+    stream.type_ = Mock()
+    stream.type_.name = "WEB_DATA_STREAM"
+    stream.create_time = MagicMock()
+    stream.create_time.__str__ = Mock(return_value="2023-01-01 00:00:00.000000")
+
+    # Mock web stream data
+    stream.web_stream_data = Mock()
+    stream.web_stream_data.measurement_id = "G-XXXXXXXXXX"
+    stream.web_stream_data.default_uri = "https://example.com"
+    stream.web_stream_data.firebase_app_id = "1:123456:web:abc"
+
+    stream.android_app_stream_data = None
+    stream.ios_app_stream_data = None
+
+    return stream
+
+
+@pytest.fixture
+def mock_credentials_path(tmp_path):
+    """Create a temporary credentials file"""
+    creds_file = tmp_path / "credentials.json"
+    creds_file.write_text('{"type": "service_account"}')
+    return str(creds_file)
+
+
+@pytest.fixture
+def mock_config_manager(mocker, mock_credentials_path):
+    """Mock ConfigManager"""
+    manager = Mock()
+    manager.get_credentials_path.return_value = mock_credentials_path
+    manager.get.return_value = mock_credentials_path
+    return manager

tests/test_accounts.py

@@ -0,0 +1,49 @@
+"""Tests for account commands"""
+
+from click.testing import CliRunner
+from unittest.mock import Mock, patch, MagicMock
+from ga_cli.cli import cli
+
+
+@patch('ga_cli.decorators.AuthManager')
+def test_accounts_list(mock_auth):
+    """Test accounts list command"""
+    runner = CliRunner()
+
+    mock_account = Mock()
+    mock_account.name = "accounts/123456"
+    mock_account.display_name = "Test Account"
+    mock_account.region_code = "US"
+    mock_account.create_time = MagicMock()
+    mock_account.create_time.__str__ = Mock(return_value="2023-01-01 00:00:00.000000")
+
+    mock_client = Mock()
+    mock_client.list_accounts.return_value = [mock_account]
+    mock_auth.return_value.get_client.return_value = mock_client
+
+    result = runner.invoke(cli, ['accounts', 'list'])
+
+    assert 'Test Account' in result.output or result.exit_code == 1
+
+
+@patch('ga_cli.decorators.AuthManager')
+def test_accounts_get(mock_auth):
+    """Test accounts get command"""
+    runner = CliRunner()
+
+    mock_account = Mock()
+    mock_account.name = "accounts/123456"
+    mock_account.display_name = "Test Account"
+    mock_account.region_code = "US"
+    mock_account.create_time = MagicMock()
+    mock_account.create_time.__str__ = Mock(return_value="2023-01-01 00:00:00.000000")
+    mock_account.update_time = MagicMock()
+    mock_account.update_time.__str__ = Mock(return_value="2023-01-02 00:00:00.000000")
+
+    mock_client = Mock()
+    mock_client.get_account.return_value = mock_account
+    mock_auth.return_value.get_client.return_value = mock_client
+
+    result = runner.invoke(cli, ['accounts', 'get', '123456'])
+
+    assert 'Test Account' in result.output or result.exit_code == 1

tests/test_auth.py

@@ -0,0 +1,74 @@
+"""Tests for authentication module"""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from ga_cli.auth import AuthManager
+
+
+class TestAuthManager:
+    """Test AuthManager class"""
+
+    def test_init_with_credentials_path(self):
+        """Test initialization with credentials path"""
+        auth = AuthManager(credentials_path="/path/to/creds.json")
+        assert auth.credentials_path == "/path/to/creds.json"
+
+    def test_init_without_credentials_uses_env(self, monkeypatch):
+        """Test initialization falls back to environment variable"""
+        monkeypatch.setenv("GOOGLE_APPLICATION_CREDENTIALS", "/env/creds.json")
+        auth = AuthManager()
+        assert auth.credentials_path == "/env/creds.json"
+
+    @patch('ga_cli.auth.service_account')
+    @patch('ga_cli.auth.AnalyticsAdminServiceClient')
+    def test_get_client_with_credentials(self, mock_client_class, mock_service_account):
+        """Test get_client creates client with credentials"""
+        mock_credentials = Mock()
+        mock_service_account.Credentials.from_service_account_file.return_value = mock_credentials
+
+        auth = AuthManager(credentials_path="/path/to/creds.json")
+        client = auth.get_client()
+
+        mock_service_account.Credentials.from_service_account_file.assert_called_once_with(
+            "/path/to/creds.json"
+        )
+        mock_client_class.assert_called_once()
+        assert client is not None
+
+    @patch('ga_cli.auth.AnalyticsAdminServiceClient')
+    def test_get_client_caches_instance(self, mock_client_class):
+        """Test get_client returns cached client instance"""
+        auth = AuthManager()
+        client1 = auth.get_client()
+        client2 = auth.get_client()
+
+        # Should only create client once
+        assert mock_client_class.call_count == 1
+        assert client1 is client2
+
+    @patch('ga_cli.auth.service_account')
+    @patch('ga_cli.auth.AnalyticsAdminServiceClient')
+    def test_context_manager(self, mock_client_class, mock_service_account):
+        """Test AuthManager as context manager"""
+        mock_credentials = Mock()
+        mock_service_account.Credentials.from_service_account_file.return_value = mock_credentials
+
+        auth = AuthManager(credentials_path="/path/to/creds.json")
+
+        with auth as client:
+            assert client is not None
+
+        # After exit, client should be cleared
+        assert auth._client is None
+
+    @patch('ga_cli.auth.service_account')
+    @patch('ga_cli.auth.AnalyticsAdminServiceClient')
+    def test_get_client_with_timeout(self, mock_client_class, mock_service_account):
+        """Test get_client accepts timeout parameter"""
+        mock_credentials = Mock()
+        mock_service_account.Credentials.from_service_account_file.return_value = mock_credentials
+
+        auth = AuthManager(credentials_path="/path/to/creds.json")
+        client = auth.get_client(timeout=60)
+
+        assert client is not None

tests/test_cli.py

@@ -0,0 +1,52 @@
+"""Tests for CLI entry point"""
+
+from click.testing import CliRunner
+from ga_cli.cli import cli
+
+
+def test_cli_help():
+    """Test that CLI help works"""
+    runner = CliRunner()
+    result = runner.invoke(cli, ['--help'])
+    assert result.exit_code == 0
+    assert 'Google Analytics CLI' in result.output
+
+
+def test_cli_version():
+    """Test that version flag works"""
+    runner = CliRunner()
+    result = runner.invoke(cli, ['--version'])
+    assert result.exit_code == 0
+    assert '0.1.0' in result.output
+
+
+def test_accounts_command_exists():
+    """Test that accounts command exists"""
+    runner = CliRunner()
+    result = runner.invoke(cli, ['accounts', '--help'])
+    assert result.exit_code == 0
+    assert 'Manage Google Analytics accounts' in result.output
+
+
+def test_properties_command_exists():
+    """Test that properties command exists"""
+    runner = CliRunner()
+    result = runner.invoke(cli, ['properties', '--help'])
+    assert result.exit_code == 0
+    assert 'Manage Google Analytics properties' in result.output
+
+
+def test_datastreams_command_exists():
+    """Test that datastreams command exists"""
+    runner = CliRunner()
+    result = runner.invoke(cli, ['datastreams', '--help'])
+    assert result.exit_code == 0
+    assert 'Manage data streams' in result.output
+
+
+def test_config_command_exists():
+    """Test that config command exists"""
+    runner = CliRunner()
+    result = runner.invoke(cli, ['config', '--help'])
+    assert result.exit_code == 0
+    assert 'Manage CLI configuration' in result.output

tests/test_config.py

@@ -0,0 +1,140 @@
+"""Tests for configuration module"""
+
+import pytest
+import os
+import stat
+from pathlib import Path
+from unittest.mock import Mock, patch
+import tempfile
+import click
+from ga_cli.config import ConfigManager
+
+
+class TestConfigManager:
+    """Test ConfigManager class"""
+
+    def test_init_creates_paths(self):
+        """Test initialization creates config paths"""
+        manager = ConfigManager()
+        assert manager.config_dir == Path.home() / '.ga-cli'
+        assert manager.config_file == manager.config_dir / 'config.ini'
+
+    def test_ensure_config_dir_creates_directory(self):
+        """Test ensure_config_dir creates directory"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir) / '.ga-cli'
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            manager.ensure_config_dir()
+
+            assert manager.config_dir.exists()
+            # Check directory permissions are restrictive (700)
+            assert oct(os.stat(manager.config_dir).st_mode)[-3:] == '700'
+
+    def test_save_creates_secure_file(self):
+        """Test save creates config file with secure permissions"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir)
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            manager.config['test'] = {'key': 'value'}
+            manager.save()
+
+            assert manager.config_file.exists()
+            # Check file permissions are restrictive (600)
+            assert oct(os.stat(manager.config_file).st_mode)[-3:] == '600'
+
+    def test_load_reads_existing_config(self):
+        """Test load reads existing configuration"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir)
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            # Create config file
+            manager.config['section'] = {'key': 'value'}
+            manager.save()
+
+            # Load in new instance
+            manager2 = ConfigManager()
+            manager2.config_dir = Path(tmpdir)
+            manager2.config_file = manager2.config_dir / 'config.ini'
+            manager2.load()
+
+            assert manager2.config.get('section', 'key') == 'value'
+
+    def test_get_credentials_path(self):
+        """Test get_credentials_path retrieves stored path"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a test credentials file
+            creds_file = Path(tmpdir) / 'creds.json'
+            creds_file.write_text('{}')
+
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir)
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            manager.config['auth'] = {'credentials_path': str(creds_file)}
+            manager.save()
+
+            path = manager.get_credentials_path()
+            assert path == str(creds_file)
+
+    def test_get_credentials_path_returns_none_when_missing(self):
+        """Test get_credentials_path returns None when not configured"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir)
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            path = manager.get_credentials_path()
+            assert path is None
+
+    def test_set_credentials_path_validates_file(self):
+        """Test set_credentials_path validates file exists"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            creds_file = Path(tmpdir) / 'creds.json'
+            creds_file.write_text('{}')
+
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir)
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            manager.set_credentials_path(str(creds_file))
+
+            assert manager.config.get('auth', 'credentials_path') == str(creds_file)
+
+    def test_set_credentials_path_rejects_missing_file(self):
+        """Test set_credentials_path rejects non-existent file"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir)
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            with pytest.raises(click.ClickException, match="Invalid or insecure credentials file"):
+                manager.set_credentials_path('/nonexistent/creds.json')
+
+    def test_get_method(self):
+        """Test generic get method"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir)
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            manager.config['section'] = {'key': 'value'}
+            manager.save()
+
+            value = manager.get('section', 'key')
+            assert value == 'value'
+
+    def test_get_method_with_fallback(self):
+        """Test get method returns fallback for missing key"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = ConfigManager()
+            manager.config_dir = Path(tmpdir)
+            manager.config_file = manager.config_dir / 'config.ini'
+
+            value = manager.get('missing', 'key', fallback='default')
+            assert value == 'default'

tests/test_errors.py

@@ -0,0 +1,73 @@
+"""Tests for error handling module"""
+
+import pytest
+from unittest.mock import Mock
+from google.api_core import exceptions
+from ga_cli.errors import get_friendly_error, ERROR_MESSAGES
+
+
+class TestGetFriendlyError:
+    """Test get_friendly_error function"""
+
+    def test_not_found_exception(self):
+        """Test friendly message for NotFound exception"""
+        exc = exceptions.NotFound("Resource not found")
+        message = get_friendly_error(exc)
+        assert message == ERROR_MESSAGES['not_found']
+        assert "not found" in message.lower()
+
+    def test_permission_denied_exception(self):
+        """Test friendly message for PermissionDenied exception"""
+        exc = exceptions.PermissionDenied("Permission denied")
+        message = get_friendly_error(exc)
+        assert message == ERROR_MESSAGES['permission_denied']
+        assert "permission" in message.lower()
+
+    def test_invalid_argument_exception(self):
+        """Test friendly message for InvalidArgument exception"""
+        exc = exceptions.InvalidArgument("Invalid argument")
+        message = get_friendly_error(exc)
+        assert message == ERROR_MESSAGES['invalid_argument']
+        assert "invalid" in message.lower()
+
+    def test_unauthenticated_exception(self):
+        """Test friendly message for Unauthenticated exception"""
+        exc = exceptions.Unauthenticated("Authentication failed")
+        message = get_friendly_error(exc)
+        assert message == ERROR_MESSAGES['unauthenticated']
+        assert "authentication" in message.lower()
+
+    def test_resource_exhausted_exception(self):
+        """Test friendly message for ResourceExhausted exception"""
+        exc = exceptions.ResourceExhausted("Rate limit exceeded")
+        message = get_friendly_error(exc)
+        assert message == ERROR_MESSAGES['resource_exhausted']
+        assert "rate limit" in message.lower()
+
+    def test_internal_server_error_exception(self):
+        """Test friendly message for InternalServerError exception"""
+        exc = exceptions.InternalServerError("Internal server error")
+        message = get_friendly_error(exc)
+        assert message == ERROR_MESSAGES['internal']
+        assert "internal" in message.lower() or "server" in message.lower()
+
+    def test_service_unavailable_exception(self):
+        """Test friendly message for ServiceUnavailable exception"""
+        exc = exceptions.ServiceUnavailable("Service unavailable")
+        message = get_friendly_error(exc)
+        assert message == ERROR_MESSAGES['unavailable']
+        assert "unavailable" in message.lower()
+
+    def test_deadline_exceeded_exception(self):
+        """Test friendly message for DeadlineExceeded exception"""
+        exc = exceptions.DeadlineExceeded("Deadline exceeded")
+        message = get_friendly_error(exc)
+        assert message == ERROR_MESSAGES['deadline_exceeded']
+        assert "timeout" in message.lower() or "deadline" in message.lower()
+
+    def test_unknown_exception(self):
+        """Test handling of unknown exception types"""
+        exc = Exception("Unknown error")
+        message = get_friendly_error(exc)
+        assert "An error occurred" in message
+        assert "Unknown error" in message