test: implement comprehensive unit test suite and fixtures

- Add `conftest.py` for shared pytest fixtures and global mocks.
- Implement unit tests for RAG processor, LLM handler, and GitHub integration.
- Add coverage for utility functions, data retrieval, and logging.
- Ensure tests run in isolation without external API calls.

Author: Jet Xu

tests/__init__.py

@@ -0,0 +1,2 @@
+# tests/__init__.py
+# Marker file for test package

tests/conftest.py

@@ -0,0 +1,51 @@
+import pytest
+from unittest.mock import MagicMock, AsyncMock
+import sys
+from datetime import datetime, timezone
+
+# Mock external dependencies that might try to connect to internet or load heavy models
+sys.modules['langchain_openai'] = MagicMock()
+sys.modules['langchain_mistralai'] = MagicMock()
+sys.modules['transformers'] = MagicMock()
+sys.modules['sentence_transformers'] = MagicMock()
+
+@pytest.fixture
+def mock_github_instance():
+    """Mocks the ExtendedGithub instance."""
+    mock = MagicMock()
+    mock.get_user.return_value.login = "test_user"
+    return mock
+
+@pytest.fixture
+def mock_repo_object():
+    """Mocks a PyGithub Repository object."""
+    mock_repo = MagicMock()
+    mock_repo.id = 12345
+    mock_repo.name = "test-repo"
+    mock_repo.full_name = "owner/test-repo"
+    mock_repo.description = "A test repository"
+    mock_repo.html_url = "https://github.com/owner/test-repo"
+    mock_repo.stargazers_count = 100
+    mock_repo.subscribers_count = 10
+    mock_repo.language = "Python"
+    mock_repo.default_branch = "main"
+    mock_repo.updated_at = datetime.now(timezone.utc)
+    return mock_repo
+
+@pytest.fixture
+def mock_content_file():
+    """Mocks a PyGithub ContentFile object."""
+    mock_file = MagicMock()
+    mock_file.name = "test.py"
+    mock_file.path = "src/test.py"
+    mock_file.encoding = "base64"
+    mock_file.content = "cHJpbnQoImhlbGxvIik="  # print("hello") in base64
+    mock_file.decoded_content = b'print("hello")'
+    return mock_file
+
+@pytest.fixture
+def mock_llm_handler():
+    """Mocks the LLMHandler."""
+    handler = MagicMock()
+    handler.ainvoke = AsyncMock()
+    return handler

tests/test_data_retrieval.py

