/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_smtp_connection.py

  • Committer: Jelmer Vernooij
  • Date: 2017-08-27 00:52:56 UTC
  • mto: This revision was merged to the branch mainline in revision 6770.
  • Revision ID: jelmer@jelmer.uk-20170827005256-x68jv9yc1varkfsu
Add --subunit2 option.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_smtp_connection.py
1
 
# Copyright (C) 2005, 2007, 2009 Canonical Ltd
 
1
# Copyright (C) 2007, 2009, 2010, 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from cStringIO import StringIO
18
17
from email.Message import Message
19
18
import errno
20
19
import smtplib
21
20
import socket
22
21
 
23
 
from bzrlib import (
 
22
from breezy import (
24
23
    config,
25
24
    email_message,
26
 
    errors,
27
25
    smtp_connection,
28
26
    tests,
29
27
    ui,
91
89
class TestSMTPConnection(tests.TestCaseInTempDir):
92
90
 
93
91
    def get_connection(self, text, smtp_factory=None):
94
 
        my_config = config.GlobalConfig()
95
 
        config_file = StringIO(text)
96
 
        my_config._get_parser(config_file)
97
 
        return smtp_connection.SMTPConnection(my_config,
98
 
                                              _smtp_factory=smtp_factory)
 
92
        my_config = config.MemoryStack(text)
 
93
        return smtp_connection.SMTPConnection(
 
94
            my_config, _smtp_factory=smtp_factory)
99
95
 
100
96
    def test_defaults(self):
101
97
        conn = self.get_connection('')
104
100
        self.assertEqual(None, conn._smtp_password)
105
101
 
106
102
    def test_smtp_server(self):
107
 
        conn = self.get_connection('[DEFAULT]\nsmtp_server=host:10\n')
 
103
        conn = self.get_connection('smtp_server=host:10')
108
104
        self.assertEqual('host:10', conn._smtp_server)
109
105
 
110
106
    def test_missing_server(self):
111
107
        conn = self.get_connection('', smtp_factory=connection_refuser)
112
 
        self.assertRaises(errors.DefaultSMTPConnectionRefused, conn._connect)
113
 
        conn = self.get_connection('[DEFAULT]\nsmtp_server=smtp.example.com\n',
 
108
        self.assertRaises(smtp_connection.DefaultSMTPConnectionRefused,
 
109
                          conn._connect)
 
110
        conn = self.get_connection('smtp_server=smtp.example.com',
114
111
                                   smtp_factory=connection_refuser)
115
 
        self.assertRaises(errors.SMTPConnectionRefused, conn._connect)
 
112
        self.assertRaises(smtp_connection.SMTPConnectionRefused, conn._connect)
116
113
 
117
114
    def test_smtp_username(self):
118
115
        conn = self.get_connection('')
119
116
        self.assertIs(None, conn._smtp_username)
120
117
 
121
 
        conn = self.get_connection('[DEFAULT]\nsmtp_username=joebody\n')
 
118
        conn = self.get_connection('smtp_username=joebody')
122
119
        self.assertEqual(u'joebody', conn._smtp_username)
123
120
 
124
121
    def test_smtp_password_from_config(self):
125
122
        conn = self.get_connection('')
126
123
        self.assertIs(None, conn._smtp_password)
127
124
 
128
 
        conn = self.get_connection('[DEFAULT]\nsmtp_password=mypass\n')
 
125
        conn = self.get_connection('smtp_password=mypass')
129
126
        self.assertEqual(u'mypass', conn._smtp_password)
130
127
 
131
128
    def test_smtp_password_from_user(self):
160
157
 
161
158
    def test_authenticate_with_byte_strings(self):
162
159
        user = 'joe'
163
 
        password = 'h\xC3\xACspass'
 
160
        unicode_pass = u'h\xECspass'
 
161
        utf8_pass = unicode_pass.encode('utf-8')
164
162
        factory = WideOpenSMTPFactory()
165
163
        conn = self.get_connection(
166
164
            '[DEFAULT]\nsmtp_username=%s\nsmtp_password=%s\n'
167
 
            % (user, password), smtp_factory=factory)
168
 
        self.assertEqual(u'h\xECspass', conn._smtp_password)
 
165
            % (user, utf8_pass), smtp_factory=factory)
 
166
        self.assertEqual(unicode_pass, conn._smtp_password)
169
167
        conn._connect()
170
168
        self.assertEqual([('connect', 'localhost'),
171
169
                          ('ehlo',),
172
170
                          ('has_extn', 'starttls'),
173
 
                          ('login', user, password)], factory._calls)
 
171
                          ('login', user, utf8_pass)], factory._calls)
