clevercloud-storage/tests/test_provider_configuration.py

"""
Tests for the ProviderConfiguration class.
"""

import pytest
from unittest.mock import patch, MagicMock

from clevercloud_storage_framework.provider_configuration import ProviderConfiguration
from clevercloud_storage_framework.exceptions import StorageError, InvalidPathError, ConfigurationPropertyError
from clevercloud_storage_framework.providers.s3_provider import S3StorageProvider
from clevercloud_storage_framework.providers.efs_provider import EFSStorageProvider
from clevercloud_storage_framework.providers.glacier_provider import GlacierStorageProvider
from clevercloud_storage_framework.providers.local_provider import LocalStorageProvider


class TestProviderConfiguration:
    """Tests for the ProviderConfiguration class."""

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_init_valid_provider(self, mock_get_providers):
        """Test initialization with valid provider type."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        
        assert config._provider_type == 's3'
        assert config._target_uri_prefix is None
        assert config._configuration == {}

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_init_invalid_provider(self, mock_get_providers):
        """Test initialization with invalid provider type."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        with pytest.raises(StorageError, match="Unknown provider type: invalid"):
            ProviderConfiguration('invalid')

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_provider_type_for_path')
    def test_init_with_compatible_uri_prefix(self, mock_get_provider_type, mock_get_providers):
        """Test initialization with compatible URI prefix."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        mock_get_provider_type.return_value = 's3'
        
        config = ProviderConfiguration('s3', 's3://bucket/path')
        
        assert config._provider_type == 's3'
        assert config._target_uri_prefix == 's3://bucket/path'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_provider_type_for_path')
    def test_init_with_incompatible_uri_prefix(self, mock_get_provider_type, mock_get_providers):
        """Test initialization with incompatible URI prefix."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        mock_get_provider_type.return_value = 'efs'
        
        with pytest.raises(InvalidPathError, match="Incompatible URI for specified provider type: s3"):
            ProviderConfiguration('s3', 'efs://filesystem/path')

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_region_name_s3(self, mock_get_providers):
        """Test set_region_name for S3 provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        result = config.set_region_name('us-east-1')
        
        assert result is config  # Should return self for chaining
        assert config._configuration['region_name'] == 'us-east-1'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_region_name_efs(self, mock_get_providers):
        """Test set_region_name for EFS provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('efs')
        result = config.set_region_name('us-west-2')
        
        assert result is config
        assert config._configuration['region_name'] == 'us-west-2'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_region_name_glacier(self, mock_get_providers):
        """Test set_region_name for Glacier provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('glacier')
        result = config.set_region_name('us-west-2')
        
        assert result is config
        assert config._configuration['region_name'] == 'us-west-2'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_region_name_local_unsupported(self, mock_get_providers):
        """Test set_region_name for Local provider (unsupported)."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('local')
        
        with pytest.raises(ConfigurationPropertyError, match="Configuration property 'region_name' is unsupported"):
            config.set_region_name('us-east-1')

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_login_s3(self, mock_get_providers):
        """Test set_login for S3 provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        result = config.set_login('access_key', 'secret_key')
        
        assert result is config
        assert config._configuration['aws_access_key_id'] == 'access_key'
        assert config._configuration['aws_secret_access_key'] == 'secret_key'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_login_efs(self, mock_get_providers):
        """Test set_login for EFS provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('efs')
        result = config.set_login('access_key', 'secret_key')
        
        assert result is config
        assert config._configuration['aws_access_key_id'] == 'access_key'
        assert config._configuration['aws_secret_access_key'] == 'secret_key'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_login_glacier(self, mock_get_providers):
        """Test set_login for Glacier provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('glacier')
        result = config.set_login('access_key', 'secret_key')
        
        assert result is config
        assert config._configuration['aws_access_key_id'] == 'access_key'
        assert config._configuration['aws_secret_access_key'] == 'secret_key'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_login_local_unsupported(self, mock_get_providers):
        """Test set_login for Local provider (unsupported)."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('local')
        
        with pytest.raises(ConfigurationPropertyError, match="Configuration property 'login' is unsupported"):
            config.set_login('access_key', 'secret_key')

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_sas_token_s3(self, mock_get_providers):
        """Test set_sas_token for S3 provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        result = config.set_sas_token('sas_token_123')
        
        assert result is config
        assert config._configuration['sas_token'] == 'sas_token_123'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_sas_token_efs_unsupported(self, mock_get_providers):
        """Test set_sas_token for EFS provider (unsupported)."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('efs')
        
        with pytest.raises(ConfigurationPropertyError, match="Configuration property 'sas_token' is unsupported"):
            config.set_sas_token('sas_token_123')

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_mount_point_efs(self, mock_get_providers):
        """Test set_mount_point for EFS provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('efs')
        result = config.set_mount_point('/mnt/efs')
        
        assert result is config
        assert config._configuration['mount_point'] == '/mnt/efs'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_mount_point_s3_unsupported(self, mock_get_providers):
        """Test set_mount_point for S3 provider (unsupported)."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        
        with pytest.raises(ConfigurationPropertyError, match="Configuration property 'mount_point' is unsupported"):
            config.set_mount_point('/mnt/efs')

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_endpoint_url_s3(self, mock_get_providers):
        """Test set_endpoint_url for S3 provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        result = config.set_endpoint_url('https://s3.amazonaws.com')
        
        assert result is config
        assert config._configuration['endpoint_url'] == 'https://s3.amazonaws.com'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_endpoint_url_glacier(self, mock_get_providers):
        """Test set_endpoint_url for Glacier provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('glacier')
        result = config.set_endpoint_url('https://glacier.amazonaws.com')
        
        assert result is config
        assert config._configuration['endpoint_url'] == 'https://glacier.amazonaws.com'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_endpoint_url_efs_unsupported(self, mock_get_providers):
        """Test set_endpoint_url for EFS provider (unsupported)."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('efs')
        
        with pytest.raises(ConfigurationPropertyError, match="Configuration property 'endpoint_url' is unsupported"):
            config.set_endpoint_url('https://s3.amazonaws.com')

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_chunk_size_all_providers(self, mock_get_providers):
        """Test set_chunk_size for all providers (supported by all)."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        for provider_type in ['s3', 'efs', 'local', 'glacier']:
            config = ProviderConfiguration(provider_type)
            result = config.set_chunk_size(1024)
            
            assert result is config
            assert config._configuration['chunk_size'] == 1024

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_poll_interval_glacier(self, mock_get_providers):
        """Test set_poll_interval for Glacier provider."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('glacier')
        result = config.set_poll_interval(30)
        
        assert result is config
        assert config._configuration['poll_interval'] == 30

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_set_poll_interval_s3_unsupported(self, mock_get_providers):
        """Test set_poll_interval for S3 provider (unsupported)."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        
        with pytest.raises(ConfigurationPropertyError, match="Configuration property 'poll_interval' is unsupported"):
            config.set_poll_interval(30)

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_get_provider_type(self, mock_get_providers):
        """Test get_provider_type method."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        assert config.get_provider_type() == 's3'

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_get_config_params(self, mock_get_providers):
        """Test get_config_params method."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        # Create a fresh config for this test
        config = ProviderConfiguration('s3')
        config.set_region_name('us-east-1')
        config.set_login('key', 'secret')
        config.set_chunk_size(1024)
        
        params = config.get_config_params()
        
        expected = {
            'region_name': 'us-east-1',
            'aws_access_key_id': 'key',
            'aws_secret_access_key': 'secret',
            'chunk_size': 1024
        }
        
        assert params == expected
        # Ensure it returns a copy, not the original
        assert params is not config._configuration

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_matches_path_prefix_none(self, mock_get_providers):
        """Test matches_path_prefix when target_uri_prefix is None."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3')
        
        assert config.matches_path_prefix('s3://bucket/key') is True
        assert config.matches_path_prefix('efs://filesystem/path') is False
        assert config.matches_path_prefix(None) is True

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_matches_path_prefix_with_prefix(self, mock_get_providers):
        """Test matches_path_prefix with specific prefix."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3', 's3://bucket/')
        
        assert config.matches_path_prefix('s3://bucket/key') is True
        assert config.matches_path_prefix('s3://bucket/path/file.txt') is True
        assert config.matches_path_prefix('s3://other-bucket/key') is False
        assert config.matches_path_prefix('efs://filesystem/path') is False

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_matches_path_prefix_empty_path(self, mock_get_providers):
        """Test matches_path_prefix with empty path."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('s3', 's3://bucket/')
        
        assert config.matches_path_prefix('') is False
        assert config.matches_path_prefix(None) is False

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_method_chaining(self, mock_get_providers):
        """Test method chaining."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = (ProviderConfiguration('s3')
                  .set_region_name('us-east-1')
                  .set_login('key', 'secret')
                  .set_sas_token('token')
                  .set_chunk_size(2048))
        
        assert config._configuration['region_name'] == 'us-east-1'
        assert config._configuration['aws_access_key_id'] == 'key'
        assert config._configuration['aws_secret_access_key'] == 'secret'
        assert config._configuration['sas_token'] == 'token'
        assert config._configuration['chunk_size'] == 2048

    @patch('clevercloud_storage_framework.factory.StorageClientFactory.get_registered_providers_ids')
    def test_configuration_property_error_provider_type(self, mock_get_providers):
        """Test ConfigurationPropertyError includes provider type."""
        mock_get_providers.return_value = ['s3', 'efs', 'local', 'glacier']
        
        config = ProviderConfiguration('local')
        
        with pytest.raises(ConfigurationPropertyError) as exc_info:
            config.set_region_name('us-east-1')
        
        assert exc_info.value.provider == 'local'