path: root/internal/modules/handler_test.go

package modules

import (
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"git.ofmax.li/go-git-server/internal/admin"
)

func TestNewModuleHandler_WithNilConfig(t *testing.T) {
	handler := NewModuleHandler("/tmp/repos", "example.com", nil)

	// Test that it returns a valid http.Handler even with nil config
	if handler == nil {
		t.Error("NewModuleHandler should return a non-nil handler")
	}
}

func TestNewModuleHandler_WithConfig(t *testing.T) {
	config := &admin.ServerRepos{
		Repos: []*admin.GitRepo{
			{
				Name:     "mylib",
				GoModule: true,
			},
		},
	}

	handler := NewModuleHandler("/tmp/repos", "example.com", config)

	// Test that it returns a valid http.Handler
	if handler == nil {
		t.Error("NewModuleHandler should return a non-nil handler")
	}
}

func TestHandleGoImport_ConfiguredModule(t *testing.T) {
	config := &admin.ServerRepos{
		Repos: []*admin.GitRepo{
			{
				Name:     "mymodule",
				GoModule: true,
			},
		},
	}

	handler := NewModuleHandler("/tmp/repos", "git.example.com", config)

	req := httptest.NewRequest("GET", "/mymodule?go-get=1", nil)
	w := httptest.NewRecorder()

	handler.ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("expected status 200, got %d", w.Code)
	}

	body := w.Body.String()

	// Check for go-import meta tag
	if !strings.Contains(body, `<meta name="go-import"`) {
		t.Error("response should contain go-import meta tag")
	}

	// Check for correct module path and VCS info
	expectedContent := `content="git.example.com/mymodule git https://git.example.com/mymodule"`
	if !strings.Contains(body, expectedContent) {
		t.Errorf("response should contain %s", expectedContent)
	}

	// Check for go-source meta tag
	if !strings.Contains(body, `<meta name="go-source"`) {
		t.Error("response should contain go-source meta tag")
	}

	// Check content type
	contentType := w.Header().Get("Content-Type")
	if contentType != "text/html; charset=utf-8" {
		t.Errorf("expected content type text/html; charset=utf-8, got %s", contentType)
	}
}

func TestModuleHandler_ServeHTTP_VersionList(t *testing.T) {
	config := &admin.ServerRepos{
		Repos: []*admin.GitRepo{
			{
				Name:     "mymodule",
				GoModule: true,
			},
		},
	}

	handler := NewModuleHandler("/tmp/repos", "git.example.com", config)

	req := httptest.NewRequest("GET", "/mymodule/@v/list", nil)
	w := httptest.NewRecorder()

	handler.ServeHTTP(w, req)

	// Since we don't have a real repo, this should return 500 (internal server error)
	// But we can test that it tries to handle the request correctly
	if w.Code == http.StatusOK {
		contentType := w.Header().Get("Content-Type")
		if contentType != "text/plain; charset=utf-8" {
			t.Errorf("expected content type text/plain; charset=utf-8, got %s", contentType)
		}
	}
}

func TestGoModuleConfiguration(t *testing.T) {
	config := &admin.ServerRepos{
		Repos: []*admin.GitRepo{
			{
				Name:     "mylib",
				GoModule: true, // This should have module endpoints
			},
			{
				Name:     "website",
				GoModule: false, // This should not have module endpoints
			},
		},
	}

	handler := NewModuleHandler("/tmp/repos", "git.example.com", config)

	// Test Go module repo (should work)
	t.Run("go_module_true", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mylib?go-get=1", nil)
		w := httptest.NewRecorder()
		handler.ServeHTTP(w, req)

		if w.Code != http.StatusOK {
			t.Errorf("expected status 200 for Go module, got %d", w.Code)
		}
	})

	// Test non-Go module repo (should return 404)
	t.Run("go_module_false", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/website?go-get=1", nil)
		w := httptest.NewRecorder()
		handler.ServeHTTP(w, req)

		if w.Code != http.StatusNotFound {
			t.Errorf("expected status 404 for non-Go module, got %d", w.Code)
		}
	})

	// Test proxy endpoints for Go module
	t.Run("go_module_proxy_endpoints", func(t *testing.T) {
		endpoints := []string{
			"/mylib/@v/list",
			"/mylib/@latest",
		}

		for _, endpoint := range endpoints {
			req := httptest.NewRequest("GET", endpoint, nil)
			w := httptest.NewRecorder()
			handler.ServeHTTP(w, req)

			// Should get 500 (repo doesn't exist) not 404 (route doesn't exist)
			if w.Code == http.StatusNotFound {
				t.Errorf("endpoint %s should be routed (got 404, want 500 or 200)", endpoint)
			}
		}
	})

	// Test proxy endpoints for non-Go module (should all be 404)
	t.Run("non_go_module_proxy_endpoints", func(t *testing.T) {
		endpoints := []string{
			"/website/@v/list",
			"/website/@latest",
		}

		for _, endpoint := range endpoints {
			req := httptest.NewRequest("GET", endpoint, nil)
			w := httptest.NewRecorder()
			handler.ServeHTTP(w, req)

			if w.Code != http.StatusNotFound {
				t.Errorf("endpoint %s should return 404 for non-Go module, got %d", endpoint, w.Code)
			}
		}
	})
}

