geoipapi/geoipapi_test.go

package main

import (
	"context"
	"encoding/json"
	"net"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"path/filepath"
	"testing"

	"github.com/oschwald/geoip2-golang"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestFindDB(t *testing.T) {
	// Create temporary directories to simulate different system paths
	tempBase, err := os.MkdirTemp("", "geoip_finddb_test")
	require.NoError(t, err)
	defer os.RemoveAll(tempBase)

	// Create some test directories
	testDirs := []string{
		filepath.Join(tempBase, "usr", "share", "GeoIP"),
		filepath.Join(tempBase, "usr", "local", "share", "GeoIP"),
		filepath.Join(tempBase, "opt", "local", "share", "GeoIP"),
	}

	for _, dir := range testDirs {
		err := os.MkdirAll(dir, 0o755)
		require.NoError(t, err)
	}

	// Test with no directories existing (original function tests system paths)
	t.Run("System path detection", func(t *testing.T) {
		result := findDB()
		// On different systems, this might return different paths or empty string
		// We just verify it doesn't panic and returns a string
		assert.IsType(t, "", result)
	})

	// We can't easily test the actual system path detection without modifying the function,
	// but we can test the logic by verifying the function behaves correctly
}

func TestDbFilesInit(t *testing.T) {
	t.Run("Database file mappings exist", func(t *testing.T) {
		assert.NotNil(t, dbFiles)
		assert.Contains(t, dbFiles, countryDB)
		assert.Contains(t, dbFiles, cityDB)
		assert.Contains(t, dbFiles, asnDB)
	})

	t.Run("Country DB files", func(t *testing.T) {
		countryFiles := dbFiles[countryDB]
		assert.Contains(t, countryFiles, "GeoIP2-Country.mmdb")
		assert.Contains(t, countryFiles, "GeoLite2-Country.mmdb")
	})

	t.Run("City DB files", func(t *testing.T) {
		cityFiles := dbFiles[cityDB]
		assert.Contains(t, cityFiles, "GeoIP2-City.mmdb")
		assert.Contains(t, cityFiles, "GeoLite2-City.mmdb")
	})

	t.Run("ASN DB files", func(t *testing.T) {
		asnFiles := dbFiles[asnDB]
		assert.Contains(t, asnFiles, "GeoIP2-ISP.mmdb")
	})
}

func TestGeoType(t *testing.T) {
	t.Run("GeoType constants", func(t *testing.T) {
		assert.Equal(t, geoType(0), countryDB)
		assert.Equal(t, geoType(1), cityDB)
		assert.Equal(t, geoType(2), asnDB)
	})
}

func TestGetCity(t *testing.T) {
	t.Run("Missing IP parameter", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/json", nil)

		_, err := getCity(req)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "missing IP address")
	})

	t.Run("Invalid IP address", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/json?ip=invalid", nil)

		_, err := getCity(req)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "missing IP address")
	})

	t.Run("Valid IP format parsing", func(t *testing.T) {
		validIPs := []string{
			"8.8.8.8",
			"192.168.1.1",
			"::1",
			"2001:4860:4860::8888",
		}

		for _, ip := range validIPs {
			t.Run("IP_"+ip, func(t *testing.T) {
				// We can't test the actual database lookup without a real database,
				// but we can test that IP parsing works correctly
				parsed := net.ParseIP(ip)
				assert.NotNil(t, parsed, "IP %s should parse correctly", ip)
			})
		}
	})

	t.Run("Invalid IP formats", func(t *testing.T) {
		invalidIPs := []string{
			"256.256.256.256",
			"not.an.ip",
			"1.2.3",
			"",
			"999.999.999.999",
		}

		for _, ip := range invalidIPs {
			t.Run("InvalidIP_"+ip, func(t *testing.T) {
				req := httptest.NewRequest("GET", "/api/json?ip="+url.QueryEscape(ip), nil)

				_, err := getCity(req)
				assert.Error(t, err)
			})
		}
	})
}

func TestHandleJSON(t *testing.T) {
	t.Run("Missing IP parameter", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/json", nil)
		w := httptest.NewRecorder()

		handleJSON(w, req)

		assert.Equal(t, http.StatusInternalServerError, w.Code)
		assert.Contains(t, w.Body.String(), "data error")
	})

	t.Run("Invalid IP parameter", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/json?ip=invalid", nil)
		w := httptest.NewRecorder()

		handleJSON(w, req)

		assert.Equal(t, http.StatusInternalServerError, w.Code)
		assert.Contains(t, w.Body.String(), "data error")
	})

	// Note: Testing with valid IPs requires actual GeoIP databases
	// In integration tests, we'll test with mock databases
}

func TestHandleCountry(t *testing.T) {
	t.Run("Missing IP parameter", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/country", nil)
		w := httptest.NewRecorder()

		handleCountry(w, req)

		assert.Equal(t, http.StatusInternalServerError, w.Code)
		assert.Contains(t, w.Body.String(), "data error")
	})

	t.Run("Invalid IP parameter", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/country?ip=invalid", nil)
		w := httptest.NewRecorder()

		handleCountry(w, req)

		assert.Equal(t, http.StatusInternalServerError, w.Code)
		assert.Contains(t, w.Body.String(), "data error")
	})
}

func TestHandleHealth(t *testing.T) {
	t.Run("Health check endpoint", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/healthz", nil)
		w := httptest.NewRecorder()

		// Health check tests the actual database
		handleHealth(w, req)

		// Health check should return either 200 (with DB) or 500 (without DB)
		assert.Contains(t, []int{200, 500}, w.Code)
	})
}

