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.

18.9 KB
Raw Blame
package send

import (
	"bytes"
	"context"
	"crypto/rand"
	"os"
	"path/filepath"
	"runtime"
	"sync"
	"testing"
	"time"

	"github.com/baiyuze/pasteferry/client-core/internal/config"
	"github.com/baiyuze/pasteferry/client-core/internal/store"
	"github.com/baiyuze/pasteferry/client-core/internal/transport/p2p"
	pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
)

// 两台设备:各有自己的数据库、保存位置和隔空传送引擎,经本机回环上真实的 WebRTC 连接互发。

type side struct {
	id      string
	mgr     *p2p.Manager
	eng     *Engine
	db      *store.Store
	recvDir string

	mu         sync.Mutex
	cfg        config.Config
	offers     []*pb.SendOffer // 发出去的 SendOffer,看续传位置用
	answers    []*pb.SendAnswer
	blockOut   bool // 模拟连接断了:控制消息发不出去
	dropResult bool // 模拟「已收到」的结果在路上丢了
	dropOffers int  // 模拟请求落在对方重启前的旧连接里

	// 好友(2.6.0):本端眼里对方的角色、对方能不能等用户接受、本端收不收对方的
	role  string
	noAsk bool
	admit Admission
}

func (s *side) config() config.Config {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.cfg
}

type pair struct {
	a, b *side
	mu   sync.Mutex
	mgrs map[string]*p2p.Manager
}

func newPair(t *testing.T) *pair {
	t.Helper()
	p := &pair{mgrs: map[string]*p2p.Manager{}}
	p.a = p.newSide(t, "alice", "bob")
	p.b = p.newSide(t, "bob", "alice")
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	if err := p.a.mgr.Connect(ctx, "bob"); err != nil {
		t.Fatalf("建立连接: %v", err)
	}
	waitFor(t, 30*time.Second, func() bool {
		return connected(p.a.mgr.State("bob")) && connected(p.b.mgr.State("alice"))
	})
	return p
}

func connected(s p2p.ConnState) bool { return s == p2p.StateDirect || s == p2p.StateRelay }

