remailer 0.2.1 → 0.3.0

data/test/unit/remailer_connection_test.rb

@@ -0,0 +1,287 @@
+require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
+
+class RemailerConnectionTest < Test::Unit::TestCase
+  def test_connect
+    engine do
+      debug = { }
+      connected_host = nil
+
+      connection = Remailer::Connection.open(
+        TestConfig.smtp_server[:host],
+        :debug => STDERR, 
+        :connect => lambda { |success, host| connected_host = host }
+      )
+
+      after_complete_trigger = false
+
+      connection.close_when_complete!
+      connection.after_complete do
+        after_complete_trigger = true
+      end
+
+      assert_equal :initialized, connection.state
+      assert !connection.error?
+      assert !connection.closed?
+
+      assert_eventually(30) do
+        connection.closed?
+      end
+
+      assert_equal TestConfig.smtp_server[:host], connected_host
+
+      assert_equal true, after_complete_trigger
+
+      assert_equal 52428800, connection.max_size
+      assert_equal :esmtp, connection.protocol
+      assert_equal true, connection.tls_support?
+    end
+  end
+
+  def test_failed_connect_no_service
+    engine do
+      error_received = nil
+
+      connection = Remailer::Connection.open(
+        'example.com',
+        :debug => STDERR,
+        :error => lambda { |code, message|
+          error_received = [ code, message ]
+        },
+        :timeout => 1
+      )
+
+      assert_eventually(3) do
+        error_received
+      end
+
+      assert_equal :timeout, error_received[0]
+    end
+  end
+
+  def test_failed_connect_no_valid_hostname
+    engine do
+      error_received = nil
+
+      connection = Remailer::Connection.open(
+        'invalid-example-domain--x.com',
+        :debug => STDERR,
+        :error => lambda { |code, message|
+          error_received = [ code, message ]
+        },
+        :timeout => 1
+      )
+
+      assert_eventually(3) do
+        error_received
+      end
+
+      assert_equal :connect_error, error_received[0]
+    end
+  end
+
+  def test_connect_with_auth
+    engine do
+      debug = { }
+
+      connection = Remailer::Connection.open(
+        TestConfig.public_smtp_server[:host],
+        :port => TestConfig.public_smtp_server[:port] || Remailer::Connection::SMTP_PORT,
+        :debug => STDERR,
+        :username => TestConfig.public_smtp_server[:username],
+        :password => TestConfig.public_smtp_server[:password]
+      )
+
+      after_complete_trigger = false
+
+      connection.close_when_complete!
+      connection.after_complete do
+        after_complete_trigger = true
+      end
+
+      assert_equal :initialized, connection.state
+      assert !connection.error?
+
+      assert_eventually(15) do
+        connection.closed?
+      end
+
+      assert_equal TestConfig.public_smtp_server[:identifier], connection.remote
+
+      assert_equal true, after_complete_trigger
+
+      assert_equal 35651584, connection.max_size
+      assert_equal :esmtp, connection.protocol
+      assert_equal true, connection.tls_support?
+    end
+  end
+
+  def test_connect_via_proxy
+    engine do
+      debug = { }
+
+      connection = Remailer::Connection.open(
+        TestConfig.smtp_server[:host],
+        :debug => STDERR,
+        :proxy => {
+          :proto => :socks5,
+          :host => TestConfig.proxy_server
+        }
+      )
+
+      after_complete_trigger = false
+
+      connection.close_when_complete!
+      connection.after_complete do
+        after_complete_trigger = true
+      end
+
+      assert_equal :connect_to_proxy, connection.state
+      assert !connection.error?
+
+      assert_eventually(15) do
+        connection.closed?
+      end
+
+      assert_equal TestConfig.smtp_server[:identifier], connection.remote
+
+      assert_equal true, after_complete_trigger
+
+      assert_equal 52428800, connection.max_size
+      assert_equal :esmtp, connection.protocol
+      assert_equal true, connection.tls_support?
+    end
+  end
+
+  def test_connect_and_send_after_start
+    engine do
+      connection = Remailer::Connection.open(
+        TestConfig.smtp_server[:host],
+        :debug => STDERR
+      )
+
+      assert_equal :initialized, connection.state
+
+      assert_eventually(10) do
+        connection.state == :ready
+      end
+
+      result_code = nil
+      callback_received = false
+      
+      connection.send_email(
+        'remailer+test@example.postageapp.com',
+        'remailer+test@example.postageapp.com',
+        example_message
+      ) do |c|
+        callback_received = true
+        result_code = c
+      end
+
+      assert_eventually(5) do
+        callback_received
+      end
+      
+      assert_equal 250, result_code
+    end
+  end
+
+  def test_connect_and_send_dotted_message
+    engine do
+      connection = Remailer::Connection.open(
+        TestConfig.smtp_server[:host],
+        :debug => STDERR
+      )
+
+      assert_equal :initialized, connection.state
+      assert !connection.error?
+
+      result_code = nil
+      connection.send_email(
+        'remailer+test@example.postageapp.com',
+        'remailer+test@example.postageapp.com',
+        example_message + "\r\n\.\r\nHam sandwich.\r\n"
+      ) do |c|
+        result_code = c
+      end
+
+      assert_eventually(15) do
+        result_code == 250
+      end
+    end
+  end
+
+  def test_connect_and_send_multiple
+    engine do
+      connection = Remailer::Connection.open(
+        TestConfig.smtp_server[:host],
+        :debug => STDERR
+      )
+
+      assert_equal :initialized, connection.state
+      assert !connection.error?
+
+      result_code = [ ]
+
+      10.times do |n|
+        connection.send_email(
+          'remailer+from@example.postageapp.com',
+          "remailer+to#{n}@example.postageapp.com",
+          example_message
+        ) do |c|
+          result_code[n] = c
+        end
+      end
+
+      assert_eventually(15) do
+        result_code == [ 250 ] * 10
+      end
+    end
+  end
+
+  def test_connect_and_long_send
+    engine do
+      connection = Remailer::Connection.open(
+        TestConfig.smtp_server[:host],
+        :debug => STDERR
+      )
+
+      assert_equal :initialized, connection.state
+
+      callback_made = false
+      result_code = nil
+
+      connection.send_email(
+        TestConfig.sender,
+        TestConfig.recipient,
+        example_message + 'a' * 100000
+      ) do |c|
+        callback_made = true
+        result_code = c
+      end
+
+      assert_eventually(30) do
+        callback_made
+      end
+      
+      assert_equal 250, result_code
+    end
+  end
+
+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}>
+Subject: Example Subject
+Mime-Version: 1.0
+Content-Type: text/plain
+Auto-Submitted: auto-generated
+
+This is a very boring message. It is dreadfully dull.
+__END__
+
+    example.gsub(/\n/, "\r\n")
+  end
+end

