sprout-ruby-aws 1.2.0

data/test/test_ruby-aws.rb

@@ -0,0 +1,22 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'test/unit'
+require 'ruby-aws'
+
+class TestRubyAWS < Test::Unit::TestCase
+
+  def testVersion
+    assert( RubyAWS::VERSION =~ /^\d+\.\d+\.\d+$/ , "RubyAWS::VERSION is incorrectly formatted")
+  end
+
+  def testAgent
+    assert( RubyAWS.agent =~ /^ruby-aws\/\d+\.\d+\.\d+$/ )
+    assert( RubyAWS.agent('Tester') =~ /^ruby-aws\/\d+\.\d+\.\d+ Tester$/ )
+  end
+
+end
+

data/test/unit/test_binder.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/binder'
+                                                                                                                                                                                      
+class TestBinder < Test::Unit::TestCase
+  include Amazon::Util
+
+  SAMPLE_VARS = { :a => 'pudding', :b => 'pie', :c => 'cheesecake' }
+
+  SAMPLE_TEMPLATE = "I love <%= @b %> (especially with <%= @a %>), but I love <%= @c %> even more!"
+
+  SAMPLE_EXPECTED = "I love pie (especially with pudding), but I love cheesecake even more!"
+
+  def testConstructorConfig
+    b = Binder.new( SAMPLE_VARS )
+    result = b.erb_eval( SAMPLE_TEMPLATE )
+    assert_equal SAMPLE_EXPECTED, result
+  end
+
+  def testBuilderConfig
+    b = Binder.new { |bb| SAMPLE_VARS.each {|k,v| bb.set( k, v ) } }
+    result = b.erb_eval( SAMPLE_TEMPLATE )
+    assert_equal SAMPLE_EXPECTED, result
+  end
+
+  def testInstanceConfig
+    b = Binder.new
+    SAMPLE_VARS.each { |k,v| b.set( k, v ) }
+    result = b.erb_eval( SAMPLE_TEMPLATE )
+    assert_equal SAMPLE_EXPECTED, result
+  end
+
+  def testMergeConfig
+    b = Binder.new
+    b.merge SAMPLE_VARS
+    result = b.erb_eval( SAMPLE_TEMPLATE )
+    assert_equal SAMPLE_EXPECTED, result
+  end
+
+  def testCombinedConfig
+    keys = SAMPLE_VARS.keys
+    b = Binder.new( keys[0] => SAMPLE_VARS[ keys[0] ] ) { |bb|
+      bb.set( keys[1], SAMPLE_VARS[ keys[1] ] ) }
+    b.set( keys[2], SAMPLE_VARS[ keys[2] ] )
+    result = b.erb_eval( SAMPLE_TEMPLATE )
+    assert_equal SAMPLE_EXPECTED, result
+  end
+
+  def testConfigPrecedence
+    b = Binder.new( SAMPLE_VARS ) { |bb|
+      bb.merge( 'a' => 'rhubarb', 'c'=> 'gelato' ) }
+    b.merge( :c => 'jello' )
+    result = b.erb_eval( SAMPLE_TEMPLATE )
+    assert_equal "I love pie (especially with rhubarb), but I love jello even more!", result
+  end
+
+  def testMissingVar
+    b = Binder.new
+    result = silently { b.erb_eval( "Going to the <%=@blue%> moon" ) }
+    assert_equal "Going to the  moon", result
+  end
+
+  def testScopeCaller
+    b = Binder.new
+    @arg = "ocean"
+    result = silently { b.erb_eval( "swim in the <%= @arg %> seas" ) }
+    assert_equal "swim in the  seas", result
+  end
+
+  def testScopeBoth
+    @zip = '--zip--'
+    b = Binder.new( :zip => '++zap++' )
+    result = b.erb_eval( "The line went <%= @zip %>" )
+    assert_equal "The line went ++zap++", result
+  end
+
+  private
+
+  def silently( &block )
+    warn_level = $VERBOSE
+    $VERBOSE = nil
+    result = block.call
+    $VERBOSE = warn_level
+    result
+  end
+
+end

data/test/unit/test_data_reader.rb

