ruby-aws 1.6.0

data/test/unit/test_exceptions.rb

@@ -0,0 +1,32 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'test/unit/testcase'
+require 'amazon/webservices/util/unknown_result_exception'
+require 'amazon/webservices/util/validation_exception'
+
+class TestExceptions < Test::Unit::TestCase
+  include Amazon::WebServices::Util
+
+  def testUnknownString
+    @methodName = :Method17
+    ex = UnknownResultException.new( RuntimeError.new('superRuntimeError'), @methodName, nil )
+
+    assert_equal "UnknownResultException: got superRuntimeError calling Method17", ex.to_s
+  end
+
+  def testValidationString
+    @result = { :OperationRequest => {:RequestId=>"aa718afb-a1f2-4812-9962-4058c20d75a8"},
+                :HIT => { :Request => { :IsValid=>"False", 
+                                        :Errors => { :Error => { :Message => "your xml broke", 
+                                                                 :Code    => "AWS.MechanicalTurk.XMLParseError"}
+                                                   }
+                                      }
+                        }
+              }
+    ex = ValidationException.new( @result )
+
+    assert_equal "ValidationException: AWS.MechanicalTurk.XMLParseError", ex.to_s
+  end
+
+end

data/test/unit/test_hash_nesting.rb

@@ -0,0 +1,99 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'test/unit/testcase'
+require 'amazon/util/hash_nesting'
+
+class TestHashNesting < Test::Unit::TestCase
+  include Amazon::Util
+
+  def setup
+    @hash = {}.extend HashNesting
+    @nested = { 'a' => 'b', 'c.d' => 'e', 'c.f' => 'g', 'h.1.i' => 'j', 'h.2.k' => 'l' }.extend HashNesting
+    @unnested = { :a => 'b', :c => { :d => 'e', :f => 'g' }, :h => [ {:i => 'j'}, {:k => 'l'} ] }.extend HashNesting
+  end
+
+  def testSimpleNest
+    @hash[:a] = 'b'
+    @hash[:p] = { :q => 'r', :s => 't' }
+    @hash[:x] = [{:y => 'z'}, {:y => 'w'}]
+    nest = @hash.nest
+    assert_equal 'b', nest['a']
+    assert_equal 'r', nest['p.q']
+    assert_equal 't', nest['p.s']
+    assert_equal 'z', nest['x.1.y']
+    assert_equal 'w', nest['x.2.y']
+    assert_equal [], %w( a p.q p.s x.1.y x.2.y) - nest.keys
+    assert_equal [], nest.keys - %w( a p.q p.s x.1.y x.2.y)
+  end
+
+  def testSimpleUnnest
+    @hash['a'] = 'b'
+    @hash['p.q'] = 'r'
+    @hash['x.1.w'] = 'q'
+    @hash['x.2.w'] = 'z'
+    unnest = @hash.unnest
+    assert_equal 'b', unnest[:a]
+    assert_equal 'r', unnest[:p][:q]
+    assert_equal 'q', unnest[:x][0][:w]
+    assert_equal 'z', unnest[:x][1][:w]
+  end
+
+  def testMutability
+    cpy = @unnested.dup
+
+    unnest = @unnested.unnest
+    assert_equal cpy, @unnested
+    assert_not_nil unnest
+    unnest[:q] = 'p'
+    assert_equal cpy, @unnested
+
+    nest = @unnested.nest
+    assert_equal cpy, @unnested
+    assert_not_nil nest
+    nest['q'] = 'p'
+    assert_equal cpy, @unnested
+
+    @unnested.nest!
+    assert_equal @nested, @unnested
+    @unnested.unnest!
+    assert_equal cpy, @unnested
+
+    @unnested.nest!.unnest!
+    assert_equal cpy, @unnested
+
+    assert_equal cpy, @unnested.unnest!
+
+    cpy = @nested.dup
+
+    @nested.unnest!.nest!
+    assert_equal cpy, @nested
+
+    assert_equal cpy, @nested.nest!
+  end
+
+  def testChaining
+    assert_equal @unnested, @nested.unnest.unnest!.unnest
+    assert_equal @nested, @unnested.nest.nest!.nest
+    assert_equal @nested, @nested.unnest.unnest!.nest!.nest
+    assert_equal @unnested, @unnested.nest.nest!.unnest!.unnest
+  end
+
+  def testPrecedence
+    @hash['a'] = 'b'
+    @hash[:a] = 'c'
+    @hash[:z] = 'x'
+    @hash['z'] = 'y'
+
+    assert_equal 'c', @hash.nest['a']
+    assert_equal 'c', @hash.unnest[:a]
+    assert_equal 'x', @hash.nest['z']
+    assert_equal 'x', @hash.unnest[:z]
+
+    @hash['a'] = 'd'
+
+    assert_equal 'c', @hash.nest['a']
+    assert_equal 'c', @hash.unnest[:a]
+  end
+
+end

