package server

import (
	"context"
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"

	"gitlab.com/Timfa/bluegit/internal/auth"
	"gitlab.com/Timfa/bluegit/internal/backup"
	"gitlab.com/Timfa/bluegit/internal/config"
	"gitlab.com/Timfa/bluegit/internal/store"
)

type backupEnv struct {
	srv  *Server
	st   *store.Store
	base string
	tim  store.User
	tok  string
}

func newBackupEnv(t *testing.T) *backupEnv {
	t.Helper()
	stateDir, storage := t.TempDir(), t.TempDir()
	st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	_ = os.WriteFile(filepath.Join(stateDir, "secret.key"), bytes32(), 0o600)
	cfg := config.Config{
		Listen: "127.0.0.1:0", StoragePath: storage, StatePath: stateDir,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: stateDir}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	srv.Cfg.BaseURL = ts.URL
	tim, err := st.UpsertUser(context.Background(), 1, "tim", "", false)
	if err != nil {
		t.Fatal(err)
	}
	if !tim.InstanceAdmin {
		t.Skip("eerste gebruiker is geen beheerder")
	}
	_ = os.MkdirAll(filepath.Join(storage, "repos", "tim", "app.git"), 0o755)
	_ = os.WriteFile(filepath.Join(storage, "repos", "tim", "app.git", "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
	srv.backupInit()
	srv.backupNote.Delay = 20 * time.Millisecond
	return &backupEnv{srv: srv, st: st, base: ts.URL, tim: tim, tok: issue(t, st, tim.ID, "api")}
}

func keyed(t *testing.T, method, u, key string, body io.Reader) (int, []byte) {
	t.Helper()
	req, _ := http.NewRequest(method, u, body)
	if key != "" {
		req.Header.Set("Authorization", "Bearer "+key)
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	return res.StatusCode, b
}

// fakeBackup speelt de backup server: hij controleert elke handtekening.
type fakeBackup struct {
	mu       sync.Mutex
	secret   string
	notifies int
	rollback []string
	calls    []string
	bodies   map[string]string
	badSig   int
	ts       *httptest.Server
}

func newFakeBackup(t *testing.T) *fakeBackup {
	f := &fakeBackup{}
	f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, _ := io.ReadAll(r.Body)
		f.mu.Lock()
		defer f.mu.Unlock()
		if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
			f.badSig++
			http.Error(w, `{"error":"sig"}`, 401)
			return
		}
		switch r.URL.Path {
		case "/api/v1/notify":
			f.notifies++
			w.WriteHeader(204)
		case "/api/v1/archives":
			_ = json.NewEncoder(w).Encode(map[string]any{"archives": []backup.Archive{{Name: "bluegit-20261115-120000.tar.gz", CreatedAt: time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC), Size: 3 << 20}}})
		case "/api/v1/status":
			_, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
		case "/api/v1/rollback":
			var in struct{ Archive string }
			_ = json.Unmarshal(body, &in)
			f.rollback = append(f.rollback, in.Archive)
			w.WriteHeader(202)
		case "/api/v1/admin/actions":
			_, _ = w.Write([]byte(`{"actions":[
				{"name":"status","method":"GET","path":"/api/v1/admin/status","bluegit":true},
				{"name":"config","method":"GET","path":"/api/v1/admin/config","bluegit":true},
				{"name":"config.update","method":"PUT","path":"/api/v1/admin/config","bluegit":true},
				{"name":"sync","method":"POST","path":"/api/v1/admin/sync","bluegit":true},
				{"name":"archive.delete","method":"DELETE","path":"/api/v1/admin/archives/{name}","bluegit":true,"params":["name"]},
				{"name":"archive.download","method":"GET","path":"/api/v1/admin/archives/{name}/download","params":["name"]},
				{"name":"rollback","method":"POST","path":"/api/v1/admin/rollback","bluegit":true},
				{"name":"disconnect","method":"POST","path":"/api/v1/admin/disconnect","bluegit":true}]}`))
		case "/api/v1/admin/config":
			if r.Method == "PUT" {
				f.calls = append(f.calls, "PUT config")
				if f.bodies == nil {
					f.bodies = map[string]string{}
				}
				f.bodies["config"] = string(body)
			}
			_, _ = w.Write([]byte(`{"fields":[{"key":"archive_interval","label":"Archiefinterval","kind":"duration","value":"24h"},{"key":"retention_days","label":"Bewaartermijn","kind":"int","value":"30"}],"data_dir":"/var/lib/bluegit-backup"}`))
		case "/api/v1/admin/rollback":
			var in struct{ Archive, Confirm string }
			_ = json.Unmarshal(body, &in)
			if in.Confirm != in.Archive {
				http.Error(w, `{"error":"confirm"}`, 400)
				return
			}
			f.rollback = append(f.rollback, in.Archive)
			w.WriteHeader(202)
		default:
			if r.URL.Path == "/api/v1/admin/sync" || r.URL.Path == "/api/v1/admin/disconnect" || strings.HasPrefix(r.URL.Path, "/api/v1/admin/archives/") {
				f.calls = append(f.calls, r.Method+" "+r.URL.Path+" "+string(body))
				_, _ = w.Write([]byte(`{}`))
				return
			}
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(f.ts.Close)
	return f
}

type addedServer struct {
	ID  string `json:"id"`
	Key string `json:"key"`
}

func addBackupServer(t *testing.T, e *backupEnv, name string) addedServer {
	t.Helper()
	code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers", map[string]any{"name": name})
	if code != 201 {
		t.Fatalf("server toevoegen: %d %s", code, b)
	}
	var a addedServer
	_ = json.Unmarshal(b, &a)
	if !strings.HasPrefix(a.Key, "bgbk_") || a.ID == "" {
		t.Fatalf("%s", b)
	}
	return a
}

func TestBackupKeyAndKeyedAPI(t *testing.T) {
	e := newBackupEnv(t)
	// Zonder key: 401. Met een gewoon toegangstoken: ook 401.
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
		t.Fatalf("zonder key: %d", code)
	}
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
		t.Fatalf("bg_-token: %d", code)
	}
	// Alleen een beheerder maakt een backup server.
	bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
	if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/servers", map[string]any{"name": "x"}); code != 403 {
		t.Fatalf("bob maakt server: %d", code)
	}
	k := addBackupServer(t, e, "nas")
	code, b := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
	var info struct {
		InstanceID string `json:"instance_id"`
		Name       string `json:"name"`
	}
	_ = json.Unmarshal(b, &info)
	if code != 200 || info.InstanceID == "" || info.Name != "nas" {
		t.Fatalf("info: %d %s", code, b)
	}
	code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
	var m backup.Manifest
	_ = json.Unmarshal(b, &m)
	if code != 200 || m.Instance != info.InstanceID {
		t.Fatalf("manifest: %d %.300s", code, b)
	}
	have := map[string]bool{}
	for _, f := range m.Files {
		have[f.Path] = true
	}
	for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
		if !have[want] {
			t.Fatalf("manifest mist %s: %v", want, have)
		}
	}
	code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
	if code != 200 || string(b) != "ref: refs/heads/master\n" {
		t.Fatalf("file: %d %q", code, b)
	}
	code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
	if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
		t.Fatalf("db-kopie: %d %.20q", code, b)
	}
	for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
		if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
			t.Fatalf("%s: %d", bad, code)
		}
	}
	// Een tweede server met een eigen key; nieuwe key voor de eerste.
	k2 := addBackupServer(t, e, "offsite")
	code, b = rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+k.ID+"/key", nil)
	var rot addedServer
	_ = json.Unmarshal(b, &rot)
	if code != 201 || rot.Key == k.Key {
		t.Fatalf("nieuwe key: %d %s", code, b)
	}
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
		t.Fatalf("oude key werkt nog: %d", code)
	}
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 200 {
		t.Fatalf("nieuwe key: %d", code)
	}
	if code, b := rapi(t, e.base, e.tok, "PUT", "/admin/backup/servers/"+k2.ID, map[string]any{"name": "Offsite 2"}); code != 200 || !strings.Contains(string(b), "Offsite 2") {
		t.Fatalf("hernoemen: %d %s", code, b)
	}
	// Verwijderen: die key werkt niet meer, de andere wel.
	if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+k.ID, nil); code != 204 {
		t.Fatalf("verwijderen: %d", code)
	}
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", rot.Key, nil); code != 401 {
		t.Fatalf("na verwijderen: %d", code)
	}
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k2.Key, nil); code != 200 {
		t.Fatalf("andere server: %d", code)
	}
	if code, _ := rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/onbekend", nil); code != 404 {
		t.Fatalf("onbekend: %d", code)
	}
}

