forked from TrueCloudLab/frostfs-node
1223 lines
32 KiB
Go
1223 lines
32 KiB
Go
package meta_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/hex"
|
|
"math/rand"
|
|
"strconv"
|
|
"testing"
|
|
|
|
v2object "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/object"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/object"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/internal/testutil"
|
|
meta "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/metabase"
|
|
cidSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
|
|
cidtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id/test"
|
|
objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/erasurecode"
|
|
oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
|
|
oidtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id/test"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/transformer"
|
|
usertest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/user/test"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/version"
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestDB_SelectUserAttributes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
raw1 := testutil.GenerateObjectWithCID(cnr)
|
|
testutil.AddAttribute(raw1, "foo", "bar")
|
|
testutil.AddAttribute(raw1, "x", "y")
|
|
|
|
err := putBig(db, raw1)
|
|
require.NoError(t, err)
|
|
|
|
raw2 := testutil.GenerateObjectWithCID(cnr)
|
|
testutil.AddAttribute(raw2, "foo", "bar")
|
|
testutil.AddAttribute(raw2, "x", "z")
|
|
|
|
err = putBig(db, raw2)
|
|
require.NoError(t, err)
|
|
|
|
raw3 := testutil.GenerateObjectWithCID(cnr)
|
|
testutil.AddAttribute(raw3, "a", "b")
|
|
|
|
err = putBig(db, raw3)
|
|
require.NoError(t, err)
|
|
|
|
raw4 := testutil.GenerateObjectWithCID(cnr)
|
|
testutil.AddAttribute(raw4, "path", "test/1/2")
|
|
|
|
err = putBig(db, raw4)
|
|
require.NoError(t, err)
|
|
|
|
raw5 := testutil.GenerateObjectWithCID(cnr)
|
|
testutil.AddAttribute(raw5, "path", "test/1/3")
|
|
|
|
err = putBig(db, raw5)
|
|
require.NoError(t, err)
|
|
|
|
raw6 := testutil.GenerateObjectWithCID(cnr)
|
|
testutil.AddAttribute(raw6, "path", "test/2/3")
|
|
|
|
err = putBig(db, raw6)
|
|
require.NoError(t, err)
|
|
|
|
raw7 := testutil.GenerateObjectWithCID(cnr)
|
|
var attr objectSDK.Attribute
|
|
attr.SetKey("path")
|
|
attr.SetValue("test/3/4")
|
|
attrs := raw7.Attributes()
|
|
attrs = append(attrs, attr)
|
|
ech := objectSDK.NewECHeader(objectSDK.ECParentInfo{
|
|
ID: oidtest.ID(),
|
|
Attributes: attrs,
|
|
}, 0, 3, []byte{}, 0)
|
|
raw7.SetECHeader(ech)
|
|
require.NoError(t, putBig(db, raw7))
|
|
var raw7Parent oid.Address
|
|
raw7Parent.SetContainer(cnr)
|
|
raw7Parent.SetObject(ech.Parent())
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter("foo", "bar", objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw1),
|
|
object.AddressOf(raw2),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("x", "y", objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("x", "y", objectSDK.MatchStringNotEqual)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw2))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("a", "b", objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw3))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("c", "d", objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("foo", "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw3),
|
|
object.AddressOf(raw4),
|
|
object.AddressOf(raw5),
|
|
object.AddressOf(raw6),
|
|
object.AddressOf(raw7),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("a", "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw1),
|
|
object.AddressOf(raw2),
|
|
object.AddressOf(raw4),
|
|
object.AddressOf(raw5),
|
|
object.AddressOf(raw6),
|
|
object.AddressOf(raw7),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw1),
|
|
object.AddressOf(raw2),
|
|
object.AddressOf(raw3),
|
|
object.AddressOf(raw4),
|
|
object.AddressOf(raw5),
|
|
object.AddressOf(raw6),
|
|
object.AddressOf(raw7),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("key", "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw1),
|
|
object.AddressOf(raw2),
|
|
object.AddressOf(raw3),
|
|
object.AddressOf(raw4),
|
|
object.AddressOf(raw5),
|
|
object.AddressOf(raw6),
|
|
object.AddressOf(raw7),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("path", "test", objectSDK.MatchCommonPrefix)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw4),
|
|
object.AddressOf(raw5),
|
|
object.AddressOf(raw6),
|
|
raw7Parent,
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("path", "test/1", objectSDK.MatchCommonPrefix)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw4),
|
|
object.AddressOf(raw5),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter("path", "test/3/4", objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs,
|
|
raw7Parent,
|
|
)
|
|
}
|
|
|
|
func TestDB_SelectRootPhyParent(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
// prepare
|
|
|
|
small := testutil.GenerateObjectWithCID(cnr)
|
|
err := putBig(db, small)
|
|
require.NoError(t, err)
|
|
|
|
ts := testutil.GenerateObjectWithCID(cnr)
|
|
ts.SetType(objectSDK.TypeTombstone)
|
|
err = putBig(db, ts)
|
|
require.NoError(t, err)
|
|
|
|
leftChild := testutil.GenerateObjectWithCID(cnr)
|
|
leftChild.InitRelations()
|
|
err = putBig(db, leftChild)
|
|
require.NoError(t, err)
|
|
|
|
lock := testutil.GenerateObjectWithCID(cnr)
|
|
lock.SetType(objectSDK.TypeLock)
|
|
err = putBig(db, lock)
|
|
require.NoError(t, err)
|
|
|
|
parent := testutil.GenerateObjectWithCID(cnr)
|
|
|
|
rightChild := testutil.GenerateObjectWithCID(cnr)
|
|
rightChild.SetParent(parent)
|
|
idParent, _ := parent.ID()
|
|
rightChild.SetParentID(idParent)
|
|
err = putBig(db, rightChild)
|
|
require.NoError(t, err)
|
|
|
|
link := testutil.GenerateObjectWithCID(cnr)
|
|
link.SetParent(parent)
|
|
link.SetParentID(idParent)
|
|
idLeftChild, _ := leftChild.ID()
|
|
idRightChild, _ := rightChild.ID()
|
|
link.SetChildren(idLeftChild, idRightChild)
|
|
|
|
err = putBig(db, link)
|
|
require.NoError(t, err)
|
|
|
|
t.Run("root objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddRootFilter()
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(small),
|
|
object.AddressOf(parent),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterPropertyRoot, "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("phy objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddPhyFilter()
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(small),
|
|
object.AddressOf(ts),
|
|
object.AddressOf(leftChild),
|
|
object.AddressOf(rightChild),
|
|
object.AddressOf(link),
|
|
object.AddressOf(lock),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterPropertyPhy, "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("regular objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderObjectType, v2object.TypeRegular.String(), objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(small),
|
|
object.AddressOf(leftChild),
|
|
object.AddressOf(rightChild),
|
|
object.AddressOf(link),
|
|
object.AddressOf(parent),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderObjectType, v2object.TypeRegular.String(), objectSDK.MatchStringNotEqual)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(ts),
|
|
object.AddressOf(lock),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderObjectType, "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("tombstone objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderObjectType, v2object.TypeTombstone.String(), objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(ts))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderObjectType, v2object.TypeTombstone.String(), objectSDK.MatchStringNotEqual)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(small),
|
|
object.AddressOf(leftChild),
|
|
object.AddressOf(rightChild),
|
|
object.AddressOf(link),
|
|
object.AddressOf(parent),
|
|
object.AddressOf(lock),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderObjectType, "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("objects with parent", func(t *testing.T) {
|
|
idParent, _ := parent.ID()
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderParent,
|
|
idParent.EncodeToString(),
|
|
objectSDK.MatchStringEqual)
|
|
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(rightChild),
|
|
object.AddressOf(link),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderParent, "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("all objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(small),
|
|
object.AddressOf(ts),
|
|
object.AddressOf(leftChild),
|
|
object.AddressOf(rightChild),
|
|
object.AddressOf(link),
|
|
object.AddressOf(parent),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
}
|
|
|
|
func TestDB_SelectInhume(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
raw1 := testutil.GenerateObjectWithCID(cnr)
|
|
err := putBig(db, raw1)
|
|
require.NoError(t, err)
|
|
|
|
raw2 := testutil.GenerateObjectWithCID(cnr)
|
|
err = putBig(db, raw2)
|
|
require.NoError(t, err)
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw1),
|
|
object.AddressOf(raw2),
|
|
)
|
|
|
|
err = metaInhume(db, object.AddressOf(raw2), oidtest.ID())
|
|
require.NoError(t, err)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(raw1),
|
|
)
|
|
}
|
|
|
|
func TestDB_SelectPayloadHash(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
raw1 := testutil.GenerateObjectWithCID(cnr)
|
|
err := putBig(db, raw1)
|
|
require.NoError(t, err)
|
|
|
|
raw2 := testutil.GenerateObjectWithCID(cnr)
|
|
err = putBig(db, raw2)
|
|
require.NoError(t, err)
|
|
|
|
cs, _ := raw1.PayloadChecksum()
|
|
payloadHash := hex.EncodeToString(cs.Value())
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadHash,
|
|
payloadHash,
|
|
objectSDK.MatchStringEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadHash,
|
|
payloadHash[:len(payloadHash)-1],
|
|
objectSDK.MatchCommonPrefix)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadHash,
|
|
payloadHash,
|
|
objectSDK.MatchStringNotEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw2))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadHash,
|
|
"",
|
|
objectSDK.MatchNotPresent)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
|
|
t.Run("invalid hashes", func(t *testing.T) {
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadHash,
|
|
payloadHash[:len(payloadHash)-1],
|
|
objectSDK.MatchStringNotEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1), object.AddressOf(raw2))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadHash,
|
|
payloadHash[:len(payloadHash)-2]+"x",
|
|
objectSDK.MatchCommonPrefix)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadHash,
|
|
payloadHash[:len(payloadHash)-3]+"x0",
|
|
objectSDK.MatchCommonPrefix)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
}
|
|
|
|
func TestDB_SelectWithSlowFilters(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
v20 := new(version.Version)
|
|
v20.SetMajor(2)
|
|
|
|
var v21 version.Version
|
|
v21.SetMajor(2)
|
|
v21.SetMinor(1)
|
|
|
|
raw1 := testutil.GenerateObjectWithCID(cnr)
|
|
raw1.SetPayloadSize(10)
|
|
raw1.SetCreationEpoch(11)
|
|
raw1.SetVersion(v20)
|
|
err := putBig(db, raw1)
|
|
require.NoError(t, err)
|
|
|
|
raw2 := testutil.GenerateObjectWithCID(cnr)
|
|
raw2.SetPayloadSize(20)
|
|
raw2.SetCreationEpoch(21)
|
|
raw2.SetVersion(&v21)
|
|
err = putBig(db, raw2)
|
|
require.NoError(t, err)
|
|
|
|
t.Run("object with TZHash", func(t *testing.T) {
|
|
cs, _ := raw1.PayloadHomomorphicHash()
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderHomomorphicHash,
|
|
hex.EncodeToString(cs.Value()),
|
|
objectSDK.MatchStringEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderHomomorphicHash,
|
|
hex.EncodeToString(cs.Value()),
|
|
objectSDK.MatchStringNotEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw2))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderHomomorphicHash,
|
|
"",
|
|
objectSDK.MatchNotPresent)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("object with payload length", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadLength, "20", objectSDK.MatchStringEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw2))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadLength, "20", objectSDK.MatchStringNotEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderPayloadLength, "", objectSDK.MatchNotPresent)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("object with creation epoch", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderCreationEpoch, "11", objectSDK.MatchStringEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderCreationEpoch, "11", objectSDK.MatchStringNotEqual)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw2))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderCreationEpoch, "", objectSDK.MatchNotPresent)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderCreationEpoch, "1", objectSDK.MatchCommonPrefix)
|
|
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1))
|
|
})
|
|
|
|
t.Run("object with version", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectVersionFilter(objectSDK.MatchStringEqual, v21)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw2))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectVersionFilter(objectSDK.MatchStringNotEqual, v21)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(raw1))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectVersionFilter(objectSDK.MatchNotPresent, version.Version{})
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
}
|
|
|
|
func TestDB_SelectObjectID(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
// prepare
|
|
|
|
parent := testutil.GenerateObjectWithCID(cnr)
|
|
|
|
regular := testutil.GenerateObjectWithCID(cnr)
|
|
idParent, _ := parent.ID()
|
|
regular.SetParentID(idParent)
|
|
regular.SetParent(parent)
|
|
|
|
err := putBig(db, regular)
|
|
require.NoError(t, err)
|
|
|
|
ts := testutil.GenerateObjectWithCID(cnr)
|
|
ts.SetType(objectSDK.TypeTombstone)
|
|
err = putBig(db, ts)
|
|
require.NoError(t, err)
|
|
|
|
lock := testutil.GenerateObjectWithCID(cnr)
|
|
lock.SetType(objectSDK.TypeLock)
|
|
err = putBig(db, lock)
|
|
require.NoError(t, err)
|
|
|
|
t.Run("not found objects", func(t *testing.T) {
|
|
raw := testutil.GenerateObjectWithCID(cnr)
|
|
|
|
id, _ := raw.ID()
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringEqual, id)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringNotEqual, id)
|
|
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(regular),
|
|
object.AddressOf(parent),
|
|
object.AddressOf(ts),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
|
|
t.Run("regular objects", func(t *testing.T) {
|
|
id, _ := regular.ID()
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringEqual, id)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(regular))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringNotEqual, id)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(parent),
|
|
object.AddressOf(ts),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
|
|
t.Run("tombstone objects", func(t *testing.T) {
|
|
id, _ := ts.ID()
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringEqual, id)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(ts))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringNotEqual, id)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(regular),
|
|
object.AddressOf(parent),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
|
|
t.Run("parent objects", func(t *testing.T) {
|
|
id, _ := parent.ID()
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringEqual, id)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(parent))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringNotEqual, id)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(regular),
|
|
object.AddressOf(ts),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
|
|
t.Run("lock objects", func(t *testing.T) {
|
|
id, _ := lock.ID()
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringEqual, id)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(lock))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectIDFilter(objectSDK.MatchStringNotEqual, id)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(regular),
|
|
object.AddressOf(parent),
|
|
object.AddressOf(ts),
|
|
)
|
|
})
|
|
}
|
|
|
|
func TestDB_SelectOwnerID(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
// prepare
|
|
|
|
parent := testutil.GenerateObjectWithCID(cnr)
|
|
|
|
regular := testutil.GenerateObjectWithCID(cnr)
|
|
idParent, _ := parent.ID()
|
|
regular.SetParentID(idParent)
|
|
regular.SetParent(parent)
|
|
|
|
err := putBig(db, regular)
|
|
require.NoError(t, err)
|
|
|
|
ts := testutil.GenerateObjectWithCID(cnr)
|
|
ts.SetType(objectSDK.TypeTombstone)
|
|
err = putBig(db, ts)
|
|
require.NoError(t, err)
|
|
|
|
lock := testutil.GenerateObjectWithCID(cnr)
|
|
lock.SetType(objectSDK.TypeLock)
|
|
err = putBig(db, lock)
|
|
require.NoError(t, err)
|
|
|
|
t.Run("not found objects", func(t *testing.T) {
|
|
raw := testutil.GenerateObjectWithCID(cnr)
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringEqual, raw.OwnerID())
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringNotEqual, raw.OwnerID())
|
|
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(regular),
|
|
object.AddressOf(parent),
|
|
object.AddressOf(ts),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
|
|
t.Run("regular objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringEqual, regular.OwnerID())
|
|
testSelect(t, db, cnr, fs, object.AddressOf(regular))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringNotEqual, regular.OwnerID())
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(parent),
|
|
object.AddressOf(ts),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
|
|
t.Run("tombstone objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringEqual, ts.OwnerID())
|
|
testSelect(t, db, cnr, fs, object.AddressOf(ts))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringNotEqual, ts.OwnerID())
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(regular),
|
|
object.AddressOf(parent),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
|
|
t.Run("parent objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringEqual, parent.OwnerID())
|
|
testSelect(t, db, cnr, fs, object.AddressOf(parent))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringNotEqual, parent.OwnerID())
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(regular),
|
|
object.AddressOf(ts),
|
|
object.AddressOf(lock),
|
|
)
|
|
})
|
|
|
|
t.Run("lock objects", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringEqual, lock.OwnerID())
|
|
testSelect(t, db, cnr, fs, object.AddressOf(lock))
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectOwnerIDFilter(objectSDK.MatchStringNotEqual, lock.OwnerID())
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(regular),
|
|
object.AddressOf(parent),
|
|
object.AddressOf(ts),
|
|
)
|
|
})
|
|
}
|
|
|
|
func TestDB_SelectECWithFastAndSlowFilters(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
ecChunk1 := oidtest.ID()
|
|
ecChunk2 := oidtest.ID()
|
|
ecParent := oidtest.ID()
|
|
var ecParentAddr oid.Address
|
|
ecParentAddr.SetContainer(cnr)
|
|
ecParentAddr.SetObject(ecParent)
|
|
var ecParentAttr []objectSDK.Attribute
|
|
var attr objectSDK.Attribute
|
|
attr.SetKey(objectSDK.AttributeFilePath)
|
|
attr.SetValue("/1/2/3")
|
|
ecParentAttr = append(ecParentAttr, attr)
|
|
|
|
chunkObj := testutil.GenerateObjectWithCID(cnr)
|
|
chunkObj.SetContainerID(cnr)
|
|
chunkObj.SetID(ecChunk1)
|
|
chunkObj.SetPayload([]byte{0, 1, 2, 3, 4})
|
|
chunkObj.SetPayloadSize(uint64(5))
|
|
chunkObj.SetECHeader(objectSDK.NewECHeader(objectSDK.ECParentInfo{ID: ecParent, Attributes: ecParentAttr}, 0, 3, []byte{}, 0))
|
|
|
|
chunkObj2 := testutil.GenerateObjectWithCID(cnr)
|
|
chunkObj2.SetContainerID(cnr)
|
|
chunkObj2.SetID(ecChunk2)
|
|
chunkObj2.SetPayload([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
|
|
chunkObj2.SetPayloadSize(uint64(10))
|
|
chunkObj2.SetECHeader(objectSDK.NewECHeader(objectSDK.ECParentInfo{ID: ecParent, Attributes: ecParentAttr}, 1, 3, []byte{}, 0))
|
|
|
|
// put object with EC
|
|
|
|
var prm meta.PutPrm
|
|
prm.SetObject(chunkObj)
|
|
_, err := db.Put(context.Background(), prm)
|
|
require.NoError(t, err)
|
|
|
|
prm.SetObject(chunkObj2)
|
|
_, err = db.Put(context.Background(), prm)
|
|
require.NoError(t, err)
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddRootFilter()
|
|
fs.AddFilter(objectSDK.AttributeFilePath, "/1/2/3", objectSDK.MatchCommonPrefix)
|
|
testSelect(t, db, cnr, fs, ecParentAddr)
|
|
}
|
|
|
|
type testTarget struct {
|
|
objects []*objectSDK.Object
|
|
}
|
|
|
|
func (tt *testTarget) WriteObject(_ context.Context, obj *objectSDK.Object) error {
|
|
tt.objects = append(tt.objects, obj)
|
|
return nil
|
|
}
|
|
|
|
func cutObject(t *testing.T, p transformer.ChunkedObjectWriter, hdr *objectSDK.Object, size int) *transformer.AccessIdentifiers {
|
|
ctx := context.Background()
|
|
require.NoError(t, p.WriteHeader(ctx, hdr))
|
|
|
|
payload := make([]byte, size)
|
|
rand.New(rand.NewSource(0)).Read(payload)
|
|
|
|
_, err := p.Write(ctx, payload)
|
|
require.NoError(t, err)
|
|
|
|
ids, err := p.Close(ctx)
|
|
require.NoError(t, err)
|
|
return ids
|
|
}
|
|
|
|
func TestDB_RawHead_SplitInfo(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const (
|
|
partSize = 10
|
|
partCount = 2
|
|
dataCount = 2
|
|
parityCount = 1
|
|
)
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
pk, err := keys.NewPrivateKey()
|
|
require.NoError(t, err)
|
|
|
|
tt := new(testTarget)
|
|
p := transformer.NewPayloadSizeLimiter(transformer.Params{
|
|
Key: &pk.PrivateKey,
|
|
NextTargetInit: func() transformer.ObjectWriter { return tt },
|
|
NetworkState: epochState{e: 1},
|
|
MaxSize: partSize,
|
|
})
|
|
|
|
hdr := objectSDK.New()
|
|
hdr.SetContainerID(cnr)
|
|
hdr.SetOwnerID(usertest.ID())
|
|
ids := cutObject(t, p, hdr, partSize*partCount)
|
|
require.Equal(t, len(tt.objects), partCount+1)
|
|
|
|
t.Run("rep", func(t *testing.T) {
|
|
testGetRawSplitInfo(t, cnr, ids, tt.objects[partCount], tt.objects[partCount-1])
|
|
})
|
|
t.Run("with ec", func(t *testing.T) {
|
|
ec, err := erasurecode.NewConstructor(dataCount, parityCount)
|
|
require.NoError(t, err)
|
|
|
|
cs, err := ec.Split(tt.objects[partCount-1], &pk.PrivateKey)
|
|
require.NoError(t, err)
|
|
|
|
testGetRawSplitInfo(t, cnr, ids, tt.objects[partCount], cs[0])
|
|
})
|
|
}
|
|
|
|
func testGetRawSplitInfo(t *testing.T, cnr cidSDK.ID, ids *transformer.AccessIdentifiers, linking, lastPart *objectSDK.Object) {
|
|
expectedLinkID, ok := linking.ID()
|
|
require.True(t, ok)
|
|
|
|
t.Run("first last, then linking", func(t *testing.T) {
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
require.NoError(t, metaPut(db, lastPart, nil))
|
|
require.NoError(t, metaPut(db, linking, nil))
|
|
|
|
var addr oid.Address
|
|
addr.SetContainer(cnr)
|
|
addr.SetObject(*ids.ParentID)
|
|
|
|
_, err := metaGet(db, addr, true)
|
|
|
|
var siErr *objectSDK.SplitInfoError
|
|
require.ErrorAs(t, err, &siErr)
|
|
|
|
lastID, ok := siErr.SplitInfo().LastPart()
|
|
require.True(t, ok)
|
|
require.Equal(t, ids.SelfID, lastID)
|
|
|
|
linkID, ok := siErr.SplitInfo().Link()
|
|
require.True(t, ok)
|
|
require.Equal(t, expectedLinkID, linkID)
|
|
})
|
|
t.Run("first linking, then last", func(t *testing.T) {
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
require.NoError(t, metaPut(db, linking, nil))
|
|
require.NoError(t, metaPut(db, lastPart, nil))
|
|
|
|
var addr oid.Address
|
|
addr.SetContainer(cnr)
|
|
addr.SetObject(*ids.ParentID)
|
|
|
|
_, err := metaGet(db, addr, true)
|
|
|
|
var siErr *objectSDK.SplitInfoError
|
|
require.ErrorAs(t, err, &siErr)
|
|
|
|
lastID, ok := siErr.SplitInfo().LastPart()
|
|
require.True(t, ok)
|
|
require.Equal(t, ids.SelfID, lastID)
|
|
|
|
linkID, ok := siErr.SplitInfo().Link()
|
|
require.True(t, ok)
|
|
require.Equal(t, expectedLinkID, linkID)
|
|
})
|
|
t.Run("only last part", func(t *testing.T) {
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
require.NoError(t, metaPut(db, lastPart, nil))
|
|
|
|
var addr oid.Address
|
|
addr.SetContainer(cnr)
|
|
addr.SetObject(*ids.ParentID)
|
|
|
|
_, err := metaGet(db, addr, true)
|
|
|
|
var siErr *objectSDK.SplitInfoError
|
|
require.ErrorAs(t, err, &siErr)
|
|
|
|
lastPart, ok := siErr.SplitInfo().LastPart()
|
|
require.True(t, ok)
|
|
require.Equal(t, ids.SelfID, lastPart)
|
|
})
|
|
}
|
|
|
|
func TestDB_SelectSplitID_EC(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const (
|
|
partSize = 10
|
|
partCount = 2
|
|
dataCount = 2
|
|
parityCount = 1
|
|
)
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
pk, err := keys.NewPrivateKey()
|
|
require.NoError(t, err)
|
|
|
|
tt := new(testTarget)
|
|
p := transformer.NewPayloadSizeLimiter(transformer.Params{
|
|
Key: &pk.PrivateKey,
|
|
NextTargetInit: func() transformer.ObjectWriter { return tt },
|
|
NetworkState: epochState{e: 1},
|
|
MaxSize: partSize,
|
|
})
|
|
|
|
hdr := objectSDK.New()
|
|
hdr.SetContainerID(cnr)
|
|
hdr.SetOwnerID(usertest.ID())
|
|
cutObject(t, p, hdr, partSize*partCount)
|
|
require.Equal(t, len(tt.objects), partCount+1)
|
|
|
|
split := tt.objects[0].SplitID()
|
|
require.NotNil(t, split)
|
|
|
|
ec, err := erasurecode.NewConstructor(dataCount, parityCount)
|
|
require.NoError(t, err)
|
|
|
|
for i := range partCount {
|
|
cs, err := ec.Split(tt.objects[i], &pk.PrivateKey)
|
|
require.NoError(t, err)
|
|
|
|
require.NoError(t, putBig(db, cs[0]))
|
|
}
|
|
|
|
t.Run("not present", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID, "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("split id", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID, split.String(), objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(tt.objects[0]),
|
|
object.AddressOf(tt.objects[1]),
|
|
)
|
|
})
|
|
|
|
t.Run("empty split", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID, "", objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("unknown split id", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID,
|
|
objectSDK.NewSplitID().String(),
|
|
objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
}
|
|
|
|
func TestDB_SelectSplitID(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
child1 := testutil.GenerateObjectWithCID(cnr)
|
|
child2 := testutil.GenerateObjectWithCID(cnr)
|
|
child3 := testutil.GenerateObjectWithCID(cnr)
|
|
|
|
split1 := objectSDK.NewSplitID()
|
|
split2 := objectSDK.NewSplitID()
|
|
|
|
child1.SetSplitID(split1)
|
|
child2.SetSplitID(split1)
|
|
child3.SetSplitID(split2)
|
|
|
|
require.NoError(t, putBig(db, child1))
|
|
require.NoError(t, putBig(db, child2))
|
|
require.NoError(t, putBig(db, child3))
|
|
|
|
t.Run("not present", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID, "", objectSDK.MatchNotPresent)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("split id", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID, split1.String(), objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(child1),
|
|
object.AddressOf(child2),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID, split2.String(), objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs, object.AddressOf(child3))
|
|
})
|
|
|
|
t.Run("empty split", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID, "", objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("unknown split id", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter(v2object.FilterHeaderSplitID,
|
|
objectSDK.NewSplitID().String(),
|
|
objectSDK.MatchStringEqual)
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
}
|
|
|
|
func TestDB_SelectContainerID(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t)
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
cnr := cidtest.ID()
|
|
|
|
obj1 := testutil.GenerateObjectWithCID(cnr)
|
|
err := putBig(db, obj1)
|
|
require.NoError(t, err)
|
|
|
|
obj2 := testutil.GenerateObjectWithCID(cnr)
|
|
err = putBig(db, obj2)
|
|
require.NoError(t, err)
|
|
|
|
t.Run("same cid", func(t *testing.T) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectContainerIDFilter(objectSDK.MatchStringEqual, cnr)
|
|
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(obj1),
|
|
object.AddressOf(obj2),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectContainerIDFilter(objectSDK.MatchStringNotEqual, cnr)
|
|
|
|
testSelect(t, db, cnr, fs,
|
|
object.AddressOf(obj1),
|
|
object.AddressOf(obj2),
|
|
)
|
|
|
|
fs = objectSDK.SearchFilters{}
|
|
fs.AddObjectContainerIDFilter(objectSDK.MatchNotPresent, cnr)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
|
|
t.Run("not same cid", func(t *testing.T) {
|
|
newCnr := cidtest.ID()
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddObjectContainerIDFilter(objectSDK.MatchStringEqual, newCnr)
|
|
|
|
testSelect(t, db, cnr, fs)
|
|
})
|
|
}
|
|
|
|
func BenchmarkSelect(b *testing.B) {
|
|
const objCount = 1000
|
|
db := newDB(b)
|
|
defer func() { require.NoError(b, db.Close()) }()
|
|
|
|
cid := cidtest.ID()
|
|
|
|
for i := range objCount {
|
|
var attr objectSDK.Attribute
|
|
attr.SetKey("myHeader")
|
|
attr.SetValue(strconv.Itoa(i))
|
|
obj := testutil.GenerateObjectWithCID(cid)
|
|
obj.SetAttributes(attr)
|
|
require.NoError(b, metaPut(db, obj, nil))
|
|
}
|
|
|
|
b.Run("string equal", func(b *testing.B) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter("myHeader", strconv.Itoa(objCount/2), objectSDK.MatchStringEqual)
|
|
benchmarkSelect(b, db, cid, fs, 1)
|
|
})
|
|
b.Run("string not equal", func(b *testing.B) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter("myHeader", strconv.Itoa(objCount/2), objectSDK.MatchStringNotEqual)
|
|
benchmarkSelect(b, db, cid, fs, objCount-1)
|
|
})
|
|
b.Run("common prefix", func(b *testing.B) {
|
|
prefix := "99"
|
|
n := 1 /* 99 */ + 10 /* 990..999 */
|
|
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter("myHeader", prefix, objectSDK.MatchCommonPrefix)
|
|
benchmarkSelect(b, db, cid, fs, n)
|
|
})
|
|
b.Run("unknown", func(b *testing.B) {
|
|
fs := objectSDK.SearchFilters{}
|
|
fs.AddFilter("myHeader", strconv.Itoa(objCount/2), objectSDK.MatchUnknown)
|
|
benchmarkSelect(b, db, cid, fs, 0)
|
|
})
|
|
}
|
|
|
|
func TestExpiredObjects(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
db := newDB(t, meta.WithEpochState(epochState{currEpoch}))
|
|
defer func() { require.NoError(t, db.Close()) }()
|
|
|
|
checkExpiredObjects(t, db, func(exp, nonExp *objectSDK.Object) {
|
|
cidExp, _ := exp.ContainerID()
|
|
cidNonExp, _ := nonExp.ContainerID()
|
|
|
|
objs, err := metaSelect(db, cidExp, objectSDK.SearchFilters{})
|
|
require.NoError(t, err)
|
|
require.Empty(t, objs) // expired object should not be returned
|
|
|
|
objs, err = metaSelect(db, cidNonExp, objectSDK.SearchFilters{})
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, objs)
|
|
})
|
|
}
|
|
|
|
func benchmarkSelect(b *testing.B, db *meta.DB, cid cidSDK.ID, fs objectSDK.SearchFilters, expected int) {
|
|
var prm meta.SelectPrm
|
|
prm.SetContainerID(cid)
|
|
prm.SetFilters(fs)
|
|
|
|
for range b.N {
|
|
res, err := db.Select(context.Background(), prm)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
if len(res.AddressList()) != expected {
|
|
b.Fatalf("expected %d items, got %d", expected, len(res.AddressList()))
|
|
}
|
|
}
|
|
}
|
|
|
|
func metaSelect(db *meta.DB, cnr cidSDK.ID, fs objectSDK.SearchFilters) ([]oid.Address, error) {
|
|
var prm meta.SelectPrm
|
|
prm.SetFilters(fs)
|
|
prm.SetContainerID(cnr)
|
|
|
|
res, err := db.Select(context.Background(), prm)
|
|
return res.AddressList(), err
|
|
}
|