storj/satellite/metabase/rangedloop/providerdb_test.go

168 lines
3.6 KiB
Go
Raw Normal View History

// Copyright (C) 2022 Storj Labs, Inc.
// See LICENSE for copying information.
package rangedloop_test
import (
"testing"
"github.com/stretchr/testify/require"
"storj.io/common/testcontext"
"storj.io/common/testrand"
"storj.io/common/uuid"
"storj.io/storj/satellite/metabase"
"storj.io/storj/satellite/metabase/metabasetest"
"storj.io/storj/satellite/metabase/rangedloop"
"storj.io/storj/satellite/metabase/segmentloop"
)
type in struct {
streamIDs []string
nRanges int
batchSize int
}
type expected struct {
nBatches int
nSegments int
}
func TestMetabaseSegementProvider(t *testing.T) {
metabasetest.Run(t, func(ctx *testcontext.Context, t *testing.T, db *metabase.DB) {
inouts := []struct {
in in
expected expected
}{
{
in: in{
streamIDs: []string{},
nRanges: 1,
batchSize: 2,
},
expected: expected{
nBatches: 0,
nSegments: 0,
},
},
{
in: in{
streamIDs: []string{
"00000000-0000-0000-0000-000000000001",
"00000000-0000-0000-0000-000000000002",
},
nRanges: 2,
batchSize: 2,
},
expected: expected{
nBatches: 1,
nSegments: 2,
},
},
{
in: in{
streamIDs: []string{
"00000000-0000-0000-0000-000000000001",
"f0000000-0000-0000-0000-000000000001",
},
nRanges: 2,
batchSize: 2,
},
expected: expected{
nBatches: 2,
nSegments: 2,
},
},
{
in: in{
streamIDs: []string{
"00000000-0000-0000-0000-000000000001",
"00000000-0000-0000-0000-000000000002",
"f0000000-0000-0000-0000-000000000001",
"f0000000-0000-0000-0000-000000000002",
},
nRanges: 2,
batchSize: 1,
},
expected: expected{
nBatches: 4,
nSegments: 4,
},
},
}
for _, inout := range inouts {
runTest(ctx, t, db, inout.in, inout.expected)
}
})
}
func runTest(ctx *testcontext.Context, t *testing.T, db *metabase.DB, in in, expected expected) {
defer metabasetest.DeleteAll{}.Check(ctx, t, db)
for _, streamID := range in.streamIDs {
u, err := uuid.FromString(streamID)
require.NoError(t, err)
createSegment(ctx, t, db, u)
}
provider := rangedloop.NewMetabaseRangeSplitter(db, in.batchSize)
ranges, err := provider.CreateRanges(in.nRanges, in.batchSize)
require.NoError(t, err)
nBatches := 0
nSegments := 0
for _, r := range ranges {
err = r.Iterate(ctx, func(segments []segmentloop.Segment) error {
nBatches++
nSegments += len(segments)
return nil
})
require.NoError(t, err)
}
require.Equal(t, expected.nSegments, nSegments)
require.Equal(t, expected.nBatches, nBatches)
}
func createSegment(ctx *testcontext.Context, t testing.TB, db *metabase.DB, streamID uuid.UUID) {
obj := metabasetest.RandObjectStream()
obj.StreamID = streamID
pos := metabase.SegmentPosition{Part: 0, Index: 0}
data := testrand.Bytes(32)
encryptedKey := testrand.Bytes(32)
encryptedKeyNonce := testrand.Bytes(32)
metabasetest.BeginObjectExactVersion{
Opts: metabase.BeginObjectExactVersion{
ObjectStream: obj,
Encryption: metabasetest.DefaultEncryption,
},
Version: 1,
}.Check(ctx, t, db)
metabasetest.CommitInlineSegment{
Opts: metabase.CommitInlineSegment{
ObjectStream: obj,
Position: pos,
EncryptedKey: encryptedKey,
EncryptedKeyNonce: encryptedKeyNonce,
PlainSize: 512,
PlainOffset: 0,
InlineData: data,
},
}.Check(ctx, t, db)
metabasetest.CommitObjectWithSegments{
Opts: metabase.CommitObjectWithSegments{
ObjectStream: obj,
Segments: []metabase.SegmentPosition{
{Part: 0, Index: 0},
},
},
}.Check(ctx, t, db)
}