remailer 0.5.2 → 0.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,13 +1,16 @@
1
- require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
1
+ require_relative '../helper'
2
2
 
3
- class SMTPDelegate
4
- attr_accessor :options, :protocol, :active_message
3
+ class TestSMTPDelegate
4
+ attr_accessor :options, :protocol, :active_message, :auth_support
5
5
  attr_accessor :tls_support
6
6
 
7
7
  def initialize(options = { })
8
8
  @sent = [ ]
9
9
  @options = options
10
10
  @protocol = :smtp
11
+ @started_tls = false
12
+ @tls_support = nil
13
+ @closed = false
11
14
  end
12
15
 
13
16
  def hostname
@@ -57,12 +60,21 @@ class SMTPDelegate
57
60
  def read
58
61
  @sent.shift
59
62
  end
63
+
64
+ def auth_support?(type = nil)
65
+ case (type)
66
+ when nil
67
+ !!@auth_support
68
+ else
69
+ !!(@auth_support&.include?(type))
70
+ end
71
+ end
60
72
 
61
73
  def method_missing(*args)
62
74
  end
63
75
  end
64
76
 
65
- class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
77
+ class RemailerSMTPClientInterpreterTest < MiniTest::Test
66
78
  def test_split_reply
67
79
  assert_mapping(
68
80
  '250 OK' => [ 250, 'OK' ],
@@ -119,28 +131,28 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
119
131
  end
120
132
 
121
133
  def test_delegate_default_state
122
- delegate = SMTPDelegate.new
134
+ delegate = TestSMTPDelegate.new
123
135
 
124
136
  assert_equal false, delegate.closed?
125
- assert_equal nil, delegate.read
137
+ assert_nil delegate.read
126
138
  assert_equal 0, delegate.size
127
139
  end
128
140
 
129
141
  def test_delegate_options
130
- delegate = SMTPDelegate.new(:use_tls => true)
142
+ delegate = TestSMTPDelegate.new(use_tls: true)
131
143
 
132
144
  assert_equal true, delegate.use_tls?
133
145
  assert_equal false, delegate.requires_authentication?
134
146
 
135
- delegate = SMTPDelegate.new(:username => 'test@example.com', :password => 'tester')
147
+ delegate = TestSMTPDelegate.new(username: 'test@example.com', password: 'tester')
136
148
 
137
149
  assert_equal false, delegate.use_tls?
138
150
  assert_equal true, delegate.requires_authentication?
139
151
  end
140
152
 
141
153
  def test_standard_smtp_connection
142
- delegate = SMTPDelegate.new
143
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
154
+ delegate = TestSMTPDelegate.new
155
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
144
156
 
145
157
  assert_equal :initialized, interpreter.state
146
158
 
@@ -162,8 +174,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
162
174
  end
163
175
 
164
176
  def test_standard_smtp_connection_send_email
165
- delegate = SMTPDelegate.new
166
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
177
+ delegate = TestSMTPDelegate.new
178
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
167
179
 
168
180
  assert_equal :initialized, interpreter.state
169
181
 
@@ -184,9 +196,9 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
184
196
  assert_equal true, delegate.closed?
185
197
 
186
198
  delegate.active_message = {
187
- :from => 'from@example.com',
188
- :to => 'to@example.com',
189
- :data => "Subject: Test Message\r\n\r\nThis is a message!\r\n"
199
+ from: 'from@example.com',
200
+ to: 'to@example.com',
201
+ data: "Subject: Test Message\r\n\r\nThis is a message!\r\n"
190
202
  }
191
203
 
192
204
  interpreter.enter_state(:send)
@@ -217,8 +229,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
217
229
  end
218
230
 
219
231
  def test_standard_esmtp_connection
220
- delegate = SMTPDelegate.new
221
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
232
+ delegate = TestSMTPDelegate.new
233
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
222
234
 
223
235
  assert_equal :initialized, interpreter.state
224
236
 
@@ -254,8 +266,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
254
266
  end
255
267
 
256
268
  def test_multi_line_hello_response
257
- delegate = SMTPDelegate.new(:use_tls => true)
258
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
269
+ delegate = TestSMTPDelegate.new(use_tls: true)
270
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
259
271
 
260
272
  assert_equal :initialized, interpreter.state
261
273
  assert_equal :smtp, delegate.protocol
@@ -276,8 +288,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
276
288
  end
277
289
 
278
290
  def test_tls_connection_with_support
279
- delegate = SMTPDelegate.new(:use_tls => true)
280
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
291
+ delegate = TestSMTPDelegate.new(use_tls: true)
292
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
281
293
 
282
294
  assert_equal true, delegate.use_tls?
283
295
  assert_equal :initialized, interpreter.state
@@ -307,8 +319,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
307
319
  end
308
320
 
309
321
  def test_tls_connection_without_support
310
- delegate = SMTPDelegate.new(:use_tls => true)
311
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
322
+ delegate = TestSMTPDelegate.new(use_tls: true)
323
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
312
324
 
313
325
  interpreter.process("220 mail.example.com ESMTP Exim 4.63\r\n")
314
326
  assert_equal 'EHLO localhost.local', delegate.read
@@ -322,8 +334,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
322
334
  end
323
335
 
324
336
  def test_basic_smtp_plaintext_auth_accepted
325
- delegate = SMTPDelegate.new(:username => 'tester@example.com', :password => 'tester')
326
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
337
+ delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
338
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
327
339
 
328
340
  assert delegate.requires_authentication?
329
341
 
@@ -347,14 +359,15 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
347
359
  assert_equal :ready, interpreter.state
348
360
  end
349
361
 
350
- def test_basic_esmtp_plaintext_auth_accepted
351
- delegate = SMTPDelegate.new(:username => 'tester@example.com', :password => 'tester')
352
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
362
+ def test_basic_esmtp_auth_plain_accepted
363
+ delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
364
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
353
365
 
354
366
  interpreter.process("220 mail.example.com ESMTP Exim 4.63\r\n")
355
367
  assert_equal 'EHLO localhost.local', delegate.read
356
368
 
357
369
  interpreter.process("250-mail.example.com Hello\r\n")
370
+ interpreter.process("250-AUTH PLAIN\r\n")
358
371
  interpreter.process("250 HELP\r\n")
359
372
 
360
373
  assert_equal false, delegate.started_tls?
@@ -367,17 +380,19 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
367
380
  assert_equal :ready, interpreter.state
368
381
  end
369
382
 
370
- def test_basic_esmtp_plaintext_auth_rejected
371
- delegate = SMTPDelegate.new(:username => 'tester@example.com', :password => 'tester')
372
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
383
+ def test_basic_esmtp_auth_plain_rejected
384
+ delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
385
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
373
386
 
374
387
  interpreter.process("220 mx.google.com ESMTP\r\n")
375
388
  assert_equal 'EHLO localhost.local', delegate.read
376
389
 
377
390
  interpreter.process("250-mx.google.com at your service\r\n")
391
+ interpreter.process("250-AUTH PLAIN LOGIN\r\n")
378
392
  interpreter.process("250 HELP\r\n")
379
393
 
380
394
  assert_equal false, delegate.started_tls?
395
+ assert_equal %i[ plain login ], delegate.auth_support.to_a
381
396
 
382
397
  assert_equal :auth, interpreter.state
383
398
  assert_equal "AUTH PLAIN AHRlc3RlckBleGFtcGxlLmNvbQB0ZXN0ZXI=", delegate.read
@@ -395,9 +410,41 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
395
410
  assert_equal true, delegate.closed?
396
411
  end
397
412
 
413
+ def test_basic_esmtp_auth_login_accepted
414
+ delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
415
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
416
+
417
+ interpreter.process("220 mail.example.com ESMTP Exim 4.63\r\n")
418
+ assert_equal 'EHLO localhost.local', delegate.read
419
+
420
+ interpreter.process("250-mail.example.com Hello\r\n")
421
+ interpreter.process("250-AUTH NTLM CRAM-MD5 GSSAPI LOGIN\r\n")
422
+ interpreter.process("250 HELP\r\n")
423
+
424
+ assert_equal false, delegate.started_tls?
425
+ assert_equal %i[ ntlm cram-md5 gssapi login ], delegate.auth_support.to_a
426
+
427
+ assert_equal "AUTH LOGIN", delegate.read
428
+
429
+ assert_equal :auth_username, interpreter.state
430
+ interpreter.process("334 VXNlcm5hbWU6\r\n")
431
+ assert_equal Base64.strict_encode64('tester@example.com'), delegate.read
432
+
433
+ assert_equal :auth_password, interpreter.state
434
+
435
+ interpreter.process("334 UGFzc3dvcmQ6\r\n")
436
+ assert_equal Base64.strict_encode64('tester'), delegate.read
437
+
438
+ assert_equal :auth_acknowledge, interpreter.state
439
+ interpreter.process("235 Sounds good\r\n")
440
+
441
+ assert_equal :ready, interpreter.state
442
+ end
443
+
444
+
398
445
  def test_unexpected_response
399
- delegate = SMTPDelegate.new(:username => 'tester@example.com', :password => 'tester')
400
- interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
446
+ delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
447
+ interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
401
448
 
402
449
  interpreter.process("530 Go away\r\n")
403
450
 
@@ -1,15 +1,14 @@
1
- require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
1
+ require_relative '../helper'
2
2
 
3
- class RemailerSMTPClientTest < Test::Unit::TestCase
3
+ class RemailerSMTPClientTest < MiniTest::Test
4
4
  def test_connect
5
5
  engine do
6
- debug = { }
7
6
  connected_host = nil
8
7
 
9
8
  connection = Remailer::SMTP::Client.open(
10
- TestConfig.smtp_server[:host],
11
- :debug => STDERR,
12
- :connect => lambda { |success, host| connected_host = host }
9
+ TestConfig.options[:public_smtp_server][:host],
10
+ debug: self.debug_channel,
11
+ connect: lambda { |success, host| connected_host = host }
13
12
  )
14
13
 
15
14
  after_complete_trigger = false
@@ -27,11 +26,11 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
27
26
  connection.closed?
28
27
  end
29
28
 
30
- assert_equal TestConfig.smtp_server[:host], connected_host
29
+ assert_equal TestConfig.options[:public_smtp_server][:identifier], connected_host
31
30
 
32
31
  assert_equal true, after_complete_trigger
33
32
 
34
- assert_equal 52428800, connection.max_size
33
+ assert_equal 157286400, connection.max_size
35
34
  assert_equal :esmtp, connection.protocol
36
35
  assert_equal true, connection.tls_support?
37
36
  end
@@ -45,13 +44,13 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
45
44
 
46
45
  connection = Remailer::SMTP::Client.open(
47
46
  'example.com',
48
- :debug => STDERR,
49
- :error => lambda { |code, message|
47
+ debug: self.debug_channel,
48
+ error: lambda { |code, message|
50
49
  error_received = [ code, message ]
51
50
  },
52
- :on_connect => lambda { on_connect = true },
53
- :on_error => lambda { on_error = true },
54
- :timeout => 1
51
+ on_connect: lambda { on_connect = true },
52
+ on_error: lambda { on_error = true },
53
+ timeout: 1
55
54
  )
56
55
 
57
56
  assert_eventually(3) do
@@ -70,13 +69,13 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
70
69
  engine do
71
70
  error_received = nil
72
71
 
73
- connection = Remailer::SMTP::Client.open(
72
+ Remailer::SMTP::Client.open(
74
73
  'invalid-example-domain--x.com',
75
- :debug => STDERR,
76
- :error => lambda { |code, message|
74
+ debug: self.debug_channel,
75
+ error: lambda { |code, message|
77
76
  error_received = [ code, message ]
78
77
  },
79
- :timeout => 1
78
+ timeout: 1
80
79
  )
81
80
 
82
81
  assert_eventually(3) do
@@ -89,14 +88,12 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
89
88
 
90
89
  def test_connect_with_auth
91
90
  engine do
92
- debug = { }
93
-
94
91
  connection = Remailer::SMTP::Client.open(
95
- TestConfig.public_smtp_server[:host],
96
- :port => TestConfig.public_smtp_server[:port] || Remailer::SMTP::Client::SMTP_PORT,
97
- :debug => STDERR,
98
- :username => TestConfig.public_smtp_server[:username],
99
- :password => TestConfig.public_smtp_server[:password]
92
+ TestConfig.options[:smtp_server][:host],
93
+ port: TestConfig.options[:smtp_server][:port] || Remailer::SMTP::Client::SMTP_PORT,
94
+ debug: self.debug_channel,
95
+ username: TestConfig.options[:smtp_server][:username],
96
+ password: TestConfig.options[:smtp_server][:password]
100
97
  )
101
98
 
102
99
  after_complete_trigger = false
@@ -113,11 +110,11 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
113
110
  connection.closed?
114
111
  end
115
112
 
116
- assert_equal TestConfig.public_smtp_server[:identifier], connection.remote
113
+ assert_equal TestConfig.options[:smtp_server][:identifier], connection.remote
117
114
 
118
115
  assert_equal true, after_complete_trigger
119
116
 
120
- assert_equal 35651584, connection.max_size
117
+ assert_equal 35882577, connection.max_size
121
118
  assert_equal :esmtp, connection.protocol
122
119
  assert_equal true, connection.tls_support?
123
120
  end
@@ -125,14 +122,12 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
125
122
 
126
123
  def test_connect_via_proxy
127
124
  engine do
128
- debug = { }
129
-
130
125
  connection = Remailer::SMTP::Client.open(
131
- TestConfig.smtp_server[:host],
132
- :debug => STDERR,
133
- :proxy => {
134
- :proto => :socks5,
135
- :host => TestConfig.proxy_server
126
+ TestConfig.options[:public_smtp_server][:host],
127
+ debug: self.debug_channel,
128
+ proxy: {
129
+ proto: :socks5,
130
+ host: TestConfig.options[:proxy_server]
136
131
  }
137
132
  )
138
133
 
@@ -143,18 +138,18 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
143
138
  after_complete_trigger = true
144
139
  end
145
140
 
146
- assert_equal :connect_to_proxy, connection.state
141
+ assert_equal :initialized, connection.state
147
142
  assert !connection.error?
148
143
 
149
144
  assert_eventually(15) do
150
145
  connection.closed?
151
146
  end
152
147
 
153
- assert_equal TestConfig.smtp_server[:identifier], connection.remote
148
+ assert_equal TestConfig.options[:public_smtp_server][:identifier], connection.remote
154
149
 
155
150
  assert_equal true, after_complete_trigger
156
151
 
157
- assert_equal 52428800, connection.max_size
152
+ assert_equal 157286400, connection.max_size
158
153
  assert_equal :esmtp, connection.protocol
159
154
  assert_equal true, connection.tls_support?
160
155
  end
@@ -163,8 +158,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
163
158
  def test_connect_and_send_after_start
164
159
  engine do
165
160
  connection = Remailer::SMTP::Client.open(
166
- TestConfig.smtp_server[:host],
167
- :debug => STDERR
161
+ TestConfig.options[:public_smtp_server][:host],
162
+ debug: self.debug_channel
168
163
  )
169
164
 
170
165
  assert_equal :initialized, connection.state
@@ -177,8 +172,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
177
172
  callback_received = false
178
173
 
179
174
  connection.send_email(
180
- 'remailer+test@example.postageapp.com',
181
- 'remailer+test@example.postageapp.com',
175
+ TestConfig.options[:sender],
176
+ TestConfig.options[:recipient],
182
177
  example_message
183
178
  ) do |c|
184
179
  callback_received = true
@@ -196,8 +191,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
196
191
  def test_connect_and_send_dotted_message
197
192
  engine do
198
193
  connection = Remailer::SMTP::Client.open(
199
- TestConfig.smtp_server[:host],
200
- :debug => STDERR
194
+ TestConfig.options[:public_smtp_server][:host],
195
+ debug: self.debug_channel
201
196
  )
202
197
 
203
198
  assert_equal :initialized, connection.state
@@ -205,8 +200,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
205
200
 
206
201
  result_code = nil
207
202
  connection.send_email(
208
- 'remailer+test@example.postageapp.com',
209
- 'remailer+test@example.postageapp.com',
203
+ TestConfig.options[:sender],
204
+ TestConfig.options[:recipient],
210
205
  example_message + "\r\n\.\r\nHam sandwich.\r\n"
211
206
  ) do |c|
212
207
  result_code = c
@@ -221,8 +216,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
221
216
  def test_connect_and_send_multiple
222
217
  engine do
223
218
  connection = Remailer::SMTP::Client.open(
224
- TestConfig.smtp_server[:host],
225
- :debug => STDERR
219
+ TestConfig.options[:public_smtp_server][:host],
220
+ debug: self.debug_channel
226
221
  )
227
222
 
228
223
  assert_equal :initialized, connection.state
@@ -231,9 +226,12 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
231
226
  result_code = [ ]
232
227
 
233
228
  10.times do |n|
229
+ recipient_parts = TestConfig.options[:sender].split(/@/)
230
+ recipient_parts.insert(1, n)
231
+
234
232
  connection.send_email(
235
- 'remailer+from@example.postageapp.com',
236
- "remailer+to#{n}@example.postageapp.com",
233
+ TestConfig.options[:sender],
234
+ '%s+%d@%s' % recipient_parts,
237
235
  example_message
238
236
  ) do |c|
239
237
  result_code[n] = c
@@ -249,8 +247,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
249
247
  def test_connect_and_long_send
250
248
  engine do
251
249
  connection = Remailer::SMTP::Client.open(
252
- TestConfig.smtp_server[:host],
253
- :debug => STDERR
250
+ TestConfig.options[:public_smtp_server][:host],
251
+ debug: self.debug_channel
254
252
  )
255
253
 
256
254
  assert_equal :initialized, connection.state
@@ -259,8 +257,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
259
257
  result_code = nil
260
258
 
261
259
  connection.send_email(
262
- TestConfig.sender,
263
- TestConfig.recipient,
260
+ TestConfig.options[:sender],
261
+ TestConfig.options[:recipient],
264
262
  example_message + 'a' * 100000
265
263
  ) do |c|
266
264
  callback_made = true
@@ -279,9 +277,9 @@ protected
279
277
  def example_message
280
278
  example = <<__END__
281
279
  Date: Sat, 13 Nov 2010 02:25:24 +0000
282
- From: #{TestConfig.sender}
283
- To: Remailer Test <#{TestConfig.receiver}>
284
- Message-Id: <hfLkcIByfjYoNIxCO7DMsxBTX9svsFHikIOfAiYy@#{TestConfig.sender.split(/@/).last}>
280
+ From: #{TestConfig.options[:sender]}
281
+ To: Remailer Test <#{TestConfig.options[:receiver]}>
282
+ Message-Id: <hfLkcIByfjYoNIxCO7DMsxBTX9svsFHikIOfAiYy@#{TestConfig.options[:sender].split(/@/).last}>
285
283
  Subject: Example Subject
286
284
  Mime-Version: 1.0
287
285
  Content-Type: text/plain