482 lines
11 KiB
Go
482 lines
11 KiB
Go
package storage
|
|
|
|
import (
|
|
"errors"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestFileExists(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setup func(tmpDir string) string
|
|
expected bool
|
|
}{
|
|
{
|
|
name: "existing file returns true",
|
|
setup: func(tmpDir string) string {
|
|
path := filepath.Join(tmpDir, "test.txt")
|
|
if err := os.WriteFile(path, []byte("test"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "non-existent file returns false",
|
|
setup: func(tmpDir string) string {
|
|
return filepath.Join(tmpDir, "nonexistent.txt")
|
|
},
|
|
expected: false,
|
|
},
|
|
{
|
|
name: "directory path returns true",
|
|
setup: func(tmpDir string) string {
|
|
path := filepath.Join(tmpDir, "testdir")
|
|
if err := os.Mkdir(path, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "empty path returns false",
|
|
setup: func(tmpDir string) string {
|
|
return ""
|
|
},
|
|
expected: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
path := tt.setup(tmpDir)
|
|
got := FileExists(path)
|
|
if got != tt.expected {
|
|
t.Errorf("FileExists(%q) = %v, want %v", path, got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEnsureDir(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setup func(tmpDir string) (string, os.FileMode)
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "creates new directory",
|
|
setup: func(tmpDir string) (string, os.FileMode) {
|
|
return filepath.Join(tmpDir, "newdir"), 0755
|
|
},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "idempotent - doesn't error if exists",
|
|
setup: func(tmpDir string) (string, os.FileMode) {
|
|
path := filepath.Join(tmpDir, "existingdir")
|
|
if err := os.Mkdir(path, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path, 0755
|
|
},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "creates nested directories",
|
|
setup: func(tmpDir string) (string, os.FileMode) {
|
|
return filepath.Join(tmpDir, "a", "b", "c", "d"), 0755
|
|
},
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
path, perm := tt.setup(tmpDir)
|
|
|
|
err := EnsureDir(path, perm)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("EnsureDir() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
|
|
if !tt.wantErr {
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Errorf("Directory not created: %v", err)
|
|
return
|
|
}
|
|
if !info.IsDir() {
|
|
t.Error("Path is not a directory")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReadFile(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setup func(tmpDir string) string
|
|
wantData []byte
|
|
wantErr bool
|
|
errCheck func(error) bool
|
|
}{
|
|
{
|
|
name: "read existing file",
|
|
setup: func(tmpDir string) string {
|
|
path := filepath.Join(tmpDir, "test.txt")
|
|
if err := os.WriteFile(path, []byte("test content"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path
|
|
},
|
|
wantData: []byte("test content"),
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "non-existent file",
|
|
setup: func(tmpDir string) string {
|
|
return filepath.Join(tmpDir, "nonexistent.txt")
|
|
},
|
|
wantErr: true,
|
|
errCheck: func(err error) bool {
|
|
return errors.Is(err, fs.ErrNotExist)
|
|
},
|
|
},
|
|
{
|
|
name: "empty file",
|
|
setup: func(tmpDir string) string {
|
|
path := filepath.Join(tmpDir, "empty.txt")
|
|
if err := os.WriteFile(path, []byte{}, 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path
|
|
},
|
|
wantData: []byte{},
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
path := tt.setup(tmpDir)
|
|
|
|
got, err := ReadFile(path)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("ReadFile() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
|
|
if tt.wantErr && tt.errCheck != nil && !tt.errCheck(err) {
|
|
t.Errorf("ReadFile() error type mismatch: %v", err)
|
|
}
|
|
|
|
if !tt.wantErr && string(got) != string(tt.wantData) {
|
|
t.Errorf("ReadFile() = %q, want %q", got, tt.wantData)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWriteFile(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setup func(tmpDir string) (string, []byte, os.FileMode)
|
|
validate func(t *testing.T, path string, data []byte, perm os.FileMode)
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "write new file",
|
|
setup: func(tmpDir string) (string, []byte, os.FileMode) {
|
|
return filepath.Join(tmpDir, "new.txt"), []byte("new content"), 0644
|
|
},
|
|
validate: func(t *testing.T, path string, data []byte, perm os.FileMode) {
|
|
got, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Errorf("Failed to read written file: %v", err)
|
|
}
|
|
if string(got) != string(data) {
|
|
t.Errorf("Content = %q, want %q", got, data)
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "overwrite existing file",
|
|
setup: func(tmpDir string) (string, []byte, os.FileMode) {
|
|
path := filepath.Join(tmpDir, "existing.txt")
|
|
if err := os.WriteFile(path, []byte("old content"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path, []byte("new content"), 0644
|
|
},
|
|
validate: func(t *testing.T, path string, data []byte, perm os.FileMode) {
|
|
got, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Errorf("Failed to read overwritten file: %v", err)
|
|
}
|
|
if string(got) != string(data) {
|
|
t.Errorf("Content = %q, want %q", got, data)
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "correct permissions applied",
|
|
setup: func(tmpDir string) (string, []byte, os.FileMode) {
|
|
return filepath.Join(tmpDir, "perms.txt"), []byte("test"), 0600
|
|
},
|
|
validate: func(t *testing.T, path string, data []byte, perm os.FileMode) {
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Errorf("Failed to stat file: %v", err)
|
|
return
|
|
}
|
|
if info.Mode().Perm() != perm {
|
|
t.Errorf("Permissions = %o, want %o", info.Mode().Perm(), perm)
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
path, data, perm := tt.setup(tmpDir)
|
|
|
|
err := WriteFile(path, data, perm)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("WriteFile() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
|
|
if !tt.wantErr && tt.validate != nil {
|
|
tt.validate(t, path, data, perm)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWithLock(t *testing.T) {
|
|
t.Run("acquires and releases lock", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
lockPath := filepath.Join(tmpDir, "test.lock")
|
|
executed := false
|
|
|
|
err := WithLock(lockPath, func() error {
|
|
executed = true
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
t.Errorf("WithLock() error = %v", err)
|
|
}
|
|
if !executed {
|
|
t.Error("Function was not executed")
|
|
}
|
|
})
|
|
|
|
t.Run("releases lock after executing", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
lockPath := filepath.Join(tmpDir, "test.lock")
|
|
|
|
err := WithLock(lockPath, func() error {
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("First lock failed: %v", err)
|
|
}
|
|
|
|
err = WithLock(lockPath, func() error {
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Errorf("Second lock failed (lock not released): %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("concurrent access blocked", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
lockPath := filepath.Join(tmpDir, "concurrent.lock")
|
|
|
|
var counter atomic.Int32
|
|
var wg sync.WaitGroup
|
|
goroutines := 10
|
|
|
|
for i := 0; i < goroutines; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
err := WithLock(lockPath, func() error {
|
|
current := counter.Load()
|
|
time.Sleep(10 * time.Millisecond)
|
|
counter.Store(current + 1)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Errorf("WithLock() error = %v", err)
|
|
}
|
|
}()
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
if counter.Load() != int32(goroutines) {
|
|
t.Errorf("Counter = %d, want %d (concurrent access not properly blocked)", counter.Load(), goroutines)
|
|
}
|
|
})
|
|
|
|
t.Run("lock released on error", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
lockPath := filepath.Join(tmpDir, "error.lock")
|
|
testErr := errors.New("test error")
|
|
|
|
err := WithLock(lockPath, func() error {
|
|
return testErr
|
|
})
|
|
if err != testErr {
|
|
t.Errorf("Expected error %v, got %v", testErr, err)
|
|
}
|
|
|
|
err = WithLock(lockPath, func() error {
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Errorf("Lock not released after error: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("lock released on panic", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
lockPath := filepath.Join(tmpDir, "panic.lock")
|
|
|
|
func() {
|
|
defer func() {
|
|
if r := recover(); r == nil {
|
|
t.Error("Expected panic")
|
|
}
|
|
}()
|
|
_ = WithLock(lockPath, func() error {
|
|
panic("test panic")
|
|
})
|
|
}()
|
|
|
|
err := WithLock(lockPath, func() error {
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Errorf("Lock not released after panic: %v", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestLockManual(t *testing.T) {
|
|
t.Run("manual acquire and release", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
lockPath := filepath.Join(tmpDir, "manual.lock")
|
|
|
|
lock, err := AcquireLock(lockPath)
|
|
if err != nil {
|
|
t.Fatalf("AcquireLock() error = %v", err)
|
|
}
|
|
|
|
err = lock.Release()
|
|
if err != nil {
|
|
t.Errorf("Release() error = %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("double release is safe", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
lockPath := filepath.Join(tmpDir, "double.lock")
|
|
|
|
lock, err := AcquireLock(lockPath)
|
|
if err != nil {
|
|
t.Fatalf("AcquireLock() error = %v", err)
|
|
}
|
|
|
|
err = lock.Release()
|
|
if err != nil {
|
|
t.Errorf("First Release() error = %v", err)
|
|
}
|
|
|
|
err = lock.Release()
|
|
if err != nil {
|
|
t.Errorf("Second Release() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestEnsureFilePermissions(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setup func(tmpDir string) string
|
|
perm os.FileMode
|
|
wantErr bool
|
|
errCheck func(error) bool
|
|
}{
|
|
{
|
|
name: "sets permissions on existing file",
|
|
setup: func(tmpDir string) string {
|
|
path := filepath.Join(tmpDir, "test.txt")
|
|
if err := os.WriteFile(path, []byte("test"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path
|
|
},
|
|
perm: 0600,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "non-existent file returns error",
|
|
setup: func(tmpDir string) string {
|
|
return filepath.Join(tmpDir, "nonexistent.txt")
|
|
},
|
|
perm: 0644,
|
|
wantErr: true,
|
|
errCheck: func(err error) bool {
|
|
return errors.Is(err, fs.ErrNotExist)
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
path := tt.setup(tmpDir)
|
|
|
|
err := EnsureFilePermissions(path, tt.perm)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("EnsureFilePermissions() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
|
|
if tt.wantErr && tt.errCheck != nil && !tt.errCheck(err) {
|
|
t.Errorf("EnsureFilePermissions() error type mismatch: %v", err)
|
|
}
|
|
|
|
if !tt.wantErr {
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Errorf("Failed to stat file: %v", err)
|
|
return
|
|
}
|
|
if info.Mode().Perm() != tt.perm {
|
|
t.Errorf("Permissions = %o, want %o", info.Mode().Perm(), tt.perm)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|