snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/s3api/s3lifecycle/lifecycletest/eventbuilder.go

@@ -0,0 +1,286 @@
+package lifecycletest
+
+import (
+	"sync"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3lifecycle"
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3lifecycle/reader"
+)
+
+// EventOption mutates a reader.Event during construction. Options compose
+// in order — later options override earlier ones if they touch the same
+// field, which lets a default+override pattern work without surprises.
+type EventOption func(*reader.Event)
+
+// WithSize sets the Size on whichever entry the event populates (NewEntry
+// for Create / Update, OldEntry for Delete). Constructors that build
+// both entries apply the size to NewEntry.
+func WithSize(bytes int64) EventOption {
+	return func(e *reader.Event) {
+		if e.NewEntry != nil && e.NewEntry.Attributes != nil {
+			e.NewEntry.Attributes.FileSize = uint64(bytes)
+		} else if e.OldEntry != nil && e.OldEntry.Attributes != nil {
+			e.OldEntry.Attributes.FileSize = uint64(bytes)
+		}
+	}
+}
+
+// WithModTime sets Mtime/MtimeNs on the populated entry.
+func WithModTime(t time.Time) EventOption {
+	return func(e *reader.Event) {
+		secs, nanos := t.Unix(), int32(t.Nanosecond())
+		if e.NewEntry != nil && e.NewEntry.Attributes != nil {
+			e.NewEntry.Attributes.Mtime = secs
+			e.NewEntry.Attributes.MtimeNs = nanos
+		} else if e.OldEntry != nil && e.OldEntry.Attributes != nil {
+			e.OldEntry.Attributes.Mtime = secs
+			e.OldEntry.Attributes.MtimeNs = nanos
+		}
+	}
+}
+
+// WithTtlSec sets the TTL on the populated entry. Used by tests that
+// exercise the lifecycle metadata-only delete path (TtlSec > 0 means
+// the volume reclaims chunks naturally).
+func WithTtlSec(ttl int32) EventOption {
+	return func(e *reader.Event) {
+		if e.NewEntry != nil && e.NewEntry.Attributes != nil {
+			e.NewEntry.Attributes.TtlSec = ttl
+		} else if e.OldEntry != nil && e.OldEntry.Attributes != nil {
+			e.OldEntry.Attributes.TtlSec = ttl
+		}
+	}
+}
+
+// WithVersionID stamps Seaweed-X-Amz-Version-Id on the populated entry's
+// Extended map. Used by versioning-aware router and dispatcher tests.
+func WithVersionID(versionID string) EventOption {
+	return func(e *reader.Event) {
+		var entry *filer_pb.Entry
+		if e.NewEntry != nil {
+			entry = e.NewEntry
+		} else if e.OldEntry != nil {
+			entry = e.OldEntry
+		}
+		if entry == nil {
+			return
+		}
+		if entry.Extended == nil {
+			entry.Extended = map[string][]byte{}
+		}
+		entry.Extended[s3_constants.ExtVersionIdKey] = []byte(versionID)
+	}
+}
+
+// WithExtended sets an arbitrary Extended key/value on the populated entry.
+func WithExtended(key string, value []byte) EventOption {
+	return func(e *reader.Event) {
+		var entry *filer_pb.Entry
+		if e.NewEntry != nil {
+			entry = e.NewEntry
+		} else if e.OldEntry != nil {
+			entry = e.OldEntry
+		}
+		if entry == nil {
+			return
+		}
+		if entry.Extended == nil {
+			entry.Extended = map[string][]byte{}
+		}
+		entry.Extended[key] = value
+	}
+}
+
+// WithChunks attaches FileChunks to the populated entry. Identity-CAS in
+// LifecycleDelete uses the head chunk's FID, so tests that exercise CAS
+// drift need at least one chunk. For Update events the chunks land on
+// NewEntry; use WithOldChunks to target the pre-update state.
+func WithChunks(chunks ...*filer_pb.FileChunk) EventOption {
+	return func(e *reader.Event) {
+		if e.NewEntry != nil {
+			e.NewEntry.Chunks = append(e.NewEntry.Chunks, chunks...)
+		} else if e.OldEntry != nil {
+			e.OldEntry.Chunks = append(e.OldEntry.Chunks, chunks...)
+		}
+	}
+}
+
+// WithOldSize sets FileSize on OldEntry specifically. Use on Update
+// events to configure the pre-update size (the WithSize default lands
+// on NewEntry when both are populated).
+func WithOldSize(bytes int64) EventOption {
+	return func(e *reader.Event) {
+		if e.OldEntry != nil && e.OldEntry.Attributes != nil {
+			e.OldEntry.Attributes.FileSize = uint64(bytes)
+		}
+	}
+}
+
+// WithOldChunks attaches FileChunks to OldEntry specifically. Use on
+// Update events to configure the pre-update chunk list (WithChunks
+// targets NewEntry when both are populated).
+func WithOldChunks(chunks ...*filer_pb.FileChunk) EventOption {
+	return func(e *reader.Event) {
+		if e.OldEntry != nil {
+			e.OldEntry.Chunks = append(e.OldEntry.Chunks, chunks...)
+		}
+	}
+}
+
+// WithOldModTime sets Mtime/MtimeNs on OldEntry specifically. Update
+// events whose pre-update mtime should differ from the event timestamp
+// use this to override the default.
+func WithOldModTime(t time.Time) EventOption {
+	return func(e *reader.Event) {
+		if e.OldEntry != nil && e.OldEntry.Attributes != nil {
+			e.OldEntry.Attributes.Mtime = t.Unix()
+			e.OldEntry.Attributes.MtimeNs = int32(t.Nanosecond())
+		}
+	}
+}
+
+// WithBootstrapVersion attaches a BootstrapVersion to the event.
+// Bootstrap-walk events use this to carry per-version state the live
+// meta-log doesn't see.
+func WithBootstrapVersion(bv *reader.BootstrapVersion) EventOption {
+	return func(e *reader.Event) { e.BootstrapVersion = bv }
+}
+
+// WithShardID overrides the computed ShardID. Most tests should leave
+// it as the s3lifecycle.ShardID default to mirror production routing.
+func WithShardID(shard int) EventOption {
+	return func(e *reader.Event) { e.ShardID = shard }
+}
+
+// NewCreate builds a Create event (NewEntry populated, OldEntry nil) at
+// the given timestamp. Bucket and key are required; everything else is
+// derived (Mtime defaults to ts, FileSize defaults to 0). Apply options
+// to override.
+func NewCreate(bucket, key string, ts time.Time, opts ...EventOption) *reader.Event {
+	e := &reader.Event{
+		TsNs:    ts.UnixNano(),
+		Bucket:  bucket,
+		Key:     key,
+		ShardID: s3lifecycle.ShardID(bucket, key),
+		NewEntry: &filer_pb.Entry{
+			Name: leafOf(key),
+			Attributes: &filer_pb.FuseAttributes{
+				Mtime:   ts.Unix(),
+				MtimeNs: int32(ts.Nanosecond()),
+			},
+		},
+	}
+	for _, o := range opts {
+		o(e)
+	}
+	return e
+}
+
+// NewDelete builds a Delete event (OldEntry populated, NewEntry nil).
+// Tests usually pass the entry the prior Create produced as a snapshot
+// of pre-delete state; this helper builds a minimal stand-in.
+func NewDelete(bucket, key string, ts time.Time, opts ...EventOption) *reader.Event {
+	e := &reader.Event{
+		TsNs:    ts.UnixNano(),
+		Bucket:  bucket,
+		Key:     key,
+		ShardID: s3lifecycle.ShardID(bucket, key),
+		OldEntry: &filer_pb.Entry{
+			Name: leafOf(key),
+			Attributes: &filer_pb.FuseAttributes{
+				Mtime:   ts.Unix(),
+				MtimeNs: int32(ts.Nanosecond()),
+			},
+		},
+	}
+	for _, o := range opts {
+		o(e)
+	}
+	return e
+}
+
+// NewUpdate builds an Update event (both OldEntry and NewEntry populated).
+// Same defaults as NewCreate; options apply to NewEntry per the rules in
+// each option's doc.
+func NewUpdate(bucket, key string, ts time.Time, opts ...EventOption) *reader.Event {
+	e := &reader.Event{
+		TsNs:    ts.UnixNano(),
+		Bucket:  bucket,
+		Key:     key,
+		ShardID: s3lifecycle.ShardID(bucket, key),
+		OldEntry: &filer_pb.Entry{
+			Name: leafOf(key),
+			Attributes: &filer_pb.FuseAttributes{
+				Mtime:   ts.Unix(),
+				MtimeNs: int32(ts.Nanosecond()),
+			},
+		},
+		NewEntry: &filer_pb.Entry{
+			Name: leafOf(key),
+			Attributes: &filer_pb.FuseAttributes{
+				Mtime:   ts.Unix(),
+				MtimeNs: int32(ts.Nanosecond()),
+			},
+		},
+	}
+	for _, o := range opts {
+		o(e)
+	}
+	return e
+}
+
+// MetaLogClock produces monotonically increasing timestamps for fixture
+// generation. Each call to Next advances by Step (default 1s) so tests
+// don't have to thread a counter through every helper invocation. Safe
+// for concurrent use.
+type MetaLogClock struct {
+	mu   sync.Mutex
+	now  time.Time
+	step time.Duration
+}
+
+// NewMetaLogClock returns a clock that ticks forward Step on every Next
+// call. Step defaults to 1s when zero.
+func NewMetaLogClock(start time.Time, step time.Duration) *MetaLogClock {
+	if step <= 0 {
+		step = time.Second
+	}
+	return &MetaLogClock{now: start, step: step}
+}
+
+// Next returns the current timestamp and advances by Step.
+func (c *MetaLogClock) Next() time.Time {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	t := c.now
+	c.now = c.now.Add(c.step)
+	return t
+}
+
+// Peek returns what Next() would return without advancing.
+func (c *MetaLogClock) Peek() time.Time {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.now
+}
+
+// leafOf returns the basename of a slash-separated key. Filer entries
+// store only the leaf name; tests that mirror production layout need
+// the same shape. Trailing slashes are stripped first so directory-key
+// fixtures (e.g. "folder/") get the slashless leaf "folder" — the
+// production directory-marker write path stores the name without the
+// trailing slash.
+func leafOf(key string) string {
+	for len(key) > 0 && key[len(key)-1] == '/' {
+		key = key[:len(key)-1]
+	}
+	for i := len(key) - 1; i >= 0; i-- {
+		if key[i] == '/' {
+			return key[i+1:]
+		}
+	}
+	return key
+}

