amazon_sdb 0.5.5

data/test/test_amazon_domain.rb

@@ -0,0 +1,208 @@
+require 'test_sdb_harness'
+
+QUERY_RESPONSE = <<-EOF
+<QueryResponse xmlns="http://sdb.amazonaws.com/doc/2007-11-07"> 
+<QueryResult> 
+<ItemName>item1</ItemName> 
+<ItemName>item2</ItemName> 
+<ItemName>item3</ItemName> 
+</QueryResult> 
+<ResponseMetadata> 
+<RequestId>c74ef8c8-77ff-4d5e-b60b-097c77c1c266</RequestId> 
+<BoxUsage>0.0000219907</BoxUsage> 
+</ResponseMetadata> 
+</QueryResponse> 
+EOF
+
+GET_ATTRIBUTES_RESPONSE = <<-EOF
+<GetAttributesResponse xmlns="http://sdb.amazonaws.com/doc/2007-11-07"> 
+<GetAttributesResult> 
+<Attribute><Name>Color</Name><Value>Blue</Value></Attribute> 
+<Attribute><Name>Size</Name><Value>Med</Value></Attribute> 
+<Attribute><Name>Price</Name><Value>14</Value></Attribute> 
+</GetAttributesResult> 
+<ResponseMetadata> 
+<RequestId>b1e8f1f7-42e9-494c-ad09-2674e557526d</RequestId> 
+<BoxUsage>0.0000219907/<BoxUsage> 
+</ResponseMetadata> 
+</GetAttributesResponse> 
+EOF
+
+class TestAmazonDomain < Test::Unit::TestCase
+  def setup
+    @domain = Amazon::SDB::Domain.new 'API_KEY', 'SECRET_KEY', 'testdb'
+    @attr_hash = {"foo" => "bar", "baz" => "quux"}
+  end
+  
+  def test_no_such_domain_error
+#    @domain.responses << error_response('NoSuchDomain', 'No such domain found')
+        
+#    assert_raise(DomainNotFoundError) { @domain.get_attributes() }
+  end
+  
+  def test_put_attributes
+    @domain.responses << generic_response('PutAttributes')
+    
+    m = Amazon::SDB::Multimap.new(@attr_hash)
+    @domain.put_attributes 'item_key', m
+    
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'Action' => 'PutAttributes', 'DomainName' => @domain.name, 'ItemName' => 'item_key'}, @domain.uris.first)
+    assert_attr_pairs_in_query @attr_hash, @domain.uris.first
+  end
+  
+  def test_put_attributes_hash
+    @domain.responses << generic_response('PutAttributes')
+    
+    @domain.put_attributes 'item_key', @attr_hash
+    
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'Action' => 'PutAttributes', 'DomainName' => @domain.name, 'ItemName' => 'item_key'}, @domain.uris.first)
+    assert_attr_pairs_in_query @attr_hash, @domain.uris.first    
+  end
+  
+  def test_put_attributes_replace_by_name
+    @domain.responses << generic_response('PutAttributes')
+    
+    @domain.put_attributes 'item_key', @attr_hash, :replace => :baz
+  end
+  
+  def test_put_attributes_replace_all
+    @domain.responses << generic_response('PutAttributes')
+    
+    m = Amazon::SDB::Multimap.new @attr_hash
+    
+    @domain.put_attributes 'item_key', m, :replace => :all
+    
+    assert_in_url_query({'Attribute.0.Replace' => 'true', 'Attribute.1.Replace' => 'true'}, @domain.uris.first)
+  end
+  
+  def test_get_attributes
+    @domain.responses << GET_ATTRIBUTES_RESPONSE
+    
+    item = @domain.get_attributes('key')
+    
+    assert_equal 1, @domain.uris.size
+    
+    assert_in_url_query({'Action' => 'GetAttributes', 'DomainName' => @domain.name, 'ItemName' => 'key'}, @domain.uris.first)
+    assert_instance_of(Amazon::SDB::Item, item)
+    assert_equal 'Blue', item['Color']
+  end
+  
+  def test_get_attributes_not_found
+    @domain.responses << <<-EOF
+    <GetAttributesResponse xmlns="http://sdb.amazonaws.com/doc/2007-11-07"> 
+    <GetAttributesResult> 
+    </GetAttributesResult> 
+    <ResponseMetadata> 
+    <RequestId>b1e8f1f7-42e9-494c-ad09-2674e557526d</RequestId> 
+    <BoxUsage>0.0000219907/<BoxUsage> 
+    </ResponseMetadata> 
+    </GetAttributesResponse>    
+    EOF
+
+    assert_raise(Amazon::SDB::RecordNotFoundError) { @domain.get_attributes('key') }
+    assert_equal 1, @domain.uris.size
+  end
+
+  def test_get_attributes_specific
+    @domain.responses << GET_ATTRIBUTES_RESPONSE
+    
+    item = @domain.get_attributes 'key', 'attr1', :attr2
+    
+    assert_in_url_query({'AttributeName' => ['attr1','attr2']}, @domain.uris.first)
+  end
+  
+  def test_delete_attributes_all
+    @domain.responses << generic_response('DeleteAttributes')
+    
+    @domain.delete_attributes 'key'
+    
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'Action' => 'DeleteAttributes', 'DomainName' => @domain.name, 'ItemName' => 'key'}, @domain.uris.first)
+  end
+  
+  def test_delete_attributes_name
+    @domain.responses << generic_response('DeleteAttributes')
+    
+    @domain.delete_attributes 'key', 'foo'
+    
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'Action' => 'DeleteAttributes', 'DomainName' => @domain.name, 'ItemName' => 'key'}, @domain.uris.first)
+    assert_in_url_query({'Attribute.0.Name' => 'foo'}, @domain.uris.first)        
+  end
+  
+  def test_delete_attributes_name_value
+    @domain.responses << generic_response('DeleteAttributes')
+    
+    @domain.delete_attributes 'key', {'foo' => 'bar'}
+    
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'Action' => 'DeleteAttributes', 'DomainName' => @domain.name, 'ItemName' => 'key'}, @domain.uris.first)
+    assert_in_url_query({'Attribute.0.Name' => 'foo', 'Attribute.0.Value' => 'bar'}, @domain.uris.first)    
+  end
+  
+  def test_query_all
+    @domain.responses << QUERY_RESPONSE
+    
+    results = @domain.query
+      
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'Action' => 'Query', 'DomainName' => @domain.name}, @domain.uris.first)
+    assert_not_in_url_query('QueryExpression', @domain.uris.first)
+    
+    assert_instance_of(Amazon::SDB::ResultSet, results)
+    
+    assert_equal 3, results.items.size
+    assert_equal ['item1', 'item2', 'item3'], results.keys
+  end
+  
+  def test_query_max_results
+    @domain.responses << QUERY_RESPONSE
+    
+    @domain.query :max_results => 3
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'MaxNumberOfItems' => '3'}, @domain.uris.first)    
+  end
+  
+  def test_query_next_token
+    @domain.responses << QUERY_RESPONSE
+    
+    @domain.query :next_token => 'FOOBAR'
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'NextToken' => 'FOOBAR'}, @domain.uris.first)
+  end
+  
+  def test_query_expr
+    @domain.responses << QUERY_RESPONSE
+    
+    @domain.query :expr => "['last_name' = 'Harris']"
+    
+    assert_equal 1, @domain.uris.length
+    assert_in_url_query({'QueryExpression' => "['last_name' = 'Harris']"}, @domain.uris.first)
+  end
+  
+  def test_list_items_load
+    @domain.responses << <<-EOF
+    <QueryResponse xmlns="http://sdb.amazonaws.com/doc/2007-11-07"> 
+    <QueryResult> 
+    <ItemName>item1</ItemName> 
+    </QueryResult> 
+    <ResponseMetadata> 
+    <RequestId>c74ef8c8-77ff-4d5e-b60b-097c77c1c266</RequestId> 
+    <BoxUsage>0.0000219907</BoxUsage> 
+    </ResponseMetadata> 
+    </QueryResponse> 
+    EOF
+        
+    @domain.responses << GET_ATTRIBUTES_RESPONSE
+    
+    results = @domain.query :load_attrs => true
+    
+    assert_equal 2, @domain.uris.length
+    assert_in_url_query({'Action' => 'GetAttributes', 'DomainName' => @domain.name, 'ItemName' => 'item1'}, @domain.uris.last)
+    
+    assert_equal 1, results.items.size
+    assert_equal 'Blue', results.items.first["Color"]
+  end
+end

