libgo/go/smtp/smtp_test.go

   1 // Copyright 2010 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package smtp
   6
   7 import (
   8         "bufio"
   9         "bytes"
  10         "io"
  11         "net/textproto"
  12         "os"
  13         "strings"
  14         "testing"
  15 )
  16
  17 type authTest struct {
  18         auth       Auth
  19         challenges []string
  20         name       string
  21         responses  []string
  22 }
  23
  24 var authTests = []authTest{
  25         {PlainAuth("", "user", "pass", "testserver"), []string{}, "PLAIN", []string{"\x00user\x00pass"}},
  26         {PlainAuth("foo", "bar", "baz", "testserver"), []string{}, "PLAIN", []string{"foo\x00bar\x00baz"}},
  27 }
  28
  29 func TestAuth(t *testing.T) {
  30 testLoop:
  31         for i, test := range authTests {
  32                 name, resp, err := test.auth.Start(&ServerInfo{"testserver", true, nil})
  33                 if name != test.name {
  34                         t.Errorf("#%d got name %s, expected %s", i, name, test.name)
  35                 }
  36                 if !bytes.Equal(resp, []byte(test.responses[0])) {
  37                         t.Errorf("#%d got response %s, expected %s", i, resp, test.responses[0])
  38                 }
  39                 if err != nil {
  40                         t.Errorf("#%d error: %s", i, err.String())
  41                 }
  42                 for j := range test.challenges {
  43                         challenge := []byte(test.challenges[j])
  44                         expected := []byte(test.responses[j+1])
  45                         resp, err := test.auth.Next(challenge, true)
  46                         if err != nil {
  47                                 t.Errorf("#%d error: %s", i, err.String())
  48                                 continue testLoop
  49                         }
  50                         if !bytes.Equal(resp, expected) {
  51                                 t.Errorf("#%d got %s, expected %s", i, resp, expected)
  52                                 continue testLoop
  53                         }
  54                 }
  55         }
  56 }
  57
  58 type faker struct {
  59         io.ReadWriter
  60 }
  61
  62 func (f faker) Close() os.Error {
  63         return nil
  64 }
  65
  66 func TestBasic(t *testing.T) {
  67         basicServer = strings.Join(strings.Split(basicServer, "\n", -1), "\r\n")
  68         basicClient = strings.Join(strings.Split(basicClient, "\n", -1), "\r\n")
  69
  70         var cmdbuf bytes.Buffer
  71         bcmdbuf := bufio.NewWriter(&cmdbuf)
  72         var fake faker
  73         fake.ReadWriter = bufio.NewReadWriter(bufio.NewReader(strings.NewReader(basicServer)), bcmdbuf)
  74         c := &Client{Text: textproto.NewConn(fake)}
  75
  76         if err := c.helo(); err != nil {
  77                 t.Fatalf("HELO failed: %s", err.String())
  78         }
  79         if err := c.ehlo(); err == nil {
  80                 t.Fatalf("Expected first EHLO to fail")
  81         }
  82         if err := c.ehlo(); err != nil {
  83                 t.Fatalf("Second EHLO failed: %s", err.String())
  84         }
  85
  86         if ok, args := c.Extension("aUtH"); !ok || args != "LOGIN PLAIN" {
  87                 t.Fatalf("Expected AUTH supported")
  88         }
  89         if ok, _ := c.Extension("DSN"); ok {
  90                 t.Fatalf("Shouldn't support DSN")
  91         }
  92
  93         if err := c.Mail("user@gmail.com"); err == nil {
  94                 t.Fatalf("MAIL should require authentication")
  95         }
  96
  97         if err := c.Verify("user1@gmail.com"); err == nil {
  98                 t.Fatalf("First VRFY: expected no verification")
  99         }
 100         if err := c.Verify("user2@gmail.com"); err != nil {
 101                 t.Fatalf("Second VRFY: expected verification, got %s", err)
 102         }
 103
 104         // fake TLS so authentication won't complain
 105         c.tls = true
 106         c.serverName = "smtp.google.com"
 107         if err := c.Auth(PlainAuth("", "user", "pass", "smtp.google.com")); err != nil {
 108                 t.Fatalf("AUTH failed: %s", err.String())
 109         }
 110
 111         if err := c.Mail("user@gmail.com"); err != nil {
 112                 t.Fatalf("MAIL failed: %s", err.String())
 113         }
 114         if err := c.Rcpt("golang-nuts@googlegroups.com"); err != nil {
 115                 t.Fatalf("RCPT failed: %s", err.String())
 116         }
 117         msg := `From: user@gmail.com
 118 To: golang-nuts@googlegroups.com
 119 Subject: Hooray for Go
 120
 121 Line 1
 122 .Leading dot line .
 123 Goodbye.`
 124         w, err := c.Data()
 125         if err != nil {
 126                 t.Fatalf("DATA failed: %s", err.String())
 127         }
 128         if _, err := w.Write([]byte(msg)); err != nil {
 129                 t.Fatalf("Data write failed: %s", err.String())
 130         }
 131         if err := w.Close(); err != nil {
 132                 t.Fatalf("Bad data response: %s", err.String())
 133         }
 134
 135         if err := c.Quit(); err != nil {
 136                 t.Fatalf("QUIT failed: %s", err.String())
 137         }
 138
 139         bcmdbuf.Flush()
 140         actualcmds := cmdbuf.String()
 141         if basicClient != actualcmds {
 142                 t.Fatalf("Got:\n%s\nExpected:\n%s", actualcmds, basicClient)
 143         }
 144 }
 145
 146 var basicServer = `250 mx.google.com at your service
 147 502 Unrecognized command.
 148 250-mx.google.com at your service
 149 250-SIZE 35651584
 150 250-AUTH LOGIN PLAIN
 151 250 8BITMIME
 152 530 Authentication required
 153 252 Send some mail, I'll try my best
 154 250 User is valid
 155 235 Accepted
 156 250 Sender OK
 157 250 Receiver OK
 158 354 Go ahead
 159 250 Data OK
 160 221 OK
 161 `
 162
 163 var basicClient = `HELO localhost
 164 EHLO localhost
 165 EHLO localhost
 166 MAIL FROM:<user@gmail.com> BODY=8BITMIME
 167 VRFY user1@gmail.com
 168 VRFY user2@gmail.com
 169 AUTH PLAIN AHVzZXIAcGFzcw==
 170 MAIL FROM:<user@gmail.com> BODY=8BITMIME
 171 RCPT TO:<golang-nuts@googlegroups.com>
 172 DATA
 173 From: user@gmail.com
 174 To: golang-nuts@googlegroups.com
 175 Subject: Hooray for Go
 176
 177 Line 1
 178 ..Leading dot line .
 179 Goodbye.
 180 .
 181 QUIT
 182 `