data/test/unit/remailer_interpreter_state_proxy_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
+
+class RemailerInterpreterStateTest < Test::Unit::TestCase
+  def test_defaults
+    options = { }
+    
+    Remailer::Interpreter::StateProxy.new(options)
+
+    assert_equal({ }, options)
+  end
+  
+  def test_simple_configuration
+    options = { }
+    
+    proxy = Remailer::Interpreter::StateProxy.new(options)
+
+    expected = {
+      :enter => [ lambda { } ],
+      :default => [ lambda { } ],
+      :leave => [ lambda { } ]
+    }.freeze
+
+    proxy.enter(&expected[:enter][0])
+    proxy.default(&expected[:default][0])
+    proxy.leave(&expected[:leave][0])
+    
+    assert_equal expected, options
+  end
+
+  def test_terminal_configuration
+    options = { }
+
+    expected = {
+      :enter => [ lambda { } ],
+      :terminate => [ lambda { } ],
+      :leave => [ lambda { } ]
+    }.freeze
+
+    Remailer::Interpreter::StateProxy.new(options) do
+      enter(&expected[:enter][0])
+      terminate(&expected[:terminate][0])
+      leave(&expected[:leave][0])
+    end
+
+    assert_equal expected, options
+  end
+
+  def test_interpreting_configuration
+    options = { }
+    
+    expected = {
+      :enter => [ lambda { } ],
+      :interpret => [ [ 10, lambda { } ], [ 1, lambda { } ] ],
+      :default => [ lambda { } ],
+      :leave => [ lambda { } ]
+    }.freeze
+
+    Remailer::Interpreter::StateProxy.new(options) do
+      enter(&expected[:enter][0])
+      interpret(10, &expected[:interpret][0][1])
+      interpret(1, &expected[:interpret][1][1])
+      default(&expected[:default][0])
+      leave(&expected[:leave][0])
+    end
+
+    assert_equal expected, options
+  end
+
+  def test_rebind
+    options_a = { }
+    options_b = { }
+    
+    proc = [ lambda { }, lambda { } ]
+    
+    proxy = Remailer::Interpreter::StateProxy.new(options_a) do
+      enter(&proc[0])
+    end
+    
+    proxy.send(:rebind, options_b)
+    
+    proxy.leave(&proc[1])
+    
+    assert_equal({ :enter => [ proc[0] ] }, options_a)
+    assert_equal({ :leave => [ proc[1] ] }, options_b)
+  end
+end