data/test/unit/test_lazy_results.rb

@@ -0,0 +1,89 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'test/unit/testcase'
+require 'amazon/util/lazy_results'
+
+class TestLazyResults < Test::Unit::TestCase
+  include Amazon::Util
+
+  def setup
+    @call_count = 0
+    @simple_pagesize = 2
+    @simple_data_size = 6
+    @simple_data = [ [1,2],[3,4],[5,6] ]
+    @simple_lazy = LazyResults.new {|page| @call_count += 1 ; @simple_data[ page-1 ] }
+  end
+
+  def testBasic
+    assert_equal 0, @call_count
+    assert_equal @simple_data.flatten, @simple_lazy.to_a
+    assert_equal 4, @call_count
+    assert_equal @simple_data.flatten, @simple_lazy.to_a
+    assert_equal 4, @call_count
+    assert_equal Array, @simple_lazy.to_a.class
+  end
+
+  def testEnumerable
+    result = @simple_lazy.collect
+    assert_equal @simple_data.flatten, result.to_a
+    assert_equal 4, @call_count
+    result = @simple_lazy.collect
+    assert_equal @simple_data.flatten, result.to_a
+    assert_equal 4, @call_count
+    minus1 = @simple_lazy.collect {|i| i-1}
+    minus1.each_with_index {|i,n| assert_equal i, n }
+    evenodd = @simple_lazy.inject({:even => [],:odd => []}) {|a,num| a[ num % 2 == 0 ? :even : :odd ] << num ; a }
+    expected = {:even => [2,4,6], :odd => [1,3,5] } 
+    assert_equal expected, evenodd
+  end
+
+  def testIncremental
+    count = 0
+    @simple_lazy.each { |value|
+      assert_equal count+1, value 
+      assert_equal( (count / @simple_pagesize)+1, @call_count )
+      count += 1
+    }
+    assert_equal 4, @call_count
+  end
+
+  def testRandomAccess
+    assert_equal 4, @simple_lazy[3]
+    assert_equal 2, @call_count
+    assert_nil @simple_lazy[@simple_data_size]
+    assert_equal 4, @call_count
+    10.times do
+      index = rand(@simple_data_size+@simple_pagesize)
+      assert_equal( ( index >= @simple_data_size ? nil : index+1 ), @simple_lazy[index] )
+    end
+    assert_equal 4, @call_count
+    assert_equal @simple_data.flatten, @simple_lazy.to_a
+  end
+
+  def testFlush
+    @simple_lazy.to_a
+    @simple_lazy.to_a
+    assert_equal 4, @call_count
+    @simple_lazy.flush
+    @simple_lazy.to_a
+    assert_equal 8, @call_count
+  end
+
+  def testError
+    @picky_message = "picky picky picky"
+    @picky_lazy = LazyResults.new {|page| @call_count += 1 ; if page < 3 ; @simple_data[ page-1 ] ; else ; raise @picky_message ; end }
+    assert_equal 4, @picky_lazy[3]
+    e = assert_raises( RuntimeError ) { @picky_lazy[4] }
+    assert_equal @picky_message, e.message
+  end
+
+  def testImmutability
+    assert_equal 3, @simple_lazy[2]
+    a = @simple_lazy.to_a
+    assert_equal 3, a[2]
+    a[2] = 7
+    assert_equal 3, @simple_lazy[2]
+  end
+
+end

data/test/unit/test_mock_transport.rb

