BlueGit

timfa bluegit

Files

bluegit / scripts / self_update_test.go

self_update_test.go

fix: markeer dode jobs na herstart en verplaats de self-update-poll
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed e5b8fc72 History
self_update_test.go 7.3 KiB Download Raw
1package scripts
2
3import (
4 "context"
5 "net/http"
6 "net/http/httptest"
7 "os"
8 "os/exec"
9 "path/filepath"
10 "strings"
11 "sync"
12 "testing"
13 "time"
14)
15
16func TestSelfUpdateWaitsForOwnSHA(t *testing.T) {
17 if _, err := exec.LookPath("bash"); err != nil {
18 t.Skip("bash ontbreekt")
19 }
20 if _, err := exec.LookPath("curl"); err != nil {
21 t.Skip("curl ontbreekt")
22 }
23 if _, err := exec.LookPath("jq"); err != nil {
24 t.Skip("jq ontbreekt")
25 }
26 script := filepath.Join("..", "scripts", "wait-self-update.sh")
27 sha := "0123456789abcdef0123456789abcdef01234567"
28 other := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
29
30 t.Run("ok na running", func(t *testing.T) {
31 var posts int
32 var gets int
33 srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
34 if r.URL.Path != "/api/v1/admin/self-update" {
35 http.NotFound(w, r)
36 return
37 }
38 if r.Method == http.MethodPost {
39 posts++
40 w.WriteHeader(http.StatusAccepted)
41 _, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`))
42 return
43 }
44 gets++
45 w.Header().Set("Content-Type", "application/json")
46 if gets < 3 {
47 _, _ = w.Write([]byte(`{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":"","update":{"sha":"` + sha + `","result":"running"}}`))
48 return
49 }
50 // log bevat een andere status. Alleen het veld ervoor telt.
51 _, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":"zie \"status\":\"failed\"","update":{"sha":"` + sha + `","result":"ok"}}`))
52 }))
53 t.Cleanup(srv.Close)
54 out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
55 if err != nil {
56 t.Fatalf("wacht: %v %s", err, out)
57 }
58 if posts != 0 || gets < 3 || !strings.Contains(out, "self-update ok voor "+sha) {
59 t.Fatalf("posts %d gets %d\n%s", posts, gets, out)
60 }
61 })
62
63 t.Run("andere sha telt niet", func(t *testing.T) {
64 var gets int
65 srv := statusServer(t, func(gets int) string {
66 if gets == 1 {
67 return `{"running":0,"status":"ok","sha":"` + other + `","result":"ok","log":""}`
68 }
69 return `{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}`
70 }, &gets)
71 out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
72 if err != nil {
73 t.Fatalf("wacht: %v %s", err, out)
74 }
75 if gets < 2 {
76 t.Fatalf("stops bij de vorige sha, gets %d\n%s", gets, out)
77 }
78 })
79
80 t.Run("log staat vooraan", func(t *testing.T) {
81 var gets int
82 // De live response begint met log. Daarin staat een nep-status en een nep-sha.
83 running := `{"log":"Self-update naar iets\n\"status\":\"ok\"\n\"sha\":\"` + sha + `\"","running":1,"status":"running","sha":"` + sha + `","result":"running"}`
84 done := `{"log":"klaar\n\"status\":\"ok\"\n\"sha\":\"ffffffffffffffffffffffffffffffffffffffff\"","running":0,"status":"ok","sha":"` + sha + `","result":"ok"}`
85 if !strings.HasPrefix(running, `{"log":`) || !strings.HasPrefix(done, `{"log":`) {
86 t.Fatal("log hoort de eerste key te zijn")
87 }
88 srv := statusServer(t, func(n int) string {
89 if n == 1 {
90 return running
91 }
92 return done
93 }, &gets)
94 out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
95 if err != nil {
96 t.Fatalf("wacht: %v %s", err, out)
97 }
98 if gets < 2 || !strings.Contains(out, "self-update ok voor "+sha) {
99 t.Fatalf("nep-status in log telde mee, gets %d\n%s", gets, out)
100 }
101 })
102
103 t.Run("failed faalt meteen", func(t *testing.T) {
104 srv := statusServer(t, func(int) string {
105 return `{"running":0,"status":"failed","sha":"` + sha + `","result":"failed","log":"exit 1"}`
106 }, nil)
107 out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
108 if err == nil || !strings.Contains(out, "Self-update mislukt: "+sha) {
109 t.Fatalf("failed hoort te stoppen: %v %s", err, out)
110 }
111 })
112
113 t.Run("timeout", func(t *testing.T) {
114 srv := statusServer(t, func(int) string {
115 return `{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":""}`
116 }, nil)
117 out, err := runSelfUpdate(t, script, srv.URL, sha, "0", "0")
118 if err == nil || !strings.Contains(out, "Self-update timeout na 0s") {
119 t.Fatalf("timeout: %v %s", err, out)
120 }
121 })
122
123 t.Run("korte storing tijdens herstart", func(t *testing.T) {
124 var gets int
125 var mu sync.Mutex
126 srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
127 if r.Method == http.MethodPost {
128 w.WriteHeader(http.StatusAccepted)
129 _, _ = w.Write([]byte(`{"status":"accepted"}`))
130 return
131 }
132 mu.Lock()
133 gets++
134 n := gets
135 mu.Unlock()
136 if n == 1 {
137 hj, ok := w.(http.Hijacker)
138 if !ok {
139 http.Error(w, "down", http.StatusBadGateway)
140 return
141 }
142 conn, _, err := hj.Hijack()
143 if err != nil {
144 return
145 }
146 _ = conn.Close()
147 return
148 }
149 _, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}`))
150 }))
151 t.Cleanup(srv.Close)
152 out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
153 if err != nil {
154 t.Fatalf("na herstart: %v %s", err, out)
155 }
156 })
157}
158
159func TestSelfUpdatePostsWithoutWaiting(t *testing.T) {
160 if _, err := exec.LookPath("bash"); err != nil {
161 t.Skip("bash ontbreekt")
162 }
163 if _, err := exec.LookPath("curl"); err != nil {
164 t.Skip("curl ontbreekt")
165 }
166 script := filepath.Join("..", "scripts", "self-update.sh")
167 sha := "0123456789abcdef0123456789abcdef01234567"
168 var posts, gets int
169 srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
170 if r.URL.Path != "/api/v1/admin/self-update" {
171 http.NotFound(w, r)
172 return
173 }
174 if r.Method == http.MethodPost {
175 posts++
176 w.WriteHeader(http.StatusAccepted)
177 _, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`))
178 return
179 }
180 gets++
181 select {}
182 }))
183 t.Cleanup(srv.Close)
184 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
185 t.Cleanup(cancel)
186 cmd := exec.CommandContext(ctx, "bash", script)
187 cmd.Env = append(os.Environ(),
188 "CI_API_URL="+srv.URL+"/api/v1",
189 "BLUEGIT_UPDATE_TOKEN=test-token",
190 "CI_COMMIT_SHA="+sha,
191 )
192 out, err := cmd.CombinedOutput()
193 if err != nil {
194 t.Fatalf("post: %v %s", err, out)
195 }
196 if posts != 1 || gets != 0 || !strings.Contains(string(out), "Self-update gestart: "+sha) {
197 t.Fatalf("posts %d gets %d\n%s", posts, gets, out)
198 }
199 raw, err := os.ReadFile(script)
200 if err != nil {
201 t.Fatal(err)
202 }
203 if strings.Contains(string(raw), "jq") || strings.Contains(string(raw), "while true") {
204 t.Fatal("self-update.sh polt nog")
205 }
206}
207
208func statusServer(t *testing.T, body func(gets int) string, gets *int) *httptest.Server {
209 t.Helper()
210 var n int
211 var mu sync.Mutex
212 srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
213 if r.URL.Path != "/api/v1/admin/self-update" {
214 http.NotFound(w, r)
215 return
216 }
217 if r.Method == http.MethodPost {
218 w.WriteHeader(http.StatusAccepted)
219 _, _ = w.Write([]byte(`{"status":"accepted"}`))
220 return
221 }
222 mu.Lock()
223 n++
224 cur := n
225 if gets != nil {
226 *gets = n
227 }
228 mu.Unlock()
229 w.Header().Set("Content-Type", "application/json")
230 _, _ = w.Write([]byte(body(cur)))
231 }))
232 t.Cleanup(srv.Close)
233 return srv
234}
235
236func runSelfUpdate(t *testing.T, script, base, sha, timeout, interval string) (string, error) {
237 t.Helper()
238 cmd := exec.Command("bash", script)
239 cmd.Env = append(os.Environ(),
240 "CI_API_URL="+base+"/api/v1",
241 "BLUEGIT_UPDATE_TOKEN=test-token",
242 "CI_COMMIT_SHA="+sha,
243 "SELF_UPDATE_TIMEOUT="+timeout,
244 "SELF_UPDATE_INTERVAL="+interval,
245 )
246 out, err := cmd.CombinedOutput()
247 return string(out), err
248}