func (p *pair) newSide(t *testing.T, id, peer string) *side {
	t.Helper()
	dir := t.TempDir()
	db, err := store.Open(filepath.Join(dir, "db.sqlite"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { db.Close() })
	s := &side{id: id, db: db, recvDir: filepath.Join(dir, "Downloads")}
	if err := os.MkdirAll(s.recvDir, 0o755); err != nil {
		t.Fatal(err)
	}
	s.cfg = config.Default()
	s.cfg.ReceiveDir = s.recvDir

	s.mgr = p2p.NewManager(p2p.ManagerOptions{
		SelfID: id,
		SendSignal: func(_ context.Context, to string, msg *pb.SignalMessage) error {
			p.mu.Lock()
			target := p.mgrs[to]
			p.mu.Unlock()
			if target != nil {
				go func() {
					ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
					defer cancel()
					_ = target.HandleSignal(ctx, id, msg)
				}()
			}
			return nil
		},
		OnMessage: func(from string, msg *pb.PeerMessage) {
			if a := msg.GetSendAnswer(); a != nil {
				s.mu.Lock()
				s.answers = append(s.answers, a)
				s.mu.Unlock()
			}
			if s.eng != nil {
				s.eng.HandleMessage(from, msg)
			}
		},
		OnStream: func(from, label string, st *p2p.Stream) {
			if s.eng != nil && IsStream(label) {
				s.eng.HandleStream(from, label, st)
			}
		},
	})
	s.mgr.SetICEServers(nil)
	p.mu.Lock()
	p.mgrs[id] = s.mgr
	p.mu.Unlock()
	t.Cleanup(s.mgr.Close)

	s.eng = New(Options{
		Store:      db,
		LoadConfig: s.config,
		Send: func(to string, msg *pb.PeerMessage) error {
			s.mu.Lock()
			blocked := s.blockOut
			if msg.GetSendResult() != nil && s.dropResult {
				s.mu.Unlock()
				return nil
			}
			if o := msg.GetSendOffer(); o != nil {
				s.offers = append(s.offers, o)
				if s.dropOffers > 0 {
					s.dropOffers--
					s.mu.Unlock()
					return nil
				}
			}
			s.mu.Unlock()
			if blocked {
				return p2p.ErrNotConnected
			}
			return s.mgr.Send(to, msg)
		},
		OpenStream: s.mgr.OpenStream,
		Peer: func(deviceID string) Peer {
			if deviceID != peer {
				return Peer{}
			}
			st := s.mgr.State(deviceID)
			s.mu.Lock()
			defer s.mu.Unlock()
			return Peer{Known: true, Name: deviceID, Online: true, Connected: connected(st),
				Relayed: st == p2p.StateRelay, Supported: true, Role: s.role, Ask: !s.noAsk}
		},
		Admit: func(string) Admission {
			s.mu.Lock()
			defer s.mu.Unlock()
			return s.admit
		},
		Thumbnail: func(path string) string {
			if filepath.Ext(path) == ".png" {
				return "thumb:" + filepath.Base(path)
			}
			return ""
		},
		AnswerTimeout: 10 * time.Second,
		AskTimeout:    2 * time.Second,
	})
	s.eng.Start()
	t.Cleanup(s.eng.Close)
	return s
}

func waitFor(t *testing.T, d time.Duration, ok func() bool) {
	t.Helper()
	deadline := time.Now().Add(d)
	for !ok() {
		if time.Now().After(deadline) {
			t.Fatal("等待超时")
		}
		time.Sleep(20 * time.Millisecond)
	}
}

func waitStatus(t *testing.T, s *side, id, want string) store.Transfer {
	t.Helper()
	var got store.Transfer
	deadline := time.Now().Add(60 * time.Second)
	for {
		tr, err := s.db.GetTransfer(id)
		if err == nil && tr.Status == want {
			return tr
		}
		if err == nil {
			got = tr
		}
		if time.Now().After(deadline) {
			t.Fatalf("%s 上的传输 %s 一直没有变成 %s(现在 %s %s)", s.id, id, want, got.Status, got.Error)
		}
		time.Sleep(20 * time.Millisecond)
	}
}

func writeFile(t *testing.T, path string, data []byte) {
	t.Helper()
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(path, data, 0o644); err != nil {
		t.Fatal(err)
	}
}

func randomBytes(t *testing.T, n int) []byte {
	t.Helper()
	b := make([]byte, n)
	if _, err := rand.Read(b); err != nil {
		t.Fatal(err)
	}
	return b
}

func sameFile(t *testing.T, want []byte, path string) {
	t.Helper()
	got, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("读取 %s: %v", path, err)
	}
	if !bytes.Equal(got, want) {
		t.Fatalf("%s 的内容不对:%d 字节,应为 %d 字节", path, len(got), len(want))
	}
}

