[sha512] storage: Get/Set digest

Adds Get and Set methods for configuring digest. Currently, only sha256
and sha512 are supported, but should make future additions easier.

Defaults to sha256.

Signed-off-by: Lokesh Mandvekar <[email protected]>

Author: lsm5

storage/pkg/supported-digests/algorithm.go

@@ -0,0 +1,32 @@
+package supporteddigests
+
+import (
+	"fmt"
+
+	"github.com/opencontainers/go-digest"
+	"github.com/sirupsen/logrus"
+)
+
+var digestAlgorithm = digest.Canonical // Default to SHA256
+
+// Get returns the current digest algorithm
+func Get() digest.Algorithm {
+	return digestAlgorithm
+}
+
+// Set sets the digest algorithm
+func Set(algorithm digest.Algorithm) error {
+	// Validate the digest type
+	switch algorithm {
+	case digest.SHA256, digest.SHA512:
+		logrus.Debugf("SetDigestAlgorithm: Setting digest algorithm to %s", algorithm.String())
+		digestAlgorithm = algorithm
+		return nil
+	case "":
+		logrus.Debugf("SetDigestAlgorithm: Setting digest algorithm to default %s", digest.Canonical.String())
+		digestAlgorithm = digest.Canonical // Default to sha256
+		return nil
+	default:
+		return fmt.Errorf("unsupported digest algorithm: %q", algorithm)
+	}
+}

storage/pkg/supported-digests/algorithm_test.go

@@ -0,0 +1,101 @@
+package supporteddigests
+
+import (
+	"testing"
+
+	"github.com/opencontainers/go-digest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGet(t *testing.T) {
+	// Test that Get returns the default algorithm (SHA256)
+	algorithm := Get()
+	assert.Equal(t, digest.Canonical, algorithm)
+	assert.Equal(t, "sha256", algorithm.String())
+}
+
+func TestSet(t *testing.T) {
+	tests := []struct {
+		name        string
+		algorithm   digest.Algorithm
+		expectError bool
+		expected    digest.Algorithm
+	}{
+		{
+			name:        "Set SHA256",
+			algorithm:   digest.SHA256,
+			expectError: false,
+			expected:    digest.SHA256,
+		},
+		{
+			name:        "Set SHA512",
+			algorithm:   digest.SHA512,
+			expectError: false,
+			expected:    digest.SHA512,
+		},
+		{
+			name:        "Set empty string (should default to SHA256)",
+			algorithm:   "",
+			expectError: false,
+			expected:    digest.Canonical, // SHA256
+		},
+		{
+			name:        "Set unsupported algorithm SHA384",
+			algorithm:   digest.SHA384,
+			expectError: true,
+			expected:    digest.Canonical, // Should remain unchanged (default)
+		},
+		{
+			name:        "Set unsupported algorithm MD5",
+			algorithm:   digest.Digest("md5:invalid").Algorithm(),
+			expectError: true,
+			expected:    digest.Canonical, // Should remain unchanged (default)
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := Set(tt.algorithm)
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), "unsupported digest algorithm")
+				// Verify algorithm wasn't changed
+				assert.Equal(t, tt.expected, Get())
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expected, Get())
+			}
+		})
+	}
+}
+
+func TestAlgorithmPersistence(t *testing.T) {
+	// Test that algorithm changes persist across multiple calls
+	err := Set(digest.SHA512)
+	require.NoError(t, err)
+	assert.Equal(t, digest.SHA512, Get())
+
+	// Verify it's still SHA512 after another call
+	assert.Equal(t, digest.SHA512, Get())
+
+	// Change to SHA256
+	err = Set(digest.SHA256)
+	require.NoError(t, err)
+	assert.Equal(t, digest.SHA256, Get())
+
+	// Verify it's still SHA256 after another call
+	assert.Equal(t, digest.SHA256, Get())
+}
+
+func TestAlgorithmStringRepresentation(t *testing.T) {
+	// Test SHA256 string representation
+	err := Set(digest.SHA256)
+	require.NoError(t, err)
+	assert.Equal(t, "sha256", Get().String())
+
+	// Test SHA512 string representation
+	err = Set(digest.SHA512)
+	require.NoError(t, err)
+	assert.Equal(t, "sha512", Get().String())
+}