aws-ses-rails31 0.4.3

data/test/address_test.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../helper', __FILE__)
+
+class AddressTest < Test::Unit::TestCase
+  context 'verifying an address' do
+    setup do
+      @base = generate_base
+    end
+
+    should 'return the correct response on success' do
+      mock_connection(@base, :body => %{
+        <VerifyEmailAddressResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <ResponseMetadata>
+            <RequestId>abc-123</RequestId>
+          </ResponseMetadata>
+        </VerifyEmailAddressResponse>
+      })
+      
+      result = @base.addresses.verify('user1@example.com')
+      assert result.success?
+      assert_equal 'abc-123', result.request_id
+    end  
+  end
+
+  context 'listing verified addressess' do 
+    setup do
+      @base = generate_base
+    end
+    
+    should 'return the correct response on success' do   
+      mock_connection(@base, :body => %{
+        <ListVerifiedEmailAddressesResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <ListVerifiedEmailAddressesResult>
+            <VerifiedEmailAddresses>
+              <member>user1@example.com</member>
+            </VerifiedEmailAddresses>
+          </ListVerifiedEmailAddressesResult>
+          <ResponseMetadata>
+            <RequestId>abc-123</RequestId>
+          </ResponseMetadata>
+        </ListVerifiedEmailAddressesResponse>
+      })
+      
+      result = @base.addresses.list
+
+      assert result.success?
+      assert_equal 'abc-123', result.request_id
+      assert_equal %w{user1@example.com}, result.result
+    end
+  end
+
+
+  context 'deleting a verified addressess' do 
+    setup do
+      @base = generate_base
+    end
+    
+    should 'return the correct response on success' do   
+      mock_connection(@base, :body => %{
+        <DeleteVerifiedEmailAddressResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <ResponseMetadata>
+            <RequestId>abc-123</RequestId>
+          </ResponseMetadata>
+        </DeleteVerifiedEmailAddressResponse>
+      })
+      
+      result = @base.addresses.delete('user1@example.com')
+
+      assert result.success?
+      assert_equal 'abc-123', result.request_id
+    end
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../helper', __FILE__)
+
+class BaseTest < Test::Unit::TestCase  
+  def test_connection_established    
+    instance = Base.new(:access_key_id => '123', :secret_access_key => 'abc')
+
+    assert_not_nil instance.instance_variable_get("@http")
+  end
+  
+  def test_failed_response
+    @base = generate_base
+    mock_connection(@base, {:code => 403, :body => %{
+      <ErrorResponse>
+         <Error>
+            <Type>
+               Sender
+            </Type>
+            <Code>
+               ValidationError
+            </Code>
+            <Message>
+               Value null at 'message.subject' failed to satisfy constraint: Member must not be null
+            </Message>
+         </Error>
+         <RequestId>
+            42d59b56-7407-4c4a-be0f-4c88daeea257
+         </RequestId>
+      </ErrorResponse>
+    }})
+    
+    assert_raises ResponseError do
+      result = @base.request('', {})
+    end
+    
+    # assert !result.success?
+    #     assert result.error?
+    #     assert result.error.error?
+    #     assert_equal 'ValidationError', result.error.code
+  end
+end

data/test/extensions_test.rb