func TestSendFilesAndFolder(t *testing.T) {
	p := newPair(t)
	src := t.TempDir()
	report := randomBytes(t, 3<<20)
	photo := randomBytes(t, 700<<10)
	writeFile(t, filepath.Join(src, "报告.pdf"), report)
	writeFile(t, filepath.Join(src, "照片", "2026", "IMG_1.HEIC"), photo)
	writeFile(t, filepath.Join(src, "照片", "空文件.txt"), nil)
	if err := os.MkdirAll(filepath.Join(src, "照片", "空文件夹"), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.Symlink("2026/IMG_1.HEIC", filepath.Join(src, "照片", "最新")); err != nil {
		t.Fatal(err)
	}
	// 对方的保存位置里已经有一个同名文件:收到的要改名,不能覆盖
	writeFile(t, filepath.Join(p.b.recvDir, "报告.pdf"), []byte("old"))

	tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "报告.pdf"), filepath.Join(src, "照片")}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	out := waitStatus(t, p.a, tr.GetId(), store.TransferDone)
	in := waitStatus(t, p.b, tr.GetId(), store.TransferDone)

	if out.FileCount != 3 || out.TotalBytes != int64(len(report)+len(photo)) {
		t.Fatalf("统计不对:%d 个文件,%d 字节", out.FileCount, out.TotalBytes)
	}
	sameFile(t, report, filepath.Join(p.b.recvDir, "报告 (2).pdf"))
	sameFile(t, []byte("old"), filepath.Join(p.b.recvDir, "报告.pdf"))
	sameFile(t, photo, filepath.Join(p.b.recvDir, "照片", "2026", "IMG_1.HEIC"))
	sameFile(t, nil, filepath.Join(p.b.recvDir, "照片", "空文件.txt"))
	if info, err := os.Stat(filepath.Join(p.b.recvDir, "照片", "空文件夹")); err != nil || !info.IsDir() {
		t.Fatal("空文件夹没有收到")
	}
	// 普通用户在 Windows 上建不了符号链接,接收方跳过它;其他平台照原样建
	if runtime.GOOS == "windows" {
		if _, err := os.Lstat(filepath.Join(p.b.recvDir, "照片", "最新")); !os.IsNotExist(err) {
			t.Fatalf("Windows 上应当跳过符号链接:%v", err)
		}
	} else if link, err := os.Readlink(filepath.Join(p.b.recvDir, "照片", "最新")); err != nil || link != "2026/IMG_1.HEIC" {
		t.Fatalf("符号链接不对:%q %v", link, err)
	}
	if _, err := os.Stat(filepath.Join(p.b.recvDir, partialDir)); !os.IsNotExist(err) {
		t.Fatal("临时目录没有清掉")
	}
	if len(in.Paths) != 2 || filepath.Base(in.Paths[0]) != "报告 (2).pdf" || in.Items[0].Name != "报告 (2).pdf" {
		t.Fatalf("收到的记录不对:%v %v", in.Paths, in.Items)
	}
	if rows, _ := p.b.db.TransferEntries(tr.GetId(), 0, 10); len(rows) != 0 {
		t.Fatal("收完以后条目应当清掉")
	}
}

// 重连通知到达时还在等旧连接的应答;之后超时也应自动继续。
func TestResumeWhenReconnectPrecedesAnswerTimeout(t *testing.T) {
	for _, lan := range []bool{false, true} {
		t.Run(map[bool]string{false: "datachannel", true: "tcp"}[lan], func(t *testing.T) {
			p := newPair(t)
			if lan {
				useLAN(t, p, false)
			}
			p.a.eng.opts.AnswerTimeout = 300 * time.Millisecond
			p.a.mu.Lock()
			p.a.dropOffers = 1
			p.a.mu.Unlock()
			path := filepath.Join(t.TempDir(), "restart.bin")
			data := randomBytes(t, 1<<20)
			writeFile(t, path, data)
			tr, err := p.a.eng.SendFiles("bob", []string{path}, false, "")
			if err != nil {
				t.Fatal(err)
			}
			waitFor(t, 5*time.Second, func() bool {
				p.a.mu.Lock()
				defer p.a.mu.Unlock()
				return len(p.a.offers) == 1
			})
			p.a.eng.PeerReady("bob")
			waitStatus(t, p.a, tr.GetId(), store.TransferDone)
			waitStatus(t, p.b, tr.GetId(), store.TransferDone)
			sameFile(t, data, filepath.Join(p.b.recvDir, "restart.bin"))
			p.a.mu.Lock()
			defer p.a.mu.Unlock()
			if len(p.a.offers) != 3 || !p.a.offers[1].GetResume() || p.a.offers[2].GetResume() {
				t.Fatalf("应先续传,对方没有记录时才从头发:%v", p.a.offers)
			}
		})
	}
}

