6834c04539
We decided that we won't use seprate table for handling pending objects. We need to remove related code. https://github.com/storj/storj/issues/6421 Change-Id: I442b0f58da75409f725e08e2cd83d29ed4f91ec6
769 lines
23 KiB
Go
769 lines
23 KiB
Go
// Copyright (C) 2020 Storj Labs, Inc.
|
|
// See LICENSE for copying information.
|
|
|
|
package metabasetest
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"sort"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/google/go-cmp/cmp/cmpopts"
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/zeebo/errs"
|
|
|
|
"storj.io/common/storj"
|
|
"storj.io/common/testcontext"
|
|
"storj.io/common/uuid"
|
|
"storj.io/storj/satellite/metabase"
|
|
)
|
|
|
|
// BeginObjectNextVersion is for testing metabase.BeginObjectNextVersion.
|
|
type BeginObjectNextVersion struct {
|
|
Opts metabase.BeginObjectNextVersion
|
|
Version metabase.Version
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step BeginObjectNextVersion) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
got, err := db.BeginObjectNextVersion(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
if step.ErrClass == nil {
|
|
require.Equal(t, step.Version, got.Version)
|
|
require.WithinDuration(t, time.Now(), got.CreatedAt, 5*time.Second)
|
|
|
|
require.Equal(t, step.Opts.ObjectStream.ProjectID, got.ObjectStream.ProjectID)
|
|
require.Equal(t, step.Opts.ObjectStream.BucketName, got.ObjectStream.BucketName)
|
|
require.Equal(t, step.Opts.ObjectStream.ObjectKey, got.ObjectStream.ObjectKey)
|
|
require.Equal(t, step.Opts.ObjectStream.StreamID, got.ObjectStream.StreamID)
|
|
require.Equal(t, metabase.Pending, got.Status)
|
|
|
|
require.Equal(t, step.Opts.ExpiresAt, got.ExpiresAt)
|
|
|
|
gotDeadline := got.ZombieDeletionDeadline
|
|
optsDeadline := step.Opts.ZombieDeletionDeadline
|
|
if optsDeadline == nil {
|
|
require.WithinDuration(t, time.Now().Add(24*time.Hour), *gotDeadline, 5*time.Second)
|
|
} else {
|
|
require.WithinDuration(t, *optsDeadline, *gotDeadline, 5*time.Second)
|
|
}
|
|
require.Equal(t, step.Opts.Encryption, got.Encryption)
|
|
}
|
|
}
|
|
|
|
// BeginObjectExactVersion is for testing metabase.BeginObjectExactVersion.
|
|
type BeginObjectExactVersion struct {
|
|
Opts metabase.BeginObjectExactVersion
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step BeginObjectExactVersion) Check(ctx *testcontext.Context, t require.TestingT, db *metabase.DB) metabase.Object {
|
|
got, err := db.TestingBeginObjectExactVersion(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
if step.ErrClass == nil {
|
|
require.Equal(t, step.Opts.Version, got.Version)
|
|
require.WithinDuration(t, time.Now(), got.CreatedAt, 5*time.Second)
|
|
require.Equal(t, step.Opts.ObjectStream, got.ObjectStream)
|
|
require.Equal(t, step.Opts.ExpiresAt, got.ExpiresAt)
|
|
|
|
gotDeadline := got.ZombieDeletionDeadline
|
|
optsDeadline := step.Opts.ZombieDeletionDeadline
|
|
if optsDeadline == nil {
|
|
require.WithinDuration(t, time.Now().Add(24*time.Hour), *gotDeadline, 5*time.Second)
|
|
} else {
|
|
require.WithinDuration(t, *optsDeadline, *gotDeadline, 5*time.Second)
|
|
}
|
|
require.Equal(t, step.Opts.Encryption, got.Encryption)
|
|
}
|
|
return got
|
|
}
|
|
|
|
// CommitObject is for testing metabase.CommitObject.
|
|
type CommitObject struct {
|
|
Opts metabase.CommitObject
|
|
ExpectVersion metabase.Version
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step CommitObject) Check(ctx *testcontext.Context, t require.TestingT, db *metabase.DB) metabase.Object {
|
|
object, err := db.CommitObject(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
if err == nil {
|
|
if step.ExpectVersion != 0 {
|
|
step.Opts.ObjectStream.Version = step.ExpectVersion
|
|
}
|
|
require.Equal(t, step.Opts.ObjectStream, object.ObjectStream)
|
|
}
|
|
return object
|
|
}
|
|
|
|
// CommitObjectWithSegments is for testing metabase.CommitObjectWithSegments.
|
|
type CommitObjectWithSegments struct {
|
|
Opts metabase.CommitObjectWithSegments
|
|
Deleted []metabase.DeletedSegmentInfo
|
|
ExpectVersion metabase.Version
|
|
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step CommitObjectWithSegments) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) metabase.Object {
|
|
object, deleted, err := db.CommitObjectWithSegments(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
if err == nil {
|
|
if step.ExpectVersion != 0 {
|
|
step.Opts.ObjectStream.Version = step.ExpectVersion
|
|
}
|
|
require.Equal(t, step.Opts.ObjectStream, object.ObjectStream)
|
|
}
|
|
require.Equal(t, step.Deleted, deleted)
|
|
return object
|
|
}
|
|
|
|
// BeginSegment is for testing metabase.BeginSegment.
|
|
type BeginSegment struct {
|
|
Opts metabase.BeginSegment
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step BeginSegment) Check(ctx *testcontext.Context, t require.TestingT, db *metabase.DB) {
|
|
err := db.BeginSegment(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// CommitSegment is for testing metabase.CommitSegment.
|
|
type CommitSegment struct {
|
|
Opts metabase.CommitSegment
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step CommitSegment) Check(ctx *testcontext.Context, t require.TestingT, db *metabase.DB) {
|
|
err := db.CommitSegment(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// CommitInlineSegment is for testing metabase.CommitInlineSegment.
|
|
type CommitInlineSegment struct {
|
|
Opts metabase.CommitInlineSegment
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step CommitInlineSegment) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
err := db.CommitInlineSegment(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// DeleteBucketObjects is for testing metabase.DeleteBucketObjects.
|
|
type DeleteBucketObjects struct {
|
|
Opts metabase.DeleteBucketObjects
|
|
Deleted int64
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step DeleteBucketObjects) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
deleted, err := db.DeleteBucketObjects(ctx, step.Opts)
|
|
require.Equal(t, step.Deleted, deleted)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// UpdateObjectLastCommittedMetadata is for testing metabase.UpdateObjectLastCommittedMetadata.
|
|
type UpdateObjectLastCommittedMetadata struct {
|
|
Opts metabase.UpdateObjectLastCommittedMetadata
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step UpdateObjectLastCommittedMetadata) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
err := db.UpdateObjectLastCommittedMetadata(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// UpdateSegmentPieces is for testing metabase.UpdateSegmentPieces.
|
|
type UpdateSegmentPieces struct {
|
|
Opts metabase.UpdateSegmentPieces
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step UpdateSegmentPieces) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
err := db.UpdateSegmentPieces(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// GetObjectExactVersion is for testing metabase.GetObjectExactVersion.
|
|
type GetObjectExactVersion struct {
|
|
Opts metabase.GetObjectExactVersion
|
|
Result metabase.Object
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step GetObjectExactVersion) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.GetObjectExactVersion(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// GetObjectLastCommitted is for testing metabase.GetObjectLastCommitted.
|
|
type GetObjectLastCommitted struct {
|
|
Opts metabase.GetObjectLastCommitted
|
|
Result metabase.Object
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step GetObjectLastCommitted) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.GetObjectLastCommitted(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
diff := cmp.Diff(step.Result, result, cmpopts.EquateApproxTime(5*time.Second))
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// GetSegmentByPosition is for testing metabase.GetSegmentByPosition.
|
|
type GetSegmentByPosition struct {
|
|
Opts metabase.GetSegmentByPosition
|
|
Result metabase.Segment
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step GetSegmentByPosition) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.GetSegmentByPosition(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// GetLatestObjectLastSegment is for testing metabase.GetLatestObjectLastSegment.
|
|
type GetLatestObjectLastSegment struct {
|
|
Opts metabase.GetLatestObjectLastSegment
|
|
Result metabase.Segment
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step GetLatestObjectLastSegment) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.GetLatestObjectLastSegment(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// BucketEmpty is for testing metabase.BucketEmpty.
|
|
type BucketEmpty struct {
|
|
Opts metabase.BucketEmpty
|
|
Result bool
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step BucketEmpty) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.BucketEmpty(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
require.Equal(t, step.Result, result)
|
|
}
|
|
|
|
// ListSegments is for testing metabase.ListSegments.
|
|
type ListSegments struct {
|
|
Opts metabase.ListSegments
|
|
Result metabase.ListSegmentsResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step ListSegments) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.ListSegments(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
if len(step.Result.Segments) == 0 && len(result.Segments) == 0 {
|
|
return
|
|
}
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// ListVerifySegments is for testing metabase.ListVerifySegments.
|
|
type ListVerifySegments struct {
|
|
Opts metabase.ListVerifySegments
|
|
Result metabase.ListVerifySegmentsResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step ListVerifySegments) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.ListVerifySegments(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff(), cmpopts.EquateEmpty())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// ListObjects is for testing metabase.ListObjects.
|
|
type ListObjects struct {
|
|
Opts metabase.ListObjects
|
|
Result metabase.ListObjectsResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step ListObjects) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.ListObjects(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff(), cmpopts.EquateEmpty())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// ListStreamPositions is for testing metabase.ListStreamPositions.
|
|
type ListStreamPositions struct {
|
|
Opts metabase.ListStreamPositions
|
|
Result metabase.ListStreamPositionsResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step ListStreamPositions) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.ListStreamPositions(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// GetStreamPieceCountByNodeID is for testing metabase.GetStreamPieceCountByNodeID.
|
|
type GetStreamPieceCountByNodeID struct {
|
|
Opts metabase.GetStreamPieceCountByNodeID
|
|
Result map[storj.NodeID]int64
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step GetStreamPieceCountByNodeID) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.GetStreamPieceCountByNodeID(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result)
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// IterateLoopSegments is for testing metabase.IterateLoopSegments.
|
|
type IterateLoopSegments struct {
|
|
Opts metabase.IterateLoopSegments
|
|
Result []metabase.LoopSegmentEntry
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step IterateLoopSegments) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result := make([]metabase.LoopSegmentEntry, 0, 10)
|
|
err := db.IterateLoopSegments(ctx, step.Opts,
|
|
func(ctx context.Context, iterator metabase.LoopSegmentsIterator) error {
|
|
var entry metabase.LoopSegmentEntry
|
|
for iterator.Next(ctx, &entry) {
|
|
result = append(result, entry)
|
|
}
|
|
return nil
|
|
})
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
if len(result) == 0 {
|
|
result = nil
|
|
}
|
|
|
|
sort.Slice(step.Result, func(i, j int) bool {
|
|
if step.Result[i].StreamID == step.Result[j].StreamID {
|
|
return step.Result[i].Position.Less(step.Result[j].Position)
|
|
}
|
|
return bytes.Compare(step.Result[i].StreamID[:], step.Result[j].StreamID[:]) < 0
|
|
})
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// DeleteObjectExactVersion is for testing metabase.DeleteObjectExactVersion.
|
|
type DeleteObjectExactVersion struct {
|
|
Opts metabase.DeleteObjectExactVersion
|
|
Result metabase.DeleteObjectResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
func compareDeleteObjectResult(t testing.TB, got, exp metabase.DeleteObjectResult) {
|
|
t.Helper()
|
|
|
|
sortObjects(got.Markers)
|
|
sortObjects(exp.Markers)
|
|
if len(got.Markers) == len(exp.Markers) {
|
|
// marker stream ID-s are internally generated, so we cannot upfront figure out what
|
|
// the values are.
|
|
for i := range got.Markers {
|
|
exp.Markers[i].StreamID = got.Markers[i].StreamID
|
|
}
|
|
}
|
|
|
|
sortObjects(got.Removed)
|
|
sortObjects(exp.Removed)
|
|
|
|
diff := cmp.Diff(exp, got, DefaultTimeDiff(), cmpopts.EquateEmpty())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step DeleteObjectExactVersion) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.DeleteObjectExactVersion(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
compareDeleteObjectResult(t, result, step.Result)
|
|
}
|
|
|
|
// DeletePendingObject is for testing metabase.DeletePendingObject.
|
|
type DeletePendingObject struct {
|
|
Opts metabase.DeletePendingObject
|
|
Result metabase.DeleteObjectResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step DeletePendingObject) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.DeletePendingObject(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
compareDeleteObjectResult(t, result, step.Result)
|
|
}
|
|
|
|
// DeleteObjectsAllVersions is for testing metabase.DeleteObjectsAllVersions.
|
|
type DeleteObjectsAllVersions struct {
|
|
Opts metabase.DeleteObjectsAllVersions
|
|
Result metabase.DeleteObjectResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step DeleteObjectsAllVersions) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.DeleteObjectsAllVersions(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
compareDeleteObjectResult(t, result, step.Result)
|
|
}
|
|
|
|
// DeleteExpiredObjects is for testing metabase.DeleteExpiredObjects.
|
|
type DeleteExpiredObjects struct {
|
|
Opts metabase.DeleteExpiredObjects
|
|
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step DeleteExpiredObjects) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
err := db.DeleteExpiredObjects(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// DeleteZombieObjects is for testing metabase.DeleteZombieObjects.
|
|
type DeleteZombieObjects struct {
|
|
Opts metabase.DeleteZombieObjects
|
|
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step DeleteZombieObjects) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
err := db.DeleteZombieObjects(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// IterateCollector is for testing metabase.IterateCollector.
|
|
type IterateCollector []metabase.ObjectEntry
|
|
|
|
// Add adds object entries from iterator to the collection.
|
|
func (coll *IterateCollector) Add(ctx context.Context, it metabase.ObjectsIterator) error {
|
|
var item metabase.ObjectEntry
|
|
|
|
for it.Next(ctx, &item) {
|
|
*coll = append(*coll, item)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// LoopIterateCollector is for testing metabase.LoopIterateCollector.
|
|
type LoopIterateCollector []metabase.LoopObjectEntry
|
|
|
|
// Add adds object entries from iterator to the collection.
|
|
func (coll *LoopIterateCollector) Add(ctx context.Context, it metabase.LoopObjectsIterator) error {
|
|
var item metabase.LoopObjectEntry
|
|
|
|
for it.Next(ctx, &item) {
|
|
*coll = append(*coll, item)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// PendingObjectsCollector is for testing metabase.PendingObjectsCollector.
|
|
type PendingObjectsCollector []metabase.PendingObjectEntry
|
|
|
|
// Add adds object entries from iterator to the collection.
|
|
func (coll *PendingObjectsCollector) Add(ctx context.Context, it metabase.PendingObjectsIterator) error {
|
|
var item metabase.PendingObjectEntry
|
|
|
|
for it.Next(ctx, &item) {
|
|
*coll = append(*coll, item)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// IteratePendingObjectsByKey is for testing metabase.IteratePendingObjectsByKey.
|
|
type IteratePendingObjectsByKey struct {
|
|
Opts metabase.IteratePendingObjectsByKey
|
|
|
|
Result []metabase.ObjectEntry
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step IteratePendingObjectsByKey) Check(ctx *testcontext.Context, t *testing.T, db *metabase.DB) {
|
|
var collector IterateCollector
|
|
|
|
err := db.IteratePendingObjectsByKey(ctx, step.Opts, collector.Add)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
result := []metabase.ObjectEntry(collector)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// IterateObjectsWithStatus is for testing metabase.IterateObjectsWithStatus.
|
|
type IterateObjectsWithStatus struct {
|
|
Opts metabase.IterateObjectsWithStatus
|
|
|
|
Result []metabase.ObjectEntry
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step IterateObjectsWithStatus) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
var result IterateCollector
|
|
|
|
err := db.IterateObjectsAllVersionsWithStatus(ctx, step.Opts, result.Add)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, []metabase.ObjectEntry(result), DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// IterateLoopObjects is for testing metabase.IterateLoopObjects.
|
|
type IterateLoopObjects struct {
|
|
Opts metabase.IterateLoopObjects
|
|
|
|
Result []metabase.LoopObjectEntry
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step IterateLoopObjects) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
var result LoopIterateCollector
|
|
|
|
err := db.IterateLoopObjects(ctx, step.Opts, result.Add)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, []metabase.LoopObjectEntry(result), DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// EnsureNodeAliases is for testing metabase.EnsureNodeAliases.
|
|
type EnsureNodeAliases struct {
|
|
Opts metabase.EnsureNodeAliases
|
|
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step EnsureNodeAliases) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
err := db.EnsureNodeAliases(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// ListNodeAliases is for testing metabase.ListNodeAliases.
|
|
type ListNodeAliases struct {
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step ListNodeAliases) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) []metabase.NodeAliasEntry {
|
|
result, err := db.ListNodeAliases(ctx)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
return result
|
|
}
|
|
|
|
// GetTableStats is for testing metabase.GetTableStats.
|
|
type GetTableStats struct {
|
|
Opts metabase.GetTableStats
|
|
Result metabase.TableStats
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step GetTableStats) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) metabase.TableStats {
|
|
result, err := db.GetTableStats(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result)
|
|
require.Zero(t, diff)
|
|
|
|
return result
|
|
}
|
|
|
|
// BeginMoveObject is for testing metabase.BeginMoveObject.
|
|
type BeginMoveObject struct {
|
|
Opts metabase.BeginMoveObject
|
|
Result metabase.BeginMoveObjectResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step BeginMoveObject) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.BeginMoveObject(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result)
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// FinishMoveObject is for testing metabase.FinishMoveObject.
|
|
type FinishMoveObject struct {
|
|
Opts metabase.FinishMoveObject
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step FinishMoveObject) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
err := db.FinishMoveObject(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
}
|
|
|
|
// BeginCopyObject is for testing metabase.BeginCopyObject.
|
|
type BeginCopyObject struct {
|
|
Opts metabase.BeginCopyObject
|
|
Result metabase.BeginCopyObjectResult
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step BeginCopyObject) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.BeginCopyObject(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result)
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
// FinishCopyObject is for testing metabase.FinishCopyObject.
|
|
type FinishCopyObject struct {
|
|
Opts metabase.FinishCopyObject
|
|
Result metabase.Object
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step FinishCopyObject) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) metabase.Object {
|
|
result, err := db.FinishCopyObject(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff())
|
|
require.Zero(t, diff)
|
|
return result
|
|
}
|
|
|
|
// DeleteObjectLastCommitted is for testing metabase.DeleteObjectLastCommitted.
|
|
type DeleteObjectLastCommitted struct {
|
|
Opts metabase.DeleteObjectLastCommitted
|
|
Result metabase.DeleteObjectResult
|
|
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
|
|
OutputMarkerStreamID *uuid.UUID
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step DeleteObjectLastCommitted) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) metabase.DeleteObjectResult {
|
|
result, err := db.DeleteObjectLastCommitted(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
compareDeleteObjectResult(t, result, step.Result)
|
|
|
|
if step.OutputMarkerStreamID != nil && len(result.Markers) > 0 {
|
|
*step.OutputMarkerStreamID = result.Markers[0].StreamID
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// CollectBucketTallies is for testing metabase.CollectBucketTallies.
|
|
type CollectBucketTallies struct {
|
|
Opts metabase.CollectBucketTallies
|
|
Result []metabase.BucketTally
|
|
ErrClass *errs.Class
|
|
ErrText string
|
|
}
|
|
|
|
// Check runs the test.
|
|
func (step CollectBucketTallies) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
result, err := db.CollectBucketTallies(ctx, step.Opts)
|
|
checkError(t, err, step.ErrClass, step.ErrText)
|
|
|
|
sortBucketTallies(result)
|
|
sortBucketTallies(step.Result)
|
|
|
|
diff := cmp.Diff(step.Result, result, DefaultTimeDiff(), cmpopts.EquateEmpty())
|
|
require.Zero(t, diff)
|
|
}
|