PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.
Dart airdrop-alternativeclipboardclipboard-sharingclipboard-synccopy-pastecross-platformend-to-end-encryptionfile-syncfile-transferfluttergolanglinuxmacosnat-traversalp2pself-hostedtailscaleuniversal-clipboardwebrtcwindows
package sync
import (
"context"
"errors"
"os"
"path/filepath"
"runtime"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/baiyuze/pasteferry/client-core/internal/cache"
"github.com/baiyuze/pasteferry/client-core/internal/clipboard"
"github.com/baiyuze/pasteferry/client-core/internal/config"
"github.com/baiyuze/pasteferry/client-core/internal/pack"
"github.com/baiyuze/pasteferry/client-core/internal/store"
pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
)
type receiveClipboard struct {
mu sync.Mutex
revision int64
writes int
failure error
// content 是 Read 返回的内容;零值时是空的(大多数用例不关心读到的内容)
content clipboard.Content
}
func (c *receiveClipboard) Peek() (clipboard.Snapshot, error) {
c.mu.Lock()
defer c.mu.Unlock()
return clipboard.Snapshot{ChangeCount: c.revision}, nil
}
func (c *receiveClipboard) Read() (clipboard.Content, error) {
c.mu.Lock()
defer c.mu.Unlock()
return c.content, nil
}
func (c *receiveClipboard) Write(clipboard.Content) error {
c.mu.Lock()
defer c.mu.Unlock()
if c.failure != nil {
return c.failure
}
c.writes++
c.revision++
return nil
}
func (*receiveClipboard) Permission() clipboard.Permission { return clipboard.PermissionNotApplicable }
func (*receiveClipboard) OpenPermissionSettings() error { return nil }
func receiveFixture(t *testing.T, cb *receiveClipboard, cfg config.Config, timeout time.Duration) (*Engine, chan ReceiveEvent) {
t.Helper()
db, err := store.Open(filepath.Join(t.TempDir(), "test.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { db.Close() })
blobs, err := cache.New(t.TempDir())
if err != nil {
t.Fatal(err)
}
loop := clipboard.NewMainLoop()
ctx, cancel := context.WithCancel(context.Background())
done := make(chan struct{})
go func() { runtime.LockOSThread(); defer runtime.UnlockOSThread(); defer close(done); loop.Run(ctx) }()
t.Cleanup(func() { cancel(); <-done })
events := make(chan ReceiveEvent, 32)
e := New(Options{Store: db, Cache: blobs, Watcher: clipboard.NewWatcher(clipboard.WatcherOptions{Clipboard: cb, MainLoop: loop}),
LoadConfig: func() config.Config { return cfg }, Send: func(string, *pb.PeerMessage) error { return nil },
ReceiveStartTimeout: timeout, OnReceive: func(event ReceiveEvent) { events <- event },
})
t.Cleanup(e.Close)
return e, events
}
func offerLarge(e *Engine, id string, backlog bool) {
e.handleOffer(context.Background(), "peer", &pb.ClipOffer{ClipId: id, Kind: pb.ClipKind_CLIP_KIND_FILE,
TotalSize: (50 << 20) + 1, CreatedAtUnix: time.Now().Unix(), Items: []*pb.ClipItem{{Name: "large.bin"}}, Backlog: backlog})
}
func waitReceive(t *testing.T, events <-chan ReceiveEvent, stage ReceiveStage) ReceiveEvent {
t.Helper()
timer := time.NewTimer(3 * time.Second)
defer timer.Stop()
for {
select {
case event := <-events:
if event.Stage == stage {
return event
}
case <-timer.C:
t.Fatalf("no stage %v", stage)
return ReceiveEvent{}
}
}
}
func TestReceiveNotifiesOnlyNewLiveOffers(t *testing.T) {
cfg := config.Default()
cfg.SyncBacklog = true
e, events := receiveFixture(t, &receiveClipboard{}, cfg, 0)
offerLarge(e, "live", false)
offerLarge(e, "live", false)
offerLarge(e, "late", true)
offerLarge(e, "late", false)
if event := waitReceive(t, events, ReceivePending); event.Record.Id != "live" {
t.Fatal(event)
}
select {
case event := <-events:
t.Fatalf("duplicate/backlog notification: %v", event)
default:
}
// A sender replays an offer after it has been downloaded. Keep its cache.
if err := e.store.SetClipCache("live", "cached", 123); err != nil {
t.Fatal(err)
}
offerLarge(e, "live", false)
clip, _ := e.store.GetClip("live")
if clip.CachePath != "cached" || clip.Status != store.StatusReady {
t.Fatal("replay erased ready record")
}
}
func TestReceiveDeduplicatesAndTimesOutBeforeHeader(t *testing.T) {
e, events := receiveFixture(t, &receiveClipboard{}, config.Default(), time.Second)
offerLarge(e, "clip", false)
var sends atomic.Int32
e.send = func(string, *pb.PeerMessage) error { sends.Add(1); return nil }
var group sync.WaitGroup
for range 20 {
group.Go(func() {
if err := e.Fetch(context.Background(), "clip"); err != nil {
t.Error(err)
}
})
}
group.Wait()
if sends.Load() != 1 {
t.Fatalf("sent %d fetches", sends.Load())
}
waitReceive(t, events, ReceiveFailed)
clip, _ := e.store.GetClip("clip")
if clip.Status != store.StatusFailed {
t.Fatal(clip.Status)
}
if err := e.Fetch(context.Background(), "clip"); err != nil {
t.Fatal(err)
}
if sends.Load() != 2 {
t.Fatal("retry did not send")
}
}
func TestImmediateRejectionAndOfflineFailure(t *testing.T) {
for _, rejected := range []bool{false, true} {
t.Run(map[bool]string{false: "offline", true: "rejected"}[rejected], func(t *testing.T) {
e, events := receiveFixture(t, &receiveClipboard{}, config.Default(), 0)
offerLarge(e, "clip", false)
e.send = func(string, *pb.PeerMessage) error {
if rejected {
e.handleReject(&pb.FetchReject{ClipId: "clip", Reason: "source missing"})
return nil
}
return errors.New("offline")
}
_ = e.Fetch(context.Background(), "clip")
waitReceive(t, events, ReceiveFailed)
clip, _ := e.store.GetClip("clip")
if clip.Status != store.StatusFailed {
t.Fatal("fast failure overwritten by fetching")
}
})
}
}
func TestReceiveCompletionProtectsClipboardAndRetainsDownload(t *testing.T) {
for _, scenario := range []string{"unchanged", "new-copy", "write-error", "auto-off", "preview"} {
t.Run(scenario, func(t *testing.T) {
cb := &receiveClipboard{revision: 10}
cfg := config.Default()
if scenario == "auto-off" {
cfg.AutoApplyToClipboard = false
}
e, events := receiveFixture(t, cb, cfg, 0)
offerLarge(e, "clip", false)
if err := e.fetch(context.Background(), "clip", scenario == "preview"); err != nil {
t.Fatal(err)
}
cb.mu.Lock()
if scenario == "new-copy" {
cb.revision++
}
if scenario == "write-error" {
cb.failure = errors.New("locked")
}
cb.mu.Unlock()
rel, dir, err := e.cache.Dir("clip")
if err != nil {
t.Fatal(err)
}
path := filepath.Join(dir, "large.bin")
if err := os.WriteFile(path, []byte("downloaded"), 0600); err != nil {
t.Fatal(err)
}
if !e.finishReceive(&receiver{clipID: "clip", total: 10}, rel, []string{path}) {
t.Fatal("receive rejected")
}
clip, _ := e.store.GetClip("clip")
if clip.Status != store.StatusReady || clip.CachePath == "" {
t.Fatal("download was not retained")
}
cb.mu.Lock()
writes := cb.writes
cb.mu.Unlock()
if scenario == "preview" {
if writes != 0 {
t.Fatal("preview wrote clipboard")
}
return
}
event := waitReceive(t, events, ReceiveCompleted)
want := pb.ClipboardWriteOutcome_CLIPBOARD_WRITE_OUTCOME_PRESERVED
if scenario == "unchanged" {
want = pb.ClipboardWriteOutcome_CLIPBOARD_WRITE_OUTCOME_APPLIED
if writes != 1 {
t.Fatal(writes)
}
} else if writes != 0 {
t.Fatal("overwrote clipboard")
}
if scenario == "write-error" {
want = pb.ClipboardWriteOutcome_CLIPBOARD_WRITE_OUTCOME_FAILED
if clip.Error != "locked" {
t.Fatalf("clipboard failure was not retained in history: %q", clip.Error)
}
cb.mu.Lock()
cb.failure = nil
cb.mu.Unlock()
if err := e.ApplyToClipboard(context.Background(), clip.ID); err != nil {
t.Fatal(err)
}
retried, _ := e.store.GetClip(clip.ID)
if retried.Error != "" || retried.Status != store.StatusReady || retried.CachePath != clip.CachePath {
t.Fatal("clipboard retry did not clear the error and retain the download")
}
}
if event.Clipboard.Outcome != want {
t.Fatalf("outcome %v, want %v", event.Clipboard.Outcome, want)
}
})
}
}
func TestUnpackFailurePublishesTerminalStateAndRetryUsesFreshCache(t *testing.T) {
e, events := receiveFixture(t, &receiveClipboard{}, config.Default(), 0)
offerLarge(e, "clip", false)
if err := e.FetchForPreview(context.Background(), "clip"); err != nil {
t.Fatal(err)
}
e.handleHeader("peer", &pb.TransferHeader{ClipId: "clip", StreamId: "broken"})
e.mu.Lock()
r := e.incoming["broken"]
e.mu.Unlock()
_, _ = r.pipeW.Write([]byte("invalid zstd stream"))
r.pipeW.Close()
select {
case <-r.done:
case <-time.After(time.Second):
t.Fatal("unpacker hung")
}
clip, _ := e.store.GetClip("clip")
if clip.Status != store.StatusFailed {
t.Fatal(clip.Status)
}
e.mu.Lock()
quiet := e.quiet["clip"]
e.mu.Unlock()
if quiet {
t.Fatal("preview state leaked")
}
if err := e.Fetch(context.Background(), "clip"); err != nil {
t.Fatal(err)
}
e.handleHeader("peer", &pb.TransferHeader{ClipId: "clip", StreamId: "retry"})
e.mu.Lock()
r = e.incoming["retry"]
e.mu.Unlock()
path := filepath.Join(t.TempDir(), "large.bin")
if err := os.WriteFile(path, []byte("whole file"), 0600); err != nil {
t.Fatal(err)
}
if err := pack.Pack(r.pipeW, []string{path}); err != nil {
t.Fatal(err)
}
r.pipeW.Close()
waitReceive(t, events, ReceiveCompleted)
entries, err := e.cache.Entries(func() string { c, _ := e.store.GetClip("clip"); return c.CachePath }())
if err != nil || len(entries) != 1 {
t.Fatalf("cache: %v %v", entries, err)
}
}
// 对端自动推送来的图片和文件:桌面默认收完就写进剪贴板;Android 打开 MediaAutoApplyDisabled,
// 只进复制记录,用户点了「复制」才写(design/phone-sync.md 3.3.2 节第 6 条)
func TestPushedMediaAutoApply(t *testing.T) {
for _, disabled := range []bool{false, true} {
t.Run(map[bool]string{false: "desktop", true: "android"}[disabled], func(t *testing.T) {
cb := &receiveClipboard{revision: 10}
cfg := config.Default()
cfg.MediaAutoApplyDisabled = disabled
e, _ := receiveFixture(t, cb, cfg, 0)
e.handleOffer(context.Background(), "peer", &pb.ClipOffer{ClipId: "pushed", Kind: pb.ClipKind_CLIP_KIND_FILE,
TotalSize: 10, WillPush: true, CreatedAtUnix: time.Now().Unix(), Items: []*pb.ClipItem{{Name: "photo.jpg"}}})
rel, dir, err := e.cache.Dir("pushed")
if err != nil {
t.Fatal(err)
}
path := filepath.Join(dir, "photo.jpg")
if err := os.WriteFile(path, []byte("jpeg-bytes"), 0600); err != nil {
t.Fatal(err)
}
if !e.finishReceive(&receiver{clipID: "pushed", total: 10}, rel, []string{path}) {
t.Fatal("receive rejected")
}
cb.mu.Lock()
writes := cb.writes
cb.mu.Unlock()
if want := map[bool]int{false: 1, true: 0}[disabled]; writes != want {
t.Fatalf("推送完成后写了 %d 次剪贴板,应为 %d", writes, want)
}
if err := e.ApplyToClipboard(context.Background(), "pushed"); err != nil {
t.Fatal(err)
}
cb.mu.Lock()
defer cb.mu.Unlock()
if cb.writes != writes+1 {
t.Error("点了「复制」还是没写进剪贴板")
}
})
}
}