SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.
Go blob-storagecloud-drivedistributed-file-systemdistributed-storageerasure-codingfusehadoop-hdfshdfskuberneteslancelancedbobject-storageposixs3s3-storageseaweedfstiered-file-systemvector-search
package shell
import (
"bytes"
"strings"
"testing"
"time"
"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
"github.com/seaweedfs/seaweedfs/weed/storage/needle_map"
"github.com/seaweedfs/seaweedfs/weed/storage/types"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
)
// TestLiveDivergenceClassifiesOneSidedVsTwoSided verifies the divergence
// classifier used to turn check.disk's dead-end "cannot prove" no-op into an
// actionable verdict: one-sided (safe to re-copy) vs two-sided (split-brain).
func TestLiveDivergenceClassifiesOneSidedVsTwoSided(t *testing.T) {
// one-sided: source has an extra live needle; target has none unique.
src, tgt := needle_map.NewMemDb(), needle_map.NewMemDb()
defer src.Close()
defer tgt.Close()
if err := src.Set(types.NeedleId(1001), types.ToOffset(8), types.Size(123)); err != nil {
t.Fatalf("seed: %v", err)
}
if err := tgt.Set(types.NeedleId(1002), types.ToOffset(8), types.Size(45)); err != nil {
t.Fatalf("seed: %v", err)
}
// a shared live needle (should NOT count as divergence either way)
if err := src.Set(types.NeedleId(2000), types.ToOffset(8), types.Size(9)); err != nil {
t.Fatalf("seed shared: %v", err)
}
if err := tgt.Set(types.NeedleId(2000), types.ToOffset(8), types.Size(9)); err != nil {
t.Fatalf("seed shared: %v", err)
}
vcd := &volumeCheckDisk{writer: &bytes.Buffer{}, now: time.Now()}
sOnly, tOnly := vcd.liveDivergence(src, tgt)
if sOnly != 1 || tOnly != 1 {
t.Fatalf("one-sided: got sOnly=%d tOnly=%d, want 1/1 (1001 only on src, 1002 only on tgt)", sOnly, tOnly)
}
// strict subset: target has no unique needles -> tOnly must be 0.
subset, full := needle_map.NewMemDb(), needle_map.NewMemDb()
defer subset.Close()
defer full.Close()
if err := subset.Set(types.NeedleId(2000), types.ToOffset(8), types.Size(9)); err != nil {
t.Fatalf("seed: %v", err)
}
for _, id := range []types.NeedleId{2000, 2001, 2002} {
if err := full.Set(id, types.ToOffset(8), types.Size(9)); err != nil {
t.Fatalf("seed: %v", err)
}
}
aOnly, bOnly := vcd.liveDivergence(full, subset) // full->subset
if aOnly != 2 || bOnly != 0 {
t.Fatalf("subset: full is superset; want aOnly=2 (2001,2002) bOnly=0, got %d/%d", aOnly, bOnly)
}
// tombstones must be excluded: a deleted-only difference is not divergence.
delSrc, delTgt := needle_map.NewMemDb(), needle_map.NewMemDb()
defer delSrc.Close()
defer delTgt.Close()
if err := delSrc.Set(types.NeedleId(3000), types.ToOffset(8), types.Size(9)); err != nil {
t.Fatalf("seed: %v", err)
}
if err := delTgt.Set(types.NeedleId(3000), types.ToOffset(8), types.Size(9)); err != nil {
t.Fatalf("seed: %v", err)
}
// delete 3000 on the source as a real tombstone (negative size), leave it
// live on target. liveDivergence must skip the tombstone on the source and
// must not count 3000 on the target either, because Get still finds the
// tombstone entry — so the expected answer is 0/0, not 0/1.
if err := delSrc.Set(types.NeedleId(3000), types.ToOffset(8), types.Size(-9)); err != nil {
t.Fatalf("tombstone: %v", err)
}
x, y := vcd.liveDivergence(delSrc, delTgt)
if x != 0 || y != 0 {
t.Fatalf("tombstone: deleted needle on src should not count; want src-only=0, tgt-only=0, got %d/%d", x, y)
}
}
// TestReportDivergenceVerdictEmitsCopyCommand checks that a one-sided verdict
// prints the exact volume.copy command (complete -> lagging, dialable address),
// that the command never uses the logical node Id, that a vacuumed (or
// unproven) lagging replica gets the no-re-copy warning instead of a copy
// command, that a proven never-vacuumed lagging replica gets the safe copy
// command — including in unidirectional mode where only the target's revision
// is known — and that a two-sided verdict warns instead of auto-repairing.
func TestReportDivergenceVerdictEmitsCopyCommand(t *testing.T) {
// Id is a logical node identifier (NOT dialable); Address is the real
// ip:port the copy command must use.
src := &VolumeReplica{location: &location{"dc1", "r1", &master_pb.DataNodeInfo{Id: "node-1", Address: "10.0.0.1:8081"}}, info: &master_pb.VolumeInformationMessage{Id: 42}}
tgt := &VolumeReplica{location: &location{"dc1", "r2", &master_pb.DataNodeInfo{Id: "node-2", Address: "10.0.0.2:8083"}}, info: &master_pb.VolumeInformationMessage{Id: 42}}
// Case A: source has 5 unique live, target has none -> target is lagging.
// Revisions were not read (both known flags false), so no copy command.
var one bytes.Buffer
vcd := &volumeCheckDisk{writer: &one, now: time.Now()}
vcd.reportDivergenceVerdict(src, tgt, 5, 0, 0, 0, false, false, false)
got := one.String()
if !strings.Contains(got, "ONE-SIDED") {
t.Fatalf("expected ONE-SIDED verdict, got: %s", got)
}
if strings.Contains(got, "volume.copy") {
t.Fatalf("unproven lagging replica must not get a volume.copy command, got: %s", got)
}
if !strings.Contains(got, "Do NOT re-copy the whole volume") {
t.Fatalf("expected no-re-copy warning for unproven lagging replica, got: %s", got)
}
if !strings.Contains(got, "10.0.0.1:8081") || !strings.Contains(got, "10.0.0.2:8083") {
t.Fatalf("expected dialable addresses in verdict, got: %s", got)
}
if strings.Contains(got, "node-1") || strings.Contains(got, "node-2") {
t.Fatalf("verdict must use dialable Address, not logical node Id, got: %s", got)
}
if !strings.Contains(got, "5") {
t.Fatalf("expected missing-needle count 5, got: %s", got)
}
// Case B: source is lagging (target complete). The safe command must go
// complete -> lagging, i.e. -source <target> -target <source>.
var safeRev bytes.Buffer
vcdSafeRev := &volumeCheckDisk{writer: &safeRev, now: time.Now()}
vcdSafeRev.reportDivergenceVerdict(src, tgt, 0, 5, 0, 0, true, false, true)
gotRev := safeRev.String()
if !strings.Contains(gotRev, "volume.copy -source 10.0.0.2:8083 -target 10.0.0.1:8081 -volumeId 42") {
t.Fatalf("expected copy complete(10.0.0.2:8083)->lagging(10.0.0.1:8081), got: %s", gotRev)
}
if strings.Contains(gotRev, "volume.copy -source 10.0.0.1:8081 -target 10.0.0.2:8083") {
t.Fatalf("reversed direction: must not copy lagging source over complete target, got: %s", gotRev)
}
// Case C: target-lagging, unidirectional run (-resurrectMissingNeedles,
// not -bidirectional): sourceRevision was never read (srcRevKnown=false)
// but targetRevision was (tgtRevKnown=true) and is 0. The safe copy
// command must still be emitted — the false-warning regression.
var uni bytes.Buffer
vcdUni := &volumeCheckDisk{writer: &uni, now: time.Now()}
vcdUni.reportDivergenceVerdict(src, tgt, 5, 0, 0, 0, false, true, true)
gotUni := uni.String()
if !strings.Contains(gotUni, "ONE-SIDED") {
t.Fatalf("expected ONE-SIDED verdict, got: %s", gotUni)
}
if !strings.Contains(gotUni, "volume.copy -source 10.0.0.1:8081 -target 10.0.0.2:8083 -volumeId 42") {
t.Fatalf("unidirectional run with proven never-vacuumed target must emit the safe copy command, got: %s", gotUni)
}
if strings.Contains(gotUni, "Do NOT re-copy the whole volume") {
t.Fatalf("false warning: proven never-vacuumed lagging target must not get the no-re-copy warning, got: %s", gotUni)
}
// Case D: target-lagging but the lagging side was vacuumed (rev 17) ->
// no copy command, even though the proof was taken under the flag.
var vac bytes.Buffer
vcdVac := &volumeCheckDisk{writer: &vac, now: time.Now()}
vcdVac.reportDivergenceVerdict(src, tgt, 5, 0, 17, 17, true, true, true)
gotVac := vac.String()
if strings.Contains(gotVac, "volume.copy") {
t.Fatalf("vacuumed lagging replica must not get a volume.copy command, got: %s", gotVac)
}
if !strings.Contains(gotVac, "Do NOT re-copy the whole volume") {
t.Fatalf("expected no-re-copy warning for vacuumed lagging replica, got: %s", gotVac)
}
// Case E: two-sided, unproven (revisions not read) -> split-brain warning.
var two bytes.Buffer
vcd2 := &volumeCheckDisk{writer: &two, now: time.Now()}
vcd2.reportDivergenceVerdict(src, tgt, 3, 4, 0, 0, false, false, false)
got2 := two.String()
if !strings.Contains(got2, "TWO-SIDED") || !strings.Contains(got2, "split-brain") {
t.Fatalf("expected TWO-SIDED split-brain warning, got: %s", got2)
}
if strings.Contains(got2, "volume.copy") {
t.Fatalf("two-sided must not emit an auto volume.copy command, got: %s", got2)
}
// Case F: two-sided with BOTH replicas proven never-vacuumed under the
// resurrection flag (bidirectional simulation): mutually missing writes,
// not split-brain — the in-place -apply repair must be recommended and
// the split-brain warning must not appear.
var both bytes.Buffer
vcdBoth := &volumeCheckDisk{writer: &both, now: time.Now()}
vcdBoth.reportDivergenceVerdict(src, tgt, 3, 4, 0, 0, true, true, true)
gotBoth := both.String()
if !strings.Contains(gotBoth, "TWO-SIDED") {
t.Fatalf("expected TWO-SIDED verdict, got: %s", gotBoth)
}
if strings.Contains(gotBoth, "Do NOT auto-repair") {
t.Fatalf("proven never-vacuumed both sides must not get the split-brain warning, got: %s", gotBoth)
}
if !strings.Contains(gotBoth, "mutually missed writes") || !strings.Contains(gotBoth, "-apply") {
t.Fatalf("expected mutually-missed-writes verdict recommending -apply, got: %s", gotBoth)
}
if strings.Contains(gotBoth, "volume.copy") {
t.Fatalf("two-sided must not emit an auto volume.copy command, got: %s", gotBoth)
}
// Case G: custom gRPC ports must survive into the emitted addresses
// (ServerAddress.String() would drop the .grpcPort suffix).
srcGrpc := &VolumeReplica{location: &location{"dc1", "r1", &master_pb.DataNodeInfo{Id: "node-1", Address: "10.0.0.1:8081", GrpcPort: 18081}}, info: &master_pb.VolumeInformationMessage{Id: 42}}
tgtGrpc := &VolumeReplica{location: &location{"dc1", "r2", &master_pb.DataNodeInfo{Id: "node-2", Address: "10.0.0.2:8083", GrpcPort: 18083}}, info: &master_pb.VolumeInformationMessage{Id: 42}}
var grpc bytes.Buffer
vcdGrpc := &volumeCheckDisk{writer: &grpc, now: time.Now()}
vcdGrpc.reportDivergenceVerdict(srcGrpc, tgtGrpc, 5, 0, 0, 0, false, true, true)
gotGrpc := grpc.String()
if !strings.Contains(gotGrpc, "10.0.0.1:8081.18081") || !strings.Contains(gotGrpc, "10.0.0.2:8083.18083") {
t.Fatalf("custom gRPC port must be preserved in emitted addresses, got: %s", gotGrpc)
}
}
// TestDoVolumeCheckDiskDoesNotResurrectAbsentNeedle verifies that a needle
// present-and-live on the source but entirely absent on the target is NOT
// pushed back by default. Such an absence is indistinguishable from a needle
// that was deleted on the target and then vacuumed away, so resurrecting it
// would raise back data the operator deleted.
func TestDoVolumeCheckDiskDoesNotResurrectAbsentNeedle(t *testing.T) {
sourceDB, targetDB := needle_map.NewMemDb(), needle_map.NewMemDb()
defer sourceDB.Close()
defer targetDB.Close()
// Source has a live needle; target lacks it (e.g. deleted+vacuumed there).
if err := sourceDB.Set(types.NeedleId(1001), types.ToOffset(8), types.Size(123)); err != nil {
t.Fatalf("seed source: %v", err)
}
var buf bytes.Buffer
vcd := &volumeCheckDisk{
commandEnv: &CommandEnv{
option: &ShellOptions{
GrpcDialOption: grpc.WithTransportCredentials(insecure.NewCredentials()),
},
},
writer: &buf,
now: time.Now(),
applyChanges: false, // simulation: should not even read the source blob
nonRepairThreshold: 1,
// resurrectMissingNeedles left false: the safe default.
}
// Source points at an unreachable address: with the fix no blob read is
// attempted, so this is never contacted. The pre-fix code queues the
// absent needle and tries to read it from here, surfacing as an error.
source := &VolumeReplica{
location: &location{"dc1", "r1", &master_pb.DataNodeInfo{Id: "127.0.0.1:1"}},
info: &master_pb.VolumeInformationMessage{Id: 7},
}
target := &VolumeReplica{
location: &location{"dc1", "r2", &master_pb.DataNodeInfo{Id: "127.0.0.1:2"}},
info: &master_pb.VolumeInformationMessage{Id: 7},
}
// With the safe default, the absent needle is skipped before any network
// read, so this returns cleanly with no changes. On the pre-fix code the
// needle is queued and a source blob read is attempted, which has no server
// to reach and surfaces as an error (or a resurrection) instead.
hasChanges, err := vcd.doVolumeCheckDisk(sourceDB, targetDB, source, target, false, 0)
if err != nil {
t.Fatalf("doVolumeCheckDisk returned error: %v", err)
}
if hasChanges {
t.Fatalf("absent-on-target needle was resurrected; expected no changes")
}
}
// TestDoVolumeCheckDiskResurrectSkipsVacuumedTarget verifies that even with
// -resurrectMissingNeedles, an absent needle is not pushed into a replica that
// has been vacuumed (compaction revision > 0): the vacuum may have erased the
// tombstone of a legitimate delete, so the absence proves nothing.
func TestDoVolumeCheckDiskResurrectSkipsVacuumedTarget(t *testing.T) {
sourceDB, targetDB := needle_map.NewMemDb(), needle_map.NewMemDb()
defer sourceDB.Close()
defer targetDB.Close()
if err := sourceDB.Set(types.NeedleId(1001), types.ToOffset(8), types.Size(123)); err != nil {
t.Fatalf("seed source: %v", err)
}
var buf bytes.Buffer
vcd := &volumeCheckDisk{
commandEnv: &CommandEnv{
option: &ShellOptions{
GrpcDialOption: grpc.WithTransportCredentials(insecure.NewCredentials()),
},
},
writer: &buf,
now: time.Now(),
applyChanges: false,
nonRepairThreshold: 1,
resurrectMissingNeedles: true,
}
source := &VolumeReplica{
location: &location{"dc1", "r1", &master_pb.DataNodeInfo{Id: "127.0.0.1:1"}},
info: &master_pb.VolumeInformationMessage{Id: 7},
}
target := &VolumeReplica{
location: &location{"dc1", "r2", &master_pb.DataNodeInfo{Id: "127.0.0.1:2"}},
info: &master_pb.VolumeInformationMessage{Id: 7},
}
// resurrectAbsent=false with revision 2: the caller found the target vacuumed.
hasChanges, err := vcd.doVolumeCheckDisk(sourceDB, targetDB, source, target, false, 2)
if err != nil {
t.Fatalf("doVolumeCheckDisk returned error: %v", err)
}
if hasChanges {
t.Fatalf("absent needle was resurrected into a vacuumed replica; expected no changes")
}
if !bytes.Contains(buf.Bytes(), []byte("compaction revision 2")) {
t.Fatalf("expected skip message to mention the compaction revision, got: %s", buf.String())
}
}
// TestDoVolumeCheckDiskResurrectQueuesProvenMissingWrite verifies that with
// -resurrectMissingNeedles and a never-vacuumed target, the absent needle is
// treated as a missing write and queued for repair: the blob read against the
// unreachable source server is attempted, which is only possible if the needle
// passed the resurrection guard.
func TestDoVolumeCheckDiskResurrectQueuesProvenMissingWrite(t *testing.T) {
sourceDB, targetDB := needle_map.NewMemDb(), needle_map.NewMemDb()
defer sourceDB.Close()
defer targetDB.Close()
if err := sourceDB.Set(types.NeedleId(1001), types.ToOffset(8), types.Size(123)); err != nil {
t.Fatalf("seed source: %v", err)
}
var buf bytes.Buffer
vcd := &volumeCheckDisk{
commandEnv: &CommandEnv{
option: &ShellOptions{
GrpcDialOption: grpc.WithTransportCredentials(insecure.NewCredentials()),
},
},
writer: &buf,
now: time.Now(),
applyChanges: false,
nonRepairThreshold: 1,
resurrectMissingNeedles: true,
}
source := &VolumeReplica{
location: &location{"dc1", "r1", &master_pb.DataNodeInfo{Id: "127.0.0.1:1"}},
info: &master_pb.VolumeInformationMessage{Id: 7},
}
target := &VolumeReplica{
location: &location{"dc1", "r2", &master_pb.DataNodeInfo{Id: "127.0.0.1:2"}},
info: &master_pb.VolumeInformationMessage{Id: 7},
}
_, err := vcd.doVolumeCheckDisk(sourceDB, targetDB, source, target, true, 0)
if err == nil {
t.Fatalf("expected blob read against unreachable source, got nil error (needle did not pass the guard?)")
}
if !bytes.Contains(buf.Bytes(), []byte("missed 1")) {
t.Fatalf("expected the absent needle to be counted as missed, got: %s", buf.String())
}
}
type testCommandVolumeCheckDisk struct {
commandVolumeCheckDisk
}
type shouldSkipVolume struct {
name string
a VolumeReplica
b VolumeReplica
pulseTimeAtSecond int64
syncDeletions bool
shouldSkipVolume bool
}
func TestShouldSkipVolume(t *testing.T) {
var tests = []shouldSkipVolume{
{
name: "identical volumes should be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583300},
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583300},
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: true,
},
{
name: "different file counts should not be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1001,
DeleteCount: 100,
ModifiedAtSecond: 1696583300},
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583300},
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: false,
},
{
name: "different delete counts with syncDeletions enabled should not be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583300},
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 101,
ModifiedAtSecond: 1696583300},
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: false,
},
{
name: "different delete counts with syncDeletions disabled should be skipped if file counts match",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583300},
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 101,
ModifiedAtSecond: 1696583300},
},
pulseTimeAtSecond: 1696583400,
syncDeletions: false,
shouldSkipVolume: true,
},
// Edge case: Zero file and delete counts
{
name: "volumes with zero file counts should be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 0,
DeleteCount: 0,
ModifiedAtSecond: 1696583300},
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 0,
DeleteCount: 0,
ModifiedAtSecond: 1696583300},
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: true,
},
{
name: "volumes with zero and non-zero file counts should not be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1,
DeleteCount: 0,
ModifiedAtSecond: 1696583300},
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 0,
DeleteCount: 0,
ModifiedAtSecond: 1696583300},
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: false,
},
// Edge case: Recently modified volumes (after pulse time)
// Note: VolumePulsePeriod is 10 seconds, so pulse cutoff is now - 20 seconds
// When both volumes are recently modified, skip check to avoid false positives
{
name: "recently modified volumes with same file counts should be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583395}, // Modified 5 seconds ago
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583390}, // Modified 10 seconds ago
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: true, // Same counts = skip
},
{
name: "one volume modified before pulse cutoff with different file counts should not be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583370}, // Modified 30 seconds ago (before cutoff at -20s)
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 999,
DeleteCount: 100,
ModifiedAtSecond: 1696583370}, // Same modification time
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: false, // Different counts + old enough = needs sync
},
// Edge case: Different ModifiedAtSecond values, same file counts
{
name: "different modification times with same file counts should be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583300}, // 100 seconds before pulse time
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583350}, // 50 seconds before pulse time
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: true, // Same counts, both before cutoff
},
// Edge case: Very close to pulse time boundary
{
name: "volumes modified exactly at pulse cutoff boundary with different counts should not be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1001,
DeleteCount: 100,
ModifiedAtSecond: 1696583379}, // Just before cutoff (pulseTime - 21s)
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583379}, // Just before cutoff
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: false, // At boundary with different counts - needs sync
},
{
name: "volumes modified just after pulse cutoff boundary with same counts should be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583381}, // Just after cutoff (pulseTime - 19s)
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583381}, // Just after cutoff
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: true, // Same counts + recent = skip to avoid false positive
},
// Edge case: Large file count differences
{
name: "large file count difference with old modification time should not be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 10000,
DeleteCount: 100,
ModifiedAtSecond: 1696583300},
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 5000,
DeleteCount: 100,
ModifiedAtSecond: 1696583300},
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: false, // Large difference requires sync
},
// Edge case: Both volumes modified AFTER pulse cutoff time
// When ModifiedAtSecond >= pulseTimeAtSecond for both volumes with same counts,
// the condition (a.info.FileCount != b.info.FileCount) is false, so we skip
// without calling eqVolumeFileCount
{
name: "both volumes modified after pulse cutoff with same file counts should be skipped",
a: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583405}, // After pulse cutoff (1696583380)
},
b: VolumeReplica{nil, &master_pb.VolumeInformationMessage{
FileCount: 1000,
DeleteCount: 100,
ModifiedAtSecond: 1696583410}, // After pulse cutoff
},
pulseTimeAtSecond: 1696583400,
syncDeletions: true,
shouldSkipVolume: true, // Same counts = skip without calling eqVolumeFileCount
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var buf bytes.Buffer
vcd := &volumeCheckDisk{
writer: &buf,
now: time.Unix(tt.pulseTimeAtSecond, 0),
verbose: false, // reduce noise in tests
syncDeletions: tt.syncDeletions,
}
result, err := vcd.shouldSkipVolume(&tt.a, &tt.b)
if err != nil {
// In unit tests, we expect no errors from shouldSkipVolume
// since we're using test data without actual network calls
t.Errorf("shouldSkipVolume() returned unexpected error: %v", err)
return
}
if result != tt.shouldSkipVolume {
t.Errorf("shouldSkipVolume() = %v, want %v\nFileCount A=%d B=%d, DeleteCount A=%d B=%d",
result, tt.shouldSkipVolume,
tt.a.info.FileCount, tt.b.info.FileCount,
tt.a.info.DeleteCount, tt.b.info.DeleteCount)
}
})
}
}
// TestVolumeCheckDiskHelperMethods tests the helper methods on volumeCheckDisk
func TestVolumeCheckDiskHelperMethods(t *testing.T) {
var buf bytes.Buffer
vcd := &volumeCheckDisk{
writer: &buf,
verbose: true,
}
// Test write method
vcd.write("test %s", "message")
if buf.String() != "test message\n" {
t.Errorf("write() output = %q, want %q", buf.String(), "test message\n")
}
// Test writeVerbose with verbose=true
buf.Reset()
vcd.writeVerbose("verbose %d", 123)
if buf.String() != "verbose 123\n" {
t.Errorf("writeVerbose() with verbose=true output = %q, want %q", buf.String(), "verbose 123\n")
}
// Test writeVerbose with verbose=false
buf.Reset()
vcd.verbose = false
vcd.writeVerbose("should not appear")
if buf.String() != "" {
t.Errorf("writeVerbose() with verbose=false output = %q, want empty", buf.String())
}
}