rumbster 1.0.0

data/test/smtp_protocol_test.rb

@@ -0,0 +1,64 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'test/unit'
+require 'smtp_protocol'
+
+class SmtpProtocolTest < Test::Unit::TestCase
+  
+  def test_protocol_sets_protocol_property_on_each_state
+    init_state = TestState.new
+    
+    protocol = SmtpProtocol.new(:init, {:init => init_state})
+
+    assert_same protocol, init_state.protocol
+  end
+  
+  def test_protocol_starts_in_the_initial_state
+    init_state = TestState.new
+    
+    protocol = SmtpProtocol.new(:init, {:init => init_state})
+    protocol.serve(nil)
+    
+    assert init_state.called
+  end
+  
+  def test_state_is_changed_when_a_new_state_is_set
+    next_state = TestState.new
+    
+    protocol = SmtpProtocol.new(:init, {:init => TestState.new, :next => next_state})
+    protocol.state = :next
+    protocol.serve(nil)
+    
+    assert next_state.called
+  end
+  
+  def test_listeners_are_notified_when_a_new_message_is_received
+    protocol = SmtpProtocol.new(:init, {:init => TestState.new})
+    observer = TestObserver.new
+    message = 'hi'
+    
+    protocol.add_observer(observer)
+    
+    protocol.new_message_received(message)
+    
+    assert_same message, observer.received_message
+  end
+  
+end
+
+class TestObserver
+  attr_accessor :received_message
+  
+  def update(message)
+    @received_message = message
+  end
+end
+
+class TestState
+  attr_accessor :called, :protocol
+  
+  def serve(io)
+    @called = true
+  end
+  
+end

data/test/smtp_states_test.rb

