package geduldh import ( "bytes" "context" "crypto/sha256" "encoding/hex" "errors" "io" "os" "path/filepath" "strings" "sync" "testing" ) func digest(data []byte) string { sum := sha256.Sum256(data); return hex.EncodeToString(sum[:]) } func local(t *testing.T) (*Local, string) { t.Helper() root := t.TempDir() s, err := NewLocal(root) if err != nil { t.Fatal(err) } return s, root } func TestLocalRoundTripAndRange(t *testing.T) { for _, payload := range [][]byte{nil, []byte("text 日本語"), {0, 0xff, 1, 0, 3}} { s, _ := local(t) ctx := context.Background() hash := digest(payload) if err := s.PutIfAbsent(ctx, hash, int64(len(payload)), bytes.NewReader(payload)); err != nil { t.Fatal(err) } info, err := s.Stat(ctx, hash) if err != nil || info.Hash != hash || info.Size != int64(len(payload)) { t.Fatalf("info=%+v err=%v", info, err) } reader, err := s.Open(ctx, hash) if err != nil { t.Fatal(err) } data, err := io.ReadAll(reader) if err != nil || !bytes.Equal(data, payload) { t.Fatalf("data=%v err=%v", data, err) } if size, err := reader.Seek(0, io.SeekEnd); err != nil || size != int64(len(payload)) { t.Fatalf("size=%d err=%v", size, err) } if len(payload) > 2 { buf := make([]byte, 2) if _, err := reader.ReadAt(buf, 1); err != nil || !bytes.Equal(buf, payload[1:3]) { t.Fatalf("range=%v err=%v", buf, err) } } reader.Close() if err := s.Verify(ctx, hash); err != nil { t.Fatal(err) } } } func TestLocalRejectsIncompleteOrCorruptInput(t *testing.T) { payload := []byte("good") for _, tc := range []struct { name string data []byte size int64 want error }{ {"hash", []byte("evil"), 4, ErrHashMismatch}, {"short", []byte("goo"), 4, ErrSizeMismatch}, {"long", []byte("good!"), 4, ErrSizeMismatch}, {"negative", payload, -1, ErrSizeMismatch}, } { t.Run(tc.name, func(t *testing.T) { s, root := local(t) err := s.PutIfAbsent(context.Background(), digest(payload), tc.size, bytes.NewReader(tc.data)) if !errors.Is(err, tc.want) { t.Fatalf("got %v want %v", err, tc.want) } if _, err := s.Stat(context.Background(), digest(payload)); !errors.Is(err, os.ErrNotExist) { t.Fatalf("published bad content: %v", err) } assertNoTemps(t, root) }) } } func TestLocalExistingAndConcurrentWritesNeverReplace(t *testing.T) { s, root := local(t) payload := []byte("immutable payload") hash := digest(payload) ctx := context.Background() var wg sync.WaitGroup errorsCh := make(chan error, 12) for range 12 { wg.Add(1) go func() { defer wg.Done() errorsCh <- s.PutIfAbsent(ctx, hash, int64(len(payload)), bytes.NewReader(payload)) }() } wg.Wait() close(errorsCh) for err := range errorsCh { if err != nil { t.Fatal(err) } } key, _ := Key(hash) filename := filepath.Join(root, filepath.FromSlash(key)) before, _ := os.Stat(filename) if err := s.PutIfAbsent(ctx, hash, int64(len(payload)), bytes.NewReader(payload)); err != nil { t.Fatal(err) } after, _ := os.Stat(filename) if !os.SameFile(before, after) { t.Fatal("existing inode replaced") } if err := os.WriteFile(filename, []byte("corrupt"), 0644); err != nil { t.Fatal(err) } if err := s.Verify(ctx, hash); !errors.Is(err, ErrHashMismatch) { t.Fatalf("verify=%v", err) } if err := s.PutIfAbsent(ctx, hash, int64(len(payload)), bytes.NewReader(payload)); !errors.Is(err, ErrHashMismatch) { t.Fatalf("put=%v", err) } content, _ := os.ReadFile(filename) if string(content) != "corrupt" { t.Fatal("corruption silently overwritten") } assertNoTemps(t, root) } func TestLocalCancellationAndReaderFailure(t *testing.T) { s, root := local(t) ctx, cancel := context.WithCancel(context.Background()) cancel() hash := digest([]byte("data")) if err := s.PutIfAbsent(ctx, hash, 4, strings.NewReader("data")); !errors.Is(err, context.Canceled) { t.Fatal(err) } if _, err := s.Open(ctx, hash); !errors.Is(err, context.Canceled) { t.Fatal(err) } failure := errors.New("source failed") if err := s.PutIfAbsent(context.Background(), hash, 4, failingReader{failure}); !errors.Is(err, failure) { t.Fatal(err) } if _, err := s.Stat(context.Background(), hash); !errors.Is(err, os.ErrNotExist) { t.Fatal(err) } if err := s.PutIfAbsent(context.Background(), hash, 4, strings.NewReader("data")); err != nil { t.Fatal(err) } ctx, cancel = context.WithCancel(context.Background()) r, err := s.Open(ctx, hash) if err != nil { t.Fatal(err) } defer r.Close() cancel() if _, err := r.Read(make([]byte, 1)); !errors.Is(err, context.Canceled) { t.Fatal(err) } if _, err := r.ReadAt(make([]byte, 1), 0); !errors.Is(err, context.Canceled) { t.Fatal(err) } assertNoTemps(t, root) } type failingReader struct{ err error } func (r failingReader) Read([]byte) (int, error) { return 0, r.err } func TestLocalStreamsWithBoundedReadsAndMidStreamCancellation(t *testing.T) { s, root := local(t) payload := bytes.Repeat([]byte("large document\x00"), 100000) hash := digest(payload) input := &boundedReader{reader: bytes.NewReader(payload)} if err := s.PutIfAbsent(context.Background(), hash, int64(len(payload)), input); err != nil { t.Fatal(err) } if input.reads < 2 { t.Fatal("expected multiple bounded reads") } // Cancellation while staging must never publish the final content address. s2, root2 := local(t) ctx, cancel := context.WithCancel(context.Background()) input = &boundedReader{reader: bytes.NewReader(payload), cancel: cancel} if err := s2.PutIfAbsent(ctx, hash, int64(len(payload)), input); !errors.Is(err, context.Canceled) { t.Fatalf("put=%v", err) } if _, err := s2.Stat(context.Background(), hash); !errors.Is(err, os.ErrNotExist) { t.Fatalf("published canceled upload: %v", err) } assertNoTemps(t, root) assertNoTemps(t, root2) } type boundedReader struct { reader io.Reader reads int cancel context.CancelFunc } func (r *boundedReader) Read(p []byte) (int, error) { if len(p) > 64<<10 { return 0, errors.New("unbounded input read") } r.reads++ n, err := r.reader.Read(p) if r.cancel != nil { r.cancel() } return n, err } func TestLocalKeysAndSymlinkEscape(t *testing.T) { for _, hash := range []string{"", "../../etc/passwd", strings.Repeat("g", 64), strings.Repeat("a", 63)} { if _, err := Key(hash); !errors.Is(err, ErrInvalidHash) { t.Fatal(err) } } hash := digest([]byte("data")) key, err := Key(" " + strings.ToUpper(hash) + " ") if err != nil || key != "sha256/"+hash[:2]+"/"+hash { t.Fatalf("key=%q err=%v", key, err) } s, root := local(t) outside := t.TempDir() if err := os.Symlink(outside, filepath.Join(root, "sha256")); err != nil { t.Skip(err) } if err := s.PutIfAbsent(context.Background(), hash, 4, strings.NewReader("data")); err == nil { t.Fatal("escaped storage root") } if _, err := s.Open(context.Background(), hash); err == nil { t.Fatal("opened escaped path") } entries, err := os.ReadDir(outside) if err != nil || len(entries) != 0 { t.Fatalf("outside modified: %v %v", entries, err) } } func assertNoTemps(t *testing.T, root string) { t.Helper() err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error { if err != nil { return err } if strings.HasPrefix(entry.Name(), ".document-") { t.Errorf("temporary file left: %s", path) } return nil }) if err != nil { t.Fatal(err) } }