remailer 0.5.2 → 0.9.1

data/test/unit/remailer_smtp_client_interpreter_test.rb

@@ -1,13 +1,16 @@
-require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
+require_relative '../helper'
 
-class SMTPDelegate
-  attr_accessor :options, :protocol, :active_message
+class TestSMTPDelegate
+  attr_accessor :options, :protocol, :active_message, :auth_support
   attr_accessor :tls_support
   
   def initialize(options = { })
     @sent = [ ]
     @options = options
     @protocol = :smtp
+    @started_tls = false
+    @tls_support = nil
+    @closed = false
   end
   
   def hostname
@@ -57,12 +60,21 @@ class SMTPDelegate
   def read
     @sent.shift
   end
+
+  def auth_support?(type = nil)
+    case (type)
+    when nil
+      !!@auth_support
+    else
+      !!(@auth_support&.include?(type))
+    end
+  end
   
   def method_missing(*args)
   end
 end
 
-class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
+class RemailerSMTPClientInterpreterTest < MiniTest::Test
   def test_split_reply
     assert_mapping(
       '250 OK' => [ 250, 'OK' ],
@@ -119,28 +131,28 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
   end
   
   def test_delegate_default_state
-    delegate = SMTPDelegate.new
+    delegate = TestSMTPDelegate.new
 
     assert_equal false, delegate.closed?
-    assert_equal nil, delegate.read
+    assert_nil delegate.read
     assert_equal 0, delegate.size
   end
 
   def test_delegate_options
-    delegate = SMTPDelegate.new(:use_tls => true)
+    delegate = TestSMTPDelegate.new(use_tls: true)
 
     assert_equal true, delegate.use_tls?
     assert_equal false, delegate.requires_authentication?
 
-    delegate = SMTPDelegate.new(:username => 'test@example.com', :password => 'tester')
+    delegate = TestSMTPDelegate.new(username: 'test@example.com', password: 'tester')
 
     assert_equal false, delegate.use_tls?
     assert_equal true, delegate.requires_authentication?
   end
 
   def test_standard_smtp_connection
-    delegate = SMTPDelegate.new
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+    delegate = TestSMTPDelegate.new
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
 
     assert_equal :initialized, interpreter.state
     
@@ -162,8 +174,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
   end
 
   def test_standard_smtp_connection_send_email
-    delegate = SMTPDelegate.new
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+    delegate = TestSMTPDelegate.new
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
 
     assert_equal :initialized, interpreter.state
     
@@ -184,9 +196,9 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
     assert_equal true, delegate.closed?
     
     delegate.active_message = {
-      :from => 'from@example.com',
-      :to => 'to@example.com',
-      :data => "Subject: Test Message\r\n\r\nThis is a message!\r\n"
+      from: 'from@example.com',
+      to: 'to@example.com',
+      data: "Subject: Test Message\r\n\r\nThis is a message!\r\n"
     }
     
     interpreter.enter_state(:send)
@@ -217,8 +229,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
   end
   
   def test_standard_esmtp_connection
-    delegate = SMTPDelegate.new
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+    delegate = TestSMTPDelegate.new
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
 
     assert_equal :initialized, interpreter.state
     
@@ -254,8 +266,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
   end
   
   def test_multi_line_hello_response
-    delegate = SMTPDelegate.new(:use_tls => true)
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+    delegate = TestSMTPDelegate.new(use_tls: true)
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
 
     assert_equal :initialized, interpreter.state
     assert_equal :smtp, delegate.protocol
@@ -276,8 +288,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
   end
 
   def test_tls_connection_with_support
-    delegate = SMTPDelegate.new(:use_tls => true)
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+    delegate = TestSMTPDelegate.new(use_tls: true)
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
     
     assert_equal true, delegate.use_tls?
     assert_equal :initialized, interpreter.state
@@ -307,8 +319,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
   end
 
   def test_tls_connection_without_support
-    delegate = SMTPDelegate.new(:use_tls => true)
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+    delegate = TestSMTPDelegate.new(use_tls: true)
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
 
     interpreter.process("220 mail.example.com ESMTP Exim 4.63\r\n")
     assert_equal 'EHLO localhost.local', delegate.read
@@ -322,8 +334,8 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
   end
 
   def test_basic_smtp_plaintext_auth_accepted
-    delegate = SMTPDelegate.new(:username => 'tester@example.com', :password => 'tester')
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+    delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
     
     assert delegate.requires_authentication?
 
@@ -347,14 +359,15 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
     assert_equal :ready, interpreter.state
   end
 
-  def test_basic_esmtp_plaintext_auth_accepted
-    delegate = SMTPDelegate.new(:username => 'tester@example.com', :password => 'tester')
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+  def test_basic_esmtp_auth_plain_accepted
+    delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
 
     interpreter.process("220 mail.example.com ESMTP Exim 4.63\r\n")
     assert_equal 'EHLO localhost.local', delegate.read
     
     interpreter.process("250-mail.example.com Hello\r\n")
+    interpreter.process("250-AUTH PLAIN\r\n")
     interpreter.process("250 HELP\r\n")
     
     assert_equal false, delegate.started_tls?
@@ -367,17 +380,19 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
     assert_equal :ready, interpreter.state
   end
 
-  def test_basic_esmtp_plaintext_auth_rejected
-    delegate = SMTPDelegate.new(:username => 'tester@example.com', :password => 'tester')
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+  def test_basic_esmtp_auth_plain_rejected
+    delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
 
     interpreter.process("220 mx.google.com ESMTP\r\n")
     assert_equal 'EHLO localhost.local', delegate.read
     
     interpreter.process("250-mx.google.com at your service\r\n")
+    interpreter.process("250-AUTH PLAIN LOGIN\r\n")
     interpreter.process("250 HELP\r\n")
     
     assert_equal false, delegate.started_tls?
+    assert_equal %i[ plain login ], delegate.auth_support.to_a
 
     assert_equal :auth, interpreter.state
     assert_equal "AUTH PLAIN AHRlc3RlckBleGFtcGxlLmNvbQB0ZXN0ZXI=", delegate.read
@@ -395,9 +410,41 @@ class RemailerSMTPClientInterpreterTest < Test::Unit::TestCase
     assert_equal true, delegate.closed?
   end
 
+  def test_basic_esmtp_auth_login_accepted
+    delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
+
+    interpreter.process("220 mail.example.com ESMTP Exim 4.63\r\n")
+    assert_equal 'EHLO localhost.local', delegate.read
+    
+    interpreter.process("250-mail.example.com Hello\r\n")
+    interpreter.process("250-AUTH NTLM CRAM-MD5 GSSAPI LOGIN\r\n")
+    interpreter.process("250 HELP\r\n")
+    
+    assert_equal false, delegate.started_tls?
+    assert_equal %i[ ntlm cram-md5 gssapi login ], delegate.auth_support.to_a
+
+    assert_equal "AUTH LOGIN", delegate.read
+
+    assert_equal :auth_username, interpreter.state
+    interpreter.process("334 VXNlcm5hbWU6\r\n")
+    assert_equal Base64.strict_encode64('tester@example.com'), delegate.read
+
+    assert_equal :auth_password, interpreter.state
+
+    interpreter.process("334 UGFzc3dvcmQ6\r\n")
+    assert_equal Base64.strict_encode64('tester'), delegate.read
+
+    assert_equal :auth_acknowledge, interpreter.state
+    interpreter.process("235 Sounds good\r\n")
+
+    assert_equal :ready, interpreter.state
+  end
+
+
   def test_unexpected_response
-    delegate = SMTPDelegate.new(:username => 'tester@example.com', :password => 'tester')
-    interpreter = Remailer::SMTP::Client::Interpreter.new(:delegate => delegate)
+    delegate = TestSMTPDelegate.new(username: 'tester@example.com', password: 'tester')
+    interpreter = Remailer::SMTP::Client::Interpreter.new(delegate: delegate)
 
     interpreter.process("530 Go away\r\n")
     

data/test/unit/remailer_smtp_client_test.rb

@@ -1,15 +1,14 @@
-require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
+require_relative '../helper'
 
-class RemailerSMTPClientTest < Test::Unit::TestCase
+class RemailerSMTPClientTest < MiniTest::Test
   def test_connect
     engine do
-      debug = { }
       connected_host = nil
 
       connection = Remailer::SMTP::Client.open(
-        TestConfig.smtp_server[:host],
-        :debug => STDERR, 
-        :connect => lambda { |success, host| connected_host = host }
+        TestConfig.options[:public_smtp_server][:host],
+        debug: self.debug_channel, 
+        connect: lambda { |success, host| connected_host = host }
       )
 
       after_complete_trigger = false
@@ -27,11 +26,11 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
         connection.closed?
       end
 
-      assert_equal TestConfig.smtp_server[:host], connected_host
+      assert_equal TestConfig.options[:public_smtp_server][:identifier], connected_host
 
       assert_equal true, after_complete_trigger
 
-      assert_equal 52428800, connection.max_size
+      assert_equal 157286400, connection.max_size
       assert_equal :esmtp, connection.protocol
       assert_equal true, connection.tls_support?
     end
@@ -45,13 +44,13 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
 
       connection = Remailer::SMTP::Client.open(
         'example.com',
-        :debug => STDERR,
-        :error => lambda { |code, message|
+        debug: self.debug_channel,
+        error: lambda { |code, message|
           error_received = [ code, message ]
         },
-        :on_connect => lambda { on_connect = true },
-        :on_error => lambda { on_error = true },
-        :timeout => 1
+        on_connect: lambda { on_connect = true },
+        on_error: lambda { on_error = true },
+        timeout: 1
       )
 
       assert_eventually(3) do
@@ -70,13 +69,13 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
     engine do
       error_received = nil
 
-      connection = Remailer::SMTP::Client.open(
+      Remailer::SMTP::Client.open(
         'invalid-example-domain--x.com',
-        :debug => STDERR,
-        :error => lambda { |code, message|
+        debug: self.debug_channel,
+        error: lambda { |code, message|
           error_received = [ code, message ]
         },
-        :timeout => 1
+        timeout: 1
       )
 
       assert_eventually(3) do
@@ -89,14 +88,12 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
 
   def test_connect_with_auth
     engine do
-      debug = { }
-
       connection = Remailer::SMTP::Client.open(
-        TestConfig.public_smtp_server[:host],
-        :port => TestConfig.public_smtp_server[:port] || Remailer::SMTP::Client::SMTP_PORT,
-        :debug => STDERR,
-        :username => TestConfig.public_smtp_server[:username],
-        :password => TestConfig.public_smtp_server[:password]
+        TestConfig.options[:smtp_server][:host],
+        port: TestConfig.options[:smtp_server][:port] || Remailer::SMTP::Client::SMTP_PORT,
+        debug: self.debug_channel,
+        username: TestConfig.options[:smtp_server][:username],
+        password: TestConfig.options[:smtp_server][:password]
       )
 
       after_complete_trigger = false
@@ -113,11 +110,11 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
         connection.closed?
       end
 
-      assert_equal TestConfig.public_smtp_server[:identifier], connection.remote
+      assert_equal TestConfig.options[:smtp_server][:identifier], connection.remote
 
       assert_equal true, after_complete_trigger
 
-      assert_equal 35651584, connection.max_size
+      assert_equal 35882577, connection.max_size
       assert_equal :esmtp, connection.protocol
       assert_equal true, connection.tls_support?
     end
@@ -125,14 +122,12 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
 
   def test_connect_via_proxy
     engine do
-      debug = { }
-
       connection = Remailer::SMTP::Client.open(
-        TestConfig.smtp_server[:host],
-        :debug => STDERR,
-        :proxy => {
-          :proto => :socks5,
-          :host => TestConfig.proxy_server
+        TestConfig.options[:public_smtp_server][:host],
+        debug: self.debug_channel,
+        proxy: {
+          proto: :socks5,
+          host: TestConfig.options[:proxy_server]
         }
       )
 
@@ -143,18 +138,18 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
         after_complete_trigger = true
       end
 
-      assert_equal :connect_to_proxy, connection.state
+      assert_equal :initialized, connection.state
       assert !connection.error?
 
       assert_eventually(15) do
         connection.closed?
       end
 
-      assert_equal TestConfig.smtp_server[:identifier], connection.remote
+      assert_equal TestConfig.options[:public_smtp_server][:identifier], connection.remote
 
       assert_equal true, after_complete_trigger
 
-      assert_equal 52428800, connection.max_size
+      assert_equal 157286400, connection.max_size
       assert_equal :esmtp, connection.protocol
       assert_equal true, connection.tls_support?
     end
@@ -163,8 +158,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
   def test_connect_and_send_after_start
     engine do
       connection = Remailer::SMTP::Client.open(
-        TestConfig.smtp_server[:host],
-        :debug => STDERR
+        TestConfig.options[:public_smtp_server][:host],
+        debug: self.debug_channel
       )
 
       assert_equal :initialized, connection.state
@@ -177,8 +172,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
       callback_received = false
       
       connection.send_email(
-        'remailer+test@example.postageapp.com',
-        'remailer+test@example.postageapp.com',
+        TestConfig.options[:sender],
+        TestConfig.options[:recipient],
         example_message
       ) do |c|
         callback_received = true
@@ -196,8 +191,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
   def test_connect_and_send_dotted_message
     engine do
       connection = Remailer::SMTP::Client.open(
-        TestConfig.smtp_server[:host],
-        :debug => STDERR
+        TestConfig.options[:public_smtp_server][:host],
+        debug: self.debug_channel
       )
 
       assert_equal :initialized, connection.state
@@ -205,8 +200,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
 
       result_code = nil
       connection.send_email(
-        'remailer+test@example.postageapp.com',
-        'remailer+test@example.postageapp.com',
+        TestConfig.options[:sender],
+        TestConfig.options[:recipient],
         example_message + "\r\n\.\r\nHam sandwich.\r\n"
       ) do |c|
         result_code = c
@@ -221,8 +216,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
   def test_connect_and_send_multiple
     engine do
       connection = Remailer::SMTP::Client.open(
-        TestConfig.smtp_server[:host],
-        :debug => STDERR
+        TestConfig.options[:public_smtp_server][:host],
+        debug: self.debug_channel
       )
 
       assert_equal :initialized, connection.state
@@ -231,9 +226,12 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
       result_code = [ ]
 
       10.times do |n|
+        recipient_parts = TestConfig.options[:sender].split(/@/)
+        recipient_parts.insert(1, n)
+
         connection.send_email(
-          'remailer+from@example.postageapp.com',
-          "remailer+to#{n}@example.postageapp.com",
+          TestConfig.options[:sender],
+          '%s+%d@%s' % recipient_parts,
           example_message
         ) do |c|
           result_code[n] = c
@@ -249,8 +247,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
   def test_connect_and_long_send
     engine do
       connection = Remailer::SMTP::Client.open(
-        TestConfig.smtp_server[:host],
-        :debug => STDERR
+        TestConfig.options[:public_smtp_server][:host],
+        debug: self.debug_channel
       )
 
       assert_equal :initialized, connection.state
@@ -259,8 +257,8 @@ class RemailerSMTPClientTest < Test::Unit::TestCase
       result_code = nil
 
       connection.send_email(
-        TestConfig.sender,
-        TestConfig.recipient,
+        TestConfig.options[:sender],
+        TestConfig.options[:recipient],
         example_message + 'a' * 100000
       ) do |c|
         callback_made = true
@@ -279,9 +277,9 @@ protected
   def example_message
     example = <<__END__
 Date: Sat, 13 Nov 2010 02:25:24 +0000
-From: #{TestConfig.sender}
-To: Remailer Test <#{TestConfig.receiver}>
-Message-Id: <hfLkcIByfjYoNIxCO7DMsxBTX9svsFHikIOfAiYy@#{TestConfig.sender.split(/@/).last}>
+From: #{TestConfig.options[:sender]}
+To: Remailer Test <#{TestConfig.options[:receiver]}>
+Message-Id: <hfLkcIByfjYoNIxCO7DMsxBTX9svsFHikIOfAiYy@#{TestConfig.options[:sender].split(/@/).last}>
 Subject: Example Subject
 Mime-Version: 1.0
 Content-Type: text/plain