@@ -0,0 +1,217 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'test/unit'
+require 'stringio'
+require 'smtp_protocol'
+
+class SmtpStatesTest < Test::Unit::TestCase
+ 
+  def setup
+    buffer = ''
+    @server_stream = StringIO.new(buffer)
+    @client_stream = StringIO.new(buffer)    
+    @protocol = TestProtocol.new
+  end
+ 
+  def test_greeting_is_returned_upon_initial_client_connection
+    init_state = InitState.new(@protocol)
+    init_state.serve(@server_stream)
+       
+    assert_equal "220 ruby ESMTP\n", @client_stream.readline
+  end
+  
+  def test_initial_state_passes_protocol_connect_as_the_next_state_in_the_chain
+    init_state = InitState.new(@protocol)
+    init_state.serve(@server_stream)
+    
+    assert_equal :connect, @protocol.state
+  end
+  
+  def test_initial_state_passes_protocol_the_same_io_as_it_received
+    init_state = InitState.new(@protocol)
+    init_state.serve(@server_stream)
+    
+    assert_same @server_stream, @protocol.io
+  end
+  
+  def test_initial_state_raises_not_initialized_when_protocol_is_not_set
+    init_state = InitState.new
+    
+    assert_raise NotInitializedError do 
+      init_state.serve(@server_stream)
+    end
+  end
+     
+  def test_helo_is_accepted_while_in_connect_state
+    @client_stream.puts "HELO test.client"
+    connect_state = ConnectState.new(@protocol)
+
+    connect_state.serve(@server_stream)
+    
+    assert_equal "250 ruby\n", @client_stream.readline
+  end
+  
+  def test_connect_state_passes_protocol_connected_as_the_next_state_in_the_chain
+    @client_stream.puts "HELO test.client"
+    connect_state = ConnectState.new(@protocol)
+
+    connect_state.serve(@server_stream)
+    
+    assert_equal :connected, @protocol.state
+  end
+  
+  def test_connect_state_passes_protocol_the_same_io_as_it_received
+    @client_stream.puts "HELO test.client"
+    connect_state = ConnectState.new(@protocol)
+
+    connect_state.serve(@server_stream)
+    
+    assert_same @server_stream, @protocol.io
+  end
+  
+  def test_connect_state_raises_not_initialized_when_protocol_is_not_set
+    connect_state = ConnectState.new
+    
+    assert_raise NotInitializedError do
+      connect_state.serve(@server_stream)
+    end
+  end
+    
+  def test_from_okayed_while_in_connected_state
+    @client_stream.puts "MAIL FROM:<adam@esterlines.com>"
+    connected_state = ConnectedState.new(@protocol)
+
+    connected_state.serve(@server_stream)
+    
+    assert_equal "250 ok\n", @client_stream.readline
+  end
+  
+  def test_connected_state_passes_protocol_connected_as_the_next_state_when_client_sends_from_request
+    @client_stream.puts "MAIL FROM:<junk@junkster.com>"
+    connected_state = ConnectedState.new(@protocol)
+
+    connected_state.serve(@server_stream)
+    
+    assert_equal :connected, @protocol.state
+  end
+  
+  def test_rcpt_okayed_while_in_connected_state
+    @client_stream.puts "RCPT TO:<junk@junkster.com>"    
+    connected_state = ConnectedState.new(@protocol)
+
+    connected_state.serve(@server_stream)
+    
+    assert_equal "250 ok\n", @client_stream.readline
+  end
+  
+  def test_connected_state_passes_protocol_connected_as_the_next_state_when_client_sends_rcpt_request
+    @client_stream.puts "RCPT TO:<foo@foo.com>"    
+    connected_state = ConnectedState.new(@protocol)
+
+    connected_state.serve(@server_stream)
+    
+    assert_equal :connected, @protocol.state
+  end
+  
+  def test_connected_state_passes_protocol_the_same_io_as_it_received
+    @client_stream.puts "MAIL FROM:<foo@foo.com>"
+    connected_state = ConnectedState.new(@protocol)
+
+    connected_state.serve(@server_stream)
+    
+    assert_same @server_stream, @protocol.io
+  end
+  
+  def test_data_request_given_the_go_ahead_while_in_connected_state
+    @client_stream.puts "DATA"
+    connected_state = ConnectedState.new(@protocol)
+
+    connected_state.serve(@server_stream)
+    
+    assert_equal "354 go ahead\n", @client_stream.readline
+  end
+  
+  def test_connected_state_passes_protocol_read_mail_as_the_next_state_when_client_sends_data_request
+    @client_stream.puts "DATA"
+    connected_state = ConnectedState.new(@protocol)
+
+    connected_state.serve(@server_stream)
+    
+    assert_equal :read_mail, @protocol.state
+  end
+  
+  def test_connected_state_raises_not_initialized_when_protocol_is_not_set
+    connected_state = ConnectedState.new
+    
+    assert_raise NotInitializedError do
+      connected_state.serve(@server_stream)
+    end
+  end
+  
+  def test_read_mail_state_reads_until_a_single_dot_is_found_on_a_line_then_returns_an_ok_message
+    @client_stream.puts "To: junk@junk.com\nFrom: junk2@junk2.com\n\nHi\n.\n"
+    read_mail_state = ReadMailState.new(@protocol)
+    
+    read_mail_state.serve(@server_stream)
+    
+    assert_equal "250 ok\n", @client_stream.readline
+  end
+  
+  def test_read_mail_state_passes_read_message_to_protocol
+    message = "To: junk@junk.com\nFrom: junk2@junk2.com\n\nHi\n"
+    @client_stream.puts "#{message}.\n"
+    read_mail_state = ReadMailState.new(@protocol)
+    
+    read_mail_state.serve(@server_stream)
+    
+    assert_equal message, @protocol.new_message
+  end
+  
+  def test_read_mail_state_passes_protocol_quit_as_the_next_state_when_mail_message_is_read
+    @client_stream.puts "To: junk@junk.com\nFrom: junk2@junk2.com\n\nHi\n.\n"
+    read_mail_state = ReadMailState.new(@protocol)
+    
+    read_mail_state.serve(@server_stream)
+    
+    assert_equal :quit, @protocol.state
+  end
+  
+  def test_read_mail_state_raises_not_initialized_when_protocol_is_not_set
+    read_mail_state = ReadMailState.new
+    
+    assert_raise NotInitializedError do
+      read_mail_state.serve(@server_stream)
+    end
+  end
+  
+  def test_quit_state_reads_client_quit_and_says_goodbye
+    @client_stream.puts "QUIT"
+    quit_state = QuitState.new(@protocol)
+    
+    quit_state.serve(@server_stream)
+    
+    assert_equal "221 ruby goodbye\n", @client_stream.readline
+  end
+  
+  def test_quit_state_raises_not_initialized_when_protocol_is_not_set
+    quit_state = QuitState.new
+    
+    assert_raise NotInitializedError do
+      quit_state.serve(@server_stream)
+    end
+  end
+  
+end
+
+class TestProtocol
+  attr_accessor :state, :io
+  attr_reader :new_message
+  
+  def serve (io)
+    @io = io
+  end
+  
+  def new_message_received(message)
+    @new_message = message
+  end
+end

data/vendor/tmail.rb

@@ -0,0 +1,4 @@
+require 'tmail/info'
+require 'tmail/mail'
+require 'tmail/mailbox'
+require 'tmail/obsolete'

data/vendor/tmail/.cvsignore

@@ -0,0 +1,3 @@
+parser.rb
+output.parser
+stringio.rb

data/vendor/tmail/Makefile

