cookie/cookiecloud_client/tests.py

"""
CookieCloud客户端单元测试
"""
import unittest
from unittest.mock import Mock, patch, MagicMock
import json
from cookiecloud_client import (
    CookieCloudClient,
    CookieConfig,
    CookieCloudError,
    ConfigurationError,
    ConnectionError,
    AuthenticationError,
    DataParseError,
    NetworkError
)


class TestCookieConfig(unittest.TestCase):
    """测试CookieConfig配置类"""
    
    def test_valid_config(self):
        """测试有效配置"""
        config = CookieConfig(
            server="https://example.com",
            username="user",
            password="pass"
        )
        self.assertEqual(config.server, "https://example.com")
        self.assertEqual(config.username, "user")
        self.assertEqual(config.password, "pass")
        self.assertEqual(config.timeout, 30)
        self.assertTrue(config.verify_ssl)
    
    def test_config_with_custom_params(self):
        """测试自定义参数配置"""
        config = CookieConfig(
            server="https://example.com",
            username="user",
            password="pass",
            timeout=60,
            verify_ssl=False,
            ignore_cookies=["test_cookie"]
        )
        self.assertEqual(config.timeout, 60)
        self.assertFalse(config.verify_ssl)
        self.assertEqual(config.ignore_cookies, ["test_cookie"])
    
    def test_config_auto_add_protocol(self):
        """测试自动添加协议"""
        config = CookieConfig(
            server="example.com",
            username="user",
            password="pass"
        )
        self.assertTrue(config.server.startswith("https://"))
    
    def test_config_empty_server(self):
        """测试空服务器地址"""
        with self.assertRaises(ValueError):
            CookieConfig(server="", username="user", password="pass")
    
    def test_config_empty_username(self):
        """测试空用户名"""
        with self.assertRaises(ValueError):
            CookieConfig(server="https://example.com", username="", password="pass")
    
    def test_config_empty_password(self):
        """测试空密码"""
        with self.assertRaises(ValueError):
            CookieConfig(server="https://example.com", username="user", password="")