// Test the catch-all handler (handleAllRequests) - currently 0% coverage
func TestHandleAllRequests(t *testing.T) {
	handler := &ModuleHandler{
		reposDir:   "/tmp/repos",
		serverHost: "git.example.com",
	}

	t.Run("version_list_endpoint", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/list", nil)
		w := httptest.NewRecorder()

		handler.handleAllRequests(w, req)

		// Should get 500 (repo doesn't exist) not 404 (route doesn't exist)
		if w.Code == http.StatusNotFound {
			t.Error("handleAllRequests should route version list requests")
		}
	})

	t.Run("latest_endpoint", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@latest", nil)
		w := httptest.NewRecorder()

		handler.handleAllRequests(w, req)

		// Should get 500 (repo doesn't exist) not 404 (route doesn't exist)
		if w.Code == http.StatusNotFound {
			t.Error("handleAllRequests should route latest version requests")
		}
	})

	t.Run("version_info_endpoint", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.info", nil)
		w := httptest.NewRecorder()

		handler.handleAllRequests(w, req)

		// Should get 500/404 (repo/version doesn't exist) not 404 (route doesn't exist)
		if w.Code == http.StatusOK {
			t.Error("expected error for nonexistent repository/version")
		}
	})

	t.Run("mod_file_endpoint", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.mod", nil)
		w := httptest.NewRecorder()

		handler.handleAllRequests(w, req)

		// Should get 500/404 (repo/version doesn't exist) not 404 (route doesn't exist)
		if w.Code == http.StatusOK {
			t.Error("expected error for nonexistent repository/version")
		}
	})

	t.Run("zip_file_endpoint", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.zip", nil)
		w := httptest.NewRecorder()

		handler.handleAllRequests(w, req)

		// Should get 500/404 (repo/version doesn't exist) not 404 (route doesn't exist)
		if w.Code == http.StatusOK {
			t.Error("expected error for nonexistent repository/version")
		}
	})

	t.Run("go_import_request", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule?go-get=1", nil)
		w := httptest.NewRecorder()

		handler.handleAllRequests(w, req)

		if w.Code != http.StatusOK {
			t.Errorf("expected 200 for go-import request, got %d", w.Code)
		}

		body := w.Body.String()
		if !strings.Contains(body, "go-import") {
			t.Error("response should contain go-import meta tag")
		}
	})

	t.Run("regular_request", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule", nil)
		w := httptest.NewRecorder()

		handler.handleAllRequests(w, req)

		// Should get 404 because go-get=1 is required for go-import
		if w.Code != http.StatusNotFound {
			t.Errorf("expected 404 for regular request without go-get, got %d", w.Code)
		}
	})
}

