From f43f18ecda9008209338e54ffd5deb19f207f849 Mon Sep 17 00:00:00 2001 From: Evgenii Stratonikov Date: Sat, 18 Feb 2023 10:13:14 +0300 Subject: [PATCH] [#19] transformer: Cover with unit-tests Signed-off-by: Evgenii Stratonikov --- object/transformer/transformer_test.go | 164 +++++++++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 object/transformer/transformer_test.go diff --git a/object/transformer/transformer_test.go b/object/transformer/transformer_test.go new file mode 100644 index 0000000..fe35fe3 --- /dev/null +++ b/object/transformer/transformer_test.go @@ -0,0 +1,164 @@ +package transformer + +import ( + "crypto/rand" + "testing" + + cidtest "github.com/TrueCloudLab/frostfs-sdk-go/container/id/test" + objectSDK "github.com/TrueCloudLab/frostfs-sdk-go/object" + "github.com/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, _ := newPayloadSizeLimiter(maxSize, tt) + + ver := version.Current() + cnr := cidtest.ID() + hdr := objectSDK.New() + hdr.SetContainerID(cnr) + hdr.SetType(objectSDK.TypeRegular) + hdr.SetVersion(&ver) + require.NoError(t, target.WriteHeader(hdr)) + + expectedPayload := make([]byte, maxSize*2+maxSize/2) + _, _ = rand.Read(expectedPayload) + + _, err := target.Write(expectedPayload) + require.NoError(t, err) + + ids, err := target.Close() + require.NoError(t, err) + + 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()) + + payload := tt.objects[i].Payload() + require.EqualValues(t, tt.objects[i].PayloadSize(), len(payload)) + actualPayload = append(actualPayload, payload...) + + switch i { + case 0, 1: + require.EqualValues(t, maxSize, len(payload)) + case 2: + require.EqualValues(t, maxSize/2, len(payload)) + case 3: + parID, ok := tt.objects[i].ParentID() + require.True(t, ok) + require.Equal(t, ids.ParentID(), &parID) + } + } + require.Equal(t, expectedPayload, actualPayload) +} + +func BenchmarkTransformer(b *testing.B) { + ver := version.Current() + cnr := cidtest.ID() + hdr := objectSDK.New() + hdr.SetContainerID(cnr) + hdr.SetType(objectSDK.TypeRegular) + hdr.SetVersion(&ver) + + 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) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + f, _ := newPayloadSizeLimiter(maxSize, benchTarget{}) + if err := f.WriteHeader(header); err != nil { + b.Fatalf("write header: %v", err) + } + if _, err := f.Write(payload); err != nil { + b.Fatalf("write: %v", err) + } + if _, err := f.Close(); 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(maxSize, true, func() ObjectTarget { + return NewFormatTarget(&FormatterParams{ + Key: &p.PrivateKey, + NextTarget: nextTarget, + NetworkState: dummyEpochSource(123), + }) + }), p +} + +type dummyEpochSource uint64 + +func (s dummyEpochSource) CurrentEpoch() uint64 { + return uint64(s) +} + +type benchTarget struct{} + +func (benchTarget) WriteHeader(object *objectSDK.Object) error { + return nil +} + +func (benchTarget) Write(p []byte) (n int, err error) { + return len(p), nil +} + +func (benchTarget) Close() (*AccessIdentifiers, error) { + return nil, nil +} + +type testTarget struct { + current *objectSDK.Object + payload []byte + objects []*objectSDK.Object +} + +func (tt *testTarget) WriteHeader(object *objectSDK.Object) error { + tt.current = object + return nil +} + +func (tt *testTarget) Write(p []byte) (n int, err error) { + tt.payload = append(tt.payload, p...) + return len(p), nil +} + +func (tt *testTarget) Close() (*AccessIdentifiers, error) { + tt.current.SetPayload(tt.payload) + // We need to marshal, because current implementation reuses written object. + data, _ := tt.current.Marshal() + obj := objectSDK.New() + _ = obj.Unmarshal(data) + + tt.objects = append(tt.objects, obj) + tt.current = nil + tt.payload = nil + return nil, nil // AccessIdentifiers should not be used. +}