mirror of
https://github.com/sonr-io/crypto.git
synced 2026-08-04 08:11:39 +00:00
No commit suggestions generated
This commit is contained in:
Prad Nukala
@@ -0,0 +1,421 @@
|
||||
package salt
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestGenerate(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
size int
|
||||
wantErr bool
|
||||
}{
|
||||
{"minimum size", MinSaltSize, false},
|
||||
{"default size", DefaultSaltSize, false},
|
||||
{"large size", 512, false},
|
||||
{"maximum size", MaxSaltSize, false},
|
||||
{"too small", MinSaltSize - 1, true},
|
||||
{"too large", MaxSaltSize + 1, true},
|
||||
{"zero size", 0, true},
|
||||
{"negative size", -1, true},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
salt, err := Generate(tt.size)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("Generate() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
|
||||
if !tt.wantErr {
|
||||
if salt == nil {
|
||||
t.Error("Generate() returned nil salt without error")
|
||||
return
|
||||
}
|
||||
if salt.Size() != tt.size {
|
||||
t.Errorf("Generate() size = %d, want %d", salt.Size(), tt.size)
|
||||
}
|
||||
if salt.IsEmpty() {
|
||||
t.Error("Generate() returned empty salt")
|
||||
}
|
||||
|
||||
// Test that salt contains random data (not all zeros)
|
||||
saltBytes := salt.Bytes()
|
||||
allZeros := true
|
||||
for _, b := range saltBytes {
|
||||
if b != 0 {
|
||||
allZeros = false
|
||||
break
|
||||
}
|
||||
}
|
||||
if allZeros {
|
||||
t.Error("Generate() returned all-zero salt (likely not random)")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestGenerateDefault(t *testing.T) {
|
||||
salt, err := GenerateDefault()
|
||||
if err != nil {
|
||||
t.Fatalf("GenerateDefault() error = %v", err)
|
||||
}
|
||||
|
||||
if salt.Size() != DefaultSaltSize {
|
||||
t.Errorf("GenerateDefault() size = %d, want %d", salt.Size(), DefaultSaltSize)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFromBytes(t *testing.T) {
|
||||
validBytes := make([]byte, DefaultSaltSize)
|
||||
for i := range validBytes {
|
||||
validBytes[i] = byte(i)
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
data []byte
|
||||
wantErr bool
|
||||
}{
|
||||
{"valid default size", validBytes, false},
|
||||
{"minimum size", make([]byte, MinSaltSize), false},
|
||||
{"large size", make([]byte, 512), false},
|
||||
{"too small", make([]byte, MinSaltSize-1), true},
|
||||
{"too large", make([]byte, MaxSaltSize+1), true},
|
||||
{"empty", []byte{}, true},
|
||||
{"nil", nil, true},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
salt, err := FromBytes(tt.data)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("FromBytes() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
|
||||
if !tt.wantErr {
|
||||
if salt == nil {
|
||||
t.Error("FromBytes() returned nil salt without error")
|
||||
return
|
||||
}
|
||||
if salt.Size() != len(tt.data) {
|
||||
t.Errorf("FromBytes() size = %d, want %d", salt.Size(), len(tt.data))
|
||||
}
|
||||
|
||||
// Verify data is copied correctly
|
||||
saltBytes := salt.Bytes()
|
||||
if !bytes.Equal(saltBytes, tt.data) {
|
||||
t.Error("FromBytes() data doesn't match input")
|
||||
}
|
||||
|
||||
// Verify external modification doesn't affect salt
|
||||
if len(tt.data) > 0 {
|
||||
originalValue := tt.data[0]
|
||||
tt.data[0] = ^tt.data[0] // Flip bits
|
||||
if salt.Bytes()[0] != originalValue {
|
||||
t.Error("FromBytes() salt was affected by external modification")
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaltBytes(t *testing.T) {
|
||||
salt, err := GenerateDefault()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate salt: %v", err)
|
||||
}
|
||||
|
||||
bytes1 := salt.Bytes()
|
||||
bytes2 := salt.Bytes()
|
||||
|
||||
// Should return same data
|
||||
if !bytes.Equal(bytes1, bytes2) {
|
||||
t.Error("Bytes() returned different data on multiple calls")
|
||||
}
|
||||
|
||||
// Should be independent copies
|
||||
if &bytes1[0] == &bytes2[0] {
|
||||
t.Error("Bytes() returned same underlying array (not a copy)")
|
||||
}
|
||||
|
||||
// Modifying returned bytes shouldn't affect salt
|
||||
if len(bytes1) > 0 {
|
||||
originalValue := bytes1[0]
|
||||
bytes1[0] = ^bytes1[0]
|
||||
bytes3 := salt.Bytes()
|
||||
if bytes3[0] != originalValue {
|
||||
t.Error("External modification of Bytes() affected salt")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaltEqual(t *testing.T) {
|
||||
salt1, err := Generate(DefaultSaltSize)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate salt1: %v", err)
|
||||
}
|
||||
|
||||
salt2, err := Generate(DefaultSaltSize)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate salt2: %v", err)
|
||||
}
|
||||
|
||||
// Same salt data
|
||||
salt3, err := FromBytes(salt1.Bytes())
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to create salt3: %v", err)
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
salt1 *Salt
|
||||
salt2 *Salt
|
||||
expected bool
|
||||
}{
|
||||
{"same salt", salt1, salt1, true},
|
||||
{"equivalent salts", salt1, salt3, true},
|
||||
{"different salts", salt1, salt2, false},
|
||||
{"nil salts", nil, nil, true},
|
||||
{"one nil salt", salt1, nil, false},
|
||||
{"nil vs non-nil", nil, salt1, false},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.salt1.Equal(tt.salt2)
|
||||
if result != tt.expected {
|
||||
t.Errorf("Equal() = %v, want %v", result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaltClear(t *testing.T) {
|
||||
salt, err := GenerateDefault()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate salt: %v", err)
|
||||
}
|
||||
|
||||
originalSize := salt.Size()
|
||||
if originalSize == 0 {
|
||||
t.Fatal("Salt size is zero before clear")
|
||||
}
|
||||
|
||||
salt.Clear()
|
||||
|
||||
if salt.Size() != 0 {
|
||||
t.Error("Salt size is not zero after clear")
|
||||
}
|
||||
|
||||
if !salt.IsEmpty() {
|
||||
t.Error("Salt is not empty after clear")
|
||||
}
|
||||
|
||||
bytes := salt.Bytes()
|
||||
if bytes != nil {
|
||||
t.Error("Bytes() should return nil after clear")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaltStore(t *testing.T) {
|
||||
store := NewSaltStore()
|
||||
|
||||
// Test empty store
|
||||
if store.Size() != 0 {
|
||||
t.Error("New store should be empty")
|
||||
}
|
||||
|
||||
// Generate and store salt
|
||||
salt1, err := GenerateDefault()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate salt: %v", err)
|
||||
}
|
||||
|
||||
err = store.Store("test1", salt1)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to store salt: %v", err)
|
||||
}
|
||||
|
||||
if store.Size() != 1 {
|
||||
t.Errorf("Store size = %d, want 1", store.Size())
|
||||
}
|
||||
|
||||
// Retrieve salt
|
||||
retrieved, err := store.Retrieve("test1")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to retrieve salt: %v", err)
|
||||
}
|
||||
|
||||
if !salt1.Equal(retrieved) {
|
||||
t.Error("Retrieved salt doesn't match stored salt")
|
||||
}
|
||||
|
||||
// Test generate and store
|
||||
salt2, err := store.GenerateAndStore("test2", DefaultSaltSize)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate and store salt: %v", err)
|
||||
}
|
||||
|
||||
if store.Size() != 2 {
|
||||
t.Errorf("Store size = %d, want 2", store.Size())
|
||||
}
|
||||
|
||||
if salt2.Size() != DefaultSaltSize {
|
||||
t.Errorf("Generated salt size = %d, want %d", salt2.Size(), DefaultSaltSize)
|
||||
}
|
||||
|
||||
// Test list
|
||||
ids := store.List()
|
||||
if len(ids) != 2 {
|
||||
t.Errorf("List() returned %d ids, want 2", len(ids))
|
||||
}
|
||||
|
||||
foundTest1 := false
|
||||
foundTest2 := false
|
||||
for _, id := range ids {
|
||||
if id == "test1" {
|
||||
foundTest1 = true
|
||||
}
|
||||
if id == "test2" {
|
||||
foundTest2 = true
|
||||
}
|
||||
}
|
||||
if !foundTest1 || !foundTest2 {
|
||||
t.Error("List() doesn't contain expected IDs")
|
||||
}
|
||||
|
||||
// Test remove
|
||||
err = store.Remove("test1")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to remove salt: %v", err)
|
||||
}
|
||||
|
||||
if store.Size() != 1 {
|
||||
t.Errorf("Store size = %d, want 1 after removal", store.Size())
|
||||
}
|
||||
|
||||
_, err = store.Retrieve("test1")
|
||||
if err == nil {
|
||||
t.Error("Should not be able to retrieve removed salt")
|
||||
}
|
||||
|
||||
// Test clear
|
||||
store.Clear()
|
||||
if store.Size() != 0 {
|
||||
t.Error("Store should be empty after clear")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaltStoreErrors(t *testing.T) {
|
||||
store := NewSaltStore()
|
||||
|
||||
// Test empty identifier errors
|
||||
err := store.Store("", nil)
|
||||
if err == nil {
|
||||
t.Error("Should error on empty identifier")
|
||||
}
|
||||
|
||||
_, err = store.Retrieve("")
|
||||
if err == nil {
|
||||
t.Error("Should error on empty identifier")
|
||||
}
|
||||
|
||||
err = store.Remove("")
|
||||
if err == nil {
|
||||
t.Error("Should error on empty identifier")
|
||||
}
|
||||
|
||||
// Test nil salt error
|
||||
err = store.Store("test", nil)
|
||||
if err == nil {
|
||||
t.Error("Should error on nil salt")
|
||||
}
|
||||
|
||||
// Test empty salt error
|
||||
emptySalt := &Salt{}
|
||||
err = store.Store("test", emptySalt)
|
||||
if err == nil {
|
||||
t.Error("Should error on empty salt")
|
||||
}
|
||||
|
||||
// Test retrieve non-existent
|
||||
_, err = store.Retrieve("nonexistent")
|
||||
if err == nil {
|
||||
t.Error("Should error when retrieving non-existent salt")
|
||||
}
|
||||
|
||||
// Test remove non-existent
|
||||
err = store.Remove("nonexistent")
|
||||
if err == nil {
|
||||
t.Error("Should error when removing non-existent salt")
|
||||
}
|
||||
}
|
||||
|
||||
func TestConstantTimeCompare(t *testing.T) {
|
||||
a := []byte{1, 2, 3, 4, 5}
|
||||
b := []byte{1, 2, 3, 4, 5}
|
||||
c := []byte{1, 2, 3, 4, 6}
|
||||
d := []byte{1, 2, 3, 4}
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
a, b []byte
|
||||
expected bool
|
||||
}{
|
||||
{"equal slices", a, b, true},
|
||||
{"different content", a, c, false},
|
||||
{"different length", a, d, false},
|
||||
{"empty slices", []byte{}, []byte{}, true},
|
||||
{"one empty", a, []byte{}, false},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := constantTimeCompare(tt.a, tt.b)
|
||||
if result != tt.expected {
|
||||
t.Errorf("constantTimeCompare() = %v, want %v", result, tt.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkGenerate(b *testing.B) {
|
||||
sizes := []int{MinSaltSize, DefaultSaltSize, 512}
|
||||
|
||||
for _, size := range sizes {
|
||||
b.Run(fmt.Sprintf("%dB", size), func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
salt, err := Generate(size)
|
||||
if err != nil {
|
||||
b.Fatalf("Generate error: %v", err)
|
||||
}
|
||||
salt.Clear() // Clean up
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkSaltEqual(b *testing.B) {
|
||||
salt1, _ := GenerateDefault()
|
||||
salt2, _ := GenerateDefault()
|
||||
salt3, _ := FromBytes(salt1.Bytes())
|
||||
|
||||
b.Run("equal", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
salt1.Equal(salt3)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("different", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
salt1.Equal(salt2)
|
||||
}
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user