@@ -0,0 +1,19 @@
+#
+# lib/tmail/Makefile
+#
+
+debug:
+	rm -f parser.rb
+	make parser.rb DEBUG=true
+
+parser.rb: parser.y
+	if [ "$(DEBUG)" = true ]; then \
+	    racc -v -g -o$@ parser.y ;\
+	else \
+	    racc -E -o$@ parser.y ;\
+	fi
+
+clean:
+	rm -f parser.rb parser.output
+
+distclean: clean

data/vendor/tmail/address.rb

@@ -0,0 +1,222 @@
+#
+# address.rb
+#
+# Copyright (c) 1998-2004 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU Lesser General Public License version 2.1.
+#
+
+require 'tmail/encode'
+require 'tmail/parser'
+
+module TMail
+
+  class Address
+
+    include TextUtils
+
+    def Address.parse(str)
+      Parser.parse :ADDRESS, str
+    end
+
+    def address_group?
+      false
+    end
+
+    def initialize(local, domain)
+      if domain
+        domain.each do |s|
+          raise SyntaxError, 'empty word in domain' if s.empty?
+        end
+      end
+      @local = local
+      @domain = domain
+      @name   = nil
+      @routes = []
+    end
+
+    attr_reader :name
+
+    def name=(str)
+      @name = str
+      @name = nil if str and str.empty?
+    end
+
+    alias phrase  name
+    alias phrase= name=
+
+    attr_reader :routes
+
+    def inspect
+      "#<#{self.class} #{address()}>"
+    end
+
+    def local
+      return nil unless @local
+      return '""' if @local.size == 1 and @local[0].empty?
+      @local.map {|i| quote_atom(i) }.join('.')
+    end
+
+    def domain
+      return nil unless @domain
+      join_domain(@domain)
+    end
+
+    def spec
+      s = self.local
+      d = self.domain
+      if s and d
+        s + '@' + d
+      else
+        s
+      end
+    end
+
+    alias address  spec
+
+
+    def ==(other)
+      other.respond_to? :spec and self.spec == other.spec
+    end
+
+    alias eql? ==
+
+    def hash
+      @local.hash ^ @domain.hash
+    end
+
+    def dup
+      obj = self.class.new(@local.dup, @domain.dup)
+      obj.name = @name.dup if @name
+      obj.routes.replace @routes
+      obj
+    end
+
+    include StrategyInterface
+
+    def accept(strategy, dummy1 = nil, dummy2 = nil)
+      unless @local
+        strategy.meta '<>'   # empty return-path
+        return
+      end
+
+      spec_p = (not @name and @routes.empty?)
+      if @name
+        strategy.phrase @name
+        strategy.space
+      end
+      tmp = spec_p ? '' : '<'
+      unless @routes.empty?
+        tmp << @routes.map {|i| '@' + i }.join(',') << ':'
+      end
+      tmp << self.spec
+      tmp << '>' unless spec_p
+      strategy.meta tmp
+      strategy.lwsp ''
+    end
+
+  end
+
+
+  class AddressGroup
+
+    include Enumerable
+
+    def address_group?
+      true
+    end
+
+    def initialize(name, addrs)
+      @name = name
+      @addresses = addrs
+    end
+
+    attr_reader :name
+    
+    def ==(other)
+      other.respond_to? :to_a and @addresses == other.to_a
+    end
+
+    alias eql? ==
+
+    def hash
+      map {|i| i.hash }.hash
+    end
+
+    def [](idx)
+      @addresses[idx]
+    end
+
+    def size
+      @addresses.size
+    end
+
+    def empty?
+      @addresses.empty?
+    end
+
+    def each(&block)
+      @addresses.each(&block)
+    end
+
+    def to_a
+      @addresses.dup
+    end
+
+    alias to_ary to_a
+
+    def include?(a)
+      @addresses.include? a
+    end
+
+    def flatten
+      set = []
+      @addresses.each do |a|
+        if a.respond_to? :flatten
+          set.concat a.flatten
+        else
+          set.push a
+        end
+      end
+      set
+    end
+
+    def each_address(&block)
+      flatten.each(&block)
+    end
+
+    def add(a)
+      @addresses.push a
+    end
+
+    alias push add
+    
+    def delete(a)
+      @addresses.delete a
+    end
+
+    include StrategyInterface
+
+    def accept(strategy, dummy1 = nil, dummy2 = nil)
+      strategy.phrase @name
+      strategy.meta ':'
+      strategy.space
+      first = true
+      each do |mbox|
+        if first
+          first = false
+        else
+          strategy.meta ','
+        end
+        strategy.space
+        mbox.accept strategy
+      end
+      strategy.meta ';'
+      strategy.lwsp ''
+    end
+
+  end
+
+end   # module TMail