weed/s3api/s3lifecycle/lifecycletest/eventbuilder_old_entry_test.go

@@ -0,0 +1,102 @@
+package lifecycletest
+
+import (
+	"testing"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3lifecycle/reader"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Coverage gap-fillers for the With* options' OldEntry-only branches
+// (NewEntry==nil, OldEntry populated — i.e. Delete events). The
+// existing eventbuilder_test.go covers Create events; these tests
+// exercise the alternate fall-through path on each option.
+
+func TestEventOption_WithModTime_AppliesToOldEntryOnDelete(t *testing.T) {
+	t0 := time.Unix(1700000000, 0)
+	override := time.Unix(1699000000, 250)
+	e := NewDelete("bk", "k", t0, WithModTime(override))
+	require.Nil(t, e.NewEntry)
+	require.NotNil(t, e.OldEntry)
+	assert.Equal(t, override.Unix(), e.OldEntry.Attributes.Mtime)
+	assert.Equal(t, int32(250), e.OldEntry.Attributes.MtimeNs)
+}
+
+func TestEventOption_WithTtlSec_AppliesToOldEntryOnDelete(t *testing.T) {
+	e := NewDelete("bk", "k", time.Unix(0, 0), WithTtlSec(7200))
+	require.NotNil(t, e.OldEntry)
+	assert.Equal(t, int32(7200), e.OldEntry.Attributes.TtlSec)
+}
+
+func TestEventOption_WithVersionID_AppliesToOldEntryOnDelete(t *testing.T) {
+	// VersionID-on-delete: the bootstrapper synthesizes deletes for
+	// noncurrent-version sweeps and needs the version-id stamp.
+	e := NewDelete("bk", "k", time.Unix(0, 0), WithVersionID("v_old"))
+	require.NotNil(t, e.OldEntry)
+	require.NotNil(t, e.OldEntry.Extended)
+	assert.Equal(t, []byte("v_old"), e.OldEntry.Extended[s3_constants.ExtVersionIdKey])
+}
+
+func TestEventOption_WithExtended_AppliesToOldEntryOnDelete(t *testing.T) {
+	e := NewDelete("bk", "k", time.Unix(0, 0), WithExtended("Custom-Tag", []byte("v")))
+	require.NotNil(t, e.OldEntry)
+	require.NotNil(t, e.OldEntry.Extended)
+	assert.Equal(t, []byte("v"), e.OldEntry.Extended["Custom-Tag"])
+}
+
+func TestEventOption_WithChunks_AppliesToOldEntryOnDelete(t *testing.T) {
+	c := &filer_pb.FileChunk{FileId: "1,old"}
+	e := NewDelete("bk", "k", time.Unix(0, 0), WithChunks(c))
+	require.NotNil(t, e.OldEntry)
+	require.Len(t, e.OldEntry.Chunks, 1)
+	assert.Equal(t, "1,old", e.OldEntry.Chunks[0].FileId)
+}
+
+func TestEventOption_WithBootstrapVersion(t *testing.T) {
+	// WithBootstrapVersion attaches a BootstrapVersion to the event;
+	// the bootstrap walker uses this for per-version state the live
+	// meta-log doesn't carry. Pin both create and delete shapes.
+	bv := &reader.BootstrapVersion{
+		LogicalKey:      "obj.txt",
+		VersionID:       "v_aaa",
+		IsLatest:        true,
+		IsDeleteMarker:  false,
+		NumVersions:     3,
+		NoncurrentIndex: 2,
+	}
+
+	create := NewCreate("bk", "obj.txt", time.Unix(0, 0), WithBootstrapVersion(bv))
+	require.Same(t, bv, create.BootstrapVersion)
+
+	del := NewDelete("bk", "obj.txt", time.Unix(0, 0), WithBootstrapVersion(bv))
+	require.Same(t, bv, del.BootstrapVersion)
+
+	update := NewUpdate("bk", "obj.txt", time.Unix(0, 0), WithBootstrapVersion(bv))
+	require.Same(t, bv, update.BootstrapVersion)
+}
+
+func TestEventOption_NoPanicOnEmptyEvent(t *testing.T) {
+	// Defense: an event with neither NewEntry nor OldEntry must not
+	// panic on any With* option, even though no constructor produces
+	// this shape today. Entry-targeting options fall through silently
+	// (NewEntry/OldEntry stay nil); WithBootstrapVersion targets the
+	// event itself, not an entry, so it does set BootstrapVersion —
+	// included here for panic safety.
+	e := &reader.Event{}
+	WithModTime(time.Unix(1, 0))(e)
+	WithTtlSec(60)(e)
+	WithVersionID("v")(e)
+	WithExtended("k", []byte("v"))(e)
+	WithChunks(&filer_pb.FileChunk{FileId: "x"})(e)
+	WithSize(1024)(e)
+	bv := &reader.BootstrapVersion{VersionID: "v"}
+	WithBootstrapVersion(bv)(e)
+
+	assert.Nil(t, e.NewEntry, "entry-targeting options must not allocate NewEntry")
+	assert.Nil(t, e.OldEntry, "entry-targeting options must not allocate OldEntry")
+	assert.Same(t, bv, e.BootstrapVersion, "WithBootstrapVersion sets the field regardless of entry state")
+}

weed/s3api/s3lifecycle/lifecycletest/eventbuilder_test.go

@@ -0,0 +1,240 @@
+package lifecycletest
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3lifecycle"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewCreate_PopulatesNewEntryOnly(t *testing.T) {
+	t0 := time.Unix(1700000000, 123)
+	e := NewCreate("bk", "obj.txt", t0)
+	require.NotNil(t, e.NewEntry)
+	assert.Nil(t, e.OldEntry)
+	assert.True(t, e.IsCreate())
+	assert.Equal(t, t0.UnixNano(), e.TsNs)
+	assert.Equal(t, "bk", e.Bucket)
+	assert.Equal(t, "obj.txt", e.Key)
+	assert.Equal(t, "obj.txt", e.NewEntry.Name)
+	// Mtime defaults to the event timestamp; tests that don't care can
+	// rely on this rather than threading time through every call.
+	assert.Equal(t, t0.Unix(), e.NewEntry.Attributes.Mtime)
+	assert.Equal(t, int32(t0.Nanosecond()), e.NewEntry.Attributes.MtimeNs)
+}
+
+func TestNewDelete_PopulatesOldEntryOnly(t *testing.T) {
+	t0 := time.Unix(1700000000, 0)
+	e := NewDelete("bk", "obj.txt", t0)
+	require.NotNil(t, e.OldEntry)
+	assert.Nil(t, e.NewEntry)
+	assert.True(t, e.IsDelete())
+	assert.Equal(t, "obj.txt", e.OldEntry.Name)
+}
+
+func TestNewUpdate_PopulatesBothEntries(t *testing.T) {
+	t0 := time.Unix(1700000000, 0)
+	e := NewUpdate("bk", "obj.txt", t0)
+	require.NotNil(t, e.OldEntry)
+	require.NotNil(t, e.NewEntry)
+	assert.False(t, e.IsCreate())
+	assert.False(t, e.IsDelete())
+	// OldEntry's Mtime defaults to the event ts so its mirror of pre-
+	// update state reflects the same wall-clock origin as NewEntry —
+	// a downstream router that compares mtimes won't see a synthetic
+	// 1970 epoch.
+	assert.Equal(t, t0.Unix(), e.OldEntry.Attributes.Mtime)
+	assert.Equal(t, t0.Unix(), e.NewEntry.Attributes.Mtime)
+}
+
+func TestNewCreate_NestedKeyUsesLeafName(t *testing.T) {
+	// Filer entries store only the leaf name; mirroring that in the
+	// fixture keeps router/dispatcher tests realistic.
+	e := NewCreate("bk", "a/b/c.txt", time.Unix(0, 0))
+	assert.Equal(t, "c.txt", e.NewEntry.Name)
+}
+
+func TestNewCreate_DirectoryKeyUsesSlashlessLeaf(t *testing.T) {
+	// Directory-marker objects (S3 keys ending in "/") store the leaf
+	// name without the trailing slash on the filer side. A pre-fix
+	// regression returned "" here.
+	e := NewCreate("bk", "folder/", time.Unix(0, 0))
+	assert.Equal(t, "folder", e.NewEntry.Name)
+
+	// Nested directory key strips both the trailing slash AND the
+	// parent prefix.
+	e2 := NewCreate("bk", "a/b/folder/", time.Unix(0, 0))
+	assert.Equal(t, "folder", e2.NewEntry.Name)
+
+	// Multiple trailing slashes collapse.
+	e3 := NewCreate("bk", "folder///", time.Unix(0, 0))
+	assert.Equal(t, "folder", e3.NewEntry.Name)
+}
+
+func TestNewCreate_ShardIDDerivedFromKey(t *testing.T) {
+	// ShardID matches s3lifecycle.ShardID(bucket, key) so the event
+	// routes through the same shard the production reader would
+	// classify it under.
+	e := NewCreate("bk", "obj.txt", time.Unix(0, 0))
+	assert.Equal(t, s3lifecycle.ShardID("bk", "obj.txt"), e.ShardID)
+}
+
+func TestEventOption_WithSize(t *testing.T) {
+	e := NewCreate("bk", "k", time.Unix(0, 0), WithSize(4096))
+	assert.Equal(t, uint64(4096), e.NewEntry.Attributes.FileSize)
+}
+
+func TestEventOption_WithSizeAppliesToOldEntryOnDelete(t *testing.T) {
+	// Delete events have OldEntry only; WithSize must apply there.
+	e := NewDelete("bk", "k", time.Unix(0, 0), WithSize(8192))
+	assert.Equal(t, uint64(8192), e.OldEntry.Attributes.FileSize)
+}
+
+func TestEventOption_WithModTimeOverridesDefault(t *testing.T) {
+	// Default Mtime is event ts; explicit WithModTime overrides.
+	t0 := time.Unix(1700000000, 0)
+	override := time.Unix(1700000123, 456)
+	e := NewCreate("bk", "k", t0, WithModTime(override))
+	assert.Equal(t, override.Unix(), e.NewEntry.Attributes.Mtime)
+	assert.Equal(t, int32(override.Nanosecond()), e.NewEntry.Attributes.MtimeNs)
+}
+
+func TestEventOption_WithTtlSec(t *testing.T) {
+	// WithTtlSec drives the lifecycle metadata-only delete path; the
+	// gate fires when the live entry's TtlSec > 0.
+	e := NewCreate("bk", "k", time.Unix(0, 0), WithTtlSec(300))
+	assert.Equal(t, int32(300), e.NewEntry.Attributes.TtlSec)
+}
+
+func TestEventOption_WithVersionID(t *testing.T) {
+	e := NewCreate("bk", "k", time.Unix(0, 0), WithVersionID("v_abc"))
+	assert.Equal(t, []byte("v_abc"), e.NewEntry.Extended[s3_constants.ExtVersionIdKey])
+}
+
+func TestEventOption_WithExtendedKeyValue(t *testing.T) {
+	e := NewCreate("bk", "k", time.Unix(0, 0), WithExtended("Custom-Tag", []byte("v1")))
+	assert.Equal(t, []byte("v1"), e.NewEntry.Extended["Custom-Tag"])
+}
+
+func TestEventOption_WithChunks(t *testing.T) {
+	c1 := &filer_pb.FileChunk{FileId: "1,abc"}
+	c2 := &filer_pb.FileChunk{FileId: "1,def"}
+	e := NewCreate("bk", "k", time.Unix(0, 0), WithChunks(c1, c2))
+	require.Len(t, e.NewEntry.Chunks, 2)
+	assert.Equal(t, "1,abc", e.NewEntry.Chunks[0].FileId)
+	assert.Equal(t, "1,def", e.NewEntry.Chunks[1].FileId)
+}
+
+func TestEventOption_WithShardIDOverrides(t *testing.T) {
+	e := NewCreate("bk", "obj.txt", time.Unix(0, 0), WithShardID(7))
+	assert.Equal(t, 7, e.ShardID)
+}
+
+func TestEventOption_WithOldSizeTargetsOldEntryOnUpdate(t *testing.T) {
+	// On Update events, WithSize lands on NewEntry; WithOldSize lets
+	// the caller configure pre-update state independently. Both options
+	// in a single call should produce distinct sizes on the two entries.
+	t0 := time.Unix(1700000000, 0)
+	e := NewUpdate("bk", "k", t0, WithSize(200), WithOldSize(100))
+	assert.Equal(t, uint64(200), e.NewEntry.Attributes.FileSize, "WithSize lands on NewEntry")
+	assert.Equal(t, uint64(100), e.OldEntry.Attributes.FileSize, "WithOldSize lands on OldEntry")
+}
+
+func TestEventOption_WithOldChunksTargetsOldEntryOnUpdate(t *testing.T) {
+	newChunk := &filer_pb.FileChunk{FileId: "1,new"}
+	oldChunk := &filer_pb.FileChunk{FileId: "1,old"}
+	t0 := time.Unix(1700000000, 0)
+	e := NewUpdate("bk", "k", t0, WithChunks(newChunk), WithOldChunks(oldChunk))
+	require.Len(t, e.NewEntry.Chunks, 1)
+	require.Len(t, e.OldEntry.Chunks, 1)
+	assert.Equal(t, "1,new", e.NewEntry.Chunks[0].FileId)
+	assert.Equal(t, "1,old", e.OldEntry.Chunks[0].FileId)
+}
+
+func TestEventOption_WithOldModTimeTargetsOldEntryOnUpdate(t *testing.T) {
+	// Pre-update mtime can lag the event timestamp; WithOldModTime lets
+	// a router test pin the noncurrent-clock origin.
+	t0 := time.Unix(1700000000, 0)
+	older := time.Unix(1699000000, 500)
+	e := NewUpdate("bk", "k", t0, WithOldModTime(older))
+	assert.Equal(t, older.Unix(), e.OldEntry.Attributes.Mtime)
+	assert.Equal(t, int32(500), e.OldEntry.Attributes.MtimeNs)
+	// NewEntry's mtime stays at the default ts.
+	assert.Equal(t, t0.Unix(), e.NewEntry.Attributes.Mtime)
+}
+
+func TestEventOption_WithOldOptionsAreNoOpsOnCreate(t *testing.T) {
+	// Create events have no OldEntry; the WithOld* options must not
+	// panic and must not leak fields into NewEntry.
+	t0 := time.Unix(1700000000, 0)
+	e := NewCreate("bk", "k", t0,
+		WithOldSize(999),
+		WithOldChunks(&filer_pb.FileChunk{FileId: "phantom"}),
+		WithOldModTime(time.Unix(1, 0)),
+	)
+	assert.Nil(t, e.OldEntry)
+	assert.Equal(t, uint64(0), e.NewEntry.Attributes.FileSize, "WithOldSize must not bleed to NewEntry")
+	assert.Empty(t, e.NewEntry.Chunks, "WithOldChunks must not bleed to NewEntry")
+	assert.Equal(t, t0.Unix(), e.NewEntry.Attributes.Mtime, "WithOldModTime must not bleed to NewEntry")
+}
+
+func TestEventOption_LaterOverridesEarlier(t *testing.T) {
+	// Apply order matters: later options win on the same field. Pins
+	// the documented ordering so tests can compose default+override
+	// patterns without surprises.
+	e := NewCreate("bk", "k", time.Unix(0, 0),
+		WithSize(100),
+		WithSize(200),
+	)
+	assert.Equal(t, uint64(200), e.NewEntry.Attributes.FileSize)
+}
+
+func TestMetaLogClock_DefaultStepIsOneSecond(t *testing.T) {
+	c := NewMetaLogClock(time.Unix(1000, 0), 0)
+	t1 := c.Next()
+	t2 := c.Next()
+	assert.Equal(t, time.Second, t2.Sub(t1))
+}
+
+func TestMetaLogClock_CustomStep(t *testing.T) {
+	c := NewMetaLogClock(time.Unix(1000, 0), 250*time.Millisecond)
+	t1 := c.Next()
+	t2 := c.Next()
+	assert.Equal(t, 250*time.Millisecond, t2.Sub(t1))
+}
+
+func TestMetaLogClock_PeekDoesNotAdvance(t *testing.T) {
+	c := NewMetaLogClock(time.Unix(1000, 0), time.Second)
+	first := c.Peek()
+	again := c.Peek()
+	assert.True(t, first.Equal(again), "Peek must not advance the clock")
+	advanced := c.Next()
+	assert.True(t, first.Equal(advanced), "Next returns what Peek returned")
+}
+
+func TestMetaLogClock_ConcurrentNextNoRace(t *testing.T) {
+	// Tests that produce events from many goroutines (e.g. fan-out
+	// fixtures) need the clock to serialize without deadlock or
+	// duplicate timestamps. -race catches a regression that drops
+	// the lock.
+	c := NewMetaLogClock(time.Unix(0, 0), time.Microsecond)
+	const N = 64
+	seen := sync.Map{}
+	var wg sync.WaitGroup
+	wg.Add(N)
+	for i := 0; i < N; i++ {
+		go func() {
+			defer wg.Done()
+			seen.Store(c.Next(), struct{}{})
+		}()
+	}
+	wg.Wait()
+	count := 0
+	seen.Range(func(_, _ any) bool { count++; return true })
+	assert.Equal(t, N, count, "every Next must produce a unique timestamp")
+}

