clevercloud-storage/tests/test_builder.py

"""
Tests for the ProviderBuilder and ProviderDirector classes.
"""

import pytest
from unittest.mock import patch, MagicMock

from clevercloud_storage_framework.builder import ProviderBuilder, ProviderDirector
from clevercloud_storage_framework.providers.s3_provider import S3StorageProvider
from clevercloud_storage_framework.providers.efs_provider import EFSStorageProvider
from clevercloud_storage_framework.providers.local_provider import LocalStorageProvider
from clevercloud_storage_framework.providers.glacier_provider import GlacierStorageProvider


class TestProviderBuilder:
    """Tests for the ProviderBuilder class."""

    def test_init(self):
        """Test ProviderBuilder initialization."""
        builder = ProviderBuilder(S3StorageProvider)
        assert builder._provider_class == S3StorageProvider
        assert builder._config == {}
        assert builder.logger is not None

    def test_with_region(self):
        """Test with_region method."""
        builder = ProviderBuilder(S3StorageProvider)
        result = builder.with_region('us-east-1')
        
        assert result is builder  # Should return self for chaining
        assert builder._config['region_name'] == 'us-east-1'

    def test_with_credentials(self):
        """Test with_credentials method."""
        builder = ProviderBuilder(S3StorageProvider)
        result = builder.with_credentials('access_key', 'secret_key')
        
        assert result is builder  # Should return self for chaining
        assert builder._config['aws_access_key_id'] == 'access_key'
        assert builder._config['aws_secret_access_key'] == 'secret_key'

    def test_with_endpoint(self):
        """Test with_endpoint method."""
        builder = ProviderBuilder(S3StorageProvider)
        result = builder.with_endpoint('https://s3.amazonaws.com')
        
        assert result is builder  # Should return self for chaining
        assert builder._config['endpoint_url'] == 'https://s3.amazonaws.com'

    def test_with_sas_token(self):
        """Test with_sas_token method."""
        builder = ProviderBuilder(S3StorageProvider)
        result = builder.with_sas_token('sas_token_123')
        
        assert result is builder  # Should return self for chaining
        assert builder._config['sas_token'] == 'sas_token_123'

    def test_with_chunk_size(self):
        """Test with_chunk_size method."""
        builder = ProviderBuilder(LocalStorageProvider)
        result = builder.with_chunk_size(1024)
        
        assert result is builder  # Should return self for chaining
        assert builder._config['chunk_size'] == 1024

    def test_with_mount_point(self):
        """Test with_mount_point method."""
        builder = ProviderBuilder(EFSStorageProvider)
        result = builder.with_mount_point('/mnt/efs')
        
        assert result is builder  # Should return self for chaining
        assert builder._config['mount_point'] == '/mnt/efs'

    def test_with_config(self):
        """Test with_config method."""
        builder = ProviderBuilder(S3StorageProvider)
        result = builder.with_config(custom_param='value', another_param=123)
        
        assert result is builder  # Should return self for chaining
        assert builder._config['custom_param'] == 'value'
        assert builder._config['another_param'] == 123

    def test_with_config_updates_existing(self):
        """Test that with_config updates existing config."""
        builder = ProviderBuilder(S3StorageProvider)
        builder.with_region('us-west-2')
        builder.with_config(region_name='us-east-1', new_param='test')
        
        assert builder._config['region_name'] == 'us-east-1'  # Should be updated
        assert builder._config['new_param'] == 'test'

    def test_method_chaining(self):
        """Test method chaining."""
        builder = ProviderBuilder(S3StorageProvider)
        result = (builder
                  .with_region('us-east-1')
                  .with_credentials('key', 'secret')
                  .with_endpoint('https://s3.amazonaws.com')
                  .with_sas_token('token')
                  .with_chunk_size(2048)
                  .with_config(custom='value'))
        
        assert result is builder
        assert builder._config['region_name'] == 'us-east-1'
        assert builder._config['aws_access_key_id'] == 'key'
        assert builder._config['aws_secret_access_key'] == 'secret'
        assert builder._config['endpoint_url'] == 'https://s3.amazonaws.com'
        assert builder._config['sas_token'] == 'token'
        assert builder._config['chunk_size'] == 2048
        assert builder._config['custom'] == 'value'

    def test_build_success(self):
        """Test successful build."""
        builder = ProviderBuilder(S3StorageProvider)
        builder.with_region('us-east-1')
        builder.with_credentials('key', 'secret')
        
        result = builder.build()
        
        assert isinstance(result, S3StorageProvider)
        # The actual provider will be created with the config, we just verify it's the right type

    def test_build_failure(self):
        """Test build failure with exception."""
        # Create a mock provider class that raises an exception
        class FailingProvider:
            def __init__(self, **kwargs):
                raise ValueError("Invalid configuration")
        
        builder = ProviderBuilder(FailingProvider)
        builder.with_region('invalid-region')
        
        with pytest.raises(ValueError, match="Invalid configuration"):
            builder.build()

    def test_build_empty_config(self):
        """Test build with empty configuration."""
        builder = ProviderBuilder(S3StorageProvider)
        result = builder.build()
        
        assert isinstance(result, S3StorageProvider)


