1// SPDX-License-Identifier: AGPL-3.0-or-later
2
3package kvstore_test
4
5import (
6 "context"
7 "errors"
8 "strings"
9 "sync"
10 "testing"
11 "time"
12
13 "github.com/stretchr/testify/assert"
14 "github.com/stretchr/testify/require"
15 "google.golang.org/protobuf/proto"
16
17 kv "bnema.dev/ermite-kv"
18
19 storagepb "bnema.dev/ermite/gen/ermite/storage"
20 "bnema.dev/ermite/internal/adapters/kvstore"
21 "bnema.dev/ermite/internal/domain"
22)
23
24func newMR(t *testing.T, repo domain.RepoName, title string) domain.MergeRequest {
25 t.Helper()
26 ti, err := domain.ParseMRTitle(title)
27 require.NoError(t, err)
28 desc, err := domain.ParsePlainText("why\nand how")
29 require.NoError(t, err)
30 return domain.MergeRequest{
31 Repo: repo, Title: ti, Description: desc, Source: "feat/x", Target: "main",
32 State: domain.MRStateOpen, Author: "agent", CreatedAt: created, UpdatedAt: created,
33 }
34}
35
36func oid(c byte) domain.ObjectID {
37 id, err := domain.ParseObjectID(strings.Repeat(string(c), 40))
38 if err != nil {
39 panic(err)
40 }
41 return id
42}
43
44// repoWithMRs opens a store holding repository "proj".
45func repoWithMRs(t *testing.T) (*kvstore.Store, *kvstore.MergeRequests, domain.RepoName) {
46 t.Helper()
47 s := openStore(t, t.TempDir())
48 n := name(t, "proj")
49 require.NoError(t, s.Create(context.Background(), domain.Repo{Name: n, Visibility: domain.VisibilityPrivate, CreatedAt: created}))
50 return s, s.MergeRequests(), n
51}
52
53func TestMergeRequestNumbersAreSequentialPerRepository(t *testing.T) {
54 ctx := context.Background()
55 s, mrs, n := repoWithMRs(t)
56 other := name(t, "other")
57 require.NoError(t, s.Create(ctx, domain.Repo{Name: other, CreatedAt: created, Visibility: domain.VisibilityPublic}))
58
59 for want := int64(1); want <= 3; want++ {
60 got, err := mrs.Create(ctx, newMR(t, n, "t"))
61 require.NoError(t, err)
62 assert.Equal(t, want, got.Number)
63 }
64 got, err := mrs.Create(ctx, newMR(t, other, "t"))
65 require.NoError(t, err)
66 assert.Equal(t, int64(1), got.Number, "each repository counts on its own")
67
68 _, err = mrs.Create(ctx, newMR(t, name(t, "ghost"), "t"))
69 assert.ErrorIs(t, err, domain.ErrNotFound, "no merge request for a missing repository")
70}
71
72func TestMergeRequestRoundTrip(t *testing.T) {
73 ctx := context.Background()
74 _, mrs, n := repoWithMRs(t)
75 in := newMR(t, n, "Ajoute « ça »")
76 in.HeadID, in.BaseID, in.MergedCommitID = oid('a'), oid('b'), oid('c')
77 in.MergeMode = domain.MergeModeSquash
78 in.State = domain.MRStateMerged
79 in.CommentSeq = 4
80 created1, err := mrs.Create(ctx, in)
81 require.NoError(t, err)
82
83 got, err := mrs.Get(ctx, n, created1.Number)
84 require.NoError(t, err)
85 assert.NotZero(t, got.Version)
86 in.Number, in.Version = 1, got.Version
87 assert.Equal(t, in, got)
88
89 _, err = mrs.Get(ctx, n, 2)
90 assert.ErrorIs(t, err, domain.ErrNotFound)
91 _, err = mrs.Get(ctx, n, 0)
92 assert.ErrorIs(t, err, domain.ErrNotFound)
93 _, err = mrs.Get(ctx, n, -3)
94 assert.ErrorIs(t, err, domain.ErrNotFound)
95}
96
97func TestMergeRequestListIsNewestFirstAndPerRepository(t *testing.T) {
98 ctx := context.Background()
99 s, mrs, n := repoWithMRs(t)
100 // "proj-2" shares the prefix "proj": its keys must not leak into proj's.
101 sib := name(t, "proj-2")
102 require.NoError(t, s.Create(ctx, domain.Repo{Name: sib, CreatedAt: created, Visibility: domain.VisibilityPublic}))
103 for range 12 { // beyond 10: numbers sort numerically, not as text
104 _, err := mrs.Create(ctx, newMR(t, n, "t"))
105 require.NoError(t, err)
106 }
107 _, err := mrs.Create(ctx, newMR(t, sib, "sibling"))
108 require.NoError(t, err)
109
110 list, err := mrs.List(ctx, n)
111 require.NoError(t, err)
112 require.Len(t, list, 12)
113 for i, mr := range list {
114 assert.Equal(t, int64(12-i), mr.Number)
115 assert.Equal(t, n, mr.Repo)
116 }
117 list, err = mrs.List(ctx, name(t, "none"))
118 require.NoError(t, err)
119 assert.Empty(t, list)
120}
121
122func TestConcurrentCreateNeverSharesANumber(t *testing.T) {
123 ctx := context.Background()
124 _, mrs, n := repoWithMRs(t)
125 const workers = 8
126 var (
127 wg sync.WaitGroup
128 mu sync.Mutex
129 numbers []int64
130 )
131 for range workers {
132 wg.Go(func() {
133 got, err := mrs.Create(ctx, newMR(t, n, "t"))
134 if assert.NoError(t, err) {
135 mu.Lock()
136 numbers = append(numbers, got.Number)
137 mu.Unlock()
138 }
139 })
140 }
141 wg.Wait()
142 assert.ElementsMatch(t, []int64{1, 2, 3, 4, 5, 6, 7, 8}, numbers)
143}
144
145func TestMergeRequestUpdateNeedsTheVersionItWasReadAt(t *testing.T) {
146 ctx := context.Background()
147 _, mrs, n := repoWithMRs(t)
148 first, err := mrs.Create(ctx, newMR(t, n, "t"))
149 require.NoError(t, err)
150
151 a, err := mrs.Get(ctx, n, first.Number)
152 require.NoError(t, err)
153 b := a
154 a.State = domain.MRStateClosed
155 require.NoError(t, mrs.Update(ctx, a))
156
157 b.State = domain.MRStateMerged
158 assert.ErrorIs(t, mrs.Update(ctx, b), domain.ErrConflict, "b was read before a wrote")
159
160 got, err := mrs.Get(ctx, n, first.Number)
161 require.NoError(t, err)
162 assert.Equal(t, domain.MRStateClosed, got.State)
163
164 gone := got
165 gone.Number = 99
166 assert.ErrorIs(t, mrs.Update(ctx, gone), domain.ErrNotFound)
167 fresh := newMR(t, n, "never read")
168 fresh.Number = first.Number
169 assert.ErrorIs(t, mrs.Update(ctx, fresh), domain.ErrConflict, "an unread request has no version")
170}
171
172func newComment(t *testing.T, id int64, text string) domain.Comment {
173 t.Helper()
174 pt, err := domain.ParsePlainText(text)
175 require.NoError(t, err)
176 return domain.Comment{
177 ID: id, Author: "root", Path: "a.txt", Line: 3, Side: domain.SideNew,
178 CommitID: oid('d'), Text: pt, CreatedAt: created.Add(time.Duration(id) * time.Minute),
179 }
180}
181
182func TestComments(t *testing.T) {
183 ctx := context.Background()
184 _, mrs, n := repoWithMRs(t)
185 first, err := mrs.Create(ctx, newMR(t, n, "t"))
186 require.NoError(t, err)
187
188 // Twelve comments: ids sort numerically too.
189 for id := int64(1); id <= 12; id++ {
190 mr, err := mrs.Get(ctx, n, first.Number)
191 require.NoError(t, err)
192 mr.CommentSeq = id
193 c := newComment(t, id, "note")
194 if id == 2 {
195 c.Path, c.Line, c.Side = "", 0, domain.SideNone
196 }
197 require.NoError(t, mrs.SaveComment(ctx, mr, c))
198 }
199 list, err := mrs.ListComments(ctx, n, first.Number)
200 require.NoError(t, err)
201 require.Len(t, list, 12)
202 for i, c := range list {
203 assert.Equal(t, int64(i+1), c.ID, "oldest first")
204 }
205 assert.True(t, list[1].IsGeneral())
206 assert.Equal(t, domain.SideNone, list[1].Side)
207 assert.Equal(t, domain.SideNew, list[0].Side)
208
209 mr, err := mrs.Get(ctx, n, first.Number)
210 require.NoError(t, err)
211 assert.Equal(t, int64(12), mr.CommentSeq)
212
213 c, err := mrs.GetComment(ctx, n, first.Number, 3)
214 require.NoError(t, err)
215 assert.NotZero(t, c.Version)
216 assert.Equal(t, "note", c.Text.String())
217 assert.Equal(t, oid('d'), c.CommitID)
218 for _, id := range []int64{0, 13, -1} {
219 _, err = mrs.GetComment(ctx, n, first.Number, id)
220 assert.ErrorIs(t, err, domain.ErrNotFound)
221 }
222
223 // Another merge request's comments are not listed.
224 second, err := mrs.Create(ctx, newMR(t, n, "t2"))
225 require.NoError(t, err)
226 list, err = mrs.ListComments(ctx, n, second.Number)
227 require.NoError(t, err)
228 assert.Empty(t, list)
229}
230
231func TestSaveCommentPreconditions(t *testing.T) {
232 ctx := context.Background()
233 _, mrs, n := repoWithMRs(t)
234 first, err := mrs.Create(ctx, newMR(t, n, "t"))
235 require.NoError(t, err)
236 mr, err := mrs.Get(ctx, n, first.Number)
237 require.NoError(t, err)
238
239 mr.CommentSeq = 1
240 require.NoError(t, mrs.SaveComment(ctx, mr, newComment(t, 1, "one")))
241
242 // The same id again, from the same stale read: the request moved on.
243 assert.ErrorIs(t, mrs.SaveComment(ctx, mr, newComment(t, 1, "dup")), domain.ErrConflict)
244
245 // A fresh read of the request but a new comment with an existing id.
246 mr, err = mrs.Get(ctx, n, first.Number)
247 require.NoError(t, err)
248 assert.ErrorIs(t, mrs.SaveComment(ctx, mr, newComment(t, 1, "dup")), domain.ErrConflict, "a new comment must not overwrite")
249
250 // Resolving needs the comment version.
251 c, err := mrs.GetComment(ctx, n, first.Number, 1)
252 require.NoError(t, err)
253 stale := c
254 c.Resolved = true
255 require.NoError(t, mrs.SaveComment(ctx, mr, c))
256 mr, err = mrs.Get(ctx, n, first.Number)
257 require.NoError(t, err)
258 stale.Resolved = false
259 assert.ErrorIs(t, mrs.SaveComment(ctx, mr, stale), domain.ErrConflict)
260
261 // An unread request cannot be saved with.
262 assert.ErrorIs(t, mrs.SaveComment(ctx, newMR(t, n, "x"), newComment(t, 2, "n")), domain.ErrConflict)
263}
264
265func TestReadPosition(t *testing.T) {
266 ctx := context.Background()
267 _, mrs, n := repoWithMRs(t)
268 got, err := mrs.GetRead(ctx, n, 1)
269 require.NoError(t, err)
270 assert.True(t, got.IsZero())
271
272 require.NoError(t, mrs.SetRead(ctx, n, 1, oid('a')))
273 require.NoError(t, mrs.SetRead(ctx, n, 1, oid('b')))
274 got, err = mrs.GetRead(ctx, n, 1)
275 require.NoError(t, err)
276 assert.Equal(t, oid('b'), got)
277 got, err = mrs.GetRead(ctx, n, 2)
278 require.NoError(t, err)
279 assert.True(t, got.IsZero())
280 assert.Error(t, mrs.SetRead(ctx, n, 1, domain.ObjectID{}))
281}
282
283// TestDeleteDropsTheMergeRequestsOfTheRepository: deleting a repository drops
284// its merge requests, comments, read positions and number sequence, and only
285// its own; a repository created again under the name starts at !1.
286func TestDeleteDropsTheMergeRequestsOfTheRepository(t *testing.T) {
287 ctx := context.Background()
288 s, mrs, n := repoWithMRs(t)
289 sib := name(t, "proj-2")
290 require.NoError(t, s.Create(ctx, domain.Repo{Name: sib, CreatedAt: created, Visibility: domain.VisibilityPublic}))
291
292 for _, repo := range []domain.RepoName{n, sib} {
293 mr, err := mrs.Create(ctx, newMR(t, repo, "t"))
294 require.NoError(t, err)
295 mr.CommentSeq = 1
296 require.NoError(t, mrs.SaveComment(ctx, mr, newComment(t, 1, "note")))
297 require.NoError(t, mrs.SetRead(ctx, repo, mr.Number, oid('a')))
298 }
299
300 require.NoError(t, s.Delete(ctx, n))
301
302 list, err := mrs.List(ctx, n)
303 require.NoError(t, err)
304 assert.Empty(t, list)
305 comments, err := mrs.ListComments(ctx, n, 1)
306 require.NoError(t, err)
307 assert.Empty(t, comments)
308 read, err := mrs.GetRead(ctx, n, 1)
309 require.NoError(t, err)
310 assert.True(t, read.IsZero())
311
312 list, err = mrs.List(ctx, sib)
313 require.NoError(t, err)
314 require.Len(t, list, 1, "a repository whose name starts like the deleted one keeps its requests")
315 comments, err = mrs.ListComments(ctx, sib, 1)
316 require.NoError(t, err)
317 assert.Len(t, comments, 1)
318
319 require.NoError(t, s.Create(ctx, domain.Repo{Name: n, CreatedAt: created, Visibility: domain.VisibilityPrivate}))
320 again, err := mrs.Create(ctx, newMR(t, n, "fresh"))
321 require.NoError(t, err)
322 assert.Equal(t, int64(1), again.Number)
323}
324
325// TestWritesAfterDeleteLeaveNothing: a comment or a read position written for
326// a repository that was deleted meanwhile is refused, so that a repository
327// created again under the name does not inherit it (GO-002).
328func TestWritesAfterDeleteLeaveNothing(t *testing.T) {
329 ctx := context.Background()
330 s, mrs, n := repoWithMRs(t)
331 mr, err := mrs.Create(ctx, newMR(t, n, "t"))
332 require.NoError(t, err)
333
334 require.NoError(t, s.Delete(ctx, n))
335
336 mr.CommentSeq = 1
337 assert.ErrorIs(t, mrs.SaveComment(ctx, mr, newComment(t, 1, "late")), domain.ErrNotFound)
338 assert.ErrorIs(t, mrs.SetRead(ctx, n, mr.Number, oid('a')), domain.ErrNotFound)
339 _, err = mrs.Create(ctx, newMR(t, n, "late"))
340 assert.ErrorIs(t, err, domain.ErrNotFound)
341
342 require.NoError(t, s.Create(ctx, domain.Repo{Name: n, CreatedAt: created, Visibility: domain.VisibilityPublic}))
343 assertNoMergeRequestKeys(t, mrs, n)
344}
345
346func assertNoMergeRequestKeys(t *testing.T, mrs *kvstore.MergeRequests, n domain.RepoName) {
347 t.Helper()
348 ctx := context.Background()
349 list, err := mrs.List(ctx, n)
350 require.NoError(t, err)
351 assert.Empty(t, list, "merge requests")
352 comments, err := mrs.ListComments(ctx, n, 1)
353 require.NoError(t, err)
354 assert.Empty(t, comments, "comments")
355 read, err := mrs.GetRead(ctx, n, 1)
356 require.NoError(t, err)
357 assert.True(t, read.IsZero(), "read position")
358}
359
360// TestDeleteRacingWithWrites: writes racing with Delete either land before it
361// and are deleted, or are refused after it; nothing is left for a repository
362// created again under the name.
363func TestDeleteRacingWithWrites(t *testing.T) {
364 ctx := context.Background()
365 for round := range 20 {
366 s, mrs, n := repoWithMRs(t)
367 mr, err := mrs.Create(ctx, newMR(t, n, "t"))
368 require.NoError(t, err)
369
370 var wg sync.WaitGroup
371 for w := range 4 {
372 wg.Add(1)
373 go func() {
374 defer wg.Done()
375 for i := range 30 {
376 if w%2 == 0 {
377 err := mrs.SetRead(ctx, n, mr.Number, oid('a'))
378 if err != nil {
379 assert.ErrorIs(t, err, domain.ErrNotFound)
380 return
381 }
382 continue
383 }
384 cur, err := mrs.Get(ctx, n, mr.Number)
385 if err != nil {
386 return
387 }
388 cur.CommentSeq = int64(w*1000 + i + 1)
389 err = mrs.SaveComment(ctx, cur, newComment(t, cur.CommentSeq, "note"))
390 if err != nil && !assert.True(t, errors.Is(err, domain.ErrConflict) || errors.Is(err, domain.ErrNotFound), "round %d: %v", round, err) {
391 return
392 }
393 }
394 }()
395 }
396 delErr := s.Delete(ctx, n)
397 wg.Wait()
398 require.NoError(t, delErr)
399
400 require.NoError(t, s.Create(ctx, domain.Repo{Name: n, CreatedAt: created, Visibility: domain.VisibilityPublic}))
401 assertNoMergeRequestKeys(t, mrs, n)
402 again, err := mrs.Create(ctx, newMR(t, n, "fresh"))
403 require.NoError(t, err)
404 assert.Equal(t, int64(1), again.Number)
405 }
406}
407
408func TestDeleteManyMergeRequests(t *testing.T) {
409 ctx := context.Background()
410 s, mrs, n := repoWithMRs(t)
411 for range 1100 {
412 _, err := mrs.Create(ctx, newMR(t, n, "t"))
413 require.NoError(t, err)
414 }
415 require.NoError(t, s.Delete(ctx, n))
416 list, err := mrs.List(ctx, n)
417 require.NoError(t, err)
418 assert.Empty(t, list)
419 _, err = s.Get(ctx, n)
420 assert.ErrorIs(t, err, domain.ErrNotFound)
421}
422
423func TestRepoSettings(t *testing.T) {
424 ctx := context.Background()
425 s := openStore(t, t.TempDir())
426 n := name(t, "proj")
427
428 // Created without settings: they are stored explicitly, with the defaults.
429 require.NoError(t, s.Create(ctx, domain.Repo{Name: n, CreatedAt: created, Visibility: domain.VisibilityPrivate}))
430 got, err := s.Get(ctx, n)
431 require.NoError(t, err)
432 assert.Equal(t, domain.DefaultRepoSettings(), got.Settings)
433
434 got.Settings = domain.RepoSettings{AllowedMergeModes: []domain.MergeMode{domain.MergeModeSquash}, FailingChecksBlock: false}
435 require.NoError(t, s.Update(ctx, got))
436 again, err := s.Get(ctx, n)
437 require.NoError(t, err)
438 assert.Equal(t, got.Settings, again.Settings)
439
440 got.Settings = domain.RepoSettings{AllowedMergeModes: []domain.MergeMode{"rebase"}}
441 assert.ErrorIs(t, s.Update(ctx, got), domain.ErrInvalid)
442}
443
444// TestRepoWithoutStoredSettingsReadsTheDefaults: a repository stored before
445// merge requests existed has no settings field.
446func TestRepoWithoutStoredSettingsReadsTheDefaults(t *testing.T) {
447 ctx := context.Background()
448 dir := t.TempDir()
449 s, err := kvstore.Open(ctx, dir)
450 require.NoError(t, err)
451 require.NoError(t, s.Close(ctx))
452
453 // Write a legacy value straight into the database.
454 db, err := kv.Open(ctx, dir, kv.Options{})
455 require.NoError(t, err)
456 legacy, err := proto.Marshal(&storagepb.Repo{Name: "legacy", Visibility: storagepb.Visibility_VISIBILITY_PUBLIC})
457 require.NoError(t, err)
458 var b kv.Batch
459 b.Put([]byte("repo/legacy"), legacy)
460 _, err = db.Apply(ctx, &b)
461 require.NoError(t, err)
462 require.NoError(t, db.Close(ctx))
463
464 s = openStore(t, dir)
465 got, err := s.Get(ctx, name(t, "legacy"))
466 require.NoError(t, err)
467 assert.Equal(t, domain.DefaultRepoSettings(), got.Settings)
468 list, err := s.List(ctx)
469 require.NoError(t, err)
470 require.Len(t, list, 1)
471 assert.Equal(t, domain.DefaultRepoSettings(), list[0].Settings)
472}
473
474func TestSigningSeed(t *testing.T) {
475 ctx := context.Background()
476 dir := t.TempDir()
477 s := openStore(t, dir)
478 calls := 0
479 gen := func() ([]byte, error) {
480 calls++
481 return []byte(strings.Repeat(string(rune('a'+calls)), kvstore.SigningSeedLen)), nil
482 }
483
484 first, err := s.SigningSeed(ctx, gen, created)
485 require.NoError(t, err)
486 require.Len(t, first, kvstore.SigningSeedLen)
487 second, err := s.SigningSeed(ctx, gen, created)
488 require.NoError(t, err)
489 assert.Equal(t, first, second, "generated once")
490 assert.Equal(t, 1, calls)
491
492 // It survives a restart.
493 require.NoError(t, s.Close(ctx))
494 s2 := openStore(t, dir)
495 third, err := s2.SigningSeed(ctx, gen, created)
496 require.NoError(t, err)
497 assert.Equal(t, first, third)
498 assert.Equal(t, 1, calls)
499}
500
501func TestSigningSeedConcurrentFirstStart(t *testing.T) {
502 ctx := context.Background()
503 s := openStore(t, t.TempDir())
504 var (
505 wg sync.WaitGroup
506 mu sync.Mutex
507 seeds [][]byte
508 n byte
509 )
510 for range 6 {
511 wg.Go(func() {
512 seed, err := s.SigningSeed(ctx, func() ([]byte, error) {
513 mu.Lock()
514 defer mu.Unlock()
515 n++
516 return []byte(strings.Repeat(string(rune('A'+n)), kvstore.SigningSeedLen)), nil
517 }, created)
518 if assert.NoError(t, err) {
519 mu.Lock()
520 seeds = append(seeds, seed)
521 mu.Unlock()
522 }
523 })
524 }
525 wg.Wait()
526 for _, seed := range seeds {
527 assert.Equal(t, seeds[0], seed, "every caller gets the winner's seed")
528 }
529}
530
531func TestSigningSeedRejectsBadGenerators(t *testing.T) {
532 ctx := context.Background()
533 s := openStore(t, t.TempDir())
534 _, err := s.SigningSeed(ctx, func() ([]byte, error) { return []byte("short"), nil }, created)
535 require.Error(t, err)
536 assert.NotContains(t, err.Error(), "short")
537 _, err = s.SigningSeed(ctx, func() ([]byte, error) { return nil, assert.AnError }, created)
538 require.ErrorIs(t, err, assert.AnError)
539}