func TestConnectedRetryStopsAfterOneAttempt(t *testing.T) {
	p := newPair(t)
	p.a.mu.Lock()
	p.a.blockOut = true
	p.a.mu.Unlock()
	path := filepath.Join(t.TempDir(), "retry.txt")
	writeFile(t, path, []byte("retry"))
	tr, err := p.a.eng.SendFiles("bob", []string{path}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	waitFor(t, 10*time.Second, func() bool {
		got, err := p.a.db.GetTransfer(tr.GetId())
		return err == nil && got.Status == store.TransferInterrupted && got.Attempt == 2
	})
	time.Sleep(3500 * time.Millisecond)
	p.a.mu.Lock()
	defer p.a.mu.Unlock()
	if len(p.a.offers) != 2 {
		t.Fatalf("持续失败不应循环重试:%d", len(p.a.offers))
	}
}

// 对方一直不应答:状态是「中断」,但要带上原因,界面才能说「对方没有应答」而不是只显示「中断」。
func TestNoAnswerKeepsReason(t *testing.T) {
	p := newPair(t)
	p.a.eng.opts.AnswerTimeout = 300 * time.Millisecond
	p.a.mu.Lock()
	p.a.dropOffers = 99 // 每次都丢掉,模拟对端永远不应答
	p.a.mu.Unlock()
	path := filepath.Join(t.TempDir(), "silent.txt")
	writeFile(t, path, []byte("silent"))
	tr, err := p.a.eng.SendFiles("bob", []string{path}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	got := waitStatus(t, p.a, tr.GetId(), store.TransferInterrupted)
	if got.Error != "peer_unreachable" {
		t.Fatalf("中断原因 = %q,应为 peer_unreachable", got.Error)
	}
}

func TestCancelDuringConnectedRetry(t *testing.T) {
	p := newPair(t)
	p.a.mu.Lock()
	p.a.blockOut = true
	p.a.mu.Unlock()
	path := filepath.Join(t.TempDir(), "cancel.txt")
	writeFile(t, path, []byte("cancel"))
	tr, err := p.a.eng.SendFiles("bob", []string{path}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	waitStatus(t, p.a, tr.GetId(), store.TransferInterrupted)
	if err := p.a.eng.Cancel(tr.GetId()); err != nil {
		t.Fatal(err)
	}
	time.Sleep(3500 * time.Millisecond)
	got := waitStatus(t, p.a, tr.GetId(), store.TransferCancelled)
	if got.Attempt != 1 {
		t.Fatalf("取消后不应再发:%d", got.Attempt)
	}
}

func TestResumeAfterInterruption(t *testing.T) {
	p := newPair(t)
	src := t.TempDir()
	first := randomBytes(t, 2<<20)
	big := randomBytes(t, 40<<20)
	writeFile(t, filepath.Join(src, "a", "1.bin"), first)
	writeFile(t, filepath.Join(src, "a", "2.bin"), big)

	tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "a")}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	// 等第二个文件收了一部分,然后掐断接收方的数据流(相当于连接断了)
	waitFor(t, 60*time.Second, func() bool {
		rows, _ := p.b.db.TransferEntries(tr.GetId(), 0, 10)
		return len(rows) == 3 && rows[2].DoneBytes > 8<<20
	})
	p.b.eng.mu.Lock()
	in := p.b.eng.in[tr.GetId()]
	p.b.eng.mu.Unlock()
	in.abort(errIdle)
	waitStatus(t, p.b, tr.GetId(), store.TransferInterrupted)
	waitStatus(t, p.a, tr.GetId(), store.TransferInterrupted)

	// 连接恢复:发送方自动续传
	p.a.eng.PeerReady("bob")
	waitStatus(t, p.a, tr.GetId(), store.TransferDone)
	waitStatus(t, p.b, tr.GetId(), store.TransferDone)
	sameFile(t, first, filepath.Join(p.b.recvDir, "a", "1.bin"))
	sameFile(t, big, filepath.Join(p.b.recvDir, "a", "2.bin"))

	p.a.mu.Lock()
	defer p.a.mu.Unlock()
	if len(p.a.offers) < 2 || !p.a.offers[len(p.a.offers)-1].GetResume() {
		t.Fatal("第二次发起应当是续传")
	}
	var resumed *pb.SendAnswer
	for _, a := range p.a.answers {
		if a.GetAttempt() == 2 {
			resumed = a
		}
	}
	if resumed == nil || resumed.GetResumeIndex() != 2 || resumed.GetResumeOffset() < 8<<20 {
		t.Fatalf("续传位置不对:%v", resumed)
	}
}

func TestCancelBySender(t *testing.T) {
	p := newPair(t)
	src := t.TempDir()
	writeFile(t, filepath.Join(src, "big.bin"), randomBytes(t, 60<<20))
	tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "big.bin")}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	waitStatus(t, p.b, tr.GetId(), store.TransferActive)
	if err := p.a.eng.Cancel(tr.GetId()); err != nil {
		t.Fatal(err)
	}
	waitStatus(t, p.a, tr.GetId(), store.TransferCancelled)
	got := waitStatus(t, p.b, tr.GetId(), store.TransferCancelled)
	if got.Error != "peer_cancelled" {
		t.Fatalf("接收方的原因应为 peer_cancelled,实际 %q", got.Error)
	}
	if _, err := os.Stat(filepath.Join(p.b.recvDir, partialDir, tr.GetId())); !os.IsNotExist(err) {
		t.Fatal("取消后没收完的部分应当删掉")
	}
}

