585 lines
21 KiB
Go
585 lines
21 KiB
Go
package imappresentation
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
|
|
"github.com/emersion/go-imap/v2"
|
|
"github.com/emersion/go-imap/v2/imapserver"
|
|
"github.com/google/uuid"
|
|
|
|
"lambdamail/protocols/internal/application/port"
|
|
"lambdamail/protocols/internal/application/usecase"
|
|
)
|
|
|
|
type fakeAuthRepository struct {
|
|
byAddress map[string]port.MailboxAuth
|
|
}
|
|
|
|
func (f *fakeAuthRepository) FindByAddress(_ context.Context, address string) (*port.MailboxAuth, error) {
|
|
rec, ok := f.byAddress[address]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
return &rec, nil
|
|
}
|
|
|
|
type fakeImapFolderRepository struct {
|
|
byName map[string]port.ImapFolderRecord
|
|
}
|
|
|
|
func (f *fakeImapFolderRepository) ListFolders(_ context.Context, _ string) ([]port.ImapFolderRecord, error) {
|
|
var out []port.ImapFolderRecord
|
|
for _, rec := range f.byName {
|
|
out = append(out, rec)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (f *fakeImapFolderRepository) FindByName(_ context.Context, _ string, name string) (*port.ImapFolderRecord, error) {
|
|
rec, ok := f.byName[name]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
return &rec, nil
|
|
}
|
|
|
|
type fakeMessageQueryRepository struct {
|
|
messages []port.MessageRecord
|
|
}
|
|
|
|
func (f *fakeMessageQueryRepository) ListMessages(_ context.Context, _ string) ([]port.MessageRecord, error) {
|
|
return f.messages, nil
|
|
}
|
|
|
|
type fakeFlagRepository struct {
|
|
lastFolderID string
|
|
lastUID uint32
|
|
lastOp port.FlagOp
|
|
lastFlags []string
|
|
|
|
calls []fakeFlagCall
|
|
}
|
|
|
|
type fakeFlagCall struct {
|
|
folderID string
|
|
uid uint32
|
|
op port.FlagOp
|
|
flags []string
|
|
}
|
|
|
|
func (f *fakeFlagRepository) SetFlags(_ context.Context, folderID string, uid uint32, op port.FlagOp, flags []string, _ uint64) (bool, error) {
|
|
f.lastFolderID, f.lastUID, f.lastOp, f.lastFlags = folderID, uid, op, flags
|
|
f.calls = append(f.calls, fakeFlagCall{folderID: folderID, uid: uid, op: op, flags: flags})
|
|
return true, nil
|
|
}
|
|
|
|
type fakeBlobReader struct {
|
|
content map[uuid.UUID][]byte
|
|
}
|
|
|
|
func (f *fakeBlobReader) ReadByID(_ context.Context, blobID uuid.UUID) ([]byte, error) {
|
|
return f.content[blobID], nil
|
|
}
|
|
|
|
// fakeExpungeRepository/fakeCopyRepository duplicate the fakes from
|
|
// internal/application/usecase/imap_session_test.go - Go test files in
|
|
// different packages can't share unexported test helpers.
|
|
type fakeExpungeRepository struct {
|
|
calls []struct {
|
|
folderID string
|
|
uids []uint32
|
|
}
|
|
}
|
|
|
|
func (f *fakeExpungeRepository) Expunge(_ context.Context, folderID string, uids []uint32) error {
|
|
f.calls = append(f.calls, struct {
|
|
folderID string
|
|
uids []uint32
|
|
}{folderID, uids})
|
|
return nil
|
|
}
|
|
|
|
type fakeCopyRepository struct {
|
|
result []port.CopiedMessage
|
|
}
|
|
|
|
func (f *fakeCopyRepository) CopyMessages(_ context.Context, _ string, _ []uint32, _ string) ([]port.CopiedMessage, error) {
|
|
return f.result, nil
|
|
}
|
|
|
|
// testPasswordHash/testPassword duplicate the constants from
|
|
// internal/application/usecase/imap_session_test.go - a real Argon2id PHC
|
|
// hash for "correct horse battery staple", generated once with
|
|
// argon2id.CreateHash and hardcoded (see that file's Task 2 note for how
|
|
// to generate it).
|
|
const (
|
|
testPassword = "correct horse battery staple"
|
|
testPasswordHash = "$argon2id$v=19$m=65536,t=1,p=12$I88aUc0rZHHX+Bt+jX+4Ag$3jKTtg1khJjFo9az4iPvFLc3eKY8WKSFy/1YMXlKvSU"
|
|
)
|
|
|
|
func newTestSession(auth *fakeAuthRepository, folders *fakeImapFolderRepository, messages *fakeMessageQueryRepository, flags *fakeFlagRepository, blobs *fakeBlobReader) imapserver.Session {
|
|
// expunger/copier are nil here: none of the tests using this helper
|
|
// exercise Expunge/CopyMessages, and NewImapSessionUseCase only stores
|
|
// these interfaces without dereferencing them at construction time.
|
|
// Tests that DO exercise Expunge/Copy use
|
|
// newTestSessionWithExpungeAndCopy below instead.
|
|
return newTestSessionWithExpungeAndCopy(auth, folders, messages, flags, blobs, nil, nil)
|
|
}
|
|
|
|
func newTestSessionWithExpungeAndCopy(auth *fakeAuthRepository, folders *fakeImapFolderRepository, messages *fakeMessageQueryRepository, flags *fakeFlagRepository, blobs *fakeBlobReader, expunger *fakeExpungeRepository, copier *fakeCopyRepository) imapserver.Session {
|
|
var expungeRepo port.ExpungeRepository
|
|
if expunger != nil {
|
|
expungeRepo = expunger
|
|
}
|
|
var copyRepo port.CopyRepository
|
|
if copier != nil {
|
|
copyRepo = copier
|
|
}
|
|
uc := usecase.NewImapSessionUseCase(auth, folders, messages, flags, blobs, expungeRepo, copyRepo)
|
|
sess, _, err := NewSession(nil, uc)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return sess
|
|
}
|
|
|
|
func TestSession_Login_SucceedsForCorrectCredentials(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
sess := newTestSession(auth, nil, nil, nil, nil)
|
|
|
|
if err := sess.Login("user@example.test", testPassword); err != nil {
|
|
t.Fatalf("Login: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSession_Login_FailsForWrongPassword(t *testing.T) {
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: uuid.New(), PasswordHash: testPasswordHash},
|
|
}}
|
|
sess := newTestSession(auth, nil, nil, nil, nil)
|
|
|
|
err := sess.Login("user@example.test", "wrong")
|
|
if err == nil {
|
|
t.Fatal("expected an error for wrong password, got nil")
|
|
}
|
|
var imapErr *imap.Error
|
|
if !errors.As(err, &imapErr) {
|
|
t.Fatalf("error is not an *imap.Error: %v", err)
|
|
}
|
|
if imapErr.Type != imap.StatusResponseTypeNo {
|
|
t.Errorf("Type = %v, want StatusResponseTypeNo", imapErr.Type)
|
|
}
|
|
}
|
|
|
|
func TestSession_Select_ReturnsDataForKnownFolder(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{
|
|
"INBOX": {ID: "folder-1", Name: "INBOX", UIDNext: 5, UIDValidity: 999, NumMessages: 3},
|
|
}}
|
|
sess := newTestSession(auth, folders, &fakeMessageQueryRepository{}, &fakeFlagRepository{}, &fakeBlobReader{})
|
|
if err := sess.Login("user@example.test", testPassword); err != nil {
|
|
t.Fatalf("Login: %v", err)
|
|
}
|
|
|
|
data, err := sess.Select("INBOX", &imap.SelectOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Select: %v", err)
|
|
}
|
|
if data.UIDNext != 5 || data.UIDValidity != 999 || data.NumMessages != 3 {
|
|
t.Errorf("data = %+v, want UIDNext=5 UIDValidity=999 NumMessages=3", data)
|
|
}
|
|
}
|
|
|
|
func TestSession_Select_FailsForUnknownFolder(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{}}
|
|
sess := newTestSession(auth, folders, &fakeMessageQueryRepository{}, &fakeFlagRepository{}, &fakeBlobReader{})
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
|
|
_, err := sess.Select("Nonexistent", &imap.SelectOptions{})
|
|
if err == nil {
|
|
t.Fatal("expected an error for an unknown folder, got nil")
|
|
}
|
|
}
|
|
|
|
func TestSession_Store_CallsFlagRepositoryWithCorrectArgs(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{
|
|
"INBOX": {ID: "folder-1", Name: "INBOX"},
|
|
}}
|
|
flags := &fakeFlagRepository{}
|
|
messages := &fakeMessageQueryRepository{messages: []port.MessageRecord{{UID: 7}}}
|
|
sess := newTestSession(auth, folders, messages, flags, &fakeBlobReader{})
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
if _, err := sess.Select("INBOX", &imap.SelectOptions{}); err != nil {
|
|
t.Fatalf("Select: %v", err)
|
|
}
|
|
|
|
numSet := imap.UIDSetNum(7)
|
|
err := sess.Store(nil, numSet, &imap.StoreFlags{
|
|
Op: imap.StoreFlagsAdd,
|
|
Silent: true,
|
|
Flags: []imap.Flag{imap.FlagSeen},
|
|
}, &imap.StoreOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Store: %v", err)
|
|
}
|
|
if flags.lastFolderID != "folder-1" || flags.lastUID != 7 || flags.lastOp != port.FlagOpAdd {
|
|
t.Errorf("flags recorded = folderID=%q uid=%d op=%v, want folder-1/7/FlagOpAdd", flags.lastFolderID, flags.lastUID, flags.lastOp)
|
|
}
|
|
}
|
|
|
|
// TestSession_Store_HandlesUIDStarRange proves that UID STORE with a dynamic
|
|
// open-ended range (e.g. "UID STORE 5:* +FLAGS (\Seen)", the "mark all as
|
|
// read" operation) resolves against the folder's real message list instead
|
|
// of relying on NumSet.Nums(), which returns (nil, false) for such ranges.
|
|
func TestSession_Store_HandlesUIDStarRange(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{
|
|
"INBOX": {ID: "folder-1", Name: "INBOX"},
|
|
}}
|
|
flags := &fakeFlagRepository{}
|
|
messages := &fakeMessageQueryRepository{messages: []port.MessageRecord{
|
|
{UID: 5}, {UID: 7}, {UID: 9},
|
|
}}
|
|
sess := newTestSession(auth, folders, messages, flags, &fakeBlobReader{})
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
if _, err := sess.Select("INBOX", &imap.SelectOptions{}); err != nil {
|
|
t.Fatalf("Select: %v", err)
|
|
}
|
|
|
|
// "5:*" - an open-ended dynamic range, the single most common real-world
|
|
// STORE usage ("mark all as read").
|
|
var numSet imap.UIDSet
|
|
numSet.AddRange(5, 0)
|
|
|
|
err := sess.Store(nil, numSet, &imap.StoreFlags{
|
|
Op: imap.StoreFlagsAdd,
|
|
Silent: true,
|
|
Flags: []imap.Flag{imap.FlagSeen},
|
|
}, &imap.StoreOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Store: %v", err)
|
|
}
|
|
|
|
if len(flags.calls) != 3 {
|
|
t.Fatalf("SetFlags called %d times, want 3 (all messages with UID >= 5)", len(flags.calls))
|
|
}
|
|
gotUIDs := map[uint32]bool{}
|
|
for _, c := range flags.calls {
|
|
gotUIDs[c.uid] = true
|
|
if c.op != port.FlagOpAdd || c.folderID != "folder-1" {
|
|
t.Errorf("call = %+v, want op=FlagOpAdd folderID=folder-1", c)
|
|
}
|
|
}
|
|
for _, want := range []uint32{5, 7, 9} {
|
|
if !gotUIDs[want] {
|
|
t.Errorf("SetFlags was not called for UID %d", want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestSession_Store_AllowsSequenceNumberSet proves that plain (non-UID)
|
|
// STORE, identified by a SeqSet rather than a UIDSet, is accepted and
|
|
// resolved against the message at that sequence position - the
|
|
// numSetIter-based design supports this the same way Fetch does, unlike the
|
|
// old implementation, which rejected any non-UIDSet outright.
|
|
func TestSession_Store_AllowsSequenceNumberSet(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{
|
|
"INBOX": {ID: "folder-1", Name: "INBOX"},
|
|
}}
|
|
flags := &fakeFlagRepository{}
|
|
messages := &fakeMessageQueryRepository{messages: []port.MessageRecord{
|
|
{UID: 5}, {UID: 7}, {UID: 9},
|
|
}}
|
|
sess := newTestSession(auth, folders, messages, flags, &fakeBlobReader{})
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
if _, err := sess.Select("INBOX", &imap.SelectOptions{}); err != nil {
|
|
t.Fatalf("Select: %v", err)
|
|
}
|
|
|
|
// Sequence number 1 refers to the first message in the folder's list
|
|
// (UID 5), not to "UID 1".
|
|
numSet := imap.SeqSetNum(1)
|
|
|
|
err := sess.Store(nil, numSet, &imap.StoreFlags{
|
|
Op: imap.StoreFlagsAdd,
|
|
Silent: true,
|
|
Flags: []imap.Flag{imap.FlagSeen},
|
|
}, &imap.StoreOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Store: %v", err)
|
|
}
|
|
|
|
if len(flags.calls) != 1 {
|
|
t.Fatalf("SetFlags called %d times, want 1", len(flags.calls))
|
|
}
|
|
if flags.calls[0].uid != 5 || flags.calls[0].folderID != "folder-1" || flags.calls[0].op != port.FlagOpAdd {
|
|
t.Errorf("call = %+v, want uid=5 folderID=folder-1 op=FlagOpAdd", flags.calls[0])
|
|
}
|
|
}
|
|
|
|
// TestMatchFolders_FiltersByWildcardPattern exercises the folder-matching
|
|
// logic extracted from Session.List (matchFolders). Session.List itself
|
|
// cannot be driven directly in a unit test because *imapserver.ListWriter
|
|
// has no exported constructor and can only be built by a live
|
|
// *imapserver.Conn - so this test proves the matching/filtering behavior
|
|
// that List delegates to, and fails if that logic regresses (e.g. matching
|
|
// nothing, matching everything regardless of pattern, or mishandling the
|
|
// hierarchy delimiter).
|
|
func TestMatchFolders_FiltersByWildcardPattern(t *testing.T) {
|
|
recs := []port.ImapFolderRecord{
|
|
{ID: "1", Name: "INBOX"},
|
|
{ID: "2", Name: "Archive"},
|
|
{ID: "3", Name: "Archive/2024"},
|
|
{ID: "4", Name: "Sent"},
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
ref string
|
|
patterns []string
|
|
want []string
|
|
}{
|
|
{
|
|
name: "star matches everything including nested",
|
|
ref: "",
|
|
patterns: []string{"*"},
|
|
want: []string{"INBOX", "Archive", "Archive/2024", "Sent"},
|
|
},
|
|
{
|
|
name: "percent does not cross hierarchy delimiter",
|
|
ref: "",
|
|
patterns: []string{"%"},
|
|
want: []string{"INBOX", "Archive", "Sent"},
|
|
},
|
|
{
|
|
name: "exact literal match",
|
|
ref: "",
|
|
patterns: []string{"INBOX"},
|
|
want: []string{"INBOX"},
|
|
},
|
|
{
|
|
name: "multiple patterns are unioned",
|
|
ref: "",
|
|
patterns: []string{"INBOX", "Sent"},
|
|
want: []string{"INBOX", "Sent"},
|
|
},
|
|
{
|
|
name: "no pattern matches anything",
|
|
ref: "",
|
|
patterns: []string{"Nonexistent"},
|
|
want: nil,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got := matchFolders(recs, tc.ref, tc.patterns)
|
|
var gotNames []string
|
|
for _, rec := range got {
|
|
gotNames = append(gotNames, rec.Name)
|
|
}
|
|
if len(gotNames) != len(tc.want) {
|
|
t.Fatalf("matchFolders() = %v, want %v", gotNames, tc.want)
|
|
}
|
|
wantSet := map[string]bool{}
|
|
for _, w := range tc.want {
|
|
wantSet[w] = true
|
|
}
|
|
for _, n := range gotNames {
|
|
if !wantSet[n] {
|
|
t.Errorf("matchFolders() included unexpected folder %q; got %v, want %v", n, gotNames, tc.want)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestSession_List_UsesFolderRepository proves Session.List consults
|
|
// useCase.ListFolders (via the fake ImapFolderRepository) rather than some
|
|
// hardcoded set - a sanity check that List is actually wired to real data,
|
|
// complementing the matchFolders unit test above and the full E2E LIST
|
|
// assertion in imap_core_e2e_test.go which drives List through a real
|
|
// *imapserver.ListWriter.
|
|
func TestSession_List_UsesFolderRepository(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{
|
|
"INBOX": {ID: "folder-1", Name: "INBOX"},
|
|
}}
|
|
sess := newTestSession(auth, folders, &fakeMessageQueryRepository{}, &fakeFlagRepository{}, &fakeBlobReader{}).(*session)
|
|
if err := sess.Login("user@example.test", testPassword); err != nil {
|
|
t.Fatalf("Login: %v", err)
|
|
}
|
|
|
|
recs, err := sess.useCase.ListFolders(context.Background(), sess.mailboxID)
|
|
if err != nil {
|
|
t.Fatalf("ListFolders: %v", err)
|
|
}
|
|
matched := matchFolders(recs, "", []string{"*"})
|
|
if len(matched) != 1 || matched[0].Name != "INBOX" {
|
|
t.Errorf("matched = %+v, want a single INBOX record", matched)
|
|
}
|
|
}
|
|
|
|
func TestSession_Expunge_CallsUseCaseWithDeletedUIDsOnly(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{"INBOX": {ID: "folder-1", NumMessages: 3}}}
|
|
messages := &fakeMessageQueryRepository{messages: []port.MessageRecord{
|
|
{UID: 1, Flags: []string{"\\Deleted"}},
|
|
{UID: 2, Flags: nil},
|
|
{UID: 3, Flags: []string{"\\Deleted", "\\Seen"}},
|
|
}}
|
|
expunger := &fakeExpungeRepository{}
|
|
sess := newTestSessionWithExpungeAndCopy(auth, folders, messages, &fakeFlagRepository{}, &fakeBlobReader{}, expunger, &fakeCopyRepository{})
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
if _, err := sess.Select("INBOX", &imap.SelectOptions{}); err != nil {
|
|
t.Fatalf("Select: %v", err)
|
|
}
|
|
|
|
if err := sess.Expunge(nil, nil); err != nil {
|
|
t.Fatalf("Expunge: %v", err)
|
|
}
|
|
if len(expunger.calls) != 1 {
|
|
t.Fatalf("expunger called %d times, want 1", len(expunger.calls))
|
|
}
|
|
uids := expunger.calls[0].uids
|
|
if len(uids) != 2 || uids[0] != 1 || uids[1] != 3 {
|
|
t.Errorf("expunged uids = %v, want [1 3] (only \\Deleted messages)", uids)
|
|
}
|
|
}
|
|
|
|
func TestSession_Copy_CallsUseCaseAndBuildsCopyData(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{
|
|
"INBOX": {ID: "folder-1"},
|
|
"Archive": {ID: "folder-2", UIDValidity: 42},
|
|
}}
|
|
messages := &fakeMessageQueryRepository{messages: []port.MessageRecord{{UID: 5}}}
|
|
copier := &fakeCopyRepository{result: []port.CopiedMessage{{SourceUID: 5, DestUID: 1}}}
|
|
sess := newTestSessionWithExpungeAndCopy(auth, folders, messages, &fakeFlagRepository{}, &fakeBlobReader{}, &fakeExpungeRepository{}, copier)
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
_, _ = sess.Select("INBOX", &imap.SelectOptions{})
|
|
|
|
data, err := sess.Copy(imap.UIDSetNum(5), "Archive")
|
|
if err != nil {
|
|
t.Fatalf("Copy: %v", err)
|
|
}
|
|
if data.UIDValidity != 42 {
|
|
t.Errorf("UIDValidity = %d, want 42", data.UIDValidity)
|
|
}
|
|
srcNums, _ := data.SourceUIDs.Nums()
|
|
destNums, _ := data.DestUIDs.Nums()
|
|
if len(srcNums) != 1 || srcNums[0] != 5 || len(destNums) != 1 || destNums[0] != 1 {
|
|
t.Errorf("SourceUIDs=%v DestUIDs=%v, want [5]/[1]", srcNums, destNums)
|
|
}
|
|
}
|
|
|
|
func TestSession_Copy_FailsForUnknownDestination(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{"INBOX": {ID: "folder-1"}}}
|
|
sess := newTestSessionWithExpungeAndCopy(auth, folders, &fakeMessageQueryRepository{}, &fakeFlagRepository{}, &fakeBlobReader{}, &fakeExpungeRepository{}, &fakeCopyRepository{})
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
_, _ = sess.Select("INBOX", &imap.SelectOptions{})
|
|
|
|
_, err := sess.Copy(imap.UIDSetNum(5), "Nonexistent")
|
|
if err == nil {
|
|
t.Fatal("expected an error copying to a nonexistent folder, got nil")
|
|
}
|
|
}
|
|
|
|
// TestSession_Move_ExpungesCopiedMessageEvenWithoutDeletedFlag proves the
|
|
// RFC 6851 fix: MOVE must expunge exactly the UIDs it just copied,
|
|
// regardless of whether they carry \Deleted. Before this fix, Move called
|
|
// the shared expungeUIDs helper in its \Deleted-requiring mode (the one
|
|
// correct for EXPUNGE), so a message with no \Deleted flag would be copied
|
|
// into the destination but never removed from the source folder - a silent
|
|
// duplication instead of a move.
|
|
func TestSession_Move_ExpungesCopiedMessageEvenWithoutDeletedFlag(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
folders := &fakeImapFolderRepository{byName: map[string]port.ImapFolderRecord{
|
|
"INBOX": {ID: "folder-1", NumMessages: 1},
|
|
"Archive": {ID: "folder-2", UIDValidity: 42},
|
|
}}
|
|
// UID 5 has no \Deleted flag - MOVE must still expunge it from the
|
|
// source folder, unlike EXPUNGE which would skip it.
|
|
messages := &fakeMessageQueryRepository{messages: []port.MessageRecord{{UID: 5, Flags: nil}}}
|
|
expunger := &fakeExpungeRepository{}
|
|
copier := &fakeCopyRepository{result: []port.CopiedMessage{{SourceUID: 5, DestUID: 1}}}
|
|
sess := newTestSessionWithExpungeAndCopy(auth, folders, messages, &fakeFlagRepository{}, &fakeBlobReader{}, expunger, copier)
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
if _, err := sess.Select("INBOX", &imap.SelectOptions{}); err != nil {
|
|
t.Fatalf("Select: %v", err)
|
|
}
|
|
|
|
// w is nil here for the same reason Expunge's tests pass a nil writer:
|
|
// *imapserver.MoveWriter has no exported constructor and can only be
|
|
// built by a live *imapserver.Conn.
|
|
if err := sess.(*session).Move(nil, imap.UIDSetNum(5), "Archive"); err != nil {
|
|
t.Fatalf("Move: %v", err)
|
|
}
|
|
|
|
if len(expunger.calls) != 1 {
|
|
t.Fatalf("expunger called %d times, want 1", len(expunger.calls))
|
|
}
|
|
uids := expunger.calls[0].uids
|
|
if len(uids) != 1 || uids[0] != 5 {
|
|
t.Errorf("expunged uids = %v, want [5] (moved even though it has no \\Deleted flag)", uids)
|
|
}
|
|
}
|
|
|
|
func TestStubMethods_ReturnNotYetImplementedError(t *testing.T) {
|
|
mailboxID := uuid.New()
|
|
auth := &fakeAuthRepository{byAddress: map[string]port.MailboxAuth{
|
|
"user@example.test": {ID: mailboxID, PasswordHash: testPasswordHash},
|
|
}}
|
|
sess := newTestSession(auth, &fakeImapFolderRepository{}, &fakeMessageQueryRepository{}, &fakeFlagRepository{}, &fakeBlobReader{})
|
|
_ = sess.Login("user@example.test", testPassword)
|
|
|
|
if err := sess.Create("Nonexistent", nil); err == nil {
|
|
t.Error("Create: expected an error, got nil")
|
|
}
|
|
if _, err := sess.Search(imapserver.NumKindUID, &imap.SearchCriteria{}, &imap.SearchOptions{}); err == nil {
|
|
t.Error("Search: expected an error, got nil")
|
|
}
|
|
if _, err := sess.Copy(imap.UIDSetNum(1), "Other"); err == nil {
|
|
t.Error("Copy: expected an error, got nil")
|
|
}
|
|
}
|