aws-ses-v4 0.8.1

data/test/base_test.rb

@@ -0,0 +1,104 @@
+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
+
+  def test_ses_authorization_header_v2
+    aws_access_key_id = 'fake_aws_key_id'
+    aws_secret_access_key = 'fake_aws_access_key'
+    time = Time.new(2021, 4, 8, 14, 07, 58, '+00:00')
+    ::Timecop.freeze(time)
+    base = ::AWS::SES::Base.new(
+        access_key_id:     aws_access_key_id,
+        secret_access_key: aws_secret_access_key,
+        signature_version: 2
+    )
+
+    assert_equal 'AWS3-HTTPS AWSAccessKeyId=fake_aws_key_id, Algorithm=HmacSHA256, Signature=Yi984ReKUv7ckcrwvsBgzLlQX/1kyva74+SF+PlrwZ0=', base.get_aws_auth_header_v2
+    Timecop.return
+  end
+
+  def test_ses_authorization_header_v4
+    aws_access_key_id = 'fake_aws_key_id'
+    aws_secret_access_key = 'fake_aws_access_key'
+    time = Time.new(2020, 7, 2, 7, 17, 58, '+00:00')
+    ::Timecop.freeze(time)
+
+    base = ::AWS::SES::Base.new(
+        server:            'ec2.amazonaws.com',
+        access_key_id:     aws_access_key_id,
+        secret_access_key: aws_secret_access_key
+    )
+
+    assert_equal 'AWS4-HMAC-SHA256 Credential=fake_aws_key_id/20200702/us-east-1/ses/aws4_request, SignedHeaders=host;x-amz-date, Signature=fb25a4a91c6f5c17637c81744998ac664d16ce70982c5ca92c0a62199ef4e7d6', base.get_aws_auth_header_v4
+    Timecop.return
+  end
+
+  def test_ses_authorization_header_v4_changed_host
+    aws_access_key_id = 'fake_aws_key_id'
+    aws_secret_access_key = 'fake_aws_access_key'
+    time = Time.new(2020, 7, 2, 7, 17, 58, '+00:00')
+    ::Timecop.freeze(time)
+
+    base = ::AWS::SES::Base.new(
+        server:            'email.us-east-1.amazonaws.com',
+        access_key_id:     aws_access_key_id,
+        secret_access_key: aws_secret_access_key
+    )
+
+    assert_equal 'AWS4-HMAC-SHA256 Credential=fake_aws_key_id/20200702/us-east-1/ses/aws4_request, SignedHeaders=host;x-amz-date, Signature=c77a9d002342ac5b210c8f4a054712f9e00335ce9555c359ea8982acfa32db4c', base.get_aws_auth_header_v4
+    Timecop.return
+  end
+
+  def test_ses_authorization_header_v4_changed_region
+    aws_access_key_id = 'fake_aws_key_id'
+    aws_secret_access_key = 'fake_aws_access_key'
+    time = Time.new(2020, 7, 2, 7, 17, 58, '+00:00')
+    ::Timecop.freeze(time)
+
+    base = ::AWS::SES::Base.new(
+        server:            'email.us-east-1.amazonaws.com',
+        access_key_id:     aws_access_key_id,
+        secret_access_key: aws_secret_access_key,
+        region:            'eu-west-1'
+    )
+
+    assert_not_equal 'AWS4-HMAC-SHA256 Credential=fake_aws_key_id/20200702/us-east-1/ec2/aws4_request, SignedHeaders=host;x-amz-date, Signature=b872601457070ab98e7038bdcd4dc1f5eab586ececf9908525474408b0740515', base.get_aws_auth_header_v4
+    Timecop.return
+  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,63 @@
+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'
+require 'timecop'
+
+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
+
+# Deals w/ http://github.com/thoughtbot/shoulda/issues/issue/117, see 
+# http://stackoverflow.com/questions/3657972/nameerror-uninitialized-constant-testunitassertionfailederror-when-upgradin
+unless defined?(Test::Unit::AssertionFailedError)
+  Test::Unit::AssertionFailedError = ActiveSupport::TestCase::Assertion
+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