func TestBackupMultipleServersAndControl(t *testing.T) {
	e := newBackupEnv(t)
	fa, fb := newFakeBackup(t), newFakeBackup(t)
	ka, kb := addBackupServer(t, e, "nas"), addBackupServer(t, e, "offsite")
	fa.secret, fb.secret = backup.SigningSecret(ka.Key), backup.SigningSecret(kb.Key)
	for _, c := range []struct {
		key, url string
	}{{ka.Key, fa.ts.URL}, {kb.Key, fb.ts.URL}} {
		code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", c.key, strings.NewReader(`{"server_url":"`+c.url+`","server_id":"s"}`))
		if code != 200 {
			t.Fatalf("connect: %d %s", code, b)
		}
	}
	if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", ka.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
		t.Fatalf("ftp-adres: %d", code)
	}

	// Een schrijvende actie geeft een ondertekende melding aan beide.
	if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
		t.Fatalf("project: %d %s", code, b)
	}
	deadline := time.Now().Add(5 * time.Second)
	for {
		fa.mu.Lock()
		na := fa.notifies
		fa.mu.Unlock()
		fb.mu.Lock()
		nb := fb.notifies
		fb.mu.Unlock()
		if na > 0 && nb > 0 {
			break
		}
		if time.Now().After(deadline) {
			t.Fatalf("meldingen: %d en %d", na, nb)
		}
		time.Sleep(20 * time.Millisecond)
	}

	// Lijst via de API en op de pagina.
	code, b := rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
	if code != 200 || strings.Count(string(b), `"connected":true`) != 2 {
		t.Fatalf("admin backup: %d %s", code, b)
	}
	code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup/servers/"+ka.ID, nil)
	if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"retention_days"`) {
		t.Fatalf("server: %d %s", code, b)
	}
	tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
	res, _ := tc.Get(e.base + "/admin/backup")
	page := body(t, res)
	for _, want := range []string{"nas", "offsite", `/admin/backup/s/` + ka.ID, `/admin/backup/s/` + kb.ID, `href="/admin/backup"`} {
		if !strings.Contains(page, want) {
			t.Fatalf("lijst mist %s: %.600s", want, page)
		}
	}
	res, _ = tc.Get(e.base + "/admin/backup/s/" + ka.ID)
	page = body(t, res)
	for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`,
		`act/config.update`, `name="retention_days" value="30"`, `act/sync`, `act/archive.delete`} {
		if !strings.Contains(page, want) {
			t.Fatalf("pagina mist %s: %.600s", want, page)
		}
	}

	// Instellingen en sync vanuit BlueGit (formulier en API).
	res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"9"}})
	res.Body.Close()
	if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/sync", nil); code != 200 {
		t.Fatalf("sync: %d %s", code, b)
	}
	if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.download", map[string]any{"name": "x"}); code != 404 {
		t.Fatalf("niet-BlueGit-actie: %d", code)
	}
	if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/archive.delete", map[string]any{"name": "bluegit-20261115-120000.tar.gz"}); code != 200 {
		t.Fatalf("archief verwijderen: %d", code)
	}
	fa.mu.Lock()
	if fa.bodies["config"] != `{"retention_days":"9"}` {
		t.Fatalf("config %q", fa.bodies["config"])
	}
	calls := strings.Join(fa.calls, "|")
	fa.mu.Unlock()
	if !strings.Contains(calls, `POST /api/v1/admin/sync {"wait":"false"}`) || !strings.Contains(calls, "DELETE /api/v1/admin/archives/bluegit-20261115-120000.tar.gz") {
		t.Fatalf("calls %s", calls)
	}

	// Rollback: zonder vinkje niets, verkeerde bevestiging 400, dan goed.
	arch := "bluegit-20261115-120000.tar.gz"
	res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}})
	res.Body.Close()
	if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": "ja"}); code != 400 {
		t.Fatalf("verkeerde bevestiging: %d", code)
	}
	fa.mu.Lock()
	if len(fa.rollback) != 0 {
		t.Fatal("rollback zonder vinkje of bevestiging")
	}
	fa.mu.Unlock()
	res, _ = tc.PostForm(e.base+"/admin/backup/s/"+ka.ID+"/act/rollback", url.Values{"csrf": {csrf}, "archive": {arch}, "confirm": {arch}, "understood": {"1"}})
	res.Body.Close()
	if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/servers/"+ka.ID+"/actions/rollback", map[string]any{"archive": arch, "confirm": arch}); code != 202 {
		t.Fatalf("rollback api: %d %s", code, b)
	}
	// Verwijderen laat de backup server ontkoppelen.
	if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/servers/"+kb.ID, nil); code != 204 {
		t.Fatalf("verwijderen: %d", code)
	}
	fb.mu.Lock()
	if !strings.Contains(strings.Join(fb.calls, "|"), "POST /api/v1/admin/disconnect") {
		t.Fatalf("geen disconnect: %v", fb.calls)
	}
	fb.mu.Unlock()
	fa.mu.Lock()
	defer fa.mu.Unlock()
	if len(fa.rollback) != 2 || fa.badSig != 0 {
		t.Fatalf("rollbacks %v, foute handtekeningen %d", fa.rollback, fa.badSig)
	}
}

