package transformer import ( "context" "crypto/rand" "crypto/sha256" "testing" cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id" cidtest "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id/test" objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object" "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/user" "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/version" "github.com/nspcc-dev/neo-go/pkg/crypto/keys" "github.com/stretchr/testify/require" ) func TestTransformer(t *testing.T) { const maxSize = 100 tt := new(testTarget) target, pk := newPayloadSizeLimiter(maxSize, tt) cnr := cidtest.ID() hdr := newObject(cnr) var owner user.ID user.IDFromKey(&owner, pk.PrivateKey.PublicKey) hdr.SetOwnerID(&owner) expectedPayload := make([]byte, maxSize*2+maxSize/2) _, _ = rand.Read(expectedPayload) ids := writeObject(t, context.Background(), target, hdr, expectedPayload) require.Equal(t, 4, len(tt.objects)) // 3 parts + linking object var actualPayload []byte for i := range tt.objects { childCnr, ok := tt.objects[i].ContainerID() require.True(t, ok) require.Equal(t, cnr, childCnr) require.Equal(t, objectSDK.TypeRegular, tt.objects[i].Type()) require.Equal(t, &owner, tt.objects[i].OwnerID()) payload := tt.objects[i].Payload() require.EqualValues(t, tt.objects[i].PayloadSize(), len(payload)) actualPayload = append(actualPayload, payload...) if len(payload) != 0 { cs, ok := tt.objects[i].PayloadChecksum() require.True(t, ok) h := sha256.Sum256(payload) require.Equal(t, h[:], cs.Value()) } require.True(t, tt.objects[i].VerifyIDSignature()) switch i { case 0, 1: require.EqualValues(t, maxSize, len(payload)) require.Nil(t, tt.objects[i].Parent()) case 2: require.EqualValues(t, maxSize/2, len(payload)) parent := tt.objects[i].Parent() require.NotNil(t, parent) require.Nil(t, parent.SplitID()) require.True(t, parent.VerifyIDSignature()) case 3: parID, ok := tt.objects[i].ParentID() require.True(t, ok) require.Equal(t, ids.ParentID, &parID) children := tt.objects[i].Children() for j := 0; j < i; j++ { id, ok := tt.objects[j].ID() require.True(t, ok) require.Equal(t, id, children[j]) } } } require.Equal(t, expectedPayload, actualPayload) t.Run("parent checksum", func(t *testing.T) { cs, ok := ids.ParentHeader.PayloadChecksum() require.True(t, ok) h := sha256.Sum256(expectedPayload) require.Equal(t, h[:], cs.Value()) }) } func newObject(cnr cid.ID) *objectSDK.Object { ver := version.Current() hdr := objectSDK.New() hdr.SetContainerID(cnr) hdr.SetType(objectSDK.TypeRegular) hdr.SetVersion(&ver) return hdr } func writeObject(t *testing.T, ctx context.Context, target ObjectTarget, header *objectSDK.Object, payload []byte) *AccessIdentifiers { require.NoError(t, target.WriteHeader(ctx, header)) _, err := target.Write(ctx, payload) require.NoError(t, err) ids, err := target.Close(ctx) require.NoError(t, err) return ids } func BenchmarkTransformer(b *testing.B) { hdr := newObject(cidtest.ID()) b.Run("small", func(b *testing.B) { benchmarkTransformer(b, hdr, 8*1024) }) b.Run("big", func(b *testing.B) { benchmarkTransformer(b, hdr, 64*1024*1024*9/2) }) } func benchmarkTransformer(b *testing.B, header *objectSDK.Object, payloadSize int) { const maxSize = 64 * 1024 * 1024 payload := make([]byte, payloadSize) ctx := context.Background() b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { f, _ := newPayloadSizeLimiter(maxSize, benchTarget{}) if err := f.WriteHeader(ctx, header); err != nil { b.Fatalf("write header: %v", err) } if _, err := f.Write(ctx, payload); err != nil { b.Fatalf("write: %v", err) } if _, err := f.Close(ctx); err != nil { b.Fatalf("close: %v", err) } } } func newPayloadSizeLimiter(maxSize uint64, nextTarget ObjectTarget) (ObjectTarget, *keys.PrivateKey) { p, err := keys.NewPrivateKey() if err != nil { panic(err) } return NewPayloadSizeLimiter(Params{ Key: &p.PrivateKey, NextTarget: nextTarget, NetworkState: dummyEpochSource(123), MaxSize: maxSize, WithoutHomomorphicHash: true, }), p } type dummyEpochSource uint64 func (s dummyEpochSource) CurrentEpoch() uint64 { return uint64(s) } type benchTarget struct{} func (benchTarget) WriteHeader(_ context.Context, object *objectSDK.Object) error { return nil } func (benchTarget) Write(_ context.Context, p []byte) (n int, err error) { return len(p), nil } func (benchTarget) Close(context.Context) (*AccessIdentifiers, error) { return nil, nil } type testTarget struct { current *objectSDK.Object payload []byte objects []*objectSDK.Object } func (tt *testTarget) WriteHeader(_ context.Context, object *objectSDK.Object) error { tt.current = object return nil } func (tt *testTarget) Write(_ context.Context, p []byte) (n int, err error) { tt.payload = append(tt.payload, p...) return len(p), nil } func (tt *testTarget) Close(_ context.Context) (*AccessIdentifiers, error) { tt.current.SetPayload(tt.payload) tt.objects = append(tt.objects, tt.current) tt.current = nil tt.payload = nil return nil, nil // AccessIdentifiers should not be used. }