frostfs-node/services/public/object/execution_test.go
alexvanin dadfd90dcd Initial commit
Initial public review release v0.10.0
2020-07-10 17:45:00 +03:00

1207 lines
29 KiB
Go

package object
import (
"context"
"io"
"io/ioutil"
"testing"
"time"
"github.com/multiformats/go-multiaddr"
"github.com/nspcc-dev/neofs-api-go/hash"
"github.com/nspcc-dev/neofs-api-go/object"
"github.com/nspcc-dev/neofs-api-go/service"
"github.com/nspcc-dev/neofs-node/internal"
"github.com/nspcc-dev/neofs-node/lib/core"
"github.com/nspcc-dev/neofs-node/lib/implementations"
"github.com/nspcc-dev/neofs-node/lib/localstore"
"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.
testExecutionEntity struct {
// Set of interfaces which testExecutionEntity must implement, but some methods from those does not call.
transport.MetaInfo
localstore.Localstore
containerTraverser
// 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
}
)
func (s *testExecutionEntity) HandleResult(_ context.Context, n multiaddr.Multiaddr, r interface{}, e error) {
if s.f != nil {
s.f(n, r, e)
}
}
var (
_ transport.ResultHandler = (*testExecutionEntity)(nil)
_ interceptorPreparer = (*testExecutionEntity)(nil)
_ implementations.ContainerTraverseExecutor = (*testExecutionEntity)(nil)
_ WorkerPool = (*testExecutionEntity)(nil)
_ operationExecutor = (*testExecutionEntity)(nil)
_ placementBuilder = (*testExecutionEntity)(nil)
_ implementations.AddressStore = (*testExecutionEntity)(nil)
_ executionParamsComputer = (*testExecutionEntity)(nil)
_ operationFinalizer = (*testExecutionEntity)(nil)
_ EpochReceiver = (*testExecutionEntity)(nil)
_ localstore.Localstore = (*testExecutionEntity)(nil)
_ containerTraverser = (*testExecutionEntity)(nil)
_ responseItemHandler = (*testExecutionEntity)(nil)
_ resultTracker = (*testExecutionEntity)(nil)
_ localObjectStorer = (*testExecutionEntity)(nil)
_ localFullObjectReceiver = (*testExecutionEntity)(nil)
_ localHeadReceiver = (*testExecutionEntity)(nil)
_ localQueryImposer = (*testExecutionEntity)(nil)
_ localRangeReader = (*testExecutionEntity)(nil)
_ localRangeHasher = (*testExecutionEntity)(nil)
)
func (s *testExecutionEntity) prepareInterceptor(p interceptorItems) (func(context.Context, multiaddr.Multiaddr) bool, error) {
if s.f != nil {
s.f(p)
}
if s.err != nil {
return nil, s.err
}
return s.res.(func(context.Context, multiaddr.Multiaddr) bool), nil
}
func (s *testExecutionEntity) Execute(_ context.Context, p implementations.TraverseParams) {
if s.f != nil {
s.f(p)
}
}
func (s *testExecutionEntity) Submit(func()) error {
return s.err
}
func (s *testExecutionEntity) executeOperation(ctx context.Context, r transport.MetaInfo, h responseItemHandler) error {
if s.f != nil {
s.f(r, h)
}
return s.err
}
func (s *testExecutionEntity) buildPlacement(_ context.Context, a Address, n ...multiaddr.Multiaddr) ([]multiaddr.Multiaddr, error) {
if s.f != nil {
s.f(a, n)
}
if s.err != nil {
return nil, s.err
}
return s.res.([]multiaddr.Multiaddr), nil
}
func (s *testExecutionEntity) getHashes(_ context.Context, a Address, r []Range, sa []byte) ([]Hash, error) {
if s.f != nil {
s.f(a, r, sa)
}
if s.err != nil {
return nil, s.err
}
return s.res.([]Hash), nil
}
func (s *testExecutionEntity) getRange(_ context.Context, addr Address, rngs Range) ([]byte, error) {
if s.f != nil {
s.f(addr, rngs)
}
if s.err != nil {
return nil, s.err
}
return s.res.([]byte), nil
}
func (s *testExecutionEntity) imposeQuery(_ context.Context, c CID, d []byte, v int) ([]Address, error) {
if s.f != nil {
s.f(c, d, v)
}
if s.err != nil {
return nil, s.err
}
return s.res.([]Address), nil
}
func (s *testExecutionEntity) headObject(_ context.Context, addr Address) (*Object, error) {
if s.f != nil {
s.f(addr)
}
if s.err != nil {
return nil, s.err
}
return s.res.(*Object), nil
}
func (s *testExecutionEntity) getObject(_ context.Context, addr Address) (*Object, error) {
if s.f != nil {
s.f(addr)
}
if s.err != nil {
return nil, s.err
}
return s.res.(*Object), nil
}
func (s *testExecutionEntity) putObject(_ context.Context, obj *Object) error {
if s.f != nil {
s.f(obj)
}
return s.err
}
func (s *testExecutionEntity) trackResult(_ context.Context, p resultItems) {
if s.f != nil {
s.f(p)
}
}
func (s *testExecutionEntity) handleItem(v interface{}) {
if s.f != nil {
s.f(v)
}
}
func (s *testExecutionEntity) add(n multiaddr.Multiaddr, b bool) {
if s.f != nil {
s.f(n, b)
}
}
func (s *testExecutionEntity) done(n multiaddr.Multiaddr) bool {
if s.f != nil {
s.f(n)
}
return s.res.(bool)
}
func (s *testExecutionEntity) close() {
if s.f != nil {
s.f()
}
}
func (s *testExecutionEntity) PRead(ctx context.Context, addr Address, rng Range) ([]byte, error) {
if s.f != nil {
s.f(addr, rng)
}
if s.err != nil {
return nil, s.err
}
return s.res.([]byte), nil
}
func (s *testExecutionEntity) Put(ctx context.Context, obj *Object) error {
if s.f != nil {
s.f(ctx, obj)
}
return s.err
}
func (s *testExecutionEntity) Get(addr Address) (*Object, error) {
if s.f != nil {
s.f(addr)
}
if s.err != nil {
return nil, s.err
}
return s.res.(*Object), nil
}
func (s *testExecutionEntity) Meta(addr Address) (*Meta, error) {
if s.f != nil {
s.f(addr)
}
if s.err != nil {
return nil, s.err
}
return s.res.(*Meta), nil
}
func (s *testExecutionEntity) Has(addr Address) (bool, error) {
if s.f != nil {
s.f(addr)
}
if s.err != nil {
return false, s.err
}
return s.res.(bool), nil
}
func (s *testExecutionEntity) Epoch() uint64 { return s.res.(uint64) }
func (s *testExecutionEntity) completeExecution(_ context.Context, p operationParams) error {
if s.f != nil {
s.f(p)
}
return s.err
}
func (s *testExecutionEntity) computeParams(p *computableParams, r transport.MetaInfo) {
if s.f != nil {
s.f(p, r)
}
}
func (s *testExecutionEntity) SelfAddr() (multiaddr.Multiaddr, error) {
if s.err != nil {
return nil, s.err
}
return s.res.(multiaddr.Multiaddr), nil
}
func (s *testExecutionEntity) Type() object.RequestType {
return s.res.(object.RequestType)
}
func Test_typeOfRequest(t *testing.T) {
t.Run("correct mapping", func(t *testing.T) {
items := []struct {
exp object.RequestType
v transport.MetaInfo
}{
{exp: object.RequestSearch, v: &transportRequest{serviceRequest: new(object.SearchRequest)}},
{exp: object.RequestSearch, v: newRawSearchInfo()},
{exp: object.RequestPut, v: new(putRequest)},
{exp: object.RequestPut, v: &transportRequest{serviceRequest: new(object.PutRequest)}},
{exp: object.RequestGet, v: newRawGetInfo()},
{exp: object.RequestGet, v: &transportRequest{serviceRequest: new(object.GetRequest)}},
{exp: object.RequestHead, v: newRawHeadInfo()},
{exp: object.RequestHead, v: &transportRequest{serviceRequest: new(object.HeadRequest)}},
{exp: object.RequestRange, v: newRawRangeInfo()},
{exp: object.RequestRange, v: &transportRequest{serviceRequest: new(GetRangeRequest)}},
{exp: object.RequestRangeHash, v: newRawRangeHashInfo()},
{exp: object.RequestRangeHash, v: &transportRequest{serviceRequest: new(object.GetRangeHashRequest)}},
}
for i := range items {
require.Equal(t, items[i].exp, items[i].v.Type())
}
})
}
func Test_coreExecParamsComp_computeParams(t *testing.T) {
s := new(coreExecParamsComp)
addr := testObjectAddress(t)
t.Run("put", func(t *testing.T) {
addr := testObjectAddress(t)
p := new(computableParams)
r := &putRequest{PutRequest: &object.PutRequest{
R: &object.PutRequest_Header{
Header: &object.PutRequest_PutHeader{
Object: &Object{
SystemHeader: SystemHeader{
ID: addr.ObjectID,
CID: addr.CID,
},
},
},
},
}}
s.computeParams(p, r)
t.Run("non-forwarding behavior", func(t *testing.T) {
require.Equal(t, 1, p.stopCount)
})
r.SetTTL(service.NonForwardingTTL)
s.computeParams(p, r)
require.False(t, p.allowPartialResult)
require.False(t, p.tryPreviousNetMap)
require.False(t, p.selfForward)
require.Equal(t, addr, p.addr)
require.Equal(t, 0, p.maxRecycleCount)
require.Equal(t, 0, int(r.CopiesNumber()))
})
t.Run("get", func(t *testing.T) {
p := new(computableParams)
r := newRawGetInfo()
r.setAddress(addr)
s.computeParams(p, r)
require.Equal(t, 1, p.stopCount)
require.False(t, p.allowPartialResult)
require.True(t, p.tryPreviousNetMap)
require.False(t, p.selfForward)
require.Equal(t, addr, p.addr)
require.Equal(t, 0, p.maxRecycleCount)
})
t.Run("head", func(t *testing.T) {
p := new(computableParams)
r := &transportRequest{serviceRequest: &object.HeadRequest{Address: addr}}
s.computeParams(p, r)
require.Equal(t, 1, p.stopCount)
require.False(t, p.allowPartialResult)
require.True(t, p.tryPreviousNetMap)
require.False(t, p.selfForward)
require.Equal(t, addr, p.addr)
require.Equal(t, 0, p.maxRecycleCount)
})
t.Run("search", func(t *testing.T) {
p := new(computableParams)
r := &transportRequest{serviceRequest: &object.SearchRequest{ContainerID: addr.CID}}
s.computeParams(p, r)
require.Equal(t, -1, p.stopCount)
require.True(t, p.allowPartialResult)
require.True(t, p.tryPreviousNetMap)
require.False(t, p.selfForward)
require.Equal(t, addr.CID, p.addr.CID)
require.True(t, p.addr.ObjectID.Empty())
require.Equal(t, 0, p.maxRecycleCount)
})
t.Run("range", func(t *testing.T) {
p := new(computableParams)
r := newRawRangeInfo()
r.setAddress(addr)
s.computeParams(p, r)
require.Equal(t, 1, p.stopCount)
require.False(t, p.allowPartialResult)
require.False(t, p.tryPreviousNetMap)
require.False(t, p.selfForward)
require.Equal(t, addr, p.addr)
require.Equal(t, 0, p.maxRecycleCount)
})
t.Run("range hash", func(t *testing.T) {
p := new(computableParams)
r := newRawRangeHashInfo()
r.setAddress(addr)
s.computeParams(p, r)
require.Equal(t, 1, p.stopCount)
require.False(t, p.allowPartialResult)
require.False(t, p.tryPreviousNetMap)
require.False(t, p.selfForward)
require.Equal(t, addr, p.addr)
require.Equal(t, 0, p.maxRecycleCount)
})
}
func Test_coreOperationExecutor_executeOperation(t *testing.T) {
ctx := context.TODO()
t.Run("correct result", func(t *testing.T) {
t.Run("error", func(t *testing.T) {
p := new(testExecutionEntity)
req := newRawPutInfo()
req.setTTL(1)
finErr := internal.Error("test error for operation finalizer")
s := &coreOperationExecutor{
pre: &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct params computer arguments", func(t *testing.T) {
require.Equal(t, computableParams{}, *items[0].(*computableParams))
require.Equal(t, req, items[1].(transport.MetaInfo))
})
},
},
fin: &testExecutionEntity{
f: func(items ...interface{}) {
par := items[0].(operationParams)
require.Equal(t, req, par.metaInfo)
require.Equal(t, p, par.itemHandler)
},
err: finErr,
},
loc: new(testExecutionEntity),
}
require.EqualError(t,
s.executeOperation(ctx, req, p),
finErr.Error(),
)
})
t.Run("zero ttl", func(t *testing.T) {
p := new(testExecutionEntity)
req := newRawPutInfo()
finErr := internal.Error("test error for operation finalizer")
s := &coreOperationExecutor{
loc: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, req, items[0])
require.Equal(t, p, items[1])
},
err: finErr,
},
}
require.EqualError(t,
s.executeOperation(ctx, req, p),
finErr.Error(),
)
})
})
}
func Test_localStoreExecutor(t *testing.T) {
ctx := context.TODO()
addr := testObjectAddress(t)
t.Run("put", func(t *testing.T) {
epoch := uint64(100)
obj := new(Object)
putErr := internal.Error("test error for put")
ls := &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct local store put params", func(t *testing.T) {
v, ok := items[0].(context.Context).Value(localstore.StoreEpochValue).(uint64)
require.True(t, ok)
require.Equal(t, epoch, v)
require.Equal(t, obj, items[1].(*Object))
})
},
}
s := &localStoreExecutor{
epochRecv: &testExecutionEntity{
res: epoch,
},
localStore: ls,
}
require.NoError(t, s.putObject(ctx, obj))
ls.err = putErr
require.EqualError(t,
s.putObject(ctx, obj),
errPutLocal.Error(),
)
})
t.Run("get", func(t *testing.T) {
t.Run("error", func(t *testing.T) {
getErr := internal.Error("test error for get")
ls := &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct local store get params", func(t *testing.T) {
require.Equal(t, addr, items[0].(Address))
})
},
err: getErr,
}
s := &localStoreExecutor{
localStore: ls,
}
res, err := s.getObject(ctx, addr)
require.EqualError(t, err, getErr.Error())
require.Nil(t, res)
ls.err = errors.Wrap(core.ErrNotFound, "wrap message")
res, err = s.getObject(ctx, addr)
require.EqualError(t, err, errIncompleteOperation.Error())
require.Nil(t, res)
})
t.Run("success", func(t *testing.T) {
obj := new(Object)
s := &localStoreExecutor{
localStore: &testExecutionEntity{
res: obj,
},
}
res, err := s.getObject(ctx, addr)
require.NoError(t, err)
require.Equal(t, obj, res)
})
})
t.Run("head", func(t *testing.T) {
t.Run("error", func(t *testing.T) {
headErr := internal.Error("test error for head")
ls := &testExecutionEntity{
err: headErr,
}
s := &localStoreExecutor{
localStore: ls,
}
res, err := s.headObject(ctx, addr)
require.EqualError(t, err, headErr.Error())
require.Nil(t, res)
ls.err = errors.Wrap(core.ErrNotFound, "wrap message")
res, err = s.headObject(ctx, addr)
require.EqualError(t, err, errIncompleteOperation.Error())
require.Nil(t, res)
})
t.Run("success", func(t *testing.T) {
obj := new(Object)
s := &localStoreExecutor{
localStore: &testExecutionEntity{
res: &Meta{Object: obj},
},
}
res, err := s.headObject(ctx, addr)
require.NoError(t, err)
require.Equal(t, obj, res)
})
})
t.Run("get range", func(t *testing.T) {
t.Run("error", func(t *testing.T) {
rngErr := internal.Error("test error for range reader")
s := &localStoreExecutor{
localStore: &testExecutionEntity{
err: rngErr,
},
}
res, err := s.getRange(ctx, addr, Range{})
require.EqualError(t, err, rngErr.Error())
require.Empty(t, res)
})
t.Run("success", func(t *testing.T) {
rng := Range{Offset: 1, Length: 1}
d := testData(t, 10)
s := &localStoreExecutor{
localStore: &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct local store pread params", func(t *testing.T) {
require.Equal(t, addr, items[0].(Address))
require.Equal(t, rng, items[1].(Range))
})
},
res: d,
},
}
res, err := s.getRange(ctx, addr, rng)
require.NoError(t, err)
require.Equal(t, d, res)
})
})
t.Run("get range hash", func(t *testing.T) {
t.Run("empty range list", func(t *testing.T) {
s := &localStoreExecutor{
localStore: new(testExecutionEntity),
}
res, err := s.getHashes(ctx, addr, nil, nil)
require.NoError(t, err)
require.Empty(t, res)
})
t.Run("error", func(t *testing.T) {
rhErr := internal.Error("test error for range hasher")
s := &localStoreExecutor{
localStore: &testExecutionEntity{
err: rhErr,
},
}
res, err := s.getHashes(ctx, addr, make([]Range, 1), nil)
require.EqualError(t, err, errors.Wrapf(rhErr, emRangeReadFail, 1).Error())
require.Empty(t, res)
})
t.Run("success", func(t *testing.T) {
rngs := []Range{
{Offset: 0, Length: 0},
{Offset: 1, Length: 1},
}
d := testData(t, 64)
salt := testData(t, 20)
callNum := 0
s := &localStoreExecutor{
salitor: hash.SaltXOR,
localStore: &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct local store pread params", func(t *testing.T) {
require.Equal(t, addr, items[0].(Address))
require.Equal(t, rngs[callNum], items[1].(Range))
callNum++
})
},
res: d,
},
}
res, err := s.getHashes(ctx, addr, rngs, salt)
require.NoError(t, err)
require.Len(t, res, len(rngs))
for i := range rngs {
require.Equal(t, hash.Sum(hash.SaltXOR(d, salt)), res[i])
}
})
})
}
func Test_coreHandler_HandleResult(t *testing.T) {
ctx := context.TODO()
node := testNode(t, 1)
t.Run("error", func(t *testing.T) {
handled := false
err := internal.Error("")
s := &coreHandler{
traverser: &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct traverser params", func(t *testing.T) {
require.Equal(t, node, items[0].(multiaddr.Multiaddr))
require.False(t, items[1].(bool))
})
},
},
itemHandler: &testExecutionEntity{
f: func(items ...interface{}) {
handled = true
},
},
resLogger: new(coreResultLogger),
}
s.HandleResult(ctx, node, nil, err)
require.False(t, handled)
})
t.Run("success", func(t *testing.T) {
handled := false
res := testData(t, 10)
s := &coreHandler{
traverser: &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct traverser params", func(t *testing.T) {
require.Equal(t, node, items[0].(multiaddr.Multiaddr))
require.True(t, items[1].(bool))
})
},
},
itemHandler: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, res, items[0])
},
},
resLogger: new(coreResultLogger),
}
s.HandleResult(ctx, node, res, nil)
require.False(t, handled)
})
}
func Test_localOperationExecutor_executeOperation(t *testing.T) {
ctx := context.TODO()
addr := testObjectAddress(t)
obj := &Object{
SystemHeader: SystemHeader{
ID: addr.ObjectID,
CID: addr.CID,
},
}
t.Run("wrong type", func(t *testing.T) {
req := &testExecutionEntity{
res: object.RequestType(-1),
}
require.EqualError(t,
new(localOperationExecutor).executeOperation(ctx, req, nil),
errors.Errorf(pmWrongRequestType, req).Error(),
)
})
t.Run("put", func(t *testing.T) {
req := &putRequest{PutRequest: &object.PutRequest{
R: &object.PutRequest_Header{
Header: &object.PutRequest_PutHeader{
Object: obj,
},
},
}}
t.Run("error", func(t *testing.T) {
putErr := internal.Error("test error for put")
s := &localOperationExecutor{
objStore: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, obj, items[0].(*Object))
},
err: putErr,
},
}
require.EqualError(t,
s.executeOperation(ctx, req, nil),
putErr.Error(),
)
})
t.Run("success", func(t *testing.T) {
h := &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, addr, *items[0].(*Address))
},
}
s := &localOperationExecutor{
objStore: new(testExecutionEntity),
}
require.NoError(t, s.executeOperation(ctx, req, h))
})
})
t.Run("get", func(t *testing.T) {
req := newRawGetInfo()
req.setAddress(addr)
t.Run("error", func(t *testing.T) {
getErr := internal.Error("test error for get")
s := &localOperationExecutor{
objRecv: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, addr, items[0].(Address))
},
err: getErr,
},
}
require.EqualError(t,
s.executeOperation(ctx, req, nil),
getErr.Error(),
)
})
t.Run("success", func(t *testing.T) {
h := &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, obj, items[0].(*Object))
},
}
s := &localOperationExecutor{
objRecv: &testExecutionEntity{
res: obj,
},
}
require.NoError(t, s.executeOperation(ctx, req, h))
})
})
t.Run("head", func(t *testing.T) {
req := &transportRequest{serviceRequest: &object.HeadRequest{
Address: addr,
}}
t.Run("error", func(t *testing.T) {
headErr := internal.Error("test error for head")
s := &localOperationExecutor{
headRecv: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, addr, items[0].(Address))
},
err: headErr,
},
}
require.EqualError(t,
s.executeOperation(ctx, req, nil),
headErr.Error(),
)
})
t.Run("success", func(t *testing.T) {
h := &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, obj, items[0].(*Object))
},
}
s := &localOperationExecutor{
headRecv: &testExecutionEntity{
res: obj,
},
}
require.NoError(t, s.executeOperation(ctx, req, h))
})
})
t.Run("search", func(t *testing.T) {
cid := testObjectAddress(t).CID
testQuery := testData(t, 10)
req := &transportRequest{serviceRequest: &object.SearchRequest{
ContainerID: cid,
Query: testQuery,
}}
t.Run("error", func(t *testing.T) {
searchErr := internal.Error("test error for search")
s := &localOperationExecutor{
queryImp: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, cid, items[0].(CID))
require.Equal(t, testQuery, items[1].([]byte))
require.Equal(t, 1, items[2].(int))
},
err: searchErr,
},
}
require.EqualError(t,
s.executeOperation(ctx, req, nil),
searchErr.Error(),
)
})
t.Run("success", func(t *testing.T) {
addrList := testAddrList(t, 5)
h := &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, addrList, items[0].([]Address))
},
}
s := &localOperationExecutor{
queryImp: &testExecutionEntity{
res: addrList,
},
}
require.NoError(t, s.executeOperation(ctx, req, h))
})
})
t.Run("get range", func(t *testing.T) {
rng := Range{Offset: 1, Length: 1}
req := newRawRangeInfo()
req.setAddress(addr)
req.setRange(rng)
t.Run("error", func(t *testing.T) {
rrErr := internal.Error("test error for range reader")
s := &localOperationExecutor{
rngReader: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, addr, items[0].(Address))
require.Equal(t, rng, items[1].(Range))
},
err: rrErr,
},
}
require.EqualError(t,
s.executeOperation(ctx, req, nil),
rrErr.Error(),
)
})
t.Run("success", func(t *testing.T) {
data := testData(t, 10)
h := &testExecutionEntity{
f: func(items ...interface{}) {
d, err := ioutil.ReadAll(items[0].(io.Reader))
require.NoError(t, err)
require.Equal(t, data, d)
},
}
s := &localOperationExecutor{
rngReader: &testExecutionEntity{
res: data,
},
}
require.NoError(t, s.executeOperation(ctx, req, h))
})
})
t.Run("get range hash", func(t *testing.T) {
rngs := []Range{
{Offset: 0, Length: 0},
{Offset: 1, Length: 1},
}
salt := testData(t, 10)
req := newRawRangeHashInfo()
req.setAddress(addr)
req.setRanges(rngs)
req.setSalt(salt)
t.Run("error", func(t *testing.T) {
rhErr := internal.Error("test error for range hasher")
s := &localOperationExecutor{
rngHasher: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, addr, items[0].(Address))
require.Equal(t, rngs, items[1].([]Range))
require.Equal(t, salt, items[2].([]byte))
},
err: rhErr,
},
}
require.EqualError(t,
s.executeOperation(ctx, req, nil),
rhErr.Error(),
)
})
t.Run("success", func(t *testing.T) {
hashes := []Hash{
hash.Sum(testData(t, 10)),
hash.Sum(testData(t, 10)),
}
h := &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, hashes, items[0].([]Hash))
},
}
s := &localOperationExecutor{
rngHasher: &testExecutionEntity{
res: hashes,
},
}
require.NoError(t, s.executeOperation(ctx, req, h))
})
})
}
func Test_coreOperationFinalizer_completeExecution(t *testing.T) {
ctx := context.TODO()
t.Run("address store failure", func(t *testing.T) {
asErr := internal.Error("test error for address store")
s := &coreOperationFinalizer{
interceptorPreparer: &testExecutionEntity{
err: asErr,
},
}
require.EqualError(t, s.completeExecution(ctx, operationParams{
metaInfo: &transportRequest{serviceRequest: new(object.SearchRequest)},
}), asErr.Error())
})
t.Run("correct execution construction", func(t *testing.T) {
req := &transportRequest{
serviceRequest: &object.SearchRequest{
ContainerID: testObjectAddress(t).CID,
Query: testData(t, 10),
QueryVersion: 1,
},
timeout: 10 * time.Second,
}
req.SetTTL(10)
itemHandler := new(testExecutionEntity)
opParams := operationParams{
computableParams: computableParams{
addr: testObjectAddress(t),
stopCount: 2,
allowPartialResult: false,
tryPreviousNetMap: false,
selfForward: true,
maxRecycleCount: 7,
},
metaInfo: req,
itemHandler: itemHandler,
}
curPl := new(testExecutionEntity)
prevPl := new(testExecutionEntity)
wp := new(testExecutionEntity)
s := &coreOperationFinalizer{
curPlacementBuilder: curPl,
prevPlacementBuilder: prevPl,
interceptorPreparer: &testExecutionEntity{
res: func(context.Context, multiaddr.Multiaddr) bool { return true },
},
workerPool: wp,
traverseExec: &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct traverse executor params", func(t *testing.T) {
p := items[0].(implementations.TraverseParams)
require.True(t, p.ExecutionInterceptor(ctx, nil))
require.Equal(t, req, p.TransportInfo)
require.Equal(t, wp, p.WorkerPool)
tr := p.Traverser.(*coreTraverser)
require.Equal(t, opParams.addr, tr.addr)
require.Equal(t, opParams.tryPreviousNetMap, tr.tryPrevNM)
require.Equal(t, curPl, tr.curPlacementBuilder)
require.Equal(t, prevPl, tr.prevPlacementBuilder)
require.Equal(t, opParams.maxRecycleCount, tr.maxRecycleCount)
require.Equal(t, opParams.stopCount, tr.stopCount)
h := p.Handler.(*coreHandler)
require.Equal(t, tr, h.traverser)
require.Equal(t, itemHandler, h.itemHandler)
})
},
},
log: zap.L(),
}
require.EqualError(t, s.completeExecution(ctx, opParams), errIncompleteOperation.Error())
})
}
func Test_coreInterceptorPreparer_prepareInterceptor(t *testing.T) {
t.Run("address store failure", func(t *testing.T) {
asErr := internal.Error("test error for address store")
s := &coreInterceptorPreparer{
addressStore: &testExecutionEntity{
err: asErr,
},
}
res, err := s.prepareInterceptor(interceptorItems{})
require.EqualError(t, err, asErr.Error())
require.Nil(t, res)
})
t.Run("correct interceptor", func(t *testing.T) {
ctx := context.TODO()
selfAddr := testNode(t, 0)
t.Run("local node", func(t *testing.T) {
req := new(transportRequest)
itemHandler := new(testExecutionEntity)
localErr := internal.Error("test error for local executor")
p := interceptorItems{
selfForward: true,
handler: &testExecutionEntity{
f: func(items ...interface{}) {
t.Run("correct local executor params", func(t *testing.T) {
require.Equal(t, selfAddr, items[0].(multiaddr.Multiaddr))
require.Nil(t, items[1])
require.EqualError(t, items[2].(error), localErr.Error())
})
},
},
metaInfo: req,
itemHandler: itemHandler,
}
s := &coreInterceptorPreparer{
localExec: &testExecutionEntity{
f: func(items ...interface{}) {
require.Equal(t, req, items[0].(transport.MetaInfo))
require.Equal(t, itemHandler, items[1].(responseItemHandler))
},
err: localErr,
},
addressStore: &testExecutionEntity{
res: selfAddr,
},
}
res, err := s.prepareInterceptor(p)
require.NoError(t, err)
require.False(t, res(ctx, selfAddr))
})
t.Run("remote node", func(t *testing.T) {
node := testNode(t, 1)
remoteNode := testNode(t, 2)
p := interceptorItems{}
s := &coreInterceptorPreparer{
addressStore: &testExecutionEntity{
res: remoteNode,
},
}
res, err := s.prepareInterceptor(p)
require.NoError(t, err)
require.False(t, res(ctx, node))
})
})
}
// testAddrList returns count random object addresses.
func testAddrList(t *testing.T, count int) (res []Address) {
for i := 0; i < count; i++ {
res = append(res, testObjectAddress(t))
}
return
}