BlueGit

timfa bluegit

Files

bluegit / internal / server / fork_sync_test.go

fork_sync_test.go

fork_sync_test.go 4.4 KiB Download Raw
1package server
2
3import (
4 "context"
5 "gitlab.com/Timfa/bluegit/internal/gitrepo"
6 "net/http"
7 "net/http/httptest"
8 "os/exec"
9 "path/filepath"
10 "strings"
11 "testing"
12 "time"
13
14 "gitlab.com/Timfa/bluegit/internal/auth"
15 "gitlab.com/Timfa/bluegit/internal/config"
16 "gitlab.com/Timfa/bluegit/internal/store"
17)
18
19func TestForkSyncUpstream(t *testing.T) {
20 if _, err := exec.LookPath("git"); err != nil {
21 t.Skip("git ontbreekt")
22 }
23 storage := t.TempDir()
24 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
25 if err != nil {
26 t.Fatal(err)
27 }
28 t.Cleanup(func() { _ = st.Close() })
29 ctx := context.Background()
30 ada, err := st.UpsertUser(ctx, 1, "ada", "", false)
31 if err != nil {
32 t.Fatal(err)
33 }
34 dev, err := st.UpsertUser(ctx, 2, "dev", "", false)
35 if err != nil {
36 t.Fatal(err)
37 }
38 issue := func(u store.User) string {
39 plain, _, err := st.IssueToken(ctx, u.ID, store.TokenRequest{Name: u.Username, Scopes: "api", ExpiresAt: time.Time{}})
40 if err != nil {
41 t.Fatal(err)
42 }
43 return plain
44 }
45 adaTok, devTok := issue(ada), issue(dev)
46 cfg := config.Config{
47 BaseURL: "http://127.0.0.1:9", StoragePath: storage,
48 Auth: config.Auth{Mode: "dev", DevUser: "ada", DevAuthID: 1},
49 Git: config.Git{Binary: "git", DefaultBranch: "master"},
50 }
51 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "ada", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true", StateDir: t.TempDir()}
52 ts := httptest.NewServer(srv.Handler())
53 t.Cleanup(ts.Close)
54
55 call := func(method, path, token, body string) (int, string) {
56 t.Helper()
57 req, _ := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
58 if body != "" {
59 req.Header.Set("Content-Type", "application/json")
60 }
61 req.Header.Set("Authorization", "Bearer "+token)
62 res, err := http.DefaultClient.Do(req)
63 if err != nil {
64 t.Fatal(err)
65 }
66 return res.StatusCode, read(t, res)
67 }
68 if code, body := call(http.MethodPost, "/api/v1/projects", adaTok, `{"name":"App","visibility":"public","initialize_with_readme":true}`); code != 201 {
69 t.Fatalf("project %d %s", code, body)
70 }
71 app, _ := st.RepoByPath(ctx, "ada", "app")
72 if code, body := call(http.MethodPost, "/api/v1/projects/ada/app/fork", devTok, `{}`); code != 201 {
73 t.Fatalf("fork %d %s", code, body)
74 }
75 updir := gitrepo.Dir(storage, "ada", "app")
76 fdir := gitrepo.Dir(storage, "dev", "app")
77 commit := func(dir, msg string) string {
78 t.Helper()
79 tree, _ := exec.Command("git", "-C", dir, "rev-parse", "master^{tree}").Output()
80 cmd := exec.Command("git", "-C", dir, "commit-tree", strings.TrimSpace(string(tree)), "-p", "master", "-m", msg)
81 cmd.Env = append(cmd.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x")
82 out, err := cmd.Output()
83 if err != nil {
84 t.Fatal(err)
85 }
86 sha := strings.TrimSpace(string(out))
87 if out, err := exec.Command("git", "-C", dir, "update-ref", "refs/heads/master", sha).CombinedOutput(); err != nil {
88 t.Fatalf("%s", out)
89 }
90 return sha
91 }
92 up1 := commit(updir, "upstream 1")
93 code, body := call(http.MethodPost, "/api/v1/projects/dev/app/sync-upstream", devTok, `{}`)
94 if code != 200 || !strings.Contains(body, up1) {
95 t.Fatalf("sync: %d %s", code, body)
96 }
97 if code, body := call(http.MethodPost, "/api/v1/projects/dev/app/sync-upstream", devTok, `{"branch":"master"}`); code != 200 || !strings.Contains(body, `"up_to_date":true`) {
98 t.Fatalf("up to date: %d %s", code, body)
99 }
100 // ada (geen schrijfrechten op de fork) mag niet
101 if code, _ := call(http.MethodPost, "/api/v1/projects/dev/app/sync-upstream", adaTok, `{}`); code != 403 && code != 404 {
102 t.Fatalf("ada: %d", code)
103 }
104 // afgeweken: 409, niets overschreven
105 mine := commit(fdir, "eigen")
106 commit(updir, "upstream 2")
107 if code, body := call(http.MethodPost, "/api/v1/projects/dev/app/sync-upstream", devTok, `{}`); code != 409 {
108 t.Fatalf("diverged: %d %s", code, body)
109 }
110 if out, _ := exec.Command("git", "-C", fdir, "rev-parse", "master").Output(); strings.TrimSpace(string(out)) != mine {
111 t.Fatal("fork overschreven")
112 }
113 if code, _ := call(http.MethodPost, "/api/v1/projects/dev/app/sync-upstream", devTok, `{"branch":"nope"}`); code != 404 {
114 t.Fatalf("onbekende branch: %d", code)
115 }
116 // upstream wordt privé: dev heeft geen toegang meer
117 if err := st.UpdateRepo(ctx, app.ID, "", "private"); err != nil {
118 t.Fatal(err)
119 }
120 code, body = call(http.MethodPost, "/api/v1/projects/dev/app/sync-upstream", devTok, `{}`)
121 if code != 403 || strings.Contains(body, "ada/app") {
122 t.Fatalf("privé upstream: %d %s", code, body)
123 }
124}