← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to src/pkg/smtp/smtp_test.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-04-20 17:36:48 UTC
  • Revision ID: james.westby@ubuntu.com-20110420173648-ifergoxyrm832trd
Tags: upstream-2011.03.07.1
Import upstream version 2011.03.07.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/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
`