weed/s3api/s3lifecycle/lifecycletest/fakeserver.go

@@ -0,0 +1,159 @@
+// Package lifecycletest provides reusable test doubles for the lifecycle
+// worker pipeline. The pieces here let component-level tests stand up the
+// gRPC boundary the worker dials at runtime without pulling in a real
+// S3ApiServer or filer.
+package lifecycletest
+
+import (
+	"context"
+	"sync"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/s3_lifecycle_pb"
+	"google.golang.org/protobuf/proto"
+)
+
+// Outcome is what the fake returns for a single LifecycleDelete call.
+// Code is required; Reason is echoed verbatim into LifecycleDeleteResponse.
+type Outcome struct {
+	Code   s3_lifecycle_pb.LifecycleDeleteOutcome
+	Reason string
+}
+
+// Done, NoopResolved, RetryLater, Blocked, SkippedObjectLock are
+// constructors for the common outcomes; tests can also build Outcome
+// values directly when they need a specific Reason.
+func Done() Outcome {
+	return Outcome{Code: s3_lifecycle_pb.LifecycleDeleteOutcome_DONE}
+}
+func NoopResolved(reason string) Outcome {
+	return Outcome{Code: s3_lifecycle_pb.LifecycleDeleteOutcome_NOOP_RESOLVED, Reason: reason}
+}
+func RetryLater(reason string) Outcome {
+	return Outcome{Code: s3_lifecycle_pb.LifecycleDeleteOutcome_RETRY_LATER, Reason: reason}
+}
+func Blocked(reason string) Outcome {
+	return Outcome{Code: s3_lifecycle_pb.LifecycleDeleteOutcome_BLOCKED, Reason: reason}
+}
+func SkippedObjectLock(reason string) Outcome {
+	return Outcome{Code: s3_lifecycle_pb.LifecycleDeleteOutcome_SKIPPED_OBJECT_LOCK, Reason: reason}
+}
+
+// FakeLifecycleServer implements s3_lifecycle_pb.SeaweedS3LifecycleInternalServer.
+// It returns per-key queued outcomes (FIFO) and falls back to Default when a
+// key has no queued entry. Every received request is recorded; tests assert
+// against Recorded() in arrival order.
+//
+// A non-nil Err short-circuits everything — LifecycleDelete returns (nil, Err)
+// immediately, before the per-key lookup or the request recording. Use it to
+// simulate transport failures.
+//
+// All methods are safe for concurrent use. Outcomes/Default may be set at
+// construction or via Queue/SetDefault between calls; mid-call mutation is
+// supported but ordering across that boundary is undefined.
+type FakeLifecycleServer struct {
+	s3_lifecycle_pb.UnimplementedSeaweedS3LifecycleInternalServer
+
+	mu       sync.Mutex
+	queues   map[requestKey][]Outcome
+	def      Outcome
+	err      error
+	received []*s3_lifecycle_pb.LifecycleDeleteRequest
+}
+
+// requestKey is the map key for queues. A struct rather than a delimited
+// string so bucket/object/versionId values containing "/" or "@" can't
+// collide.
+type requestKey struct {
+	bucket, objectPath, versionId string
+}
+
+// NewFakeLifecycleServer returns a server whose Default outcome is DONE.
+// Most tests want a different default; call SetDefault to change it.
+func NewFakeLifecycleServer() *FakeLifecycleServer {
+	return &FakeLifecycleServer{
+		queues: map[requestKey][]Outcome{},
+		def:    Done(),
+	}
+}
+
+// Queue appends an outcome to the FIFO for (bucket, objectPath, versionId).
+// Subsequent calls matching the same key return outcomes in the order they
+// were queued; once the queue is drained, Default applies.
+func (f *FakeLifecycleServer) Queue(bucket, objectPath, versionId string, outcome Outcome) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	k := key(bucket, objectPath, versionId)
+	f.queues[k] = append(f.queues[k], outcome)
+}
+
+// SetDefault sets the outcome returned when no per-key queue entry remains.
+func (f *FakeLifecycleServer) SetDefault(o Outcome) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.def = o
+}
+
+// SetError makes LifecycleDelete return (nil, err) on every call until
+// SetError(nil) clears it. The request is not recorded while Err is set —
+// transport-error tests should rely on the worker's own bookkeeping.
+func (f *FakeLifecycleServer) SetError(err error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.err = err
+}
+
+// Recorded returns a deep-copied snapshot of every request the server has
+// received (excluding calls that returned a transport error). Both the
+// slice and each element are independent of the fake's internal state, so
+// callers can mutate freely without affecting later Recorded() snapshots.
+func (f *FakeLifecycleServer) Recorded() []*s3_lifecycle_pb.LifecycleDeleteRequest {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	out := make([]*s3_lifecycle_pb.LifecycleDeleteRequest, len(f.received))
+	for i, r := range f.received {
+		out[i] = cloneRequest(r)
+	}
+	return out
+}
+
+// LifecycleDelete is the gRPC handler. It honors Err first, then dequeues
+// the per-key outcome, falling back to Default.
+func (f *FakeLifecycleServer) LifecycleDelete(ctx context.Context, req *s3_lifecycle_pb.LifecycleDeleteRequest) (*s3_lifecycle_pb.LifecycleDeleteResponse, error) {
+	f.mu.Lock()
+	if f.err != nil {
+		err := f.err
+		f.mu.Unlock()
+		return nil, err
+	}
+	// Record a deep copy so a caller mutating a Recorded() entry can't
+	// reach back into the fake's bookkeeping (and so subsequent calls'
+	// view of "what arrived" stays stable across assertions).
+	f.received = append(f.received, cloneRequest(req))
+	if req == nil {
+		out := f.def
+		f.mu.Unlock()
+		return &s3_lifecycle_pb.LifecycleDeleteResponse{Outcome: out.Code, Reason: out.Reason}, nil
+	}
+	k := key(req.Bucket, req.ObjectPath, req.VersionId)
+	q := f.queues[k]
+	var out Outcome
+	if len(q) > 0 {
+		out = q[0]
+		f.queues[k] = q[1:]
+	} else {
+		out = f.def
+	}
+	f.mu.Unlock()
+	return &s3_lifecycle_pb.LifecycleDeleteResponse{Outcome: out.Code, Reason: out.Reason}, nil
+}
+
+func key(bucket, objectPath, versionId string) requestKey {
+	return requestKey{bucket: bucket, objectPath: objectPath, versionId: versionId}
+}
+
+func cloneRequest(req *s3_lifecycle_pb.LifecycleDeleteRequest) *s3_lifecycle_pb.LifecycleDeleteRequest {
+	if req == nil {
+		return nil
+	}
+	return proto.Clone(req).(*s3_lifecycle_pb.LifecycleDeleteRequest)
+}