data/test/test_multimap.rb

@@ -0,0 +1,177 @@
+require "test_sdb_harness"
+
+class TestMultimap < Test::Unit::TestCase
+  include Amazon::SDB
+  
+  def setup
+    @m = Multimap.new
+  end
+  
+  def test_init_nil
+    assert_equal 0, @m.size
+    @m.each_pair do |k, v|
+      flunk 'Shouldn''t be anything in the multimap'
+    end
+  end
+  
+  def test_init_array
+    m = Multimap.new [['a', 1], ['b', 2], ['a', 3]]
+    assert_equal 3, m.size
+    assert_equal [1, 3], m.get('a')
+    assert_equal 2, m.get('b')
+  end
+  
+  def test_init_array_bad
+    assert_raise(ArgumentError) { m = Multimap.new [:a, :b, :c] }
+  end
+  
+  def test_init_hash
+    m = Multimap.new({:a => 'a', :b => 'b'})
+    assert_equal 2, m.size
+    assert_equal 'a', m.get(:a)
+    assert_equal 'b', m.get(:b)
+  end
+  
+  def test_init_null_value
+    m = Multimap.new({:a => nil, :b => 'b'})
+    assert_nil(m.get(:a))
+    assert_equal 'b', m.get(:b)
+  end
+  
+  def test_init_null_put
+    m = Multimap.new({:a => nil})
+    assert_equal 1, m.size
+    
+    m.put(:a, 1)
+    assert_equal 1, m.size
+  end
+  
+  def test_indifferent_access
+    m = Multimap.new({:a => 1})
+    assert_equal 1, m["a"]
+  end
+  
+  def test_indifferent_both
+    m = Multimap.new({:a => 1, "a" => 2})
+    assert_equal 2, m.size
+    assert_equal [2, 1], m[:a]
+  end
+  
+  def test_put
+    @m["a"] = 23
+    assert_equal(23, @m.get("a"))
+  end
+  
+  def test_put_append
+    @m.put("a", 2)
+    @m.put("a", 4)
+    assert_equal 2, @m.size
+  end
+  
+  def test_put_replace
+    @m.put("a", 2)
+    @m.put("a", 4, :replace => true)
+    assert_equal 1, @m.size
+    assert_equal 4, @m["a"]
+  end
+  
+  def test_bracket_read
+    m = Multimap.new({:a => 5})
+    assert_equal 5, m[:a]
+    assert_nil m["b"]
+  end
+  
+  def test_bracket_write
+    @m[:a] = 1
+    @m[:a] = 3
+    assert_equal(1, @m.size)
+    assert_equal(3, @m[:a])
+  end
+  
+  def test_delete_key
+    # m = Multimap.new([[:a, 1][:a, 2][:a, 3]])
+    # assert_equal 3, m.size
+    # m.delete
+  end
+  
+  def test_fixnum_padding
+    @m['Num'] = 12
+    Amazon::SDB::Base.number_padding = 6
+    
+    assert_equal '000012', @m.to_sdb['Attribute.0.Value']
+  end
+  
+  def test_numeric
+    @m['Num'] = Amazon::SDB::Multimap.numeric(12.34, 10, 4)
+    assert_equal '00012.3400', @m['Num']
+  end
+    
+  def test_to_sdb_replace_all
+    @m[:a] = "foo"
+    @m[:b] = "bar"
+    
+    out = @m.to_sdb({:replace => :all})
+    assert out.key?('Attribute.0.Replace')
+    assert out.key?('Attribute.1.Replace')
+  end
+  
+  def test_to_sdb_replace_by_name
+    @m[:a] = "foo"
+    
+    out = @m.to_sdb({:replace => 'a'})
+    assert out.key?('Attribute.0.Replace')
+  end
+  
+  def test_delete_pair
+    
+  end
+  
+  def test_char_escape
+    @m["a\'b"] = "c\\d"
+    
+    out = @m.to_sdb
+    
+    assert_equal 'a\\\'b', out["Attribute.0.Name"]
+    assert_equal 'c\\\\d', out["Attribute.0.Value"]
+  end
+  
+  def test_method_missing_get
+    @m["foo"] = "bar"
+    
+    assert_equal "bar", @m.foo
+    assert_raise(NoMethodError) { @m.baz }
+  end
+  
+  def test_method_missing_get_before_cast
+    @m.from_sdb([["foo","0000000000000000023"]])
+    
+    assert_equal 23, @m.foo
+    assert_equal "0000000000000000023", @m.foo_before_cast
+  end
+  
+  def test_coerce_int
+    m = Multimap.new
+    m.from_sdb([["a", "00000000023"],["b", "1992"]])
+    
+    assert_equal 23, m["a"]
+    assert_equal "00000000023", m.get("a", :before_cast => true)
+    assert_equal "1992", m["b"]
+  end
+  
+  def test_coerce_float
+    m = Multimap.new
+    m.from_sdb([["a", "0000000000034.3400000000"]])
+    
+    assert_in_delta(34.34, m["a"], 2 ** -20)
+    assert_equal "0000000000034.3400000000", m.get("a", :before_cast => true)
+  end
+  
+  def test_coerce_datetime
+    now = Time.now
+    
+    m = Multimap.new
+    m.from_sdb([["a", now.iso8601]])
+    assert_equal now.to_s, m["a"].to_s
+    assert_instance_of(Time, m["a"])
+  end
+end

