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) }) }