func TestBackupRestoreStagesAndRestarts(t *testing.T) {
	e := newBackupEnv(t)
	restarted := make(chan struct{}, 1)
	e.srv.RequestRestart = func() { restarted <- struct{}{} }
	k := addBackupServer(t, e, "nas")
	// Ongeldig archief: 400, niets klaargezet.
	if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
		t.Fatalf("ongeldig: %d", code)
	}
	if backup.HasPending(e.srv.StateDir) {
		t.Fatal("READY na fout")
	}
	// Een archief uit het eigen manifest terugsturen.
	tarball := buildTarFromInstance(t, e, k.Key)
	code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
	if code != 202 {
		t.Fatalf("restore: %d %s", code, b)
	}
	select {
	case <-restarted:
	case <-time.After(3 * time.Second):
		t.Fatal("geen herstart")
	}
	if !backup.HasPending(e.srv.StateDir) {
		t.Fatal("geen READY")
	}
	restoreBusy.Store(false)
}

func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
	t.Helper()
	_, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
	var m backup.Manifest
	_ = json.Unmarshal(b, &m)
	var sb strings.Builder
	files := map[string]string{}
	for _, f := range m.Files {
		_, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
		files[f.Path] = string(data)
	}
	writeTarGz(t, &sb, files)
	return sb.String()
}

