api: namer implementation

Makefile

@@ -38,7 +38,7 @@ coveralls-deps:
 .PHONY: lint-deps
 lint-deps:
 	@echo "Installing lint deps"
-	@go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.5.0
+	@go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.7.2
 
 .PHONY: lint
 lint: lint-deps

crypto/interfaces.go

@@ -1,4 +1,4 @@
-// Package crypto implements crypto interfaces.
+// Package crypto implements verification interfaces.
 package crypto
 
 // Signer implements high-level API for package signing.

crypto/rsa.go → crypto/rsapss.go

@@ -1,4 +1,4 @@
-package crypto
+package crypto //nolint:revive
 
 import (
 	"crypto"
@@ -29,12 +29,12 @@ func NewRSAPSS(privKey rsa.PrivateKey, pubKey rsa.PublicKey) RSAPSS {
 }
 
 // Name implements SignerVerifier interface.
-func (r *RSAPSS) Name() string {
+func (r RSAPSS) Name() string {
 	return "RSASSA-PSS"
 }
 
 // Sign generates SHA-256 digest and signs it using RSASSA-PSS.
-func (r *RSAPSS) Sign(data []byte) ([]byte, error) {
+func (r RSAPSS) Sign(data []byte) ([]byte, error) {
 	digest, err := r.hasher.Hash(data)
 	if err != nil {
 		return []byte{}, fmt.Errorf("failed to get hash: %w", err)
@@ -52,7 +52,7 @@ func (r *RSAPSS) Sign(data []byte) ([]byte, error) {
 }
 
 // Verify compares data with signature.
-func (r *RSAPSS) Verify(data []byte, signature []byte) error {
+func (r RSAPSS) Verify(data []byte, signature []byte) error {
 	digest, err := r.hasher.Hash(data)
 	if err != nil {
 		return fmt.Errorf("failed to get hash: %w", err)

crypto/rsa_test.go → crypto/rsapss_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+
 	"github.com/tarantool/go-storage/crypto"
 )
 

hasher/hasher_test.go

@@ -61,9 +61,9 @@ func TestSHA256Hasher(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
-		name string
-		in   []byte
-		out  string
+		name     string
+		in       []byte
+		expected string
 	}{
 		{"empty", []byte(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
 		{"abc", []byte("abc"), "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"},
@@ -77,7 +77,7 @@ func TestSHA256Hasher(t *testing.T) {
 
 			result, _ := h.Hash(test.in)
 
-			assert.Equal(t, test.out, hex.EncodeToString(result))
+			assert.Equal(t, test.expected, hex.EncodeToString(result))
 		})
 	}
 }

kv/kv.go

@@ -9,7 +9,6 @@ type KeyValue struct {
 	Key []byte
 	// Value is the serialized representation of the value.
 	Value []byte
-
 	// ModRevision is the revision number of the last modification to this key.
 	ModRevision int64
 }

marshaller/marshaller.go

@@ -17,24 +17,24 @@ var ErrUnmarshall = errors.New("failed to unmarshal")
 // implements one time for all objects.
 // Required for `integrity.Storage` to set marshalling format for any type object
 // and as recommendation for developers of `Storage` wrappers.
-type DefaultMarshaller interface {
+type DefaultMarshaller interface { //nolint:iface
 	Marshal(data any) ([]byte, error)
 	Unmarshal(data []byte, out any) error
 }
 
 // Marshallable - custom object serialization, implements for each object.
 // Required for `integrity.Storage` type to set marshalling format to specific object
 // and as recommendation for developers of `Storage` wrappers.
-type Marshallable interface {
-	Marshal() ([]byte, error)
+type Marshallable interface { //nolint:iface
+	Marshal(data any) ([]byte, error)
 	Unmarshal(data []byte, out any) error
 }
 
 // YAMLMarshaller struct represent realization.
 type YAMLMarshaller struct{}
 
 // NewYamlMarshaller creates new NewYamlMarshaller object.
-func NewYamlMarshaller() YAMLMarshaller {
+func NewYamlMarshaller() Marshallable {
 	return YAMLMarshaller{}
 }
 

namer/error.go

@@ -0,0 +1,39 @@
+package namer
+
+import (
+	"fmt"
+)
+
+// InvalidKeyError represents an error for invalid key format.
+type InvalidKeyError struct {
+	Key     string
+	Problem string
+}
+
+func (e InvalidKeyError) Error() string {
+	return fmt.Sprintf("invalid key '%s': %s", e.Key, e.Problem)
+}
+
+func errInvalidKey(key string, problem string) error {
+	return InvalidKeyError{
+		Key:     key,
+		Problem: problem,
+	}
+}
+
+// InvalidNameError represents an error for invalid name format.
+type InvalidNameError struct {
+	Name    string
+	Problem string
+}
+
+func (e InvalidNameError) Error() string {
+	return fmt.Sprintf("invalid name '%s': %s", e.Name, e.Problem)
+}
+
+func errInvalidName(name string, problem string) error {
+	return InvalidNameError{
+		Name:    name,
+		Problem: problem,
+	}
+}

namer/error_test.go

@@ -0,0 +1,23 @@
+package namer_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/tarantool/go-storage/namer"
+)
+
+func TestInvalidNameError_Error(t *testing.T) {
+	t.Parallel()
+
+	err := namer.InvalidNameError{Name: "name", Problem: "problem"}
+	assert.Equal(t, "invalid name 'name': problem", err.Error())
+}
+
+func TestInvalidKeyError_Error(t *testing.T) {
+	t.Parallel()
+
+	err := namer.InvalidKeyError{Key: "name", Problem: "problem"}
+	assert.Equal(t, "invalid key 'name': problem", err.Error())
+}

namer/key.go

@@ -0,0 +1,59 @@
+package namer
+
+// KeyType represents key types.
+type KeyType int
+
+const (
+	// KeyTypeValue represents data type.
+	KeyTypeValue KeyType = iota + 1
+	// KeyTypeHash represents hash of the data type.
+	KeyTypeHash
+	// KeyTypeSignature represents signature of the data type.
+	KeyTypeSignature
+)
+
+// Key defines the minimal interface required by keys.
+type Key interface {
+	Name() string     // Get object name.
+	Type() KeyType    // Get key type.
+	Property() string // Get metadata (e.g., algorithm version).
+	Build() string    // Reconstruct raw key string.
+}
+
+// DefaultKey implements default realization.
+type DefaultKey struct {
+	name     string  // Object identifier.
+	keyType  KeyType // Type of object (hash/signature/value).
+	property string  // Additional metadata (version/algorithm).
+	raw      string  // Raw key string.
+}
+
+// NewDefaultKey returns new Key object.
+func NewDefaultKey(name string, keytype KeyType, property string, raw string) DefaultKey {
+	return DefaultKey{
+		name:     name,
+		keyType:  keytype,
+		property: property,
+		raw:      raw,
+	}
+}
+
+// Name returns name of the key.
+func (k DefaultKey) Name() string {
+	return k.name
+}
+
+// Type returns type of the key.
+func (k DefaultKey) Type() KeyType {
+	return k.keyType
+}
+
+// Property returns property of the key.
+func (k DefaultKey) Property() string {
+	return k.property
+}
+
+// Build reconstructs key string.
+func (k DefaultKey) Build() string {
+	return k.raw
+}

namer/key_test.go

@@ -0,0 +1,52 @@
+package namer_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/tarantool/go-storage/namer"
+)
+
+const (
+	defaultName     = "all"
+	defaultType     = namer.KeyTypeHash
+	defaultProperty = "sha256"
+	defaultRaw      = "/config/hash/sha256/all"
+)
+
+func TestNewDefaultKey(t *testing.T) {
+	t.Parallel()
+
+	a := namer.NewDefaultKey(defaultName, defaultType, defaultProperty, defaultRaw)
+	require.NotEmpty(t, a)
+}
+
+func TestDefaultKey_Build(t *testing.T) {
+	t.Parallel()
+
+	a := namer.NewDefaultKey(defaultName, defaultType, defaultProperty, defaultRaw)
+	require.Equal(t, defaultRaw, a.Build())
+}
+
+func TestDefaultKey_Name(t *testing.T) {
+	t.Parallel()
+
+	a := namer.NewDefaultKey(defaultName, defaultType, defaultProperty, defaultRaw)
+	assert.Equal(t, defaultName, a.Name())
+}
+
+func TestDefaultKey_Type(t *testing.T) {
+	t.Parallel()
+
+	a := namer.NewDefaultKey(defaultName, defaultType, defaultProperty, defaultRaw)
+	assert.Equal(t, defaultType, a.Type())
+}
+
+func TestDefaultKey_Property(t *testing.T) {
+	t.Parallel()
+
+	a := namer.NewDefaultKey(defaultName, defaultType, defaultProperty, defaultRaw)
+	assert.Equal(t, defaultProperty, a.Property())
+}