pop3/conn_test.go

   1 package pop3
   2
   3 import (
   4         "fmt"
   5         "io"
   6         "io/ioutil"
   7         "net"
   8         "net/textproto"
   9         "path/filepath"
  10         "reflect"
  11         "runtime"
  12         "strings"
  13         "testing"
  14
  15         "github.com/uber-go/zap"
  16 )
  17
  18 func _fl(depth int) string {
  19         _, file, line, _ := runtime.Caller(depth + 1)
  20         return fmt.Sprintf("[%s:%d]", filepath.Base(file), line)
  21 }
  22
  23 func ok(t testing.TB, err error) {
  24         if err != nil {
  25                 t.Errorf("%s unexpected error: %v", _fl(1), err)
  26         }
  27 }
  28
  29 func responseOK(t testing.TB, conn *textproto.Conn) string {
  30         line, err := conn.ReadLine()
  31         if err != nil {
  32                 t.Errorf("%s responseOK: %v", _fl(1), err)
  33         }
  34         if !strings.HasPrefix(line, "+OK") {
  35                 t.Errorf("%s expected +OK, got %q", _fl(1), line)
  36         }
  37         return line
  38 }
  39
  40 func responseERR(t testing.TB, conn *textproto.Conn) string {
  41         line, err := conn.ReadLine()
  42         if err != nil {
  43                 t.Errorf("%s responseERR: %v", _fl(1), err)
  44         }
  45         if !strings.HasPrefix(line, "-ERR") {
  46                 t.Errorf("%s expected -ERR, got %q", _fl(1), line)
  47         }
  48         return line
  49 }
  50
  51 func runServer(t *testing.T, po PostOffice) net.Listener {
  52         l, err := net.Listen("tcp", "localhost:0")
  53         if err != nil {
  54                 t.Fatal(err)
  55                 return nil
  56         }
  57
  58         go func() {
  59                 for {
  60                         conn, err := l.Accept()
  61                         if err != nil {
  62                                 return
  63                         }
  64                         go AcceptConnection(conn, po, zap.New(zap.NullEncoder()))
  65                 }
  66         }()
  67         return l
  68 }
  69
  70 type testServer struct {
  71         user, pass string
  72         mb         testMailbox
  73 }
  74
  75 func (s *testServer) Name() string {
  76         return "Test-Server"
  77 }
  78
  79 func (s *testServer) OpenMailbox(user, pass string) (Mailbox, error) {
  80         if s.user == user && s.pass == pass {
  81                 return &s.mb, nil
  82         }
  83         return nil, fmt.Errorf("bad username/pass")
  84 }
  85
  86 type testMailbox struct {
  87         msgs map[int]*testMessage
  88 }
  89
  90 func (mb *testMailbox) ListMessages() ([]Message, error) {
  91         msgs := make([]Message, 0, len(mb.msgs))
  92         for i, _ := range mb.msgs {
  93                 msgs = append(msgs, mb.msgs[i])
  94         }
  95         return msgs, nil
  96 }
  97
  98 func (mb *testMailbox) GetMessage(id int) Message {
  99         if msg, ok := mb.msgs[id]; ok {
 100                 return msg
 101         }
 102         return nil
 103 }
 104
 105 func (mb *testMailbox) Retrieve(msg Message) (io.ReadCloser, error) {
 106         r := strings.NewReader(msg.(*testMessage).body)
 107         return ioutil.NopCloser(r), nil
 108 }
 109
 110 func (mb *testMailbox) Delete(msg Message) error {
 111         msg.(*testMessage).deleted = true
 112         return nil
 113 }
 114
 115 func (mb *testMailbox) Close() error {
 116         return nil
 117 }
 118
 119 func (mb *testMailbox) Reset() {
 120         for _, msg := range mb.msgs {
 121                 msg.deleted = false
 122         }
 123 }
 124
 125 type testMessage struct {
 126         id      int
 127         size    int
 128         deleted bool
 129         body    string
 130 }
 131
 132 func (m *testMessage) UniqueID() string {
 133         return fmt.Sprintf("%p", m)
 134 }
 135
 136 func (m *testMessage) ID() int {
 137         return m.id
 138 }
 139 func (m *testMessage) Size() int {
 140         return m.size
 141 }
 142 func (m *testMessage) Deleted() bool {
 143         return m.deleted
 144 }
 145
 146 func newTestServer() *testServer {
 147         return &testServer{
 148                 user: "u",
 149                 pass: "p",
 150                 mb: testMailbox{
 151                         msgs: make(map[int]*testMessage),
 152                 },
 153         }
 154 }
 155
 156 // RFC 1939 § 10
 157 func TestExampleSession(t *testing.T) {
 158         s := newTestServer()
 159         l := runServer(t, s)
 160         defer l.Close()
 161
 162         s.mb.msgs[1] = &testMessage{1, 120, false, ""}
 163         s.mb.msgs[2] = &testMessage{2, 200, false, ""}
 164
 165         conn, err := textproto.Dial(l.Addr().Network(), l.Addr().String())
 166         ok(t, err)
 167
 168         line := responseOK(t, conn)
 169         if !strings.Contains(line, s.Name()) {
 170                 t.Errorf("POP greeting did not include server name, got %q", line)
 171         }
 172
 173         ok(t, conn.PrintfLine("USER u"))
 174         responseOK(t, conn)
 175
 176         ok(t, conn.PrintfLine("PASS p"))
 177         responseOK(t, conn)
 178
 179         ok(t, conn.PrintfLine("STAT"))
 180         line = responseOK(t, conn)
 181         expected := "+OK 2 320"
 182         if line != expected {
 183                 t.Errorf("STAT expected %q, got %q", expected, line)
 184         }
 185
 186         ok(t, conn.PrintfLine("LIST"))
 187         responseOK(t, conn)
 188         lines, err := conn.ReadDotLines()
 189         ok(t, err)
 190         if len(lines) != 2 {
 191                 t.Errorf("LIST expected 2 lines, got %d", len(lines))
 192         }
 193         expected = "1 120"
 194         if lines[0] != expected {
 195                 t.Errorf("LIST line 0 expected %q, got %q", expected, lines[0])
 196         }
 197         expected = "2 200"
 198         if lines[1] != expected {
 199                 t.Errorf("LIST line 1 expected %q, got %q", expected, lines[1])
 200         }
 201
 202         ok(t, conn.PrintfLine("QUIT"))
 203         responseOK(t, conn)
 204 }
 205
 206 type requestResponse struct {
 207         command  string
 208         expecter func(testing.TB, *textproto.Conn) string
 209 }
 210
 211 func expectOKResponse(predicate func(string) bool) func(testing.TB, *textproto.Conn) string {
 212         return func(t testing.TB, conn *textproto.Conn) string {
 213                 line := responseOK(t, conn)
 214                 if !predicate(line) {
 215                         t.Errorf("%s Predicate failed, got %q", _fl(1), line)
 216                 }
 217                 return line
 218         }
 219 }
 220
 221 func clientServerTest(t *testing.T, s *testServer, sequence []requestResponse) {
 222         l := runServer(t, s)
 223         defer l.Close()
 224
 225         conn, err := textproto.Dial(l.Addr().Network(), l.Addr().String())
 226         ok(t, err)
 227
 228         responseOK(t, conn)
 229
 230         for _, pair := range sequence {
 231                 ok(t, conn.PrintfLine(pair.command))
 232                 pair.expecter(t, conn)
 233                 if t.Failed() {
 234                         t.Logf("command %q", pair.command)
 235                 }
 236         }
 237 }
 238
 239 func TestAuthStates(t *testing.T) {
 240         clientServerTest(t, newTestServer(), []requestResponse{
 241                 {"STAT", responseERR},
 242                 {"NOOP", responseOK},
 243                 {"USER bad", responseOK},
 244                 {"PASS bad", responseERR},
 245                 {"LIST", responseERR},
 246                 {"USER u", responseOK},
 247                 {"PASS bad", responseERR},
 248                 {"STAT", responseERR},
 249                 {"PASS p", responseOK},
 250                 {"QUIT", responseOK},
 251         })
 252 }
 253
 254 func TestDeleted(t *testing.T) {
 255         s := newTestServer()
 256         s.mb.msgs[1] = &testMessage{1, 999, false, ""}
 257         s.mb.msgs[2] = &testMessage{2, 10, false, ""}
 258
 259         clientServerTest(t, s, []requestResponse{
 260                 {"USER u", responseOK},
 261                 {"PASS p", responseOK},
 262                 {"STAT", expectOKResponse(func(s string) bool {
 263                         return s == "+OK 2 1009"
 264                 })},
 265                 {"DELE 1", responseOK},
 266                 {"RETR 1", responseERR},
 267                 {"DELE 1", responseERR},
 268                 {"STAT", expectOKResponse(func(s string) bool {
 269                         return s == "+OK 1 10"
 270                 })},
 271                 {"RSET", responseOK},
 272                 {"STAT", expectOKResponse(func(s string) bool {
 273                         return s == "+OK 2 1009"
 274                 })},
 275                 {"QUIT", responseOK},
 276         })
 277 }
 278
 279 func TestCaseSensitivty(t *testing.T) {
 280         s := newTestServer()
 281         s.mb.msgs[999] = &testMessage{999, 1, false, "a"}
 282
 283         clientServerTest(t, s, []requestResponse{
 284                 {"user u", responseOK},
 285                 {"PasS p", responseOK},
 286                 {"sTaT", responseOK},
 287                 {"retr 1", responseERR},
 288                 {"dele 999", responseOK},
 289                 {"QUIT", responseOK},
 290         })
 291 }
 292
 293 func TestRetr(t *testing.T) {
 294         s := newTestServer()
 295         s.mb.msgs[1] = &testMessage{1, 5, false, "hello"}
 296         s.mb.msgs[2] = &testMessage{2, 69, false, "this\r\nis a\r\n.\r\ntest"}
 297
 298         clientServerTest(t, s, []requestResponse{
 299                 {"USER u", responseOK},
 300                 {"PASS p", responseOK},
 301                 {"STAT", responseOK},
 302                 {"RETR 1", func(t testing.TB, tp *textproto.Conn) string {
 303                         responseOK(t, tp)
 304                         if t.Failed() {
 305                                 return ""
 306                         }
 307
 308                         resp, err := tp.ReadDotLines()
 309                         if err != nil {
 310                                 t.Error(err)
 311                                 return ""
 312                         }
 313
 314                         expected := []string{"hello"}
 315                         if !reflect.DeepEqual(resp, expected) {
 316                                 t.Errorf("Expected %v, got %v", expected, resp)
 317                         }
 318
 319                         return ""
 320                 }},
 321                 {"RETR 2", func(t testing.TB, tp *textproto.Conn) string {
 322                         responseOK(t, tp)
 323                         if t.Failed() {
 324                                 return ""
 325                         }
 326
 327                         resp, err := tp.ReadDotLines()
 328                         if err != nil {
 329                                 t.Error(err)
 330                                 return ""
 331                         }
 332
 333                         expected := []string{"this", "is a", ".", "test"}
 334                         if !reflect.DeepEqual(resp, expected) {
 335                                 t.Errorf("Expected %v, got %v", expected, resp)
 336                         }
 337
 338                         return ""
 339                 }},
 340                 {"QUIT", responseOK},
 341         })
 342 }
 343
 344 func TestUidl(t *testing.T) {
 345         s := newTestServer()
 346         s.mb.msgs[1] = &testMessage{1, 3, false, "abc"}
 347         s.mb.msgs[2] = &testMessage{2, 1, true, "Z"}
 348         s.mb.msgs[3] = &testMessage{3, 4, false, "test"}
 349
 350         clientServerTest(t, s, []requestResponse{
 351                 {"USER u", responseOK},
 352                 {"PASS p", responseOK},
 353                 {"UIDL", func(t testing.TB, tp *textproto.Conn) string {
 354                         responseOK(t, tp)
 355                         if t.Failed() {
 356                                 return ""
 357                         }
 358
 359                         resp, err := tp.ReadDotLines()
 360                         if err != nil {
 361                                 t.Error(err)
 362                                 return ""
 363                         }
 364
 365                         expected := []string{
 366                                 fmt.Sprintf("1 %p", s.mb.msgs[1]),
 367                                 fmt.Sprintf("3 %p", s.mb.msgs[3]),
 368                         }
 369                         if !reflect.DeepEqual(resp, expected) {
 370                                 t.Errorf("Expected %v, got %v", expected, resp)
 371                         }
 372
 373                         return ""
 374                 }},
 375                 {"QUIT", responseOK},
 376         })
 377 }