// Test non-"ForModule" handler functions - currently 0% coverage
func TestNonForModuleHandlers(t *testing.T) {
	handler := &ModuleHandler{
		reposDir:   "/tmp/repos",
		serverHost: "git.example.com",
	}

	t.Run("handleGoImport", func(t *testing.T) {
		// Test without go-get parameter
		req := httptest.NewRequest("GET", "/mymodule", nil)
		w := httptest.NewRecorder()

		handler.handleGoImport(w, req)

		if w.Code != http.StatusNotFound {
			t.Error("expected 404 when go-get parameter is missing")
		}

		// Test with go-get=1
		req = httptest.NewRequest("GET", "/mymodule?go-get=1", nil)
		w = httptest.NewRecorder()

		handler.handleGoImport(w, req)

		if w.Code != http.StatusOK {
			t.Errorf("expected 200 with go-get=1, got %d", w.Code)
		}

		body := w.Body.String()
		if !strings.Contains(body, "go-import") {
			t.Error("response should contain go-import meta tag")
		}
	})

	t.Run("handleVersionList", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/list", nil)
		w := httptest.NewRecorder()

		handler.handleVersionList(w, req)

		// Should get 500 (repo doesn't exist)
		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("handleLatestVersion", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@latest", nil)
		w := httptest.NewRecorder()

		handler.handleLatestVersion(w, req)

		// Should get 500 (repo doesn't exist)
		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("handleVersionInfo", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.info", nil)
		w := httptest.NewRecorder()

		handler.handleVersionInfo(w, req)

		// Should get 500 (repo doesn't exist)
		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("handleModFile", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.mod", nil)
		w := httptest.NewRecorder()

		handler.handleModFile(w, req)

		// Should get 500 (repo doesn't exist)
		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("handleModuleZip", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.zip", nil)
		w := httptest.NewRecorder()

		handler.handleModuleZip(w, req)

		// Should get 500 (repo doesn't exist)
		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})
}

// Test ForModule handlers that have 0% coverage
func TestForModuleHandlersZeroCoverage(t *testing.T) {
	handler := &ModuleHandler{
		reposDir:   "/tmp/repos",
		serverHost: "git.example.com",
	}

	t.Run("handleVersionInfoForModule", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.info", nil)
		w := httptest.NewRecorder()

		handler.handleVersionInfoForModule(w, req, "mymodule", "v1.0.0")

		// Should get 500 (repo doesn't exist)
		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("handleModFileForModule", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.mod", nil)
		w := httptest.NewRecorder()

		handler.handleModFileForModule(w, req, "mymodule", "v1.0.0")

		// Should get 500 (repo doesn't exist)
		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("handleModuleZipForModule", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.zip", nil)
		w := httptest.NewRecorder()

		handler.handleModuleZipForModule(w, req, "mymodule", "v1.0.0")

		// Should get 500 (repo doesn't exist)
		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("handleGoImportForModule_without_go_get", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule", nil)
		w := httptest.NewRecorder()

		handler.handleGoImportForModule(w, req, "mymodule")

		if w.Code != http.StatusNotFound {
			t.Error("expected 404 when go-get parameter is missing")
		}
	})

	t.Run("handleGoImportForModule_with_go_get", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule?go-get=1", nil)
		w := httptest.NewRecorder()

		handler.handleGoImportForModule(w, req, "mymodule")

		if w.Code != http.StatusOK {
			t.Errorf("expected 200 with go-get=1, got %d", w.Code)
		}

		body := w.Body.String()
		if !strings.Contains(body, "go-import") {
			t.Error("response should contain go-import meta tag")
		}
	})
}

// Test createGenericVersionHandler which has low coverage (8.3%)
func TestCreateGenericVersionHandler(t *testing.T) {
	handler := &ModuleHandler{
		reposDir:   "/tmp/repos",
		serverHost: "git.example.com",
	}

	genericHandler := handler.createGenericVersionHandler("mymodule")

	t.Run("info_file", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.info", nil)
		w := httptest.NewRecorder()

		genericHandler(w, req)

		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("mod_file", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.mod", nil)
		w := httptest.NewRecorder()

		genericHandler(w, req)

		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("zip_file", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/v1.0.0.zip", nil)
		w := httptest.NewRecorder()

		genericHandler(w, req)

		if w.Code != http.StatusInternalServerError {
			t.Errorf("expected 500 for nonexistent repo, got %d", w.Code)
		}
	})

	t.Run("unknown_endpoint", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/unknown", nil)
		w := httptest.NewRecorder()

		genericHandler(w, req)

		if w.Code != http.StatusNotFound {
			t.Errorf("expected 404 for unknown endpoint, got %d", w.Code)
		}
	})
}

// Test middleware coverage
func TestModuleMiddleware(t *testing.T) {
	moduleHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("module-response"))
	})

	nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("next-response"))
	})

	middleware := ModuleMiddleware(moduleHandler, nextHandler)

	t.Run("module_request_go_get", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule?go-get=1", nil)
		w := httptest.NewRecorder()

		middleware.ServeHTTP(w, req)

		if w.Body.String() != "module-response" {
			t.Error("should route to module handler for go-get requests")
		}
	})

	t.Run("module_request_version_list", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule/@v/list", nil)
		w := httptest.NewRecorder()

		middleware.ServeHTTP(w, req)

		if w.Body.String() != "module-response" {
			t.Error("should route to module handler for version list requests")
		}
	})

	t.Run("non_module_request", func(t *testing.T) {
		req := httptest.NewRequest("GET", "/mymodule.git/info/refs", nil)
		w := httptest.NewRecorder()

		middleware.ServeHTTP(w, req)

		if w.Body.String() != "next-response" {
			t.Error("should route to next handler for git requests")
		}
	})
}