@@ -0,0 +1,111 @@
+require File.expand_path('../helper', __FILE__)
+
+class KerneltExtensionsTest < Test::Unit::TestCase
+  class Foo
+    def foo
+      __method__
+    end
+
+    def bar
+      foo
+    end
+
+    def baz
+      bar
+    end
+  end
+  
+  class Bar
+    def foo
+      calling_method
+    end
+    
+    def bar
+      calling_method
+    end
+    
+    def calling_method
+      __method__(1)
+    end
+  end
+    
+  def test___method___works_regardless_of_nesting
+    f = Foo.new
+    [:foo, :bar, :baz].each do |method|
+      assert_equal 'foo', f.send(method)
+    end
+  end
+  
+  def test___method___depth
+    b = Bar.new
+    assert_equal 'foo', b.foo
+    assert_equal 'bar', b.bar
+  end
+end if RUBY_VERSION <= '1.8.7'
+
+class ModuleExtensionsTest < Test::Unit::TestCase
+  class Foo
+    def foo(reload = false)
+      expirable_memoize(reload) do
+        Time.now
+      end
+    end
+    
+    def bar(reload = false)
+      expirable_memoize(reload, :baz) do
+        Time.now
+      end
+    end
+    
+    def quux
+      Time.now
+    end
+    memoized :quux
+  end
+  
+  def setup
+    @instance = Foo.new
+  end
+  
+  def test_memoize
+    assert !instance_variables_of(@instance).include?('@foo')
+    cached_result = @instance.foo
+    assert_equal cached_result, @instance.foo
+    assert instance_variables_of(@instance).include?('@foo')
+    assert_equal cached_result, @instance.send(:instance_variable_get, :@foo)
+    assert_not_equal cached_result, new_cache = @instance.foo(:reload)
+    assert_equal new_cache, @instance.foo
+    assert_equal new_cache, @instance.send(:instance_variable_get, :@foo)
+  end
+  
+  def test_customizing_memoize_storage
+    assert !instance_variables_of(@instance).include?('@bar')
+    assert !instance_variables_of(@instance).include?('@baz')
+    cached_result = @instance.bar
+    assert !instance_variables_of(@instance).include?('@bar')
+    assert instance_variables_of(@instance).include?('@baz')
+    assert_equal cached_result, @instance.bar
+    assert_equal cached_result, @instance.send(:instance_variable_get, :@baz)
+    assert_nil @instance.send(:instance_variable_get, :@bar)
+  end
+  
+  def test_memoized
+    assert !instance_variables_of(@instance).include?('@quux')
+    cached_result = @instance.quux
+    assert_equal cached_result, @instance.quux
+    assert instance_variables_of(@instance).include?('@quux')
+    assert_equal cached_result, @instance.send(:instance_variable_get, :@quux)
+    assert_not_equal cached_result, new_cache = @instance.quux(:reload)
+    assert_equal new_cache, @instance.quux
+    assert_equal new_cache, @instance.send(:instance_variable_get, :@quux)
+  end
+  
+  private
+    # For 1.9 compatibility
+    def instance_variables_of(object)
+      object.instance_variables.map do |instance_variable|
+        instance_variable.to_s
+      end
+    end
+      
+end

data/test/fixtures.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+
+module AWS
+  module SES
+    # When this file is loaded, for each fixture file, a module is created within the Fixtures module
+    # with the same name as the fixture file. For each fixture in that fixture file, a singleton method is 
+    # added to the module with the name of the given fixture, returning the value of the fixture.
+    #
+    # For example:
+    #
+    # A fixture in <tt>buckets.yml</tt> named <tt>empty_bucket_list</tt> with value <tt><foo>hi!</foo></tt>
+    # would be made available like so:
+    #
+    #   Fixtures::Buckets.empty_bucket_list
+    #   => "<foo>hi!</foo>"
+    #   
+    # Alternatively you can treat the fixture module like a hash
+    #
+    #   Fixtures::Buckets[:empty_bucket_list]
+    #   => "<foo>hi!</foo>"
+    #
+    # You can find out all available fixtures by calling
+    #
+    #   Fixtures.fixtures
+    #   => ["Buckets"]
+    #
+    # And all the fixtures contained in a given fixture by calling
+    #
+    #   Fixtures::Buckets.fixtures
+    #   => ["bucket_list_with_more_than_one_bucket", "bucket_list_with_one_bucket", "empty_bucket_list"]
+    module Fixtures
+      class << self
+        def create_fixtures
+          files.each do |file|
+            create_fixture_for(file)
+          end
+        end
+        
+        def create_fixture_for(file)
+          fixtures       = YAML.load_file(path(file))
+          fixture_module = Module.new
+          
+          fixtures.each do |name, value|
+            fixture_module.module_eval(<<-EVAL, __FILE__, __LINE__)
+              def #{name}
+                #{value.inspect}
+              end
+              module_function :#{name}
+            EVAL
+          end
+          
+          fixture_module.module_eval(<<-EVAL, __FILE__, __LINE__)
+            module_function 
+          
+              def fixtures
+                #{fixtures.keys.sort.inspect}
+              end
+              
+              def [](name)
+                send(name) if fixtures.include?(name.to_s)
+              end
+          EVAL
+          
+          const_set(module_name(file), fixture_module)
+        end
+        
+        def fixtures
+          constants.sort
+        end
+        
+        private
+        
+          def files
+            Dir.glob(File.dirname(__FILE__) + '/fixtures/*.yml').map {|fixture| File.basename(fixture)}
+          end
+          
+          def module_name(file_name)
+            File.basename(file_name, '.*').capitalize
+          end
+          
+          def path(file_name)
+            File.join(File.dirname(__FILE__), 'fixtures', file_name)
+          end
+      end
+      
+      create_fixtures
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda-context'
+
+begin
+  require 'ruby-debug'
+rescue LoadError
+end
+
+require 'flexmock'
+require 'flexmock/test_unit'
+
+require File.dirname(__FILE__) + '/mocks/fake_response'
+require File.dirname(__FILE__) + '/fixtures'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'aws/ses'
+
+class Test::Unit::TestCase
+  require 'net/http'
+  require 'net/https'
+  
+  include AWS::SES
+  
+  def mock_connection(object, data = {})
+    return_values = case data
+    when Hash
+      FakeResponse.new(data)
+    when Array
+      data.map {|hash| FakeResponse.new(hash)}
+    else
+      abort "Response data for mock connection must be a Hash or an Array. Was #{data.inspect}."
+    end
+    
+    connection = flexmock('Net::HTTP.new') do |mock|
+      mock.should_receive(:post).and_return(*return_values).at_least.once
+    end
+
+    mock = flexmock(object)
+    mock.should_receive(:connection).and_return(connection)
+    mock
+  end
+  
+  def generate_base
+    Base.new(:access_key_id=>'123', :secret_access_key=>'abc')
+  end
+end

