412 lines
16 KiB
Go
412 lines
16 KiB
Go
package imap_server
|
||
|
||
import (
|
||
"reflect"
|
||
"testing"
|
||
|
||
"git.pcux.cn/xuans/Smail/db"
|
||
"git.pcux.cn/xuans/Smail/models"
|
||
"git.pcux.cn/xuans/Smail/services/group"
|
||
"git.pcux.cn/xuans/Smail/services/list"
|
||
"git.pcux.cn/xuans/Smail/utils/context"
|
||
"github.com/emersion/go-imap/v2"
|
||
)
|
||
|
||
func TestAuditLargeSelectedMailboxMustBatchUIDQueries(t *testing.T) {
|
||
user := models.User{Account: t.Name()}
|
||
if _, err := db.Instance.Insert(&user); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
message := models.Email{Subject: t.Name()}
|
||
if _, err := db.Instance.Insert(&message); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
const count = 10001
|
||
uids := make([]int, 0, count)
|
||
deleted := make(map[int]bool)
|
||
// 独立账户及共享邮件内容限制夹具体积，同时保留每个副本的真实 UID。
|
||
for start := 0; start < count; start += 400 {
|
||
batch := make([]models.UserEmail, min(400, count-start))
|
||
for index := range batch {
|
||
batch[index] = models.UserEmail{UserID: user.ID, EmailID: message.Id}
|
||
if position := start + index; position == 0 || position == 500 || position == count-1 {
|
||
batch[index].IsDeleted = 1
|
||
}
|
||
}
|
||
if _, err := db.Instance.Insert(&batch); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
relations, err := list.GetUEListByUID(&context.Context{UserID: user.ID}, "INBOX", 0, 0, nil)
|
||
if err != nil || len(relations) != count {
|
||
t.Fatalf("大邮箱夹具不完整：count=%d err=%v", len(relations), err)
|
||
}
|
||
for _, relation := range relations {
|
||
uids = append(uids, relation.ID)
|
||
if relation.IsDeleted == 1 {
|
||
deleted[relation.ID] = true
|
||
}
|
||
}
|
||
session := &serverSession{ctx: &context.Context{UserID: user.ID}, currentMailbox: "INBOX", mailboxUIDs: uids}
|
||
for _, numbers := range []imap.NumSet{
|
||
imap.SeqSet{{Start: 1, Stop: 0}},
|
||
imap.UIDSet{{Start: imap.UID(uids[0]), Stop: 0}},
|
||
} {
|
||
rows, err := session.selectedMessages(numbers)
|
||
if err != nil || len(rows) != count {
|
||
t.Fatalf("范围读取必须分批保留全部副本：count=%d err=%v", len(rows), err)
|
||
}
|
||
for index, row := range rows {
|
||
if row.UeId != uids[index] || row.SerialNumber != index+1 {
|
||
t.Fatalf("分批读取改变了 UID 或会话序号：index=%d uid=%d sequence=%d", index, row.UeId, row.SerialNumber)
|
||
}
|
||
}
|
||
}
|
||
if err := session.Expunge(nil, nil); err != nil {
|
||
t.Fatalf("大邮箱 EXPUNGE 不能被查询参数上限拒绝：%v", err)
|
||
}
|
||
if len(session.mailboxUIDs) != count-len(deleted) {
|
||
t.Fatalf("删除后快照数量错误：%d", len(session.mailboxUIDs))
|
||
}
|
||
for _, uid := range session.mailboxUIDs {
|
||
if deleted[uid] {
|
||
t.Fatalf("已清除的 UID 仍留在会话快照：%d", uid)
|
||
}
|
||
}
|
||
remaining, err := db.Instance.Where("user_id = ?", user.ID).Count(&models.UserEmail{})
|
||
if err != nil || remaining != int64(count-len(deleted)) {
|
||
t.Fatalf("大邮箱只能清除标记邮件：remaining=%d err=%v", remaining, err)
|
||
}
|
||
}
|
||
|
||
func TestAuditSnapshotSearchAndExpungeBoundaries(t *testing.T) {
|
||
first, last := auditIMAPMessage(t), auditIMAPMessage(t)
|
||
ctx := &context.Context{UserID: first.UserID}
|
||
snapshot := []int{first.ID, last.ID}
|
||
starUID := imap.UIDSet{{Start: 0, Stop: 0}}
|
||
starSequence := imap.SeqSet{{Start: 0, Stop: 0}}
|
||
for _, criteria := range []*imap.SearchCriteria{
|
||
{UID: []imap.UIDSet{starUID}},
|
||
{SeqNum: []imap.SeqSet{starSequence}},
|
||
} {
|
||
rows, err := list.SearchEmails(ctx, "INBOX", criteria, snapshot)
|
||
if err != nil || len(rows) != 1 || rows[0].ID != last.ID {
|
||
t.Fatalf("通配应选择快照最后一封：rows=%v err=%v", rows, err)
|
||
}
|
||
}
|
||
rows, err := list.SearchEmails(ctx, "INBOX", &imap.SearchCriteria{
|
||
UID: []imap.UIDSet{imap.UIDSetNum(imap.UID(first.ID))}, SeqNum: []imap.SeqSet{starSequence},
|
||
}, snapshot)
|
||
if err != nil || len(rows) != 0 {
|
||
t.Fatalf("UID 筛选不能缩小序号通配上界：rows=%v err=%v", rows, err)
|
||
}
|
||
session := &serverSession{ctx: ctx, currentMailbox: "INBOX", mailboxUIDs: append([]int{}, snapshot...)}
|
||
if _, err := db.Instance.ID(last.ID).Delete(&models.UserEmail{}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
for _, criteria := range []*imap.SearchCriteria{
|
||
{UID: []imap.UIDSet{starUID}}, {SeqNum: []imap.SeqSet{starSequence}},
|
||
{Or: [][2]imap.SearchCriteria{{{UID: []imap.UIDSet{starUID}}, {SeqNum: []imap.SeqSet{starSequence}}}}},
|
||
} {
|
||
rows, err := list.SearchEmails(ctx, "INBOX", criteria, snapshot)
|
||
if err != nil || len(rows) != 0 {
|
||
t.Fatalf("未通知删除不能把通配目标前移：rows=%v err=%v", rows, err)
|
||
}
|
||
}
|
||
rows, err = list.SearchEmails(ctx, "INBOX", &imap.SearchCriteria{Not: []imap.SearchCriteria{{UID: []imap.UIDSet{starUID}}}}, snapshot)
|
||
if err != nil || len(rows) != 1 || rows[0].ID != first.ID {
|
||
t.Fatalf("NOT 必须使用同一快照：rows=%v err=%v", rows, err)
|
||
}
|
||
selected, err := session.selectedMessages(imap.SeqSetNum(2))
|
||
if err != nil || len(selected) != 0 {
|
||
t.Fatalf("FETCH/STORE 共用目标解析不能改变已删除序号：rows=%v err=%v", selected, err)
|
||
}
|
||
if _, err := db.Instance.ID(first.ID).Cols("is_deleted").Update(&models.UserEmail{IsDeleted: 1}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
empty := imap.UIDSet{}
|
||
for _, set := range []*imap.UIDSet{&empty, &starUID} {
|
||
if err := session.Expunge(nil, set); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if found, err := db.Instance.ID(first.ID).Exist(&models.UserEmail{}); err != nil || !found {
|
||
t.Fatalf("空集合或尾部通配不得删除其他邮件：found=%v err=%v", found, err)
|
||
}
|
||
}
|
||
// 极大反向区间按快照过滤，不能按数值展开或错误拒绝。
|
||
wide := imap.UIDSet{{Start: imap.UID(^uint32(0)), Stop: 1}}
|
||
if err := session.Expunge(nil, &wide); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if found, err := db.Instance.ID(first.ID).Exist(&models.UserEmail{}); err != nil || found {
|
||
t.Fatalf("反向范围应删除匹配标记：found=%v err=%v", found, err)
|
||
}
|
||
if !reflect.DeepEqual(session.mailboxUIDs, []int{last.ID}) {
|
||
t.Fatalf("只移除已经通知删除的序号：%v", session.mailboxUIDs)
|
||
}
|
||
}
|
||
|
||
// 使用现有 TestMain 创建的临时 SQLite 和随机本地 TLS 端口，不连接开发服务。
|
||
func TestAuditCopyThenMoveMustKeepMailboxIdentity(t *testing.T) {
|
||
var user models.User
|
||
if found, err := db.Instance.Where("account=?", "testCase").Get(&user); err != nil || !found {
|
||
t.Fatalf("临时测试账户不可用: found=%v err=%v", found, err)
|
||
}
|
||
message := models.Email{Subject: "audit-copy-move"}
|
||
if _, err := db.Instance.Insert(&message); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
relation := models.UserEmail{UserID: user.ID, EmailID: message.Id, Status: 0}
|
||
if _, err := db.Instance.Insert(&relation); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
uid := imap.UIDSetNum(imap.UID(relation.ID))
|
||
if _, err := clientLogin.Copy(uid, "Junk").Wait(); err != nil {
|
||
t.Fatalf("复制前置条件失败: %v", err)
|
||
}
|
||
count, err := db.Instance.Where("user_id=? AND email_id=?", user.ID, message.Id).Count(&models.UserEmail{})
|
||
if err != nil || count != 2 {
|
||
t.Fatalf("未生成预期副本: count=%d err=%v", count, err)
|
||
}
|
||
// 当前服务器未声明 MOVE 扩展，客户端会回退 COPY/STORE/EXPUNGE。
|
||
// 另外验证网页移动所用的服务，避免把回退成功误判为原生 MOVE 已通过。
|
||
webMoveErr := group.Move2DefaultBox(&context.Context{UserID: user.ID}, []int{message.Id}, "Deleted Messages")
|
||
t.Logf("web_move_after_imap_copy_error=%v", webMoveErr)
|
||
if webMoveErr != nil {
|
||
t.Errorf("IMAP 复制后网页移动不应把自己的邮件判断为不属于自己: %v", webMoveErr)
|
||
}
|
||
// 网页移动已经移走原 UID；另建独立样本验证客户端回退，不能重复移动旧 UID。
|
||
moveRelation := auditIMAPMessage(t)
|
||
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
_, err = clientLogin.Move(imap.UIDSetNum(imap.UID(moveRelation.ID)), "Deleted Messages").Wait()
|
||
t.Logf("copy_relation_count=%d move_error=%v", count, err)
|
||
if err != nil {
|
||
t.Fatalf("同一用户复制邮件后，移动原文件夹中的 UID 不应失败: %v", err)
|
||
}
|
||
}
|
||
|
||
func auditIMAPMessage(t *testing.T) models.UserEmail {
|
||
t.Helper()
|
||
var user models.User
|
||
if found, err := db.Instance.Where("account=?", "testCase").Get(&user); err != nil || !found {
|
||
t.Fatalf("测试账户不可用: found=%v err=%v", found, err)
|
||
}
|
||
message := models.Email{Subject: t.Name()}
|
||
if _, err := db.Instance.Insert(&message); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
relation := models.UserEmail{UserID: user.ID, EmailID: message.Id, Status: 0}
|
||
if _, err := db.Instance.Insert(&relation); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
return relation
|
||
}
|
||
|
||
func TestAuditExamineMustNotPersistStore(t *testing.T) {
|
||
relation := auditIMAPMessage(t)
|
||
if _, err := clientLogin.Select("INBOX", &imap.SelectOptions{ReadOnly: true}).Wait(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
err := clientLogin.Store(imap.UIDSetNum(imap.UID(relation.ID)), &imap.StoreFlags{
|
||
Op: imap.StoreFlagsAdd, Flags: []imap.Flag{imap.FlagSeen}, Silent: true,
|
||
}, nil).Close()
|
||
var updated models.UserEmail
|
||
if found, lookupErr := db.Instance.ID(relation.ID).Get(&updated); lookupErr != nil || !found {
|
||
t.Fatalf("读取测试邮件失败: found=%v err=%v", found, lookupErr)
|
||
}
|
||
t.Logf("readonly=true store_error=%v persisted_is_read=%d", err, updated.IsRead)
|
||
if updated.IsRead != relation.IsRead {
|
||
t.Fatal("EXAMINE 只读打开后，STORE 仍持久化修改已读状态")
|
||
}
|
||
}
|
||
|
||
func TestAuditCopiedMessagesMustKeepDistinctUIDs(t *testing.T) {
|
||
relation := auditIMAPMessage(t)
|
||
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := clientLogin.Copy(imap.UIDSetNum(imap.UID(relation.ID)), "INBOX").Wait(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
var relations []models.UserEmail
|
||
if err := db.Instance.Where("user_id=? AND email_id=?", relation.UserID, relation.EmailID).Find(&relations); err != nil || len(relations) != 2 {
|
||
t.Fatalf("复制前置条件失败: count=%d err=%v", len(relations), err)
|
||
}
|
||
for _, stored := range relations {
|
||
t.Logf("stored_uid=%d status=%d group=%d", stored.ID, stored.Status, stored.GroupId)
|
||
}
|
||
rows, lookupErr := list.GetEmailListByGroup(&context.Context{UserID: relation.UserID}, "INBOX", list.ImapListReq{
|
||
UidList: []int{relations[0].ID, relations[1].ID},
|
||
}, true)
|
||
if lookupErr != nil || len(rows) != 2 {
|
||
t.Fatalf("直接查询副本失败: count=%d err=%v", len(rows), lookupErr)
|
||
}
|
||
t.Logf("hydrated_uids=%d,%d same_pointer=%v", rows[0].UeId, rows[1].UeId, rows[0] == rows[1])
|
||
if rows[0] == rows[1] || rows[0].UeId == rows[1].UeId {
|
||
t.Error("不同邮箱关系复用了同一个可变响应对象，UID 被后一个副本覆盖")
|
||
}
|
||
uids := imap.UIDSetNum(imap.UID(relations[0].ID), imap.UID(relations[1].ID))
|
||
messages, err := clientLogin.Fetch(uids, &imap.FetchOptions{UID: true, Flags: true}).Collect()
|
||
if err != nil || len(messages) != 2 {
|
||
t.Fatalf("读取两个副本失败: count=%d err=%v", len(messages), err)
|
||
}
|
||
t.Logf("stored_uids=%d,%d fetched_uids=%d,%d", relations[0].ID, relations[1].ID, messages[0].UID, messages[1].UID)
|
||
if messages[0].UID == messages[1].UID {
|
||
t.Fatal("不同副本在实际 IMAP FETCH 响应中使用了同一个 UID")
|
||
}
|
||
}
|
||
|
||
func TestAuditListPercentMustIncludeInbox(t *testing.T) {
|
||
mailboxes, err := clientLogin.List("", "%", nil).Collect()
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
names := make([]string, 0, len(mailboxes))
|
||
found := false
|
||
for _, mailbox := range mailboxes {
|
||
names = append(names, mailbox.Mailbox)
|
||
found = found || mailbox.Mailbox == "INBOX"
|
||
}
|
||
t.Logf("top_level_mailboxes=%v", names)
|
||
if !found {
|
||
t.Fatal("LIST 顶层通配符遗漏 INBOX 和默认文件夹")
|
||
}
|
||
}
|
||
|
||
func TestAuditUIDNextMustNotDecrease(t *testing.T) {
|
||
relation := auditIMAPMessage(t)
|
||
before, err := clientLogin.Status("INBOX", &imap.StatusOptions{UIDNext: true, UIDValidity: true}).Wait()
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := group.Move2DefaultBox(&context.Context{UserID: relation.UserID}, []int{relation.EmailID}, "Junk"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
after, err := clientLogin.Status("INBOX", &imap.StatusOptions{UIDNext: true, UIDValidity: true}).Wait()
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Logf("uidnext_before=%d uidnext_after=%d validity_before=%d validity_after=%d", before.UIDNext, after.UIDNext, before.UIDValidity, after.UIDValidity)
|
||
if after.UIDValidity == before.UIDValidity && after.UIDNext < before.UIDNext {
|
||
t.Fatal("同一 UIDVALIDITY 下，移走最大 UID 邮件导致 UIDNEXT 倒退")
|
||
}
|
||
}
|
||
|
||
func TestAuditFetchWildcardUIDMustReturnLastMessage(t *testing.T) {
|
||
relation := auditIMAPMessage(t)
|
||
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
messages, err := clientLogin.Fetch(imap.UIDSetNum(0), &imap.FetchOptions{UID: true}).Collect()
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// go-imap/v2 beta.5 的动态 UID 集合 Contains(*) 固定返回 false，
|
||
// 因而客户端会丢弃合法的动态 UID 响应；静态 UID 用于验证响应解析本身。
|
||
if len(messages) != 0 {
|
||
t.Fatalf("动态 UID 客户端结果异常: count=%d", len(messages))
|
||
}
|
||
staticMessages, err := clientLogin.Fetch(imap.UIDSetNum(imap.UID(relation.ID)), &imap.FetchOptions{UID: true}).Collect()
|
||
if err != nil || len(staticMessages) != 1 || staticMessages[0].UID != imap.UID(relation.ID) {
|
||
t.Fatalf("静态 UID FETCH 未正确解析服务端响应: count=%d err=%v", len(staticMessages), err)
|
||
}
|
||
}
|
||
|
||
func TestAuditInboxCountMustExcludeLoginBindings(t *testing.T) {
|
||
relation := auditIMAPMessage(t)
|
||
bindings, err := db.Instance.Where("user_id=? AND email_id=0 AND group_id=0 AND status=0", relation.UserID).Count(&models.UserEmail{})
|
||
if err != nil || bindings < 1 {
|
||
t.Fatalf("临时登录邮箱绑定前置条件未成立: count=%d err=%v", bindings, err)
|
||
}
|
||
want, err := db.Instance.Where("user_id=? AND email_id>0 AND group_id=0 AND status=0", relation.UserID).Count(&models.UserEmail{})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
status, err := clientLogin.Status("INBOX", &imap.StatusOptions{NumMessages: true}).Wait()
|
||
if err != nil || status.NumMessages == nil {
|
||
t.Fatalf("查询邮箱数量失败: status=%v err=%v", status, err)
|
||
}
|
||
t.Logf("login_bindings=%d real_messages=%d status_messages=%d", bindings, want, *status.NumMessages)
|
||
if int64(*status.NumMessages) != want {
|
||
t.Fatal("登录邮箱绑定被当作邮件计入 INBOX，状态数量与可读取邮件不一致")
|
||
}
|
||
}
|
||
|
||
func TestAuditSearchKeysMustIntersect(t *testing.T) {
|
||
first := auditIMAPMessage(t)
|
||
second := auditIMAPMessage(t)
|
||
third := auditIMAPMessage(t)
|
||
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
uidCriterion := func(ids ...int) imap.SearchCriteria {
|
||
var set imap.UIDSet
|
||
for _, id := range ids {
|
||
set.AddNum(imap.UID(id))
|
||
}
|
||
return imap.SearchCriteria{UID: []imap.UIDSet{set}}
|
||
}
|
||
cases := map[string]imap.SearchCriteria{
|
||
"multiple_or": {Or: [][2]imap.SearchCriteria{
|
||
{uidCriterion(first.ID), uidCriterion(second.ID)},
|
||
{uidCriterion(second.ID), uidCriterion(third.ID)},
|
||
}},
|
||
"multiple_uid": {UID: []imap.UIDSet{
|
||
imap.UIDSetNum(imap.UID(first.ID), imap.UID(second.ID)),
|
||
imap.UIDSetNum(imap.UID(second.ID), imap.UID(third.ID)),
|
||
}},
|
||
}
|
||
for name, criteria := range cases {
|
||
t.Run(name, func(t *testing.T) {
|
||
result, err := clientLogin.UIDSearch(&criteria, nil).Wait()
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
uids := result.AllUIDs()
|
||
t.Logf("returned=%v expected_only=%d", uids, second.ID)
|
||
if len(uids) != 1 || uids[0] != imap.UID(second.ID) {
|
||
t.Fatal("同一个 SEARCH 的多个键应取交集，而不是并集")
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestAuditSearchDeletedMustMatchStoredFlag(t *testing.T) {
|
||
relation := auditIMAPMessage(t)
|
||
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
uid := imap.UIDSetNum(imap.UID(relation.ID))
|
||
if err := clientLogin.Store(uid, &imap.StoreFlags{
|
||
Op: imap.StoreFlagsAdd, Flags: []imap.Flag{imap.FlagDeleted}, Silent: true,
|
||
}, nil).Close(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
messages, err := clientLogin.Fetch(uid, &imap.FetchOptions{Flags: true, UID: true}).Collect()
|
||
if err != nil || len(messages) != 1 {
|
||
t.Fatalf("读取标记前置条件失败: count=%d err=%v", len(messages), err)
|
||
}
|
||
deleted := false
|
||
for _, flag := range messages[0].Flags {
|
||
deleted = deleted || flag == imap.FlagDeleted
|
||
}
|
||
if !deleted {
|
||
t.Fatal("STORE 后 FETCH 没有返回删除标记，不能继续归因 SEARCH")
|
||
}
|
||
result, err := clientLogin.UIDSearch(&imap.SearchCriteria{
|
||
UID: []imap.UIDSet{uid}, Flag: []imap.Flag{imap.FlagDeleted},
|
||
}, nil).Wait()
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Logf("fetch_deleted=%t search_uids=%v expected_uid=%d", deleted, result.AllUIDs(), relation.ID)
|
||
if len(result.AllUIDs()) != 1 || result.AllUIDs()[0] != imap.UID(relation.ID) {
|
||
t.Fatal("已通过 STORE 设置且 FETCH 确认的删除标记未被 SEARCH 识别")
|
||
}
|
||
}
|