// Tests for new helper functions
func TestNormalizeImportPath(t *testing.T) {
	handler := &ModuleHandler{
		reposDir:   "/tmp/repos",
		serverHost: "git.example.com",
	}

	tests := []struct {
		name       string
		serverHost string
		modulePath string
		expected   string
		shouldErr  bool
	}{
		{
			name:       "valid_simple_path",
			serverHost: "git.example.com",
			modulePath: "mymodule",
			expected:   "git.example.com/mymodule",
			shouldErr:  false,
		},
		{
			name:       "trailing_slash_on_host",
			serverHost: "git.example.com/",
			modulePath: "mymodule",
			expected:   "git.example.com/mymodule",
			shouldErr:  false,
		},
		{
			name:       "leading_slash_on_module",
			serverHost: "git.example.com",
			modulePath: "/mymodule",
			expected:   "git.example.com/mymodule",
			shouldErr:  false,
		},
		{
			name:       "nested_module_path",
			serverHost: "git.example.com",
			modulePath: "company/mymodule",
			expected:   "git.example.com/company/mymodule",
			shouldErr:  false,
		},
		{
			name:       "empty_server_host",
			serverHost: "",
			modulePath: "mymodule",
			expected:   "",
			shouldErr:  true,
		},
		{
			name:       "empty_module_path",
			serverHost: "git.example.com",
			modulePath: "",
			expected:   "",
			shouldErr:  true,
		},
		{
			name:       "path_traversal_attempt",
			serverHost: "git.example.com",
			modulePath: "../../../etc/passwd",
			expected:   "",
			shouldErr:  true,
		},
		{
			name:       "whitespace_in_module_path",
			serverHost: "git.example.com",
			modulePath: "my module",
			expected:   "",
			shouldErr:  true,
		},
		{
			name:       "tab_in_module_path",
			serverHost: "git.example.com",
			modulePath: "my\tmodule",
			expected:   "",
			shouldErr:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Update handler for this test
			handler.serverHost = tt.serverHost

			result, err := handler.normalizeImportPath(tt.modulePath)

			if tt.shouldErr {
				if err == nil {
					t.Errorf("expected error but got none")
				}
			} else {
				if err != nil {
					t.Errorf("unexpected error: %v", err)
				}
				if result != tt.expected {
					t.Errorf("expected %q, got %q", tt.expected, result)
				}
			}
		})
	}
}

func TestBuildRepoURL(t *testing.T) {
	handler := &ModuleHandler{
		reposDir:   "/tmp/repos",
		serverHost: "git.example.com",
	}

	tests := []struct {
		name       string
		modulePath string
		expected   string
		shouldErr  bool
	}{
		{
			name:       "simple_module",
			modulePath: "mymodule",
			expected:   "https://git.example.com/mymodule",
			shouldErr:  false,
		},
		{
			name:       "nested_module",
			modulePath: "company/mymodule",
			expected:   "https://git.example.com/company/mymodule",
			shouldErr:  false,
		},
		{
			name:       "invalid_module_path",
			modulePath: "",
			expected:   "",
			shouldErr:  true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := handler.buildRepoURL(tt.modulePath)

			if tt.shouldErr {
				if err == nil {
					t.Errorf("expected error but got none")
				}
			} else {
				if err != nil {
					t.Errorf("unexpected error: %v", err)
				}
				if result != tt.expected {
					t.Errorf("expected %q, got %q", tt.expected, result)
				}
			}
		})
	}
}

