forward_test.go

package main

import (
	"bytes"
	"net"
	"strings"
	"testing"
	"time"

	"github.com/emersion/go-imap/backend/memory"
	"github.com/emersion/go-imap/client"
	"github.com/emersion/go-imap/server"
)

// startMemoryServer spins up an in-memory IMAP server (no TLS) on a random
// local port and returns its address.
func startMemoryServer(t *testing.T) string {
	t.Helper()
	be := memory.New()
	s := server.New(be)
	s.AllowInsecureAuth = true

	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("listen: %v", err)
	}
	go func() { _ = s.Serve(ln) }()
	t.Cleanup(func() { _ = s.Close() })
	return ln.Addr().String()
}

func dialTest(t *testing.T, addr string) *client.Client {
	t.Helper()
	c, err := client.Dial(addr) // plaintext for the test server
	if err != nil {
		t.Fatalf("dial: %v", err)
	}
	if err := c.Login("username", "password"); err != nil { // memory backend defaults
		t.Fatalf("login: %v", err)
	}
	if _, err := c.Select("INBOX", false); err != nil {
		t.Fatalf("select: %v", err)
	}
	t.Cleanup(func() { _ = c.Logout() })
	return c
}

func findMarker(msgs []fetchedMessage, marker string) *fetchedMessage {
	for i := range msgs {
		if bytes.Contains(msgs[i].raw, []byte(marker)) {
			return &msgs[i]
		}
	}
	return nil
}

// TestFetchUnseenAndMarkSeen verifies the three core IMAP guarantees:
//  1. fetchUnseen returns the full raw body of an unseen message,
//  2. fetching uses PEEK so the message stays UNSEEN afterwards,
//  3. markSeen removes it from the UNSEEN set.
func TestFetchUnseenAndMarkSeen(t *testing.T) {
	addr := startMemoryServer(t)
	c := dialTest(t, addr)

	const marker = "X-Imap2gmail-Test: nonce-9f3a"
	raw := "From: sender@example.com\r\n" +
		"To: dest@example.com\r\n" +
		"Subject: hello world\r\n" +
		marker + "\r\n\r\n" +
		"this is the body\r\n"
	if err := c.Append("INBOX", nil, time.Time{}, strings.NewReader(raw)); err != nil {
		t.Fatalf("append: %v", err)
	}

	msgs, err := fetchUnseen(c)
	if err != nil {
		t.Fatalf("fetchUnseen: %v", err)
	}
	got := findMarker(msgs, marker)
	if got == nil {
		t.Fatalf("appended message not found among %d unseen messages", len(msgs))
	}
	if !bytes.Contains(got.raw, []byte("this is the body")) {
		t.Fatalf("fetched body does not contain expected content: %q", got.raw)
	}

	// PEEK: message must still be UNSEEN after fetching.
	again, err := fetchUnseen(c)
	if err != nil {
		t.Fatalf("second fetchUnseen: %v", err)
	}
	if findMarker(again, marker) == nil {
		t.Fatal("message disappeared from UNSEEN after fetch — PEEK failed (it set \\Seen)")
	}

	// markSeen must remove it from UNSEEN.
	if err := markSeen(c, got.seqNum); err != nil {
		t.Fatalf("markSeen: %v", err)
	}
	after, err := fetchUnseen(c)
	if err != nil {
		t.Fatalf("post-markSeen fetchUnseen: %v", err)
	}
	if findMarker(after, marker) != nil {
		t.Fatal("message still UNSEEN after markSeen")
	}
}

func TestParseConfigMultiAccount(t *testing.T) {
	raw := `{
      "accounts": [
        {"name":"o2","imap":{"host":"poczta.o2.pl","user":"a@o2.pl","password":"p"},
         "gmail":{"token":{"client_id":"c","client_secret":"s","refresh_token":"r"}}},
        {"imap":{"host":"imap.wp.pl","port":993,"user":"b@wp.pl","password":"p2"},
         "gmail":{"user":"me","token":{"client_id":"c","client_secret":"s","refresh_token":"r"}}}
      ]}`
	cfg, err := parseConfig([]byte(raw))
	if err != nil {
		t.Fatalf("parseConfig: %v", err)
	}
	if len(cfg.Accounts) != 2 {
		t.Fatalf("want 2 accounts, got %d", len(cfg.Accounts))
	}
	// Defaults applied.
	if cfg.Accounts[0].IMAP.Port != 993 {
		t.Errorf("default port not applied: %d", cfg.Accounts[0].IMAP.Port)
	}
	if cfg.Accounts[0].IMAP.Mailbox != "INBOX" {
		t.Errorf("default mailbox not applied: %q", cfg.Accounts[0].IMAP.Mailbox)
	}
	if cfg.Accounts[1].Name != "imap.wp.pl" {
		t.Errorf("default name not derived from host: %q", cfg.Accounts[1].Name)
	}
	if !cfg.Accounts[0].markSeen() {
		t.Error("markSeen should default to true")
	}
}

func TestParseConfigRejectsIncomplete(t *testing.T) {
	raw := `{"accounts":[{"name":"x","imap":{"host":"h","user":"u","password":"p"},"gmail":{"token":{"client_id":"c"}}}]}`
	if _, err := parseConfig([]byte(raw)); err == nil {
		t.Fatal("expected error for incomplete gmail token, got nil")
	}
}