test_delete_simple.py

#!/usr/bin/env python3
"""
Simplified test script to verify repository deletion functionality.
This version avoids complex dependencies.
"""

import tempfile
from pathlib import Path
from unittest.mock import Mock

from app.models.repository import Repository, RepositoryStorage


def test_repository_storage_deletion():
    """Test repository storage deletion functionality."""
    print("🧪 Testing Repository Storage Deletion\n")

    with tempfile.TemporaryDirectory() as temp_dir:
        storage_path = Path(temp_dir) / "test_repos.json"
        storage = RepositoryStorage(storage_path)

        # Create test repositories
        repos = [
            Repository(
                url="https://github.com/test/repo1.git",
                commit_id="abc123",
                playground_path="/tmp/repo1",
                kg_root_node_id=1,
                kg_max_ast_depth=3,
                kg_chunk_size=1000,
                kg_chunk_overlap=200,
            ),
            Repository(
                url="https://github.com/test/repo1.git",
                commit_id="def456",
                playground_path="/tmp/repo1_v2",
                kg_root_node_id=2,
                kg_max_ast_depth=3,
                kg_chunk_size=1000,
                kg_chunk_overlap=200,
            ),
            Repository(
                url="https://github.com/test/repo2.git",
                commit_id=None,
                playground_path="/tmp/repo2",
                kg_root_node_id=3,
                kg_max_ast_depth=3,
                kg_chunk_size=1000,
                kg_chunk_overlap=200,
            ),
        ]

        # Save all repositories
        for repo in repos:
            storage.save_repository(repo)

        print(f"✓ Created {len(repos)} test repositories")

        # Verify initial state
        all_repos = storage._load_repositories()
        assert len(all_repos) == 3
        print(f"✓ Confirmed {len(all_repos)} repositories in storage")

        # Test 1: Delete specific repository
        print("\n📋 Test 1: Delete specific repository...")
        deleted = storage.delete_repository("https://github.com/test/repo1.git", "abc123")
        assert deleted is True
        print("✓ Successfully deleted repository")

        # Verify deletion
        remaining_repos = storage._load_repositories()
        assert len(remaining_repos) == 2
        print(f"✓ Remaining repositories: {len(remaining_repos)}")

        # Verify specific repo is gone
        deleted_repo = storage.get_repository_by_url_and_commit_id(
            "https://github.com/test/repo1.git", "abc123"
        )
        assert deleted_repo is None
        print("✓ Deleted repository not found in storage")

        # Verify other version still exists
        other_version = storage.get_repository_by_url_and_commit_id(
            "https://github.com/test/repo1.git", "def456"
        )
        assert other_version is not None
        print("✓ Other version of same repository still exists")

        # Test 2: Delete non-existent repository
        print("\n📋 Test 2: Delete non-existent repository...")
        deleted = storage.delete_repository("https://github.com/nonexistent/repo.git", "xyz")
        assert deleted is False
        print("✓ Correctly returned False for non-existent repository")

        # Test 3: Delete repository with None commit_id
        print("\n📋 Test 3: Delete repository with None commit_id...")
        deleted = storage.delete_repository("https://github.com/test/repo2.git", None)
        assert deleted is True
        print("✓ Successfully deleted repository with None commit_id")

        # Verify final state
        final_repos = storage._load_repositories()
        assert len(final_repos) == 1
        assert final_repos[0].commit_id == "def456"
        print(f"✓ Final repository count: {len(final_repos)}")


def test_repository_service_methods():
    """Test repository service deletion methods using mocks."""
    print("\n🧪 Testing Repository Service Methods\n")

    # Mock the complex dependencies
    mock_kg_service = Mock()
    mock_kg_service.clear_kg = Mock()

    # We'll test the logic without actually importing the full service
    # This simulates what the service methods would do

    with tempfile.TemporaryDirectory() as temp_dir:
        temp_path = Path(temp_dir)

        # Create test directory structure
        repo_dirs = [
            temp_path / "repo1",
            temp_path / "repo2",
            temp_path / "repo3",
        ]

        for repo_dir in repo_dirs:
            repo_dir.mkdir(parents=True)
            (repo_dir / "README.md").write_text("# Test")
            (repo_dir / "src").mkdir()
            (repo_dir / "src" / "main.py").write_text("print('test')")

        print(f"✓ Created {len(repo_dirs)} test directories")

        # Test directory cleanup logic
        import shutil

        # Test 1: Remove existing directory
        test_dir = repo_dirs[0]
        assert test_dir.exists()
        shutil.rmtree(test_dir)
        assert not test_dir.exists()
        print("✓ Successfully removed directory and contents")

        # Test 2: Handle non-existent directory (should not raise error)
        try:
            shutil.rmtree(test_dir)  # Already removed
            print("❌ Should have raised an error")
        except FileNotFoundError:
            print("✓ Correctly handled non-existent directory")

        # Test 3: Parent directory cleanup
        nested_dir = temp_path / "nested" / "deep" / "path"
        nested_dir.mkdir(parents=True)
        assert nested_dir.exists()

        # Remove nested directory
        shutil.rmtree(nested_dir)

        # Try to remove parent if empty
        try:
            nested_dir.parent.rmdir()  # Should work if empty
            print("✓ Removed empty parent directory")
        except OSError:
            print("✓ Parent directory not empty (as expected)")


def main():
    """Run all tests."""
    print("🗑️ Testing Repository Deletion Functionality")
    print("=" * 60)

    try:
        test_repository_storage_deletion()
        test_repository_service_methods()

        print("\n" + "=" * 60)
        print("✅ All deletion tests passed!")
        print("\nKey features verified:")
        print("• Repository metadata deletion from JSON storage")
        print("• Handling of different URL + commit_id combinations")
        print("• Support for None commit_id deletion")
        print("• Error handling for non-existent repositories")
        print("• Directory cleanup simulation")
        print("• Parent directory cleanup logic")

        print("\n📋 Deletion workflow summary:")
        print("1. Check if repository exists in metadata")
        print("2. Remove local files and directories")
        print("3. Clean up knowledge graph from Neo4j")
        print("4. Remove metadata from storage")
        print("5. Return success/failure status")

    except Exception as e:
        print(f"\n❌ Test failed: {e}")
        import traceback

        traceback.print_exc()
        return 1

    return 0


if __name__ == "__main__":
    exit(main())