data/test/info_test.rb

@@ -0,0 +1,108 @@
+require File.expand_path('../helper', __FILE__)
+
+class InfoTest < Test::Unit::TestCase
+  context 'getting send quota' do
+    setup do
+      @base = generate_base
+    end
+
+    should 'return the correct response on success' do
+      mock_connection(@base, :body => %{
+        <GetSendQuotaResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <GetSendQuotaResult>
+            <SentLast24Hours>0.0</SentLast24Hours>
+            <Max24HourSend>1000.0</Max24HourSend>
+            <MaxSendRate>1.0</MaxSendRate>
+          </GetSendQuotaResult>
+          <ResponseMetadata>
+            <RequestId>abc-123</RequestId>
+          </ResponseMetadata>
+        </GetSendQuotaResponse>
+      })
+      
+      result = @base.quota
+      assert result.success?
+      assert_equal 'abc-123', result.request_id
+      assert_equal '0.0', result.sent_last_24_hours
+      assert_equal '1000.0', result.max_24_hour_send
+      assert_equal '1.0', result.max_send_rate
+    end  
+  end
+
+  context 'getting send statistics' do 
+    setup do
+      @base = generate_base
+    end
+    
+    should 'return the correct response on success' do   
+      mock_connection(@base, :body => %{
+        <GetSendStatisticsResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <GetSendStatisticsResult>
+            <SendDataPoints>
+              <member>
+                <DeliveryAttempts>3</DeliveryAttempts>
+                <Timestamp>2011-01-31T15:31:00Z</Timestamp>
+                <Rejects>2</Rejects>
+                <Bounces>4</Bounces>
+                <Complaints>1</Complaints>
+              </member>
+              <member>
+                <DeliveryAttempts>3</DeliveryAttempts>
+                <Timestamp>2011-01-31T16:01:00Z</Timestamp>
+                <Rejects>0</Rejects>
+                <Bounces>0</Bounces>
+                <Complaints>0</Complaints>
+              </member>
+              <member>
+                <DeliveryAttempts>1</DeliveryAttempts>
+                <Timestamp>2011-01-26T16:31:00Z</Timestamp>
+                <Rejects>0</Rejects>
+                <Bounces>0</Bounces>
+                <Complaints>0</Complaints>
+              </member>
+            </SendDataPoints>
+          </GetSendStatisticsResult>
+          <ResponseMetadata>
+            <RequestId>abc-123</RequestId>
+          </ResponseMetadata>
+        </GetSendStatisticsResponse>
+      })
+      
+      result = @base.statistics
+
+      assert result.success?
+      assert_equal 'abc-123', result.request_id
+      
+      assert_equal 3, result.data_points.size
+      
+      d = result.data_points.first
+      
+      assert_equal '2', d['Rejects']
+      assert_equal '3', d['DeliveryAttempts']
+      assert_equal '4', d['Bounces']
+      assert_equal '1', d['Complaints']
+    end
+  end
+
+
+  context 'deleting a verified addressess' do 
+    setup do
+      @base = generate_base
+    end
+    
+    should 'return the correct response on success' do   
+      mock_connection(@base, :body => %{
+        <DeleteVerifiedEmailAddressResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <ResponseMetadata>
+            <RequestId>abc-123</RequestId>
+          </ResponseMetadata>
+        </DeleteVerifiedEmailAddressResponse>
+      })
+      
+      result = @base.addresses.delete('user1@example.com')
+
+      assert result.success?
+      assert_equal 'abc-123', result.request_id
+    end
+  end
+end

