Skip to content

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.

20.5 KB
Raw Blame
package peers

import (
	"context"
	"errors"
	"io"
	"log/slog"
	"net"
	"net/http/httptest"
	"os"
	"path/filepath"
	"slices"
	"strconv"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/baiyuze/pasteferry/client-core/internal/config"
	"github.com/baiyuze/pasteferry/client-core/internal/identity"
	"github.com/baiyuze/pasteferry/client-core/internal/store"
	"github.com/baiyuze/pasteferry/client-core/internal/transport/lan"
	"github.com/baiyuze/pasteferry/client-core/internal/transport/p2p"
	pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
	turnrelay "github.com/baiyuze/pasteferry/server/relay"
	"github.com/baiyuze/pasteferry/server/signal"
)

// device 是测试里的一台完整设备:真实的 peers.Manager、数据库和身份。
type device struct {
	name string
	m    *Manager

	mu       sync.Mutex
	cfg      config.Config
	sessions chan string // 对方兑换了我的码,界面上该弹出的确认
	messages chan *pb.PeerMessage
}

func newDevice(t *testing.T, name string, net *lan.MemoryNetwork, cfg config.Config) *device {
	return newDeviceWith(t, name, net, cfg, nil)
}

// newDeviceWith 与 newDevice 相同,另外可以在建 Manager 之前改一下 Options,
// 用来模拟没有隔空传送的手机端。
func newDeviceWith(t *testing.T, name string, net *lan.MemoryNetwork, cfg config.Config, tweak func(*Options)) *device {
	t.Helper()
	dir := t.TempDir()
	id, err := identity.LoadOrCreate(filepath.Join(dir, "identity.json"))
	if err != nil {
		t.Fatal(err)
	}
	db, err := store.Open(filepath.Join(dir, "pasteferry.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { db.Close() })

	cfg.DeviceName = name
	d := &device{
		name:     name,
		cfg:      cfg,
		sessions: make(chan string, 4),
		messages: make(chan *pb.PeerMessage, 16),
	}
	var disc lan.Discovery
	if net != nil {
		disc = net.Discovery()
	}
	opts := Options{
		Identity:   id,
		Store:      db,
		Logger:     testLogger(name),
		LoadConfig: d.config,
		StatePath:  filepath.Join(dir, "egress.json"),
		OnDeviceChanged: func(dev *pb.Device) {
			if dev.GetPairingSession() != "" {
				d.sessions <- dev.GetPairingSession()
			}
		},
		OnPeerMessage: func(_ string, msg *pb.PeerMessage) { d.messages <- msg },
		LANPort:       -1,
		LANDiscovery:  disc,
		SendFiles:     true,
	}
	if tweak != nil {
		tweak(&opts)
	}
	d.m, err = NewManager(opts)
	if err != nil {
		t.Fatal(err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	done := make(chan struct{})
	go func() { d.m.Run(ctx); close(done) }()
	t.Cleanup(func() {
		cancel()
		<-done
		d.m.P2P().Close()
	})
	return d
}

func (d *device) config() config.Config {
	d.mu.Lock()
	defer d.mu.Unlock()
	return d.cfg
}

func (d *device) id() string { return d.m.identity.DeviceID }

func lanOnly() config.Config {
	c := config.Default()
	c.SignalingURL = ""
	return c
}

func waitFor(t *testing.T, what string, cond func() bool) {
	t.Helper()
	waitForWithin(t, what, 15*time.Second, cond)
}

func waitForWithin(t *testing.T, what string, timeout time.Duration, cond func() bool) {
	t.Helper()
	deadline := time.Now().Add(timeout)
	for !cond() {
		if time.Now().After(deadline) {
			t.Fatalf("等不到:%s", what)
		}
		time.Sleep(50 * time.Millisecond)
	}
}

func waitLANUp(t *testing.T, ds ...*device) {
	t.Helper()
	for _, d := range ds {
		waitFor(t, d.name+" 的局域网通道开启", d.m.LANEnabled)
	}
}

// pairDevices 走一遍完整的配对:a 显示码,b 输入码(和地址),双方核对后确认。
func pairDevices(t *testing.T, a, b *device, address string) {
	t.Helper()
	ctx := context.Background()
	code, _, addrs, err := a.m.CreatePairingCode(ctx)
	if err != nil {
		t.Fatalf("生成配对码: %v", err)
	}
	if len(code) != 6 {
		t.Fatalf("配对码格式不对: %q", code)
	}
	_ = addrs

	peer, session, err := b.m.RedeemPairingCode(ctx, strings.ToLower(code), address)
	if err != nil {
		t.Fatalf("兑换配对码: %v", err)
	}
	if peer.GetId() != a.id() {
		t.Fatalf("找到的不是 a: %v", peer)
	}

	var aSession string
	select {
	case aSession = <-a.sessions:
	case <-time.After(5 * time.Second):
		t.Fatal("显示码的一方没收到配对请求")
	}
	if err := a.m.ConfirmPairing(ctx, aSession, true); err != nil {
		t.Fatal(err)
	}
	if err := b.m.ConfirmPairing(ctx, session, true); err != nil {
		t.Fatal(err)
	}
}

func waitDirect(t *testing.T, a, b *device) {
	t.Helper()
	waitFor(t, "P2P 直连", func() bool {
		return a.m.P2P().State(b.id()) == p2p.StateDirect && b.m.P2P().State(a.id()) == p2p.StateDirect
	})
}

func sendAndExpect(t *testing.T, from, to *device, clipID string) {
	t.Helper()
	msg := &pb.PeerMessage{Payload: &pb.PeerMessage_Fetch{Fetch: &pb.PeerFetch{ClipId: clipID}}}
	if err := from.m.P2P().Send(to.id(), msg); err != nil {
		t.Fatal(err)
	}
	deadline := time.After(5 * time.Second)
	for {
		select {
		case got := <-to.messages:
			if got.GetFetch().GetClipId() == clipID {
				return
			}
		case <-deadline:
			t.Fatalf("%s 没收到 %s 发的消息", to.name, from.name)
		}
	}
}

// 没有服务器:同一网络里的两台设备配对、直连、互发消息。
func TestPairAndConnectWithoutServer(t *testing.T) {
	net := lan.NewMemoryNetwork()
	a, b := newDevice(t, "a", net, lanOnly()), newDevice(t, "b", net, lanOnly())
	waitLANUp(t, a, b)

	pairDevices(t, a, b, "")
	waitDirect(t, a, b)
	sendAndExpect(t, a, b, "clip-1")
	sendAndExpect(t, b, a, "clip-2")

	_, peers := a.m.Devices()
	if len(peers) != 1 || !peers[0].GetOnline() {
		t.Fatalf("配对后对方应当显示在线: %v", peers)
	}

	// 解除配对后连接要断开,对方也不再显示
	if err := a.m.Unpair(context.Background(), b.id()); err != nil {
		t.Fatal(err)
	}
	waitFor(t, "解除配对后断开连接", func() bool { return a.m.P2P().State(b.id()) == p2p.StateOffline })
	if _, peers := a.m.Devices(); len(peers) != 0 {
		t.Fatalf("解除配对后不该还有设备: %v", peers)
	}
}

// 不在同一网段:mDNS 找不到对方,输入对方显示的地址配对;之后靠地址簿重新找到对方。
func TestPairByAddressAcrossSubnets(t *testing.T) {
	a := newDevice(t, "a", lan.NewMemoryNetwork(), lanOnly())
	b := newDevice(t, "b", lan.NewMemoryNetwork(), lanOnly())
	waitLANUp(t, a, b)

	ctx := context.Background()
	code, _, _, err := a.m.CreatePairingCode(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if _, _, err := b.m.RedeemPairingCode(ctx, code, ""); !errors.Is(err, lan.ErrNotFound) {
		t.Fatalf("不输地址应当找不到,得到 %v", err)
	}
	// 上一次兑换没碰到 a,码还有效;这次带上地址
	a.m.lan.ClosePairing()
	addr := "127.0.0.1:" + strconv.Itoa(a.m.lan.Port())
	pairDevices(t, a, b, addr)
	waitDirect(t, a, b)
	sendAndExpect(t, b, a, "clip-3")
}

// 关掉局域网,只用服务器:原来的配对路径不受影响。
func TestServerOnlyPairingStillWorks(t *testing.T) {
	// Hosted Windows runners may block UDP routed through their own NIC.
	// Match the transport relay fixtures: listen on the wildcard socket while
	// advertising loopback, so Windows can route both allocation directions.
	// Keep the real P2P/message assertions.
	socket, err := net.ListenPacket("udp4", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	port := socket.LocalAddr().(*net.UDPAddr).Port
	_ = socket.Close()
	turnServer, err := turnrelay.New(turnrelay.Options{PublicIP: "127.0.0.1", Port: port, Secret: "local-pairing-test", CredentialTTL: time.Hour})
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = turnServer.Close() })
	srv := httptest.NewServer(signal.NewServer(signal.Options{ICEServers: func(id string) []*pb.IceServer {
		credential := turnServer.Issue(id)
		return []*pb.IceServer{{Urls: credential.URLs, Username: credential.Username, Credential: credential.Password}}
	}}))
	t.Cleanup(srv.Close)
	cfg := config.Default()
	cfg.SignalingURL = "ws" + strings.TrimPrefix(srv.URL, "http") + "/signal"
	cfg.LANDisabled = true
	// This fixture has a local signaling server and no external STUN service.
	// Public probe reachability must not decide whether local pairing passes.
	cfg.OnlyOwnSTUN = true

	a, b := newDevice(t, "a", nil, cfg), newDevice(t, "b", nil, cfg)
	waitFor(t, "连上服务器", func() bool { return a.m.Connected() && b.m.Connected() })
	if a.m.LANEnabled() {
		t.Fatal("关掉局域网后不该开启局域网通道")
	}

	pairDevices(t, a, b, "")
	// 托管的 CI 机器上第一次 ICE 偶尔连不上(经网卡的 UDP 可能被拦),之后由每 10 秒一次的巡检
	// 重新连接(第一次尝试最长 30 秒才放弃)。这里验证的是只靠服务器配对最终能连通,所以等足一轮重连
	waitForWithin(t, "P2P 连通", 60*time.Second, func() bool { return connected(a.m.P2P().State(b.id())) })
	sendAndExpect(t, a, b, "clip-4")

	// 服务器上不存在的码:立即报错,而不是干等
	start := time.Now()
	if _, _, err := b.m.RedeemPairingCode(context.Background(), "ZZZZZZ", ""); !errors.Is(err, ErrCodeRejected) {
		t.Fatalf("错码应当被服务器拒绝,得到 %v", err)
	}
	if time.Since(start) > 5*time.Second {
		t.Errorf("服务器拒绝后应当马上返回,花了 %v", time.Since(start))
	}
}

// 局域网和服务器都开着:同一个码两边都开放,用掉一次就失效。
func TestCodeUsableOnceAcrossChannels(t *testing.T) {
	srv := httptest.NewServer(signal.NewServer(signal.Options{}))
	t.Cleanup(srv.Close)
	cfg := config.Default()
	cfg.SignalingURL = "ws" + strings.TrimPrefix(srv.URL, "http") + "/signal"

	net := lan.NewMemoryNetwork()
	a, b, c := newDevice(t, "a", net, cfg), newDevice(t, "b", net, cfg), newDevice(t, "c", net, cfg)
	waitFor(t, "连上服务器", func() bool { return a.m.Connected() && b.m.Connected() && c.m.Connected() })
	waitLANUp(t, a, b, c)

	ctx := context.Background()
	code, _, _, err := a.m.CreatePairingCode(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if _, _, err := b.m.RedeemPairingCode(ctx, code, ""); err != nil {
		t.Fatal(err)
	}
	<-a.sessions
	// c 拿同一个码:局域网里已撤下,服务器那边的兑换也会被 a 忽略
	_, _, _ = c.m.RedeemPairingCode(ctx, code, "")
	select {
	case s := <-a.sessions:
		t.Fatalf("同一个码不该被用第二次,又收到配对请求 %s", s)
	case <-time.After(time.Second):
	}
}

// 搜索附近设备:两台都打开窗口,a 点了 b,b 弹出确认(重复的请求只弹一次),
// 双方核对后确认、直连;之后 b 在 a 的列表里显示为已配对。
func TestPairNearby(t *testing.T) {
	net := lan.NewMemoryNetwork()
	a, b := newDevice(t, "办公室的 Mac", net, lanOnly()), newDevice(t, "b", net, lanOnly())
	waitLANUp(t, a, b)
	hideA, hideB := a.m.ShowNearby(), b.m.ShowNearby()
	defer hideA()
	defer hideB()

	var target *pb.NearbyDevice
	waitFor(t, "a 看到附近的 b", func() bool {
		list := a.m.Nearby()
		if len(list) == 1 {
			target = list[0]
		}
		return target != nil
	})
	if target.GetName() != "b" || target.GetPaired() {
		t.Fatalf("附近的设备信息不对: %v", target)
	}
	waitFor(t, "b 看到附近的 a", func() bool {
		list := b.m.Nearby()
		return len(list) == 1 && list[0].GetName() == "办公室的 Mac"
	})

	ctx := context.Background()
	peer, session, err := a.m.PairNearby(ctx, target.GetId())
	if err != nil {
		t.Fatalf("向附近的设备发起配对: %v", err)
	}
	if peer.GetId() != b.id() || peer.GetName() != "b" {
		t.Fatalf("配对的不是 b: %v", peer)
	}
	var bSession string
	select {
	case bSession = <-b.sessions:
	case <-time.After(5 * time.Second):
		t.Fatal("b 没收到配对请求")
	}
	// a 没收到回复时会重发;同一台设备的请求只弹一次确认
	if _, _, err := a.m.PairNearby(ctx, target.GetId()); err != nil {
		t.Fatalf("再点一次: %v", err)
	}
	select {
	case s := <-b.sessions:
		t.Fatalf("同一台设备的请求不该再弹一次确认: %s", s)
	case <-time.After(300 * time.Millisecond):
	}

	if err := b.m.ConfirmPairing(ctx, bSession, true); err != nil {
		t.Fatal(err)
	}
	if err := a.m.ConfirmPairing(ctx, session, true); err != nil {
		t.Fatal(err)
	}
	waitDirect(t, a, b)
	sendAndExpect(t, a, b, "clip-nearby")
	waitFor(t, "b 在 a 的列表里显示为已配对", func() bool {
		list := a.m.Nearby()
		return len(list) == 1 && list[0].GetPaired()
	})
}

// 对方没打开窗口时看不到它,也配不上。
func TestNearbyNeedsBothWindows(t *testing.T) {
	net := lan.NewMemoryNetwork()
	a, b := newDevice(t, "a", net, lanOnly()), newDevice(t, "b", net, lanOnly())
	waitLANUp(t, a, b)
	defer a.m.ShowNearby()()

	time.Sleep(500 * time.Millisecond)
	if list := a.m.Nearby(); len(list) != 0 {
		t.Fatalf("b 没打开窗口,不该出现在附近: %v", list)
	}
	if _, _, err := a.m.PairNearby(context.Background(), "pasteferry-000000000000"); !errors.Is(err, lan.ErrNotFound) {
		t.Fatalf("应当找不到,得到 %v", err)
	}
	if _, peers := b.m.Devices(); len(peers) != 0 {
		t.Fatalf("b 不该多出设备: %v", peers)
	}
}

// 两端同版本:功能声明迟到或丢失后,刷新声明恢复接收能力与用户开关。
func TestRefreshPeerFeatures(t *testing.T) {
	network := lan.NewMemoryNetwork()
	a, b := newDevice(t, "a", network, lanOnly()), newDevice(t, "b", network, lanOnly())
	waitLANUp(t, a, b)
	pairDevices(t, a, b, "")
	waitDirect(t, a, b)
	waitFor(t, "双方收到功能声明", func() bool {
		sa, _ := a.m.SendFilesSupport(b.id())
		sb, _ := b.m.SendFilesSupport(a.id())
		return sa && sb
	})
	a.m.mu.Lock()
	delete(a.m.features, b.id()) // 模拟没有收到对方的首条声明
	a.m.mu.Unlock()
	b.m.BroadcastFeatures()
	waitFor(t, "刷新恢复接收能力", func() bool { ok, _ := a.m.SendFilesSupport(b.id()); return ok })
	b.mu.Lock()
	b.cfg.ReceiveDisabled = true
	b.mu.Unlock()
	b.m.BroadcastFeatures()
	waitFor(t, "刷新接收开关", func() bool { ok, off := a.m.SendFilesSupport(b.id()); return ok && off })
	if !a.m.HasFeature(b.id(), FeatureSendFilesTCP) {
		t.Fatal("快速通道能力丢失")
	}
}

// 没有隔空传送的客户端(手机端)不能声明 send_files,否则对端会把文件发给它、
// 然后一直等不到应答。见 Options.SendFiles。
func TestFeaturesWithoutSendFiles(t *testing.T) {
	phone := newDeviceWith(t, "phone", nil, lanOnly(), func(o *Options) { o.SendFiles = false })
	msg := phone.m.featuresFor(RoleSelf)
	if f := msg.GetFeatures().GetFeatures(); slices.Contains(f, FeatureSendFiles) ||
		slices.Contains(f, FeatureSendFilesOff) || slices.Contains(f, FeatureSendFilesTCP) ||
		slices.Contains(f, FeatureSendFilesRecv) || slices.Contains(f, FeatureSendAsk) {
		t.Fatalf("没有隔空传送却声明了文件相关能力: %v", f)
	}

	desktop := newDevice(t, "pc", nil, lanOnly())
	msg = desktop.m.featuresFor(RoleSelf)
	if f := msg.GetFeatures().GetFeatures(); !slices.Contains(f, FeatureSendFiles) ||
		!slices.Contains(f, FeatureSendFilesTCP) || !slices.Contains(f, FeatureSendFilesRecv) {
		t.Fatalf("桌面端应声明隔空传送: %v", f)
	}
}

// 2.7.4 及更早的安卓包会照抄桌面端的声明:手机平台只声明 send_files_v1 不算数,
// 要额外声明 send_files_recv_v1(真的实现了隔空传送)才认。
func TestOldAndroidPackageDoesNotReceiveFiles(t *testing.T) {
	d := newDevice(t, "pc", nil, lanOnly())
	const phoneID = "phonephonephonephonephonephoneph"
	advertised := featureSet([]string{FeatureSendFiles, FeatureSendFilesTCP, FeatureSendAsk})

	d.m.mu.Lock()
	d.m.known[phoneID] = store.Device{ID: phoneID, Name: "Pixel 8", Platform: "android"}
	d.m.features[phoneID] = advertised
	d.m.mu.Unlock()

	dev := peerDevice(t, d, phoneID)
	if dev.GetReceivesFiles() {
		t.Fatal("手机平台只声明 send_files_v1 时,不能让界面以为它能收文件")
	}
	if ok, _ := d.m.SendFilesSupport(phoneID); ok {
		t.Fatal("手机平台只声明 send_files_v1 时,不能允许发文件")
	}

	// 以后手机端真的实现了隔空传送,声明 send_files_recv_v1 就恢复
	d.m.mu.Lock()
	d.m.features[phoneID] = featureSet([]string{FeatureSendFiles, FeatureSendFilesTCP, FeatureSendFilesRecv, FeatureSendAsk})
	d.m.mu.Unlock()
	if dev = peerDevice(t, d, phoneID); !dev.GetReceivesFiles() {
		t.Fatal("声明了 send_files_recv_v1 的手机应该能收文件")
	}
	if ok, _ := d.m.SendFilesSupport(phoneID); !ok {
		t.Fatal("声明了 send_files_recv_v1 的手机应该允许发文件")
	}

	// 桌面端不受影响
	d.m.mu.Lock()
	d.m.known["desktopphonephonephonephoneph"] = store.Device{ID: "desktopphonephonephonephoneph", Name: "PC", Platform: "windows"}
	d.m.features["desktopphonephonephonephoneph"] = advertised
	d.m.mu.Unlock()
	if !peerDevice(t, d, "desktopphonephonephonephoneph").GetReceivesFiles() {
		t.Fatal("桌面平台只声明 send_files_v1 就该能收文件")
	}

	// 好友这条路径用的是名片里的平台,也要一起挡住
	d.m.mu.Lock()
	const friendID = "friendfriendfriendfriendfriend"
	d.m.contacts[friendID] = store.Contact{ID: friendID, DisplayName: "手机", Platform: "android"}
	d.m.features[friendID] = advertised
	friend := d.m.friendLocked(d.m.contacts[friendID])
	d.m.features[friendID] = featureSet([]string{FeatureSendFiles, FeatureSendFilesTCP, FeatureSendFilesRecv, FeatureSendAsk})
	friendWithRecv := d.m.friendLocked(d.m.contacts[friendID])
	d.m.mu.Unlock()
	if friend.GetReceivesFiles() {
		t.Fatal("好友是手机平台、只声明 send_files_v1 时,不能让界面以为它能收文件")
	}
	if !friendWithRecv.GetReceivesFiles() {
		t.Fatal("好友是手机平台、声明了 send_files_recv_v1 时应该能收文件")
	}
}

func peerDevice(t *testing.T, d *device, id string) *pb.Device {
	t.Helper()
	dev, ok := d.m.device(id)
	if !ok {
		t.Fatalf("%s 没有设备 %s", d.name, id)
	}
	return dev
}

// 没连上的设备只能说「还不知道」:在线(服务器或局域网报告)但 P2P 没通时,
// 不能因为没收到声明就判定为旧版本。
func TestFeaturesUnknownWhileNotConnected(t *testing.T) {
	a := newDevice(t, "a", nil, lanOnly())
	peer := store.Device{ID: "peer", Name: "peer", PublicKey: make([]byte, 32), PairedAt: time.Now()}
	if err := a.m.store.PutDevice(peer); err != nil {
		t.Fatal(err)
	}
	a.m.mu.Lock()
	a.m.known[peer.ID] = peer
	a.m.serverOnline[peer.ID] = true
	a.m.mu.Unlock()
	a.m.checkLegacy(peer.ID, 0)
	dev := peerDevice(t, a, peer.ID)
	if !dev.GetOnline() || dev.GetFeaturesKnown() || dev.GetReceivesFiles() {
		t.Fatalf("没连上就判定了功能: %v", dev)
	}
}

// 收到声明后知道对方能收文件和它的版本号,并存进数据库;重启后不必等连上就知道。
func TestFeaturesDeclaredAndRemembered(t *testing.T) {
	network := lan.NewMemoryNetwork()
	a, b := newDevice(t, "a", network, lanOnly()), newDevice(t, "b", network, lanOnly())
	b.m.appVersion = "2.5.4"
	waitLANUp(t, a, b)
	pairDevices(t, a, b, "")
	waitDirect(t, a, b)
	waitFor(t, "a 收到 b 的声明", func() bool { return peerDevice(t, a, b.id()).GetFeaturesKnown() })
	dev := peerDevice(t, a, b.id())
	if !dev.GetReceivesFiles() || dev.GetAppVersion() != "2.5.4" {
		t.Fatalf("声明不对: %v", dev)
	}
	devices, err := a.m.store.ListDevices()
	if err != nil || len(devices) != 1 {
		t.Fatalf("读设备: %v %v", devices, err)
	}
	got := devices[0]
	if got.AppVersion != "2.5.4" || !slices.Contains(got.Features, FeatureSendFiles) {
		t.Fatalf("没存下声明: %+v", got)
	}

	// 用同一个数据库再建一个 Manager,相当于重启:还没连上就知道对方的功能
	restarted, err := NewManager(Options{
		Identity:   a.m.identity,
		Store:      a.m.store,
		Logger:     slog.New(slog.NewTextHandler(io.Discard, nil)),
		LoadConfig: lanOnly,
		StatePath:  filepath.Join(t.TempDir(), "egress.json"),
		LANPort:    -1,
	})
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { restarted.P2P().Close() })
	dev, _ = restarted.device(b.id())
	if !dev.GetFeaturesKnown() || !dev.GetReceivesFiles() || dev.GetAppVersion() != "2.5.4" {
		t.Fatalf("重启后没读回声明: %v", dev)
	}
}

// 旧版本从不发声明:连上 legacyWait 后仍没有,才判定为旧版本,并清掉上次存下的声明。
func TestLegacyPeerAfterWait(t *testing.T) {
	old := legacyWait
	legacyWait = 300 * time.Millisecond
	t.Cleanup(func() { legacyWait = old })
	network := lan.NewMemoryNetwork()
	a, b := newDevice(t, "a", network, lanOnly()), newDevice(t, "b", network, lanOnly())
	b.m.noFeatures = true
	waitLANUp(t, a, b)
	pairDevices(t, a, b, "")
	waitDirect(t, a, b)
	waitFor(t, "判定为旧版本", func() bool { return peerDevice(t, a, b.id()).GetFeaturesKnown() })
	if dev := peerDevice(t, a, b.id()); dev.GetReceivesFiles() || dev.GetAppVersion() != "" {
		t.Fatalf("旧版本不该能收文件: %v", dev)
	}
}

// testLogger 平时丢掉日志;设了 PF_TEST_LOG 时打到标准错误,排查用
func testLogger(name string) *slog.Logger {
	if os.Getenv("PF_TEST_LOG") == "" {
		return slog.New(slog.NewTextHandler(io.Discard, nil))
	}
	return slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})).With("dev", name)
}