// Feature: beheerders zien bovenaan elke pagina een banner als een backup
// server niet bij deze BlueGit past; BlueGit weigert dan gegevens uit te
// wisselen (426), maar info en connect blijven werken.
func TestBackupCompatBanner(t *testing.T) {
	e := newBackupEnv(t)
	k := addBackupServer(t, e, "nas")
	call := func(method, path, proto, min string, body io.Reader) (int, []byte, http.Header) {
		req, _ := http.NewRequest(method, e.base+path, body)
		req.Header.Set("Authorization", "Bearer "+k.Key)
		if proto != "" {
			req.Header.Set(backup.HeaderBackupProtocol, proto)
			req.Header.Set(backup.HeaderBackupMinProtocol, min)
			req.Header.Set(backup.HeaderBackupVersion, "v9.9.9")
		}
		res, err := http.DefaultClient.Do(req)
		if err != nil {
			t.Fatal(err)
		}
		defer res.Body.Close()
		b, _ := io.ReadAll(res.Body)
		return res.StatusCode, b, res.Header
	}
	// Een backup server zonder koppen (v0.1.0) spreekt protocol 1: past.
	if code, b, h := call("POST", "/api/v1/backup/connect", "", "", strings.NewReader(`{"server_url":"http://127.0.0.1:9","server_id":"s"}`)); code != 200 || h.Get(backup.HeaderBlueGitProtocol) != "1" {
		t.Fatalf("connect: %d %s %v", code, b, h)
	}
	if code, _, _ := call("GET", "/api/v1/backup/manifest", "", "", nil); code != 200 {
		t.Fatalf("manifest v1: %d", code)
	}
	tim, _ := sessionClient(t, e.st, e.base, e.tim.ID)
	bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
	bobc, _ := sessionClient(t, e.st, e.base, bob.ID)
	page := func(c *http.Client, p string) string {
		res, err := c.Get(e.base + p)
		if err != nil {
			t.Fatal(err)
		}
		return body(t, res)
	}
	if strings.Contains(page(tim, "/"), "compat-banner") {
		t.Fatal("banner terwijl alles past")
	}

	// De backup server vraagt minstens protocol 9: BlueGit is te oud.
	code, b, _ := call("GET", "/api/v1/backup/info", "9", "9", nil)
	if code != 200 || !strings.Contains(string(b), `"compat":"bluegit_too_old"`) || !strings.Contains(string(b), `"protocol":1`) {
		t.Fatalf("info: %d %s", code, b)
	}
	code, b, _ = call("GET", "/api/v1/backup/manifest", "9", "9", nil)
	if code != http.StatusUpgradeRequired || !strings.Contains(string(b), "bluegit_too_old") {
		t.Fatalf("manifest bij te oude BlueGit: %d %s", code, b)
	}
	for _, p := range []string{"/", "/users/tim", "/admin/backup", "/-/info", "/help"} {
		html := page(tim, p)
		if !strings.Contains(html, `class="compat-banner"`) || !strings.Contains(html, "nas") || !strings.Contains(html, `href="/admin/backup"`) || !strings.Contains(html, "Update BlueGit") {
			t.Fatalf("%s: geen banner voor de beheerder:\n%.2000s", p, html)
		}
	}
	if html := page(bobc, "/"); strings.Contains(html, "compat-banner") || strings.Contains(html, "nas") {
		t.Fatal("niet-beheerder ziet de banner")
	}
	// Ook in de API voor beheerders.
	if code, b := rapi(t, e.base, e.tok, "GET", "/admin/backup", nil); code != 200 || !strings.Contains(string(b), `"compat":"bluegit_too_old"`) {
		t.Fatalf("api: %d %s", code, b)
	}

	// BlueGit vraagt minstens protocol 3; de backup server spreekt 2.
	restore := backup.OverrideProtocol("4", "3")
	defer restore()
	code, b, _ = call("GET", "/api/v1/backup/manifest", "2", "1", nil)
	if code != http.StatusUpgradeRequired || !strings.Contains(string(b), "backup_too_old") {
		t.Fatalf("manifest bij te oude backup server: %d %s", code, b)
	}
	if html := page(tim, "/"); !strings.Contains(html, "The backup server is out of date") {
		t.Fatalf("banner zegt niet dat de backup server te oud is:\n%.2000s", html)
	}
	// Bijgewerkt: de banner verdwijnt.
	if code, _, _ := call("GET", "/api/v1/backup/manifest", "4", "1", nil); code != 200 {
		t.Fatalf("na update: %d", code)
	}
	if strings.Contains(page(tim, "/"), "compat-banner") {
		t.Fatal("banner blijft na de update")
	}
}
