frostfs-sdk-go/object/transformer/transformer_test.go

192 lines
4.8 KiB
Go
Raw Normal View History

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