refactor: add test dir for helpers

Author: srg-bnd

internal/shared/services/checksum.go

@@ -5,10 +5,14 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"errors"
+	"fmt"
 	"hash"
 )
 
-var ErrVerify = errors.New("unverified data")
+var (
+	ErrVerify      = errors.New("unverified data")
+	ErrInvalidData = errors.New("invalid data")
+)
 
 type Checksum struct {
 	hmac hash.Hash
@@ -23,7 +27,7 @@ func NewChecksum(secretkey string) *Checksum {
 func (c *Checksum) Verify(dataHash, data string) error {
 	sum, err := c.Sum(data)
 	if err != nil {
-		return err
+		return fmt.Errorf("%w: %w", ErrVerify, err)
 	}
 
 	if sum != dataHash {
@@ -36,9 +40,8 @@ func (c *Checksum) Verify(dataHash, data string) error {
 func (c *Checksum) Sum(data string) (string, error) {
 	defer c.hmac.Reset()
 
-	_, err := c.hmac.Write([]byte(data))
-	if err != nil {
-		return "", err
+	if _, err := c.hmac.Write([]byte(data)); err != nil {
+		return "", fmt.Errorf("%w: %w", ErrInvalidData, err)
 	}
 
 	return hex.EncodeToString(c.hmac.Sum(nil)), nil

internal/shared/services/checksum_test.go

@@ -1,53 +1,89 @@
 package services
 
 import (
-	"crypto/hmac"
-	"crypto/rand"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/hex"
+	"fmt"
 	"testing"
 
+	"github.com/srg-bnd/observator/tests/helpers"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestChecksum(t *testing.T) {
-	randomString, err := secureRandomString(16)
+	randomString, err := helpers.SecureRandomString(16)
 	assert.Nil(t, err)
 
-	data := "test data"
-	hmac := hmac.New(sha256.New, []byte(randomString))
-	hmac.Write([]byte(data))
+	testCases := []struct {
+		data     string
+		dataHash string
+		err      error
+	}{
+		{
+			data:     "correctData",
+			dataHash: helpers.Sha256Hash("correctData", randomString),
+		},
+		{
+			data:     "",
+			dataHash: helpers.Sha256Hash("", randomString),
+		},
+		{
+			data:     "correctData",
+			dataHash: helpers.Sha256Hash("incorrectData", randomString),
+			err:      ErrVerify,
+		},
+	}
 
-	err = NewChecksum(randomString).Verify(hex.EncodeToString(hmac.Sum(nil)), data)
-	assert.Nil(t, err)
+	service := NewChecksum(randomString)
+
+	for i, tc := range testCases {
+		t.Run(fmt.Sprint("Test ", i+1, ": ", tc.data), func(t *testing.T) {
+			err := service.Verify(tc.dataHash, tc.data)
+
+			if tc.err != nil {
+				assert.NotNil(t, err)
+			} else {
+				assert.ErrorIs(t, err, tc.err)
+			}
+		})
+	}
 }
 
 func TestSum(t *testing.T) {
-	randomString, err := secureRandomString(16)
+	randomString, err := helpers.SecureRandomString(16)
 	assert.Nil(t, err)
 
-	data := "test data"
-	hmac := hmac.New(sha256.New, []byte(randomString))
-	hmac.Write([]byte(data))
-	service := NewChecksum(randomString)
-	sum, err := service.Sum(data)
-	assert.Nil(t, err)
-	assert.Equal(t, hex.EncodeToString(hmac.Sum(nil)), sum)
+	testCases := []struct {
+		input    string
+		expected string
+		fail     bool
+	}{
+		{
+			input:    "correctData",
+			expected: helpers.Sha256Hash("correctData", randomString),
+		},
+		// For testing resets
+		{
+			input:    "newCorrectData",
+			expected: helpers.Sha256Hash("newCorrectData", randomString),
+		},
+		{
+			input:    "oldData",
+			expected: helpers.Sha256Hash("newData", randomString),
+			fail:     true,
+		},
+	}
 
-	sum, err = service.Sum(data)
-	assert.Nil(t, err)
-	assert.Equal(t, hex.EncodeToString(hmac.Sum(nil)), sum)
-}
+	service := NewChecksum(randomString)
 
-// Helpers
+	for i, tc := range testCases {
+		t.Run(fmt.Sprint("Test ", i+1, ": ", tc.input), func(t *testing.T) {
+			result, err := service.Sum(tc.input)
+			assert.Nil(t, err)
 
-func secureRandomString(length int) (string, error) {
-	b := make([]byte, length)
-	_, err := rand.Read(b)
-	if err != nil {
-		return "", err
+			if tc.fail {
+				assert.NotEqual(t, tc.expected, result)
+			} else {
+				assert.Equal(t, tc.expected, result)
+			}
+		})
 	}
-
-	return base64.StdEncoding.EncodeToString(b), nil
 }

tests/helpers/helpers.go

@@ -0,0 +1,26 @@
+package helpers
+
+import (
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+)
+
+func Sha256Hash(data string, key string) string {
+	hmac := hmac.New(sha256.New, []byte(key))
+	hmac.Write([]byte(data))
+
+	return hex.EncodeToString(hmac.Sum(nil))
+}
+
+func SecureRandomString(length int) (string, error) {
+	b := make([]byte, length)
+	_, err := rand.Read(b)
+	if err != nil {
+		return "", err
+	}
+
+	return base64.StdEncoding.EncodeToString(b), nil
+}