Fast implementation of Git in pure Go
codeberg.org/lindenii/furgit
git
go
object/store/memory: Remove AddObject, fix lints
+424
-116
+61
-13
commitquery/queries_is_ancestor_unit_test.go
+61
-13
commitquery/queries_is_ancestor_unit_test.go
···
55
55
56
56
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
57
57
store := memory.New(algo)
58
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
59
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{
58
+
59
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
60
+
if err != nil {
61
+
t.Fatal(err)
62
+
}
63
+
64
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{
60
65
Mode: objecttree.FileModeRegular,
61
66
Name: []byte("f"),
62
67
ID: blob,
63
68
}}}))
64
-
c1 := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(tree))
65
-
c2 := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(tree, c1))
66
-
otherBlob := store.AddObject(objecttype.TypeBlob, []byte("other-blob\n"))
67
-
otherTree := store.AddObject(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{
69
+
if err != nil {
70
+
t.Fatal(err)
71
+
}
72
+
73
+
c1, err := store.WriteBytesContent(objecttype.TypeCommit, ancestorCommitBody(tree))
74
+
if err != nil {
75
+
t.Fatal(err)
76
+
}
77
+
78
+
c2, err := store.WriteBytesContent(objecttype.TypeCommit, ancestorCommitBody(tree, c1))
79
+
if err != nil {
80
+
t.Fatal(err)
81
+
}
82
+
83
+
otherBlob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("other-blob\n"))
84
+
if err != nil {
85
+
t.Fatal(err)
86
+
}
87
+
88
+
otherTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{
68
89
Mode: objecttree.FileModeRegular,
69
90
Name: []byte("g"),
70
91
ID: otherBlob,
71
92
}}}))
72
-
c3 := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(otherTree))
73
-
tag := store.AddObject(objecttype.TypeTag, ancestorTagBody(c2, objecttype.TypeCommit))
93
+
if err != nil {
94
+
t.Fatal(err)
95
+
}
96
+
97
+
c3, err := store.WriteBytesContent(objecttype.TypeCommit, ancestorCommitBody(otherTree))
98
+
if err != nil {
99
+
t.Fatal(err)
100
+
}
101
+
102
+
tag, err := store.WriteBytesContent(objecttype.TypeTag, ancestorTagBody(c2, objecttype.TypeCommit))
103
+
if err != nil {
104
+
t.Fatal(err)
105
+
}
74
106
75
107
ok, err := commitquery.New(fetch.New(store), nil).IsAncestor(c1, tag)
76
108
if err != nil {
···
97
129
98
130
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
99
131
store := memory.New(algo)
100
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
101
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{
132
+
133
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
134
+
if err != nil {
135
+
t.Fatal(err)
136
+
}
137
+
138
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{
102
139
Mode: objecttree.FileModeRegular,
103
140
Name: []byte("f"),
104
141
ID: blob,
105
142
}}}))
106
-
commit := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(tree))
107
-
tagToTree := store.AddObject(objecttype.TypeTag, ancestorTagBody(tree, objecttype.TypeTree))
143
+
if err != nil {
144
+
t.Fatal(err)
145
+
}
108
146
109
-
_, err := commitquery.New(fetch.New(store), nil).IsAncestor(commit, tagToTree)
147
+
commit, err := store.WriteBytesContent(objecttype.TypeCommit, ancestorCommitBody(tree))
148
+
if err != nil {
149
+
t.Fatal(err)
150
+
}
151
+
152
+
tagToTree, err := store.WriteBytesContent(objecttype.TypeTag, ancestorTagBody(tree, objecttype.TypeTree))
153
+
if err != nil {
154
+
t.Fatal(err)
155
+
}
156
+
157
+
_, err = commitquery.New(fetch.New(store), nil).IsAncestor(commit, tagToTree)
110
158
if err == nil {
111
159
t.Fatal("expected error")
112
160
}
+191
-39
commitquery/queries_merge_bases_unit_test.go
+191
-39
commitquery/queries_merge_bases_unit_test.go
···
74
74
75
75
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
76
76
store := memory.New(algo)
77
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
78
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
77
+
78
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
79
+
if err != nil {
80
+
t.Fatal(err)
81
+
}
82
+
83
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
79
84
Mode: tree.FileModeRegular,
80
85
Name: []byte("f"),
81
86
ID: blob,
82
87
}}}))
83
-
base := store.AddObject(objecttype.TypeCommit, commitBody(tree))
84
-
left := store.AddObject(objecttype.TypeCommit, commitBody(tree, base))
85
-
right := store.AddObject(objecttype.TypeCommit, commitBody(tree, left))
88
+
if err != nil {
89
+
t.Fatal(err)
90
+
}
91
+
92
+
base, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree))
93
+
if err != nil {
94
+
t.Fatal(err)
95
+
}
96
+
97
+
left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, base))
98
+
if err != nil {
99
+
t.Fatal(err)
100
+
}
101
+
102
+
right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, left))
103
+
if err != nil {
104
+
t.Fatal(err)
105
+
}
86
106
87
107
query := commitquery.New(fetch.New(store), nil)
88
108
···
115
135
116
136
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
117
137
store := memory.New(algo)
118
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
119
-
leftTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
138
+
139
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
140
+
if err != nil {
141
+
t.Fatal(err)
142
+
}
143
+
144
+
leftTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
120
145
Mode: tree.FileModeRegular,
121
146
Name: []byte("left"),
122
147
ID: blob,
123
148
}}}))
124
-
rightTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
149
+
if err != nil {
150
+
t.Fatal(err)
151
+
}
152
+
153
+
rightTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
125
154
Mode: tree.FileModeRegular,
126
155
Name: []byte("right"),
127
156
ID: blob,
128
157
}}}))
129
-
base := store.AddObject(objecttype.TypeCommit, commitBody(leftTree))
130
-
left := store.AddObject(objecttype.TypeCommit, commitBody(leftTree, base))
131
-
right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree, base))
132
-
tag := store.AddObject(objecttype.TypeTag, tagBody(right, objecttype.TypeCommit))
158
+
if err != nil {
159
+
t.Fatal(err)
160
+
}
161
+
162
+
base, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(leftTree))
163
+
if err != nil {
164
+
t.Fatal(err)
165
+
}
166
+
167
+
left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(leftTree, base))
168
+
if err != nil {
169
+
t.Fatal(err)
170
+
}
171
+
172
+
right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rightTree, base))
173
+
if err != nil {
174
+
t.Fatal(err)
175
+
}
176
+
177
+
tag, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(right, objecttype.TypeCommit))
178
+
if err != nil {
179
+
t.Fatal(err)
180
+
}
133
181
134
182
query := commitquery.New(fetch.New(store), nil)
135
183
···
149
197
150
198
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
151
199
store := memory.New(algo)
152
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
153
-
rootTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
200
+
201
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
202
+
if err != nil {
203
+
t.Fatal(err)
204
+
}
205
+
206
+
rootTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
154
207
Mode: tree.FileModeRegular,
155
208
Name: []byte("root"),
156
209
ID: blob,
157
210
}}}))
158
-
base1Tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
211
+
if err != nil {
212
+
t.Fatal(err)
213
+
}
214
+
215
+
base1Tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
159
216
Mode: tree.FileModeRegular,
160
217
Name: []byte("base1"),
161
218
ID: blob,
162
219
}}}))
163
-
base2Tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
220
+
if err != nil {
221
+
t.Fatal(err)
222
+
}
223
+
224
+
base2Tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
164
225
Mode: tree.FileModeRegular,
165
226
Name: []byte("base2"),
166
227
ID: blob,
167
228
}}}))
168
-
leftTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
229
+
if err != nil {
230
+
t.Fatal(err)
231
+
}
232
+
233
+
leftTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
169
234
Mode: tree.FileModeRegular,
170
235
Name: []byte("left"),
171
236
ID: blob,
172
237
}}}))
173
-
rightTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
238
+
if err != nil {
239
+
t.Fatal(err)
240
+
}
241
+
242
+
rightTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
174
243
Mode: tree.FileModeRegular,
175
244
Name: []byte("right"),
176
245
ID: blob,
177
246
}}}))
178
-
root := store.AddObject(objecttype.TypeCommit, commitBody(rootTree))
179
-
base1 := store.AddObject(objecttype.TypeCommit, commitBody(base1Tree, root))
180
-
base2 := store.AddObject(objecttype.TypeCommit, commitBody(base2Tree, root))
181
-
left := store.AddObject(objecttype.TypeCommit, commitBody(leftTree, base1, base2))
182
-
right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree, base2, base1))
247
+
if err != nil {
248
+
t.Fatal(err)
249
+
}
250
+
251
+
root, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rootTree))
252
+
if err != nil {
253
+
t.Fatal(err)
254
+
}
255
+
256
+
base1, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(base1Tree, root))
257
+
if err != nil {
258
+
t.Fatal(err)
259
+
}
260
+
261
+
base2, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(base2Tree, root))
262
+
if err != nil {
263
+
t.Fatal(err)
264
+
}
265
+
266
+
left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(leftTree, base1, base2))
267
+
if err != nil {
268
+
t.Fatal(err)
269
+
}
270
+
271
+
right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rightTree, base2, base1))
272
+
if err != nil {
273
+
t.Fatal(err)
274
+
}
183
275
184
276
query := commitquery.New(fetch.New(store), nil)
185
277
···
215
307
216
308
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
217
309
store := memory.New(algo)
218
-
leftBlob := store.AddObject(objecttype.TypeBlob, []byte("left\n"))
219
-
leftTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
310
+
311
+
leftBlob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("left\n"))
312
+
if err != nil {
313
+
t.Fatal(err)
314
+
}
315
+
316
+
leftTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
220
317
Mode: tree.FileModeRegular,
221
318
Name: []byte("left"),
222
319
ID: leftBlob,
223
320
}}}))
224
-
rightBlob := store.AddObject(objecttype.TypeBlob, []byte("right\n"))
225
-
rightTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
321
+
if err != nil {
322
+
t.Fatal(err)
323
+
}
324
+
325
+
rightBlob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("right\n"))
326
+
if err != nil {
327
+
t.Fatal(err)
328
+
}
329
+
330
+
rightTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
226
331
Mode: tree.FileModeRegular,
227
332
Name: []byte("right"),
228
333
ID: rightBlob,
229
334
}}}))
230
-
left := store.AddObject(objecttype.TypeCommit, commitBody(leftTree))
231
-
right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree))
335
+
if err != nil {
336
+
t.Fatal(err)
337
+
}
338
+
339
+
left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(leftTree))
340
+
if err != nil {
341
+
t.Fatal(err)
342
+
}
343
+
344
+
right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rightTree))
345
+
if err != nil {
346
+
t.Fatal(err)
347
+
}
232
348
233
349
query := commitquery.New(fetch.New(store), nil)
234
350
···
257
373
258
374
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
259
375
store := memory.New(algo)
260
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
261
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
376
+
377
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
378
+
if err != nil {
379
+
t.Fatal(err)
380
+
}
381
+
382
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
262
383
Mode: tree.FileModeRegular,
263
384
Name: []byte("f"),
264
385
ID: blob,
265
386
}}}))
266
-
commit := store.AddObject(objecttype.TypeCommit, commitBody(tree))
267
-
tagToTree := store.AddObject(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree))
387
+
if err != nil {
388
+
t.Fatal(err)
389
+
}
390
+
391
+
commit, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree))
392
+
if err != nil {
393
+
t.Fatal(err)
394
+
}
395
+
396
+
tagToTree, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree))
397
+
if err != nil {
398
+
t.Fatal(err)
399
+
}
268
400
269
401
query := commitquery.New(fetch.New(store), nil)
270
402
271
-
_, err := query.MergeBases(commit, tagToTree)
403
+
_, err = query.MergeBases(commit, tagToTree)
272
404
if err == nil {
273
405
t.Fatal("expected error")
274
406
}
···
289
421
290
422
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
291
423
store := memory.New(algo)
292
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
293
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
424
+
425
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
426
+
if err != nil {
427
+
t.Fatal(err)
428
+
}
429
+
430
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
294
431
Mode: tree.FileModeRegular,
295
432
Name: []byte("f"),
296
433
ID: blob,
297
434
}}}))
298
-
base := store.AddObject(objecttype.TypeCommit, commitBody(tree))
299
-
left := store.AddObject(objecttype.TypeCommit, commitBody(tree, base))
300
-
right := store.AddObject(objecttype.TypeCommit, commitBody(tree, left))
435
+
if err != nil {
436
+
t.Fatal(err)
437
+
}
438
+
439
+
base, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree))
440
+
if err != nil {
441
+
t.Fatal(err)
442
+
}
443
+
444
+
left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, base))
445
+
if err != nil {
446
+
t.Fatal(err)
447
+
}
448
+
449
+
right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, left))
450
+
if err != nil {
451
+
t.Fatal(err)
452
+
}
301
453
302
454
query := commitquery.New(fetch.New(store), nil)
303
455
-18
object/store/memory/add.go
-18
object/store/memory/add.go
···
1
-
package memory
2
-
3
-
import (
4
-
objectid "codeberg.org/lindenii/furgit/object/id"
5
-
objecttype "codeberg.org/lindenii/furgit/object/type"
6
-
)
7
-
8
-
// AddObject stores one object body and returns its object ID.
9
-
//
10
-
//go:fix inline
11
-
func (store *Store) AddObject(ty objecttype.Type, body []byte) objectid.ObjectID {
12
-
id, err := store.WriteBytesContent(ty, body)
13
-
if err != nil {
14
-
panic(err)
15
-
}
16
-
17
-
return id
18
-
}
+36
-14
object/store/memory/write_test.go
+36
-14
object/store/memory/write_test.go
···
1
-
package memory
1
+
package memory_test
2
2
3
3
import (
4
4
"bytes"
···
7
7
"codeberg.org/lindenii/furgit/internal/testgit"
8
8
objectheader "codeberg.org/lindenii/furgit/object/header"
9
9
objectid "codeberg.org/lindenii/furgit/object/id"
10
+
"codeberg.org/lindenii/furgit/object/store/memory"
10
11
objecttype "codeberg.org/lindenii/furgit/object/type"
11
12
)
12
13
13
14
func TestStoreWriteReaderContent(t *testing.T) {
14
15
t.Parallel()
15
16
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
16
-
store := New(algo)
17
+
store := memory.New(algo)
17
18
content := []byte("memory-content\n")
18
19
19
20
gotID, err := store.WriteReaderContent(objecttype.TypeBlob, int64(len(content)), bytes.NewReader(content))
···
21
22
t.Fatalf("WriteReaderContent: %v", err)
22
23
}
23
24
24
-
wantID := algo.Sum(buildRawObject(objecttype.TypeBlob, content))
25
+
wantID := algo.Sum(buildRawObject(t, objecttype.TypeBlob, content))
25
26
if gotID != wantID {
26
27
t.Fatalf("WriteReaderContent id = %s, want %s", gotID, wantID)
27
28
}
···
44
45
func TestStoreWriteReaderFull(t *testing.T) {
45
46
t.Parallel()
46
47
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
47
-
store := New(algo)
48
+
store := memory.New(algo)
48
49
content := []byte("memory-full\n")
49
-
raw := buildRawObject(objecttype.TypeBlob, content)
50
+
raw := buildRawObject(t, objecttype.TypeBlob, content)
50
51
51
52
gotID, err := store.WriteReaderFull(bytes.NewReader(raw))
52
53
if err != nil {
···
72
73
func TestStoreWriteBytes(t *testing.T) {
73
74
t.Parallel()
74
75
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
75
-
store := New(algo)
76
+
store := memory.New(algo)
76
77
content := []byte("memory-bytes\n")
77
78
78
79
gotID, err := store.WriteBytesContent(objecttype.TypeBlob, content)
···
80
81
t.Fatalf("WriteBytesContent: %v", err)
81
82
}
82
83
83
-
wantID := algo.Sum(buildRawObject(objecttype.TypeBlob, content))
84
+
wantID := algo.Sum(buildRawObject(t, objecttype.TypeBlob, content))
84
85
if gotID != wantID {
85
86
t.Fatalf("WriteBytesContent id = %s, want %s", gotID, wantID)
86
87
}
87
88
88
-
raw := buildRawObject(objecttype.TypeBlob, content)
89
+
raw := buildRawObject(t, objecttype.TypeBlob, content)
89
90
90
91
gotID2, err := store.WriteBytesFull(raw)
91
92
if err != nil {
···
103
104
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
104
105
t.Run("content overflow", func(t *testing.T) {
105
106
t.Parallel()
106
-
store := New(algo)
107
+
108
+
store := memory.New(algo)
107
109
108
110
_, err := store.WriteReaderContent(objecttype.TypeBlob, 1, bytes.NewReader([]byte("hello")))
109
111
if err == nil {
···
113
115
114
116
t.Run("content short", func(t *testing.T) {
115
117
t.Parallel()
116
-
store := New(algo)
118
+
119
+
store := memory.New(algo)
117
120
118
121
_, err := store.WriteReaderContent(objecttype.TypeBlob, 5, bytes.NewReader([]byte("x")))
119
122
if err == nil {
···
123
126
124
127
t.Run("full malformed header", func(t *testing.T) {
125
128
t.Parallel()
126
-
store := New(algo)
129
+
130
+
store := memory.New(algo)
127
131
128
132
_, err := store.WriteReaderFull(bytes.NewReader([]byte("not-a-header")))
129
133
if err == nil {
···
133
137
134
138
t.Run("full size mismatch", func(t *testing.T) {
135
139
t.Parallel()
136
-
store := New(algo)
140
+
141
+
store := memory.New(algo)
137
142
138
143
_, err := store.WriteReaderFull(bytes.NewReader([]byte("blob 1\x00hello")))
139
144
if err == nil {
···
143
148
144
149
t.Run("bytes malformed header", func(t *testing.T) {
145
150
t.Parallel()
146
-
store := New(algo)
151
+
152
+
store := memory.New(algo)
147
153
148
154
_, err := store.WriteBytesFull([]byte("not-a-header"))
149
155
if err == nil {
···
157
163
t.Parallel()
158
164
159
165
content := []byte("body")
160
-
raw := buildRawObject(objecttype.TypeBlob, content)
166
+
raw := buildRawObject(t, objecttype.TypeBlob, content)
167
+
161
168
header, ok := objectheader.Encode(objecttype.TypeBlob, int64(len(content)))
162
169
if !ok {
163
170
t.Fatalf("objectheader.Encode failed")
···
168
175
t.Fatalf("buildRawObject mismatch")
169
176
}
170
177
}
178
+
179
+
func buildRawObject(tb testing.TB, ty objecttype.Type, body []byte) []byte { //nolint:unparam
180
+
tb.Helper()
181
+
182
+
header, ok := objectheader.Encode(ty, int64(len(body)))
183
+
if !ok {
184
+
tb.Fatalf("objectheader.Encode(%v, %d) failed", ty, len(body))
185
+
}
186
+
187
+
raw := make([]byte, len(header)+len(body))
188
+
copy(raw, header)
189
+
copy(raw[len(header):], body)
190
+
191
+
return raw
192
+
}
+136
-32
reachability/unit_test.go
+136
-32
reachability/unit_test.go
···
83
83
84
84
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
85
85
store := newCountingMemStore(algo)
86
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
87
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
86
+
87
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
88
+
if err != nil {
89
+
t.Fatal(err)
90
+
}
91
+
92
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
88
93
Mode: tree.FileModeRegular,
89
94
Name: []byte("f"),
90
95
ID: blob,
91
96
}}}))
92
-
commit1 := store.AddObject(objecttype.TypeCommit, commitBody(tree))
93
-
commit2 := store.AddObject(objecttype.TypeCommit, commitBody(tree, commit1))
94
-
tag1 := store.AddObject(objecttype.TypeTag, tagBody(commit2, objecttype.TypeCommit))
95
-
tag2 := store.AddObject(objecttype.TypeTag, tagBody(tag1, objecttype.TypeTag))
97
+
if err != nil {
98
+
t.Fatal(err)
99
+
}
100
+
101
+
commit1, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree))
102
+
if err != nil {
103
+
t.Fatal(err)
104
+
}
105
+
106
+
commit2, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, commit1))
107
+
if err != nil {
108
+
t.Fatal(err)
109
+
}
110
+
111
+
tag1, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(commit2, objecttype.TypeCommit))
112
+
if err != nil {
113
+
t.Fatal(err)
114
+
}
115
+
116
+
tag2, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(tag1, objecttype.TypeTag))
117
+
if err != nil {
118
+
t.Fatal(err)
119
+
}
96
120
97
121
r := reachability.New(store, nil)
98
122
walk := r.Walk(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{tag2: {}})
99
123
100
124
got := collectSeq(walk.Seq())
101
125
102
-
err := walk.Err()
126
+
err = walk.Err()
103
127
if err != nil {
104
128
t.Fatalf("walk.Err(): %v", err)
105
129
}
···
118
142
119
143
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
120
144
store := newCountingMemStore(algo)
121
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
122
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
145
+
146
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
147
+
if err != nil {
148
+
t.Fatal(err)
149
+
}
150
+
151
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
123
152
Mode: tree.FileModeRegular,
124
153
Name: []byte("f"),
125
154
ID: blob,
126
155
}}}))
127
-
commit := store.AddObject(objecttype.TypeCommit, commitBody(tree))
156
+
if err != nil {
157
+
t.Fatal(err)
158
+
}
159
+
160
+
commit, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree))
161
+
if err != nil {
162
+
t.Fatal(err)
163
+
}
128
164
129
165
r := reachability.New(store, nil)
130
166
walk := r.Walk(reachability.DomainCommits, map[objectid.ObjectID]struct{}{commit: {}}, map[objectid.ObjectID]struct{}{commit: {}})
131
167
132
168
got := collectSeq(walk.Seq())
133
169
134
-
err := walk.Err()
170
+
err = walk.Err()
135
171
if err != nil {
136
172
t.Fatalf("walk.Err(): %v", err)
137
173
}
···
147
183
148
184
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
149
185
store := newCountingMemStore(algo)
150
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
151
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
186
+
187
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
188
+
if err != nil {
189
+
t.Fatal(err)
190
+
}
191
+
192
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
152
193
Mode: tree.FileModeRegular,
153
194
Name: []byte("f"),
154
195
ID: blob,
155
196
}}}))
156
-
tag := store.AddObject(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree))
197
+
if err != nil {
198
+
t.Fatal(err)
199
+
}
200
+
201
+
tag, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree))
202
+
if err != nil {
203
+
t.Fatal(err)
204
+
}
157
205
158
206
r := reachability.New(store, nil)
159
207
walk := r.Walk(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{tag: {}})
160
208
_ = collectSeq(walk.Seq())
161
209
162
-
err := walk.Err()
210
+
err = walk.Err()
163
211
if err == nil {
164
212
t.Fatal("expected error")
165
213
}
···
180
228
181
229
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
182
230
store := newCountingMemStore(algo)
183
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
184
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
231
+
232
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
233
+
if err != nil {
234
+
t.Fatal(err)
235
+
}
236
+
237
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
185
238
Mode: tree.FileModeRegular,
186
239
Name: []byte("f"),
187
240
ID: blob,
188
241
}}}))
189
-
commit1 := store.AddObject(objecttype.TypeCommit, commitBody(tree))
190
-
commit2 := store.AddObject(objecttype.TypeCommit, commitBody(tree, commit1))
191
-
tag1 := store.AddObject(objecttype.TypeTag, tagBody(commit2, objecttype.TypeCommit))
192
-
tag2 := store.AddObject(objecttype.TypeTag, tagBody(tag1, objecttype.TypeTag))
242
+
if err != nil {
243
+
t.Fatal(err)
244
+
}
245
+
246
+
commit1, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree))
247
+
if err != nil {
248
+
t.Fatal(err)
249
+
}
250
+
251
+
commit2, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, commit1))
252
+
if err != nil {
253
+
t.Fatal(err)
254
+
}
255
+
256
+
tag1, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(commit2, objecttype.TypeCommit))
257
+
if err != nil {
258
+
t.Fatal(err)
259
+
}
260
+
261
+
tag2, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(tag1, objecttype.TypeTag))
262
+
if err != nil {
263
+
t.Fatal(err)
264
+
}
193
265
194
266
r := reachability.New(store, nil)
195
267
walk := r.Walk(
···
200
272
201
273
got := collectSeq(walk.Seq())
202
274
203
-
err := walk.Err()
275
+
err = walk.Err()
204
276
if err != nil {
205
277
t.Fatalf("walk.Err(): %v", err)
206
278
}
···
220
292
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
221
293
store := newCountingMemStore(algo)
222
294
223
-
blob1 := store.AddObject(objecttype.TypeBlob, []byte("b1\n"))
224
-
blob2 := store.AddObject(objecttype.TypeBlob, []byte("b2\n"))
295
+
blob1, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("b1\n"))
296
+
if err != nil {
297
+
t.Fatal(err)
298
+
}
299
+
300
+
blob2, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("b2\n"))
301
+
if err != nil {
302
+
t.Fatal(err)
303
+
}
304
+
225
305
gitlinkTarget := store.Algorithm().Sum([]byte("external-submodule"))
226
306
227
-
subtree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
307
+
subtree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
228
308
Mode: tree.FileModeRegular,
229
309
Name: []byte("nested"),
230
310
ID: blob2,
231
311
}}}))
232
-
rootTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{
312
+
if err != nil {
313
+
t.Fatal(err)
314
+
}
315
+
316
+
rootTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{
233
317
{Mode: tree.FileModeRegular, Name: []byte("a"), ID: blob1},
234
318
{Mode: tree.FileModeDir, Name: []byte("dir"), ID: subtree},
235
319
{Mode: tree.FileModeGitlink, Name: []byte("submodule"), ID: gitlinkTarget},
236
320
}}))
237
-
commit := store.AddObject(objecttype.TypeCommit, commitBody(rootTree))
321
+
if err != nil {
322
+
t.Fatal(err)
323
+
}
324
+
325
+
commit, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rootTree))
326
+
if err != nil {
327
+
t.Fatal(err)
328
+
}
238
329
239
330
r := reachability.New(store, nil)
240
331
walk := r.Walk(reachability.DomainObjects, nil, map[objectid.ObjectID]struct{}{commit: {}})
241
332
242
333
got := collectSeq(walk.Seq())
243
334
244
-
err := walk.Err()
335
+
err = walk.Err()
245
336
if err != nil {
246
337
t.Fatalf("walk.Err(): %v", err)
247
338
}
···
264
355
265
356
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
266
357
store := newCountingMemStore(algo)
267
-
blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n"))
268
-
tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
358
+
359
+
blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n"))
360
+
if err != nil {
361
+
t.Fatal(err)
362
+
}
363
+
364
+
tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{
269
365
Mode: tree.FileModeRegular,
270
366
Name: []byte("f"),
271
367
ID: blob,
272
368
}}}))
369
+
if err != nil {
370
+
t.Fatal(err)
371
+
}
372
+
273
373
missingParent := store.Algorithm().Sum([]byte("missing-parent"))
274
-
commit := store.AddObject(objecttype.TypeCommit, commitBody(tree, missingParent))
374
+
375
+
commit, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, missingParent))
376
+
if err != nil {
377
+
t.Fatal(err)
378
+
}
275
379
276
380
r := reachability.New(store, nil)
277
381
278
-
err := r.CheckConnected(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{commit: {}})
382
+
err = r.CheckConnected(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{commit: {}})
279
383
if err == nil {
280
384
t.Fatal("expected error")
281
385
}