Upload 2 files

test_community_tab.py

@@ -0,0 +1,266 @@
+import unittest
+import os
+import sys
+import json
+from unittest.mock import patch, MagicMock
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import modules to test
+from model_config import ModelConfigManager
+
+class MockDB:
+    """Mock database for testing."""
+    
+    def __init__(self):
+        self.configs = {}
+        
+    def get_config(self, config_id):
+        return self.configs.get(config_id)
+        
+    def add_config(self, config_id, config):
+        self.configs[config_id] = config
+        return config_id
+
+class TestModelConfigManager(unittest.TestCase):
+    """Test the ModelConfigManager class."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.db = MockDB()
+        self.config_dir = "test_model_configs"
+        
+        # Create test directory
+        os.makedirs(self.config_dir, exist_ok=True)
+        
+        # Create a test instance with the test directory
+        self.manager = ModelConfigManager(self.db)
+        self.manager.config_dir = self.config_dir
+        
+    def tearDown(self):
+        """Clean up after tests."""
+        # Remove test files
+        for filename in os.listdir(self.config_dir):
+            file_path = os.path.join(self.config_dir, filename)
+            if os.path.isfile(file_path):
+                os.unlink(file_path)
+        
+        # Remove test directory
+        os.rmdir(self.config_dir)
+    
+    def test_initialize_default_configs(self):
+        """Test _initialize_default_configs method."""
+        # Check that default configs are created
+        self.manager._initialize_default_configs()
+        
+        # Verify files exist
+        for model_type in self.manager.default_configs:
+            config_path = os.path.join(self.config_dir, f"{model_type}.json")
+            self.assertTrue(os.path.exists(config_path))
+            
+            # Verify content
+            with open(config_path, "r") as f:
+                config = json.load(f)
+            
+            self.assertEqual(config["name"], self.manager.default_configs[model_type]["name"])
+            self.assertEqual(config["description"], self.manager.default_configs[model_type]["description"])
+            self.assertEqual(config["parameters"], self.manager.default_configs[model_type]["parameters"])
+    
+    def test_get_available_configs(self):
+        """Test get_available_configs method."""
+        # Create test configs
+        test_configs = {
+            "test1": {
+                "name": "Test Config 1",
+                "description": "Test description 1",
+                "parameters": {"temperature": 0.7}
+            },
+            "test2": {
+                "name": "Test Config 2",
+                "description": "Test description 2",
+                "parameters": {"temperature": 0.8}
+            }
+        }
+        
+        for config_id, config in test_configs.items():
+            config_path = os.path.join(self.config_dir, f"{config_id}.json")
+            with open(config_path, "w") as f:
+                json.dump(config, f)
+        
+        # Get configs
+        configs = self.manager.get_available_configs()
+        
+        # Verify results
+        self.assertEqual(len(configs), 2)
+        
+        # Check that IDs are added
+        config_ids = [config["id"] for config in configs]
+        self.assertIn("test1", config_ids)
+        self.assertIn("test2", config_ids)
+        
+        # Check content
+        for config in configs:
+            test_config = test_configs[config["id"]]
+            self.assertEqual(config["name"], test_config["name"])
+            self.assertEqual(config["description"], test_config["description"])
+            self.assertEqual(config["parameters"], test_config["parameters"])
+    
+    def test_get_config(self):
+        """Test get_config method."""
+        # Create test config
+        config = {
+            "name": "Test Config",
+            "description": "Test description",
+            "parameters": {"temperature": 0.7}
+        }
+        
+        config_path = os.path.join(self.config_dir, "test.json")
+        with open(config_path, "w") as f:
+            json.dump(config, f)
+        
+        # Get config
+        result = self.manager.get_config("test")
+        
+        # Verify result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["id"], "test")
+        self.assertEqual(result["name"], config["name"])
+        self.assertEqual(result["description"], config["description"])
+        self.assertEqual(result["parameters"], config["parameters"])
+        
+        # Test non-existent config
+        result = self.manager.get_config("nonexistent")
+        self.assertIsNone(result)
+    
+    def test_add_config(self):
+        """Test add_config method."""
+        # Add config
+        name = "Test Config"
+        description = "Test description"
+        parameters = {"temperature": 0.7, "top_k": 50}
+        
+        config_id = self.manager.add_config(name, description, parameters)
+        
+        # Verify result
+        self.assertIsNotNone(config_id)
+        self.assertEqual(config_id, "test_config")
+        
+        # Verify file exists
+        config_path = os.path.join(self.config_dir, f"{config_id}.json")
+        self.assertTrue(os.path.exists(config_path))
+        
+        # Verify content
+        with open(config_path, "r") as f:
+            config = json.load(f)
+        
+        self.assertEqual(config["name"], name)
+        self.assertEqual(config["description"], description)
+        self.assertEqual(config["parameters"], parameters)
+    
+    def test_update_config(self):
+        """Test update_config method."""
+        # Create test config
+        config = {
+            "name": "Test Config",
+            "description": "Test description",
+            "parameters": {"temperature": 0.7}
+        }
+        
+        config_path = os.path.join(self.config_dir, "test.json")
+        with open(config_path, "w") as f:
+            json.dump(config, f)
+        
+        # Update config
+        new_name = "Updated Config"
+        new_description = "Updated description"
+        new_parameters = {"temperature": 0.8, "top_k": 60}
+        
+        success = self.manager.update_config("test", new_name, new_description, new_parameters)
+        
+        # Verify result
+        self.assertTrue(success)
+        
+        # Verify content
+        with open(config_path, "r") as f:
+            updated_config = json.load(f)
+        
+        self.assertEqual(updated_config["name"], new_name)
+        self.assertEqual(updated_config["description"], new_description)
+        self.assertEqual(updated_config["parameters"], new_parameters)
+        
+        # Test updating non-existent config
+        success = self.manager.update_config("nonexistent", "New Name", "New Description", {})
+        self.assertFalse(success)
+    
+    def test_delete_config(self):
+        """Test delete_config method."""
+        # Create test config
+        config = {
+            "name": "Test Config",
+            "description": "Test description",
+            "parameters": {"temperature": 0.7}
+        }
+        
+        config_path = os.path.join(self.config_dir, "test.json")
+        with open(config_path, "w") as f:
+            json.dump(config, f)
+        
+        # Delete config
+        success = self.manager.delete_config("test")
+        
+        # Verify result
+        self.assertTrue(success)
+        self.assertFalse(os.path.exists(config_path))
+        
+        # Test deleting non-existent config
+        success = self.manager.delete_config("nonexistent")
+        self.assertFalse(success)
+        
+        # Test deleting default config
+        for model_type in self.manager.default_configs:
+            config_path = os.path.join(self.config_dir, f"{model_type}.json")
+            with open(config_path, "w") as f:
+                json.dump(self.manager.default_configs[model_type], f)
+            
+            success = self.manager.delete_config(model_type)
+            self.assertFalse(success)
+            self.assertTrue(os.path.exists(config_path))
+    
+    def test_apply_config_to_model_params(self):
+        """Test apply_config_to_model_params method."""
+        # Create test config
+        config = {
+            "name": "Test Config",
+            "description": "Test description",
+            "parameters": {
+                "temperature": 0.7,
+                "top_k": 50,
+                "top_p": 0.9
+            }
+        }
+        
+        config_path = os.path.join(self.config_dir, "test.json")
+        with open(config_path, "w") as f:
+            json.dump(config, f)
+        
+        # Apply config
+        model_params = {
+            "temperature": 0.5,
+            "max_length": 100
+        }
+        
+        result = self.manager.apply_config_to_model_params(model_params, "test")
+        
+        # Verify result
+        self.assertEqual(result["temperature"], 0.7)
+        self.assertEqual(result["top_k"], 50)
+        self.assertEqual(result["top_p"], 0.9)
+        self.assertEqual(result["max_length"], 100)
+        
+        # Test with non-existent config
+        result = self.manager.apply_config_to_model_params(model_params, "nonexistent")
+        self.assertEqual(result, model_params)
+
+if __name__ == '__main__':
+    unittest.main()

test_login.py

@@ -0,0 +1,180 @@
+import unittest
+import os
+import sys
+import json
+from unittest.mock import patch, MagicMock
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import modules to test
+from auth import HuggingFaceAuth
+
+class MockDB:
+    """Mock database for testing."""
+    
+    def __init__(self):
+        self.users = {}
+        
+    def add_user(self, username, hf_user_id, is_admin=False):
+        user_id = len(self.users) + 1
+        self.users[hf_user_id] = {
+            'id': user_id,
+            'username': username,
+            'hf_user_id': hf_user_id,
+            'is_admin': is_admin
+        }
+        return user_id
+        
+    def get_user(self, hf_user_id):
+        return self.users.get(hf_user_id)
+        
+    def get_user_by_username(self, username):
+        for user in self.users.values():
+            if user['username'] == username:
+                return user
+        return None
+        
+    def can_submit_today(self, user_id):
+        return True
+        
+    def update_submission_date(self, user_id):
+        pass
+
+class MockRequest:
+    """Mock Gradio request for testing."""
+    
+    def __init__(self, headers=None, cookies=None):
+        self.headers = headers or {}
+        self.cookies = cookies or {}
+
+class TestHuggingFaceAuth(unittest.TestCase):
+    """Test the HuggingFaceAuth class."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.db = MockDB()
+        
+        # Set environment variables for testing
+        os.environ['SPACE_ID'] = 'test_space'
+        os.environ['OAUTH_CLIENT_ID'] = 'test_client_id'
+        os.environ['OAUTH_CLIENT_SECRET'] = 'test_client_secret'
+        os.environ['OAUTH_SCOPES'] = 'openid profile'
+        os.environ['OPENID_PROVIDER_URL'] = 'https://huggingface.co'
+        
+        self.auth = HuggingFaceAuth(self.db)
+        
+    def tearDown(self):
+        """Clean up after tests."""
+        # Remove environment variables
+        for var in ['SPACE_ID', 'OAUTH_CLIENT_ID', 'OAUTH_CLIENT_SECRET', 'OAUTH_SCOPES', 'OPENID_PROVIDER_URL']:
+            if var in os.environ:
+                del os.environ[var]
+    
+    def test_init(self):
+        """Test initialization."""
+        self.assertEqual(self.auth.admin_username, 'Quazim0t0')
+        self.assertTrue(self.auth.running_in_space)
+        self.assertEqual(self.auth.client_id, 'test_client_id')
+        self.assertEqual(self.auth.client_secret, 'test_client_secret')
+        self.assertEqual(self.auth.oauth_scopes, 'openid profile')
+        self.assertEqual(self.auth.openid_provider_url, 'https://huggingface.co')
+    
+    @patch('auth.HfApi')
+    def test_login_user(self, mock_hf_api):
+        """Test login_user method."""
+        # Mock HfApi.whoami
+        mock_instance = mock_hf_api.return_value
+        mock_instance.whoami.return_value = {
+            'id': 'test_user_id',
+            'name': 'Test User'
+        }
+        
+        # Test successful login
+        user = self.auth.login_user('test_token')
+        self.assertIsNotNone(user)
+        self.assertEqual(user['username'], 'Test User')
+        self.assertEqual(user['hf_user_id'], 'test_user_id')
+        self.assertEqual(user['token'], 'test_token')
+        
+        # Test admin login
+        mock_instance.whoami.return_value = {
+            'id': 'admin_user_id',
+            'name': 'Quazim0t0'
+        }
+        user = self.auth.login_user('admin_token')
+        self.assertIsNotNone(user)
+        self.assertEqual(user['username'], 'Quazim0t0')
+        self.assertTrue(user['is_admin'])
+        
+        # Test failed login
+        mock_instance.whoami.return_value = None
+        user = self.auth.login_user('invalid_token')
+        self.assertIsNone(user)
+    
+    def test_check_login_space_oauth(self):
+        """Test check_login method with Space OAuth."""
+        # Test with HF-User header
+        request = MockRequest(headers={'HF-User': 'Test User'})
+        user = self.auth.check_login(request)
+        self.assertIsNotNone(user)
+        self.assertEqual(user['username'], 'Test User')
+        
+        # Test with admin username
+        request = MockRequest(headers={'HF-User': 'Quazim0t0'})
+        user = self.auth.check_login(request)
+        self.assertIsNotNone(user)
+        self.assertEqual(user['username'], 'Quazim0t0')
+        self.assertTrue(user['is_admin'])
+    
+    @patch('auth.HfApi')
+    def test_check_login_token(self, mock_hf_api):
+        """Test check_login method with token."""
+        # Remove SPACE_ID to test token-based auth
+        del os.environ['SPACE_ID']
+        self.auth.running_in_space = False
+        
+        # Mock HfApi.whoami
+        mock_instance = mock_hf_api.return_value
+        mock_instance.whoami.return_value = {
+            'id': 'test_user_id',
+            'name': 'Test User'
+        }
+        
+        # Add user to database
+        self.db.add_user('Test User', 'test_user_id')
+        
+        # Test with token in cookie
+        request = MockRequest(cookies={'hf_token': 'test_token'})
+        user = self.auth.check_login(request)
+        self.assertIsNotNone(user)
+        self.assertEqual(user['hf_user_id'], 'test_user_id')
+        
+        # Test with token in header
+        request = MockRequest(headers={'HF-Token': 'test_token'})
+        user = self.auth.check_login(request)
+        self.assertIsNotNone(user)
+        self.assertEqual(user['hf_user_id'], 'test_user_id')
+        
+        # Test with invalid token
+        mock_instance.whoami.return_value = None
+        request = MockRequest(cookies={'hf_token': 'invalid_token'})
+        user = self.auth.check_login(request)
+        self.assertIsNone(user)
+    
+    def test_get_oauth_login_url(self):
+        """Test get_oauth_login_url method."""
+        # Test with default redirect URI
+        url = self.auth.get_oauth_login_url()
+        self.assertIsNotNone(url)
+        self.assertIn('client_id=test_client_id', url)
+        self.assertIn('scope=openid%20profile', url)
+        self.assertIn('response_type=code', url)
+        
+        # Test with custom redirect URI
+        url = self.auth.get_oauth_login_url('https://example.com/callback')
+        self.assertIsNotNone(url)
+        self.assertIn('redirect_uri=https://example.com/callback', url)
+
+if __name__ == '__main__':
+    unittest.main()