BlueGit

timfa bluegit

Files

bluegit / internal / server / selfupdate_test.go

selfupdate_test.go

fix: accepteer een checkout van een andere uid en toon het update-log
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
71de6a16 History
selfupdate_test.go 6.9 KiB Download Raw
1package server
2
3import (
4 "bytes"
5 "context"
6 "fmt"
7 "net/http"
8 "net/http/cookiejar"
9 "net/http/httptest"
10 "os"
11 "path/filepath"
12 "strings"
13 "testing"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/auth"
17 "gitlab.com/Timfa/bluegit/internal/config"
18 "gitlab.com/Timfa/bluegit/internal/store"
19 "gitlab.com/Timfa/bluegit/internal/update"
20)
21
22func newUpdateServer(t *testing.T) (*Server, *httptest.Server, string) {
23 t.Helper()
24 dir := t.TempDir()
25 st, err := store.Open(filepath.Join(dir, "bluegit.db"), bytes32())
26 if err != nil {
27 t.Fatal(err)
28 }
29 t.Cleanup(func() { _ = st.Close() })
30 cfg := config.Config{
31 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: dir,
32 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1},
33 Git: config.Git{Binary: "git", DefaultBranch: "master"},
34 CI: config.CI{Enabled: false},
35 }
36 srv := &Server{
37 Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true,
38 Git: "git", StateDir: dir,
39 }
40 ts := httptest.NewServer(srv.Handler())
41 t.Cleanup(ts.Close)
42 return srv, ts, dir
43}
44
45func TestSelfUpdateDisabledWithoutToken(t *testing.T) {
46 t.Setenv(update.TokenEnv, "")
47 _, ts, _ := newUpdateServer(t)
48 res, err := http.Post(ts.URL+"/api/v1/admin/self-update", "application/json", strings.NewReader(`{"ref":"master"}`))
49 if err != nil {
50 t.Fatal(err)
51 }
52 body := read(t, res)
53 if res.StatusCode != http.StatusNotFound {
54 t.Fatalf("uit hoort 404, kreeg %d %s", res.StatusCode, body)
55 }
56 res, err = http.Get(ts.URL + "/api/v1/admin/self-update")
57 if err != nil {
58 t.Fatal(err)
59 }
60 if res.StatusCode != http.StatusNotFound {
61 t.Fatalf("status uit hoort 404, kreeg %d", res.StatusCode)
62 }
63 _ = read(t, res)
64}
65
66func TestSelfUpdateAuthAndStart(t *testing.T) {
67 t.Setenv(update.TokenEnv, "sleutel-voor-de-test")
68 srv, ts, dir := newUpdateServer(t)
69 var started string
70 srv.UpdateStarter = func(_ context.Context, ref string) error {
71 started = ref
72 return nil
73 }
74 post := func(token, body string) *http.Response {
75 t.Helper()
76 req, err := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/admin/self-update", strings.NewReader(body))
77 if err != nil {
78 t.Fatal(err)
79 }
80 if token != "" {
81 req.Header.Set("Authorization", "Bearer "+token)
82 }
83 res, err := http.DefaultClient.Do(req)
84 if err != nil {
85 t.Fatal(err)
86 }
87 return res
88 }
89
90 res := post("fout", `{"ref":"master"}`)
91 if res.StatusCode != http.StatusUnauthorized {
92 t.Fatalf("foute sleutel %d %s", res.StatusCode, read(t, res))
93 }
94 _ = read(t, res)
95
96 res = post("sleutel-voor-de-test", `{"ref":"../etc"}`)
97 if res.StatusCode != http.StatusBadRequest {
98 t.Fatalf("slechte ref %d %s", res.StatusCode, read(t, res))
99 }
100 _ = read(t, res)
101 if started != "" {
102 t.Fatal("ongeldige ref startte de unit")
103 }
104
105 sha := "0123456789abcdef0123456789abcdef01234567"
106 res = post("sleutel-voor-de-test", `{"sha":"`+sha+`"}`)
107 body := read(t, res)
108 if res.StatusCode != http.StatusAccepted || !strings.Contains(body, `"accepted"`) {
109 t.Fatalf("start %d %s", res.StatusCode, body)
110 }
111 if started != sha {
112 t.Fatalf("unit kreeg %q", started)
113 }
114 raw, err := os.ReadFile(filepath.Join(dir, update.RequestFile))
115 if err != nil || string(raw) != sha+"\n" {
116 t.Fatalf("verzoek %q %v", raw, err)
117 }
118
119 req, err := http.NewRequest(http.MethodGet, ts.URL+"/api/v1/admin/self-update", nil)
120 if err != nil {
121 t.Fatal(err)
122 }
123 req.Header.Set("Authorization", "Bearer sleutel-voor-de-test")
124 res, err = http.DefaultClient.Do(req)
125 if err != nil {
126 t.Fatal(err)
127 }
128 body = read(t, res)
129 if res.StatusCode != 200 || !strings.Contains(body, `"running":0`) || !strings.Contains(body, `"log":""`) {
130 t.Fatalf("status %d %s", res.StatusCode, body)
131 }
132
133 var logb strings.Builder
134 for i := 1; i <= update.LogTailLines+5; i++ {
135 fmt.Fprintf(&logb, "regel %d\n", i)
136 }
137 if err := os.WriteFile(filepath.Join(dir, update.LogFile), []byte(logb.String()), 0o644); err != nil {
138 t.Fatal(err)
139 }
140 if err := update.WriteStatus(dir, update.Status{Time: "2026-10-22T12:00:00Z", SHA: sha, Result: "failed", Error: "exit 1"}); err != nil {
141 t.Fatal(err)
142 }
143 req, err = http.NewRequest(http.MethodGet, ts.URL+"/api/v1/admin/self-update", nil)
144 if err != nil {
145 t.Fatal(err)
146 }
147 req.Header.Set("Authorization", "Bearer sleutel-voor-de-test")
148 res, err = http.DefaultClient.Do(req)
149 if err != nil {
150 t.Fatal(err)
151 }
152 body = read(t, res)
153 if res.StatusCode != 200 || !strings.Contains(body, `"running":0`) || !strings.Contains(body, `"started_at":"2026-10-22T12:00:00Z"`) || !strings.Contains(body, `"sha":"`+sha+`"`) || !strings.Contains(body, `"result":"failed"`) || !strings.Contains(body, `"status":"failed"`) || !strings.Contains(body, `"error":"exit 1"`) {
154 t.Fatalf("logstatus %d %s", res.StatusCode, body)
155 }
156 if !strings.Contains(body, "regel 6\\nregel 7") || strings.Contains(body, "regel 5\\n") {
157 t.Fatalf("logstaart hoort bij regel 6 te beginnen:\n%s", body)
158 }
159
160 if err := update.WriteStatus(dir, update.Status{Time: time.Now().UTC().Format(time.RFC3339), SHA: sha, Result: "running"}); err != nil {
161 t.Fatal(err)
162 }
163 started = ""
164 res = post("sleutel-voor-de-test", "")
165 if res.StatusCode != http.StatusConflict {
166 t.Fatalf("bezig %d %s", res.StatusCode, read(t, res))
167 }
168 _ = read(t, res)
169 if started != "" {
170 t.Fatal("een lopende update startte opnieuw")
171 }
172}
173
174func TestSelfUpdateRateLimit(t *testing.T) {
175 t.Setenv(update.TokenEnv, "sleutel-voor-de-test")
176 _, ts, _ := newUpdateServer(t)
177 var last int
178 for i := 0; i < updateLimit+1; i++ {
179 req, err := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/admin/self-update", bytes.NewReader(nil))
180 if err != nil {
181 t.Fatal(err)
182 }
183 req.Header.Set("Authorization", "Bearer fout")
184 res, err := http.DefaultClient.Do(req)
185 if err != nil {
186 t.Fatal(err)
187 }
188 last = res.StatusCode
189 _ = read(t, res)
190 }
191 if last != http.StatusTooManyRequests {
192 t.Fatalf("rate limit %d", last)
193 }
194}
195
196func TestUpdateStatusOnAdminPages(t *testing.T) {
197 dirSetup := func(t *testing.T) (*httptest.Server, string) {
198 t.Helper()
199 _, ts, dir := newUpdateServer(t)
200 sha := "abcdef1234567890abcdef1234567890abcdef12"
201 if err := update.WriteStatus(dir, update.Status{Time: "2026-10-22T12:00:00Z", SHA: sha, Result: "ok"}); err != nil {
202 t.Fatal(err)
203 }
204 return ts, sha
205 }
206 ts, sha := dirSetup(t)
207 anon, err := http.Get(ts.URL + "/-/info")
208 if err != nil {
209 t.Fatal(err)
210 }
211 anonBody := read(t, anon)
212 if strings.Contains(anonBody, sha) || strings.Contains(anonBody, "data-update") {
213 t.Fatal("anonieme infopagina toont de update")
214 }
215
216 jar, _ := cookiejar.New(nil)
217 client := &http.Client{Jar: jar}
218 res, err := client.Get(ts.URL + "/login")
219 if err != nil {
220 t.Fatal(err)
221 }
222 _ = read(t, res)
223 for _, path := range []string{"/-/info", "/setup"} {
224 res, err = client.Get(ts.URL + path)
225 if err != nil {
226 t.Fatal(err)
227 }
228 body := read(t, res)
229 if res.StatusCode != 200 || !strings.Contains(body, "data-update") || !strings.Contains(body, sha) || !strings.Contains(body, "succeeded") {
230 t.Fatalf("%s mist de update (%d):\n%s", path, res.StatusCode, body)
231 }
232 }
233}