internal/control/ghimport_test.go
191 lines · 6955 bytes
1package control
2
3import (
4 "context"
5 "net"
6 "net/http"
7 "net/http/cgi"
8 "net/http/httptest"
9 "net/url"
10 "os"
11 "path/filepath"
12 "slices"
13 "strings"
14 "testing"
15
16 "gitbay.org/gitbay/internal/gitutil"
17 "gitbay.org/gitbay/internal/protocol"
18)
19
20// pullUpstream serves a bare repository whose refs/pull/1/head is one
21// commit over smart HTTP, and returns its port and that commit.
22func pullUpstream(t *testing.T) (string, string) {
23 t.Helper()
24 git := gitRunner(t)
25 parent := t.TempDir()
26 bare := filepath.Join(parent, "o", "r.git")
27 work := filepath.Join(parent, "work")
28 git(parent, "init", "-q", "--bare", "--initial-branch=main", bare)
29 git(parent, "init", "-q", "--initial-branch=main", work)
30 git(work, "commit", "-q", "--allow-empty", "-m", "pr")
31 git(work, "push", "-q", bare, "HEAD:refs/pull/1/head")
32 sha := strings.TrimSpace(git(work, "rev-parse", "HEAD"))
33 execPath := strings.TrimSpace(git(parent, "--exec-path"))
34 srv := httptest.NewServer(&cgi.Handler{
35 Path: filepath.Join(execPath, "git-http-backend"),
36 Env: []string{"GIT_PROJECT_ROOT=" + parent, "GIT_HTTP_EXPORT_ALL=1"},
37 })
38 t.Cleanup(srv.Close)
39 u, _ := url.Parse(srv.URL)
40 return u.Port(), sha
41}
42
43// stubLookup answers every host with ip and records what was asked.
44func stubLookup(t *testing.T, ip string) *[]string {
45 t.Helper()
46 var asked []string
47 prev := importLookup
48 importLookup = func(ctx context.Context, host string) ([]net.IP, error) {
49 asked = append(asked, host)
50 return []net.IP{net.ParseIP(ip)}, nil
51 }
52 t.Cleanup(func() { importLookup = prev })
53 return &asked
54}
55
56// pulls.test does not resolve, and the daemon's environment points git
57// at a proxy and rewrites the URL to a dead port: the fetch works only
58// because git was pinned to the checked address and ran with its own
59// environment (#301).
60func TestFetchPullHeadsIsPinned(t *testing.T) {
61 port, sha := pullUpstream(t)
62 t.Setenv("http_proxy", "http://127.0.0.1:1")
63 t.Setenv("HTTP_PROXY", "http://127.0.0.1:1")
64 global := filepath.Join(t.TempDir(), "gitconfig")
65 rewrite := "[url \"http://127.0.0.1:1/\"]\n\tinsteadOf = http://pulls.test:" + port + "/\n"
66 if err := os.WriteFile(global, []byte(rewrite), 0o644); err != nil {
67 t.Fatal(err)
68 }
69 t.Setenv("GIT_CONFIG_GLOBAL", global)
70 c, errOut, _, root := importCtx(t, true)
71 asked := stubLookup(t, "127.0.0.1")
72 dir := filepath.Join(root, "dest.git")
73 if err := gitutil.InitBare(dir, "main", ""); err != nil {
74 t.Fatal(err)
75 }
76 if !fetchPullHeads(c, dir, "http://pulls.test:"+port+"/o/r.git", "") {
77 t.Fatalf("fetch failed: %s", errOut.String())
78 }
79 got := strings.TrimSpace(gitRunner(t)(dir, "rev-parse", "refs/gh-pull/1"))
80 if got != sha {
81 t.Fatalf("refs/gh-pull/1 = %s, want %s", got, sha)
82 }
83 if !slices.Equal(*asked, []string{"pulls.test"}) {
84 t.Fatalf("looked up %v", *asked)
85 }
86}
87
88// A git host that resolves to loopback is refused on a default
89// instance; the fetch reports it and fetches nothing.
90func TestFetchPullHeadsRefusesALocalAddress(t *testing.T) {
91 port, _ := pullUpstream(t)
92 c, errOut, _, root := importCtx(t, false)
93 stubLookup(t, "127.0.0.1")
94 dir := filepath.Join(root, "dest.git")
95 if err := gitutil.InitBare(dir, "main", ""); err != nil {
96 t.Fatal(err)
97 }
98 if fetchPullHeads(c, dir, "http://pulls.test:"+port+"/o/r.git", "sekrit") {
99 t.Fatal("fetched from a local address")
100 }
101 if !strings.Contains(errOut.String(), "private or local address") || strings.Contains(errOut.String(), "sekrit") {
102 t.Fatalf("stderr %q", errOut.String())
103 }
104 if refExists(dir, "refs/gh-pull/1") {
105 t.Fatal("refs/gh-pull/1 was fetched")
106 }
107}
108
109// apiServer serves an empty issue list for o/r, plus whatever extra
110// registers, and returns the server's port.
111func apiServer(t *testing.T, extra func(mux *http.ServeMux)) string {
112 t.Helper()
113 mux := http.NewServeMux()
114 mux.HandleFunc("/repos/o/r/issues", func(w http.ResponseWriter, r *http.Request) {
115 w.Write([]byte("[]"))
116 })
117 if extra != nil {
118 extra(mux)
119 }
120 srv := httptest.NewServer(mux)
121 t.Cleanup(srv.Close)
122 u, _ := url.Parse(srv.URL)
123 return u.Port()
124}
125
126// api.test does not resolve; the import reaches the API only because the
127// client dialed the address import-issues looked up and checked (#301).
128func TestImportIssuesConnectsToTheCheckedAddress(t *testing.T) {
129 port := apiServer(t, nil)
130 c, errOut, _, _ := importCtx(t, true)
131 asked := stubLookup(t, "127.0.0.1")
132 code := Dispatch(c, []string{"repo", "import-issues", "alice/app", "--from", "o/r", "--api-base", "http://api.test:" + port})
133 if code != protocol.ExitOK {
134 t.Fatalf("exit %d: %s", code, errOut.String())
135 }
136 if len(*asked) == 0 || (*asked)[0] != "api.test" {
137 t.Fatalf("looked up %v", *asked)
138 }
139}
140
141// A redirect is refused and its target never asked, although the dialer
142// would land it on the checked address.
143func TestImportIssuesRefusesARedirect(t *testing.T) {
144 var port string
145 reached := false
146 port = apiServer(t, func(mux *http.ServeMux) {
147 mux.HandleFunc("/repos/o/x/issues", func(w http.ResponseWriter, r *http.Request) {
148 http.Redirect(w, r, "http://other.test:"+port+"/repos/o/x/moved", http.StatusMovedPermanently)
149 })
150 mux.HandleFunc("/repos/o/x/moved", func(w http.ResponseWriter, r *http.Request) {
151 reached = true
152 w.Write([]byte("[]"))
153 })
154 })
155 c, errOut, _, _ := importCtx(t, true)
156 stubLookup(t, "127.0.0.1")
157 code := Dispatch(c, []string{"repo", "import-issues", "alice/app", "--from", "o/x", "--api-base", "http://api.test:" + port})
158 if code != protocol.ExitFailure || !strings.Contains(errOut.String(), "refusing redirect to http://other.test") {
159 t.Fatalf("exit %d: %s", code, errOut.String())
160 }
161 if reached {
162 t.Fatal("followed a redirect to another host")
163 }
164}
165
166// An API base that resolves to private space is refused on a default
167// instance before anything connects.
168func TestImportIssuesRefusesAPrivateAPIBase(t *testing.T) {
169 c, errOut, _, _ := importCtx(t, false)
170 asked := stubLookup(t, "10.0.0.1")
171 code := Dispatch(c, []string{"repo", "import-issues", "alice/app", "--from", "o/r", "--api-base", "https://api.test"})
172 if code != protocol.ExitUsage || !strings.Contains(errOut.String(), "private or local address") {
173 t.Fatalf("exit %d: %s", code, errOut.String())
174 }
175 if !slices.Equal(*asked, []string{"api.test"}) {
176 t.Fatalf("looked up %v", *asked)
177 }
178}
179
180// --api-base takes a plain http or https URL: no credentials, query,
181// fragment or other scheme, and nothing of a refused one is echoed.
182func TestImportIssuesRefusesAnAPIBaseShape(t *testing.T) {
183 for _, base := range []string{"https://abc@api.test", "https://api.test/?abc", "https://api.test/#abc", "ftp://api.test/abc"} {
184 c, errOut, _, _ := importCtx(t, true)
185 asked := stubLookup(t, "127.0.0.1")
186 code := Dispatch(c, []string{"repo", "import-issues", "alice/app", "--from", "o/r", "--api-base", base})
187 if code != protocol.ExitUsage || len(*asked) != 0 || strings.Contains(errOut.String(), "abc") {
188 t.Fatalf("%s: exit %d, looked up %v: %s", base, code, *asked, errOut.String())
189 }
190 }
191}