weed/s3api/s3lifecycle/lifecycletest/fakeserver_test.go

@@ -0,0 +1,217 @@
+package lifecycletest
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"testing"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/s3_lifecycle_pb"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFake_DefaultIsDoneOutOfTheBox(t *testing.T) {
+	// A test that doesn't queue anything should still get a non-error
+	// response so it can exercise the worker's happy path.
+	f := NewFakeLifecycleServer()
+	resp, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{
+		Bucket:     "b",
+		ObjectPath: "k",
+	})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	assert.Equal(t, s3_lifecycle_pb.LifecycleDeleteOutcome_DONE, resp.Outcome)
+	assert.Equal(t, "", resp.Reason)
+}
+
+func TestFake_QueuedOutcomesPopFIFO(t *testing.T) {
+	// Per-key queue is FIFO and one-shot per entry; after the queue
+	// drains, Default kicks in.
+	f := NewFakeLifecycleServer()
+	f.SetDefault(NoopResolved("nothing more queued"))
+	f.Queue("b", "k", "", RetryLater("first"))
+	f.Queue("b", "k", "", Blocked("second"))
+
+	got := []s3_lifecycle_pb.LifecycleDeleteOutcome{}
+	reasons := []string{}
+	for i := 0; i < 3; i++ {
+		resp, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{
+			Bucket: "b", ObjectPath: "k",
+		})
+		require.NoError(t, err)
+		got = append(got, resp.Outcome)
+		reasons = append(reasons, resp.Reason)
+	}
+	assert.Equal(t, []s3_lifecycle_pb.LifecycleDeleteOutcome{
+		s3_lifecycle_pb.LifecycleDeleteOutcome_RETRY_LATER,
+		s3_lifecycle_pb.LifecycleDeleteOutcome_BLOCKED,
+		s3_lifecycle_pb.LifecycleDeleteOutcome_NOOP_RESOLVED,
+	}, got)
+	assert.Equal(t, []string{"first", "second", "nothing more queued"}, reasons)
+}
+
+func TestFake_QueuesIsolatedByKey(t *testing.T) {
+	// Queues are partitioned by (bucket, objectPath, versionId); a queued
+	// outcome for one key must not bleed into another's lookup.
+	f := NewFakeLifecycleServer()
+	f.Queue("b", "a", "", Blocked("a-only"))
+	f.Queue("b", "b", "", RetryLater("b-only"))
+
+	respA, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "a"})
+	require.NoError(t, err)
+	assert.Equal(t, s3_lifecycle_pb.LifecycleDeleteOutcome_BLOCKED, respA.Outcome)
+
+	respB, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "b"})
+	require.NoError(t, err)
+	assert.Equal(t, s3_lifecycle_pb.LifecycleDeleteOutcome_RETRY_LATER, respB.Outcome)
+}
+
+func TestFake_VersionIDPartOfKey(t *testing.T) {
+	// Two requests for the same bucket/objectPath but different
+	// versionIds must address different queues.
+	f := NewFakeLifecycleServer()
+	f.Queue("b", "k", "v1", SkippedObjectLock("v1-locked"))
+	f.Queue("b", "k", "v2", Done())
+
+	respV1, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "k", VersionId: "v1"})
+	require.NoError(t, err)
+	respV2, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "k", VersionId: "v2"})
+	require.NoError(t, err)
+	assert.Equal(t, s3_lifecycle_pb.LifecycleDeleteOutcome_SKIPPED_OBJECT_LOCK, respV1.Outcome)
+	assert.Equal(t, s3_lifecycle_pb.LifecycleDeleteOutcome_DONE, respV2.Outcome)
+}
+
+func TestFake_KeyComponentsWithDelimitersDoNotCollide(t *testing.T) {
+	// String-concatenation keys would have made these two requests
+	// indistinguishable. The struct key keeps them separate.
+	f := NewFakeLifecycleServer()
+	f.Queue("b/k", "", "", Blocked("variant-a"))
+	f.Queue("b", "k", "", Done())
+
+	respA, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b/k", ObjectPath: ""})
+	require.NoError(t, err)
+	respB, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "k"})
+	require.NoError(t, err)
+	assert.Equal(t, s3_lifecycle_pb.LifecycleDeleteOutcome_BLOCKED, respA.Outcome)
+	assert.Equal(t, s3_lifecycle_pb.LifecycleDeleteOutcome_DONE, respB.Outcome)
+}
+
+func TestFake_ErrShortCircuitsBeforeRecording(t *testing.T) {
+	// Err makes LifecycleDelete return (nil, err) without recording the
+	// request — transport-error tests rely on the worker's own
+	// bookkeeping, not the fake's.
+	f := NewFakeLifecycleServer()
+	transportErr := errors.New("connection refused")
+	f.SetError(transportErr)
+
+	resp, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "k"})
+	assert.Nil(t, resp)
+	assert.ErrorIs(t, err, transportErr)
+	assert.Empty(t, f.Recorded(), "transport-error calls must not be recorded")
+
+	// Clearing the error returns the server to normal behavior.
+	f.SetError(nil)
+	resp2, err2 := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "k"})
+	require.NoError(t, err2)
+	require.NotNil(t, resp2)
+	assert.Len(t, f.Recorded(), 1)
+}
+
+func TestFake_RecordsRequestsInOrder(t *testing.T) {
+	// Recorded() preserves arrival order so tests can assert that
+	// dispatch happened in the expected sequence.
+	f := NewFakeLifecycleServer()
+	for _, key := range []string{"k1", "k2", "k3"} {
+		_, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{
+			Bucket: "b", ObjectPath: key,
+		})
+		require.NoError(t, err)
+	}
+	rec := f.Recorded()
+	require.Len(t, rec, 3)
+	assert.Equal(t, "k1", rec[0].ObjectPath)
+	assert.Equal(t, "k2", rec[1].ObjectPath)
+	assert.Equal(t, "k3", rec[2].ObjectPath)
+}
+
+func TestFake_RecordedIsSnapshot(t *testing.T) {
+	// Mutating the slice the caller got back must not bleed into the
+	// fake's internal state — otherwise a flaky test could corrupt
+	// bookkeeping for later assertions.
+	f := NewFakeLifecycleServer()
+	_, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "k"})
+	require.NoError(t, err)
+
+	snap := f.Recorded()
+	require.Len(t, snap, 1)
+	snap[0] = nil
+	again := f.Recorded()
+	require.Len(t, again, 1)
+	assert.NotNil(t, again[0], "internal record must survive caller-side mutation of the snapshot")
+}
+
+func TestFake_RecordedRequestsAreDeepCopies(t *testing.T) {
+	// A caller mutating fields on a Recorded() entry must not bleed
+	// into a later Recorded() snapshot. We also confirm the original
+	// request the caller passed in stays decoupled from internal state
+	// — proto.Clone runs at record time, so the caller's pointer is
+	// no longer the one the fake holds.
+	f := NewFakeLifecycleServer()
+	orig := &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "k", VersionId: "v"}
+	_, err := f.LifecycleDelete(context.Background(), orig)
+	require.NoError(t, err)
+
+	snap := f.Recorded()
+	require.Len(t, snap, 1)
+	snap[0].Bucket = "mutated-by-caller"
+	snap[0].ObjectPath = "also-mutated"
+
+	again := f.Recorded()
+	require.Len(t, again, 1)
+	assert.Equal(t, "b", again[0].Bucket, "field mutations on a snapshot must not bleed back")
+	assert.Equal(t, "k", again[0].ObjectPath)
+	assert.Equal(t, "v", again[0].VersionId)
+
+	// The caller's own pointer is independent of the fake's record.
+	orig.Bucket = "caller-mutates-original"
+	yetAgain := f.Recorded()
+	assert.Equal(t, "b", yetAgain[0].Bucket, "caller mutating the input pointer must not bleed in either")
+}
+
+func TestFake_NilRequestUsesDefault(t *testing.T) {
+	// gRPC won't deliver a nil request in practice, but defensive code
+	// in the fake should still produce a deterministic response so a
+	// regressing client doesn't panic the test process.
+	f := NewFakeLifecycleServer()
+	f.SetDefault(Blocked("no request"))
+	resp, err := f.LifecycleDelete(context.Background(), nil)
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	assert.Equal(t, s3_lifecycle_pb.LifecycleDeleteOutcome_BLOCKED, resp.Outcome)
+}
+
+func TestFake_ConcurrentCallsSerializeWithoutDeadlock(t *testing.T) {
+	// The dispatcher fans dispatch across many goroutines; the fake
+	// must not livelock or drop records under concurrent load. Capture
+	// each goroutine's err so a regression in concurrent paths surfaces
+	// instead of being masked by length-only assertions.
+	f := NewFakeLifecycleServer()
+	const N = 64
+	var wg sync.WaitGroup
+	errCh := make(chan error, N)
+	wg.Add(N)
+	for i := 0; i < N; i++ {
+		go func() {
+			defer wg.Done()
+			_, err := f.LifecycleDelete(context.Background(), &s3_lifecycle_pb.LifecycleDeleteRequest{Bucket: "b", ObjectPath: "k"})
+			errCh <- err
+		}()
+	}
+	wg.Wait()
+	close(errCh)
+	for err := range errCh {
+		require.NoError(t, err)
+	}
+	assert.Len(t, f.Recorded(), N)
+}