ruby-aws 1.6.0

data/test/mturk/test_mock_mechanical_turk_requester.rb

@@ -0,0 +1,205 @@
+# Copyright:: Copyright (c) 2007 Amazon Technologies, Inc.
+# License::   Apache License, Version 2.0
+
+require 'test/unit/testcase'
+require 'ruby-aws'
+require 'amazon/webservices/util/mock_transport'
+
+class TestMockMechanicalTurkRequester < Test::Unit::TestCase
+
+  def setup
+    @mock = Amazon::WebServices::Util::MockTransport.new
+    @mturk = Amazon::WebServices::MechanicalTurkRequester.new( :Transport => @mock, :AWSAccessKey => 'bogus', :AWSAccessKeyId => 'fake' )
+  end
+
+  def testGetAccountBalance
+    res = @mturk.getAccountBalance # using the convenience layer method
+    assert_equal nil, res
+    res = @mturk.getAccountBalanceRaw({}) # using the raw method ( no default parameters )
+    assert_equal nil, res
+    res = @mturk.GetAccountBalance # using pass-through method ( no convenience processing )
+    assert_equal true, res[:MockResult][:Mock]
+
+    assert_equal 3, @mock.call_buffer.size
+    @mock.each do |request| 
+      assert_equal :GetAccountBalance, request.name
+      assert request.args
+      [:AWSAccessKeyId, :Signature, :Timestamp, :Request].each { |key| assert request.args[key]}
+      assert_equal( {}, request.request )
+    end
+  end
+
+  def testCreateHIT
+    res = @mturk.createHIT # convenience layer, will auto-populate some default parameters
+    res = @mturk.createHITRaw({}) # raw method, no default parameters
+    res = @mturk.CreateHIT # pass-through method ( no convenience processing )
+
+    assert_equal 3, @mock.call_buffer.size
+
+    default_call = @mock.next # request from convenience layer
+    request = default_call.request
+    assert !request.keys.empty?
+    expected = [:MaxAssignments, :AssignmentDurationInSeconds, :AutoApprovalDelayInSeconds, :LifetimeInSeconds]
+    assert_equal [], request.keys - expected, 'Convenience layer should not populate unexpected arguments'
+    assert_equal [], expected - request.keys, 'Convenience layer should populate all expected arguments'
+
+    @mock.each do |call|
+      # both remaining calls should have no arguments
+      assert_equal( {}, call.request, 'Raw calls should not auto-populate arguments')
+    end
+  end
+
+  def testCreateHITs
+    @mock.listen do |call|
+      {:RegisterHITTypeResult => {:HITTypeId => 'specialType', :Request => {}} } if call.name == :RegisterHITType
+    end
+
+    template = { :Arg1 => 'Param2', :RequesterAnnotation => 'blub' }
+    question_template = "blarg <%= @zip %> foo"
+    data_set = [ { :zip => 'poodle' }, { :zip => 'fizz' } ]
+
+    result = @mturk.createHITs( template, question_template, data_set )
+
+    assert_equal 2, result[:Created].size
+    assert_equal 0, result[:Failed].size
+
+    register_call = @mock.next
+    assert_equal :RegisterHITType, register_call.name
+    assert_equal( 
+                 { :AssignmentDurationInSeconds=>3600, # default
+                   :AutoApprovalDelayInSeconds=>604800, # default
+                   :Arg1=>"Param2" # there's our arg!
+                 },
+                 register_call.request )
+    expected_questions = [ "blarg poodle foo", "blarg fizz foo" ]
+    @mock.each do |call|
+      assert_equal :CreateHIT, call.name
+      assert_equal 'specialType', call.request[:HITTypeId]
+      assert_equal call.request[:Question], expected_questions.delete( call.request[:Question] )
+    end
+  end
+
+  def testCreateHITsWithMaxAssignment
+    @mock.listen do |call|
+      case call.name
+      when :RegisterHITType
+        {:RegisterHITTypeResult => {:HITTypeId => 'mockHITType', :Request => {} } }
+      else
+        {}
+      end
+    end
+
+    template = { :Description => 'foo bar', :MaxAssignments => 2, :RequesterAnnotation => "Funky <%= @jazz %>" }
+    question = "who what <%= @where %>"
+    data_set = [ { :jazz => "LaLa", :where => 1}, {:jazz => nil, :where => 2, :MaxAssignments => 1}, {:jazz => "Poodle", :where => nil} ]
+
+    results = @mturk.createHITs( template, question, data_set )
+
+    assert_equal [], results[:Failed]
+    assert_equal 3, results[:Created].size
+
+    ht = @mock.next
+    assert_equal :RegisterHITType, ht.name
+    assert_equal 'foo bar', ht.request[:Description]
+    assert_equal nil, ht.request[:MaxAssignments]
+
+    3.times do
+      hit = @mock.next
+      assert_equal :CreateHIT, hit.name
+      assert_equal 'mockHITType', hit.request[:HITTypeId]
+      case hit.request[:Question]
+      when 'who what 1'
+        assert_equal 2, hit.request[:MaxAssignments]
+        assert_equal 'Funky LaLa', hit.request[:RequesterAnnotation]
+      when 'who what 2'
+        assert_equal 1, hit.request[:MaxAssignments]
+        assert_equal 'Funky ', hit.request[:RequesterAnnotation]
+      when 'who what '
+        assert_equal 2, hit.request[:MaxAssignments]
+        assert_equal 'Funky Poodle', hit.request[:RequesterAnnotation]
+      else
+        fail 'generated an unexpected Question'
+      end
+    end
+
+    assert_equal nil, @mock.next
+  end
+
+  def testCreatHITsWithFailure
+    @mock.listen do |call|
+      raise "Mock hates you" if call.request[:Question] and call.request[:Question] =~ /poodle/
+      {:RegisterHITTypeResult => {:HITTypeId => 'specialType', :Request => {}} } if call.name == :RegisterHITType
+    end
+
+    template = { :Arg1 => 'Param2', :RequesterAnnotation => 'blub' }
+    question_template = "blarg <%= @zip %> foo"
+    data_set = [ { :zip => 'poodle' }, { :zip => 'fizz' } ]
+
+    result = @mturk.createHITs( template, question_template, data_set )
+
+    assert_equal 1, result[:Created].size
+    assert_equal 1, result[:Failed].size
+
+    assert_equal "Mock hates you", result[:Failed].first[:Error]
+  end
+
+  def testGetHITResults
+    # need to set up a listener to feed back hit and assignment attributes for testing results and work with pagination
+    assignments_per_hit = 31
+    @mock.mock_reply = {:OperationRequest => {}}
+    @mock.listen do |call|
+      case call.name
+      when :GetHIT
+        {:HIT => { :HITId => call.request[:HITId], :MockHITAttribute => 'amazing', :Request => {} } }
+      when :GetAssignmentsForHIT
+        size = call.request[:PageSize]
+        num = call.request[:PageNumber]
+        index = size * (num-1)
+        max = ( assignments_per_hit > index+size ) ? index+size : assignments_per_hit
+        res = []
+        index.upto(max-1) do |i|
+          res << { :HITId => call.request[:HITId], :AssignmentId => i, :MockAssignmentAttribute => 'stunning' }
+        end
+        { :GetAssignmentsForHITResult => { :Assignment => res, :Request => {} } }
+      else
+        nil
+      end
+    end
+
+    list = %w( hitid1 hitid2 amazinghit3 lamehit4 ).collect {|id| { :HITId => id } }
+    results = @mturk.getHITResults( list )
+
+    assert_equal assignments_per_hit*list.size, results.size
+    results.each { |item|
+      assert_not_nil item[:HITId]
+      assert_equal 'amazing', item[:MockHITAttribute]
+      assert_not_nil item[:AssignmentId]
+      assert_equal 'stunning', item[:MockAssignmentAttribute]
+    }
+
+  end
+
+  def testAvailableFunds
+    # TODO
+  end
+
+  def testSimplifyAnswer
+    rawAnswer = <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<QuestionFormAnswers xmlns="http://mechanicalturk.amazonaws.com/AWSMechanicalTurkDataSchemas/2005-10-01/QuestionFormAnswers.xsd">
+  <Answer>
+    <QuestionIdentifier>1</QuestionIdentifier>
+    <FreeText>yes, sir</FreeText>
+  </Answer>
+  <Answer>
+    <QuestionIdentifier>pudding</QuestionIdentifier>
+    <SelectionIdentifier>B+</SelectionIdentifier>
+  </Answer>
+</QuestionFormAnswers>
+EOF
+    expected = { 1 => 'yes, sir', 'pudding' => 'B+' }
+    result = @mturk.simplifyAnswer( rawAnswer )
+    assert_equal expected, result
+  end
+
+end

data/test/test_ruby-aws.rb

@@ -0,0 +1,24 @@
+# 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
+
+  VERSION_NUMBER_PATTERN = '\d+\.\d+\.\d+(\.[a-zA-Z\d]+)*'
+
+  def testVersion
+    assert( RubyAWS::VERSION =~ /^#{VERSION_NUMBER_PATTERN}$/ , "RubyAWS::VERSION is incorrectly formatted")
+  end
+
+  def testAgent
+    assert( RubyAWS.agent =~ /^ruby-aws\/#{VERSION_NUMBER_PATTERN}$/ )
+    assert( RubyAWS.agent('Tester') =~ /^ruby-aws\/#{VERSION_NUMBER_PATTERN} 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