R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 1 | import unittest |
Richard Jones | 64b02de | 2010-08-03 06:39:33 +0000 | [diff] [blame] | 2 | from test import support, mock_socket |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 3 | import socket |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 4 | import io |
| 5 | import smtpd |
Richard Jones | 64b02de | 2010-08-03 06:39:33 +0000 | [diff] [blame] | 6 | import asyncore |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 7 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 8 | |
| 9 | class DummyServer(smtpd.SMTPServer): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 10 | def __init__(self, localaddr, remoteaddr): |
| 11 | smtpd.SMTPServer.__init__(self, localaddr, remoteaddr) |
Georg Brandl | 6d23c44 | 2010-07-29 13:19:42 +0000 | [diff] [blame] | 12 | self.messages = [] |
Richard Jones | 64b02de | 2010-08-03 06:39:33 +0000 | [diff] [blame] | 13 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 14 | def process_message(self, peer, mailfrom, rcpttos, data): |
| 15 | self.messages.append((peer, mailfrom, rcpttos, data)) |
| 16 | if data == 'return status': |
| 17 | return '250 Okish' |
| 18 | |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 19 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 20 | class DummyDispatcherBroken(Exception): |
| 21 | pass |
| 22 | |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 23 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 24 | class BrokenDummyServer(DummyServer): |
| 25 | def listen(self, num): |
| 26 | raise DummyDispatcherBroken() |
| 27 | |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 28 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 29 | class SMTPDServerTest(unittest.TestCase): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 30 | def setUp(self): |
| 31 | smtpd.socket = asyncore.socket = mock_socket |
| 32 | |
| 33 | def test_process_message_unimplemented(self): |
| 34 | server = smtpd.SMTPServer('a', 'b') |
| 35 | conn, addr = server.accept() |
| 36 | channel = smtpd.SMTPChannel(server, conn, addr) |
| 37 | |
| 38 | def write_line(line): |
| 39 | channel.socket.queue_recv(line) |
| 40 | channel.handle_read() |
| 41 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 42 | write_line(b'HELO example') |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 43 | write_line(b'MAIL From:eggs@example') |
| 44 | write_line(b'RCPT To:spam@example') |
| 45 | write_line(b'DATA') |
| 46 | self.assertRaises(NotImplementedError, write_line, b'spam\r\n.\r\n') |
| 47 | |
| 48 | def tearDown(self): |
Richard Jones | daf2350 | 2010-08-16 01:48:14 +0000 | [diff] [blame] | 49 | asyncore.close_all() |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 50 | asyncore.socket = smtpd.socket = socket |
| 51 | |
| 52 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 53 | class SMTPDChannelTest(unittest.TestCase): |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 54 | def setUp(self): |
Richard Jones | 64b02de | 2010-08-03 06:39:33 +0000 | [diff] [blame] | 55 | smtpd.socket = asyncore.socket = mock_socket |
Antoine Pitrou | e0815e2 | 2011-11-12 20:36:29 +0100 | [diff] [blame] | 56 | self.old_debugstream = smtpd.DEBUGSTREAM |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 57 | self.debug = smtpd.DEBUGSTREAM = io.StringIO() |
| 58 | self.server = DummyServer('a', 'b') |
| 59 | conn, addr = self.server.accept() |
| 60 | self.channel = smtpd.SMTPChannel(self.server, conn, addr) |
| 61 | |
Richard Jones | 64b02de | 2010-08-03 06:39:33 +0000 | [diff] [blame] | 62 | def tearDown(self): |
Richard Jones | daf2350 | 2010-08-16 01:48:14 +0000 | [diff] [blame] | 63 | asyncore.close_all() |
Richard Jones | 64b02de | 2010-08-03 06:39:33 +0000 | [diff] [blame] | 64 | asyncore.socket = smtpd.socket = socket |
Antoine Pitrou | e0815e2 | 2011-11-12 20:36:29 +0100 | [diff] [blame] | 65 | smtpd.DEBUGSTREAM = self.old_debugstream |
Richard Jones | 64b02de | 2010-08-03 06:39:33 +0000 | [diff] [blame] | 66 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 67 | def write_line(self, line): |
| 68 | self.channel.socket.queue_recv(line) |
| 69 | self.channel.handle_read() |
| 70 | |
| 71 | def test_broken_connect(self): |
| 72 | self.assertRaises(DummyDispatcherBroken, BrokenDummyServer, 'a', 'b') |
| 73 | |
| 74 | def test_server_accept(self): |
| 75 | self.server.handle_accept() |
| 76 | |
| 77 | def test_missing_data(self): |
| 78 | self.write_line(b'') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 79 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 80 | b'500 Error: bad syntax\r\n') |
| 81 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 82 | def test_EHLO(self): |
| 83 | self.write_line(b'EHLO example') |
| 84 | self.assertEqual(self.channel.socket.last, b'250 HELP\r\n') |
| 85 | |
| 86 | def test_EHLO_bad_syntax(self): |
| 87 | self.write_line(b'EHLO') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 88 | self.assertEqual(self.channel.socket.last, |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 89 | b'501 Syntax: EHLO hostname\r\n') |
| 90 | |
| 91 | def test_EHLO_duplicate(self): |
| 92 | self.write_line(b'EHLO example') |
| 93 | self.write_line(b'EHLO example') |
| 94 | self.assertEqual(self.channel.socket.last, |
| 95 | b'503 Duplicate HELO/EHLO\r\n') |
| 96 | |
| 97 | def test_EHLO_HELO_duplicate(self): |
| 98 | self.write_line(b'EHLO example') |
| 99 | self.write_line(b'HELO example') |
| 100 | self.assertEqual(self.channel.socket.last, |
| 101 | b'503 Duplicate HELO/EHLO\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 102 | |
| 103 | def test_HELO(self): |
Richard Jones | 64b02de | 2010-08-03 06:39:33 +0000 | [diff] [blame] | 104 | name = smtpd.socket.getfqdn() |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 105 | self.write_line(b'HELO example') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 106 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 107 | '250 {}\r\n'.format(name).encode('ascii')) |
| 108 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 109 | def test_HELO_EHLO_duplicate(self): |
| 110 | self.write_line(b'HELO example') |
| 111 | self.write_line(b'EHLO example') |
| 112 | self.assertEqual(self.channel.socket.last, |
| 113 | b'503 Duplicate HELO/EHLO\r\n') |
| 114 | |
| 115 | def test_HELP(self): |
| 116 | self.write_line(b'HELP') |
| 117 | self.assertEqual(self.channel.socket.last, |
| 118 | b'250 Supported commands: EHLO HELO MAIL RCPT ' + \ |
| 119 | b'DATA RSET NOOP QUIT VRFY\r\n') |
| 120 | |
| 121 | def test_HELP_command(self): |
| 122 | self.write_line(b'HELP MAIL') |
| 123 | self.assertEqual(self.channel.socket.last, |
| 124 | b'250 Syntax: MAIL FROM: <address>\r\n') |
| 125 | |
| 126 | def test_HELP_command_unknown(self): |
| 127 | self.write_line(b'HELP SPAM') |
| 128 | self.assertEqual(self.channel.socket.last, |
| 129 | b'501 Supported commands: EHLO HELO MAIL RCPT ' + \ |
| 130 | b'DATA RSET NOOP QUIT VRFY\r\n') |
| 131 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 132 | def test_HELO_bad_syntax(self): |
| 133 | self.write_line(b'HELO') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 134 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 135 | b'501 Syntax: HELO hostname\r\n') |
| 136 | |
| 137 | def test_HELO_duplicate(self): |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 138 | self.write_line(b'HELO example') |
| 139 | self.write_line(b'HELO example') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 140 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 141 | b'503 Duplicate HELO/EHLO\r\n') |
| 142 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 143 | def test_HELO_parameter_rejected_when_extensions_not_enabled(self): |
| 144 | self.extended_smtp = False |
| 145 | self.write_line(b'HELO example') |
| 146 | self.write_line(b'MAIL from:<foo@example.com> SIZE=1234') |
| 147 | self.assertEqual(self.channel.socket.last, |
| 148 | b'501 Syntax: MAIL FROM: <address>\r\n') |
| 149 | |
| 150 | def test_MAIL_allows_space_after_colon(self): |
| 151 | self.write_line(b'HELO example') |
| 152 | self.write_line(b'MAIL from: <foo@example.com>') |
| 153 | self.assertEqual(self.channel.socket.last, |
| 154 | b'250 OK\r\n') |
| 155 | |
| 156 | def test_extended_MAIL_allows_space_after_colon(self): |
| 157 | self.write_line(b'EHLO example') |
| 158 | self.write_line(b'MAIL from: <foo@example.com> size=20') |
| 159 | self.assertEqual(self.channel.socket.last, |
| 160 | b'250 OK\r\n') |
| 161 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 162 | def test_NOOP(self): |
| 163 | self.write_line(b'NOOP') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 164 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 165 | |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 166 | def test_HELO_NOOP(self): |
| 167 | self.write_line(b'HELO example') |
| 168 | self.write_line(b'NOOP') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 169 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 170 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 171 | def test_NOOP_bad_syntax(self): |
| 172 | self.write_line(b'NOOP hi') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 173 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 174 | b'501 Syntax: NOOP\r\n') |
| 175 | |
| 176 | def test_QUIT(self): |
| 177 | self.write_line(b'QUIT') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 178 | self.assertEqual(self.channel.socket.last, b'221 Bye\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 179 | |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 180 | def test_HELO_QUIT(self): |
| 181 | self.write_line(b'HELO example') |
| 182 | self.write_line(b'QUIT') |
| 183 | self.assertEqual(self.channel.socket.last, b'221 Bye\r\n') |
| 184 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 185 | def test_QUIT_arg_ignored(self): |
| 186 | self.write_line(b'QUIT bye bye') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 187 | self.assertEqual(self.channel.socket.last, b'221 Bye\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 188 | |
| 189 | def test_bad_state(self): |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 190 | self.channel.smtp_state = 'BAD STATE' |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 191 | self.write_line(b'HELO example') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 192 | self.assertEqual(self.channel.socket.last, |
| 193 | b'451 Internal confusion\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 194 | |
Georg Brandl | 1e5c5f8 | 2010-12-03 07:38:22 +0000 | [diff] [blame] | 195 | def test_command_too_long(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 196 | self.write_line(b'HELO example') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 197 | self.write_line(b'MAIL from: ' + |
Georg Brandl | 1e5c5f8 | 2010-12-03 07:38:22 +0000 | [diff] [blame] | 198 | b'a' * self.channel.command_size_limit + |
| 199 | b'@example') |
| 200 | self.assertEqual(self.channel.socket.last, |
| 201 | b'500 Error: line too long\r\n') |
| 202 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 203 | def test_MAIL_command_limit_extended_with_SIZE(self): |
| 204 | self.write_line(b'EHLO example') |
| 205 | fill_len = self.channel.command_size_limit - len('MAIL from:<@example>') |
| 206 | self.write_line(b'MAIL from:<' + |
| 207 | b'a' * fill_len + |
| 208 | b'@example> SIZE=1234') |
| 209 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 210 | |
| 211 | self.write_line(b'MAIL from:<' + |
| 212 | b'a' * (fill_len + 26) + |
| 213 | b'@example> SIZE=1234') |
| 214 | self.assertEqual(self.channel.socket.last, |
| 215 | b'500 Error: line too long\r\n') |
| 216 | |
| 217 | def test_data_longer_than_default_data_size_limit(self): |
| 218 | # Hack the default so we don't have to generate so much data. |
| 219 | self.channel.data_size_limit = 1048 |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 220 | self.write_line(b'HELO example') |
Georg Brandl | 1e5c5f8 | 2010-12-03 07:38:22 +0000 | [diff] [blame] | 221 | self.write_line(b'MAIL From:eggs@example') |
| 222 | self.write_line(b'RCPT To:spam@example') |
| 223 | self.write_line(b'DATA') |
| 224 | self.write_line(b'A' * self.channel.data_size_limit + |
| 225 | b'A\r\n.') |
| 226 | self.assertEqual(self.channel.socket.last, |
| 227 | b'552 Error: Too much mail data\r\n') |
| 228 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 229 | def test_MAIL_size_parameter(self): |
| 230 | self.write_line(b'EHLO example') |
| 231 | self.write_line(b'MAIL FROM:<eggs@example> SIZE=512') |
| 232 | self.assertEqual(self.channel.socket.last, |
| 233 | b'250 OK\r\n') |
| 234 | |
| 235 | def test_MAIL_invalid_size_parameter(self): |
| 236 | self.write_line(b'EHLO example') |
| 237 | self.write_line(b'MAIL FROM:<eggs@example> SIZE=invalid') |
| 238 | self.assertEqual(self.channel.socket.last, |
| 239 | b'501 Syntax: MAIL FROM: <address> [SP <mail-parameters>]\r\n') |
| 240 | |
| 241 | def test_MAIL_RCPT_unknown_parameters(self): |
| 242 | self.write_line(b'EHLO example') |
| 243 | self.write_line(b'MAIL FROM:<eggs@example> ham=green') |
| 244 | self.assertEqual(self.channel.socket.last, |
| 245 | b'555 MAIL FROM parameters not recognized or not implemented\r\n') |
| 246 | |
| 247 | self.write_line(b'MAIL FROM:<eggs@example>') |
| 248 | self.write_line(b'RCPT TO:<eggs@example> ham=green') |
| 249 | self.assertEqual(self.channel.socket.last, |
| 250 | b'555 RCPT TO parameters not recognized or not implemented\r\n') |
| 251 | |
| 252 | def test_MAIL_size_parameter_larger_than_default_data_size_limit(self): |
| 253 | self.channel.data_size_limit = 1048 |
| 254 | self.write_line(b'EHLO example') |
| 255 | self.write_line(b'MAIL FROM:<eggs@example> SIZE=2096') |
| 256 | self.assertEqual(self.channel.socket.last, |
| 257 | b'552 Error: message size exceeds fixed maximum message size\r\n') |
| 258 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 259 | def test_need_MAIL(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 260 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 261 | self.write_line(b'RCPT to:spam@example') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 262 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 263 | b'503 Error: need MAIL command\r\n') |
| 264 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 265 | def test_MAIL_syntax_HELO(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 266 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 267 | self.write_line(b'MAIL from eggs@example') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 268 | self.assertEqual(self.channel.socket.last, |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 269 | b'501 Syntax: MAIL FROM: <address>\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 270 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 271 | def test_MAIL_syntax_EHLO(self): |
| 272 | self.write_line(b'EHLO example') |
| 273 | self.write_line(b'MAIL from eggs@example') |
| 274 | self.assertEqual(self.channel.socket.last, |
| 275 | b'501 Syntax: MAIL FROM: <address> [SP <mail-parameters>]\r\n') |
| 276 | |
| 277 | def test_MAIL_missing_address(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 278 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 279 | self.write_line(b'MAIL from:') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 280 | self.assertEqual(self.channel.socket.last, |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 281 | b'501 Syntax: MAIL FROM: <address>\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 282 | |
| 283 | def test_MAIL_chevrons(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 284 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 285 | self.write_line(b'MAIL from:<eggs@example>') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 286 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 287 | |
| 288 | def test_MAIL_empty_chevrons(self): |
| 289 | self.write_line(b'EHLO example') |
| 290 | self.write_line(b'MAIL from:<>') |
| 291 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 292 | |
| 293 | def test_MAIL_quoted_localpart(self): |
| 294 | self.write_line(b'EHLO example') |
| 295 | self.write_line(b'MAIL from: <"Fred Blogs"@example.com>') |
| 296 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 297 | self.assertEqual(self.channel.mailfrom, '"Fred Blogs"@example.com') |
| 298 | |
| 299 | def test_MAIL_quoted_localpart_no_angles(self): |
| 300 | self.write_line(b'EHLO example') |
| 301 | self.write_line(b'MAIL from: "Fred Blogs"@example.com') |
| 302 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 303 | self.assertEqual(self.channel.mailfrom, '"Fred Blogs"@example.com') |
| 304 | |
| 305 | def test_MAIL_quoted_localpart_with_size(self): |
| 306 | self.write_line(b'EHLO example') |
| 307 | self.write_line(b'MAIL from: <"Fred Blogs"@example.com> SIZE=1000') |
| 308 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 309 | self.assertEqual(self.channel.mailfrom, '"Fred Blogs"@example.com') |
| 310 | |
| 311 | def test_MAIL_quoted_localpart_with_size_no_angles(self): |
| 312 | self.write_line(b'EHLO example') |
| 313 | self.write_line(b'MAIL from: "Fred Blogs"@example.com SIZE=1000') |
| 314 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 315 | self.assertEqual(self.channel.mailfrom, '"Fred Blogs"@example.com') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 316 | |
| 317 | def test_nested_MAIL(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 318 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 319 | self.write_line(b'MAIL from:eggs@example') |
| 320 | self.write_line(b'MAIL from:spam@example') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 321 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 322 | b'503 Error: nested MAIL command\r\n') |
| 323 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 324 | def test_VRFY(self): |
| 325 | self.write_line(b'VRFY eggs@example') |
| 326 | self.assertEqual(self.channel.socket.last, |
| 327 | b'252 Cannot VRFY user, but will accept message and attempt ' + \ |
| 328 | b'delivery\r\n') |
| 329 | |
| 330 | def test_VRFY_syntax(self): |
| 331 | self.write_line(b'VRFY') |
| 332 | self.assertEqual(self.channel.socket.last, |
| 333 | b'501 Syntax: VRFY <address>\r\n') |
| 334 | |
| 335 | def test_EXPN_not_implemented(self): |
| 336 | self.write_line(b'EXPN') |
| 337 | self.assertEqual(self.channel.socket.last, |
| 338 | b'502 EXPN not implemented\r\n') |
| 339 | |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 340 | def test_no_HELO_MAIL(self): |
| 341 | self.write_line(b'MAIL from:<foo@example.com>') |
| 342 | self.assertEqual(self.channel.socket.last, |
| 343 | b'503 Error: send HELO first\r\n') |
| 344 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 345 | def test_need_RCPT(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 346 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 347 | self.write_line(b'MAIL From:eggs@example') |
| 348 | self.write_line(b'DATA') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 349 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 350 | b'503 Error: need RCPT command\r\n') |
| 351 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 352 | def test_RCPT_syntax_HELO(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 353 | self.write_line(b'HELO example') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 354 | self.write_line(b'MAIL From: eggs@example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 355 | self.write_line(b'RCPT to eggs@example') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 356 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 357 | b'501 Syntax: RCPT TO: <address>\r\n') |
| 358 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 359 | def test_RCPT_syntax_EHLO(self): |
| 360 | self.write_line(b'EHLO example') |
| 361 | self.write_line(b'MAIL From: eggs@example') |
| 362 | self.write_line(b'RCPT to eggs@example') |
| 363 | self.assertEqual(self.channel.socket.last, |
| 364 | b'501 Syntax: RCPT TO: <address> [SP <mail-parameters>]\r\n') |
| 365 | |
| 366 | def test_RCPT_lowercase_to_OK(self): |
| 367 | self.write_line(b'HELO example') |
| 368 | self.write_line(b'MAIL From: eggs@example') |
| 369 | self.write_line(b'RCPT to: <eggs@example>') |
| 370 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 371 | |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 372 | def test_no_HELO_RCPT(self): |
| 373 | self.write_line(b'RCPT to eggs@example') |
| 374 | self.assertEqual(self.channel.socket.last, |
| 375 | b'503 Error: send HELO first\r\n') |
| 376 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 377 | def test_data_dialog(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 378 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 379 | self.write_line(b'MAIL From:eggs@example') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 380 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 381 | self.write_line(b'RCPT To:spam@example') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 382 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 383 | |
| 384 | self.write_line(b'DATA') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 385 | self.assertEqual(self.channel.socket.last, |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 386 | b'354 End data with <CR><LF>.<CR><LF>\r\n') |
| 387 | self.write_line(b'data\r\nmore\r\n.') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 388 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 389 | self.assertEqual(self.server.messages, |
| 390 | [('peer', 'eggs@example', ['spam@example'], 'data\nmore')]) |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 391 | |
| 392 | def test_DATA_syntax(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 393 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 394 | self.write_line(b'MAIL From:eggs@example') |
| 395 | self.write_line(b'RCPT To:spam@example') |
| 396 | self.write_line(b'DATA spam') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 397 | self.assertEqual(self.channel.socket.last, b'501 Syntax: DATA\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 398 | |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 399 | def test_no_HELO_DATA(self): |
| 400 | self.write_line(b'DATA spam') |
| 401 | self.assertEqual(self.channel.socket.last, |
| 402 | b'503 Error: send HELO first\r\n') |
| 403 | |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 404 | def test_data_transparency_section_4_5_2(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 405 | self.write_line(b'HELO example') |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 406 | self.write_line(b'MAIL From:eggs@example') |
| 407 | self.write_line(b'RCPT To:spam@example') |
| 408 | self.write_line(b'DATA') |
| 409 | self.write_line(b'..\r\n.\r\n') |
| 410 | self.assertEqual(self.channel.received_data, '.') |
| 411 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 412 | def test_multiple_RCPT(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 413 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 414 | self.write_line(b'MAIL From:eggs@example') |
| 415 | self.write_line(b'RCPT To:spam@example') |
| 416 | self.write_line(b'RCPT To:ham@example') |
| 417 | self.write_line(b'DATA') |
| 418 | self.write_line(b'data\r\n.') |
Richard Jones | 6a9e6bb | 2010-08-04 12:27:36 +0000 | [diff] [blame] | 419 | self.assertEqual(self.server.messages, |
| 420 | [('peer', 'eggs@example', ['spam@example','ham@example'], 'data')]) |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 421 | |
| 422 | def test_manual_status(self): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 423 | # checks that the Channel is able to return a custom status message |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 424 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 425 | self.write_line(b'MAIL From:eggs@example') |
| 426 | self.write_line(b'RCPT To:spam@example') |
| 427 | self.write_line(b'DATA') |
| 428 | self.write_line(b'return status\r\n.') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 429 | self.assertEqual(self.channel.socket.last, b'250 Okish\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 430 | |
| 431 | def test_RSET(self): |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 432 | self.write_line(b'HELO example') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 433 | self.write_line(b'MAIL From:eggs@example') |
| 434 | self.write_line(b'RCPT To:spam@example') |
| 435 | self.write_line(b'RSET') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 436 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 437 | self.write_line(b'MAIL From:foo@example') |
| 438 | self.write_line(b'RCPT To:eggs@example') |
| 439 | self.write_line(b'DATA') |
| 440 | self.write_line(b'data\r\n.') |
Richard Jones | 6a9e6bb | 2010-08-04 12:27:36 +0000 | [diff] [blame] | 441 | self.assertEqual(self.server.messages, |
| 442 | [('peer', 'foo@example', ['eggs@example'], 'data')]) |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 443 | |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 444 | def test_HELO_RSET(self): |
| 445 | self.write_line(b'HELO example') |
| 446 | self.write_line(b'RSET') |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 447 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
R David Murray | 669b755 | 2012-03-20 16:16:29 -0400 | [diff] [blame] | 448 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 449 | def test_RSET_syntax(self): |
| 450 | self.write_line(b'RSET hi') |
Georg Brandl | 17e3d69 | 2010-07-31 10:08:09 +0000 | [diff] [blame] | 451 | self.assertEqual(self.channel.socket.last, b'501 Syntax: RSET\r\n') |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 452 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 453 | def test_unknown_command(self): |
| 454 | self.write_line(b'UNKNOWN_CMD') |
| 455 | self.assertEqual(self.channel.socket.last, |
| 456 | b'500 Error: command "UNKNOWN_CMD" not ' + \ |
| 457 | b'recognized\r\n') |
| 458 | |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 459 | def test_attribute_deprecations(self): |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 460 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 461 | spam = self.channel._SMTPChannel__server |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 462 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 463 | self.channel._SMTPChannel__server = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 464 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 465 | spam = self.channel._SMTPChannel__line |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 466 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 467 | self.channel._SMTPChannel__line = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 468 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 469 | spam = self.channel._SMTPChannel__state |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 470 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 471 | self.channel._SMTPChannel__state = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 472 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 473 | spam = self.channel._SMTPChannel__greeting |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 474 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 475 | self.channel._SMTPChannel__greeting = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 476 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 477 | spam = self.channel._SMTPChannel__mailfrom |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 478 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 479 | self.channel._SMTPChannel__mailfrom = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 480 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 481 | spam = self.channel._SMTPChannel__rcpttos |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 482 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 483 | self.channel._SMTPChannel__rcpttos = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 484 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 485 | spam = self.channel._SMTPChannel__data |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 486 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 487 | self.channel._SMTPChannel__data = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 488 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 489 | spam = self.channel._SMTPChannel__fqdn |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 490 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 491 | self.channel._SMTPChannel__fqdn = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 492 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 493 | spam = self.channel._SMTPChannel__peer |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 494 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 495 | self.channel._SMTPChannel__peer = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 496 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 497 | spam = self.channel._SMTPChannel__conn |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 498 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 499 | self.channel._SMTPChannel__conn = 'spam' |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 500 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 501 | spam = self.channel._SMTPChannel__addr |
Florent Xicluna | 6731775 | 2011-12-10 11:07:42 +0100 | [diff] [blame] | 502 | with support.check_warnings(('', DeprecationWarning)): |
Richard Jones | 4aa0d4d | 2010-08-04 01:20:14 +0000 | [diff] [blame] | 503 | self.channel._SMTPChannel__addr = 'spam' |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 504 | |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 505 | |
| 506 | class SMTPDChannelWithDataSizeLimitTest(unittest.TestCase): |
| 507 | |
| 508 | def setUp(self): |
| 509 | smtpd.socket = asyncore.socket = mock_socket |
R David Murray | 05cab75 | 2012-06-04 15:55:51 -0400 | [diff] [blame] | 510 | self.old_debugstream = smtpd.DEBUGSTREAM |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 511 | self.debug = smtpd.DEBUGSTREAM = io.StringIO() |
| 512 | self.server = DummyServer('a', 'b') |
| 513 | conn, addr = self.server.accept() |
| 514 | # Set DATA size limit to 32 bytes for easy testing |
| 515 | self.channel = smtpd.SMTPChannel(self.server, conn, addr, 32) |
| 516 | |
| 517 | def tearDown(self): |
| 518 | asyncore.close_all() |
| 519 | asyncore.socket = smtpd.socket = socket |
R David Murray | 05cab75 | 2012-06-04 15:55:51 -0400 | [diff] [blame] | 520 | smtpd.DEBUGSTREAM = self.old_debugstream |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 521 | |
| 522 | def write_line(self, line): |
| 523 | self.channel.socket.queue_recv(line) |
| 524 | self.channel.handle_read() |
| 525 | |
| 526 | def test_data_limit_dialog(self): |
| 527 | self.write_line(b'HELO example') |
| 528 | self.write_line(b'MAIL From:eggs@example') |
| 529 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 530 | self.write_line(b'RCPT To:spam@example') |
| 531 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 532 | |
| 533 | self.write_line(b'DATA') |
| 534 | self.assertEqual(self.channel.socket.last, |
| 535 | b'354 End data with <CR><LF>.<CR><LF>\r\n') |
| 536 | self.write_line(b'data\r\nmore\r\n.') |
| 537 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 538 | self.assertEqual(self.server.messages, |
| 539 | [('peer', 'eggs@example', ['spam@example'], 'data\nmore')]) |
| 540 | |
| 541 | def test_data_limit_dialog_too_much_data(self): |
| 542 | self.write_line(b'HELO example') |
| 543 | self.write_line(b'MAIL From:eggs@example') |
| 544 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 545 | self.write_line(b'RCPT To:spam@example') |
| 546 | self.assertEqual(self.channel.socket.last, b'250 OK\r\n') |
| 547 | |
| 548 | self.write_line(b'DATA') |
| 549 | self.assertEqual(self.channel.socket.last, |
| 550 | b'354 End data with <CR><LF>.<CR><LF>\r\n') |
| 551 | self.write_line(b'This message is longer than 32 bytes\r\n.') |
| 552 | self.assertEqual(self.channel.socket.last, |
| 553 | b'552 Error: Too much mail data\r\n') |
| 554 | |
Richard Jones | 8cb3619 | 2010-07-23 16:20:40 +0000 | [diff] [blame] | 555 | |
| 556 | if __name__ == "__main__": |
R David Murray | d1a30c9 | 2012-05-26 14:33:59 -0400 | [diff] [blame] | 557 | unittest.main() |