Download internal/proxypool/pool_test.go from a3216/gcli2api: direct link, hf CLI and curl.
- Browser
- Download file 11.9 kB
-
https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/proxypool/pool_test.go
- Command line
-
hf download hf://spaces/a3216/gcli2api/internal/proxypool/pool_test.go
-
curl -L -o pool_test.go https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/proxypool/pool_test.go
11.9 kB
| package proxypool | |
| import ( | |
| "context" | |
| "encoding/json" | |
| "errors" | |
| "fmt" | |
| "io" | |
| "net/http" | |
| "net/http/httptest" | |
| "os" | |
| "path/filepath" | |
| "strings" | |
| "sync" | |
| "sync/atomic" | |
| "testing" | |
| "time" | |
| ) | |
| func testManager(t *testing.T, path string) *Manager { | |
| t.Helper() | |
| m, err := New(path, http.DefaultTransport.(*http.Transport), nil) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| m.data.Settings.URL = "http://health.invalid/" | |
| t.Cleanup(m.Close) | |
| return m | |
| } | |
| func addProxy(t *testing.T, m *Manager, raw string) string { | |
| t.Helper() | |
| results, err := m.Import(raw) | |
| if err != nil || len(results) != 1 || results[0].Status != "added" { | |
| t.Fatalf("import: %+v, %v", results, err) | |
| } | |
| return results[0].ID | |
| } | |
| func probe(t *testing.T, m *Manager, id string) { | |
| t.Helper() | |
| if err := m.Probe(context.Background(), id); err != nil { | |
| t.Fatal(err) | |
| } | |
| } | |
| func TestImportPersistenceAndRedaction(t *testing.T) { | |
| path := filepath.Join(t.TempDir(), "nested", "proxy-pool.json") | |
| m := testManager(t, path) | |
| results, err := m.Import("\nHTTP://user:TOPSECRET@localhost:80/\r\nhttp://user:TOPSECRET@LOCALHOST\nbad://user:TOPSECRET@host\nsocks5h://[::1]:1080\n") | |
| if err != nil || len(results) != 4 || results[0].Line != 2 || results[1].Status != "duplicate" || results[2].Status != "invalid" { | |
| t.Fatalf("results=%+v err=%v", results, err) | |
| } | |
| id := results[0].ID | |
| if err := m.Bind("account", Binding{Mode: "fixed", ProxyID: id}); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := m.Update(id, Input{Name: "Office", URL: "http://user@localhost:8080"}); err != nil { | |
| t.Fatal(err) | |
| } | |
| snapshot, _ := json.Marshal(m.Snapshot()) | |
| if strings.Contains(string(snapshot), "TOPSECRET") || !strings.Contains(string(snapshot), `"password_set":true`) { | |
| t.Fatalf("snapshot leaked password: %s", snapshot) | |
| } | |
| stored, _ := os.ReadFile(path) | |
| if !strings.Contains(string(stored), "TOPSECRET") { | |
| t.Fatal("blank edit lost stored password") | |
| } | |
| reloaded := testManager(t, path) | |
| s := reloaded.Snapshot() | |
| if len(s.Proxies) != 2 || s.Proxies[0].Name != "Office" || s.Proxies[0].Status != "pending" || s.Bindings["account"].ProxyID != id { | |
| t.Fatalf("reload=%+v", s) | |
| } | |
| if err := m.Delete(id); !errors.Is(err, ErrBound) { | |
| t.Fatalf("bound deletion=%v", err) | |
| } | |
| if err := m.Unbind("account"); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := m.Delete(id); err != nil { | |
| t.Fatal(err) | |
| } | |
| } | |
| func TestInvalidURLsDoNotEchoCredentials(t *testing.T) { | |
| for _, raw := range []string{ | |
| "http://HOST:0", "http://HOST:65536", "http://HOST/path", "http://HOST?x=secret", | |
| "http://HOST#fragment", "ftp://user:TOPSECRET@HOST", "http://user:%zz@HOST", "http://:TOPSECRET@HOST", "HOST:8080", | |
| } { | |
| _, err := parseURL(raw) | |
| if err == nil || strings.Contains(err.Error(), "TOPSECRET") { | |
| t.Fatalf("%q: %v", raw, err) | |
| } | |
| } | |
| } | |
| func TestWriteFailureDoesNotPublish(t *testing.T) { | |
| m := testManager(t, "") | |
| id := addProxy(t, m, "http://localhost:8080") | |
| blocker := filepath.Join(t.TempDir(), "file") | |
| if err := os.WriteFile(blocker, []byte("x"), 0o600); err != nil { | |
| t.Fatal(err) | |
| } | |
| m.path = filepath.Join(blocker, "pool.json") | |
| if err := m.Update(id, Input{Name: "Changed"}); err == nil { | |
| t.Fatal("expected storage error") | |
| } | |
| if m.Snapshot().Proxies[0].Name == "Changed" { | |
| t.Fatal("failed save changed runtime") | |
| } | |
| if err := m.Bind("u1", Binding{Mode: "direct"}); err == nil || len(m.Snapshot().Bindings) != 0 { | |
| t.Fatal("failed binding save changed runtime") | |
| } | |
| } | |
| func TestHealthThresholdsAndManualDisable(t *testing.T) { | |
| var status atomic.Int32 | |
| status.Store(200) | |
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| if r.Header.Get("Authorization") != "" || r.Header.Get("Cookie") != "" { | |
| t.Error("probe carried account credentials") | |
| } | |
| w.WriteHeader(int(status.Load())) | |
| })) | |
| defer server.Close() | |
| m := testManager(t, "") | |
| id := addProxy(t, m, server.URL) | |
| probe(t, m, id) | |
| if m.Snapshot().Proxies[0].Status != "healthy" { | |
| t.Fatal("initial success did not enable") | |
| } | |
| status.Store(502) | |
| for range 2 { | |
| probe(t, m, id) | |
| } | |
| if m.Snapshot().Proxies[0].Status != "healthy" { | |
| t.Fatal("disabled before failure threshold") | |
| } | |
| probe(t, m, id) | |
| if m.Snapshot().Proxies[0].Status != "unhealthy" { | |
| t.Fatal("failure threshold not applied") | |
| } | |
| status.Store(200) | |
| probe(t, m, id) | |
| if m.Snapshot().Proxies[0].Status != "unhealthy" { | |
| t.Fatal("recovered before success threshold") | |
| } | |
| probe(t, m, id) | |
| if m.Snapshot().Proxies[0].Status != "healthy" { | |
| t.Fatal("did not recover") | |
| } | |
| off := false | |
| if err := m.Update(id, Input{Enabled: &off}); err != nil { | |
| t.Fatal(err) | |
| } | |
| for range 3 { | |
| probe(t, m, id) | |
| } | |
| if m.Snapshot().Proxies[0].Status != "disabled" { | |
| t.Fatal("probe overrode manual disable") | |
| } | |
| } | |
| func TestStaleProbeDiscarded(t *testing.T) { | |
| for _, mutation := range []string{"edit", "delete", "settings"} { | |
| t.Run(mutation, func(t *testing.T) { | |
| started, finish := make(chan struct{}), make(chan struct{}) | |
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| close(started) | |
| <-finish | |
| w.WriteHeader(200) | |
| })) | |
| defer server.Close() | |
| m := testManager(t, "") | |
| id := addProxy(t, m, server.URL) | |
| done := make(chan struct{}) | |
| go func() { _ = m.Probe(context.Background(), id); close(done) }() | |
| <-started | |
| var err error | |
| switch mutation { | |
| case "edit": | |
| off := false | |
| err = m.Update(id, Input{Enabled: &off}) | |
| case "delete": | |
| err = m.Delete(id) | |
| case "settings": | |
| s := DefaultSettings() | |
| s.FailureThreshold = 2 | |
| err = m.Configure(s) | |
| } | |
| close(finish) | |
| <-done | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| snapshot := m.Snapshot() | |
| if len(snapshot.Proxies) > 0 && !snapshot.Proxies[0].CheckedAt.IsZero() { | |
| t.Fatal("stale probe published") | |
| } | |
| }) | |
| } | |
| } | |
| func TestRoutingRandomFixedDirectAndRedirect(t *testing.T) { | |
| m := testManager(t, "") | |
| direct := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, _ = io.WriteString(w, "direct") })) | |
| defer direct.Close() | |
| request := func(uid string) (string, error) { | |
| req, _ := http.NewRequest("GET", direct.URL, nil) | |
| resp, err := m.Do(&http.Client{Timeout: time.Second}, req, uid, "cn") | |
| if err != nil { | |
| return "", err | |
| } | |
| defer resp.Body.Close() | |
| b, _ := io.ReadAll(resp.Body) | |
| return string(b), nil | |
| } | |
| if body, err := request("u"); err != nil || body != "direct" { | |
| t.Fatalf("empty pool: %q %v", body, err) | |
| } | |
| var ids []string | |
| for i := range 2 { | |
| label := fmt.Sprint(i) | |
| srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| if r.URL.Path == "/redirect" { | |
| if r.URL.Query().Get("via") != "" && r.URL.Query().Get("via") != label { | |
| t.Error("redirect changed proxy") | |
| } | |
| http.Redirect(w, r, "http://destination.invalid/final?via="+label, 302) | |
| return | |
| } | |
| if via := r.URL.Query().Get("via"); via != "" && via != label { | |
| t.Error("redirect changed proxy") | |
| } | |
| _, _ = io.WriteString(w, label) | |
| })) | |
| defer srv.Close() | |
| ids = append(ids, addProxy(t, m, srv.URL)) | |
| } | |
| if _, err := request("u"); !IsError(err) { | |
| t.Fatal("pending pool silently used direct") | |
| } | |
| for _, id := range ids { | |
| probe(t, m, id) | |
| } | |
| seen := map[string]bool{} | |
| for range 100 { | |
| body, err := request("u") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| seen[body] = true | |
| } | |
| if len(seen) != 2 { | |
| t.Fatalf("random routes=%v", seen) | |
| } | |
| if err := m.Bind("fixed", Binding{Mode: "fixed", ProxyID: ids[0]}); err != nil { | |
| t.Fatal(err) | |
| } | |
| if body, err := request("fixed"); err != nil || body != "0" { | |
| t.Fatalf("fixed: %q %v", body, err) | |
| } | |
| for range 10 { | |
| req, _ := http.NewRequest("GET", "http://destination.invalid/redirect", nil) | |
| resp, err := m.Do(&http.Client{Timeout: time.Second}, req, "u", "cn") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| _ = resp.Body.Close() | |
| } | |
| off := false | |
| if err := m.Update(ids[0], Input{Enabled: &off}); err != nil { | |
| t.Fatal(err) | |
| } | |
| if _, err := request("fixed"); !IsError(err) { | |
| t.Fatal("fixed binding failed open") | |
| } | |
| if err := m.Bind("direct", Binding{Mode: "direct"}); err != nil { | |
| t.Fatal(err) | |
| } | |
| if body, err := request("direct"); err != nil || body != "direct" { | |
| t.Fatalf("explicit direct: %q %v", body, err) | |
| } | |
| if err := m.Update(ids[1], Input{Enabled: &off}); err != nil { | |
| t.Fatal(err) | |
| } | |
| // 全部停用 = 代理池关掉,随机绑定回落直连(issue #150);fixed 仍须报错—— | |
| // 显式钉住的代理不可用时静默直连会把本机 IP 泄漏给上游(上面那条已验)。 | |
| if body, err := request("u"); err != nil || body != "direct" { | |
| t.Fatalf("all proxies disabled should fall back to direct: %q %v", body, err) | |
| } | |
| } | |
| func TestProbeConcurrencyBound(t *testing.T) { | |
| var active, peak atomic.Int32 | |
| entered, release := make(chan struct{}, 32), make(chan struct{}) | |
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| n := active.Add(1) | |
| defer active.Add(-1) | |
| for old := peak.Load(); n > old && !peak.CompareAndSwap(old, n); old = peak.Load() { | |
| } | |
| // 非阻塞:两次 CheckAll × 24 个节点会产生 48 个请求,但下方只消费 8 个就离开, | |
| // 缓冲满了再阻塞发送会让 handler 永远卡住、wg.Wait 挂到 go test 超时(CI 实测)。 | |
| select { | |
| case entered <- struct{}{}: | |
| default: | |
| } | |
| <-release | |
| w.WriteHeader(200) | |
| })) | |
| defer server.Close() | |
| m := testManager(t, "") | |
| for i := range 24 { | |
| addProxy(t, m, strings.Replace(server.URL, "://", fmt.Sprintf("://user%d:pass@", i), 1)) | |
| } | |
| var wg sync.WaitGroup | |
| for range 2 { | |
| wg.Add(1) | |
| go func() { defer wg.Done(); m.CheckAll(context.Background()) }() | |
| } | |
| for range 8 { | |
| select { | |
| case <-entered: | |
| case <-time.After(3 * time.Second): | |
| close(release) | |
| t.Fatal("workers did not start") | |
| } | |
| } | |
| close(release) | |
| wg.Wait() | |
| if peak.Load() > 8 { | |
| t.Fatalf("concurrent probes=%d", peak.Load()) | |
| } | |
| } | |
| func TestPeriodicRunRecoversAndStops(t *testing.T) { | |
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(204) })) | |
| defer server.Close() | |
| m := testManager(t, "") | |
| id := addProxy(t, m, server.URL) | |
| m.mu.Lock() | |
| m.health[id] = health{status: "unhealthy"} | |
| m.mu.Unlock() | |
| s := DefaultSettings() | |
| s.URL = "http://health.invalid/" | |
| s.IntervalSeconds, s.SuccessThreshold = 1, 1 | |
| if err := m.Configure(s); err != nil { | |
| t.Fatal(err) | |
| } | |
| m.mu.Lock() | |
| m.health[id] = health{status: "unhealthy"} | |
| m.mu.Unlock() | |
| ctx, cancel := context.WithCancel(context.Background()) | |
| done := make(chan struct{}) | |
| go func() { m.Run(ctx); close(done) }() | |
| defer func() { cancel(); <-done }() | |
| deadline := time.After(3 * time.Second) | |
| for m.Snapshot().Proxies[0].Status != "healthy" { | |
| select { | |
| case <-deadline: | |
| t.Fatal("periodic probe did not recover disabled node") | |
| case <-time.After(10 * time.Millisecond): | |
| } | |
| } | |
| } | |
| func TestProxyResponseErrorsRetainIdentityAndCancellation(t *testing.T) { | |
| proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | |
| if r.URL.Path == "/" { | |
| w.WriteHeader(204) | |
| return | |
| } | |
| w.Header().Set("Content-Length", "100") | |
| _, _ = io.WriteString(w, "truncated") | |
| })) | |
| defer proxy.Close() | |
| m := testManager(t, "") | |
| id := addProxy(t, m, proxy.URL) | |
| probe(t, m, id) | |
| req, _ := http.NewRequest("GET", "http://origin.invalid/truncated", nil) | |
| resp, err := m.Do(http.DefaultClient, req, "u1", "cn") | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| _, err = io.ReadAll(resp.Body) | |
| _ = resp.Body.Close() | |
| if !IsError(err) || !errors.Is(err, io.ErrUnexpectedEOF) { | |
| t.Fatalf("body read error lost proxy identity or cause: %v", err) | |
| } | |
| ctx, cancel := context.WithCancel(context.Background()) | |
| cancel() | |
| req, _ = http.NewRequestWithContext(ctx, "GET", "http://origin.invalid/", nil) | |
| _, err = m.Do(http.DefaultClient, req, "u1", "cn") | |
| if !IsError(err) || !errors.Is(err, context.Canceled) { | |
| t.Fatalf("cancellation lost proxy identity or cause: %v", err) | |
| } | |
| } | |