data/test/test_sdb_harness.rb

@@ -0,0 +1,124 @@
+require "test/unit"
+require 'cgi'
+require "amazon_sdb"
+
+# little mock override of open for base (technique from Eric Hodel)
+class Amazon::SDB::Base
+  attr_accessor :uris, :responses
+  
+  def initialize(aws_access_key, aws_secret_key)
+    @access_key = aws_access_key
+    @secret_key = aws_secret_key
+    @responses = []
+    @uris = []  
+  end
+  
+  def open(uri)
+    @uris << uri
+    
+    if @responses.size == 0
+      fail "Unexpected HTTP request #{uri}"
+    end
+    
+    yield StringIO.new(@responses.shift)
+  end
+end
+
+class Test::Unit::TestCase
+  def error_response(code, msg)
+    "<Response> 
+    <Errors> 
+    <Error> 
+    <Code>#{code}</Code> 
+    <Message>#{msg}</Message> 
+    <BoxUsage>0.0000219907</BoxUsage> 
+    </Error> 
+    </Errors> 
+    <RequestID> 
+    1e6265c5-f1f2-4a4b-afef-1448cac0f065 
+    </RequestID> 
+    </Response>"
+  end
+  
+  def generic_response(method)
+    "<#{method}Response xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07\"> 
+    <ResponseMetadata> 
+    <RequestId>490206ce-8292-456c-a00f-61b335eb202b</RequestId> 
+    <BoxUsage>0.0000219907</BoxUsage> 
+    </ResponseMetadata> 
+    </#{method}Response>"
+  end
+  
+  def assert_in_url_query(hash, uri)
+    query_str = uri.gsub(/^.+\?/, '')
+    query_hash = CGI.parse query_str
+    
+    hash.each_pair do |key, value|
+      case value
+      when Array
+        assert_equal value, query_hash[key], "Query #{query_str} includes #{key}=#{query_hash[key]}, expected #{value.inspect}"
+      else
+        assert_equal [value], query_hash[key], "Query #{query_str} includes #{key}=#{query_hash[key]}, expected #{value}"
+      end
+    end
+  end
+  
+  def assert_url_path(path, uri)
+    test_path = uri.dup
+    test_path.gsub!(/^http:\/\/[^\/]+\//, '/')
+    test_path.gsub!(/\?.+$/, '')
+    
+    assert_equal path, test_path
+  end
+  
+  
+  def assert_attr_pairs_in_query(attr_hash, uri)
+    attr_hash.each_pair do |k, v|
+      assert_attr_pair_in_query k, v, uri
+    end
+  end
+  
+  def assert_attr_pair_in_query(key, value, uri)
+    query_str = uri.gsub(/^.+\?/, '')
+    query_hash = CGI.parse query_str
+    
+    key_found = false
+    value_found = false
+    
+    query_hash.each_pair do |cgi_key, cgi_value|
+      if cgi_key =~ /Attribute\.\d+\.Name/
+        key_found ||= cgi_value.any? {|k| k == key}
+      elsif cgi_key =~ /Attribute\.\d+\.Value/
+        value_found ||= cgi_value.any? {|k| k == value}
+      end
+      
+      return if key_found and value_found
+    end
+    
+    if key_found and not value_found
+      fail "Key '#{key}' found but not with value '#{value}' found in #{query_str}"
+    elsif value_found and not key_found
+      fail "Key '#{key}' not found but value '#{value}' found in #{query_str}"
+    else
+      fail "Neither key '#{key}' or value '#{value}' found in #{query_str}"
+    end
+  end
+  
+  def assert_not_in_url_query(args, uri)
+    arg_array = case args
+      when String
+        args.to_a
+      when Array
+        args
+      else
+        raise ArgumentError, "Should be a string or array"
+      end
+    
+    query_str = uri.gsub /^.+\?/, ''
+    query_hash = CGI.parse query_str
+
+    arg_array.each do |key|
+      assert_equal [], query_hash[key], "The key #{key} should not be in the URL argument string"
+    end
+  end
+end