class TestCookieCloudClient(unittest.TestCase):
    """测试CookieCloudClient客户端类"""
    
    def setUp(self):
        """测试前准备"""
        self.config = CookieConfig(
            server="https://test.example.com",
            username="testuser",
            password="testpass"
        )
        self.client = CookieCloudClient(self.config)
    
    def test_client_initialization(self):
        """测试客户端初始化"""
        self.assertIsInstance(self.client.config, CookieConfig)
        self.assertIsNone(self.client.last_download_time)
        self.assertEqual(self.client.download_count, 0)
    
    def test_client_invalid_config(self):
        """测试无效配置"""
        with self.assertRaises(ConfigurationError):
            CookieCloudClient("invalid_config")
    
    @patch('urllib.request.urlopen')
    def test_download_success(self, mock_urlopen):
        """测试成功下载"""
        mock_response = Mock()
        mock_response.status = 200
        mock_response.read.return_value = json.dumps({
            "cookie_data": {
                "test.com": [
                    {
                        "domain": "test.com",
                        "name": "session",
                        "value": "test_value",
                        "path": "/",
                        "secure": False,
                        "httpOnly": False
                    }
                ]
            }
        }).encode('utf-8')
        mock_urlopen.return_value = mock_response
        
        result = self.client.download()
        
        self.assertTrue(result.success)
        self.assertEqual(result.total_domains, 1)
        self.assertEqual(result.total_cookies, 1)
        self.assertIsNotNone(self.client.last_download_time)
        self.assertEqual(self.client.download_count, 1)
    
    @patch('urllib.request.urlopen')
    def test_download_authentication_error(self, mock_urlopen):
        """测试认证失败"""
        import urllib.error
        
        mock_urlopen.side_effect = urllib.error.HTTPError(
            url="https://test.example.com/get/testuser",
            code=401,
            msg="Unauthorized",
            hdrs={},
            fp=None
        )
        
        with self.assertRaises(AuthenticationError):
            self.client.download()
    
    @patch('urllib.request.urlopen')
    def test_download_connection_error(self, mock_urlopen):
        """测试连接错误"""
        import urllib.error
        
        mock_urlopen.side_effect = urllib.error.HTTPError(
            url="https://test.example.com/get/testuser",
            code=404,
            msg="Not Found",
            hdrs={},
            fp=None
        )
        
        with self.assertRaises(ConnectionError):
            self.client.download()
    
    @patch('urllib.request.urlopen')
    def test_download_network_error(self, mock_urlopen):
        """测试网络错误"""
        import urllib.error
        
        mock_urlopen.side_effect = urllib.error.URLError("Connection refused")
        
        with self.assertRaises(NetworkError):
            self.client.download()
    
    @patch('urllib.request.urlopen')
    def test_download_empty_data(self, mock_urlopen):
        """测试空数据"""
        mock_response = Mock()
        mock_response.status = 200
        mock_response.read.return_value = json.dumps({}).encode('utf-8')
        mock_urlopen.return_value = mock_response
        
        with self.assertRaises(DataParseError):
            self.client.download()
    
    @patch('urllib.request.urlopen')
    def test_test_connection_success(self, mock_urlopen):
        """测试连接测试成功"""
        mock_response = Mock()
        mock_response.status = 200
        mock_response.read.return_value = json.dumps({
            "cookie_data": {}
        }).encode('utf-8')
        mock_urlopen.return_value = mock_response
        
        success, message = self.client.test_connection()
        
        self.assertTrue(success)
        self.assertEqual(message, "连接成功")
    
    @patch('urllib.request.urlopen')
    def test_test_connection_failure(self, mock_urlopen):
        """测试连接测试失败"""
        import urllib.error
        
        mock_urlopen.side_effect = urllib.error.HTTPError(
            url="https://test.example.com/get/testuser",
            code=401,
            msg="Unauthorized",
            hdrs={},
            fp=None
        )
        
        success, message = self.client.test_connection()
        
        self.assertFalse(success)
        self.assertIn("认证失败", message)
    
    @patch('urllib.request.urlopen')
    def test_download_for_domain(self, mock_urlopen):
        """测试下载指定域名"""
        mock_response = Mock()
        mock_response.status = 200
        mock_response.read.return_value = json.dumps({
            "cookie_data": {
                "test.com": [
                    {
                        "domain": "test.com",
                        "name": "session",
                        "value": "test_value",
                        "path": "/",
                        "secure": False,
                        "httpOnly": False
                    }
                ]
            }
        }).encode('utf-8')
        mock_urlopen.return_value = mock_response
        
        cookie_str = self.client.download_for_domain("test.com")
        
        self.assertIsNotNone(cookie_str)
        self.assertIn("session=test_value", cookie_str)
    
    @patch('urllib.request.urlopen')
    def test_download_for_domains(self, mock_urlopen):
        """测试批量下载多个域名"""
        mock_response = Mock()
        mock_response.status = 200
        mock_response.read.return_value = json.dumps({
            "cookie_data": {
                "test1.com": [
                    {"domain": "test1.com", "name": "cookie1", "value": "value1", "path": "/"}
                ],
                "test2.com": [
                    {"domain": "test2.com", "name": "cookie2", "value": "value2", "path": "/"}
                ]
            }
        }).encode('utf-8')
        mock_urlopen.return_value = mock_response
        
        domains = ["test1.com", "test2.com", "test3.com"]
        cookies = self.client.download_for_domains(domains)
        
        self.assertEqual(len(cookies), 3)
        self.assertIn("cookie1=value1", cookies["test1.com"])
        self.assertIn("cookie2=value2", cookies["test2.com"])
        self.assertIsNone(cookies["test3.com"])


class TestExceptions(unittest.TestCase):
    """测试异常类"""
    
    def test_cookie_cloud_error(self):
        """测试基础异常"""
        error = CookieCloudError("测试错误", {"key": "value"})
        self.assertEqual(error.message, "测试错误")
        self.assertEqual(error.details, {"key": "value"})
        self.assertIn("测试错误", str(error))
    
    def test_configuration_error(self):
        """测试配置错误"""
        error = ConfigurationError("配置错误", config_key="server")
        self.assertEqual(error.message, "配置错误")
        self.assertEqual(error.details["config_key"], "server")
    
    def test_connection_error(self):
        """测试连接错误"""
        error = ConnectionError("连接失败", server="example.com", status_code=404)
        self.assertEqual(error.message, "连接失败")
        self.assertEqual(error.details["server"], "example.com")
        self.assertEqual(error.details["status_code"], 404)
    
    def test_authentication_error(self):
        """测试认证错误"""
        error = AuthenticationError("认证失败", username="testuser")
        self.assertEqual(error.message, "认证失败")
        self.assertEqual(error.details["username"], "testuser")


if __name__ == '__main__':
    unittest.main()