修复生产审查凭据泄露风险并增加持久投递队列

This commit is contained in:
xuans committed 2026-09-17 10:17:09 +08:00
1 parent 071460ed9a
commit 6b009197bc
70 files changed
+1581 -262

No files matched your search

@@ -104,3 +104,40 @@ func TestMaintenanceGuardDrainsRequestsAndKeepsRestartRoute(t *testing.T) {
t.Fatal("cleanup wrote to frozen source")
}
}
func TestMaintenanceDrainsBackgroundDeliveryBeforeFreeze(t *testing.T) {
executor := &PortableExecutor{}
service := NewService(&DatabaseExecutor{portable: executor})
previous := Current()
SetCurrent(service)
t.Cleanup(func() { SetCurrent(previous) })
entered, finish, done := make(chan struct{}), make(chan struct{}), make(chan struct{})
go func() {
defer close(done)
_ = WhileWritable(func() error {
close(entered)
<-finish
return nil
})
}()
<-entered
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
defer cancel()
release, err := service.drainRequests(ctx)
release()
close(finish)
<-done
if !errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("migration did not wait for delivery: %v", err)
}
release, err = service.drainRequests(context.Background())
if err != nil {
t.Fatal(err)
}
executor.paused.Store(true)
release()
called := false
if err := WhileWritable(func() error { called = true; return nil }); err != nil || called {
t.Fatal("delivery started after source freeze")
}
}
+172
View File
@@ -0,0 +1,172 @@
package outbox
import (
stdcontext "context"
"errors"
"fmt"
"sync"
"time"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/hooks"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/dbmigration"
"git.pcux.cn/xuans/Smail/utils/context"
"git.pcux.cn/xuans/Smail/utils/send"
"git.pcux.cn/xuans/Smail/utils/smtp"
log "github.com/sirupsen/logrus"
"xorm.io/xorm"
)
type Runtime struct {
engine *xorm.Engine
stop chan struct{}
done chan struct{}
once sync.Once
deliver func(*context.Context, *parsemail.Email, string) error
}
func Start(engine *xorm.Engine) (*Runtime, error) {
if err := recoverInterrupted(engine); err != nil {
return nil, err
}
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: send.SendRecipientTriggered}
go r.loop()
return r, nil
}
func (r *Runtime) Stop(ctx stdcontext.Context) error {
if r == nil {
return nil
}
r.once.Do(func() { close(r.stop) })
select {
case <-r.done:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func (r *Runtime) loop() {
defer close(r.done)
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for {
select {
case <-r.stop:
return
default:
}
var jobs []models.OutboundDelivery
err := r.engine.Where("state = ? AND next_attempt <= ?", queued, time.Now().Unix()).Asc("id").Limit(20).Find(&jobs)
if err != nil {
log.WithError(err).Error("读取持久投递队列失败")
}
for _, job := range jobs {
select {
case <-r.stop:
return
default:
}
if err := r.process(job); err != nil {
log.WithError(err).WithField("delivery_id", job.ID).Error("处理持久投递队列失败")
}
}
select {
case <-r.stop:
return
case <-ticker.C:
}
}
}
func (r *Runtime) process(job models.OutboundDelivery) error {
// 迁移必须等待 SMTP 及结果落库结束,冻结源库后不再领取任务。
return dbmigration.WhileWritable(func() error { return r.processWritable(job) })
}
func (r *Runtime) processWritable(job models.OutboundDelivery) error {
// 读取失败时尚未开始投递,保留排队状态供数据库恢复后继续处理。
var stored models.Email
emailFound, err := r.engine.ID(job.EmailID).Get(&stored)
if err != nil {
return err
}
var user models.User
userFound := false
if emailFound {
userFound, err = r.engine.ID(stored.SendUserID).Get(&user)
if err != nil {
return err
}
}
owned, err := claim(r.engine, &job)
if err != nil || !owned {
return err
}
ctx := &context.Context{Context: stdcontext.Background()}
var message *parsemail.Email
deliveryErr := func() (result error) {
defer func() {
if value := recover(); value != nil {
result = &smtp.DeliveryUncertainError{Cause: fmt.Errorf("投递任务异常: %v", value)}
}
}()
if !emailFound {
return errors.New("待投递邮件已不存在")
}
if !userFound || user.Disabled != 0 {
return errors.New("发件账号不可用,已停止投递")
}
ctx.UserID, ctx.UserAccount, ctx.UserName, ctx.Role = user.ID, user.Account, user.Name, user.EffectiveRole()
message, err = parsemail.NewEmailFromModel(stored)
if err != nil {
return err
}
return r.deliver(ctx, message, job.Recipient)
}()
// 只重试结果落库,绝不因数据库故障再次调用 SMTP。
var terminal bool
for attempt := 0; attempt < 3; attempt++ {
terminal, err = finish(r.engine, job, deliveryErr)
if err == nil {
break
}
time.Sleep(time.Second)
}
if err != nil {
return fmt.Errorf("投递结果写入失败,保留在途记录并禁止自动重投: %w", err)
}
if terminal && message != nil {
r.notify(ctx, message, job.EmailID)
}
return nil
}
func (r *Runtime) notify(ctx *context.Context, message *parsemail.Email, emailID int) {
var jobs []models.OutboundDelivery
if err := r.engine.Where("email_id = ?", emailID).Find(&jobs); err != nil {
log.WithError(err).Error("读取投递结果用于插件通知失败")
return
}
failures := make(map[string]error)
for _, job := range jobs {
if job.State != accepted {
failures[job.Recipient] = errors.New(job.LastError)
}
}
for _, hook := range hooks.Snapshot() {
if hook == nil {
continue
}
func() {
defer func() {
if recover() != nil {
log.Error("投递完成插件发生异常")
}
}()
hook.SendAfter(ctx, message, failures)
}()
}
}
+179
View File
@@ -0,0 +1,179 @@
package outbox
import (
"database/sql"
"errors"
"fmt"
"sort"
"strings"
"time"
"git.pcux.cn/xuans/Smail/consts"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/logstore"
"git.pcux.cn/xuans/Smail/utils/send"
"git.pcux.cn/xuans/Smail/utils/smtp"
"xorm.io/xorm"
)
const (
queued = "queued"
running = "running"
accepted = "accepted"
failed = "failed"
uncertain = "uncertain"
maxAttempts = 5
uncertainMessage = "投递结果不确定,已暂停自动重试,请先核对收件结果"
)
// Enqueue 必须与邮件及用户关联在同一事务内保存,不保存验证码或恢复令牌。
func Enqueue(session *xorm.Session, email models.Email) error {
message, err := parsemail.NewEmailFromModel(email)
if err != nil {
return err
}
seen := make(map[string]bool)
for _, user := range append(append(message.To, message.Cc...), message.Bcc...) {
if user == nil || user.EmailAddress == "" {
return errors.New("队列收件人不能为空")
}
// 本地部分保留大小写,仅合并完全相同的 SMTP 信封地址。
address := user.EmailAddress
if at := strings.LastIndexByte(address, '@'); at >= 0 {
address = address[:at+1] + strings.ToLower(address[at+1:])
}
if seen[address] {
continue
}
seen[address] = true
job := models.OutboundDelivery{EmailID: email.Id, Recipient: address, State: queued}
if _, err := session.Insert(&job); err != nil {
return err
}
}
if len(seen) == 0 {
return errors.New("队列必须包含收件人")
}
return nil
}
func summarize(jobs []models.OutboundDelivery) (int8, string, bool) {
counts := make(map[string]int)
reasons := make(map[string]bool)
for _, job := range jobs {
counts[job.State]++
if job.LastError != "" {
reasons[job.LastError] = true
}
}
if counts[queued]+counts[running] > 0 {
return consts.EmailStatusDeliveryPending, "", false
}
details := make([]string, 0, len(reasons))
for reason := range reasons {
details = append(details, reason)
}
sort.Strings(details)
suffix := ""
if len(details) > 0 {
suffix = ";原因:" + strings.Join(details, ";")
}
if counts[uncertain] > 0 {
return consts.EmailStatusDeliveryUncertain, fmt.Sprintf("%s;已接收 %d,结果不确定 %d,失败 %d", uncertainMessage, counts[accepted], counts[uncertain], counts[failed]) + suffix, true
}
if len(jobs) > 0 && counts[accepted] == len(jobs) {
return consts.EmailStatusSent, "", true
}
return consts.EmailStatusFail, fmt.Sprintf("投递未全部完成;已接收 %d,失败 %d。已接收的收件人不会自动重投", counts[accepted], counts[failed]) + suffix, true
}
func syncStatus(session *xorm.Session, emailID int) (bool, error) {
var jobs []models.OutboundDelivery
if err := session.Where("email_id = ?", emailID).Find(&jobs); err != nil {
return false, err
}
status, message, terminal := summarize(jobs)
if _, err := session.ID(emailID).Cols("status", "error").Update(&models.Email{Status: status, Error: sql.NullString{String: message, Valid: true}}); err != nil {
return false, err
}
// 不改动用户已放入回收站的关联状态。
_, err := session.Where("email_id = ? AND status <> ?", emailID, consts.EmailStatusDel).Cols("status").Update(&models.UserEmail{Status: status})
return terminal, err
}
// recoverInterrupted 只在独占运行实例启动时执行,在途记录绝不重新排队。
func recoverInterrupted(engine *xorm.Engine) error {
return db.Transaction(engine, func(session *xorm.Session) error {
// 旧版本未记录 SMTP 尝试边界,只标记待核对,不能当作未发送任务导入。
var legacy []models.Email
if err := session.Where("type = ? AND status = ? AND id NOT IN (SELECT email_id FROM outbound_delivery)", consts.EmailTypeSend, consts.EmailStatusDeliveryPending).Find(&legacy); err != nil {
return err
}
for _, email := range legacy {
if _, err := session.ID(email.Id).Cols("status", "error").Update(&models.Email{Status: consts.EmailStatusDeliveryUncertain, Error: sql.NullString{String: uncertainMessage, Valid: true}}); err != nil {
return err
}
if _, err := session.Where("email_id = ? AND status = ?", email.Id, consts.EmailStatusDeliveryPending).Cols("status").Update(&models.UserEmail{Status: consts.EmailStatusDeliveryUncertain}); err != nil {
return err
}
}
var interrupted []models.OutboundDelivery
if err := session.Where("state = ?", running).Find(&interrupted); err != nil {
return err
}
if _, err := session.Where("state = ?", running).Cols("state", "last_error").Update(&models.OutboundDelivery{State: uncertain, LastError: uncertainMessage}); err != nil {
return err
}
seen := make(map[int]bool)
for _, job := range interrupted {
if !seen[job.EmailID] {
if _, err := syncStatus(session, job.EmailID); err != nil {
return err
}
seen[job.EmailID] = true
}
}
return nil
})
}
func claim(engine *xorm.Engine, job *models.OutboundDelivery) (bool, error) {
update := *job
update.State = running
update.Attempts++
count, err := engine.ID(job.ID).Where("state = ? AND attempts = ? AND next_attempt <= ?", queued, job.Attempts, time.Now().Unix()).Cols("state", "attempts").Update(&update)
if err == nil && count == 1 {
*job = update
}
return count == 1, err
}
func finish(engine *xorm.Engine, job models.OutboundDelivery, deliveryErr error) (bool, error) {
job.State, job.LastError, job.NextAttempt = accepted, "", 0
if deliveryErr != nil {
// 不保存远端响应原文,避免凭据或恶意超长内容进入数据库和页面。
job.State, job.LastError = failed, logstore.MailFailureReason(deliveryErr)
if smtp.IsDeliveryUncertain(deliveryErr) {
job.State = uncertain
job.LastError = uncertainMessage
} else if send.Retryable(deliveryErr) && job.Attempts < maxAttempts {
job.State = queued
job.NextAttempt = time.Now().Add(time.Minute * time.Duration(1<<(job.Attempts-1))).Unix()
}
}
terminal := false
err := db.Transaction(engine, func(session *xorm.Session) error {
count, err := session.ID(job.ID).Where("state = ? AND attempts = ?", running, job.Attempts).Cols("state", "last_error", "next_attempt").Update(&job)
if err != nil {
return err
}
if count != 1 {
return errors.New("投递任务状态已发生变化")
}
terminal, err = syncStatus(session, job.EmailID)
return err
})
return terminal, err
}
+340
View File
@@ -0,0 +1,340 @@
package outbox
import (
stdcontext "context"
"errors"
"io"
"net/textproto"
"strings"
"sync/atomic"
"testing"
"time"
"git.pcux.cn/xuans/Smail/consts"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/utils/context"
"git.pcux.cn/xuans/Smail/utils/smtp"
"xorm.io/xorm"
)
func queueFixture(t *testing.T) (*xorm.Engine, models.Email, []models.OutboundDelivery) {
t.Helper()
engine, err := xorm.NewEngine("sqlite", ":memory:")
if err != nil {
t.Fatal(err)
}
engine.SetMaxOpenConns(1)
t.Cleanup(func() { engine.Close() })
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.User{}, &models.OutboundDelivery{}); err != nil {
t.Fatal(err)
}
user := models.User{Account: "sender", Name: "sender", Password: "test", Role: "user"}
if _, err := engine.Insert(&user); err != nil {
t.Fatal(err)
}
email := models.Email{Type: consts.EmailTypeSend, Status: consts.EmailStatusDeliveryPending, SendUserID: user.ID, FromAddress: "sender@example.com", To: `[{"EmailAddress":"one@example.com"},{"EmailAddress":"two@example.com"}]`, Cc: `[{"EmailAddress":"one@EXAMPLE.com"}]`, MsgID: "stable@example.com"}
err = db.Transaction(engine, func(session *xorm.Session) error {
if _, err := session.Insert(&email); err != nil {
return err
}
if _, err := session.Insert(&models.UserEmail{UserID: user.ID, EmailID: email.Id, Status: consts.EmailStatusDeliveryPending}); err != nil {
return err
}
return Enqueue(session, email)
})
if err != nil {
t.Fatal(err)
}
var jobs []models.OutboundDelivery
if err := engine.Asc("id").Find(&jobs); err != nil {
t.Fatal(err)
}
if len(jobs) != 2 {
t.Fatalf("duplicate recipient: %v", jobs)
}
return engine, email, jobs
}
func assertStatus(t *testing.T, engine *xorm.Engine, emailID int, status int8) {
t.Helper()
var email models.Email
var relation models.UserEmail
if ok, err := engine.ID(emailID).Get(&email); err != nil || !ok {
t.Fatal(err)
}
if ok, err := engine.Where("email_id = ?", emailID).Get(&relation); err != nil || !ok {
t.Fatal(err)
}
if email.Status != status || relation.Status != status {
t.Fatalf("email=%d relation=%d want=%d", email.Status, relation.Status, status)
}
}
func TestClaimAndPartialResults(t *testing.T) {
engine, email, jobs := queueFixture(t)
first := jobs[0]
if ok, err := claim(engine, &first); err != nil || !ok {
t.Fatal(err)
}
if ok, err := claim(engine, &jobs[0]); err != nil || ok {
t.Fatalf("duplicate claim: %v %v", ok, err)
}
if _, err := finish(engine, first, nil); err != nil {
t.Fatal(err)
}
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryPending)
second := jobs[1]
if ok, err := claim(engine, &second); err != nil || !ok {
t.Fatal(err)
}
if _, err := finish(engine, second, &textproto.Error{Code: 451, Msg: "later"}); err != nil {
t.Fatal(err)
}
var queuedJob models.OutboundDelivery
if _, err := engine.ID(second.ID).Get(&queuedJob); err != nil {
t.Fatal(err)
}
if queuedJob.State != queued || queuedJob.NextAttempt <= time.Now().Unix() {
t.Fatalf("retry state=%+v", queuedJob)
}
if ok, err := claim(engine, &queuedJob); err != nil || ok {
t.Fatal("retry was claimed before backoff elapsed")
}
if _, err := engine.ID(queuedJob.ID).Cols("next_attempt").Update(&models.OutboundDelivery{}); err != nil {
t.Fatal(err)
}
if ok, err := claim(engine, &queuedJob); err != nil || !ok {
t.Fatal(err)
}
if _, err := finish(engine, queuedJob, &textproto.Error{Code: 550, Msg: "rejected"}); err != nil {
t.Fatal(err)
}
assertStatus(t, engine, email.Id, consts.EmailStatusFail)
if ok, err := claim(engine, &first); err != nil || ok {
t.Fatal("accepted job was claimed again")
}
}
func TestRestartDoesNotResendInterruptedOrAccepted(t *testing.T) {
engine, email, jobs := queueFixture(t)
for i := range jobs {
if ok, err := claim(engine, &jobs[i]); err != nil || !ok {
t.Fatal(err)
}
}
if _, err := finish(engine, jobs[0], nil); err != nil {
t.Fatal(err)
}
if err := recoverInterrupted(engine); err != nil {
t.Fatal(err)
}
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryUncertain)
var stored []models.OutboundDelivery
if err := engine.Asc("id").Find(&stored); err != nil {
t.Fatal(err)
}
if stored[0].State != accepted || stored[1].State != uncertain {
t.Fatalf("states=%+v", stored)
}
if err := recoverInterrupted(engine); err != nil {
t.Fatal(err)
}
}
func TestUncertainDATAIsNeverRetried(t *testing.T) {
engine, _, jobs := queueFixture(t)
job := jobs[0]
if ok, err := claim(engine, &job); err != nil || !ok {
t.Fatal(err)
}
if _, err := finish(engine, job, &smtp.DeliveryUncertainError{Cause: io.EOF}); err != nil {
t.Fatal(err)
}
if ok, err := claim(engine, &job); err != nil || ok {
t.Fatal("uncertain job was claimed again")
}
}
func TestResultFailureRollsBackAndNeverRedelivers(t *testing.T) {
engine, email, jobs := queueFixture(t)
if _, err := engine.Exec("CREATE TRIGGER reject_result BEFORE UPDATE ON user_email BEGIN SELECT RAISE(ABORT, 'injected failure'); END"); err != nil {
t.Fatal(err)
}
var calls atomic.Int32
r := &Runtime{engine: engine, deliver: func(_ *context.Context, e *parsemail.Email, recipient string) error {
calls.Add(1)
if e.MsgID != "stable@example.com" || len(e.To) != 2 || recipient != "one@example.com" {
t.Fatal("envelope changed message headers")
}
return nil
}}
if err := r.process(jobs[0]); err == nil {
t.Fatal("result failure was ignored")
}
if err := r.process(jobs[0]); err != nil {
t.Fatal(err)
}
if calls.Load() != 1 {
t.Fatalf("SMTP called %d times", calls.Load())
}
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryPending)
var job models.OutboundDelivery
if _, err := engine.ID(jobs[0].ID).Get(&job); err != nil {
t.Fatal(err)
}
if job.State != running {
t.Fatalf("state=%s", job.State)
}
}
func TestQueuedJobsSurviveRestartAndDrain(t *testing.T) {
engine, email, _ := queueFixture(t)
if err := recoverInterrupted(engine); err != nil {
t.Fatal(err)
}
var calls atomic.Int32
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error { calls.Add(1); return nil }}
go r.loop()
deadline := time.Now().Add(3 * time.Second)
for calls.Load() < 2 && time.Now().Before(deadline) {
time.Sleep(10 * time.Millisecond)
}
ctx, cancel := stdcontext.WithTimeout(stdcontext.Background(), time.Second)
defer cancel()
if err := r.Stop(ctx); err != nil {
t.Fatal(err)
}
if calls.Load() != 2 {
t.Fatalf("calls=%d", calls.Load())
}
assertStatus(t, engine, email.Id, consts.EmailStatusSent)
}
func TestRetryLimitAndSafeFailureDetails(t *testing.T) {
engine, _, jobs := queueFixture(t)
job := jobs[0]
for attempt := 1; attempt <= maxAttempts; attempt++ {
if _, err := engine.ID(job.ID).Cols("next_attempt").Update(&models.OutboundDelivery{}); err != nil {
t.Fatal(err)
}
if ok, err := claim(engine, &job); err != nil || !ok {
t.Fatalf("claim %d: %v", attempt, err)
}
before := time.Now().Unix()
if _, err := finish(engine, job, &textproto.Error{Code: 451, Msg: "sensitive-remote-response"}); err != nil {
t.Fatal(err)
}
var refreshed models.OutboundDelivery
if found, err := engine.ID(job.ID).Get(&refreshed); err != nil || !found {
t.Fatal(err)
}
job = refreshed
if strings.Contains(job.LastError, "sensitive") || !strings.Contains(job.LastError, "451") {
t.Fatalf("unsafe or missing failure details: %s", job.LastError)
}
if attempt < maxAttempts {
minimum := before + int64(60*(1<<(attempt-1)))
if job.State != queued || job.NextAttempt < minimum || job.NextAttempt > minimum+2 {
t.Fatalf("unexpected backoff: %+v", job)
}
} else if job.State != failed || job.NextAttempt != 0 {
t.Fatalf("retry limit ignored: %+v", job)
}
}
status, message, terminal := summarize([]models.OutboundDelivery{job})
if status != consts.EmailStatusFail || !terminal || !strings.Contains(message, "451") {
t.Fatalf("failure summary: %d %s %v", status, message, terminal)
}
}
func TestLegacyPendingIsUncertainWithoutEnqueue(t *testing.T) {
engine, _, _ := queueFixture(t)
email := models.Email{Type: consts.EmailTypeSend, Status: consts.EmailStatusDeliveryPending}
if _, err := engine.Insert(&email); err != nil {
t.Fatal(err)
}
if _, err := engine.Insert(&models.UserEmail{UserID: 1, EmailID: email.Id, Status: consts.EmailStatusDeliveryPending}); err != nil {
t.Fatal(err)
}
if err := recoverInterrupted(engine); err != nil {
t.Fatal(err)
}
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryUncertain)
count, err := engine.Where("email_id = ?", email.Id).Count(&models.OutboundDelivery{})
if err != nil || count != 0 {
t.Fatalf("legacy message enqueued: %d %v", count, err)
}
}
func TestReadFailureDoesNotClaimOrDeliver(t *testing.T) {
engine, _, jobs := queueFixture(t)
if _, err := engine.Exec("ALTER TABLE email RENAME TO unavailable_email"); err != nil {
t.Fatal(err)
}
r := &Runtime{engine: engine, deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error {
t.Fatal("SMTP called despite read failure")
return nil
}}
if err := r.process(jobs[0]); err == nil {
t.Fatal("read failure ignored")
}
var job models.OutboundDelivery
if _, err := engine.ID(jobs[0].ID).Get(&job); err != nil {
t.Fatal(err)
}
if job.State != queued || job.Attempts != 0 {
t.Fatalf("read failure consumed attempt: %+v", job)
}
}
func TestStopTimeoutDoesNotStartAnotherDelivery(t *testing.T) {
engine, _, _ := queueFixture(t)
entered, release := make(chan struct{}), make(chan struct{})
var calls atomic.Int32
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error {
if calls.Add(1) == 1 {
close(entered)
}
<-release
return nil
}}
go r.loop()
<-entered
ctx, cancel := stdcontext.WithTimeout(stdcontext.Background(), 20*time.Millisecond)
defer cancel()
err := r.Stop(ctx)
close(release)
if !errors.Is(err, stdcontext.DeadlineExceeded) {
t.Fatalf("stop did not time out: %v", err)
}
if err := r.Stop(stdcontext.Background()); err != nil {
t.Fatal(err)
}
if calls.Load() != 1 {
t.Fatalf("delivery started after stop: %d", calls.Load())
}
}
func TestDeliveryDoesNotRestoreTrashedRelation(t *testing.T) {
engine, email, jobs := queueFixture(t)
if _, err := engine.Where("email_id = ?", email.Id).Cols("status").Update(&models.UserEmail{Status: consts.EmailStatusDel}); err != nil {
t.Fatal(err)
}
for _, job := range jobs {
if ok, err := claim(engine, &job); err != nil || !ok {
t.Fatal(err)
}
if _, err := finish(engine, job, nil); err != nil {
t.Fatal(err)
}
}
var relation models.UserEmail
if _, err := engine.Where("email_id = ?", email.Id).Get(&relation); err != nil {
t.Fatal(err)
}
if relation.Status != consts.EmailStatusDel {
t.Fatal("delivery restored trashed message")
}
}