@@ -0,0 +1,132 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'test/unit/testcase'
+require 'amazon/webservices/util/mock_transport'
+
+class TestMockTransport < Test::Unit::TestCase
+  include Amazon::WebServices::Util
+
+  SAMPLE_REQUEST = { :speed => :slow }
+  SAMPLE_ARGS = { :Auth => :fake, :Request => [SAMPLE_REQUEST] }
+
+  def setup
+    @mock = MockTransport.new
+  end
+
+  def testBasic
+    result = @mock.dance SAMPLE_ARGS
+
+    assert result[:OperationRequest]
+    assert result[:MockResult]
+    assert_equal SAMPLE_REQUEST, result[:MockResult][:Request]
+
+    request = @mock.call_buffer[0]
+    assert request
+    assert request.args
+    assert request.request
+    assert_equal :dance, request.name
+    assert_equal SAMPLE_ARGS, request.args
+    assert_equal SAMPLE_REQUEST, request.request
+  end
+
+  def testListener
+    @a = []
+    log_listener = proc { |call| @a << call }
+
+    mock = MockTransport.new :MockListener => log_listener
+    mock.dance SAMPLE_ARGS
+
+    assert_equal 1, @a.size
+    assert_equal SAMPLE_REQUEST, @a.first.request
+  end
+
+  def testListenerInjection
+    injection_listener = proc {|call| {:Param => :Injected } }
+
+    mock = MockTransport.new :MockListener => injection_listener
+    result = mock.dance SAMPLE_ARGS
+
+    assert_equal :Injected, result[:Param], "Should have injected our parameter"
+    assert result[:MockResult], "Injection should not have precluded MockResult"
+  end
+
+  def testMockReply
+    result = @mock.dance SAMPLE_ARGS
+    @mock.mock_reply = {:Bogus => :Fun}
+    result2 = @mock.dance SAMPLE_ARGS
+
+    assert result[:MockResult]
+    assert_nil result2[:MockResult]
+
+    assert_nil result[:Bogus]
+    assert result2[:Bogus]
+  end
+
+  def testEnumerable
+
+    # should start out with empty buffer
+    calls = @mock.collect { |call| call.name }
+    assert_equal [], calls
+
+    # now generate 3 calls
+    @mock.dance SAMPLE_ARGS
+    @mock.fall SAMPLE_ARGS
+    @mock.sing SAMPLE_ARGS
+
+    # ensure we got all 3 args in proper order
+    calls = @mock.collect { |call| call.name }
+    assert_equal [:dance,:fall,:sing], calls
+
+    # should be repeatable
+    calls = @mock.collect { |call| call.name }
+    assert_equal [:dance,:fall,:sing], calls
+
+    # now flush the buffer and ensure it's empty again
+    @mock.flush
+    calls = @mock.collect { |call| call.name }
+    assert_equal [], calls
+  end
+
+  def testNext
+
+    # should start out with empty buffer
+    assert_nil @mock.next
+
+    # make a call
+    @mock.dance SAMPLE_ARGS
+
+    # call shows up with #next
+    n = @mock.next
+    assert_equal :dance, n.name
+
+    # should only have been one call in the buffer
+    assert_nil @mock.next
+
+    # two more calls
+    @mock.fall SAMPLE_ARGS
+    @mock.sing SAMPLE_ARGS
+
+    # ensure we get them in proper order
+    assert_equal :fall, @mock.next.name
+    assert_equal :sing, @mock.next.name
+
+    # and we should have no more
+    assert_nil @mock.next
+
+    # after flushing, we should still have none
+    @mock.flush
+    assert_nil @mock.next
+
+    # add one more call
+    @mock.smile SAMPLE_ARGS
+
+    # we should have just one queued up now
+    assert_equal :smile, @mock.next.name
+    assert_nil @mock.next
+
+  end
+
+end
+
+

data/test/unit/test_paginated_iterator.rb

@@ -0,0 +1,58 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'test/unit/testcase'
+require 'amazon/util/paginated_iterator'
+
+class TestPaginatedIterator < Test::Unit::TestCase
+  include Amazon::Util
+
+  def setup
+    @call_count = 0
+    @simple_pagesize = 2
+    @simple_data_size = 6
+    @simple_data = [ [1,2],[3,4],[5,6] ]
+    @simple_iter = PaginatedIterator.new {|page| @call_count += 1 ; @simple_data[ page-1 ] }
+  end
+
+  def testNext
+    assert_equal 0, @call_count
+    @simple_data.flatten.each do |i|
+      assert_equal i, @simple_iter.next
+    end
+    assert_equal 3, @call_count
+    assert !@simple_iter.done
+    assert_nil @simple_iter.next
+    assert_equal 4, @call_count
+    assert @simple_iter.done
+  end
+
+  def testRestart
+    assert_equal 0, @call_count
+    @simple_iter.next until @simple_iter.done
+    assert_equal 4, @call_count
+    @simple_iter.restart
+    assert !@simple_iter.done
+    @simple_iter.next until @simple_iter.done
+    assert_equal 8, @call_count
+  end
+
+  def testEach
+    res = []
+    @simple_iter.each {|i| res << i }
+    assert_equal @simple_data.flatten, res
+    assert_equal 4, @call_count
+    assert @simple_iter.done
+    @simple_iter.each {|i| fail }
+  end
+
+  def testError
+    @picky_message = "picky picky picky"
+    @picky_iter = PaginatedIterator.new {|page| @call_count += 1 ; if page < 3 ; @simple_data[ page-1 ] ; else ; raise @picky_message ; end }
+    3.times { @picky_iter.next }
+    assert_equal 4, @picky_iter.next
+    e = assert_raises( RuntimeError ) { @picky_iter.next }
+    assert_equal @picky_message, e.message
+  end
+
+end