func TestReceiveDisabled(t *testing.T) {
	p := newPair(t)
	p.b.mu.Lock()
	p.b.cfg.ReceiveDisabled = true
	p.b.mu.Unlock()
	src := t.TempDir()
	writeFile(t, filepath.Join(src, "x.txt"), []byte("hi"))
	tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "x.txt")}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	got := waitStatus(t, p.a, tr.GetId(), store.TransferDeclined)
	if got.Error != "disabled" {
		t.Fatalf("原因应为 disabled,实际 %q", got.Error)
	}
	if _, err := p.b.db.GetTransfer(tr.GetId()); err == nil {
		t.Fatal("关闭接收时不应留下记录")
	}
}

func TestSourceChangedBeforeSending(t *testing.T) {
	p := newPair(t)
	src := t.TempDir()
	path := filepath.Join(src, "notes.txt")
	writeFile(t, path, []byte("version 1"))

	// 先让控制消息发不出去,这一批统计完会停在中断
	p.a.mu.Lock()
	p.a.blockOut = true
	p.a.mu.Unlock()
	tr, err := p.a.eng.SendFiles("bob", []string{path}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	waitStatus(t, p.a, tr.GetId(), store.TransferInterrupted)

	writeFile(t, path, []byte("version 2, longer"))
	p.a.mu.Lock()
	p.a.blockOut = false
	p.a.mu.Unlock()
	p.a.eng.PeerReady("bob")
	got := waitStatus(t, p.a, tr.GetId(), store.TransferFailed)
	if got.Error != "source_changed" {
		t.Fatalf("原因应为 source_changed,实际 %q", got.Error)
	}
	waitStatus(t, p.b, tr.GetId(), store.TransferFailed)
}

func TestRejectsPathsThroughSymlinks(t *testing.T) {
	base := t.TempDir()
	if err := os.MkdirAll(filepath.Join(base, "top"), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.Symlink(t.TempDir(), filepath.Join(base, "top", "link")); err != nil {
		t.Fatal(err)
	}
	if err := noLinkParents(base, filepath.Join(base, "top", "link", "sub"), map[string]bool{}); err == nil {
		t.Fatal("经过符号链接的路径应当被拒绝")
	}
	if err := noLinkParents(base, filepath.Join(base, "top", "dir"), map[string]bool{}); err != nil {
		t.Fatalf("普通路径不该被拒绝: %v", err)
	}
}

func TestClaimDest(t *testing.T) {
	dir := t.TempDir()
	writeFile(t, filepath.Join(dir, "a.txt"), nil)
	writeFile(t, filepath.Join(dir, "a (2).txt"), nil)
	if got := filepath.Base(claimDest(dir, "a.txt", false)); got != "a (3).txt" {
		t.Fatalf("得到 %q", got)
	}
	if err := os.Mkdir(filepath.Join(dir, "v1.0"), 0o755); err != nil {
		t.Fatal(err)
	}
	if got := filepath.Base(claimDest(dir, "v1.0", true)); got != "v1.0 (2)" {
		t.Fatalf("文件夹不该按扩展名拆分,得到 %q", got)
	}
}

func TestDeclinesWhenSaveLocationIsGone(t *testing.T) {
	p := newPair(t)
	p.b.mu.Lock()
	p.b.cfg.ReceiveDir = filepath.Join(p.b.recvDir, "外置盘已拔出")
	p.b.mu.Unlock()
	src := t.TempDir()
	writeFile(t, filepath.Join(src, "x.txt"), []byte("hi"))
	tr, err := p.a.eng.SendFiles("bob", []string{filepath.Join(src, "x.txt")}, false, "")
	if err != nil {
		t.Fatal(err)
	}
	if got := waitStatus(t, p.a, tr.GetId(), store.TransferDeclined); got.Error != "dest_unavailable" {
		t.Fatalf("发送方的原因应为 dest_unavailable,实际 %q", got.Error)
	}
	// 接收方也留一条记录:本机用户要知道有人发过来、为什么没收下
	if got := waitStatus(t, p.b, tr.GetId(), store.TransferDeclined); got.Error != "dest_unavailable" {
		t.Fatalf("接收方的原因应为 dest_unavailable,实际 %q", got.Error)
	}
}

func TestRefusesPeersThatCannotReceive(t *testing.T) {
	db, err := store.Open(filepath.Join(t.TempDir(), "db.sqlite"))
	if err != nil {
		t.Fatal(err)
	}
	defer db.Close()
	src := filepath.Join(t.TempDir(), "x.txt")
	writeFile(t, src, []byte("hi"))
	peer := Peer{Known: true, Online: true, Connected: true}
	e := New(Options{Store: db, LoadConfig: config.Default, Peer: func(string) Peer { return peer }})
	defer e.Close()

	cases := []struct {
		name string
		set  func()
		want error
	}{
		{"旧版本", func() {}, ErrUnsupported},
		{"还没连上", func() { peer.Connecting = true }, ErrConnecting},
		{"关闭了接收", func() { peer.Connecting = false; peer.Supported, peer.Disabled = true, true }, ErrPeerDisabled},
		{"离线", func() { peer.Disabled, peer.Online = false, false }, ErrOffline},
		{"没配对", func() { peer.Known = false }, ErrUnknownDevice},
	}
	for _, c := range cases {
		c.set()
		if _, err := e.SendFiles("x", []string{src}, false, ""); err != c.want {
			t.Errorf("%s:应返回 %v,实际 %v", c.name, c.want, err)
		}
	}
	peer = Peer{Known: true, Online: true, Connected: true, Supported: true}
	if _, err := e.SendFiles("x", []string{filepath.Join(t.TempDir(), "不存在")}, false, ""); err == nil {
		t.Error("路径不存在时应当报错")
	}
}

func TestOfficialRelayNeedsConsent(t *testing.T) {
	db, err := store.Open(filepath.Join(t.TempDir(), "db.sqlite"))
	if err != nil {
		t.Fatal(err)
	}
	defer db.Close()
	src := filepath.Join(t.TempDir(), "x.txt")
	writeFile(t, src, []byte("hi"))
	cfg := config.Default()
	cfg.ServiceMode = "official"
	e := New(Options{Store: db, LoadConfig: func() config.Config { return cfg },
		Peer: func(string) Peer {
			return Peer{Known: true, Online: true, Connected: true, Relayed: true, Supported: true}
		},
		Send: func(string, *pb.PeerMessage) error { return p2p.ErrNotConnected }})
	defer e.Close()
	if _, err := e.SendFiles("x", []string{src}, false, ""); err != ErrNeedRelayConsent {
		t.Fatalf("经官方中转时应先征得同意,实际 %v", err)
	}
	if _, err := e.SendFiles("x", []string{src}, true, ""); err != nil {
		t.Fatalf("同意后应当能发:%v", err)
	}
}