From de0e66a14419b608f6d81ebd12598fceb07a91ea Mon Sep 17 00:00:00 2001
From: Max Resnick <max@ofmax.li>
Date: Sat, 20 Sep 2025 23:59:46 -0700
Subject: fix: some things

---
 internal/modules/handler_test.go | 316 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 315 insertions(+), 1 deletion(-)

(limited to 'internal/modules/handler_test.go')

diff --git a/internal/modules/handler_test.go b/internal/modules/handler_test.go
index b173f98..943c74c 100644
--- a/internal/modules/handler_test.go
+++ b/internal/modules/handler_test.go
@@ -65,7 +65,7 @@ func TestHandleGoImport_ConfiguredModule(t *testing.T) {
 	}
 
 	// Check for correct module path and VCS info
-	expectedContent := `content="mymodule git https://git.example.com/mymodule"`
+	expectedContent := `content="git.example.com/mymodule git https://git.example.com/mymodule"`
 	if !strings.Contains(body, expectedContent) {
 		t.Errorf("response should contain %s", expectedContent)
 	}
@@ -548,3 +548,317 @@ func TestModuleMiddleware(t *testing.T) {
 		}
 	})
 }
+
+// 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")
+		}
+	}
+}
-- 
cgit v1.2.3