data/test/unit/test_proactive_results.rb

@@ -0,0 +1,108 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'test/unit/testcase'
+require 'amazon/util/proactive_results'
+
+class TestProactiveResults < Test::Unit::TestCase
+  include Amazon::Util
+
+  def setup
+    @call_count = 0
+    @exception_count = 0
+    @simple_pagesize = 2
+    @simple_data_size = 6
+    @simple_data = [ [1,2],[3,4],[5,6] ]
+    @simple_proactive = ProactiveResults.new {|page| @call_count += 1 ; @simple_data[ page-1 ] }
+  end
+
+  def testBasic
+    assert @call_count >= 0
+    assert_equal @simple_data.flatten, @simple_proactive.to_a
+    assert_equal 6, @call_count
+    assert_equal @simple_data.flatten, @simple_proactive.to_a
+    assert_equal 6, @call_count
+    assert_equal Array, @simple_proactive.to_a.class
+  end
+
+  def testEnumerable
+    result = @simple_proactive.collect
+    assert_equal @simple_data.flatten, result.to_a
+    assert_equal 6, @call_count
+    result = @simple_proactive.collect
+    assert_equal @simple_data.flatten, result.to_a
+    assert_equal 6, @call_count
+    minus1 = @simple_proactive.collect {|i| i-1}
+    minus1.each_with_index {|i,n| assert_equal i, n }
+    evenodd = @simple_proactive.inject({:even => [],:odd => []}) {|a,num| a[ num % 2 == 0 ? :even : :odd ] << num ; a }
+    expected = {:even => [2,4,6], :odd => [1,3,5] } 
+    assert_equal expected, evenodd
+  end
+
+  def testIncremental
+    count = 0
+    remaining = @simple_data.flatten
+    @simple_proactive.each { |value|
+      assert_not_nil value
+      assert_not_nil remaining.delete( value )
+      assert @call_count >= (count / @simple_pagesize)+1
+      count += 1
+    }
+    assert_equal 6, count
+    assert_equal 6, @call_count
+  end
+
+  def testRandomAccess
+    assert [2,4,6].member?( @simple_proactive[3] )
+    assert @call_count >= 2
+    assert_nil @simple_proactive[@simple_data_size]
+    assert_equal 6, @call_count
+    10.times do
+      index = rand(@simple_data_size+@simple_pagesize)
+      if index >= @simple_data_size
+        assert_nil @simple_proactive[index]
+      else
+        if index % 2 == 0
+          assert [1,3,5].member?( @simple_proactive[index] )
+        else
+          assert [2,4,6].member?( @simple_proactive[index] )
+        end
+      end
+    end
+    assert_equal 6, @call_count
+    assert_equal @simple_data.flatten, @simple_proactive.to_a.sort
+  end
+
+  def testFlush
+    @simple_proactive.to_a
+    @simple_proactive.to_a
+    assert_equal 6, @call_count
+    @simple_proactive.flush
+    @simple_proactive.to_a
+    assert_equal 12, @call_count
+  end
+
+  def testError
+    @picky_message = "picky picky picky"
+    exception_count = 0
+    @picky_proactive = ProactiveResults.new(Proc.new {|i| exception_count += 1 }) do |page| 
+      @call_count += 1
+      if page < 3
+        @simple_data[ page-1 ]
+      else
+        raise @picky_message
+      end
+    end
+    assert_equal @simple_data.flatten[0..3], @picky_proactive.to_a
+    assert_equal 3, exception_count
+  end
+
+  def testImmutability
+    assert_equal 3, @simple_proactive[2]
+    a = @simple_proactive.to_a
+    assert_equal 3, a[2]
+    a[2] = 7
+    assert_equal 3, @simple_proactive[2]
+  end
+
+end