mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-08-19 21:56:54 +00:00
Chris LuandGitHub
0955d1aa08
Both helpers were exercised indirectly through MatchOriginalWrite / MatchPath; pinning them directly catches a regression at the helper level so a Match-test failure isn't the first signal of a broken filter. prefixMatches: empty prefix fast path; exact-prefix match; non-match rejection; path shorter than prefix. filterAllows: no-filter accepts any event; FilterSizeGreaterThan is strictly > (boundary value rejected); FilterSizeLessThan is strictly <; zero-size thresholds mean "not set" (must let any size through — a regression treating 0 as a real threshold would reject everything); required tag present accepts; missing key, empty tags map, wrong value, and missing-among-multiple all reject; size + tag filters are AND'd so either failing rejects.
322 lines
14 KiB
Go
322 lines
14 KiB
Go
package engine
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/seaweedfs/seaweedfs/weed/s3api/s3lifecycle"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// prefixMatches and filterAllows are pure helpers exercised indirectly
|
|
// through MatchOriginalWrite / MatchPath; pinning them directly catches
|
|
// a regression at the helper level so a Match-test failure isn't the
|
|
// first signal of a broken filter.
|
|
|
|
func TestPrefixMatches_EmptyPrefixAllowsEverything(t *testing.T) {
|
|
// An empty prefix on a rule means "match every key in the bucket"
|
|
// — the no-op fast path that skips the HasPrefix call.
|
|
assert.True(t, prefixMatches("", "logs/2026/01/01"))
|
|
assert.True(t, prefixMatches("", ""))
|
|
assert.True(t, prefixMatches("", "/"))
|
|
}
|
|
|
|
func TestPrefixMatches_HonorsExactPrefix(t *testing.T) {
|
|
assert.True(t, prefixMatches("logs/", "logs/2026/01/01"))
|
|
assert.True(t, prefixMatches("logs/", "logs/"))
|
|
}
|
|
|
|
func TestPrefixMatches_RejectsNonMatchingPath(t *testing.T) {
|
|
assert.False(t, prefixMatches("logs/", "metrics/2026/01/01"))
|
|
assert.False(t, prefixMatches("logs/", "log/2026/01/01")) // no trailing slash
|
|
}
|
|
|
|
func TestPrefixMatches_PathShorterThanPrefixIsReject(t *testing.T) {
|
|
// Path shorter than the rule prefix can't satisfy HasPrefix; the
|
|
// helper must say no rather than treat it as a partial match.
|
|
assert.False(t, prefixMatches("logs/2026/", "logs/"))
|
|
}
|
|
|
|
func TestFilterAllows_NoFiltersAcceptsAnything(t *testing.T) {
|
|
// A rule without any filter knobs allows every event regardless of
|
|
// size or tag map. Pins the documented "no filter" fast path.
|
|
rule := &s3lifecycle.Rule{}
|
|
assert.True(t, filterAllows(rule, &Event{Size: 0}))
|
|
assert.True(t, filterAllows(rule, &Event{Size: 1024}))
|
|
assert.True(t, filterAllows(rule, &Event{Tags: map[string]string{"a": "b"}}))
|
|
}
|
|
|
|
func TestFilterAllows_SizeGreaterThanGate(t *testing.T) {
|
|
// FilterSizeGreaterThan is "strictly greater"; events at or below
|
|
// the threshold are rejected.
|
|
rule := &s3lifecycle.Rule{FilterSizeGreaterThan: 1024}
|
|
assert.False(t, filterAllows(rule, &Event{Size: 1024}), "boundary value rejected (gate is >, not >=)")
|
|
assert.False(t, filterAllows(rule, &Event{Size: 100}))
|
|
assert.True(t, filterAllows(rule, &Event{Size: 1025}))
|
|
}
|
|
|
|
func TestFilterAllows_SizeLessThanGate(t *testing.T) {
|
|
// FilterSizeLessThan is "strictly less"; events at or above the
|
|
// threshold are rejected.
|
|
rule := &s3lifecycle.Rule{FilterSizeLessThan: 1024}
|
|
assert.False(t, filterAllows(rule, &Event{Size: 1024}), "boundary value rejected (gate is <, not <=)")
|
|
assert.False(t, filterAllows(rule, &Event{Size: 4096}))
|
|
assert.True(t, filterAllows(rule, &Event{Size: 1023}))
|
|
}
|
|
|
|
func TestFilterAllows_ZeroSizeFilterIsDisabled(t *testing.T) {
|
|
// FilterSizeGreaterThan/LessThan = 0 means "not set"; the filter
|
|
// must let any size through. A regression treating 0 as a real
|
|
// threshold would reject every event at or above 0 (i.e., all of
|
|
// them).
|
|
greater := &s3lifecycle.Rule{FilterSizeGreaterThan: 0}
|
|
less := &s3lifecycle.Rule{FilterSizeLessThan: 0}
|
|
for _, size := range []int64{0, 1, 1024, 1 << 30} {
|
|
assert.True(t, filterAllows(greater, &Event{Size: size}), "Gt 0 must allow size %d", size)
|
|
assert.True(t, filterAllows(less, &Event{Size: size}), "Lt 0 must allow size %d", size)
|
|
}
|
|
}
|
|
|
|
func TestFilterAllows_RequiredTagPresent(t *testing.T) {
|
|
// A FilterTags entry is "must equal"; the event's Tags map must
|
|
// have the same key with the same value.
|
|
rule := &s3lifecycle.Rule{FilterTags: map[string]string{"env": "prod"}}
|
|
assert.True(t, filterAllows(rule, &Event{Tags: map[string]string{"env": "prod"}}))
|
|
assert.True(t, filterAllows(rule, &Event{Tags: map[string]string{"env": "prod", "team": "a"}}))
|
|
}
|
|
|
|
func TestFilterAllows_RequiredTagMissingOrWrong(t *testing.T) {
|
|
rule := &s3lifecycle.Rule{FilterTags: map[string]string{"env": "prod"}}
|
|
assert.False(t, filterAllows(rule, &Event{}), "nil tags map rejected")
|
|
assert.False(t, filterAllows(rule, &Event{Tags: map[string]string{}}), "empty tags rejected")
|
|
assert.False(t, filterAllows(rule, &Event{Tags: map[string]string{"team": "a"}}), "different key rejected")
|
|
assert.False(t, filterAllows(rule, &Event{Tags: map[string]string{"env": "stage"}}), "wrong value rejected")
|
|
}
|
|
|
|
func TestFilterAllows_AllRequiredTagsMustMatch(t *testing.T) {
|
|
// Multiple FilterTags are AND'd; missing any one rejects.
|
|
rule := &s3lifecycle.Rule{FilterTags: map[string]string{"env": "prod", "team": "data"}}
|
|
assert.True(t, filterAllows(rule, &Event{Tags: map[string]string{"env": "prod", "team": "data"}}))
|
|
assert.False(t, filterAllows(rule, &Event{Tags: map[string]string{"env": "prod"}}), "missing one tag rejected")
|
|
assert.False(t, filterAllows(rule, &Event{Tags: map[string]string{"team": "data"}}), "missing other tag rejected")
|
|
assert.False(t, filterAllows(rule, &Event{Tags: map[string]string{"env": "prod", "team": "ops"}}), "wrong value on second tag rejected")
|
|
}
|
|
|
|
func TestFilterAllows_SizeAndTagAreANDed(t *testing.T) {
|
|
// A rule with both size and tag filters requires BOTH to pass;
|
|
// either one failing rejects the event.
|
|
rule := &s3lifecycle.Rule{
|
|
FilterSizeGreaterThan: 100,
|
|
FilterTags: map[string]string{"env": "prod"},
|
|
}
|
|
// Both pass.
|
|
assert.True(t, filterAllows(rule, &Event{Size: 200, Tags: map[string]string{"env": "prod"}}))
|
|
// Size fails.
|
|
assert.False(t, filterAllows(rule, &Event{Size: 50, Tags: map[string]string{"env": "prod"}}))
|
|
// Tag fails.
|
|
assert.False(t, filterAllows(rule, &Event{Size: 200, Tags: map[string]string{"env": "stage"}}))
|
|
}
|
|
|
|
// ---------- MatchOriginalWrite / MatchPredicateChange / MatchPath edge cases ----------
|
|
|
|
// helperSnapshot constructs a Snapshot via the engine's Compile path so
|
|
// the action map and bucket index are populated correctly. Tests below
|
|
// poke at the public Match functions rather than the internal maps.
|
|
func helperSnapshot(t *testing.T) (*Snapshot, *s3lifecycle.Rule, s3lifecycle.ActionKey) {
|
|
t.Helper()
|
|
rule := &s3lifecycle.Rule{
|
|
ID: "r",
|
|
Status: s3lifecycle.StatusEnabled,
|
|
Prefix: "logs/",
|
|
ExpirationDays: 7,
|
|
}
|
|
hash := s3lifecycle.RuleHash(rule)
|
|
prior := map[s3lifecycle.ActionKey]PriorState{}
|
|
for _, k := range s3lifecycle.RuleActionKinds(rule) {
|
|
prior[s3lifecycle.ActionKey{Bucket: "bk", RuleHash: hash, ActionKind: k}] = PriorState{
|
|
BootstrapComplete: true,
|
|
Mode: ModeEventDriven,
|
|
}
|
|
}
|
|
snap := New().Compile(
|
|
[]CompileInput{{Bucket: "bk", Rules: []*s3lifecycle.Rule{rule}}},
|
|
CompileOptions{PriorStates: prior},
|
|
)
|
|
key := s3lifecycle.ActionKey{Bucket: "bk", RuleHash: hash, ActionKind: s3lifecycle.ActionKindExpirationDays}
|
|
return snap, rule, key
|
|
}
|
|
|
|
func TestMatchOriginalWrite_NilEventReturnsNil(t *testing.T) {
|
|
// A nil event is treated as "no match"; the routing path should
|
|
// not panic on a defensive caller.
|
|
snap, _, _ := helperSnapshot(t)
|
|
assert.Nil(t, snap.MatchOriginalWrite(nil, 7*24*time.Hour))
|
|
}
|
|
|
|
func TestMatchOriginalWrite_WrongShapeReturnsNil(t *testing.T) {
|
|
// Only EventShapeOriginalWrite goes through this path; a
|
|
// PredicateChange event must not produce delay-group matches.
|
|
snap, _, _ := helperSnapshot(t)
|
|
got := snap.MatchOriginalWrite(&Event{Shape: EventShapePredicateChange, Bucket: "bk"}, 7*24*time.Hour)
|
|
assert.Nil(t, got)
|
|
}
|
|
|
|
func TestMatchOriginalWrite_DelayMismatchReturnsNil(t *testing.T) {
|
|
// The action is in the 7-day delay group; asking for a different
|
|
// delay must produce no matches.
|
|
snap, _, _ := helperSnapshot(t)
|
|
got := snap.MatchOriginalWrite(&Event{Shape: EventShapeOriginalWrite, Bucket: "bk", Path: "logs/x"}, 30*24*time.Hour)
|
|
assert.Empty(t, got)
|
|
}
|
|
|
|
func TestMatchPredicateChange_NilEventReturnsNil(t *testing.T) {
|
|
snap, _, _ := helperSnapshot(t)
|
|
assert.Nil(t, snap.MatchPredicateChange(nil))
|
|
}
|
|
|
|
func TestMatchPredicateChange_WrongShapeReturnsNil(t *testing.T) {
|
|
// EventShapeOriginalWrite events go through MatchOriginalWrite; a
|
|
// caller passing one to MatchPredicateChange gets nothing back.
|
|
snap, _, _ := helperSnapshot(t)
|
|
got := snap.MatchPredicateChange(&Event{Shape: EventShapeOriginalWrite, Bucket: "bk"})
|
|
assert.Nil(t, got)
|
|
}
|
|
|
|
func TestMatchPredicateChange_NoTagSensitiveActionsReturnsNil(t *testing.T) {
|
|
// The default helperSnapshot rule has no FilterTags, so it's not
|
|
// tag-sensitive — predicate changes must yield no matches.
|
|
snap, _, _ := helperSnapshot(t)
|
|
got := snap.MatchPredicateChange(&Event{Shape: EventShapePredicateChange, Bucket: "bk", Path: "logs/x"})
|
|
assert.Nil(t, got, "non-tag-sensitive snapshot returns nil from predicate change")
|
|
}
|
|
|
|
func TestMatchPath_UnknownBucketReturnsNil(t *testing.T) {
|
|
snap, _, _ := helperSnapshot(t)
|
|
got := snap.MatchPath("other-bucket", "logs/x", nil)
|
|
assert.Nil(t, got)
|
|
}
|
|
|
|
func TestMatchPath_NilEventStillAppliesPrefix(t *testing.T) {
|
|
// MatchPath with ev=nil applies prefix matching only; tags/size
|
|
// don't gate. Pinned because the bootstrap walker calls it that
|
|
// way.
|
|
snap, _, key := helperSnapshot(t)
|
|
matches := snap.MatchPath("bk", "logs/2026/01/01", nil)
|
|
assert.Contains(t, matches, key)
|
|
assert.Empty(t, snap.MatchPath("bk", "metrics/x", nil), "prefix mismatch must reject even with nil event")
|
|
}
|
|
|
|
func TestMatchPath_FilterRespectedWhenEventProvided(t *testing.T) {
|
|
// When the caller supplies an Event, both prefix and filter gates
|
|
// fire. A size-filter rule rejects an event below the threshold.
|
|
rule := &s3lifecycle.Rule{
|
|
ID: "r",
|
|
Status: s3lifecycle.StatusEnabled,
|
|
ExpirationDays: 7,
|
|
FilterSizeGreaterThan: 1000,
|
|
}
|
|
hash := s3lifecycle.RuleHash(rule)
|
|
prior := map[s3lifecycle.ActionKey]PriorState{}
|
|
for _, k := range s3lifecycle.RuleActionKinds(rule) {
|
|
prior[s3lifecycle.ActionKey{Bucket: "bk", RuleHash: hash, ActionKind: k}] = PriorState{
|
|
BootstrapComplete: true,
|
|
Mode: ModeEventDriven,
|
|
}
|
|
}
|
|
snap := New().Compile(
|
|
[]CompileInput{{Bucket: "bk", Rules: []*s3lifecycle.Rule{rule}}},
|
|
CompileOptions{PriorStates: prior},
|
|
)
|
|
belowThreshold := &Event{Size: 500}
|
|
aboveThreshold := &Event{Size: 2000}
|
|
assert.Empty(t, snap.MatchPath("bk", "x", belowThreshold), "size below threshold must reject")
|
|
assert.NotEmpty(t, snap.MatchPath("bk", "x", aboveThreshold), "size above threshold must allow")
|
|
}
|
|
|
|
// ---------- filterMatching direct coverage ----------
|
|
|
|
func TestFilterMatching_BucketScoping(t *testing.T) {
|
|
// Two buckets sharing identical rules: filterMatching must reject
|
|
// keys whose action.Bucket doesn't match ev.Bucket so a match in
|
|
// "alpha" doesn't bleed into "beta".
|
|
rule := &s3lifecycle.Rule{ID: "r", Status: s3lifecycle.StatusEnabled, ExpirationDays: 7}
|
|
hash := s3lifecycle.RuleHash(rule)
|
|
prior := map[s3lifecycle.ActionKey]PriorState{}
|
|
for _, b := range []string{"alpha", "beta"} {
|
|
for _, k := range s3lifecycle.RuleActionKinds(rule) {
|
|
prior[s3lifecycle.ActionKey{Bucket: b, RuleHash: hash, ActionKind: k}] = PriorState{
|
|
BootstrapComplete: true,
|
|
Mode: ModeEventDriven,
|
|
}
|
|
}
|
|
}
|
|
snap := New().Compile(
|
|
[]CompileInput{
|
|
{Bucket: "alpha", Rules: []*s3lifecycle.Rule{rule}},
|
|
{Bucket: "beta", Rules: []*s3lifecycle.Rule{rule}},
|
|
},
|
|
CompileOptions{PriorStates: prior},
|
|
)
|
|
got := snap.MatchOriginalWrite(&Event{
|
|
Shape: EventShapeOriginalWrite, Bucket: "alpha", Path: "x", Size: 1,
|
|
}, 7*24*time.Hour)
|
|
require.NotEmpty(t, got)
|
|
for _, k := range got {
|
|
assert.Equal(t, "alpha", k.Bucket, "match leaked across bucket")
|
|
}
|
|
}
|
|
|
|
func TestFilterMatching_AbortMPURequiresMPUInit(t *testing.T) {
|
|
// AbortMPU actions only fire on MPU-init events; a normal write to
|
|
// the same prefix must not trigger them.
|
|
rule := &s3lifecycle.Rule{
|
|
ID: "r",
|
|
Status: s3lifecycle.StatusEnabled,
|
|
AbortMPUDaysAfterInitiation: 7,
|
|
}
|
|
hash := s3lifecycle.RuleHash(rule)
|
|
abortKey := s3lifecycle.ActionKey{Bucket: "bk", RuleHash: hash, ActionKind: s3lifecycle.ActionKindAbortMPU}
|
|
prior := map[s3lifecycle.ActionKey]PriorState{
|
|
abortKey: {BootstrapComplete: true, Mode: ModeEventDriven},
|
|
}
|
|
snap := New().Compile(
|
|
[]CompileInput{{Bucket: "bk", Rules: []*s3lifecycle.Rule{rule}}},
|
|
CompileOptions{PriorStates: prior},
|
|
)
|
|
regular := &Event{Shape: EventShapeOriginalWrite, Bucket: "bk", Path: "x", IsMPUInit: false}
|
|
mpu := &Event{Shape: EventShapeOriginalWrite, Bucket: "bk", Path: "x", IsMPUInit: true}
|
|
assert.Empty(t, snap.MatchOriginalWrite(regular, 7*24*time.Hour), "regular write must not trigger AbortMPU")
|
|
assert.Contains(t, snap.MatchOriginalWrite(mpu, 7*24*time.Hour), abortKey, "MPU init must trigger AbortMPU")
|
|
}
|
|
|
|
func TestFilterMatching_ExpiredDeleteMarkerRequiresMarkerLatest(t *testing.T) {
|
|
// EXPIRED_DELETE_MARKER actions only fire when the event is both a
|
|
// delete marker AND the current latest version. A non-delete event
|
|
// or a noncurrent delete marker must not trigger.
|
|
rule := &s3lifecycle.Rule{
|
|
ID: "r",
|
|
Status: s3lifecycle.StatusEnabled,
|
|
ExpiredObjectDeleteMarker: true,
|
|
}
|
|
hash := s3lifecycle.RuleHash(rule)
|
|
markerKey := s3lifecycle.ActionKey{Bucket: "bk", RuleHash: hash, ActionKind: s3lifecycle.ActionKindExpiredDeleteMarker}
|
|
prior := map[s3lifecycle.ActionKey]PriorState{
|
|
markerKey: {BootstrapComplete: true, Mode: ModeEventDriven},
|
|
}
|
|
snap := New().Compile(
|
|
[]CompileInput{{Bucket: "bk", Rules: []*s3lifecycle.Rule{rule}}},
|
|
CompileOptions{PriorStates: prior},
|
|
)
|
|
// ExpiredDeleteMarker has MinTriggerAge=0; the action lives in the
|
|
// zero-duration delay group, so the dispatcher polls it on every
|
|
// tick.
|
|
delay := time.Duration(0)
|
|
notMarker := &Event{Shape: EventShapeOriginalWrite, Bucket: "bk", Path: "x", IsDeleteMarker: false, IsLatest: true}
|
|
notLatest := &Event{Shape: EventShapeOriginalWrite, Bucket: "bk", Path: "x", IsDeleteMarker: true, IsLatest: false}
|
|
bothTrue := &Event{Shape: EventShapeOriginalWrite, Bucket: "bk", Path: "x", IsDeleteMarker: true, IsLatest: true}
|
|
assert.Empty(t, snap.MatchOriginalWrite(notMarker, delay), "non-marker must not trigger")
|
|
assert.Empty(t, snap.MatchOriginalWrite(notLatest, delay), "noncurrent marker must not trigger")
|
|
assert.Contains(t, snap.MatchOriginalWrite(bothTrue, delay), markerKey, "marker that is also latest must trigger")
|
|
}
|