package runner import ( "context" "path/filepath" "testing" "time" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/store" ) func names(tiers []Tier) []string { var out []string for _, t := range tiers { if t.Builtin { out = append(out, "builtin") continue } s := "" for i, r := range t.Runners { if i > 0 { s += "+" } s += r.Name } out = append(out, s) } return out } func eq(t *testing.T, got []string, want ...string) { t.Helper() if len(got) != len(want) { t.Fatalf("got %v, want %v", got, want) } for i := range got { if got[i] != want[i] { t.Fatalf("got %v, want %v", got, want) } } } func TestOrder(t *testing.T) { own := []store.Runner{{ID: 1, Name: "laptop"}} grp := []store.Runner{{ID: 2, Name: "grp"}} opt := []store.Runner{{ID: 3, Name: "maint"}} eq(t, names(Order("user", store.RunnerPrefOwnFirst, false, own, nil, nil)), "laptop", "builtin") eq(t, names(Order("user", store.RunnerPrefBuiltinFirst, false, own, nil, nil)), "builtin", "laptop") eq(t, names(Order("user", "", false, own, nil, nil)), "builtin", "laptop") eq(t, names(Order("user", store.RunnerPrefOwnFirst, false, nil, nil, nil)), "builtin") eq(t, names(Order("group", "", false, nil, grp, opt)), "grp", "maint", "builtin") eq(t, names(Order("group", "", true, nil, grp, opt)), "builtin", "grp", "maint") eq(t, names(Order("group", "", false, nil, nil, opt)), "maint", "builtin") eq(t, names(Order("group", "", false, nil, grp, nil)), "grp", "builtin") } func TestAdvance(t *testing.T) { now := time.Now() on := store.Runner{ID: 1, Name: "on", LastSeen: now} off := store.Runner{ID: 2, Name: "off", LastSeen: now.Add(-time.Hour)} remoteOn := Tier{Runners: []store.Runner{on}} remoteOff := Tier{Runners: []store.Runner{off}} builtin := Tier{Builtin: true} // Eigen runners eerst, runner online: blijft op de runner wachten. st := Advance([]Tier{remoteOn, builtin}, 0, time.Time{}, now, true) if st.Builtin || st.Tier != 0 || !st.Moved { t.Fatalf("own first online: %+v", st) } // Na de wachttijd gaat de job naar de BlueGit-runner. st = Advance([]Tier{remoteOn, builtin}, 0, now.Add(-OfferTimeout-time.Second), now, true) if !st.Builtin || st.Tier != 1 { t.Fatalf("own first timeout: %+v", st) } // Runner offline: meteen door. st = Advance([]Tier{remoteOff, builtin}, 0, time.Time{}, now, true) if !st.Builtin || st.Tier != 1 { t.Fatalf("offline: %+v", st) } // BlueGit-runner eerst maar vol: door naar de eigen runner. st = Advance([]Tier{builtin, remoteOn}, 0, time.Time{}, now, false) if st.Builtin || st.Tier != 1 || !st.Moved { t.Fatalf("builtin busy: %+v", st) } // BlueGit-runner eerst en vrij: direct. st = Advance([]Tier{builtin, remoteOn}, 0, time.Time{}, now, true) if !st.Builtin || st.Tier != 0 { t.Fatalf("builtin free: %+v", st) } // Groep: groepsrunner offline, maintainer-runner online → wacht daar. st = Advance([]Tier{remoteOff, remoteOn, builtin}, 0, time.Time{}, now, true) if st.Builtin || st.Tier != 1 { t.Fatalf("group fallback: %+v", st) } // Alles bezet en offline: rondje, eindigt weer bij een trede, start niets. st = Advance([]Tier{builtin, remoteOff}, 0, time.Time{}, now, false) if st.Builtin { t.Fatalf("nothing free: %+v", st) } // Wrap: maintainer-runner timeout, builtin vol → terug naar de groepsrunner (online). st = Advance([]Tier{remoteOn, builtin}, 1, now, now, false) if st.Builtin || st.Tier != 0 { t.Fatalf("wrap: %+v", st) } } func TestTiersAndPrivacy(t *testing.T) { dir := t.TempDir() s, err := store.Open(filepath.Join(dir, "b.db"), make([]byte, 32)) if err != nil { t.Fatal(err) } defer s.Close() ctx := context.Background() tim, _ := s.UpsertUser(ctx, 1, "tim", "", false) bob, _ := s.UpsertUser(ctx, 2, "bob", "", false) carol, _ := s.UpsertUser(ctx, 3, "carol", "", false) g, err := s.CreateGroup(ctx, tim.ID, "Team", "team", "", access.RoleReadonly) if err != nil { t.Fatal(err) } if err := s.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper); err != nil { t.Fatal(err) } if err := s.SetMember(ctx, "group", g.ID, "carol", access.RoleMaintainer); err != nil { t.Fatal(err) } grepo, err := s.CreateRepo(ctx, "group", g.ID, "app", "", "master", "private") if err != nil { t.Fatal(err) } trepo, err := s.CreateRepo(ctx, "user", tim.ID, "secret", "", "master", "private") if err != nil { t.Fatal(err) } reg := func(kind string, id int64, name string) store.Runner { tok, err := s.CreateRunnerRegToken(ctx, kind, id, id) if err != nil { t.Fatal(err) } rn, _, err := s.RegisterRunner(ctx, tok, name, "test") if err != nil { t.Fatal(err) } if _, _, err := s.RegisterRunner(ctx, tok, "again", "test"); err == nil { t.Fatal("registration token reused") } return rn } grn := reg("group", g.ID, "grp") bobRn := reg("user", bob.ID, "bob-pc") carolRn := reg("user", carol.ID, "carol-pc") timRn := reg("user", tim.ID, "tim-pc") dave, _ := s.UpsertUser(ctx, 4, "dave", "", false) reg("user", dave.ID, "dave-pc") _ = s.SetRunnerOptIn(ctx, g.ID, dave.ID, true) // geen lid, geen leesrecht: telt niet tiers, err := Tiers(ctx, s, grepo, false) if err != nil { t.Fatal(err) } eq(t, names(tiers), "grp", "builtin") _ = s.SetRunnerOptIn(ctx, g.ID, bob.ID, true) // lid (developer): telt tiers, _ = Tiers(ctx, s, grepo, false) eq(t, names(tiers), "grp", "bob-pc", "builtin") // Ingetrokken lidmaatschap: meteen weg, ook al staat de toestemming nog. if err := s.RemoveMember(ctx, "group", g.ID, "bob"); err != nil { t.Fatal(err) } tiers, _ = Tiers(ctx, s, grepo, false) eq(t, names(tiers), "grp", "builtin") _ = s.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper) _ = s.SetRunnerOptIn(ctx, g.ID, bob.ID, false) _ = s.SetRunnerOptIn(ctx, g.ID, carol.ID, true) // maintainer: telt tiers, _ = Tiers(ctx, s, grepo, false) eq(t, names(tiers), "grp", "carol-pc", "builtin") _ = s.SetGroupBuiltinFirst(ctx, g.ID, true) tiers, _ = Tiers(ctx, s, grepo, false) eq(t, names(tiers), "builtin", "grp", "carol-pc") tiers, _ = Tiers(ctx, s, trepo, false) eq(t, names(tiers), "builtin", "tim-pc") _ = s.SetUserRunnerPref(ctx, tim.ID, store.RunnerPrefOwnFirst) tiers, _ = Tiers(ctx, s, trepo, false) eq(t, names(tiers), "tim-pc", "builtin") // Gepauzeerd: valt uit de volgorde, blijft in de lijst. paused := true if _, err := s.UpdateRunner(ctx, "user", carol.ID, carolRn.ID, nil, &paused); err != nil { t.Fatal(err) } _ = s.SetGroupBuiltinFirst(ctx, g.ID, false) tiers, _ = Tiers(ctx, s, grepo, false) eq(t, names(tiers), "grp", "builtin") if rs, _ := s.ListRunners(ctx, "user", carol.ID); len(rs) != 1 || !rs[0].Paused { t.Fatal("paused runner listed") } if _, err := s.UpdateRunner(ctx, "user", tim.ID, carolRn.ID, nil, &paused); err == nil { t.Fatal("tim paused carol's runner") } r := &Runner{Store: s} if !r.mayRun(ctx, grn, grepo, false) || r.mayRun(ctx, grn, trepo, false) { t.Fatal("group runner scope") } if !r.mayRun(ctx, carolRn, grepo, false) || r.mayRun(ctx, carolRn, trepo, false) { t.Fatal("carol scope") } if r.mayRun(ctx, bobRn, trepo, false) { t.Fatal("bob may not run tim's private repo") } if !r.mayRun(ctx, timRn, trepo, false) { t.Fatal("tim runs own repo") } // Ingetrokken runner verdwijnt uit de volgorde en zijn token werkt niet meer. if err := s.RevokeRunner(ctx, "user", tim.ID, timRn.ID); err != nil { t.Fatal(err) } tiers, _ = Tiers(ctx, s, trepo, false) eq(t, names(tiers), "builtin") }