func TestGenerateGoImportHTML(t *testing.T) {
	handler := &ModuleHandler{
		reposDir:   "/tmp/repos",
		serverHost: "git.example.com",
	}

	tests := []struct {
		name         string
		modulePath   string
		shouldErr    bool
		expectedHTML []string // Strings that should be present in the HTML
	}{
		{
			name:       "valid_module",
			modulePath: "mymodule",
			shouldErr:  false,
			expectedHTML: []string{
				`<meta name="go-import" content="git.example.com/mymodule git https://git.example.com/mymodule">`,
				`<meta name="go-source" content="git.example.com/mymodule https://git.example.com/mymodule`,
				`go get git.example.com/mymodule`,
			},
		},
		{
			name:         "invalid_module",
			modulePath:   "",
			shouldErr:    true,
			expectedHTML: nil,
		},
		{
			name:         "module_with_path_traversal",
			modulePath:   "../../../etc/passwd",
			shouldErr:    true,
			expectedHTML: nil,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := handler.generateGoImportHTML(tt.modulePath)

			if tt.shouldErr {
				if err == nil {
					t.Errorf("expected error but got none")
				}
			} else {
				if err != nil {
					t.Errorf("unexpected error: %v", err)
				}

				for _, expected := range tt.expectedHTML {
					if !strings.Contains(result, expected) {
						t.Errorf("HTML should contain %q, got:\n%s", expected, result)
					}
				}
			}
		})
	}
}

// Integration test that simulates the full go-get flow
func TestGoGetIntegration(t *testing.T) {
	config := &admin.ServerRepos{
		Repos: []*admin.GitRepo{
			{
				Name:     "mymodule",
				GoModule: true,
			},
		},
	}

	handler := NewModuleHandler("/tmp/repos", "git.example.com", config)

	// Test the complete go-get flow:
	// 1. Initial request with go-get=1
	// 2. Verify correct meta tags are returned
	// 3. Verify import path format is correct

	req := httptest.NewRequest("GET", "/mymodule?go-get=1", nil)
	w := httptest.NewRecorder()

	handler.ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected status 200, got %d", w.Code)
	}

	body := w.Body.String()

	// Verify the response contains proper go-import directive
	expectedImport := `content="git.example.com/mymodule git https://git.example.com/mymodule"`
	if !strings.Contains(body, expectedImport) {
		t.Errorf("response should contain correct go-import directive: %s\nGot: %s", expectedImport, body)
	}

	// Verify the response contains proper go-source directive
	expectedSource := `content="git.example.com/mymodule https://git.example.com/mymodule`
	if !strings.Contains(body, expectedSource) {
		t.Errorf("response should contain correct go-source directive: %s\nGot: %s", expectedSource, body)
	}

	// Verify the response contains proper body content
	expectedBody := `go get git.example.com/mymodule`
	if !strings.Contains(body, expectedBody) {
		t.Errorf("response should contain correct body content: %s\nGot: %s", expectedBody, body)
	}

	// Verify content type
	contentType := w.Header().Get("Content-Type")
	if contentType != "text/html; charset=utf-8" {
		t.Errorf("expected content type text/html; charset=utf-8, got %s", contentType)
	}

	// Test that the import path format matches Go's expectations:
	// - Should be domain/path format
	// - Should not have protocol prefix in the import path
	// - Should use HTTPS for the repository URL
	if strings.Contains(body, `content="mymodule git`) {
		t.Error("import path should include domain, not just module name")
	}

	if strings.Contains(body, `content="https://git.example.com/mymodule git`) {
		t.Error("import path should not include protocol")
	}
}

// Test error handling in go-import generation
func TestGoImportErrorHandling(t *testing.T) {
	// Test with invalid server configuration
	handler := &ModuleHandler{
		reposDir:   "/tmp/repos",
		serverHost: "", // Invalid empty host
	}

	req := httptest.NewRequest("GET", "/mymodule?go-get=1", nil)
	w := httptest.NewRecorder()

	handler.handleGoImport(w, req)

	if w.Code != http.StatusInternalServerError {
		t.Errorf("expected status 500 for invalid server config, got %d", w.Code)
	}

	// Test with invalid module path characters
	handler.serverHost = "git.example.com"

	req = httptest.NewRequest("GET", "/my%20module?go-get=1", nil)
	w = httptest.NewRecorder()

	handler.handleGoImport(w, req)

	// Should handle URL-encoded paths gracefully or return appropriate error
	if w.Code == http.StatusOK {
		body := w.Body.String()
		// Verify it doesn't contain malformed content
		if strings.Contains(body, "%20") {
			t.Error("response should not contain URL-encoded characters in meta tags")
		}
	}
}