seaweedfs/weed/storage/blockvol/wal_writer_test.go

package blockvol

import (
	"os"
	"path/filepath"
	"testing"
)

func TestWALWriter(t *testing.T) {
	tests := []struct {
		name string
		run  func(t *testing.T)
	}{
		{name: "wal_writer_append_read_back", run: testWALWriterAppendReadBack},
		{name: "wal_writer_multiple_entries", run: testWALWriterMultipleEntries},
		{name: "wal_writer_wrap_around", run: testWALWriterWrapAround},
		{name: "wal_writer_full", run: testWALWriterFull},
		{name: "wal_writer_advance_tail_frees_space", run: testWALWriterAdvanceTailFreesSpace},
		{name: "wal_writer_fill_no_flusher", run: testWALWriterFillNoFlusher},
		// Phase 3 Task 1.5: WAL UsedFraction.
		{name: "wal_fraction_empty", run: testWALFractionEmpty},
		{name: "wal_fraction_after_writes", run: testWALFractionAfterWrites},
		{name: "wal_fraction_after_advance_tail", run: testWALFractionAfterAdvanceTail},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.run(t)
		})
	}
}

// createTestWAL creates a temp file with a WAL region at the given offset and size.
func createTestWAL(t *testing.T, walOffset, walSize uint64) (*os.File, func()) {
	t.Helper()
	dir := t.TempDir()
	path := filepath.Join(dir, "test.blockvol")
	fd, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
	if err != nil {
		t.Fatalf("create temp file: %v", err)
	}
	// Extend file to cover superblock + WAL region.
	totalSize := int64(walOffset + walSize)
	if err := fd.Truncate(totalSize); err != nil {
		fd.Close()
		t.Fatalf("truncate: %v", err)
	}
	return fd, func() { fd.Close() }
}

func testWALWriterAppendReadBack(t *testing.T) {
	walOffset := uint64(SuperblockSize)
	walSize := uint64(64 * 1024) // 64KB WAL
	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)

	data := []byte("hello WAL writer test!")
	// Pad to block size for a realistic entry.
	padded := make([]byte, 4096)
	copy(padded, data)

	entry := &WALEntry{
		LSN:    1,
		Type:   EntryTypeWrite,
		LBA:    0,
		Length: uint32(len(padded)),
		Data:   padded,
	}

	off, err := w.Append(entry)
	if err != nil {
		t.Fatalf("Append: %v", err)
	}
	if off != 0 {
		t.Errorf("first entry offset = %d, want 0", off)
	}

	// Read back from file and decode.
	buf := make([]byte, entry.EntrySize)
	if _, err := fd.ReadAt(buf, int64(walOffset+off)); err != nil {
		t.Fatalf("ReadAt: %v", err)
	}
	decoded, err := DecodeWALEntry(buf)
	if err != nil {
		t.Fatalf("DecodeWALEntry: %v", err)
	}
	if decoded.LSN != 1 {
		t.Errorf("decoded LSN = %d, want 1", decoded.LSN)
	}
}

func testWALWriterMultipleEntries(t *testing.T) {
	walOffset := uint64(SuperblockSize)
	walSize := uint64(64 * 1024)
	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)

	for i := uint64(1); i <= 5; i++ {
		entry := &WALEntry{
			LSN:    i,
			Type:   EntryTypeWrite,
			LBA:    i * 10,
			Length: 4096,
			Data:   make([]byte, 4096),
		}
		_, err := w.Append(entry)
		if err != nil {
			t.Fatalf("Append entry %d: %v", i, err)
		}
	}

	expectedHead := uint64(5 * (walEntryHeaderSize + 4096))
	if w.Head() != expectedHead {
		t.Errorf("head = %d, want %d", w.Head(), expectedHead)
	}
}

func testWALWriterWrapAround(t *testing.T) {
	walOffset := uint64(SuperblockSize)
	// Small WAL: 2.5x entry size. After writing 2 entries (head at 2*entrySize),
	// remaining (0.5*entrySize) is too small for entry 3, so it wraps to offset 0.
	// Tail must be advanced past both entries so there's free space after wrap.
	entrySize := uint64(walEntryHeaderSize + 4096)
	walSize := entrySize*2 + entrySize/2

	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)

	// Write 2 entries to fill most of the WAL.
	for i := uint64(1); i <= 2; i++ {
		entry := &WALEntry{LSN: i, Type: EntryTypeWrite, LBA: i, Length: 4096, Data: make([]byte, 4096)}
		if _, err := w.Append(entry); err != nil {
			t.Fatalf("Append entry %d: %v", i, err)
		}
	}

	// Advance tail past both entries (simulates flusher flushed them).
	w.AdvanceTail(entrySize * 2)

	// Write a 3rd entry -- should wrap around.
	entry3 := &WALEntry{LSN: 3, Type: EntryTypeWrite, LBA: 3, Length: 4096, Data: make([]byte, 4096)}
	off, err := w.Append(entry3)
	if err != nil {
		t.Fatalf("Append entry 3 (wrap): %v", err)
	}

	// After wrap, entry should be written at offset 0.
	if off != 0 {
		t.Errorf("wrapped entry offset = %d, want 0", off)
	}
}

