31560c94f8
Tests are intermittently fail with similar error:
```
--- FAIL: TestDeletePendingObject/Cockroach (15.85s)
test.go:380:
Error Trace: test.go:380
delete_test.go:221
Error: Should be zero, but was metabase.DeleteObjectResult{
Objects: []metabase.Object{
{
ObjectStream: {ProjectID: {0x0f, 0x40, 0x70, 0x41, ...}, BucketName: "txxywyg4", ObjectKey: "\xbb+$\x17\x80\xc6\xcaC\xa3\xdb\xc3z*\xa8\xbe\xaf", Version: 1, ...},
- CreatedAt: s"2022-05-20 14:40:15.995376773 +0200 CEST",
+ CreatedAt: s"2022-05-20 14:40:21.04949 +0200 CEST",
ExpiresAt: nil,
Status: 1,
... // 9 identical fields
},
},
Segments: {{RootPieceID: {0x01, 0x00, 0x00, 0x00, ...}, Pieces: {{...}}}, {RootPieceID: {0x01, 0x00, 0x00, 0x00, ...}, Pieces: {{...}}}},
}
Test: TestDeletePendingObject/Cockroach/with_segments
--- FAIL: TestDeletePendingObject/Cockroach/with_segments (0.68s)
```
Looks like we shouldn't have an assumption that all tests can be finished in 5 seconds, especially not in highly parallel environment.
These tests use `time.Now` at the beginning and compare the time saved in the database (usually filled by the database).
The difference shouldn't be higher than 20 seconds (before this commit: 5 seconds) which assumes that the records are saved in this timeframe...
Change-Id: Ia6f52897d13f88c6857c05d728bf8e72ab863c9b
100 lines
2.6 KiB
Go
100 lines
2.6 KiB
Go
// Copyright (C) 2021 Storj Labs, Inc.
|
|
// See LICENSE for copying information.
|
|
|
|
package metabasetest
|
|
|
|
import (
|
|
"bytes"
|
|
"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/testcontext"
|
|
"storj.io/storj/satellite/metabase"
|
|
)
|
|
|
|
// DeleteAll deletes all data from metabase.
|
|
type DeleteAll struct{}
|
|
|
|
// Check runs the test.
|
|
func (step DeleteAll) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
err := db.TestingDeleteAll(ctx)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// Verify verifies whether metabase state matches the content.
|
|
type Verify metabase.RawState
|
|
|
|
// Check runs the test.
|
|
func (step Verify) Check(ctx *testcontext.Context, t testing.TB, db *metabase.DB) {
|
|
state, err := db.TestingGetState(ctx)
|
|
require.NoError(t, err)
|
|
|
|
sortRawObjects(state.Objects)
|
|
sortRawObjects(step.Objects)
|
|
sortRawSegments(state.Segments)
|
|
sortRawSegments(step.Segments)
|
|
sortRawCopies(state.Copies)
|
|
sortRawCopies(step.Copies)
|
|
|
|
diff := cmp.Diff(metabase.RawState(step), *state,
|
|
DefaultTimeDiff(),
|
|
cmpopts.EquateEmpty())
|
|
require.Zero(t, diff)
|
|
}
|
|
|
|
func sortObjects(objects []metabase.Object) {
|
|
sort.Slice(objects, func(i, j int) bool {
|
|
return objects[i].StreamID.Less(objects[j].StreamID)
|
|
})
|
|
}
|
|
|
|
func sortRawObjects(objects []metabase.RawObject) {
|
|
sort.Slice(objects, func(i, j int) bool {
|
|
return objects[i].StreamID.Less(objects[j].StreamID)
|
|
})
|
|
}
|
|
|
|
func sortRawSegments(segments []metabase.RawSegment) {
|
|
sort.Slice(segments, func(i, j int) bool {
|
|
if segments[i].StreamID == segments[j].StreamID {
|
|
return segments[i].Position.Less(segments[j].Position)
|
|
}
|
|
return segments[i].StreamID.Less(segments[j].StreamID)
|
|
})
|
|
}
|
|
|
|
func sortRawCopies(copies []metabase.RawCopy) {
|
|
sort.Slice(copies, func(i, j int) bool {
|
|
return copies[i].StreamID.Less(copies[j].StreamID)
|
|
})
|
|
}
|
|
|
|
func sortDeletedSegments(segments []metabase.DeletedSegmentInfo) {
|
|
sort.Slice(segments, func(i, j int) bool {
|
|
return bytes.Compare(segments[i].RootPieceID[:], segments[j].RootPieceID[:]) < 0
|
|
})
|
|
}
|
|
|
|
func checkError(t testing.TB, err error, errClass *errs.Class, errText string) {
|
|
if errClass != nil {
|
|
require.True(t, errClass.Has(err), "expected an error %v got %v", *errClass, err)
|
|
}
|
|
if errText != "" {
|
|
require.EqualError(t, err, errClass.New(errText).Error())
|
|
}
|
|
if errClass == nil && errText == "" {
|
|
require.NoError(t, err)
|
|
}
|
|
}
|
|
|
|
// DefaultTimeDiff is the central place to adjust test sql "timeout" (accepted diff between start and end of the test).
|
|
func DefaultTimeDiff() cmp.Option {
|
|
return cmpopts.EquateApproxTime(20 * time.Second)
|
|
}
|