forked from TrueCloudLab/frostfs-node
449 lines
11 KiB
Go
449 lines
11 KiB
Go
package object
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/nspcc-dev/neofs-api-go/object"
|
|
"github.com/nspcc-dev/neofs-api-go/service"
|
|
"github.com/nspcc-dev/neofs-api-go/session"
|
|
"github.com/nspcc-dev/neofs-node/internal"
|
|
"github.com/nspcc-dev/neofs-node/lib/rand"
|
|
"github.com/nspcc-dev/neofs-node/lib/transformer"
|
|
"github.com/nspcc-dev/neofs-node/lib/transport"
|
|
"github.com/pkg/errors"
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type (
|
|
// Entity for mocking interfaces.
|
|
// Implementation of any interface intercepts arguments via f (if not nil).
|
|
// If err is not nil, it returns as it is. Otherwise, casted to needed type res returns w/o error.
|
|
testDeleteEntity struct {
|
|
// Set of interfaces which testDeleteEntity must implement, but some methods from those does not call.
|
|
session.PrivateTokenStore
|
|
|
|
// Argument interceptor. Used for ascertain of correct parameter passage between components.
|
|
f func(...interface{})
|
|
// Mocked result of any interface.
|
|
res interface{}
|
|
// Mocked error of any interface.
|
|
err error
|
|
}
|
|
)
|
|
|
|
var (
|
|
_ EpochReceiver = (*testDeleteEntity)(nil)
|
|
_ objectStorer = (*testDeleteEntity)(nil)
|
|
_ tombstoneCreator = (*testDeleteEntity)(nil)
|
|
_ objectChildrenLister = (*testDeleteEntity)(nil)
|
|
_ objectRemover = (*testDeleteEntity)(nil)
|
|
_ requestHandler = (*testDeleteEntity)(nil)
|
|
_ deletePreparer = (*testDeleteEntity)(nil)
|
|
_ responsePreparer = (*testDeleteEntity)(nil)
|
|
)
|
|
|
|
func (s *testDeleteEntity) verify(context.Context, *session.Token, *Object) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *testDeleteEntity) Fetch(id session.PrivateTokenKey) (session.PrivateToken, error) {
|
|
if s.f != nil {
|
|
s.f(id)
|
|
}
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.res.(session.PrivateToken), nil
|
|
}
|
|
|
|
func (s *testDeleteEntity) prepareResponse(_ context.Context, req serviceRequest, resp serviceResponse) error {
|
|
if s.f != nil {
|
|
s.f(req, resp)
|
|
}
|
|
return s.err
|
|
}
|
|
|
|
func (s *testDeleteEntity) Epoch() uint64 { return s.res.(uint64) }
|
|
|
|
func (s *testDeleteEntity) putObject(_ context.Context, p transport.PutInfo) (*Address, error) {
|
|
if s.f != nil {
|
|
s.f(p)
|
|
}
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.res.(*Address), nil
|
|
}
|
|
|
|
func (s *testDeleteEntity) createTombstone(_ context.Context, p deleteInfo) *Object {
|
|
if s.f != nil {
|
|
s.f(p)
|
|
}
|
|
return s.res.(*Object)
|
|
}
|
|
|
|
func (s *testDeleteEntity) children(ctx context.Context, addr Address) []ID {
|
|
if s.f != nil {
|
|
s.f(addr, ctx)
|
|
}
|
|
return s.res.([]ID)
|
|
}
|
|
|
|
func (s *testDeleteEntity) delete(ctx context.Context, p deleteInfo) error {
|
|
if s.f != nil {
|
|
s.f(p, ctx)
|
|
}
|
|
return s.err
|
|
}
|
|
|
|
func (s *testDeleteEntity) prepare(_ context.Context, p deleteInfo) ([]deleteInfo, error) {
|
|
if s.f != nil {
|
|
s.f(p)
|
|
}
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.res.([]deleteInfo), nil
|
|
}
|
|
|
|
func (s *testDeleteEntity) handleRequest(_ context.Context, p handleRequestParams) (interface{}, error) {
|
|
if s.f != nil {
|
|
s.f(p)
|
|
}
|
|
return s.res, s.err
|
|
}
|
|
|
|
func Test_objectService_Delete(t *testing.T) {
|
|
ctx := context.TODO()
|
|
req := &object.DeleteRequest{Address: testObjectAddress(t)}
|
|
|
|
t.Run("handler error", func(t *testing.T) {
|
|
rhErr := internal.Error("test error for request handler")
|
|
|
|
s := &objectService{
|
|
statusCalculator: newStatusCalculator(),
|
|
}
|
|
|
|
s.requestHandler = &testDeleteEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct request handler params", func(t *testing.T) {
|
|
p := items[0].(handleRequestParams)
|
|
require.Equal(t, req, p.request)
|
|
require.Equal(t, s, p.executor)
|
|
})
|
|
},
|
|
err: rhErr, // force requestHandler to return rhErr
|
|
}
|
|
|
|
res, err := s.Delete(ctx, req)
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, err, rhErr.Error())
|
|
require.Nil(t, res)
|
|
})
|
|
|
|
t.Run("correct result", func(t *testing.T) {
|
|
s := objectService{
|
|
requestHandler: new(testDeleteEntity),
|
|
respPreparer: &testDeleteEntity{res: new(object.DeleteResponse)},
|
|
|
|
statusCalculator: newStatusCalculator(),
|
|
}
|
|
|
|
res, err := s.Delete(ctx, req)
|
|
require.NoError(t, err)
|
|
require.Equal(t, new(object.DeleteResponse), res)
|
|
})
|
|
}
|
|
|
|
func Test_coreObjRemover_delete(t *testing.T) {
|
|
ctx := context.TODO()
|
|
pToken, err := session.NewPrivateToken(0)
|
|
require.NoError(t, err)
|
|
|
|
addr := testObjectAddress(t)
|
|
|
|
token := new(service.Token)
|
|
token.SetAddress(addr)
|
|
|
|
req := newRawDeleteInfo()
|
|
req.setAddress(addr)
|
|
req.setSessionToken(token)
|
|
|
|
t.Run("nil token", func(t *testing.T) {
|
|
s := new(coreObjRemover)
|
|
|
|
req := newRawDeleteInfo()
|
|
require.Nil(t, req.GetSessionToken())
|
|
|
|
require.EqualError(t, s.delete(ctx, req), errNilToken.Error())
|
|
})
|
|
|
|
t.Run("prepare error", func(t *testing.T) {
|
|
dpErr := internal.Error("test error for delete preparer")
|
|
|
|
dp := &testDeleteEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct delete preparer params", func(t *testing.T) {
|
|
require.Equal(t, req, items[0])
|
|
})
|
|
},
|
|
err: dpErr, // force deletePreparer to return dpErr
|
|
}
|
|
|
|
s := &coreObjRemover{
|
|
delPrep: dp,
|
|
tokenStore: &testDeleteEntity{res: pToken},
|
|
mErr: map[error]struct{}{
|
|
dpErr: {},
|
|
},
|
|
log: zap.L(),
|
|
}
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, s.delete(ctx, req), dpErr.Error())
|
|
|
|
dp.err = internal.Error("some other error")
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, s.delete(ctx, req), errDeletePrepare.Error())
|
|
})
|
|
|
|
t.Run("straight remover error", func(t *testing.T) {
|
|
dInfo := newRawDeleteInfo()
|
|
dInfo.setAddress(addr)
|
|
dInfo.setSessionToken(token)
|
|
|
|
list := []deleteInfo{
|
|
dInfo,
|
|
}
|
|
|
|
srErr := internal.Error("test error for straight remover")
|
|
|
|
s := &coreObjRemover{
|
|
delPrep: &testDeleteEntity{
|
|
res: list, // force deletePreparer to return list
|
|
},
|
|
straightRem: &testDeleteEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct straight remover params", func(t *testing.T) {
|
|
require.Equal(t, list[0], items[0])
|
|
|
|
ctx := items[1].(context.Context)
|
|
|
|
require.Equal(t,
|
|
dInfo.GetSessionToken(),
|
|
ctx.Value(transformer.PublicSessionToken),
|
|
)
|
|
|
|
require.Equal(t,
|
|
pToken,
|
|
ctx.Value(transformer.PrivateSessionToken),
|
|
)
|
|
})
|
|
},
|
|
err: srErr, // force objectRemover to return srErr
|
|
},
|
|
tokenStore: &testDeleteEntity{res: pToken},
|
|
}
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, s.delete(ctx, req), errors.Wrapf(srErr, emRemovePart, 1, 1).Error())
|
|
})
|
|
|
|
t.Run("success", func(t *testing.T) {
|
|
dInfo := newRawDeleteInfo()
|
|
dInfo.setAddress(addr)
|
|
dInfo.setSessionToken(token)
|
|
|
|
list := []deleteInfo{
|
|
dInfo,
|
|
}
|
|
|
|
s := &coreObjRemover{
|
|
delPrep: &testDeleteEntity{
|
|
res: list, // force deletePreparer to return list
|
|
},
|
|
straightRem: &testDeleteEntity{
|
|
err: nil, // force objectRemover to return empty error
|
|
},
|
|
tokenStore: &testDeleteEntity{res: pToken},
|
|
}
|
|
|
|
// ascertain that nil error returns
|
|
require.NoError(t, s.delete(ctx, req))
|
|
})
|
|
}
|
|
|
|
func Test_coreDelPreparer_prepare(t *testing.T) {
|
|
var (
|
|
ctx = context.TODO()
|
|
ownerID = OwnerID{1, 2, 3}
|
|
addr = testObjectAddress(t)
|
|
timeout = 5 * time.Second
|
|
token = new(service.Token)
|
|
childCount = 10
|
|
children = make([]ID, 0, childCount)
|
|
)
|
|
|
|
req := newRawDeleteInfo()
|
|
req.setAddress(addr)
|
|
req.setSessionToken(token)
|
|
req.setOwnerID(ownerID)
|
|
|
|
token.SetID(session.TokenID{1, 2, 3})
|
|
|
|
for i := 0; i < childCount; i++ {
|
|
children = append(children, testObjectAddress(t).ObjectID)
|
|
}
|
|
|
|
s := &coreDelPreparer{
|
|
timeout: timeout,
|
|
childLister: &testDeleteEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct children lister params", func(t *testing.T) {
|
|
require.Equal(t, addr, items[0])
|
|
require.Equal(t,
|
|
token,
|
|
items[1].(context.Context).Value(transformer.PublicSessionToken),
|
|
)
|
|
})
|
|
},
|
|
res: children,
|
|
},
|
|
}
|
|
|
|
res, err := s.prepare(ctx, req)
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, res, childCount+1)
|
|
|
|
for i := range res {
|
|
require.Equal(t, timeout, res[i].GetTimeout())
|
|
require.Equal(t, token, res[i].GetSessionToken())
|
|
require.Equal(t, uint32(service.NonForwardingTTL), res[i].GetTTL())
|
|
|
|
a := res[i].GetAddress()
|
|
require.Equal(t, addr.CID, a.CID)
|
|
if i > 0 {
|
|
require.Equal(t, children[i-1], a.ObjectID)
|
|
} else {
|
|
require.Equal(t, addr.ObjectID, a.ObjectID)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_straightObjRemover_delete(t *testing.T) {
|
|
var (
|
|
ctx = context.TODO()
|
|
addr = testObjectAddress(t)
|
|
ttl = uint32(10)
|
|
timeout = 5 * time.Second
|
|
token = new(service.Token)
|
|
obj = &Object{SystemHeader: SystemHeader{ID: addr.ObjectID, CID: addr.CID}}
|
|
)
|
|
|
|
token.SetID(session.TokenID{1, 2, 3})
|
|
|
|
req := newRawDeleteInfo()
|
|
req.setTTL(ttl)
|
|
req.setTimeout(timeout)
|
|
req.setAddress(testObjectAddress(t))
|
|
req.setSessionToken(token)
|
|
|
|
t.Run("correct result", func(t *testing.T) {
|
|
osErr := internal.Error("test error for object storer")
|
|
|
|
s := &straightObjRemover{
|
|
tombCreator: &testDeleteEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct tombstone creator params", func(t *testing.T) {
|
|
require.Equal(t, req, items[0])
|
|
})
|
|
},
|
|
res: obj,
|
|
},
|
|
objStorer: &testDeleteEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct object storer params", func(t *testing.T) {
|
|
p := items[0].(transport.PutInfo)
|
|
require.Equal(t, timeout, p.GetTimeout())
|
|
require.Equal(t, ttl, p.GetTTL())
|
|
require.Equal(t, obj, p.GetHead())
|
|
require.Equal(t, token, p.GetSessionToken())
|
|
})
|
|
},
|
|
err: osErr, // force objectStorer to return osErr
|
|
},
|
|
}
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, s.delete(ctx, req), osErr.Error())
|
|
})
|
|
}
|
|
|
|
func Test_coreTombCreator_createTombstone(t *testing.T) {
|
|
var (
|
|
ctx = context.TODO()
|
|
addr = testObjectAddress(t)
|
|
ownerID = OwnerID{1, 2, 3}
|
|
)
|
|
|
|
req := newRawDeleteInfo()
|
|
req.setAddress(addr)
|
|
req.setOwnerID(ownerID)
|
|
|
|
t.Run("correct result", func(t *testing.T) {
|
|
s := new(coreTombCreator)
|
|
|
|
res := s.createTombstone(ctx, req)
|
|
require.Equal(t, addr.CID, res.SystemHeader.CID)
|
|
require.Equal(t, addr.ObjectID, res.SystemHeader.ID)
|
|
require.Equal(t, ownerID, res.SystemHeader.OwnerID)
|
|
|
|
_, tsHdr := res.LastHeader(object.HeaderType(object.TombstoneHdr))
|
|
require.NotNil(t, tsHdr)
|
|
require.Equal(t, new(object.Tombstone), tsHdr.Value.(*object.Header_Tombstone).Tombstone)
|
|
})
|
|
}
|
|
|
|
func Test_deleteInfo(t *testing.T) {
|
|
t.Run("address", func(t *testing.T) {
|
|
addr := testObjectAddress(t)
|
|
|
|
req := newRawDeleteInfo()
|
|
req.setAddress(addr)
|
|
|
|
require.Equal(t, addr, req.GetAddress())
|
|
})
|
|
|
|
t.Run("owner ID", func(t *testing.T) {
|
|
ownerID := OwnerID{}
|
|
_, err := rand.Read(ownerID[:])
|
|
require.NoError(t, err)
|
|
|
|
req := newRawDeleteInfo()
|
|
req.setOwnerID(ownerID)
|
|
require.Equal(t, ownerID, req.GetOwnerID())
|
|
|
|
tReq := &transportRequest{serviceRequest: &object.DeleteRequest{OwnerID: ownerID}}
|
|
require.Equal(t, ownerID, tReq.GetOwnerID())
|
|
})
|
|
|
|
t.Run("token", func(t *testing.T) {
|
|
token := new(session.Token)
|
|
_, err := rand.Read(token.ID[:])
|
|
require.NoError(t, err)
|
|
|
|
req := newRawDeleteInfo()
|
|
req.setSessionToken(token)
|
|
require.Equal(t, token, req.GetSessionToken())
|
|
|
|
dReq := new(object.DeleteRequest)
|
|
dReq.SetToken(token)
|
|
tReq := &transportRequest{serviceRequest: dReq}
|
|
require.Equal(t, token, tReq.GetSessionToken())
|
|
})
|
|
}
|