data/test/unit/remailer_interpreter_test.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
+
+class ExampleDelegate
+  include TestTriggerHelper
+  
+  attr_accessor :attribute
+  
+  def method_no_args
+    trigger(:method_no_args)
+  end
+
+  def method_with_args(arg1, arg2)
+    trigger(:method_with_args, [ arg1, arg2 ])
+  end
+end
+
+class AutomaticDelegate
+  include TestTriggerHelper
+
+  def enter_initialized!
+    trigger(:enter_initialized)
+  end
+end
+
+class ExampleInterpreter < Remailer::Interpreter
+  include TestTriggerHelper
+
+  attr_accessor :message, :reply
+  
+  state :initialized do
+    enter do
+      trigger(:enter_initialized_state)
+    end
+    
+    interpret(:start) do
+      enter_state(:start)
+    end
+
+    interpret(:branch) do
+      enter_state(:branch)
+    end
+
+    leave do
+      trigger(:leave_initialized_state)
+    end
+  end
+  
+  state :start do
+    interpret(:stop) do |message|
+      self.message = message
+      enter_state(:stop)
+    end
+  end
+  
+  state :branch do
+    default do |reply|
+      @reply = reply
+    end
+  end
+  
+  state :stop do
+    terminate
+  end
+end
+
+class RemailerInterpreterTest < Test::Unit::TestCase
+  def test_default_state
+    assert_equal [ :initialized, :terminated ], Remailer::Interpreter.states_defined
+    assert_equal true, Remailer::Interpreter.state_defined?(:initialized)
+    assert_equal true, Remailer::Interpreter.state_defined?(:terminated)
+    assert_equal false, Remailer::Interpreter.state_defined?(:unknown)
+
+    interpreter = Remailer::Interpreter.new
+    
+    assert_equal :initialized, interpreter.state
+  end
+  
+  def test_delegate
+    delegate = ExampleDelegate.new
+
+    assert delegate.triggered
+
+    interpreter = Remailer::Interpreter.new(:delegate => delegate)
+    
+    assert_equal nil, delegate.attribute
+    assert_equal false, delegate.triggered[:method_no_args]
+    assert_equal false, delegate.triggered[:method_with_args]
+    
+    interpreter.send(:delegate_call, :method_no_args)
+    
+    assert_equal true, delegate.triggered[:method_no_args]
+    assert_equal false, delegate.triggered[:method_with_args]
+
+    interpreter.send(:delegate_call, :method_with_args, 'one', :two)
+    
+    assert_equal true, delegate.triggered[:method_no_args]
+    assert_equal [ 'one', :two ], delegate.triggered[:method_with_args]
+    
+    interpreter.send(:delegate_call, :invalid_method)
+    
+    interpreter.send(:delegate_assign, :attribute, 'true')
+    
+    assert_equal 'true', delegate.attribute
+  end
+  
+  def test_example_interpreter
+    interpreter = ExampleInterpreter.new
+    
+    assert_equal :initialized, interpreter.state
+    assert_equal true, interpreter.triggered[:enter_initialized_state]
+    assert_equal false, interpreter.triggered[:leave_initialized_state]
+    
+    interpreter.interpret(:start)
+    
+    assert_equal :start, interpreter.state
+    assert_equal true, interpreter.triggered[:enter_initialized_state]
+    assert_equal true, interpreter.triggered[:leave_initialized_state]
+    
+    interpreter.interpret(:stop, 'Stop message')
+
+    assert_equal 'Stop message', interpreter.message
+    assert_equal :terminated, interpreter.state
+  end
+
+  def test_default_handler_for_interpreter
+    interpreter = ExampleInterpreter.new
+    
+    interpreter.interpret(:branch)
+    
+    assert_equal :branch, interpreter.state
+    
+    assert_equal true, interpreter.interpret(:random)
+    
+    assert_equal :branch, interpreter.state
+    assert_equal nil, interpreter.error
+    
+    assert_equal :random, interpreter.reply
+  end
+
+  def test_invalid_response_for_interpreter
+    interpreter = ExampleInterpreter.new
+    
+    assert_equal :initialized, interpreter.state
+    
+    interpreter.interpret(:invalid)
+    
+    assert_equal :terminated, interpreter.state
+    assert_equal true, interpreter.error?
+
+    assert interpreter.error.index(':initialized')
+    assert interpreter.error.index(':invalid')
+  end
+end