174
172
        smtp_username, smtp_password = factory._calls[-1][1:]
175
173
        self.assertIsInstance(smtp_username, str)
176
174
        self.assertIsInstance(smtp_password, str)
197
195
        # Check that we raise an exception if both EHLO and HELO fail.
198
196
        factory = StubSMTPFactory(fail_on=['ehlo', 'helo'])
199
197
        conn = self.get_connection('', smtp_factory=factory)
200
 
        self.assertRaises(errors.SMTPError, conn._create_connection)
 
198
        self.assertRaises(smtp_connection.SMTPError, conn._create_connection)
201
199
        self.assertEqual([('connect', 'localhost'),
202
200
                          ('ehlo',),
203
201
                          ('helo',)], factory._calls)
220
218
        factory = StubSMTPFactory(fail_on=['starttls'],
221
219
                                  smtp_features=['starttls'])
222
220
        conn = self.get_connection('', smtp_factory=factory)
223
 
        self.assertRaises(errors.SMTPError, conn._create_connection)
 
221
        self.assertRaises(smtp_connection.SMTPError, conn._create_connection)
224
222
        self.assertEqual([('connect', 'localhost'),
225
223
                          ('ehlo',),
226
224
                          ('has_extn', 'starttls'),
243
241
        self.assertEqual(sorted(['john@doe.com', 'jane@doe.com',
244
242
            'pperez@ejemplo.com', 'user@localhost']), sorted(to))
245
243
 
246
 
        # now with bzrlib's EmailMessage
 
244
        # now with breezy's EmailMessage
247
245
        msg = email_message.EmailMessage(
248
246
            '"J. Random Developer" <jrandom@example.com>',
249
247
            ['John Doe <john@doe.com>', 'Jane Doe <jane@doe.com>',
256
254
            'pperez@ejemplo.com', 'user@localhost']), sorted(to))
257
255
 
258
256
    def test_destination_address_required(self):
259
 
        class FakeConfig:
260
 
            def get_user_option(self, option):
261
 
                return None
262
 
 
263
257
        msg = Message()
264
258
        msg['From'] = '"J. Random Developer" <jrandom@example.com>'
265
259
        self.assertRaises(
266
 
            errors.NoDestinationAddress,
267
 
            smtp_connection.SMTPConnection(FakeConfig()).send_email, msg)
 
260
            smtp_connection.NoDestinationAddress,
 
261
            smtp_connection.SMTPConnection(config.MemoryStack("")
 
262
                                           ).send_email, msg)
268
263
 
269
264
        msg = email_message.EmailMessage('from@from.com', '', 'subject')
270
265
        self.assertRaises(
271
 
            errors.NoDestinationAddress,
272
 
            smtp_connection.SMTPConnection(FakeConfig()).send_email, msg)
 
266
            smtp_connection.NoDestinationAddress,
 
267
            smtp_connection.SMTPConnection(config.MemoryStack("")
 
268
                                           ).send_email, msg)
273
269
 
274
270
        msg = email_message.EmailMessage('from@from.com', [], 'subject')
275
271
        self.assertRaises(
276
 
            errors.NoDestinationAddress,
277
 
            smtp_connection.SMTPConnection(FakeConfig()).send_email, msg)
 
272
            smtp_connection.NoDestinationAddress,
 
273
            smtp_connection.SMTPConnection(config.MemoryStack("")
 
274
                                           ).send_email, msg)