BlueGit

timfa bluegit

Files

bluegit / scripts / self_update_test.go

self_update_test.go

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