package transformer import ( "bytes" "context" "crypto/sha256" "io" "math/rand" "sort" "testing" "github.com/nspcc-dev/neofs-api-go/hash" "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-api-go/storagegroup" crypto "github.com/nspcc-dev/neofs-crypto" "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/objutil" "github.com/nspcc-dev/neofs-node/lib/test" "github.com/pkg/errors" "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. // 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 ( _ io.Writer = (*testPutEntity)(nil) _ EpochReceiver = (*testPutEntity)(nil) _ Transformer = (*testPutEntity)(nil) _ storagegroup.InfoReceiver = (*testPutEntity)(nil) _ objutil.Verifier = (*testPutEntity)(nil) ) func (s *testPutEntity) Verify(_ context.Context, obj *Object) error { if s.f != nil { s.f(obj) } return s.err } func (s *testPutEntity) Write(p []byte) (int, error) { if s.f != nil { s.f(p) } return 0, s.err } func (s *testPutEntity) Transform(_ context.Context, u ProcUnit, h ...ProcUnitHandler) error { if s.f != nil { s.f(u, h) } return s.err } func (s *testPutEntity) GetSGInfo(_ context.Context, cid CID, group []ObjectID) (*StorageGroup, error) { if s.f != nil { s.f(cid, group) } if s.err != nil { return nil, s.err } return s.res.(*StorageGroup), nil } func (s *testPutEntity) Epoch() uint64 { return s.res.(uint64) } func TestNewTransformer(t *testing.T) { validParams := Params{ SGInfoReceiver: new(testPutEntity), EpochReceiver: new(testPutEntity), SizeLimit: 1, Verifier: new(testPutEntity), } t.Run("valid params", func(t *testing.T) { res, err := NewTransformer(validParams) require.NoError(t, err) require.NotNil(t, res) }) t.Run("non-positive size", func(t *testing.T) { p := validParams p.SizeLimit = 0 _, err := NewTransformer(p) require.EqualError(t, err, errors.Wrap(errInvalidSizeLimit, transformerInstanceFailMsg).Error()) }) t.Run("empty SG info receiver", func(t *testing.T) { p := validParams p.SGInfoReceiver = nil _, err := NewTransformer(p) require.EqualError(t, err, errors.Wrap(errEmptySGInfoRecv, transformerInstanceFailMsg).Error()) }) t.Run("empty epoch receiver", func(t *testing.T) { p := validParams p.EpochReceiver = nil _, err := NewTransformer(p) require.EqualError(t, err, errors.Wrap(errEmptyEpochReceiver, transformerInstanceFailMsg).Error()) }) t.Run("empty object verifier", func(t *testing.T) { p := validParams p.Verifier = nil _, err := NewTransformer(p) require.EqualError(t, err, errors.Wrap(errEmptyVerifier, transformerInstanceFailMsg).Error()) }) } func Test_transformer(t *testing.T) { ctx := context.TODO() u := ProcUnit{ Head: &Object{ Payload: testData(t, 10), }, Payload: new(emptyReader), } handlers := []ProcUnitHandler{func(context.Context, ProcUnit) error { return nil }} t.Run("preliminary transformation failure", func(t *testing.T) { // create custom error for test pErr := internal.Error("test error for prelim transformer") s := &transformer{ tPrelim: &testPutEntity{ f: func(items ...interface{}) { t.Run("correct prelim transformer params", func(t *testing.T) { require.Equal(t, u, items[0]) require.Empty(t, items[1]) }) }, err: pErr, // force Transformer to return pErr }, } // ascertain that error returns as expected require.EqualError(t, s.Transform(ctx, u, handlers...), pErr.Error()) }) t.Run("size limiter error/correct sign processing", func(t *testing.T) { // create custom error for test sErr := internal.Error("test error for signer") lErr := internal.Error("test error for size limiter") s := &transformer{ tPrelim: new(testPutEntity), tSizeLim: &testPutEntity{ f: func(items ...interface{}) { t.Run("correct size limiter params", func(t *testing.T) { require.Equal(t, u, items[0]) hs := items[1].([]ProcUnitHandler) require.Len(t, hs, 1) require.EqualError(t, hs[0](ctx, u), sErr.Error()) }) }, err: lErr, // force Transformer to return lErr }, tSign: &testPutEntity{ f: func(items ...interface{}) { t.Run("correct signer params", func(t *testing.T) { require.Equal(t, u, items[0]) require.Equal(t, handlers, items[1]) }) }, err: sErr, // force Transformer to return sErr }, } // ascertain that error returns as expected require.EqualError(t, s.Transform(ctx, u, handlers...), lErr.Error()) }) } func Test_preliminaryTransformer(t *testing.T) { ctx := context.TODO() u := ProcUnit{ Head: &Object{ Payload: testData(t, 10), }, Payload: new(emptyReader), } t.Run("field moulder failure", func(t *testing.T) { // create custom error for test mErr := internal.Error("test error for field moulder") s := &preliminaryTransformer{ fMoulder: &testPutEntity{ f: func(items ...interface{}) { t.Run("correct field moulder params", func(t *testing.T) { require.Equal(t, u, items[0]) require.Empty(t, items[1]) }) }, err: mErr, // force Transformer to return mErr }, } // ascertain that error returns as expected require.EqualError(t, s.Transform(ctx, u), mErr.Error()) }) t.Run("correct result", func(t *testing.T) { // create custom error for test sgErr := internal.Error("test error for SG moulder") s := &preliminaryTransformer{ fMoulder: new(testPutEntity), sgMoulder: &testPutEntity{ f: func(items ...interface{}) { t.Run("correct field moulder params", func(t *testing.T) { require.Equal(t, u, items[0]) require.Empty(t, items[1]) }) }, err: sgErr, // force Transformer to return sgErr }, } // ascertain that error returns as expected require.EqualError(t, s.Transform(ctx, u), sgErr.Error()) }) } func Test_readChunk(t *testing.T) { t.Run("empty slice", func(t *testing.T) { t.Run("missing checksum header", func(t *testing.T) { obj := new(Object) _, h := obj.LastHeader(object.HeaderType(object.PayloadChecksumHdr)) require.Nil(t, h) require.NoError(t, readChunk(ProcUnit{ Head: obj, Payload: bytes.NewBuffer(testData(t, 10)), }, nil, nil, nil)) _, h = obj.LastHeader(object.HeaderType(object.PayloadChecksumHdr)) require.NotNil(t, h) require.Equal(t, sha256.New().Sum(nil), h.Value.(*object.Header_PayloadChecksum).PayloadChecksum) }) t.Run("existing checksum header", func(t *testing.T) { h := &object.Header_PayloadChecksum{PayloadChecksum: testData(t, 10)} obj := &Object{Headers: []object.Header{{Value: h}}} require.NoError(t, readChunk(ProcUnit{ Head: obj, Payload: bytes.NewBuffer(testData(t, 10)), }, nil, nil, nil)) require.NotNil(t, h) require.Equal(t, sha256.New().Sum(nil), h.PayloadChecksum) }) }) t.Run("non-empty slice", func(t *testing.T) { t.Run("non-full data", func(t *testing.T) { var ( size = 10 buf = testData(t, size) r = bytes.NewBuffer(buf[:size-1]) ) require.EqualError(t, readChunk(ProcUnit{Head: new(Object), Payload: r}, buf, nil, nil), ErrPayloadEOF.Error(), ) }) t.Run("hash accumulator write", func(t *testing.T) { var ( d = testData(t, 10) srcHash = sha256.Sum256(d) hAcc = sha256.New() buf = bytes.NewBuffer(d) b = make([]byte, len(d)) obj = new(Object) srcHomoHash = hash.Sum(d) homoHashHdr = &object.Header_HomoHash{HomoHash: hash.Sum(make([]byte, 0))} ) t.Run("failure", func(t *testing.T) { hErr := internal.Error("test error for hash writer") b := testData(t, len(d)) require.EqualError(t, readChunk(EmptyPayloadUnit(new(Object)), b, &testPutEntity{ f: func(items ...interface{}) { t.Run("correct accumulator params", func(t *testing.T) { require.Equal(t, b, items[0]) }) }, err: hErr, }, nil), hErr.Error()) }) require.NoError(t, readChunk(ProcUnit{Head: obj, Payload: buf}, b, hAcc, homoHashHdr)) _, h := obj.LastHeader(object.HeaderType(object.PayloadChecksumHdr)) require.NotNil(t, h) require.Equal(t, srcHash[:], h.Value.(*object.Header_PayloadChecksum).PayloadChecksum) require.Equal(t, srcHash[:], hAcc.Sum(nil)) require.Equal(t, srcHomoHash, homoHashHdr.HomoHash) }) }) } func Test_headSigner(t *testing.T) { ctx := context.TODO() t.Run("invalid input", func(t *testing.T) { t.Run("missing token", func(t *testing.T) { u := ProcUnit{Head: new(Object)} require.Error(t, u.Head.Verify()) s := &headSigner{verifier: &testPutEntity{err: internal.Error("")}} require.EqualError(t, s.Transform(ctx, u), errNoToken.Error()) }) t.Run("with token", func(t *testing.T) { u := ProcUnit{Head: new(Object)} verifier, err := implementations.NewLocalHeadIntegrityVerifier(core.NewNeoKeyVerifier()) require.NoError(t, err) require.Error(t, u.Head.Verify()) privateToken, err := session.NewPrivateToken(0) require.NoError(t, err) ctx := context.WithValue(ctx, PrivateSessionToken, privateToken) s := &headSigner{ verifier: &testPutEntity{ err: internal.Error(""), }, } key := &privateToken.PrivateKey().PublicKey u.Head.SystemHeader.OwnerID, err = refs.NewOwnerID(key) require.NoError(t, err) u.Head.AddHeader(&object.Header{ Value: &object.Header_PublicKey{ PublicKey: &object.PublicKey{ Value: crypto.MarshalPublicKey(key), }, }, }) require.NoError(t, s.Transform(ctx, u, func(_ context.Context, unit ProcUnit) error { require.NoError(t, verifier.Verify(ctx, unit.Head)) _, h := unit.Head.LastHeader(object.HeaderType(object.IntegrityHdr)) require.NotNil(t, h) d, err := objutil.MarshalHeaders(unit.Head, len(unit.Head.Headers)-1) require.NoError(t, err) cs := sha256.Sum256(d) require.Equal(t, cs[:], h.Value.(*object.Header_Integrity).Integrity.GetHeadersChecksum()) return nil })) t.Run("valid input", func(t *testing.T) { s := &headSigner{verifier: new(testPutEntity)} require.NoError(t, s.Transform(ctx, u, func(_ context.Context, unit ProcUnit) error { require.Equal(t, u, unit) return nil })) }) }) }) } func Test_fieldMoulder(t *testing.T) { ctx := context.TODO() epoch := uint64(100) fMoulder := &fieldMoulder{epochRecv: &testPutEntity{res: epoch}} t.Run("no token", func(t *testing.T) { require.EqualError(t, new(fieldMoulder).Transform(ctx, ProcUnit{}), errNoToken.Error()) }) t.Run("with token", func(t *testing.T) { token := new(service.Token) token.SetID(service.TokenID{1, 2, 3}) ctx := context.WithValue(ctx, PublicSessionToken, token) u := ProcUnit{Head: new(Object)} _, h := u.Head.LastHeader(object.HeaderType(object.TokenHdr)) require.Nil(t, h) require.NoError(t, fMoulder.Transform(ctx, u)) _, h = u.Head.LastHeader(object.HeaderType(object.TokenHdr)) require.Equal(t, token, h.Value.(*object.Header_Token).Token) require.False(t, u.Head.SystemHeader.ID.Empty()) require.NotZero(t, u.Head.SystemHeader.CreatedAt.UnixTime) require.Equal(t, epoch, u.Head.SystemHeader.CreatedAt.Epoch) require.Equal(t, uint64(1), u.Head.SystemHeader.Version) }) } func Test_sgMoulder(t *testing.T) { ctx := context.TODO() t.Run("invalid SG linking", func(t *testing.T) { t.Run("w/ header and w/o links", func(t *testing.T) { obj := new(Object) obj.SetStorageGroup(new(storagegroup.StorageGroup)) require.EqualError(t, new(sgMoulder).Transform(ctx, ProcUnit{Head: obj}), ErrInvalidSGLinking.Error()) }) t.Run("w/o header and w/ links", func(t *testing.T) { obj := new(Object) addLink(obj, object.Link_StorageGroup, ObjectID{}) require.EqualError(t, new(sgMoulder).Transform(ctx, ProcUnit{Head: obj}), ErrInvalidSGLinking.Error()) }) }) t.Run("non-SG", func(t *testing.T) { obj := new(Object) require.NoError(t, new(sgMoulder).Transform(ctx, ProcUnit{Head: obj})) }) t.Run("receive SG info", func(t *testing.T) { cid := testObjectAddress(t).CID group := make([]ObjectID, 5) for i := range group { group[i] = testObjectAddress(t).ObjectID } t.Run("failure", func(t *testing.T) { obj := &Object{SystemHeader: object.SystemHeader{CID: cid}} obj.SetStorageGroup(new(storagegroup.StorageGroup)) for i := range group { addLink(obj, object.Link_StorageGroup, group[i]) } sgErr := internal.Error("test error for SG info receiver") mSG := &sgMoulder{ sgInfoRecv: &testPutEntity{ f: func(items ...interface{}) { t.Run("correct SG info receiver params", func(t *testing.T) { cp := make([]ObjectID, len(group)) copy(cp, group) sort.Sort(storagegroup.IDList(cp)) require.Equal(t, cid, items[0]) require.Equal(t, cp, items[1]) }) }, err: sgErr, }, } require.EqualError(t, mSG.Transform(ctx, ProcUnit{Head: obj}), sgErr.Error()) }) }) t.Run("correct result", func(t *testing.T) { obj := new(Object) obj.SetStorageGroup(new(storagegroup.StorageGroup)) addLink(obj, object.Link_StorageGroup, ObjectID{}) sgInfo := &storagegroup.StorageGroup{ ValidationDataSize: 19, ValidationHash: hash.Sum(testData(t, 10)), } mSG := &sgMoulder{ sgInfoRecv: &testPutEntity{ res: sgInfo, }, } require.NoError(t, mSG.Transform(ctx, ProcUnit{Head: obj})) _, h := obj.LastHeader(object.HeaderType(object.StorageGroupHdr)) require.NotNil(t, h) require.Equal(t, sgInfo, h.Value.(*object.Header_StorageGroup).StorageGroup) }) } func Test_sizeLimiter(t *testing.T) { ctx := context.TODO() t.Run("limit entry", func(t *testing.T) { payload := testData(t, 10) payloadSize := uint64(len(payload) - 1) u := ProcUnit{ Head: &Object{SystemHeader: object.SystemHeader{ PayloadLength: payloadSize, }}, Payload: bytes.NewBuffer(payload[:payloadSize]), } sl := &sizeLimiter{limit: payloadSize} t.Run("cut payload", func(t *testing.T) { require.Error(t, sl.Transform(ctx, ProcUnit{ Head: &Object{SystemHeader: object.SystemHeader{PayloadLength: payloadSize}}, Payload: bytes.NewBuffer(payload[:payloadSize-1]), })) }) require.NoError(t, sl.Transform(ctx, u, func(_ context.Context, unit ProcUnit) error { _, err := unit.Payload.Read(make([]byte, 1)) require.EqualError(t, err, io.EOF.Error()) require.Equal(t, payload[:payloadSize], unit.Head.Payload) _, h := unit.Head.LastHeader(object.HeaderType(object.HomoHashHdr)) require.NotNil(t, h) require.Equal(t, hash.Sum(payload[:payloadSize]), h.Value.(*object.Header_HomoHash).HomoHash) return nil })) }) t.Run("limit exceed", func(t *testing.T) { payload := testData(t, 100) sizeLimit := uint64(len(payload)) / 13 pToken, err := session.NewPrivateToken(0) require.NoError(t, err) srcObj := &object.Object{ SystemHeader: object.SystemHeader{ Version: 12, PayloadLength: uint64(len(payload)), ID: testObjectAddress(t).ObjectID, OwnerID: object.OwnerID{1, 2, 3}, CID: testObjectAddress(t).CID, }, Headers: []object.Header{ {Value: &object.Header_UserHeader{UserHeader: &object.UserHeader{Key: "key", Value: "value"}}}, }, } u := ProcUnit{ Head: srcObj, Payload: bytes.NewBuffer(payload), } epoch := uint64(77) sl := &sizeLimiter{ limit: sizeLimit, epochRecv: &testPutEntity{res: epoch}, } t.Run("no token", func(t *testing.T) { require.EqualError(t, sl.Transform(ctx, ProcUnit{ Head: &Object{ SystemHeader: object.SystemHeader{ PayloadLength: uint64(len(payload)), }, }, Payload: bytes.NewBuffer(payload), }), errNoToken.Error()) }) ctx := context.WithValue(ctx, PrivateSessionToken, pToken) t.Run("cut payload", func(t *testing.T) { require.Error(t, sl.Transform(ctx, ProcUnit{ Head: &Object{ SystemHeader: object.SystemHeader{ PayloadLength: uint64(len(payload)) + 1, }, }, Payload: bytes.NewBuffer(payload), })) }) objs := make([]Object, 0) t.Run("handler error", func(t *testing.T) { hErr := internal.Error("test error for handler") require.EqualError(t, sl.Transform(ctx, ProcUnit{ Head: &Object{ SystemHeader: object.SystemHeader{PayloadLength: uint64(len(payload))}, Headers: make([]object.Header, 0), }, Payload: bytes.NewBuffer(payload), }, func(context.Context, ProcUnit) error { return hErr }), hErr.Error()) }) require.NoError(t, sl.Transform(ctx, u, func(_ context.Context, unit ProcUnit) error { _, err := unit.Payload.Read(make([]byte, 1)) require.EqualError(t, err, io.EOF.Error()) objs = append(objs, *unit.Head.Copy()) return nil })) ln := len(objs) res := make([]byte, 0, len(payload)) zObj := objs[ln-1] require.Zero(t, zObj.SystemHeader.PayloadLength) require.Empty(t, zObj.Payload) require.Empty(t, zObj.Links(object.Link_Next)) require.Empty(t, zObj.Links(object.Link_Previous)) require.Empty(t, zObj.Links(object.Link_Parent)) children := zObj.Links(object.Link_Child) require.Len(t, children, ln-1) for i := range objs[:ln-1] { require.Equal(t, objs[i].SystemHeader.ID, children[i]) } for i := range objs[:ln-1] { res = append(res, objs[i].Payload...) if i == 0 { require.Equal(t, objs[i].Links(object.Link_Next)[0], objs[i+1].SystemHeader.ID) require.True(t, objs[i].Links(object.Link_Previous)[0].Empty()) } else if i < ln-2 { require.Equal(t, objs[i].Links(object.Link_Previous)[0], objs[i-1].SystemHeader.ID) require.Equal(t, objs[i].Links(object.Link_Next)[0], objs[i+1].SystemHeader.ID) } else { _, h := objs[i].LastHeader(object.HeaderType(object.HomoHashHdr)) require.NotNil(t, h) require.Equal(t, hash.Sum(payload), h.Value.(*object.Header_HomoHash).HomoHash) require.Equal(t, objs[i].Links(object.Link_Previous)[0], objs[i-1].SystemHeader.ID) require.True(t, objs[i].Links(object.Link_Next)[0].Empty()) } } require.Equal(t, payload, res) }) } // testData returns size bytes of random data. func testData(t *testing.T, size int) []byte { res := make([]byte, size) _, err := rand.Read(res) require.NoError(t, err) return res } // testObjectAddress returns new random object address. func testObjectAddress(t *testing.T) refs.Address { oid, err := refs.NewObjectID() require.NoError(t, err) return refs.Address{CID: refs.CIDForBytes(testData(t, refs.CIDSize)), ObjectID: oid} } func TestIntegration(t *testing.T) { ownerKey := test.DecodeKey(1) ownerID, err := refs.NewOwnerID(&ownerKey.PublicKey) require.NoError(t, err) privToken, err := session.NewPrivateToken(0) require.NoError(t, err) pkBytes, err := session.PublicSessionToken(privToken) require.NoError(t, err) ctx := context.WithValue(context.TODO(), PrivateSessionToken, privToken) pubToken := new(service.Token) pubToken.SetID(service.TokenID{1, 2, 3}) pubToken.SetSessionKey(pkBytes) pubToken.SetOwnerID(ownerID) pubToken.SetOwnerKey(crypto.MarshalPublicKey(&ownerKey.PublicKey)) require.NoError(t, service.AddSignatureWithKey(ownerKey, service.NewSignedSessionToken(pubToken))) ctx = context.WithValue(ctx, PublicSessionToken, pubToken) t.Run("non-SG object", func(t *testing.T) { t.Run("with split", func(t *testing.T) { tr, err := NewTransformer(Params{ SGInfoReceiver: new(testPutEntity), EpochReceiver: &testPutEntity{res: uint64(1)}, SizeLimit: 13, Verifier: &testPutEntity{ err: internal.Error(""), // force verifier to return non-nil error }, }) require.NoError(t, err) payload := make([]byte, 20) _, err = rand.Read(payload) require.NoError(t, err) obj := &Object{ SystemHeader: object.SystemHeader{ PayloadLength: uint64(len(payload)), CID: CID{3}, }, Headers: []object.Header{ {Value: &object.Header_UserHeader{UserHeader: &object.UserHeader{Key: "key", Value: "value"}}}, }, } obj.SystemHeader.OwnerID = ownerID obj.SetHeader(&object.Header{ Value: &object.Header_Token{ Token: pubToken, }, }) testTransformer(t, ctx, ProcUnit{ Head: obj, Payload: bytes.NewBuffer(payload), }, tr, payload) }) }) } func testTransformer(t *testing.T, ctx context.Context, u ProcUnit, tr Transformer, src []byte) { objList := make([]Object, 0) verifier, err := implementations.NewLocalHeadIntegrityVerifier(core.NewNeoKeyVerifier()) require.NoError(t, err) require.NoError(t, tr.Transform(ctx, u, func(_ context.Context, unit ProcUnit) error { require.NoError(t, verifier.Verify(ctx, unit.Head)) objList = append(objList, *unit.Head.Copy()) return nil })) reverse := NewRestorePipeline(SplitRestorer()) res, err := reverse.Restore(ctx, objList...) require.NoError(t, err) integrityVerifier, err := implementations.NewLocalIntegrityVerifier(core.NewNeoKeyVerifier()) require.NoError(t, err) require.NoError(t, integrityVerifier.Verify(ctx, &res[0])) require.Equal(t, src, res[0].Payload) _, h := res[0].LastHeader(object.HeaderType(object.HomoHashHdr)) require.True(t, hash.Sum(src).Equal(h.Value.(*object.Header_HomoHash).HomoHash)) } func addLink(o *Object, t object.Link_Type, id ObjectID) { o.AddHeader(&object.Header{Value: &object.Header_Link{ Link: &object.Link{Type: t, ID: id}, }}) }