Free apps from using github.com/nspcc-dev/neofs-api-go/v2 module

bearer/bearer.go

@@ -290,11 +290,24 @@ func (b *Token) Sign(signer user.Signer) error {
 
 // SignedData returns actual payload to sign.
 //
-// See also [Token.Sign].
+// See also [Token.Sign], [Token.UnmarshalSignedData].
 func (b *Token) SignedData() []byte {
 	return b.signedData()
 }
 
+// UnmarshalSignedData is a reverse op to [Token.SignedData].
+func (b *Token) UnmarshalSignedData(data []byte) error {
+	var body acl.BearerTokenBody
+	err := body.Unmarshal(data)
+	if err != nil {
+		return fmt.Errorf("decode body: %w", err)
+	}
+
+	var tok acl.BearerToken
+	tok.SetBody(&body)
+	return b.readFromV2(tok, false)
+}
+
 // VerifySignature checks if Token signature is presented and valid.
 //
 // Zero Token fails the check.

bearer/bearer_test.go

@@ -289,6 +289,11 @@ func TestToken_SignedData(t *testing.T) {
 
 	require.False(t, val.VerifySignature())
 
+	signedData := val.SignedData()
+	var dec bearer.Token
+	require.NoError(t, dec.UnmarshalSignedData(signedData))
+	require.Equal(t, val, dec)
+
 	signer := test.RandomSignerRFC6979(t)
 	val = bearertest.Token(t)
 	val.SetIssuer(signer.UserID())

client/container_statistic_test.go

@@ -127,7 +127,7 @@ func prepareContainer(accountID user.ID) container.Container {
 	rd.SetNumberOfObjects(1)
 
 	pp.SetContainerBackupFactor(1)
-	pp.AddReplicas(rd)
+	pp.SetReplicas([]netmap.ReplicaDescriptor{rd})
 	cont.SetPlacementPolicy(pp)
 
 	return cont

container/container_internal_test.go

@@ -30,15 +30,15 @@ func TestContainer_CopyTo(t *testing.T) {
 	var rd netmap.ReplicaDescriptor
 	rd.SetSelectorName("selector")
 	rd.SetNumberOfObjects(100)
-	pp.AddReplicas(rd)
+	pp.SetReplicas([]netmap.ReplicaDescriptor{rd})
 
 	var f netmap.Filter
 	f.SetName("filter")
-	pp.AddFilters(f)
+	pp.SetFilters([]netmap.Filter{f})
 
 	var s netmap.Selector
 	s.SetName("selector")
-	pp.AddSelectors(s)
+	pp.SetSelectors([]netmap.Selector{s})
 
 	container.SetPlacementPolicy(pp)
 

container/example_test.go

@@ -36,7 +36,7 @@ func ExampleContainer_Init() {
 	// placement policy and replicas definition is required
 	var pp netmap.PlacementPolicy
 	pp.SetContainerBackupFactor(1)
-	pp.AddReplicas(rd)
+	pp.SetReplicas([]netmap.ReplicaDescriptor{rd})
 
 	cnr.SetPlacementPolicy(pp)
 }

eacl/filter.go

@@ -13,35 +13,25 @@ import (
 type Filter struct {
 	from    FilterHeaderType
 	matcher Match
-	key     filterKey
+	key     string
 	value   stringEncoder
 }
 
 type staticStringer string
 
 type u64Stringer uint64
 
-type filterKey struct {
-	typ filterKeyType
-
-	str string
-}
-
-// enumeration of reserved filter keys.
-type filterKeyType int
-
+// Various keys to object filters.
 const (
-	_ filterKeyType = iota
-	fKeyObjVersion
-	fKeyObjID
-	fKeyObjContainerID
-	fKeyObjOwnerID
-	fKeyObjCreationEpoch
-	fKeyObjPayloadLength
-	fKeyObjPayloadHash
-	fKeyObjType
-	fKeyObjHomomorphicHash
-	fKeyObjLast // helper, used in tests
+	FilterObjectVersion                    = v2acl.FilterObjectVersion
+	FilterObjectID                         = v2acl.FilterObjectID
+	FilterObjectContainerID                = v2acl.FilterObjectContainerID
+	FilterObjectOwnerID                    = v2acl.FilterObjectOwnerID
+	FilterObjectCreationEpoch              = v2acl.FilterObjectCreationEpoch
+	FilterObjectPayloadSize                = v2acl.FilterObjectPayloadLength
+	FilterObjectPayloadChecksum            = v2acl.FilterObjectPayloadHash
+	FilterObjectType                       = v2acl.FilterObjectType
+	FilterObjectPayloadHomomorphicChecksum = v2acl.FilterObjectHomomorphicHash
 )
 
 func (s staticStringer) EncodeToString() string {
@@ -72,7 +62,7 @@ func (f Filter) Matcher() Match {
 
 // Key returns key to the filtered header.
 func (f Filter) Key() string {
-	return f.key.String()
+	return f.key
 }
 
 // From returns FilterHeaderType that defined which header will be filtered.
@@ -90,63 +80,13 @@ func (f *Filter) ToV2() *v2acl.HeaderFilter {
 
 	filter := new(v2acl.HeaderFilter)
 	filter.SetValue(f.value.EncodeToString())
-	filter.SetKey(f.key.String())
+	filter.SetKey(f.key)
 	filter.SetMatchType(f.matcher.ToV2())
 	filter.SetHeaderType(f.from.ToV2())
 
 	return filter
 }
 
-func (k filterKey) String() string {
-	switch k.typ {
-	default:
-		return k.str
-	case fKeyObjVersion:
-		return v2acl.FilterObjectVersion
-	case fKeyObjID:
-		return v2acl.FilterObjectID
-	case fKeyObjContainerID:
-		return v2acl.FilterObjectContainerID
-	case fKeyObjOwnerID:
-		return v2acl.FilterObjectOwnerID
-	case fKeyObjCreationEpoch:
-		return v2acl.FilterObjectCreationEpoch
-	case fKeyObjPayloadLength:
-		return v2acl.FilterObjectPayloadLength
-	case fKeyObjPayloadHash:
-		return v2acl.FilterObjectPayloadHash
-	case fKeyObjType:
-		return v2acl.FilterObjectType
-	case fKeyObjHomomorphicHash:
-		return v2acl.FilterObjectHomomorphicHash
-	}
-}
-
-func (k *filterKey) fromString(s string) {
-	switch s {
-	default:
-		k.typ, k.str = 0, s
-	case v2acl.FilterObjectVersion:
-		k.typ, k.str = fKeyObjVersion, ""
-	case v2acl.FilterObjectID:
-		k.typ, k.str = fKeyObjID, ""
-	case v2acl.FilterObjectContainerID:
-		k.typ, k.str = fKeyObjContainerID, ""
-	case v2acl.FilterObjectOwnerID:
-		k.typ, k.str = fKeyObjOwnerID, ""
-	case v2acl.FilterObjectCreationEpoch:
-		k.typ, k.str = fKeyObjCreationEpoch, ""
-	case v2acl.FilterObjectPayloadLength:
-		k.typ, k.str = fKeyObjPayloadLength, ""
-	case v2acl.FilterObjectPayloadHash:
-		k.typ, k.str = fKeyObjPayloadHash, ""
-	case v2acl.FilterObjectType:
-		k.typ, k.str = fKeyObjType, ""
-	case v2acl.FilterObjectHomomorphicHash:
-		k.typ, k.str = fKeyObjHomomorphicHash, ""
-	}
-}
-
 // NewFilter creates, initializes and returns blank Filter instance.
 //
 // Defaults:
@@ -168,7 +108,7 @@ func NewFilterFromV2(filter *v2acl.HeaderFilter) *Filter {
 
 	f.from = FilterHeaderTypeFromV2(filter.GetHeaderType())
 	f.matcher = MatchFromV2(filter.GetMatchType())
-	f.key.fromString(filter.GetKey())
+	f.key = filter.GetKey()
 	f.value = staticStringer(filter.GetValue())
 
 	return f

eacl/filter_test.go

@@ -2,7 +2,6 @@ package eacl
 
 import (
 	"bytes"
-	"strconv"
 	"testing"
 
 	"github.com/nspcc-dev/neofs-api-go/v2/acl"
@@ -12,10 +11,8 @@ import (
 
 func newObjectFilter(match Match, key, val string) *Filter {
 	return &Filter{
-		from: HeaderFromObject,
-		key: filterKey{
-			str: key,
-		},
+		from:    HeaderFromObject,
+		key:     key,
 		matcher: match,
 		value:   staticStringer(val),
 	}
@@ -87,30 +84,14 @@ func TestFilter_ToV2(t *testing.T) {
 		require.Equal(t, acl.HeaderTypeUnknown, filterV2.GetHeaderType())
 		require.Equal(t, acl.MatchTypeUnknown, filterV2.GetMatchType())
 	})
-
-	t.Run("reserved types", func(t *testing.T) {
-		r := NewRecord()
-		for i := filterKeyType(1); i < fKeyObjLast; i++ {
-			r.addObjectReservedFilter(MatchStringEqual, i, staticStringer(strconv.FormatUint(uint64(i), 16)))
-		}
-
-		for i := range r.filters {
-			fv2 := r.filters[i].ToV2()
-			actual := NewFilterFromV2(fv2)
-			require.Equal(t, actual, &r.filters[i])
-		}
-	})
 }
 
 func TestFilter_CopyTo(t *testing.T) {
 	var filter Filter
 	filter.value = staticStringer("value")
 	filter.from = 1
 	filter.matcher = 1
-	filter.key = filterKey{
-		typ: 1,
-		str: "1",
-	}
+	filter.key = "1"
 
 	var dst Filter
 	t.Run("copy", func(t *testing.T) {
@@ -130,19 +111,16 @@ func TestFilter_CopyTo(t *testing.T) {
 		require.Equal(t, filter.value, dst.value)
 		require.Equal(t, filter.from, dst.from)
 		require.Equal(t, filter.matcher, dst.matcher)
-		require.Equal(t, filter.key.typ, dst.key.typ)
-		require.Equal(t, filter.key.str, dst.key.str)
+		require.Equal(t, filter.key, dst.key)
 
 		dst.value = staticStringer("value2")
 		dst.from = 2
 		dst.matcher = 2
-		dst.key.typ = 2
-		dst.key.str = "2"
+		dst.key = "2"
 
 		require.NotEqual(t, filter.value, dst.value)
 		require.NotEqual(t, filter.from, dst.from)
 		require.NotEqual(t, filter.matcher, dst.matcher)
-		require.NotEqual(t, filter.key.typ, dst.key.typ)
-		require.NotEqual(t, filter.key.str, dst.key.str)
+		require.NotEqual(t, filter.key, dst.key)
 	})
 }