@@ -0,0 +1,115 @@
+import pytest
+from unittest.mock import MagicMock, patch, PropertyMock
+from llama_github.data_retrieval.github_api import GitHubAPIHandler
+from llama_github.data_retrieval.github_entities import Repository, RepositoryPool
+
+class TestRepository:
+    def test_repository_initialization(self, mock_github_instance, mock_repo_object):
+        mock_github_instance.get_repo.return_value = mock_repo_object
+        
+        repo = Repository("owner/test-repo", mock_github_instance)
+        
+        assert repo.full_name == "owner/test-repo"
+        assert repo.id == 12345
+        assert repo.language == "Python"
+
+    def test_get_readme_caching(self, mock_github_instance, mock_repo_object):
+        mock_github_instance.get_repo.return_value = mock_repo_object
+        repo = Repository("owner/test-repo", mock_github_instance)
+        
+        # Mock the internal repo object's get_readme
+        mock_readme = MagicMock()
+        mock_readme.decoded_content = b"# Readme"
+        mock_repo_object.get_readme.return_value = mock_readme
+        
+        # First call
+        content1 = repo.get_readme()
+        assert content1 == "# Readme"
+        
+        # Second call should not trigger API
+        content2 = repo.get_readme()
+        assert content2 == "# Readme"
+        assert mock_repo_object.get_readme.call_count == 1
+
+    def test_get_file_content_base64(self, mock_github_instance, mock_repo_object, mock_content_file):
+        mock_github_instance.get_repo.return_value = mock_repo_object
+        mock_repo_object.get_contents.return_value = mock_content_file
+        
+        repo = Repository("owner/test-repo", mock_github_instance)
+        content = repo.get_file_content("src/test.py")
+        
+        assert content == 'print("hello")'
+
+class TestRepositoryPool:
+    def setup_method(self):
+        # Reset singleton for testing
+        RepositoryPool._instance = None
+        RepositoryPool._instance_lock = MagicMock() # Reset lock mock if needed
+
+    def test_singleton_behavior(self, mock_github_instance):
+        pool1 = RepositoryPool(mock_github_instance)
+        pool2 = RepositoryPool(mock_github_instance)
+        assert pool1 is pool2
+
+    def test_get_repository_caching(self, mock_github_instance, mock_repo_object):
+        mock_github_instance.get_repo.return_value = mock_repo_object
+        pool = RepositoryPool(mock_github_instance)
+        
+        repo1 = pool.get_repository("owner/test-repo")
+        repo2 = pool.get_repository("owner/test-repo")
+        
+        assert repo1 is repo2
+        # Ensure we didn't create two Repository objects
+        assert len(pool._pool) == 1
+
+    def test_cleanup_logic(self, mock_github_instance):
+        # This test requires careful mocking of time and threads
+        # We will mock the _cleanup method to avoid thread waiting
+        pool = RepositoryPool(mock_github_instance, cleanup_interval=0.1, max_idle_time=0.1)
+        pool.stop_cleanup() # Stop the real thread immediately
+        
+        # Manually insert an expired repo
+        mock_repo = MagicMock()
+        mock_repo.last_read_time = datetime(2000, 1, 1, tzinfo=timezone.utc)
+        mock_repo.creation_time = datetime(2000, 1, 1, tzinfo=timezone.utc)
+        
+        with pool._registry_lock:
+            pool._pool["expired/repo"] = mock_repo
+            pool._locks_registry["expired/repo"] = MagicMock()
+
+        # Manually invoke cleanup logic once
+        with patch('llama_github.data_retrieval.github_entities.datetime') as mock_dt:
+            mock_dt.now.return_value = datetime(2025, 1, 1, tzinfo=timezone.utc)
+            
+            # Extract the logic from _cleanup loop for testing
+            with pool._registry_lock:
+                current_time = mock_dt.now(timezone.utc)
+                if (current_time - mock_repo.last_read_time).total_seconds() > pool.max_idle_time:
+                    del pool._locks_registry["expired/repo"]
+                    mock_repo.clear_cache()
+        
+        mock_repo.clear_cache.assert_called()
+
+class TestGitHubAPIHandler:
+    def test_search_code_integration(self, mock_github_instance):
+        handler = GitHubAPIHandler(mock_github_instance)
+        
+        # Mock search_code response
+        mock_code_result = MagicMock()
+        mock_code_result.name = "test.py"
+        mock_code_result.path = "test.py"
+        mock_code_result.repository.full_name = "owner/repo"
+        mock_code_result.html_url = "http://url"
+        
+        mock_github_instance.search_code.return_value = [mock_code_result]
+        
+        # Mock RepositoryPool to return a mock repo that returns content
+        with patch.object(handler, 'get_repository') as mock_get_repo:
+            mock_repo = MagicMock()
+            mock_repo.get_file_content.return_value = "content"
+            mock_get_repo.return_value = mock_repo
+            
+            results = handler.search_code("query")
+            
+            assert len(results) == 1
+            assert results[0]['content'] == "content"

tests/test_github_auth_manager.py

@@ -0,0 +1,64 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from llama_github.github_integration.github_auth_manager import GitHubAuthManager, ExtendedGithub
+
+class TestGitHubAuthManager:
+    def setup_method(self):
+        self.auth_manager = GitHubAuthManager()
+
+    @patch('llama_github.github_integration.github_auth_manager.ExtendedGithub')
+    def test_authenticate_with_token(self, mock_extended_github):
+        token = "fake_token"
+        instance = self.auth_manager.authenticate_with_token(token)
+        
+        assert self.auth_manager.access_token == token
+        assert instance == mock_extended_github.return_value
+        mock_extended_github.assert_called_with(login_or_token=token)
+
+    @patch('llama_github.github_integration.github_auth_manager.GithubIntegration')
+    @patch('llama_github.github_integration.github_auth_manager.ExtendedGithub')
+    def test_authenticate_with_app(self, mock_extended_github, mock_integration):
+        # Setup mocks
+        mock_integration_instance = mock_integration.return_value
+        mock_integration_instance.get_access_token.return_value.token = "app_token"
+        
+        instance = self.auth_manager.authenticate_with_app(1, "key", 123)
+        
+        assert self.auth_manager.access_token == "app_token"
+        mock_extended_github.assert_called_with(login_or_token="app_token")
+
+class TestExtendedGithub:
+    @patch('requests.get')
+    def test_get_repo_structure(self, mock_get):
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "tree": [
+                {"path": "folder", "type": "tree"},
+                {"path": "folder/file.py", "type": "blob", "size": 100}
+            ]
+        }
+        mock_get.return_value = mock_response
+
+        gh = ExtendedGithub("token")
+        structure = gh.get_repo_structure("owner/repo")
+
+        assert "folder" in structure
+        assert "file.py" in structure["folder"]["children"]
+        assert structure["folder"]["children"]["file.py"]["size"] == 100
+
+    @patch('requests.Session')
+    def test_search_code_retry_logic(self, mock_session):
+        mock_adapter = MagicMock()
+        mock_session.return_value.mount = MagicMock()
+        
+        gh = ExtendedGithub("token")
+        # We just want to ensure no exception is raised and session is used
+        with patch.object(gh, 'access_token', 'token'):
+             # Mock the get call to raise then succeed or just return
+             mock_session.return_value.get.return_value.status_code = 200
+             mock_session.return_value.get.return_value.json.return_value = {'items': []}
+             
+             result = gh.search_code("query")
+             assert isinstance(result, list)

