test: Add comprehensive test suite for database functionality

- Add unit tests for database operations and optimization
- Test external data source loading and caching
- Add callsign manager functionality tests
- Create test helpers for database testing utilities
- Ensure database reliability and performance validation

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

internal/database/loader_test.go

@@ -0,0 +1,177 @@
+package database
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDataLoader_Creation(t *testing.T) {
+	db, cleanup := setupTestDatabase(t)
+	defer cleanup()
+
+	loader := NewDataLoader(db.GetConnection())
+	if loader == nil {
+		t.Fatal("NewDataLoader returned nil")
+	}
+}
+
+func TestDataLoader_LoadOpenFlightsAirlines(t *testing.T) {
+	db, cleanup := setupTestDatabase(t)
+	defer cleanup()
+
+	loader := NewDataLoader(db.GetConnection())
+
+	// Create a test data source for OpenFlights Airlines
+	source := DataSource{
+		Name:    "OpenFlights Airlines Test",
+		License: "ODbL 1.0",
+		URL:     "https://raw.githubusercontent.com/jpatokal/openflights/master/data/airlines.dat",
+		Format:  "openflights",
+		Version: "2024-test",
+	}
+
+	result, err := loader.LoadDataSource(source)
+	if err != nil {
+		// Network issues in tests are acceptable
+		if strings.Contains(err.Error(), "connection") || 
+		   strings.Contains(err.Error(), "timeout") ||
+		   strings.Contains(err.Error(), "no such host") {
+			t.Skipf("Skipping network test due to connectivity issue: %v", err)
+		}
+		t.Fatal("LoadDataSource failed:", err)
+	}
+
+	if result == nil {
+		t.Fatal("Expected load result, got nil")
+	}
+
+	t.Logf("Loaded airlines: Total=%d, New=%d, Errors=%d, Duration=%v", 
+		result.RecordsTotal, result.RecordsNew, result.RecordsError, result.Duration)
+
+	// Verify some data was processed
+	if result.RecordsTotal == 0 {
+		t.Error("No records were processed")
+	}
+}
+
+func TestDataLoader_LoadOurAirports(t *testing.T) {
+	db, cleanup := setupTestDatabase(t)
+	defer cleanup()
+
+	loader := NewDataLoader(db.GetConnection())
+
+	// Create a test data source for OurAirports
+	source := DataSource{
+		Name:    "OurAirports Test",
+		License: "CC0 1.0",
+		URL:     "https://davidmegginson.github.io/ourairports-data/airports.csv",
+		Format:  "ourairports",
+		Version: "2024-test",
+	}
+
+	result, err := loader.LoadDataSource(source)
+	if err != nil {
+		// Network issues in tests are acceptable
+		if strings.Contains(err.Error(), "connection") || 
+		   strings.Contains(err.Error(), "timeout") ||
+		   strings.Contains(err.Error(), "no such host") {
+			t.Skipf("Skipping network test due to connectivity issue: %v", err)
+		}
+		t.Fatal("LoadDataSource failed:", err)
+	}
+
+	if result != nil {
+		t.Logf("Loaded airports: Total=%d, New=%d, Errors=%d, Duration=%v", 
+			result.RecordsTotal, result.RecordsNew, result.RecordsError, result.Duration)
+	}
+}
+
+func TestDataLoader_GetLoadedDataSources(t *testing.T) {
+	db, cleanup := setupTestDatabase(t)
+	defer cleanup()
+
+	loader := NewDataLoader(db.GetConnection())
+
+	sources, err := loader.GetLoadedDataSources()
+	if err != nil {
+		t.Fatal("GetLoadedDataSources failed:", err)
+	}
+
+	// Initially should be empty or minimal
+	t.Logf("Found %d loaded data sources", len(sources))
+}
+
+func TestDataLoader_ClearDataSource(t *testing.T) {
+	db, cleanup := setupTestDatabase(t)
+	defer cleanup()
+
+	loader := NewDataLoader(db.GetConnection())
+
+	// Test clearing a non-existent source (should not error)
+	err := loader.ClearDataSource("nonexistent")
+	if err != nil {
+		t.Error("ClearDataSource should not error on nonexistent source:", err)
+	}
+}
+
+func TestDataSource_Struct(t *testing.T) {
+	source := DataSource{
+		Name:                "Test Source",
+		License:             "Test License",
+		URL:                 "https://example.com/data.csv",
+		RequiresConsent:     false,
+		UserAcceptedLicense: true,
+		Format:              "csv",
+		Version:             "1.0",
+	}
+
+	// Test that all fields are accessible
+	if source.Name != "Test Source" {
+		t.Error("Name field not preserved")
+	}
+	if source.License != "Test License" {
+		t.Error("License field not preserved")
+	}
+	if source.URL != "https://example.com/data.csv" {
+		t.Error("URL field not preserved")
+	}
+	if source.RequiresConsent != false {
+		t.Error("RequiresConsent field not preserved")
+	}
+	if source.UserAcceptedLicense != true {
+		t.Error("UserAcceptedLicense field not preserved")
+	}
+	if source.Format != "csv" {
+		t.Error("Format field not preserved")
+	}
+	if source.Version != "1.0" {
+		t.Error("Version field not preserved")
+	}
+}
+
+func TestLoadResult_Struct(t *testing.T) {
+	result := LoadResult{
+		Source:       "Test Source",
+		RecordsTotal: 100,
+		RecordsNew:   80,
+		RecordsError: 5,
+		Errors:       []string{"error1", "error2"},
+	}
+
+	// Test that all fields are accessible
+	if result.Source != "Test Source" {
+		t.Error("Source field not preserved")
+	}
+	if result.RecordsTotal != 100 {
+		t.Error("RecordsTotal field not preserved")
+	}
+	if result.RecordsNew != 80 {
+		t.Error("RecordsNew field not preserved")
+	}
+	if result.RecordsError != 5 {
+		t.Error("RecordsError field not preserved")
+	}
+	if len(result.Errors) != 2 {
+		t.Error("Errors field not preserved")
+	}
+}