mirror of
https://github.com/runbear-io/beardrive.git
synced 2026-08-25 08:08:08 +02:00
9088127176
Adding a path to .bdriveignore only stopped future uploads: anything that synced before the rule existed stayed on the hub forever, with no command that removed it without deleting it from local disk on every device. Two engine changes make an explicit removal safe: - materialize's delete loop now consults the filter. A cached path absent from the replayed target that the rules exclude is dropped from tracking instead of unlinked — without this, any delete op for a now-filtered path wipes every peer's local copy, which is the data loss this issue is about. - the filter is reloaded mid-cycle from the pulled .bdriveignore, before materialize. A peer receiving the new rules and the deletes they justify in one batch would otherwise materialize with stale rules and the guard would never fire. materialize's write side is split into materializeFile so the ignore file can land on its own. On top of that, Session.Prune journals a delete for every path the replayed state still holds that the SHARED rules exclude — reconciling against the replay, not the local cache, because a path filtered out in an earlier cycle was dropped from the cache back then and is invisible locally today. The rules are deliberately ignore-only: the include scope lives in each device's own .bdrive/config.json and does not sync, so pruning against it would let a narrow-scope device delete a whole-folder teammate's files. Plain `bdrive sync` and the daemon are unchanged — pruning is never a side effect of editing .bdriveignore. Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
80 lines
2.1 KiB
Go
80 lines
2.1 KiB
Go
package main
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
func TestIgnoreRule(t *testing.T) {
|
|
root := t.TempDir()
|
|
if err := os.MkdirAll(filepath.Join(root, "notes", ".omc"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, "notes", "private.md"), []byte("x"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
for _, tc := range []struct{ arg, want string }{
|
|
{filepath.Join(root, "notes", ".omc"), "notes/.omc/"}, // a directory covers its contents
|
|
{filepath.Join(root, "notes", "private.md"), "notes/private.md"},
|
|
{filepath.Join(root, "gone.txt"), "gone.txt"}, // need not exist
|
|
} {
|
|
got, err := ignoreRule(root, tc.arg)
|
|
if err != nil {
|
|
t.Fatalf("ignoreRule(%s): %v", tc.arg, err)
|
|
}
|
|
if got != tc.want {
|
|
t.Errorf("ignoreRule(%s) = %q, want %q", tc.arg, got, tc.want)
|
|
}
|
|
}
|
|
|
|
// Outside the project, and the rules file itself, are errors.
|
|
for _, bad := range []string{filepath.Dir(root), root, filepath.Join(root, "..", "elsewhere"), filepath.Join(root, ".bdriveignore")} {
|
|
if got, err := ignoreRule(root, bad); err == nil {
|
|
t.Errorf("ignoreRule(%s) = %q, want an error", bad, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAppendIgnoreRules(t *testing.T) {
|
|
root := t.TempDir()
|
|
path := filepath.Join(root, ".bdriveignore")
|
|
if err := os.WriteFile(path, []byte("*.tmp"), 0o644); err != nil { // no trailing newline
|
|
t.Fatal(err)
|
|
}
|
|
|
|
added, err := appendIgnoreRules(root, []string{".omc/", "*.tmp", ".omc/"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(added) != 1 || !added[".omc/"] {
|
|
t.Fatalf("added = %v, want only .omc/", added)
|
|
}
|
|
if got := string(mustRead(t, path)); got != "*.tmp\n.omc/\n" {
|
|
t.Fatalf("file = %q", got)
|
|
}
|
|
|
|
// Idempotent: a second run writes nothing.
|
|
before := mustRead(t, path)
|
|
added, err = appendIgnoreRules(root, []string{".omc/"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(added) != 0 {
|
|
t.Fatalf("added = %v on a repeat run", added)
|
|
}
|
|
if string(mustRead(t, path)) != string(before) {
|
|
t.Fatal("repeat run rewrote the file")
|
|
}
|
|
}
|
|
|
|
func mustRead(t *testing.T, path string) []byte {
|
|
t.Helper()
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return b
|
|
}
|