tests/test_initial_load.py

@@ -0,0 +1,43 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from llama_github.llm_integration.initial_load import LLMManager
+
+@pytest.fixture(autouse=True)
+def reset_singleton():
+    LLMManager._instance = None
+    LLMManager._initialized = False
+    yield
+    LLMManager._instance = None
+
+class TestLLMManager:
+    @patch('llama_github.llm_integration.initial_load.ChatOpenAI')
+    def test_init_openai(self, mock_chat_openai):
+        manager = LLMManager(openai_api_key="sk-test", simple_mode=True)
+        assert manager.model_type == "OpenAI"
+        assert manager.llm is not None
+        mock_chat_openai.assert_called()
+
+    @patch('llama_github.llm_integration.initial_load.AutoTokenizer')
+    @patch('llama_github.llm_integration.initial_load.AutoModel')
+    @patch('llama_github.llm_integration.initial_load.AutoModelForSequenceClassification')
+    def test_init_huggingface_full_mode(self, mock_seq, mock_model, mock_tokenizer):
+        # Mock system checks
+        with patch('sys.platform', 'linux'), \
+             patch('subprocess.run'):
+            
+            manager = LLMManager(
+                open_source_models_hg_dir="/tmp", 
+                simple_mode=False,
+                embedding_model="emb-model",
+                rerank_model="rerank-model"
+            )
+            
+            assert manager.tokenizer is not None
+            assert manager.embedding_model is not None
+            assert manager.rerank_model is not None
+            mock_tokenizer.from_pretrained.assert_called_with("emb-model")
+
+    def test_simple_mode_skips_heavy_models(self):
+        manager = LLMManager(simple_mode=True)
+        assert manager.embedding_model is None
+        assert manager.rerank_model is None

tests/test_llm_handler.py

@@ -0,0 +1,36 @@
+import pytest
+from unittest.mock import MagicMock, AsyncMock
+from llama_github.llm_integration.llm_handler import LLMHandler
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+
+@pytest.mark.asyncio
+async def test_ainvoke_basic():
+    mock_manager = MagicMock()
+    mock_llm = MagicMock()
+    mock_llm.ainvoke = AsyncMock(return_value="AI Response")
+    mock_manager.get_llm.return_value = mock_llm
+    mock_manager.model_type = "OpenAI"
+    
+    handler = LLMHandler(llm_manager=mock_manager)
+    
+    response = await handler.ainvoke("Hello")
+    assert response == "AI Response"
+
+def test_compose_chat_history():
+    handler = LLMHandler(MagicMock())
+    history = ["Hi", "Hello"]
+    messages = handler._compose_chat_history_messages(history)
+    
+    assert len(messages) == 2
+    assert isinstance(messages[0], HumanMessage)
+    assert messages[0].content == "Hi"
+    assert isinstance(messages[1], AIMessage)
+    assert messages[1].content == "Hello"
+
+def test_compose_context_messages():
+    handler = LLMHandler(MagicMock())
+    context = ["ctx1", "ctx2"]
+    messages = handler._compose_context_messages(context)
+    
+    assert len(messages) == 2
+    assert isinstance(messages[0], SystemMessage)

tests/test_logger.py

@@ -0,0 +1,29 @@
+import logging
+import pytest
+from llama_github.logger import configure_logging, logger
+
+def test_configure_logging_defaults():
+    """Test default logging configuration."""
+    # Reset handlers
+    logger.handlers = []
+    
+    configure_logging()
+    
+    assert logger.level == logging.INFO
+    assert len(logger.handlers) == 1
+    assert isinstance(logger.handlers[0], logging.StreamHandler)
+
+def test_configure_logging_custom_level():
+    """Test logging with custom level."""
+    logger.handlers = []
+    configure_logging(level=logging.DEBUG)
+    assert logger.level == logging.DEBUG
+
+def test_configure_logging_custom_handler():
+    """Test logging with a custom handler."""
+    logger.handlers = []
+    custom_handler = logging.NullHandler()
+    configure_logging(handler=custom_handler)
+    
+    assert len(logger.handlers) == 1
+    assert logger.handlers[0] == custom_handler