data/test/mocks/fake_response.rb

@@ -0,0 +1,26 @@
+module AWS
+  module SES
+    class FakeResponse
+      attr_reader :code, :body, :headers
+      def initialize(options = {})
+        @code    = options.delete(:code)  || 200 
+        @body    = options.delete(:body)  || ''
+        @headers = {'content-type' => 'application/xml'}.merge(options.delete(:headers) || {})
+      end
+
+      # For ErrorResponse
+      def response
+        body
+      end
+      
+      def [](header)
+        headers[header]
+      end
+      
+      def each(&block)
+        headers.each(&block)
+      end
+      alias_method :each_header, :each
+    end
+  end
+end

data/test/response_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../helper', __FILE__)
+
+class BaseResponseTest < Test::Unit::TestCase 
+  def setup
+    @headers       = {'content-type' => 'text/plain', 'date' => Time.now}
+    @response      = FakeResponse.new()
+    @base_response = Response.new('ResponseAction', @response)
+  end
+  
+  def test_status_predicates
+    response = Proc.new {|code| Response.new('ResponseAction', FakeResponse.new(:code => code))}
+    assert response[200].success?
+    assert response[300].redirect?
+    assert response[400].client_error?
+    assert response[500].server_error?
+  end
+  
+  def test_headers_passed_along_from_original_response
+    assert_equal @response.headers, @base_response.headers
+    assert_equal @response['date'], @base_response['date']
+    original_headers, new_headers = {}, {}
+    @response.headers.each {|k,v| original_headers[k] = v}
+    @base_response.each {|k,v| new_headers[k] = v}
+    assert_equal original_headers, new_headers
+  end
+end

data/test/send_email_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../helper', __FILE__)
+
+class SendEmailTest < Test::Unit::TestCase
+  context 'when sending email' do
+    setup do
+      @base = generate_base
+      @basic_email = { :from => 'jon@example.com', 
+                        :to   => 'dave@example.com',
+                        :subject => 'Subject1', 
+                        :text_body => 'Body1' }
+    end
+    
+    context 'adding to a hash' do
+      should 'add array elements to the hash' do
+        hash = {}
+        ary  = ['x', 'y']
+        @base.send(:add_array_to_hash!, hash, 'SomeKey', ary)
+        expected = {'SomeKey.member.1' => 'x', 'SomeKey.member.2' => 'y'}
+        assert_equal expected, hash
+      end
+      
+      should 'add singular elements to the hash' do
+        hash = {}
+        ary  = 'z'
+        @base.send(:add_array_to_hash!, hash, 'SomeKey', ary)
+        expected = {'SomeKey.member.1' => 'z'}
+        assert_equal expected, hash
+      end
+    end
+    
+    should 'send an e-mail' do
+      mock_connection(@base, :body => %{
+        <SendEmailResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <SendEmailResult>
+            <MessageId>abc-123</MessageId>
+          </SendEmailResult>
+          <ResponseMetadata>
+            <RequestId>xyz-123</RequestId>
+          </ResponseMetadata>
+        </SendEmailResponse>
+      })
+      
+      result = @base.send_email @basic_email
+      assert result.success?
+      assert_equal 'abc-123', result.message_id
+      assert_equal 'xyz-123', result.request_id
+    end
+    
+    should 'send a raw e-mail with a hash object' do
+      mock_connection(@base, :body => %{
+        <SendRawEmailResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">
+          <SendRawEmailResult>
+            <MessageId>abc-123</MessageId>
+          </SendRawEmailResult>
+          <ResponseMetadata>
+            <RequestId>xyz-123</RequestId>
+          </ResponseMetadata>
+        </SendRawEmailResponse>
+      })
+      
+      result = @base.send_raw_email(@basic_email)
+      assert result.success?
+      assert_equal 'abc-123', result.message_id
+      assert_equal 'xyz-123', result.request_id
+    end
+  end
+end