Fast implementation of Git in pure Go codeberg.org/lindenii/furgit
git go
6
fork

Configure Feed

Select the types of activity you want to include in your feed.

object/store/memory: Remove AddObject, fix lints

Runxi Yu f23c6a80 d4483c3d

+424 -116
+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
··· 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
··· 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
··· 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
··· 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 }