aws_sdb_bare 1.2.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Paolo Negri
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,88 @@
+= aws_sdb_bare
+
+AwsSdb Bare is a ruby gem intended to provide a basic modular interface to use
+the SimpleDB service provided by Amazon.
+
+== Concept
+
+The aim of the project is to not commit to any http handling strategy and to
+not enforce any response parsing solution by default.
+
+The idea behind this project is to provide a basic layer on top of which
+more high level libraries can be built.
+
+The library provides XML response parsing through Hpricot or Nokogiri to
+run the test against a specific parser
+
+  rake nokogiri test
+
+Or
+
+  rake hpricot test
+
+
+== Project sources
+
+the project is hosted on github http://github.com/hungryblank/aws_sdb_bare
+
+blog posts explaining the usage can be found on http://assertbuggy.blogspot.com
+
+== Support and bug tracking
+
+issues can be posted on github http://github.com/hungryblank/aws_sdb_bare
+forking and patch proposal throguh github are encouraged
+
+== Installation
+
+  sudo gem install hungryblank-aws_sdb_bare -s http://gems.github.com
+
+== Usage - Requests
+
+The most basic primitive is the request, as a sample here's how a ListDomains
+request is generated
+
+  require 'rubygems'
+  require 'aws_sdb_bare'
+
+  ENV['AMAZON_ACCESS_KEY_ID'] = 'your_amazon_access_key'
+  ENV['AMAZON_SECRET_ACCESS_KEY'] = 'your_amazon_secret'
+
+  #create the request object
+  request = AwsSdb::Request::Base.new('GET', 'Action' => 'ListDomains')
+
+  #using curl we can send the request as http get and print out the xml
+  #response with the domains under your account
+  puts `curl #{request.uri}`
+
+The gem provides classes to create directly all the requests listed in
+Amazon's 2007 11 07 specs so you can do
+
+  request = AwsSdb::Request::ListDomains.new
+
+Instead of using the Base class like the previous example.
+
+Please refer to the gem rdocs and to the amazon documentation to see
+a list of all the available requests and their parameters
+
+== Usage - Responses
+
+To parse a response you simply call AwsSdb::Response.parse(xml_doc) example:
+
+  require 'open-uri'
+  require 'aws_sdb_bare'
+  #the following line could require nokogiri instead
+  require 'hpricot'
+
+  request = AwsSdb::Request::ListDomains.new
+  xml_response = open request.uri
+  response = AwsSdb::Response.parse(xml_response)
+  puts response.domains
+  puts response.metadata.box_usage
+
+== Documentation
+
+Rdoc are available at http://rdoc.elastastic.com/aws_sdb_bare
+
+== Copyright
+
+Copyright (c) 2009 Paolo Negri. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "aws_sdb_bare"
+    gem.summary = %Q{Amazon AWS SDB SimpleDB client library, low level and http lib agnostic}
+    gem.email = "hungryblank@gmail.com"
+    gem.homepage = "http://github.com/hungryblank/aws_sdb_bare"
+    gem.authors = ["Paolo Negri"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+task :hpricot do
+  ENV['PARSER'] = 'hpricot'
+end
+
+task :nokogiri do
+  ENV['PARSER'] = 'nokogiri'
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "aws_sdb_bare #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 1
+:minor: 2

data/aws_sdb_bare.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{aws_sdb_bare}
+  s.version = "1.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paolo Negri"]
+  s.date = %q{2010-02-20}
+  s.email = %q{hungryblank@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "aws_sdb_bare.gemspec",
+     "lib/aws_sdb_bare.rb",
+     "lib/aws_sdb_bare/request.rb",
+     "lib/aws_sdb_bare/response.rb",
+     "test/aws_sdb_request_template_test.rb",
+     "test/aws_sdb_request_test.rb",
+     "test/aws_sdb_response_test.rb",
+     "test/samples/responses.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/hungryblank/aws_sdb_bare}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Amazon AWS SDB SimpleDB client library, low level and http lib agnostic}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/aws_sdb_request_test.rb",
+     "test/samples/responses.rb",
+     "test/aws_sdb_response_test.rb",
+     "test/aws_sdb_request_template_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/aws_sdb_bare/request.rb

@@ -0,0 +1,318 @@
+module AwsSdb
+
+  module Request
+
+    class Base
+
+      HOST = 'sdb.amazonaws.com'
+
+      attr_accessor :account, :secret, :params
+
+      def initialize(method, params, opts={})
+        @account = opts[:account] || ENV['AMAZON_ACCESS_KEY_ID']
+        @secret = opts[:secret] || ENV['AMAZON_SECRET_ACCESS_KEY']
+        raise <<-end_msg unless @account && @secret
+          Amazon AWS account or access key not defined
+          Please pass {:account => 'your account', :secret => 'your secret'}
+          as a last argument or define the following environment variables
+          ENV['AMAZON_ACCESS_KEY_ID']
+          ENV['AMAZON_SECRET_ACCESS_KEY']
+        end_msg
+        @method = method
+        @params = params
+        add_req_data_to_params
+      end
+
+      #Hostname for the request
+      def host
+        HOST
+      end
+
+      #Uri path
+      def path
+        '/'
+      end
+
+      #The full uri for the request, it takes the protocol as argument
+      def uri(protocol = 'http')
+        "#{protocol}://" + host + path + '?' + uri_query
+      end
+
+      #Only the query part of the uri
+      def uri_query
+        params_query + '&Signature=' + signature
+      end
+
+      alias :to_s :uri
+
+      private
+
+      def add_req_data_to_params
+        @params.update({'Version' => '2007-11-07',
+                        'SignatureVersion' => '2',
+                        'SignatureMethod' => 'HmacSHA256',
+                        'AWSAccessKeyId' => @account,
+                        'Timestamp' => Time.now.gmtime.iso8601})
+      end
+
+      def params_query
+        @params_query ||= @params.keys.sort.map do |key|
+          key + '=' + escape(@params[key].to_s)
+        end.join('&')
+      end
+
+      def data_to_sign
+        [@method, host, path, params_query].join("\n")
+      end
+
+      def signature
+        @signature ||= begin
+          digest = OpenSSL::Digest::Digest.new('sha256')
+          hmac = OpenSSL::HMAC.digest(digest, @secret, data_to_sign)
+          escape(Base64.encode64(hmac).strip)
+        end
+      end
+
+      def escape(string)
+        URI.escape(string, /[^-_.~a-zA-Z\d]/)
+      end
+
+    end
+
+    #Is the parent of all the request templates, defines some methods
+    class Template
+
+      class << self
+
+        #Generates method to allow shorter expressions in parameter
+        #definition takes an hash
+        #
+        #  shortcuts({'LongUrlQueryParams' => :abbr})
+        #
+        #will cause :abbr params to be expanded in LongUrlQueryParams
+        def shortcuts(shortcuts_hash)
+          shortcuts_hash.each do |full_key, shortcut|
+            define_method("#{shortcut}=") do |value|
+              @params[full_key] = value
+            end
+          end
+        end
+
+      end
+
+      #takes the params for the request and an optional options hash
+      #params for the request are request specific, options accepted are only
+      #AWS credentials in form of
+      #
+      #  {:account => 'your account', :secret => 'your secret'} 
+      def initialize(params={}, opts={})
+        @params, @opts = params, opts
+      end
+
+      def token=(value)
+        @params['NextToken'] = value
+      end
+
+      def attributes=(attributes)
+        attributes.each_with_index do |attribute, index|
+          @params["AttributeName.#{index}"] = attribute.to_s
+        end
+      end
+
+      def request
+        expand!
+        @request ||= begin
+          Base.new('GET', @params.merge('Action' => self.class.to_s.split(':')[-1]), @opts)
+        end
+      end
+
+      [:to_s, :uri, :uri_query].each do |method|
+        define_method(method) do
+          request.send(method)
+        end
+      end
+
+      private
+
+      def expand!
+        @params.keys.each do |key|
+          send("#{key}=", @params.delete(key)) if respond_to?("#{key}=")
+        end
+        @params
+      end
+
+    end
+
+    #List the domains
+    #
+    #  ListDomains.new({:max => 4}, {:account => 'account', :secret => 'secret'})
+    #
+    #Shortcut in params:
+    #
+    #  :max - the maximum number of domain that can be returned
+    #  :token - the token for follow up requests
+    class ListDomains < Template
+      shortcuts({'MaxNumberOfDomains' =>  :max})
+    end
+
+    #Creates a new domain
+    #
+    #  CreateDomain.new({:name => 'my_domain'})
+    #
+    #Shortcut in params:
+    #
+    #  :name - the name for the new domain
+    class CreateDomain < Template
+      shortcuts({'DomainName' =>  :name})
+    end
+
+    #Deletes a domain
+    #
+    #  DeleteDomain.new({:name => 'my_domain'})
+    #
+    #Shortcut in params:
+    #
+    #  :name - the name for domain
+    class DeleteDomain < Template
+      shortcuts({'DomainName' =>  :name})
+    end
+
+    #Provides informations for a domain
+    #
+    #  DomainMetadata.new({:name => 'my_domain'})
+    #
+    #Shortcut in params:
+    #
+    #  :name - the name for domain
+    class DomainMetadata < Template
+      shortcuts({'DomainName' =>  :name})
+    end
+
+    #Get the attributes for an item
+    #
+    #  GetAttributes.new({:name => 'my_item', :attributes => [:first, :second]})
+    #
+    #Shortcut in params:
+    #
+    #  :name - the item name
+    #  :attributes - the list of the attributes to fetch, if not specified
+    #                fetches all the attributes
+    class GetAttributes < Template
+      shortcuts({'ItemName' =>  :name, 'DomainName' => :domain})
+    end
+
+    #Add attributes to an item or create a new item whith the given attributes
+    #
+    #  req = PutAttributes.new({:name => 'my_item'})
+    #  req.attributes = {:color => :black, :shape => {:value => :square, :replace => true}}
+    #
+    #Note: in this request the value 'black' will be added to other color
+    #values if they already exist, while the shape value 'square' will replace
+    #pre existing values of shape
+    #the request, adding the :attributes to the params hash in the new method
+    #would have the same effect
+    #
+    #Note: in the sample above attributes are defined after initializing
+    #the request, adding the :attributes to the params hash in the new method
+    #would have the same effect
+    class PutAttributes < Template
+
+      attr_accessor :attributes
+
+      class << self
+
+        #multiple PutAttributes requests can be batched in one BatchPutAttributes
+        #just define the single PutAttributes and then pass them as args to
+        #the PutAttributes::batch method and you'll be returned the batched
+        #request.
+        #At the moment of writing the maximum number of requests you can batch
+        #are 25
+        def batch(*requests)
+          items_params = requests.map { |r| r.send(:expand!) }
+          first_request = requests.first.request
+          account = first_request.account
+          secret = first_request.secret
+          batch_params = {}
+          batch_params['DomainName'] ||= first_request.params['DomainName']
+          items_params.each_with_index do |params, index|
+            params.keys.each do |key|
+              batch_params["Item.#{index.to_s + '.' + key}"] = params[key] if key =~ /^ItemName|Attribute/
+            end
+          end
+          BatchPutAttributes.new(batch_params, {:account => account, :secret => secret})
+        end
+      end
+
+      shortcuts({'ItemName' =>  :name, 'DomainName' => :domain})
+
+      def expand_attributes!
+        index = 0
+        @attributes.keys.each do |attr_name|
+          replace = nil
+          values = case @attributes[attr_name]
+          when Hash
+            replace = @attributes[attr_name][:replace].to_s
+            @attributes[attr_name][:value].to_s
+          else
+            @attributes[attr_name].to_s
+          end
+          values = [values] unless values.is_a?(Array)
+          values.each do |value|
+            @params["Attribute.#{index}.Replace"] = replace if replace
+            @params["Attribute.#{index}.Name"] = attr_name.to_s
+            @params["Attribute.#{index}.Value"] = value
+            index += 1
+          end
+        end
+      end
+
+      private
+
+      def expand!
+        super
+        expand_attributes!
+      end
+
+    end
+
+    class BatchPutAttributes < Template
+      shortcuts({'DomainName' => :domain})
+    end
+
+    #delete some attributes from the given item, if no attributes
+    #are provided the whole item is deleted
+    #
+    #  DeleteAttributes.new(:domain => 'test_domain', :name => 'item_1'
+    #    :attributes => [:color, :shape])
+    class DeleteAttributes < Template
+      shortcuts({'ItemName' =>  :name, 'DomainName' => :domain})
+    end
+
+    #execute a select statement
+    #  Select.new(:query => "SELECT * FROM test_domain")
+    class Select < Template
+      shortcuts({'SelectExpression' => :query})
+    end
+
+    #execute a query statement returns the array of the item names
+    #satisfying the statment
+    #
+    #  Query.new(:domain => 'test_domain', :query => "['shape' = 'square']")
+    class Query < Template
+      shortcuts({'DomainName' =>  :domain,
+                 'QueryExpression' => :query,
+                 'MaxNumberOfItems' => :max})
+    end
+
+    #execute a query with attributes statement returns the items
+    #satisfying statement
+    #
+    #  QueryWithAttributes.new(:domain => 'test_domain', :query => "['shape' = 'square']")
+    class QueryWithAttributes < Template
+      shortcuts({'DomainName' =>  :domain,
+                 'QueryExpression' => :query,
+                 'MaxNumberOfItems' => :max})
+    end
+  end
+
+end

data/lib/aws_sdb_bare/response.rb

@@ -0,0 +1,163 @@
+module AwsSdb
+
+  module Response
+
+    MEMBERS = {}
+
+    class UnknownResponse < ArgumentError
+    end
+
+    #returns an instance of the response, the class of the response is determined
+    #by the response content
+    def self.parse(doc)
+      @@parser ||= Hpricot if defined?(Hpricot)
+      @@parser ||= Nokogiri if defined?(Nokogiri)
+      parsed_doc = @@parser.XML(doc)
+      begin
+        MEMBERS[parsed_doc.root.name].new(parsed_doc)
+      rescue
+        raise UnknownResponse, "unkwonw response #{doc.inspect}"
+      end
+    end
+
+    module XmlUtils
+
+      private
+
+      def xml_attr_reader(*attributes)
+        attributes.each do |attr|
+          define_method(attr.gsub(/[A-Z]+/,'\1_\0').downcase[1..-1]) do
+            value = @doc.at(attr).inner_html
+            value = yield(value) if block_given?
+            value
+          end
+        end
+      end
+
+    end
+
+    class Base
+ 
+      class << self
+
+        def register
+          Response::MEMBERS[to_s.split(':').pop + 'Response'] = self 
+        end
+
+        def has_items
+          define_method :items do
+            @items ||= begin
+              (@doc / 'Item').inject({}) do |items_hash, item|
+                items_hash[item.at('Name').inner_html] = attributes_hash(item)
+                items_hash
+              end
+            end
+          end
+        end
+
+      end
+
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def metadata
+        @metadata ||= Metadata.new(@doc.at('ResponseMetadata'))
+      end
+
+      #the token to get the following chunk of response in case the response
+      #is broken in parts due to the size limit being exceeded
+      def token
+        if token_element = @doc.at('NextToken')
+          token_element.inner_html
+        end
+      end
+
+      private
+
+      def attributes_hash(element)
+        attr_hash = Hash.new() { |h, k| h[k] = [] }
+          (element / 'Attribute').each do |attribute|
+            attr_hash[attribute.at('Name').inner_html] << attribute.at('Value').inner_html
+          end
+        attr_hash
+      end
+
+    end
+
+    %w(BatchPutAttributesResponse)
+
+    class GetAttributes < Base
+
+      register
+
+      #hash of item attributes
+      def attributes
+        @attributes ||= attributes_hash(@doc)
+      end
+
+    end
+
+    class Select < Base
+      register
+      has_items
+    end
+
+    class QueryWithAttributes < Base
+      register
+      has_items
+    end
+
+    class Query < Base
+
+      register
+
+      def item_names
+        @items ||= (@doc / 'ItemName').map { |i| i.inner_html }
+      end
+
+    end
+
+    class ListDomains < Base
+
+      register
+
+      def domains
+        @domains ||= (@doc / 'DomainName').map { |d| d.inner_html }
+      end
+
+    end
+
+    class DomainMetadata < Base
+
+      extend XmlUtils
+      register
+      xml_attr_reader('ItemCount', 'ItemNamesSizeBytes', 'AttributeNameCount',
+                      'AttributeNamesSizeBytes', 'AttributeValueCount',
+                      'AttributeValuesSizeBytes', 'Timestamp') { |value| value.to_i }
+
+    end
+
+    %w(CreateDomain DeleteDomain PutAttributes BatchPutAttributes DeleteAttributes).each do |klass|
+      module_eval <<-eval_end
+        class #{klass} < Base
+          register
+        end
+      eval_end
+    end
+
+    class Metadata
+
+      extend XmlUtils
+
+      xml_attr_reader 'RequestId', 'BoxUsage'
+
+      def initialize(doc)
+        @doc = doc
+      end
+
+    end
+
+  end
+
+end

data/lib/aws_sdb_bare.rb

@@ -0,0 +1,7 @@
+require 'base64'
+require 'time'
+require 'uri'
+require 'openssl'
+Dir.glob(File.dirname(__FILE__) + '/aws_sdb_bare/**/*.rb').each do |lib|
+  require lib
+end

data/test/aws_sdb_request_template_test.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class AwsSdbRequestTemplateTest < Test::Unit::TestCase
+
+  include AwsSdb::Request
+
+  def setup
+    ENV['AMAZON_ACCESS_KEY_ID'] = 'a'
+    ENV['AMAZON_SECRET_ACCESS_KEY'] = 'a'
+  end
+
+  should "add the token using shortcut" do
+    req = Template.new({'a' => '1', :token => 'this_is_the_token'})
+    assert_attribute({'NextToken' => 'this_is_the_token'}, req.uri_query)
+  end
+
+  should "add attributes and number them" do
+    req = Template.new({'a' => 1, :attributes => [:attr_1, :attr_2]}, {:account => 'account', :secret => 'secret'})
+    assert_attribute({'AttributeName.0' => 'attr_1'}, req.uri_query)
+    assert_attribute({'AttributeName.1' => 'attr_2'}, req.uri_query)
+  end
+
+  should "generate all the parameters for a ListDomains" do
+    req = ListDomains.new({:max => 4}, {:account => 'account', :secret => 'secret'})
+    assert_attribute({'Action' => 'ListDomains'}, req.uri_query)
+    assert_attribute({'MaxNumberOfDomains' => '4'}, req.uri_query)
+  end
+
+  should "generate all the parameters for an CreateDomain" do
+    req = CreateDomain.new({:name => 'my_domain'}, {:account => 'account', :secret => 'secret'})
+    assert_attribute({'Action' => 'CreateDomain'}, req.uri_query)
+    assert_attribute({'DomainName' => 'my_domain'}, req.uri_query)
+  end
+
+  should "generate all the parameters for a DeleteDomain" do
+    req = DeleteDomain.new({:name => 'my_domain'}, {:account => 'account', :secret => 'secret'})
+    assert_attribute({'Action' => 'DeleteDomain'}, req.uri_query)
+    assert_attribute({'DomainName' => 'my_domain'}, req.uri_query)
+  end
+
+  should "generate all the parameters for a GetAttributes" do
+    req = GetAttributes.new({:name => 'my_item', :attributes => [:first, :second]}, {:account => 'account', :secret => 'secret'})
+    assert_attribute({'Action' => 'GetAttributes'}, req.uri_query)
+    assert_attribute({'ItemName' => 'my_item'}, req.uri_query)
+  end
+
+  should "generate all the parameters for a PutAttributes" do
+    req = PutAttributes.new({:name => 'my_domain', :name => 'my_item'},
+                           {:account => 'account', :secret => 'secret'})
+    req.attributes = {:color => :black, :shape => {:value => :square, :replace => true}}
+    assert_attribute({'Action' => 'PutAttributes'}, req.uri_query)
+    assert_attribute({'ItemName' => 'my_item'}, req.uri_query)
+    shape_index = query_hash(req.uri_query)['Attribute.0.Name'] == 'shape' ? 0 : 1
+    assert_attribute({"Attribute.#{shape_index}.Name" => 'shape'}, req.uri_query)
+    assert_attribute({"Attribute.#{shape_index}.Value" => 'square'}, req.uri_query)
+    assert_attribute({"Attribute.#{shape_index}.Replace" => 'true'}, req.uri_query)
+    color_index = (shape_index - 1).abs
+    assert_attribute({"Attribute.#{color_index}.Name" => 'color'}, req.uri_query)
+    assert_attribute({"Attribute.#{color_index}.Value" => 'black'}, req.uri_query)
+    assert_attribute({"Attribute.#{color_index}.Replace" => nil}, req.uri_query)
+  end
+
+  should "generate all the parameters for a Select" do
+    req = Select.new({:query => 'Select * from my_domain'}, {:account => 'account', :secret => 'secret'})
+    assert_attribute({'Action' => 'Select'}, req.uri_query)
+    assert_attribute({'SelectExpression' => /^Select/}, req.uri_query)
+  end
+
+  should "generate all the parameters for a Query" do
+    req = Query.new({:query => "['Color' = 'blue']", :domain => 'my_domain', :max => 10 }, {:account => 'account', :secret => 'secret'})
+    assert_attribute({'Action' => 'Query'}, req.uri_query)
+    assert_attribute({'QueryExpression' => /Color.*blue/}, req.uri_query)
+  end
+
+end

data/test/aws_sdb_request_test.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class AwsSdbRequestTest < Test::Unit::TestCase
+
+  include AwsSdb::Request
+
+  def setup
+    ENV['AMAZON_ACCESS_KEY_ID'] = 'a'
+    ENV['AMAZON_SECRET_ACCESS_KEY'] = 'a'
+  end
+
+  should "prepend the verb and host to the params for signing" do
+    req = Base.new('GET', 'Action' => 'ListDomains')
+    assert_match /^GET\n#{AwsSdb::Request::Base::HOST}/, req.send(:data_to_sign)
+  end
+
+  should "build the query and sort alphabetically the parameters" do
+    req = Base.new('GET', 'b' => '2', 'x' => '1', 'a' => '1')
+    assert_match /a=1&b=2&x=1/, req.send(:params_query)
+  end
+
+  should "url encode the param values" do
+    safe_chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_.~"
+    some_unsafe_chars = "+*!@£$%^&*()"
+    req = Base.new('GET', 'SafeChars' => safe_chars, 'UnsafeChars' => some_unsafe_chars)
+    assert_attribute({'SafeChars' => safe_chars}, req.send(:params_query))
+    assert_attribute({'UnsafeChars' => '%2B%2A%21%40%C2%A3%24%25%5E%26%2A%28%29'}, req.send(:params_query))
+  end
+
+  should "append the signature method to the request" do
+    req = Base.new('GET', {'a' => '1'}, {:account => 'account', :secret => 'secret'})
+    assert_match /&SignatureMethod=HmacSHA256&SignatureVersion=2/, req.uri_query
+  end
+
+  should "add the actual signature" do
+    req = Base.new('GET', {'a' => '1'}, {:account => 'account', :secret => 'secret'})
+    assert_attribute({'Signature' => /^[0-9a-zA-Z%]+$/}, req.uri_query)
+  end
+
+  should "build a correct uri" do
+    req = Base.new('GET', {'a' => '1'}, {:account => 'account', :secret => 'secret'})
+    assert URI.parse(req.uri)
+  end
+
+end

data/test/aws_sdb_response_test.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+require File.join(File.dirname(__FILE__), 'samples/responses')
+
+ENV['PARSER'] ||= 'hpricot'
+
+require ENV['PARSER']
+
+class AwsSdbRequestTest < Test::Unit::TestCase
+
+  include AwsSdb
+
+  context "parsing a GetAttributes" do
+
+    should "generate the attributes hash" do
+      response = Response.parse(SAMPLE_RESPONSES['GetAttributes'])
+      assert_same_elements ["20:45:22", "22:50:25", "22:51:06", "20:44:30", "20:44:19",
+      "22:50:55", "22:49:55", "20:30:08", "22:51:02"],  response.attributes['last_visit']
+      assert_equal ['62'], response.attributes['code']
+    end
+
+  end
+
+  context "parsing a Select" do
+
+    should "generate the items hash" do
+      response = Response.parse(SAMPLE_RESPONSES['Select'])
+      assert_same_elements ["bar81", "bar83", "bar98", "my_entity5"],  response.items.keys
+    end
+
+    should "generate the attributes for each item" do
+      response = Response.parse(SAMPLE_RESPONSES['Select'])
+      assert_equal({"code" => ["48"], "foo" => ["value"]}, response.items['bar98'])
+    end
+
+  end
+
+  context "parsing a Query" do
+
+    should "generate the item names array" do
+      response = Response.parse(SAMPLE_RESPONSES['Query'])
+      assert_same_elements ["bar81", "bar83", "bar98", "my_entity5"],  response.item_names
+    end
+
+  end
+
+  context "parsing a QueryWithAttributes" do
+
+    should "generate the items hash" do
+      response = Response.parse(SAMPLE_RESPONSES['QueryWithAttributes'])
+      assert_equal({"code" => ["48"], "foo" => ["value"]}, response.items['bar98'])
+    end
+
+  end
+
+  context "parsing a response with token" do
+
+    should "find and return the token" do
+      response = Response.parse(SAMPLE_RESPONSES['ResWithToken'])
+      assert_equal "rO0ABXNyACdjb20uYW1hem9uLnNkcy5RdWVyeVByb2Nlc3Nvci5Nb3JlVG9rZW7racXLnINNqwMA\nCkkAFGluaXRpYWxDb25qdW5jdEluZGV4WgAOaXNQYWdlQm91bmRhcnlKAAxsYXN0RW50aXR5SURa\nAApscnFFbmFibGVkSQAPcXVlcnlDb21wbGV4aXR5SgATcXVlcnlTdHJpbmdDaGVja3N1bUkACnVu\naW9uSW5kZXhaAA11c2VRdWVyeUluZGV4TAASbGFzdEF0dHJpYnV0ZVZhbHVldAASTGphdmEvbGFu\nZy9TdHJpbmc7TAAJc29ydE9yZGVydAAvTGNvbS9hbWF6b24vc2RzL1F1ZXJ5UHJvY2Vzc29yL1F1\nZXJ5JFNvcnRPcmRlcjt4cAAAAAAATZbLYbTOwAAAAAAAAAAAAAArd5WtAAAAAAF0AAI0M35yAC1j\nb20uYW1hem9uLnNkcy5RdWVyeVByb2Nlc3Nvci5RdWVyeSRTb3J0T3JkZXIAAAAAAAAAABIAAHhy\nAA5qYXZhLmxhbmcuRW51bQAAAAAAAAAAEgAAeHB0AAlBU0NFTkRJTkd4", response.token
+    end
+
+  end
+
+  context "parsing ListDomains" do
+
+    should "return the list of domains" do
+      response = Response.parse(SAMPLE_RESPONSES['ListDomains'])
+      assert_same_elements ['myapp_development', 'myapp_production', 'myapp_test', 'test_domain'], response.domains
+    end
+    %w(ListDomains DomainMetadata)
+
+  end
+
+  context "parsing a request" do
+
+    should "return the metadata" do
+      response = Response.parse(SAMPLE_RESPONSES['ListDomains'])
+      assert_equal '0.0000071759', response.metadata.box_usage
+    end
+    %w(ListDomains DomainMetadata)
+
+  end
+
+  context "parsing DomainMetadata" do
+
+    should "provide direct acceess to attributes" do
+      response = Response.parse(SAMPLE_RESPONSES['DomainMetadata'])
+      assert_equal 282, response.item_count
+      assert_equal 7237, response.item_names_size_bytes
+      assert_equal 13, response.attribute_name_count
+      assert_equal 92, response.attribute_names_size_bytes
+      assert_equal 1095, response.attribute_value_count
+      assert_equal 5689, response.attribute_values_size_bytes
+      assert_equal 1241131496, response.timestamp
+    end
+
+  end
+
+  context "parsing simple responses" do
+
+    %w(CreateDomain DeleteDomain PutAttributes BatchPutAttributes DeleteAttributes).each do |simple_request|
+
+      should "recognize #{simple_request}" do
+        assert_nothing_raised { Response.parse(SAMPLE_RESPONSES[simple_request]) }
+      end
+
+    end
+
+  end
+
+end

data/test/samples/responses.rb

@@ -0,0 +1,27 @@
+SAMPLE_RESPONSES = {
+'GetAttributes' =>
+"<?xml version=\"1.0\"?>\n<GetAttributesResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><GetAttributesResult><Attribute><Name>code</Name><Value>62</Value></Attribute><Attribute><Name>last_visit</Name><Value>20:30:08</Value></Attribute><Attribute><Name>last_visit</Name><Value>20:44:19</Value></Attribute><Attribute><Name>last_visit</Name><Value>20:44:30</Value></Attribute><Attribute><Name>last_visit</Name><Value>20:45:22</Value></Attribute><Attribute><Name>last_visit</Name><Value>22:49:55</Value></Attribute><Attribute><Name>last_visit</Name><Value>22:50:25</Value></Attribute><Attribute><Name>last_visit</Name><Value>22:50:55</Value></Attribute><Attribute><Name>last_visit</Name><Value>22:51:02</Value></Attribute><Attribute><Name>last_visit</Name><Value>22:51:06</Value></Attribute></GetAttributesResult><ResponseMetadata><RequestId>0d5da91d-e2c4-1de0-7106-cc1d08bf0e8f</RequestId><BoxUsage>0.0000093282</BoxUsage></ResponseMetadata></GetAttributesResponse>",
+'Select' => 
+"<?xml version=\"1.0\"?>\n<SelectResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><SelectResult><Item><Name>my_entity5</Name><Attribute><Name>last_visit</Name><Value>12:58:53</Value></Attribute><Attribute><Name>last_visit</Name><Value>13:13:05</Value></Attribute><Attribute><Name>last_visit</Name><Value>13:13:22</Value></Attribute><Attribute><Name>last_visit</Name><Value>21:45:29</Value></Attribute><Attribute><Name>last_visit</Name><Value>22:11:18</Value></Attribute><Attribute><Name>code</Name><Value>16</Value></Attribute></Item><Item><Name>bar83</Name><Attribute><Name>code</Name><Value>43</Value></Attribute></Item><Item><Name>bar81</Name><Attribute><Name>foo</Name><Value>value</Value></Attribute><Attribute><Name>code</Name><Value>44</Value></Attribute></Item><Item><Name>bar98</Name><Attribute><Name>foo</Name><Value>value</Value></Attribute><Attribute><Name>code</Name><Value>48</Value></Attribute></Item></SelectResult><ResponseMetadata><RequestId>0201e630-dea7-8c4e-88ad-d76cc297388c</RequestId><BoxUsage>0.0000503747</BoxUsage></ResponseMetadata></SelectResponse>",
+'Query' => 
+"<?xml version=\"1.0\"?>\n<QueryResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><QueryResult><ItemName>my_entity5</ItemName><ItemName>bar83</ItemName><ItemName>bar81</ItemName><ItemName>bar98</ItemName></QueryResult><ResponseMetadata><RequestId>48de733e-b08d-7aeb-b855-e08e376da538</RequestId><BoxUsage>0.0000140320</BoxUsage></ResponseMetadata></QueryResponse>",
+'QueryWithAttributes' =>
+"<?xml version=\"1.0\"?>\n<QueryWithAttributesResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><QueryWithAttributesResult><Item><Name>my_entity5</Name><Attribute><Name>last_visit</Name><Value>12:58:53</Value></Attribute><Attribute><Name>last_visit</Name><Value>13:13:05</Value></Attribute><Attribute><Name>last_visit</Name><Value>13:13:22</Value></Attribute><Attribute><Name>last_visit</Name><Value>21:45:29</Value></Attribute><Attribute><Name>last_visit</Name><Value>22:11:18</Value></Attribute><Attribute><Name>code</Name><Value>16</Value></Attribute></Item><Item><Name>bar83</Name><Attribute><Name>code</Name><Value>43</Value></Attribute></Item><Item><Name>bar81</Name><Attribute><Name>foo</Name><Value>value</Value></Attribute><Attribute><Name>code</Name><Value>44</Value></Attribute></Item><Item><Name>bar98</Name><Attribute><Name>foo</Name><Value>value</Value></Attribute><Attribute><Name>code</Name><Value>48</Value></Attribute></Item></QueryWithAttributesResult><ResponseMetadata><RequestId>d849662b-b02b-f0b8-45d2-e13685d10026</RequestId><BoxUsage>0.0000503747</BoxUsage></ResponseMetadata></QueryWithAttributesResponse>",
+'CreateDomain' =>
+"<?xml version=\"1.0\"?>\n<CreateDomainResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><ResponseMetadata><RequestId>606100ad-9b94-9e55-09f5-21de864591f2</RequestId><BoxUsage>0.0055590278</BoxUsage></ResponseMetadata></CreateDomainResponse>",
+'DeleteDomain' =>
+"<?xml version=\"1.0\"?>\n<DeleteDomainResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><ResponseMetadata><RequestId>ba116912-8684-41fd-b60f-87dda3a6d301</RequestId><BoxUsage>0.0055590278</BoxUsage></ResponseMetadata></DeleteDomainResponse>",
+'PutAttributes' =>
+"<?xml version=\"1.0\"?>\n<PutAttributesResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><ResponseMetadata><RequestId>9583937f-4127-20c8-d34c-bd44a676afad</RequestId><BoxUsage>0.0000219923</BoxUsage></ResponseMetadata></PutAttributesResponse>",
+'BatchPutAttributes' =>
+"<?xml version=\"1.0\"?>\n<BatchPutAttributesResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><ResponseMetadata><RequestId>ab252f42-e5f5-dca5-9aa9-f695cc1fb113</RequestId><BoxUsage>0.0000307892</BoxUsage></ResponseMetadata></BatchPutAttributesResponse>",
+'DeleteAttributes' =>
+"<?xml version=\"1.0\"?>\n<DeleteAttributesResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><ResponseMetadata><RequestId>cafe7877-cc29-8c41-fa68-f14101665b3a</RequestId><BoxUsage>0.0000219907</BoxUsage></ResponseMetadata></DeleteAttributesResponse>",
+'ResWithToken' =>
+"<?xml version=\"1.0\"?>\n<QueryWithAttributesResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><QueryWithAttributesResult><Item><Name>bar83</Name><Attribute><Name>code</Name><Value>43</Value></Attribute></Item><NextToken>rO0ABXNyACdjb20uYW1hem9uLnNkcy5RdWVyeVByb2Nlc3Nvci5Nb3JlVG9rZW7racXLnINNqwMA\nCkkAFGluaXRpYWxDb25qdW5jdEluZGV4WgAOaXNQYWdlQm91bmRhcnlKAAxsYXN0RW50aXR5SURa\nAApscnFFbmFibGVkSQAPcXVlcnlDb21wbGV4aXR5SgATcXVlcnlTdHJpbmdDaGVja3N1bUkACnVu\naW9uSW5kZXhaAA11c2VRdWVyeUluZGV4TAASbGFzdEF0dHJpYnV0ZVZhbHVldAASTGphdmEvbGFu\nZy9TdHJpbmc7TAAJc29ydE9yZGVydAAvTGNvbS9hbWF6b24vc2RzL1F1ZXJ5UHJvY2Vzc29yL1F1\nZXJ5JFNvcnRPcmRlcjt4cAAAAAAATZbLYbTOwAAAAAAAAAAAAAArd5WtAAAAAAF0AAI0M35yAC1j\nb20uYW1hem9uLnNkcy5RdWVyeVByb2Nlc3Nvci5RdWVyeSRTb3J0T3JkZXIAAAAAAAAAABIAAHhy\nAA5qYXZhLmxhbmcuRW51bQAAAAAAAAAAEgAAeHB0AAlBU0NFTkRJTkd4</NextToken></QueryWithAttributesResult><ResponseMetadata><RequestId>5f1cd665-843a-17df-bb07-8c3a3bbbcbdd</RequestId><BoxUsage>0.0000228636</BoxUsage></ResponseMetadata></QueryWithAttributesResponse>",
+'DomainMetadata' =>
+"<?xml version=\"1.0\"?>\n<DomainMetadataResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><DomainMetadataResult><ItemCount>282</ItemCount><ItemNamesSizeBytes>7237</ItemNamesSizeBytes><AttributeNameCount>13</AttributeNameCount><AttributeNamesSizeBytes>92</AttributeNamesSizeBytes><AttributeValueCount>1095</AttributeValueCount><AttributeValuesSizeBytes>5689</AttributeValuesSizeBytes><Timestamp>1241131496</Timestamp></DomainMetadataResult><ResponseMetadata><RequestId>fdca49d6-5d0c-1006-5571-648d29e7f183</RequestId><BoxUsage>0.0000071759</BoxUsage></ResponseMetadata></DomainMetadataResponse>",
+'ListDomains' =>
+"<?xml version=\"1.0\"?>\n<ListDomainsResponse xmlns=\"http://sdb.amazonaws.com/doc/2007-11-07/\"><ListDomainsResult><DomainName>myapp_development</DomainName><DomainName>myapp_production</DomainName><DomainName>myapp_test</DomainName><DomainName>test_domain</DomainName></ListDomainsResult><ResponseMetadata><RequestId>f79cd7ab-5f1e-4a32-5a90-de630ed679b8</RequestId><BoxUsage>0.0000071759</BoxUsage></ResponseMetadata></ListDomainsResponse>"
+
+}

data/test/test_helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'aws_sdb_bare'
+
+class Test::Unit::TestCase
+
+  def assert_attribute(attribute_hash, query_string)
+    query_hash = query_hash(query_string)
+    attribute_hash.keys.each do |key|
+      method = attribute_hash[key].is_a?(Regexp) ? :assert_match : :assert_equal
+      send(method, attribute_hash[key], query_hash[key])
+    end
+  end
+
+  def query_hash(query_string)
+    query_hash = query_string.split('&').inject({}) do |hash, token|
+      key, value = *token.split('=')
+      hash[key] = value
+      hash
+    end
+  end
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: aws_sdb_bare
+version: !ruby/object:Gem::Version 
+  version: 1.2.0
+platform: ruby
+authors: 
+- Paolo Negri
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-20 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: hungryblank@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- aws_sdb_bare.gemspec
+- lib/aws_sdb_bare.rb
+- lib/aws_sdb_bare/request.rb
+- lib/aws_sdb_bare/response.rb
+- test/aws_sdb_request_template_test.rb
+- test/aws_sdb_request_test.rb
+- test/aws_sdb_response_test.rb
+- test/samples/responses.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/hungryblank/aws_sdb_bare
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Amazon AWS SDB SimpleDB client library, low level and http lib agnostic
+test_files: 
+- test/test_helper.rb
+- test/aws_sdb_request_test.rb
+- test/samples/responses.rb
+- test/aws_sdb_response_test.rb
+- test/aws_sdb_request_template_test.rb