func TestSetupHTTP(t *testing.T) {
	t.Run("HTTP server configuration", func(t *testing.T) {
		// We can't easily test the full setupHTTP function without starting a server,
		// but we can test that it configures routes correctly by testing individual handlers

		// Test that handlers are properly configured
		w := httptest.NewRecorder()
		handleCountry(w, httptest.NewRequest("GET", "/api/country?ip=invalid", nil))

		// Should handle the request (even if it errors due to invalid IP)
		assert.NotEqual(t, http.StatusNotFound, w.Code)
	})
}

func TestVersionHandler(t *testing.T) {
	t.Run("Version headers added", func(t *testing.T) {
		// Create a test handler that the version handler will wrap
		testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusOK)
			w.Write([]byte("test"))
		})

		// We can't easily test the actual version handler without extracting it,
		// but we can verify the concept by testing header setting
		req := httptest.NewRequest("GET", "/test", nil)
		w := httptest.NewRecorder()

		testHandler.ServeHTTP(w, req)

		assert.Equal(t, http.StatusOK, w.Code)
		assert.Equal(t, "test", w.Body.String())
	})
}

func TestIPAddressValidation(t *testing.T) {
	testCases := []struct {
		name    string
		ip      string
		isValid bool
	}{
		{"Valid IPv4", "192.168.1.1", true},
		{"Valid IPv4 public", "8.8.8.8", true},
		{"Valid IPv6", "2001:db8::1", true},
		{"Valid IPv6 loopback", "::1", true},
		{"Invalid IPv4 high values", "256.256.256.256", false},
		{"Invalid IPv4 format", "192.168.1", false},
		{"Invalid string", "not.an.ip", false},
		{"Empty string", "", false},
		{"Invalid IPv6", "2001:db8::xyz", false},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			ip := net.ParseIP(tc.ip)
			if tc.isValid {
				assert.NotNil(t, ip, "Expected %s to be valid", tc.ip)
			} else {
				assert.Nil(t, ip, "Expected %s to be invalid", tc.ip)
			}
		})
	}
}

func TestJSONSerialization(t *testing.T) {
	t.Run("GeoIP2 City JSON serialization", func(t *testing.T) {
		// Create a sample geoip2.City struct
		city := &geoip2.City{}
		city.Country.GeoNameID = 12345
		city.Country.IsoCode = "US"
		city.Country.Names = map[string]string{"en": "United States"}

		// Test JSON marshaling
		jsonBytes, err := json.Marshal(city)
		assert.NoError(t, err)
		assert.NotEmpty(t, jsonBytes)

		// Verify JSON contains expected fields
		jsonStr := string(jsonBytes)
		assert.Contains(t, jsonStr, "US")
		assert.Contains(t, jsonStr, "United States")
	})
}

func TestHTTPRouting(t *testing.T) {
	t.Run("Route configuration", func(t *testing.T) {
		// Test that all expected routes respond (even with errors due to missing DB)
		routes := map[string]http.HandlerFunc{
			"/api/country": handleCountry,
			"/api/json":    handleJSON,
			"/healthz":     handleHealth,
		}

		for path, handler := range routes {
			t.Run("Route_"+path, func(t *testing.T) {
				req := httptest.NewRequest("GET", path, nil)
				w := httptest.NewRecorder()

				handler(w, req)

				// All routes should respond (not 404), even if they error due to missing parameters
				assert.NotEqual(t, http.StatusNotFound, w.Code)
			})
		}
	})
}

func TestHTTPMethods(t *testing.T) {
	t.Run("GET method support", func(t *testing.T) {
		methods := []string{"GET", "POST", "PUT", "DELETE"}

		for _, method := range methods {
			t.Run("Method_"+method, func(t *testing.T) {
				req := httptest.NewRequest(method, "/api/country?ip=8.8.8.8", nil)
				w := httptest.NewRecorder()

				handleCountry(w, req)

				// All methods should be handled (our handlers don't restrict by method)
				// They will fail due to database issues, but not method issues
				assert.NotEqual(t, http.StatusMethodNotAllowed, w.Code)
			})
		}
	})
}

func TestQueryParameterParsing(t *testing.T) {
	t.Run("Multiple query parameters", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/country?ip=8.8.8.8&extra=value", nil)

		err := req.ParseForm()
		assert.NoError(t, err)

		ip := req.FormValue("ip")
		extra := req.FormValue("extra")

		assert.Equal(t, "8.8.8.8", ip)
		assert.Equal(t, "value", extra)
	})

	t.Run("URL encoded parameters", func(t *testing.T) {
		// Test with URL-encoded IPv6 address
		encodedIP := url.QueryEscape("2001:4860:4860::8888")
		req := httptest.NewRequest("GET", "/api/country?ip="+encodedIP, nil)

		err := req.ParseForm()
		assert.NoError(t, err)

		ip := req.FormValue("ip")
		assert.Equal(t, "2001:4860:4860::8888", ip)
	})
}

func TestContextHandling(t *testing.T) {
	t.Run("Context propagation", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/api/country?ip=8.8.8.8", nil)

		// Verify context is available
		ctx := req.Context()
		assert.NotNil(t, ctx)

		// Test context with timeout
		ctx, cancel := context.WithCancel(ctx)
		defer cancel()

		req = req.WithContext(ctx)
		assert.NotNil(t, req.Context())
	})
}