func testWALWriterFull(t *testing.T) {
	walOffset := uint64(SuperblockSize)
	entrySize := uint64(walEntryHeaderSize + 4096)
	walSize := entrySize * 2 // fits exactly 2 entries

	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)

	// Fill the WAL with 2 entries (exact fit).
	for i := uint64(1); i <= 2; i++ {
		entry := &WALEntry{LSN: i, Type: EntryTypeWrite, LBA: i - 1, Length: 4096, Data: make([]byte, 4096)}
		if _, err := w.Append(entry); err != nil {
			t.Fatalf("Append entry %d: %v", i, err)
		}
	}

	// Third entry should fail -- tail hasn't moved, so no free space.
	entry3 := &WALEntry{LSN: 3, Type: EntryTypeWrite, LBA: 2, Length: 4096, Data: make([]byte, 4096)}
	_, err := w.Append(entry3)
	if err == nil {
		t.Fatal("expected ErrWALFull when WAL is full")
	}
}

func testWALWriterAdvanceTailFreesSpace(t *testing.T) {
	walOffset := uint64(SuperblockSize)
	entrySize := uint64(walEntryHeaderSize + 4096)
	walSize := entrySize * 2

	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)

	// Fill the WAL with 2 entries.
	for i := uint64(1); i <= 2; i++ {
		entry := &WALEntry{LSN: i, Type: EntryTypeWrite, LBA: i - 1, Length: 4096, Data: make([]byte, 4096)}
		if _, err := w.Append(entry); err != nil {
			t.Fatalf("Append entry %d: %v", i, err)
		}
	}

	// WAL is full. Third entry should fail.
	entry3 := &WALEntry{LSN: 3, Type: EntryTypeWrite, LBA: 2, Length: 4096, Data: make([]byte, 4096)}
	if _, err := w.Append(entry3); err == nil {
		t.Fatal("expected ErrWALFull before AdvanceTail")
	}

	// Advance tail to free space for 1 entry.
	w.AdvanceTail(entrySize)

	// Now entry 3 should succeed.
	if _, err := w.Append(entry3); err != nil {
		t.Fatalf("Append after AdvanceTail: %v", err)
	}
}

// --- Phase 3 Task 1.5: WAL UsedFraction tests ---

func testWALFractionEmpty(t *testing.T) {
	walOffset := uint64(SuperblockSize)
	walSize := uint64(64 * 1024)
	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)
	frac := w.UsedFraction()
	if frac != 0 {
		t.Errorf("UsedFraction on empty WAL = %f, want 0", frac)
	}
}

func testWALFractionAfterWrites(t *testing.T) {
	walOffset := uint64(SuperblockSize)
	walSize := uint64(64 * 1024)
	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)

	entry := &WALEntry{LSN: 1, Type: EntryTypeWrite, LBA: 0, Length: 4096, Data: make([]byte, 4096)}
	if _, err := w.Append(entry); err != nil {
		t.Fatalf("Append: %v", err)
	}

	frac := w.UsedFraction()
	if frac <= 0 || frac > 1 {
		t.Errorf("UsedFraction after write = %f, want (0, 1]", frac)
	}

	entrySize := float64(walEntryHeaderSize + 4096)
	expected := entrySize / float64(walSize)
	if diff := frac - expected; diff > 0.001 || diff < -0.001 {
		t.Errorf("UsedFraction = %f, want ~%f", frac, expected)
	}
}

func testWALFractionAfterAdvanceTail(t *testing.T) {
	walOffset := uint64(SuperblockSize)
	entrySize := uint64(walEntryHeaderSize + 4096)
	walSize := entrySize * 4
	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)

	// Write 2 entries.
	for i := uint64(1); i <= 2; i++ {
		entry := &WALEntry{LSN: i, Type: EntryTypeWrite, LBA: i, Length: 4096, Data: make([]byte, 4096)}
		if _, err := w.Append(entry); err != nil {
			t.Fatalf("Append: %v", err)
		}
	}

	fracBefore := w.UsedFraction()

	// Advance tail past first entry.
	w.AdvanceTail(entrySize)

	fracAfter := w.UsedFraction()
	if fracAfter >= fracBefore {
		t.Errorf("UsedFraction should decrease after AdvanceTail: before=%f, after=%f", fracBefore, fracAfter)
	}
}

func testWALWriterFillNoFlusher(t *testing.T) {
	// QA-001 regression: fill WAL without flusher (tail stays at 0).
	// After wrap, head=0 and tail=0 must NOT be treated as "empty".
	walOffset := uint64(SuperblockSize)
	entrySize := uint64(walEntryHeaderSize + 4096)
	walSize := entrySize * 10 // room for ~10 entries

	fd, cleanup := createTestWAL(t, walOffset, walSize)
	defer cleanup()

	w := NewWALWriter(fd, walOffset, walSize, 0, 0)

	// Fill the WAL completely -- tail never moves (no flusher).
	written := 0
	for i := uint64(1); ; i++ {
		entry := &WALEntry{LSN: i, Type: EntryTypeWrite, LBA: i, Length: 4096, Data: make([]byte, 4096)}
		_, err := w.Append(entry)
		if err != nil {
			// Should eventually get ErrWALFull, NOT wrap and overwrite.
			break
		}
		written++
		if written > 20 {
			t.Fatalf("wrote %d entries to a 10-entry WAL without ErrWALFull -- wrap overwrote live entries (QA-001)", written)
		}
	}

	if written == 0 {
		t.Fatal("should have written at least 1 entry")
	}
	t.Logf("correctly wrote %d entries then got ErrWALFull", written)
}