forked from TrueCloudLab/frostfs-node
958 lines
22 KiB
Go
958 lines
22 KiB
Go
package object
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/nspcc-dev/neofs-api-go/object"
|
|
"github.com/nspcc-dev/neofs-api-go/refs"
|
|
"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/implementations"
|
|
"github.com/nspcc-dev/neofs-node/lib/localstore"
|
|
"github.com/nspcc-dev/neofs-node/lib/test"
|
|
"github.com/nspcc-dev/neofs-node/lib/transformer"
|
|
"github.com/nspcc-dev/neofs-node/lib/transport"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
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.
|
|
testPutEntity struct {
|
|
// Set of interfaces which entity must implement, but some methods from those does not call.
|
|
object.Service_PutServer
|
|
transport.PutInfo
|
|
Filter
|
|
session.PrivateTokenStore
|
|
implementations.SelectiveContainerExecutor
|
|
|
|
// 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 (
|
|
_ object.Service_PutServer = (*testPutEntity)(nil)
|
|
_ requestHandler = (*testPutEntity)(nil)
|
|
_ objectStorer = (*testPutEntity)(nil)
|
|
_ transport.PutInfo = (*testPutEntity)(nil)
|
|
_ Filter = (*testPutEntity)(nil)
|
|
_ operationExecutor = (*testPutEntity)(nil)
|
|
_ session.PrivateTokenStore = (*testPutEntity)(nil)
|
|
_ EpochReceiver = (*testPutEntity)(nil)
|
|
_ transformer.Transformer = (*testPutEntity)(nil)
|
|
)
|
|
|
|
func (s *testPutEntity) Verify(_ context.Context, obj *Object) error {
|
|
if s.f != nil {
|
|
s.f(obj)
|
|
}
|
|
return s.err
|
|
}
|
|
|
|
func (s *testPutEntity) Transform(_ context.Context, u transformer.ProcUnit, h ...transformer.ProcUnitHandler) error {
|
|
if s.f != nil {
|
|
s.f(u, h)
|
|
}
|
|
return s.err
|
|
}
|
|
|
|
func (s *testPutEntity) verify(_ context.Context, token *session.Token, obj *Object) error {
|
|
if s.f != nil {
|
|
s.f(token, obj)
|
|
}
|
|
return s.err
|
|
}
|
|
|
|
func (s *testPutEntity) Epoch() uint64 { return s.res.(uint64) }
|
|
|
|
func (s *testPutEntity) Direct(ctx context.Context, objs ...Object) ([]Object, error) {
|
|
if s.f != nil {
|
|
s.f(ctx, objs)
|
|
}
|
|
return s.res.([]Object), s.err
|
|
}
|
|
|
|
func (s *testPutEntity) 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 *testPutEntity) executeOperation(_ context.Context, m transport.MetaInfo, h responseItemHandler) error {
|
|
if s.f != nil {
|
|
s.f(m, h)
|
|
}
|
|
return s.err
|
|
}
|
|
|
|
func (s *testPutEntity) Pass(ctx context.Context, m *Meta) *localstore.FilterResult {
|
|
if s.f != nil {
|
|
s.f(ctx, m)
|
|
}
|
|
items := s.res.([]interface{})
|
|
return items[0].(*localstore.FilterResult)
|
|
}
|
|
|
|
func (s *testPutEntity) GetTTL() uint32 { return s.res.(uint32) }
|
|
|
|
func (s *testPutEntity) GetToken() *session.Token { return s.res.(*session.Token) }
|
|
|
|
func (s *testPutEntity) GetHead() *Object { return s.res.(*Object) }
|
|
|
|
func (s *testPutEntity) putObject(ctx context.Context, p transport.PutInfo) (*Address, error) {
|
|
if s.f != nil {
|
|
s.f(p, ctx)
|
|
}
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
}
|
|
return s.res.(*Address), nil
|
|
}
|
|
|
|
func (s *testPutEntity) handleRequest(_ context.Context, p handleRequestParams) (interface{}, error) {
|
|
if s.f != nil {
|
|
s.f(p)
|
|
}
|
|
return s.res, s.err
|
|
}
|
|
|
|
func (s *testPutEntity) Recv() (*object.PutRequest, error) {
|
|
if s.f != nil {
|
|
s.f()
|
|
}
|
|
if s.err != nil {
|
|
return nil, s.err
|
|
} else if s.res == nil {
|
|
return nil, nil
|
|
}
|
|
return s.res.(*object.PutRequest), nil
|
|
}
|
|
|
|
func (s *testPutEntity) Context() context.Context { return context.TODO() }
|
|
|
|
func Test_objectService_Put(t *testing.T) {
|
|
|
|
t.Run("stream error", func(t *testing.T) {
|
|
// create custom error for test
|
|
psErr := internal.Error("test error for put stream server")
|
|
|
|
s := &testPutEntity{
|
|
err: psErr, // force server to return psErr
|
|
}
|
|
|
|
srv := &objectService{
|
|
statusCalculator: newStatusCalculator(),
|
|
}
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t,
|
|
srv.Put(s),
|
|
psErr.Error(),
|
|
)
|
|
})
|
|
|
|
t.Run("request handling", func(t *testing.T) {
|
|
// create custom request for test
|
|
req := &object.PutRequest{R: &object.PutRequest_Header{
|
|
Header: &object.PutRequest_PutHeader{
|
|
Object: new(Object),
|
|
},
|
|
}}
|
|
|
|
// create custom error for test
|
|
hErr := internal.Error("test error for request handler")
|
|
|
|
srv := &testPutEntity{
|
|
res: req, // force server to return req
|
|
}
|
|
|
|
s := &objectService{
|
|
statusCalculator: newStatusCalculator(),
|
|
}
|
|
|
|
s.requestHandler = &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct request handler params", func(t *testing.T) {
|
|
p := items[0].(handleRequestParams)
|
|
require.Equal(t, s, p.executor)
|
|
require.Equal(t, &putRequest{
|
|
PutRequest: req,
|
|
srv: srv,
|
|
}, p.request)
|
|
})
|
|
},
|
|
err: hErr, // force requestHandler to return hErr
|
|
}
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t,
|
|
s.Put(srv),
|
|
hErr.Error(),
|
|
)
|
|
})
|
|
}
|
|
|
|
func Test_straightObjectStorer_putObject(t *testing.T) {
|
|
ctx := context.TODO()
|
|
|
|
t.Run("executor error", func(t *testing.T) {
|
|
// create custom error for test
|
|
exErr := internal.Error("test error for operation executor")
|
|
|
|
// create custom meta info for test
|
|
info := new(testPutEntity)
|
|
|
|
s := &straightObjectStorer{
|
|
executor: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct operation executor params", func(t *testing.T) {
|
|
require.Equal(t, info, items[0])
|
|
acc := items[1].(*coreAddrAccum)
|
|
require.NotNil(t, acc.Once)
|
|
})
|
|
},
|
|
err: exErr,
|
|
},
|
|
}
|
|
|
|
_, err := s.putObject(ctx, info)
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, err, exErr.Error())
|
|
})
|
|
|
|
t.Run("correct result", func(t *testing.T) {
|
|
addr := testObjectAddress(t)
|
|
|
|
s := &straightObjectStorer{
|
|
executor: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
// add address to accumulator
|
|
items[1].(addressAccumulator).handleItem(&addr)
|
|
},
|
|
},
|
|
}
|
|
|
|
res, err := s.putObject(ctx, new(testPutEntity))
|
|
require.NoError(t, err)
|
|
|
|
// ascertain that result returns as expected
|
|
require.Equal(t, &addr, res)
|
|
})
|
|
}
|
|
|
|
func Test_recvPutHeaderMsg(t *testing.T) {
|
|
t.Run("server error", func(t *testing.T) {
|
|
// create custom error for test
|
|
srvErr := internal.Error("test error for put server")
|
|
|
|
srv := &testPutEntity{
|
|
err: srvErr, // force put server to return srvErr
|
|
}
|
|
|
|
res, err := recvPutHeaderMsg(srv)
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, err, srvErr.Error())
|
|
require.Nil(t, res)
|
|
})
|
|
|
|
t.Run("empty message", func(t *testing.T) {
|
|
srv := &testPutEntity{
|
|
res: nil, // force put server to return nil, nil
|
|
}
|
|
|
|
res, err := recvPutHeaderMsg(srv)
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, err, errHeaderExpected.Error())
|
|
require.Nil(t, res)
|
|
})
|
|
|
|
t.Run("empty put header in message", func(t *testing.T) {
|
|
srv := &testPutEntity{
|
|
res: new(object.PutRequest), // force put server to return message w/o put header
|
|
}
|
|
|
|
res, err := recvPutHeaderMsg(srv)
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, err, object.ErrHeaderExpected.Error())
|
|
require.Nil(t, res)
|
|
})
|
|
|
|
t.Run("empty object in put header", func(t *testing.T) {
|
|
srv := &testPutEntity{
|
|
res: object.MakePutRequestHeader(nil), // force put server to return message w/ nil object
|
|
}
|
|
|
|
res, err := recvPutHeaderMsg(srv)
|
|
|
|
// ascertain that error returns as expected
|
|
require.EqualError(t, err, errObjectExpected.Error())
|
|
require.Nil(t, res)
|
|
})
|
|
}
|
|
|
|
func Test_putRequest(t *testing.T) {
|
|
t.Run("timeout", func(t *testing.T) {
|
|
timeout := 3 * time.Second
|
|
|
|
req := &putRequest{
|
|
timeout: timeout,
|
|
}
|
|
|
|
// ascertain that timeout returns as expected
|
|
require.Equal(t, timeout, req.GetTimeout())
|
|
})
|
|
|
|
t.Run("head", func(t *testing.T) {
|
|
// create custom object for test
|
|
obj := new(Object)
|
|
|
|
req := &putRequest{
|
|
PutRequest: object.MakePutRequestHeader(obj), // wrap object to test message
|
|
}
|
|
|
|
// ascertain that head returns as expected
|
|
require.Equal(t, obj, req.GetHead())
|
|
})
|
|
|
|
t.Run("payload", func(t *testing.T) {
|
|
req := &putRequest{
|
|
srv: new(testPutEntity),
|
|
}
|
|
|
|
require.Equal(t, &putStreamReader{srv: req.srv}, req.Payload())
|
|
})
|
|
|
|
t.Run("copies number", func(t *testing.T) {
|
|
cn := uint32(5)
|
|
|
|
req := &putRequest{
|
|
PutRequest: &object.PutRequest{
|
|
R: &object.PutRequest_Header{
|
|
Header: &object.PutRequest_PutHeader{
|
|
CopiesNumber: cn,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
require.Equal(t, cn, req.CopiesNumber())
|
|
})
|
|
}
|
|
|
|
func Test_coreAddrAccum(t *testing.T) {
|
|
t.Run("new", func(t *testing.T) {
|
|
s := newAddressAccumulator()
|
|
// ascertain that type is correct and Once entity initialize
|
|
require.NotNil(t, s.(*coreAddrAccum).Once)
|
|
})
|
|
|
|
t.Run("address", func(t *testing.T) {
|
|
addr := testObjectAddress(t)
|
|
|
|
s := &coreAddrAccum{addr: &addr}
|
|
|
|
// ascertain that address returns as expected
|
|
require.Equal(t, &addr, s.address())
|
|
})
|
|
|
|
t.Run("handle", func(t *testing.T) {
|
|
addr := testObjectAddress(t)
|
|
|
|
s := newAddressAccumulator()
|
|
|
|
s.handleItem(&addr)
|
|
|
|
// ascertain that address saved
|
|
require.Equal(t, &addr, s.address())
|
|
|
|
// create another address for test
|
|
addr2 := testObjectAddress(t)
|
|
|
|
s.handleItem(&addr2)
|
|
|
|
// ascertain that second address is ignored
|
|
require.Equal(t, &addr, s.address())
|
|
})
|
|
}
|
|
|
|
func Test_rawPutInfo(t *testing.T) {
|
|
t.Run("TTL", func(t *testing.T) {
|
|
ttl := uint32(3)
|
|
|
|
s := newRawPutInfo()
|
|
s.setTTL(ttl)
|
|
|
|
require.Equal(t, ttl, s.GetTTL())
|
|
})
|
|
|
|
t.Run("head", func(t *testing.T) {
|
|
obj := new(Object)
|
|
|
|
s := newRawPutInfo()
|
|
s.setHead(obj)
|
|
|
|
require.Equal(t, obj, s.GetHead())
|
|
})
|
|
|
|
t.Run("payload", func(t *testing.T) {
|
|
// ascertain that nil chunk returns as expected
|
|
r := bytes.NewBuffer(nil)
|
|
|
|
req := newRawPutInfo()
|
|
req.setPayload(r)
|
|
|
|
require.Equal(t, r, req.Payload())
|
|
})
|
|
|
|
t.Run("token", func(t *testing.T) {
|
|
// ascertain that nil token returns as expected
|
|
require.Nil(t, newRawPutInfo().GetSessionToken())
|
|
})
|
|
|
|
t.Run("copies number", func(t *testing.T) {
|
|
cn := uint32(100)
|
|
|
|
s := newRawPutInfo()
|
|
s.setCopiesNumber(cn)
|
|
|
|
require.Equal(t, cn, s.CopiesNumber())
|
|
})
|
|
}
|
|
|
|
func Test_contextWithValues(t *testing.T) {
|
|
k1, k2 := "key 1", "key2"
|
|
v1, v2 := "value 1", "value 2"
|
|
|
|
ctx := contextWithValues(context.TODO(), k1, v1, k2, v2)
|
|
|
|
// ascertain that all values added
|
|
require.Equal(t, v1, ctx.Value(k1))
|
|
require.Equal(t, v2, ctx.Value(k2))
|
|
}
|
|
|
|
func Test_bifurcatingObjectStorer(t *testing.T) {
|
|
ctx := context.TODO()
|
|
|
|
// create custom error for test
|
|
sErr := internal.Error("test error for object storer")
|
|
|
|
t.Run("w/ token", func(t *testing.T) {
|
|
// create custom request w/ token
|
|
sk := test.DecodeKey(0)
|
|
|
|
owner, err := refs.NewOwnerID(&sk.PublicKey)
|
|
require.NoError(t, err)
|
|
|
|
token := new(service.Token)
|
|
token.SetOwnerID(owner)
|
|
|
|
req := &putRequest{
|
|
PutRequest: object.MakePutRequestHeader(new(Object)),
|
|
}
|
|
req.SetToken(token)
|
|
require.NoError(t, requestSignFunc(sk, req))
|
|
|
|
s := &bifurcatingObjectStorer{
|
|
tokenStorer: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct token storer params", func(t *testing.T) {
|
|
require.Equal(t, req, items[0])
|
|
})
|
|
},
|
|
err: sErr, // force token storer to return sErr
|
|
},
|
|
}
|
|
|
|
_, err = s.putObject(ctx, req)
|
|
require.EqualError(t, err, sErr.Error())
|
|
})
|
|
|
|
t.Run("w/o token", func(t *testing.T) {
|
|
// create custom request w/o token
|
|
req := newRawPutInfo()
|
|
require.Nil(t, req.GetSessionToken())
|
|
|
|
s := &bifurcatingObjectStorer{
|
|
straightStorer: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct token storer params", func(t *testing.T) {
|
|
require.Equal(t, req, items[0])
|
|
})
|
|
},
|
|
err: sErr, // force token storer to return sErr
|
|
},
|
|
}
|
|
|
|
_, err := s.putObject(ctx, req)
|
|
require.EqualError(t, err, sErr.Error())
|
|
})
|
|
}
|
|
|
|
func TestWithTokenFromOwner(t *testing.T) {
|
|
// nil request
|
|
require.False(t, withTokenFromOwner(nil))
|
|
|
|
// create test request
|
|
req := &putRequest{
|
|
PutRequest: new(object.PutRequest),
|
|
}
|
|
|
|
// w/o session token
|
|
require.Nil(t, req.GetSessionToken())
|
|
require.False(t, withTokenFromOwner(req))
|
|
|
|
// create test session token and add it to request
|
|
token := new(service.Token)
|
|
req.SetToken(token)
|
|
|
|
// w/o signatures
|
|
require.False(t, withTokenFromOwner(req))
|
|
|
|
// create test public key
|
|
pk := &test.DecodeKey(0).PublicKey
|
|
|
|
// add key-signature pair
|
|
req.AddSignKey(nil, pk)
|
|
|
|
// wrong token owner
|
|
require.False(t, withTokenFromOwner(req))
|
|
|
|
// set correct token owner
|
|
owner, err := refs.NewOwnerID(pk)
|
|
require.NoError(t, err)
|
|
|
|
token.SetOwnerID(owner)
|
|
|
|
require.True(t, withTokenFromOwner(req))
|
|
}
|
|
|
|
func Test_tokenObjectStorer(t *testing.T) {
|
|
ctx := context.TODO()
|
|
|
|
token := new(service.Token)
|
|
token.SetID(session.TokenID{1, 2, 3})
|
|
token.SetSignature(testData(t, 10))
|
|
|
|
// create custom request w/ token and object for test
|
|
req := newRawPutInfo()
|
|
req.setSessionToken(token)
|
|
req.setHead(&Object{
|
|
Payload: testData(t, 10),
|
|
})
|
|
|
|
t.Run("token store failure", func(t *testing.T) {
|
|
s := &tokenObjectStorer{
|
|
tokenStore: &testPutEntity{
|
|
err: internal.Error(""), // force token store to return a non-nil error
|
|
},
|
|
}
|
|
|
|
_, err := s.putObject(ctx, req)
|
|
require.EqualError(t, err, errTokenRetrieval.Error())
|
|
})
|
|
|
|
t.Run("correct result", func(t *testing.T) {
|
|
addr := testObjectAddress(t)
|
|
|
|
pToken, err := session.NewPrivateToken(0)
|
|
require.NoError(t, err)
|
|
|
|
s := &tokenObjectStorer{
|
|
tokenStore: &testPutEntity{
|
|
res: pToken,
|
|
},
|
|
objStorer: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct object storer params", func(t *testing.T) {
|
|
require.Equal(t, req, items[0])
|
|
ctx := items[1].(context.Context)
|
|
require.Equal(t, pToken, ctx.Value(transformer.PrivateSessionToken))
|
|
require.Equal(t, token, ctx.Value(transformer.PublicSessionToken))
|
|
})
|
|
},
|
|
res: &addr,
|
|
},
|
|
}
|
|
|
|
res, err := s.putObject(ctx, req)
|
|
require.NoError(t, err)
|
|
require.Equal(t, addr, *res)
|
|
})
|
|
}
|
|
|
|
func Test_filteringObjectStorer(t *testing.T) {
|
|
ctx := context.TODO()
|
|
|
|
t.Run("filter failure", func(t *testing.T) {
|
|
var (
|
|
ttl = uint32(5)
|
|
obj = &Object{Payload: testData(t, 10)}
|
|
)
|
|
|
|
req := newRawPutInfo()
|
|
req.setHead(obj)
|
|
req.setTTL(ttl)
|
|
|
|
s := &filteringObjectStorer{
|
|
filter: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct filter params", func(t *testing.T) {
|
|
require.Equal(t, &Meta{Object: obj}, items[1])
|
|
ctx := items[0].(context.Context)
|
|
require.Equal(t, ttl, ctx.Value(ttlValue))
|
|
})
|
|
},
|
|
res: []interface{}{localstore.ResultFail()},
|
|
},
|
|
}
|
|
|
|
_, err := s.putObject(ctx, req)
|
|
require.EqualError(t, err, errObjectFilter.Error())
|
|
})
|
|
|
|
t.Run("correct result", func(t *testing.T) {
|
|
req := newRawPutInfo()
|
|
req.setHead(&Object{
|
|
Payload: testData(t, 10),
|
|
})
|
|
|
|
addr := testObjectAddress(t)
|
|
|
|
s := &filteringObjectStorer{
|
|
filter: &testPutEntity{
|
|
res: []interface{}{localstore.ResultPass()},
|
|
},
|
|
objStorer: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct object storer params", func(t *testing.T) {
|
|
require.Equal(t, req, items[0])
|
|
})
|
|
},
|
|
res: &addr,
|
|
},
|
|
}
|
|
|
|
res, err := s.putObject(ctx, req)
|
|
require.NoError(t, err)
|
|
require.Equal(t, &addr, res)
|
|
})
|
|
}
|
|
|
|
func Test_receivingObjectStorer(t *testing.T) {
|
|
ctx := context.TODO()
|
|
|
|
t.Run("cut payload", func(t *testing.T) {
|
|
payload := testData(t, 10)
|
|
|
|
req := newRawPutInfo()
|
|
req.setHead(&Object{
|
|
SystemHeader: SystemHeader{
|
|
PayloadLength: uint64(len(payload)) + 1,
|
|
},
|
|
})
|
|
req.setPayload(bytes.NewBuffer(payload))
|
|
|
|
_, err := new(receivingObjectStorer).putObject(ctx, req)
|
|
require.EqualError(t, err, transformer.ErrPayloadEOF.Error())
|
|
})
|
|
|
|
t.Run("payload verification failure", func(t *testing.T) {
|
|
vErr := internal.Error("payload verification error for test")
|
|
|
|
req := newRawPutInfo()
|
|
req.setHead(&Object{
|
|
Payload: testData(t, 10),
|
|
})
|
|
|
|
s := &receivingObjectStorer{
|
|
vPayload: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
require.Equal(t, req.obj, items[0])
|
|
},
|
|
err: vErr,
|
|
},
|
|
}
|
|
|
|
_, err := s.putObject(ctx, req)
|
|
|
|
require.EqualError(t, err, errPayloadChecksum.Error())
|
|
})
|
|
|
|
t.Run("correct result", func(t *testing.T) {
|
|
var (
|
|
cn = uint32(10)
|
|
ttl = uint32(5)
|
|
timeout = 3 * time.Second
|
|
payload = testData(t, 10)
|
|
addr = testObjectAddress(t)
|
|
)
|
|
|
|
obj := &Object{
|
|
SystemHeader: SystemHeader{
|
|
PayloadLength: uint64(len(payload)),
|
|
ID: addr.ObjectID,
|
|
CID: addr.CID,
|
|
},
|
|
}
|
|
|
|
req := newRawPutInfo()
|
|
req.setHead(obj)
|
|
req.setPayload(bytes.NewBuffer(payload))
|
|
req.setTimeout(timeout)
|
|
req.setTTL(ttl)
|
|
req.setCopiesNumber(cn)
|
|
req.setSessionToken(new(service.Token))
|
|
|
|
s := &receivingObjectStorer{
|
|
straightStorer: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct straight storer params", func(t *testing.T) {
|
|
exp := newRawPutInfo()
|
|
exp.setHead(obj)
|
|
exp.setTimeout(timeout)
|
|
exp.setTTL(ttl)
|
|
exp.setCopiesNumber(cn)
|
|
exp.setSessionToken(req.GetSessionToken())
|
|
|
|
require.Equal(t, exp, items[0])
|
|
})
|
|
},
|
|
res: &addr,
|
|
},
|
|
vPayload: new(testPutEntity),
|
|
}
|
|
|
|
res, err := s.putObject(ctx, req)
|
|
require.NoError(t, err)
|
|
require.Equal(t, &addr, res)
|
|
})
|
|
}
|
|
|
|
func Test_transformingObjectStorer(t *testing.T) {
|
|
ctx := context.TODO()
|
|
|
|
t.Run("correct behavior", func(t *testing.T) {
|
|
var (
|
|
tErr = internal.Error("test error for transformer")
|
|
addr = testObjectAddress(t)
|
|
obj = &Object{
|
|
SystemHeader: SystemHeader{
|
|
ID: addr.ObjectID,
|
|
CID: addr.CID,
|
|
},
|
|
Payload: testData(t, 10),
|
|
}
|
|
)
|
|
|
|
req := newRawPutInfo()
|
|
req.setHead(obj)
|
|
req.setPayload(bytes.NewBuffer(obj.Payload))
|
|
req.setTimeout(3 * time.Second)
|
|
req.setTTL(5)
|
|
req.setCopiesNumber(100)
|
|
req.setSessionToken(new(service.Token))
|
|
|
|
tr := &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct transformer params", func(t *testing.T) {
|
|
require.Equal(t, transformer.ProcUnit{
|
|
Head: req.obj,
|
|
Payload: req.r,
|
|
}, items[0])
|
|
fns := items[1].([]transformer.ProcUnitHandler)
|
|
require.Len(t, fns, 1)
|
|
_ = fns[0](ctx, transformer.ProcUnit{
|
|
Head: req.obj,
|
|
Payload: req.r,
|
|
})
|
|
})
|
|
},
|
|
}
|
|
|
|
s := &transformingObjectStorer{
|
|
transformer: tr,
|
|
objStorer: &testPutEntity{
|
|
f: func(items ...interface{}) {
|
|
t.Run("correct object storer params", func(t *testing.T) {
|
|
exp := newRawPutInfo()
|
|
exp.setHead(req.GetHead())
|
|
exp.setPayload(req.Payload())
|
|
exp.setTimeout(req.GetTimeout())
|
|
exp.setTTL(req.GetTTL())
|
|
exp.setCopiesNumber(req.CopiesNumber())
|
|
exp.setSessionToken(req.GetSessionToken())
|
|
|
|
require.Equal(t, exp, items[0])
|
|
})
|
|
},
|
|
err: internal.Error(""),
|
|
},
|
|
mErr: map[error]struct{}{
|
|
tErr: {},
|
|
},
|
|
}
|
|
|
|
res, err := s.putObject(ctx, req)
|
|
require.NoError(t, err)
|
|
require.Equal(t, &addr, res)
|
|
|
|
tr.err = tErr
|
|
|
|
_, err = s.putObject(ctx, req)
|
|
require.EqualError(t, err, tErr.Error())
|
|
|
|
tr.err = internal.Error("some other error")
|
|
|
|
_, err = s.putObject(ctx, req)
|
|
require.EqualError(t, err, errTransformer.Error())
|
|
|
|
e := &transformerHandlerErr{
|
|
error: internal.Error("transformer handler error"),
|
|
}
|
|
|
|
tr.err = e
|
|
|
|
_, err = s.putObject(ctx, req)
|
|
require.EqualError(t, err, e.error.Error())
|
|
})
|
|
}
|
|
|
|
func Test_putStreamReader(t *testing.T) {
|
|
t.Run("empty server", func(t *testing.T) {
|
|
s := new(putStreamReader)
|
|
n, err := s.Read(make([]byte, 1))
|
|
require.EqualError(t, err, io.EOF.Error())
|
|
require.Zero(t, n)
|
|
})
|
|
|
|
t.Run("fail presence", func(t *testing.T) {
|
|
initTail := testData(t, 10)
|
|
|
|
s := putStreamReader{
|
|
tail: initTail,
|
|
srv: new(testPutEntity),
|
|
}
|
|
|
|
buf := make([]byte, len(s.tail)/2)
|
|
|
|
n, err := s.Read(buf)
|
|
require.NoError(t, err)
|
|
require.Equal(t, len(buf), n)
|
|
require.Equal(t, buf, initTail[:n])
|
|
require.Equal(t, initTail[n:], s.tail)
|
|
})
|
|
|
|
t.Run("receive message failure", func(t *testing.T) {
|
|
t.Run("stream problem", func(t *testing.T) {
|
|
srvErr := internal.Error("test error for stream server")
|
|
|
|
s := &putStreamReader{
|
|
srv: &testPutEntity{
|
|
err: srvErr,
|
|
},
|
|
}
|
|
|
|
n, err := s.Read(make([]byte, 1))
|
|
require.EqualError(t, err, srvErr.Error())
|
|
require.Zero(t, n)
|
|
})
|
|
|
|
t.Run("incorrect chunk", func(t *testing.T) {
|
|
t.Run("empty data", func(t *testing.T) {
|
|
s := &putStreamReader{
|
|
srv: &testPutEntity{
|
|
res: object.MakePutRequestChunk(make([]byte, 0)),
|
|
},
|
|
}
|
|
|
|
n, err := s.Read(make([]byte, 1))
|
|
require.EqualError(t, err, errChunkExpected.Error())
|
|
require.Zero(t, n)
|
|
})
|
|
|
|
t.Run("wrong message type", func(t *testing.T) {
|
|
s := &putStreamReader{
|
|
srv: &testPutEntity{
|
|
res: object.MakePutRequestHeader(new(Object)),
|
|
},
|
|
}
|
|
|
|
n, err := s.Read(make([]byte, 1))
|
|
require.EqualError(t, err, errChunkExpected.Error())
|
|
require.Zero(t, n)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.Run("correct read", func(t *testing.T) {
|
|
chunk := testData(t, 10)
|
|
buf := make([]byte, len(chunk)/2)
|
|
|
|
s := &putStreamReader{
|
|
srv: &testPutEntity{
|
|
res: object.MakePutRequestChunk(chunk),
|
|
},
|
|
}
|
|
|
|
n, err := s.Read(buf)
|
|
require.NoError(t, err)
|
|
require.Equal(t, chunk[:n], buf)
|
|
require.Equal(t, chunk[n:], s.tail)
|
|
})
|
|
|
|
t.Run("ful read", func(t *testing.T) {
|
|
var (
|
|
callNum = 0
|
|
chunk1, chunk2 = testData(t, 100), testData(t, 88)
|
|
)
|
|
|
|
srv := new(testPutEntity)
|
|
srv.f = func(items ...interface{}) {
|
|
if callNum == 0 {
|
|
srv.res = object.MakePutRequestChunk(chunk1)
|
|
} else if callNum == 1 {
|
|
srv.res = object.MakePutRequestChunk(chunk2)
|
|
} else {
|
|
srv.res, srv.err = 0, io.EOF
|
|
}
|
|
callNum++
|
|
}
|
|
|
|
s := &putStreamReader{
|
|
srv: srv,
|
|
}
|
|
|
|
var (
|
|
n int
|
|
err error
|
|
res = make([]byte, 0)
|
|
buf = make([]byte, 10)
|
|
)
|
|
|
|
for err != io.EOF {
|
|
n, err = s.Read(buf)
|
|
res = append(res, buf[:n]...)
|
|
}
|
|
|
|
require.Equal(t, append(chunk1, chunk2...), res)
|
|
})
|
|
}
|