package scripts import ( "net/http" "net/http/httptest" "os" "os/exec" "path/filepath" "strings" "sync" "testing" ) func TestSelfUpdateWaitsForOwnSHA(t *testing.T) { if _, err := exec.LookPath("bash"); err != nil { t.Skip("bash ontbreekt") } if _, err := exec.LookPath("curl"); err != nil { t.Skip("curl ontbreekt") } if _, err := exec.LookPath("jq"); err != nil { t.Skip("jq ontbreekt") } script := filepath.Join("..", "scripts", "self-update.sh") sha := "0123456789abcdef0123456789abcdef01234567" other := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" t.Run("ok na running", func(t *testing.T) { var posts int var gets int srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path != "/api/v1/admin/self-update" { http.NotFound(w, r) return } if r.Method == http.MethodPost { posts++ w.WriteHeader(http.StatusAccepted) _, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`)) return } gets++ w.Header().Set("Content-Type", "application/json") if gets < 3 { _, _ = w.Write([]byte(`{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":"","update":{"sha":"` + sha + `","result":"running"}}`)) return } // log bevat een andere status. Alleen het veld ervoor telt. _, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":"zie \"status\":\"failed\"","update":{"sha":"` + sha + `","result":"ok"}}`)) })) t.Cleanup(srv.Close) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err != nil { t.Fatalf("wacht: %v %s", err, out) } if posts != 1 || gets < 3 || !strings.Contains(out, "Self-update ok: "+sha) { t.Fatalf("posts %d gets %d\n%s", posts, gets, out) } }) t.Run("andere sha telt niet", func(t *testing.T) { var gets int srv := statusServer(t, func(gets int) string { if gets == 1 { return `{"running":0,"status":"ok","sha":"` + other + `","result":"ok","log":""}` } return `{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}` }, &gets) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err != nil { t.Fatalf("wacht: %v %s", err, out) } if gets < 2 { t.Fatalf("stops bij de vorige sha, gets %d\n%s", gets, out) } }) t.Run("log staat vooraan", func(t *testing.T) { var gets int // De live response begint met log. Daarin staat een nep-status en een nep-sha. running := `{"log":"Self-update naar iets\n\"status\":\"ok\"\n\"sha\":\"` + sha + `\"","running":1,"status":"running","sha":"` + sha + `","result":"running"}` done := `{"log":"klaar\n\"status\":\"ok\"\n\"sha\":\"ffffffffffffffffffffffffffffffffffffffff\"","running":0,"status":"ok","sha":"` + sha + `","result":"ok"}` if !strings.HasPrefix(running, `{"log":`) || !strings.HasPrefix(done, `{"log":`) { t.Fatal("log hoort de eerste key te zijn") } srv := statusServer(t, func(n int) string { if n == 1 { return running } return done }, &gets) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err != nil { t.Fatalf("wacht: %v %s", err, out) } if gets < 2 || !strings.Contains(out, "Self-update ok: "+sha) { t.Fatalf("nep-status in log telde mee, gets %d\n%s", gets, out) } }) t.Run("failed faalt meteen", func(t *testing.T) { srv := statusServer(t, func(int) string { return `{"running":0,"status":"failed","sha":"` + sha + `","result":"failed","log":"exit 1"}` }, nil) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err == nil || !strings.Contains(out, "Self-update mislukt: "+sha) { t.Fatalf("failed hoort te stoppen: %v %s", err, out) } }) t.Run("timeout", func(t *testing.T) { srv := statusServer(t, func(int) string { return `{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":""}` }, nil) out, err := runSelfUpdate(t, script, srv.URL, sha, "0", "0") if err == nil || !strings.Contains(out, "Self-update timeout na 0s") { t.Fatalf("timeout: %v %s", err, out) } }) t.Run("korte storing tijdens herstart", func(t *testing.T) { var gets int var mu sync.Mutex srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Method == http.MethodPost { w.WriteHeader(http.StatusAccepted) _, _ = w.Write([]byte(`{"status":"accepted"}`)) return } mu.Lock() gets++ n := gets mu.Unlock() if n == 1 { hj, ok := w.(http.Hijacker) if !ok { http.Error(w, "down", http.StatusBadGateway) return } conn, _, err := hj.Hijack() if err != nil { return } _ = conn.Close() return } _, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}`)) })) t.Cleanup(srv.Close) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err != nil { t.Fatalf("na herstart: %v %s", err, out) } }) } func statusServer(t *testing.T, body func(gets int) string, gets *int) *httptest.Server { t.Helper() var n int var mu sync.Mutex srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path != "/api/v1/admin/self-update" { http.NotFound(w, r) return } if r.Method == http.MethodPost { w.WriteHeader(http.StatusAccepted) _, _ = w.Write([]byte(`{"status":"accepted"}`)) return } mu.Lock() n++ cur := n if gets != nil { *gets = n } mu.Unlock() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(body(cur))) })) t.Cleanup(srv.Close) return srv } func runSelfUpdate(t *testing.T, script, base, sha, timeout, interval string) (string, error) { t.Helper() cmd := exec.Command("bash", script) cmd.Env = append(os.Environ(), "CI_API_URL="+base+"/api/v1", "BLUEGIT_UPDATE_TOKEN=test-token", "CI_COMMIT_SHA="+sha, "SELF_UPDATE_TIMEOUT="+timeout, "SELF_UPDATE_INTERVAL="+interval, ) out, err := cmd.CombinedOutput() return string(out), err }