class TestProviderDirector:
    """Tests for the ProviderDirector class."""

    @patch('clevercloud_storage_framework.providers.s3_provider.S3StorageProvider')
    def test_create_s3_provider_minimal(self, mock_provider_class):
        """Test creating S3 provider with minimal configuration."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_s3_provider()
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with()

    @patch('clevercloud_storage_framework.providers.s3_provider.S3StorageProvider')
    def test_create_s3_provider_with_region(self, mock_provider_class):
        """Test creating S3 provider with region."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_s3_provider(region_name='us-west-2')
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(region_name='us-west-2')

    @patch('clevercloud_storage_framework.providers.s3_provider.S3StorageProvider')
    def test_create_s3_provider_with_credentials(self, mock_provider_class):
        """Test creating S3 provider with credentials."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_s3_provider(
            aws_access_key_id='key',
            aws_secret_access_key='secret'
        )
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(
            aws_access_key_id='key',
            aws_secret_access_key='secret'
        )

    @patch('clevercloud_storage_framework.providers.s3_provider.S3StorageProvider')
    def test_create_s3_provider_with_endpoint(self, mock_provider_class):
        """Test creating S3 provider with endpoint."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_s3_provider(endpoint_url='https://custom-s3.com')
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(endpoint_url='https://custom-s3.com')

    @patch('clevercloud_storage_framework.providers.s3_provider.S3StorageProvider')
    def test_create_s3_provider_with_sas_token(self, mock_provider_class):
        """Test creating S3 provider with SAS token."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_s3_provider(sas_token='sas_token_123')
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(sas_token='sas_token_123')

    @patch('clevercloud_storage_framework.providers.s3_provider.S3StorageProvider')
    def test_create_s3_provider_full_config(self, mock_provider_class):
        """Test creating S3 provider with full configuration."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_s3_provider(
            region_name='us-east-1',
            aws_access_key_id='key',
            aws_secret_access_key='secret',
            endpoint_url='https://s3.amazonaws.com',
            sas_token='token'
        )
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(
            region_name='us-east-1',
            aws_access_key_id='key',
            aws_secret_access_key='secret',
            endpoint_url='https://s3.amazonaws.com',
            sas_token='token'
        )

    @patch('clevercloud_storage_framework.providers.efs_provider.EFSStorageProvider')
    def test_create_efs_provider_minimal(self, mock_provider_class):
        """Test creating EFS provider with minimal configuration."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_efs_provider()
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with()

    @patch('clevercloud_storage_framework.providers.efs_provider.EFSStorageProvider')
    def test_create_efs_provider_with_region(self, mock_provider_class):
        """Test creating EFS provider with region."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_efs_provider(region_name='us-west-2')
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(region_name='us-west-2')

    @patch('clevercloud_storage_framework.providers.efs_provider.EFSStorageProvider')
    def test_create_efs_provider_with_credentials(self, mock_provider_class):
        """Test creating EFS provider with credentials."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_efs_provider(
            aws_access_key_id='key',
            aws_secret_access_key='secret'
        )
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(
            aws_access_key_id='key',
            aws_secret_access_key='secret'
        )

    @patch('clevercloud_storage_framework.providers.efs_provider.EFSStorageProvider')
    def test_create_efs_provider_with_mount_point(self, mock_provider_class):
        """Test creating EFS provider with mount point."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_efs_provider(mount_point='/mnt/efs')
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(mount_point='/mnt/efs')

    @patch('clevercloud_storage_framework.providers.efs_provider.EFSStorageProvider')
    def test_create_efs_provider_full_config(self, mock_provider_class):
        """Test creating EFS provider with full configuration."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_efs_provider(
            region_name='us-east-1',
            aws_access_key_id='key',
            aws_secret_access_key='secret',
            mount_point='/mnt/efs'
        )
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(
            region_name='us-east-1',
            aws_access_key_id='key',
            aws_secret_access_key='secret',
            mount_point='/mnt/efs'
        )

    @patch('clevercloud_storage_framework.providers.local_provider.LocalStorageProvider')
    def test_create_local_provider_default(self, mock_provider_class):
        """Test creating local provider with default configuration."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_local_provider()
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(chunk_size=8 * 1024 * 1024)

    @patch('clevercloud_storage_framework.providers.local_provider.LocalStorageProvider')
    def test_create_local_provider_custom_chunk_size(self, mock_provider_class):
        """Test creating local provider with custom chunk size."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_local_provider(chunk_size=4096)
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(chunk_size=4096)

    @patch('clevercloud_storage_framework.providers.glacier_provider.GlacierStorageProvider')
    def test_create_glacier_provider_minimal(self, mock_provider_class):
        """Test creating Glacier provider with minimal configuration."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_glacier_provider()
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with()

    @patch('clevercloud_storage_framework.providers.glacier_provider.GlacierStorageProvider')
    def test_create_glacier_provider_with_region(self, mock_provider_class):
        """Test creating Glacier provider with region."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_glacier_provider(region_name='us-west-2')
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(region_name='us-west-2')

    @patch('clevercloud_storage_framework.providers.glacier_provider.GlacierStorageProvider')
    def test_create_glacier_provider_with_credentials(self, mock_provider_class):
        """Test creating Glacier provider with credentials."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_glacier_provider(
            aws_access_key_id='key',
            aws_secret_access_key='secret'
        )
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(
            aws_access_key_id='key',
            aws_secret_access_key='secret'
        )

    @patch('clevercloud_storage_framework.providers.glacier_provider.GlacierStorageProvider')
    def test_create_glacier_provider_full_config(self, mock_provider_class):
        """Test creating Glacier provider with full configuration."""
        mock_provider_instance = MagicMock()
        mock_provider_class.return_value = mock_provider_instance
        
        result = ProviderDirector.create_glacier_provider(
            region_name='us-east-1',
            aws_access_key_id='key',
            aws_secret_access_key='secret'
        )
        
        assert result == mock_provider_instance
        mock_provider_class.assert_called_once_with(
            region_name='us-east-1',
            aws_access_key_id='key',
            aws_secret_access_key='secret'
        )

    def test_create_s3_provider_partial_credentials(self):
        """Test that S3 provider is not created with only one credential."""
        # This should not call the provider constructor with credentials
        with patch('clevercloud_storage_framework.providers.s3_provider.S3StorageProvider') as mock_provider_class:
            mock_provider_instance = MagicMock()
            mock_provider_class.return_value = mock_provider_instance
            
            result = ProviderDirector.create_s3_provider(aws_access_key_id='key')
            
            assert result == mock_provider_instance
            mock_provider_class.assert_called_once_with()  # No credentials passed

    def test_create_efs_provider_partial_credentials(self):
        """Test that EFS provider is not created with only one credential."""
        # This should not call the provider constructor with credentials
        with patch('clevercloud_storage_framework.providers.efs_provider.EFSStorageProvider') as mock_provider_class:
            mock_provider_instance = MagicMock()
            mock_provider_class.return_value = mock_provider_instance
            
            result = ProviderDirector.create_efs_provider(aws_access_key_id='key')
            
            assert result == mock_provider_instance
            mock_provider_class.assert_called_once_with()  # No credentials passed

    def test_create_glacier_provider_partial_credentials(self):
        """Test that Glacier provider is not created with only one credential."""
        # This should not call the provider constructor with credentials
        with patch('clevercloud_storage_framework.providers.glacier_provider.GlacierStorageProvider') as mock_provider_class:
            mock_provider_instance = MagicMock()
            mock_provider_class.return_value = mock_provider_instance
            
            result = ProviderDirector.create_glacier_provider(aws_access_key_id='key')
            
            assert result == mock_provider_instance
            mock_provider_class.assert_called_once_with()  # No credentials passed