Files
Mediarr/storage/storage_test.go
T
2026-11-16 10:04:52 +01:00

191 lines
4.9 KiB
Go

package storage
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"io"
"os"
"path/filepath"
"strings"
"testing"
"mediarr/ident"
)
func TestLocalStageCommitDedupOpenRemove(t *testing.T) {
ctx := context.Background()
root := t.TempDir()
store, err := NewLocal(root)
if err != nil {
t.Fatalf("NewLocal : %v", err)
}
payload := []byte("contenu local")
expectedRoot := sha256.Sum256(payload)
staged, err := store.Stage(ctx, mustUUID(t), bytes.NewReader(payload))
if err != nil {
t.Fatalf("Stage : %v", err)
}
if staged.Size != int64(len(payload)) {
t.Fatalf("size = %d, attendu %d", staged.Size, len(payload))
}
if !bytes.Equal(staged.Root, expectedRoot[:]) {
t.Fatalf("root = %x, attendu %x", staged.Root, expectedRoot)
}
if !strings.HasPrefix(staged.Locator, "staging/") {
t.Fatalf("locator = %q, attendu staging/...", staged.Locator)
}
locator, err := store.Commit(ctx, staged)
if err != nil {
t.Fatalf("Commit : %v", err)
}
rootHex := hex.EncodeToString(expectedRoot[:])
expectedLocator := filepath.ToSlash(filepath.Join("blobs", rootHex[:2], rootHex[2:4], rootHex))
if locator != expectedLocator {
t.Fatalf("locator = %q, attendu %q", locator, expectedLocator)
}
if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(staged.Locator))); !os.IsNotExist(err) {
t.Fatalf("fichier de staging encore présent : %v", err)
}
reader, err := store.Open(ctx, locator)
if err != nil {
t.Fatalf("Open : %v", err)
}
data, err := io.ReadAll(reader)
if err != nil {
_ = reader.Close()
t.Fatalf("ReadAll : %v", err)
}
if err := reader.Close(); err != nil {
t.Fatalf("Close : %v", err)
}
if !bytes.Equal(data, payload) {
t.Fatalf("contenu = %q, attendu %q", data, payload)
}
duplicate, err := store.Stage(ctx, mustUUID(t), bytes.NewReader(payload))
if err != nil {
t.Fatalf("Stage(doublon) : %v", err)
}
duplicateLocator, err := store.Commit(ctx, duplicate)
if err != nil {
t.Fatalf("Commit(doublon) : %v", err)
}
if duplicateLocator != locator {
t.Fatalf("locator doublon = %q, attendu %q", duplicateLocator, locator)
}
if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(duplicate.Locator))); !os.IsNotExist(err) {
t.Fatalf("staging doublon encore présent : %v", err)
}
if err := store.Remove(ctx, locator); err != nil {
t.Fatalf("Remove : %v", err)
}
if _, err := store.Open(ctx, locator); !errors.Is(err, ErrNotFound) {
t.Fatalf("Open après Remove : erreur = %v, attendu ErrNotFound", err)
}
}
func TestLocalReplace(t *testing.T) {
ctx := context.Background()
root := t.TempDir()
store, err := NewLocal(root)
if err != nil {
t.Fatalf("NewLocal : %v", err)
}
payload := []byte("contenu à réparer")
staged, err := store.Stage(ctx, mustUUID(t), bytes.NewReader(payload))
if err != nil {
t.Fatalf("Stage : %v", err)
}
locator, err := store.Commit(ctx, staged)
if err != nil {
t.Fatalf("Commit : %v", err)
}
if err := os.WriteFile(filepath.Join(root, filepath.FromSlash(locator)), []byte("corrompu"), 0o640); err != nil {
t.Fatalf("WriteFile : %v", err)
}
replacement, err := store.Stage(ctx, mustUUID(t), bytes.NewReader(payload))
if err != nil {
t.Fatalf("Stage(remplacement) : %v", err)
}
replacedLocator, err := store.Replace(ctx, replacement)
if err != nil {
t.Fatalf("Replace : %v", err)
}
if replacedLocator != locator {
t.Fatalf("locator = %q, attendu %q", replacedLocator, locator)
}
reader, err := store.Open(ctx, locator)
if err != nil {
t.Fatalf("Open : %v", err)
}
data, err := io.ReadAll(reader)
if err != nil {
_ = reader.Close()
t.Fatalf("ReadAll : %v", err)
}
if err := reader.Close(); err != nil {
t.Fatalf("Close : %v", err)
}
if !bytes.Equal(data, payload) {
t.Fatalf("contenu = %q, attendu %q", data, payload)
}
}
func TestLocalRejectsInvalidLocators(t *testing.T) {
ctx := context.Background()
store, err := NewLocal(t.TempDir())
if err != nil {
t.Fatalf("NewLocal : %v", err)
}
for _, locator := range []string{"", "../secret", "/etc/passwd", "staging/../../secret"} {
if _, err := store.Open(ctx, locator); !errors.Is(err, ErrInvalidLocator) {
t.Fatalf("Open(%q) : erreur = %v, attendu ErrInvalidLocator", locator, err)
}
}
if _, err := store.Commit(ctx, Staged{Locator: "staging/x", Root: []byte{1}}); !errors.Is(err, ErrInvalidLocator) {
t.Fatalf("Commit avec racine invalide : erreur = %v, attendu ErrInvalidLocator", err)
}
}
func TestLocalStageHonorsCanceledContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
store, err := NewLocal(t.TempDir())
if err != nil {
t.Fatalf("NewLocal : %v", err)
}
if _, err := store.Stage(ctx, mustUUID(t), strings.NewReader("contenu")); !errors.Is(err, context.Canceled) {
t.Fatalf("Stage : erreur = %v, attendu context.Canceled", err)
}
}
func mustUUID(t *testing.T) ident.UUID {
t.Helper()
id, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
return id
}