Add end-to-end replication/restore testing

internal/locking_buffer.go

@@ -0,0 +1,145 @@
+package internal
+
+import (
+	"bytes"
+	"io"
+	"sync"
+)
+
+// LockingBuffer wraps a bytes.Buffer with a mutex.
+type LockingBuffer struct {
+	mu sync.Mutex
+	b  bytes.Buffer
+}
+
+func (b *LockingBuffer) Bytes() []byte {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	buf := b.b.Bytes()
+	other := make([]byte, len(buf))
+	copy(other, buf)
+	return other
+}
+
+func (b *LockingBuffer) Cap() int {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.Cap()
+}
+
+func (b *LockingBuffer) Grow(n int) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.b.Grow(n)
+}
+
+func (b *LockingBuffer) Len() int {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.Len()
+}
+
+func (b *LockingBuffer) Next(n int) []byte {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	buf := b.b.Next(n)
+	other := make([]byte, len(buf))
+	copy(other, buf)
+	return other
+}
+
+func (b *LockingBuffer) Read(p []byte) (n int, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.Read(p)
+}
+
+func (b *LockingBuffer) ReadByte() (byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.ReadByte()
+}
+
+func (b *LockingBuffer) ReadBytes(delim byte) (line []byte, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.ReadBytes(delim)
+}
+
+func (b *LockingBuffer) ReadFrom(r io.Reader) (n int64, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.ReadFrom(r)
+}
+
+func (b *LockingBuffer) ReadRune() (r rune, size int, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.ReadRune()
+}
+
+func (b *LockingBuffer) ReadString(delim byte) (line string, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.ReadString(delim)
+}
+
+func (b *LockingBuffer) Reset() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.b.Reset()
+}
+
+func (b *LockingBuffer) String() string {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.String()
+}
+
+func (b *LockingBuffer) Truncate(n int) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.b.Truncate(n)
+}
+
+func (b *LockingBuffer) UnreadByte() error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.UnreadByte()
+}
+
+func (b *LockingBuffer) UnreadRune() error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.UnreadRune()
+}
+
+func (b *LockingBuffer) Write(p []byte) (n int, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.Write(p)
+}
+
+func (b *LockingBuffer) WriteByte(c byte) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.WriteByte(c)
+}
+
+func (b *LockingBuffer) WriteRune(r rune) (n int, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.WriteRune(r)
+}
+
+func (b *LockingBuffer) WriteString(s string) (n int, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.WriteString(s)
+}
+
+func (b *LockingBuffer) WriteTo(w io.Writer) (n int64, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.b.WriteTo(w)
+}

internal/testingutil/testingutil.go

@@ -1,12 +1,13 @@
 package testingutil
 
 import (
+	"io"
 	"os"
 	"testing"
 )
 
-// MustReadFile reads all data from filename. Fail on error.
-func MustReadFile(tb testing.TB, filename string) []byte {
+// ReadFile reads all data from filename. Fail on error.
+func ReadFile(tb testing.TB, filename string) []byte {
 	tb.Helper()
 	b, err := os.ReadFile(filename)
 	if err != nil {
@@ -15,6 +16,26 @@ func MustReadFile(tb testing.TB, filename string) []byte {
 	return b
 }
 
+// CopyFile copies all data from src to dst. Fail on error.
+func CopyFile(tb testing.TB, src, dst string) {
+	tb.Helper()
+	r, err := os.Open(src)
+	if err != nil {
+		tb.Fatal(err)
+	}
+	defer r.Close()
+
+	w, err := os.Create(dst)
+	if err != nil {
+		tb.Fatal(err)
+	}
+	defer w.Close()
+
+	if _, err := io.Copy(w, r); err != nil {
+		tb.Fatal(err)
+	}
+}
+
 // Getpwd returns the working directory. Fail on error.
 func Getwd(tb testing.TB) string {
 	tb.Helper()