@@ -0,0 +1,135 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'tempfile'
+require 'test/unit/testcase'
+require 'amazon/util/data_reader'
+
+class TestDataReader < Test::Unit::TestCase
+  include Amazon::Util
+
+SAMPLE_LIST_DATA = [ { :a => 1, :b => { :c => 2, :d => 3 }, :e => [ {:f => 4, :g => 5}, {:f => "anew\nline", :g => 7} ] }, 
+                     { :a => 2, :b => { :c => 4, :d => "for	fun" }, :e => [ {:f => 2, :g => 4}, {:f => 8, :g => 7} ] }, 
+                     { :a => 3, :b => { :c => "apples, oranges", :d => 1 }, :e => [ {:f => 2, :g => 3}, {:f => 9, :g => 6} ] }, ] 
+
+YAML_LIST_DATA = <<EOF
+---
+- :b:
+    :c: 2
+    :d: 3
+  :a: 1
+  :e:
+  - :f: 4
+    :g: 5
+  - :f: "anew\\nline"
+    :g: 7
+- :b:
+    :c: 4
+    :d: for	fun
+  :a: 2
+  :e:
+  - :f: 2
+    :g: 4
+  - :f: 8
+    :g: 7
+- :b:
+    :c: apples, oranges
+    :d: 1
+  :a: 3
+  :e:
+  - :f: 2
+    :g: 3
+  - :f: 9
+    :g: 6
+EOF
+
+TABULAR_LIST_DATA = <<EOF
+a	b.c	b.d	e.1.f	e.1.g	e.2.f	e.2.g
+1	2	3	4	5	"anew
+line"	7
+2	4	"for	fun"	2	4	8	7
+3	apples, oranges	1	2	3	9	6
+EOF
+
+CSV_LIST_DATA = <<EOF
+a,b.c,b.d,e.1.f,e.1.g,e.2.f,e.2.g
+1,2,3,4,5,"anew
+line",7
+2,4,for	fun,2,4,8,7
+3,"apples, oranges",1,2,3,9,6
+EOF
+
+SAMPLE_PROPERTIES_DATA = { :a => 1, :b => { :c => 2, :d => 3 }, :e => 4, :f => "Such a complex, yet whimsical fancy" }
+
+YAML_PROPERTIES_DATA = <<EOF
+---
+:b:
+  :c: 2
+  :d: 3
+:a: 1
+:e: 4
+:f: Such a complex, yet whimsical fancy
+EOF
+
+PROP_PROPERTIES_DATA = <<EOF
+b.c=2
+b.d=3
+a=1
+e=4
+f=Such a complex, yet whimsical fancy
+EOF
+
+  include Amazon::Util
+
+  def saveAndLoad( raw, format, sample )
+    @tmp = Tempfile.new( 'ruby-aws-test')
+    @tmp << raw
+    @tmp.close
+    data = DataReader.load( @tmp.path, format )
+    assert_equal sample, data
+  end
+
+  def reloadCheck( format, data )
+    @tmp = Tempfile.new( 'ruby-aws-test')
+    @tmp.close
+    DataReader.save( @tmp.path, data, format )
+    restore = DataReader.load( @tmp.path, format )
+    assert_equal data, restore
+  end
+
+  def testReadYAML
+    saveAndLoad( YAML_LIST_DATA, :YAML, SAMPLE_LIST_DATA )
+    saveAndLoad( YAML_PROPERTIES_DATA, :YAML, SAMPLE_PROPERTIES_DATA )
+  end
+
+  def testReadProp
+    saveAndLoad( PROP_PROPERTIES_DATA, :Properties, SAMPLE_PROPERTIES_DATA )
+  end
+
+  def testReadTabular
+    saveAndLoad( TABULAR_LIST_DATA, :Tabular, SAMPLE_LIST_DATA )
+  end
+
+  def testReadCSV
+    saveAndLoad( CSV_LIST_DATA, :CSV, SAMPLE_LIST_DATA )
+  end
+
+  def testRestoreYAML
+    reloadCheck( :YAML, SAMPLE_LIST_DATA )
+    reloadCheck( :YAML, SAMPLE_PROPERTIES_DATA )
+  end
+
+  def testRestoreProp
+    reloadCheck( :Properties, SAMPLE_PROPERTIES_DATA )
+  end
+
+  def testRestoreTabular
+    reloadCheck( :Tabular, SAMPLE_LIST_DATA )
+  end
+
+  def testRestoreCSV
+    reloadCheck( :CSV, SAMPLE_LIST_DATA )
+  end
+
+
+end # TestDataReader

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,93 @@
+# 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
+
+    nest = @unnested.nest
+    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
+    assert_equal 4, @call_count
+    result = @simple_lazy.collect
+    assert_equal @simple_data.flatten, result
+    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