mct-amazon-ecs 0.5.7

data/CHANGELOG

@@ -0,0 +1,29 @@
+0.5.5 2009-07-10
+----------------
+* Added function of managing new request authentication
+
+0.5.4 2008-01-02
+----------------
+* Add Response#error_code
+
+0.5.3 2007-09-12
+----------------
+* send_request to use default options.
+
+0.5.2 2007-09-08
+----------------
+* Fixed Amazon::Element.get_unescaped error when result returned for given element path is nil
+
+0.5.1 2007-02-08
+----------------
+* Fixed Amazon Japan and France URL error
+* Removed opts.delete(:search_index) from item_lookup, SearchIndex param is allowed 
+  when looking for a book with IdType other than the ASIN.
+* Check for defined? RAILS_DEFAULT_LOGGER to avoid exception for non-rails ruby app
+* Added check for LOGGER constant if RAILS_DEFAULT_LOGGER is not defined
+* Added Ecs.configure(&proc) method for easier configuration of default options
+* Added Element#search_and_convert method
+
+0.5.0 2006-09-12
+----------------
+Initial Release

data/README

@@ -0,0 +1,97 @@
+== amazon-ecs
+
+Generic Amazon E-commerce REST API using Hpricot with configurable 
+default options and method call options. Uses Response and 
+Element wrapper classes for easy access to REST XML output. It supports ECS 4.0.
+
+It is generic, so you can easily extend <tt>Amazon::Ecs</tt> to support 
+other not implemented REST operations; and it is also generic because it just wraps around
+Hpricot element object, instead of providing one-to-one object/attributes to XML elements map.
+
+If in the future, there is a change in REST XML output structure, 
+no changes will be required on <tt>amazon-ecs</tt> library, 
+instead you just need to change the element path.
+
+Version: 0.5.5
+
+== INSTALLATION
+
+  $ gem install amazon-ecs
+
+== EXAMPLE
+
+    require 'amazon/ecs'
+	
+    # set the default options; options will be camelized and converted to REST request parameters.
+    Amazon::Ecs.options = {:aWS_access_key_id => [your developer token]}
+
+    # options provided on method call will merge with the default options
+    res = Amazon::Ecs.item_search('ruby', {:response_group => 'Medium', :sort => 'salesrank'})
+
+    # some common response object methods
+    res.is_valid_request?     # return true if request is valid
+    res.has_error?            # return true if there is an error
+    res.error                 # return error message if there is any
+    res.total_pages           # return total pages
+    res.total_results         # return total results
+    res.item_page             # return current page no if :item_page option is provided
+
+    # traverse through each item (Amazon::Element)
+    res.items.each do |item|
+      # retrieve string value using XML path
+      item.get('asin')
+      item.get('itemattributes/title')
+
+      # or return Amazon::Element instance
+      atts = item.search_and_convert('itemattributes')
+      atts.get('title')
+  
+      # return first author or a string array of authors
+      atts.get('author')          # 'Author 1'
+      atts.get_array('author')    # ['Author 1', 'Author 2', ...]
+  
+      # return an hash of children text values with the element names as the keys
+      item.get_hash('smallimage') # {:url => ..., :width => ..., :height => ...}
+  
+      # note that '/' returns Hpricot::Elements array object, nil if not found
+      reviews = item/'editorialreview'
+  
+      # traverse through Hpricot elements
+      reviews.each do |review|
+        # Getting hash value out of Hpricot element
+        Amazon::Element.get_hash(review) # [:source => ..., :content ==> ...]
+    
+        # Or to get unescaped HTML values
+        Amazon::Element.get_unescaped(review, 'source')
+        Amazon::Element.get_unescaped(review, 'content')
+        
+        # Or this way
+        el = Amazon::Element.new(review)
+        el.get_unescaped('source')
+        el.get_unescaped('content')
+      end
+      
+      # returns Amazon::Element instead of string
+      item.search_and_convert('itemattributes').
+    end
+
+Refer to Amazon ECS documentation for more information on Amazon REST request parameters and XML output:
+http://docs.amazonwebservices.com/AWSEcommerceService/2006-09-13/
+
+To get a sample of Amazon REST response XML output, use AWSZone.com scratch pad:
+http://www.awszone.com/scratchpads/aws/ecs.us/index.aws
+
+== SOURCE CODES
+
+* http://github.com/jugend/amazon-ecs/tree/master
+
+== LINKS
+
+* http://amazon-ecs.rubyforge.org
+* http://www.pluitsolutions.com/amazon-ecs
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2006 Herryanto Siatono, Pluit Solutions

data/lib/amazon-ecs.rb

@@ -0,0 +1,5 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'amazon/aws_product_sign'
+require 'amazon/ecs'

data/lib/amazon/aws_product_sign.rb

@@ -0,0 +1,149 @@
+  require 'rubygems'
+  require 'cgi'
+  require 'time'
+  require 'hmac'
+  require 'hmac-sha2'
+  require 'base64'  
+  
+# Code to sign a request to Amazon Product Advertising API (formerly known as
+# the AWS ECommerce Service), as per the specs at:
+# http://docs.amazonwebservices.com/AWSECommerceService/latest/DG/index.html?RequestAuthenticationArticle.html
+#
+# This code based heavily on that at: http://chrisroos.co.uk/blog/2009-01-31-implementing-version-2-of-the-amazon-aws-http-request-signature-in-ruby
+# Thanks Chris!
+#
+#  Example:
+#
+#  aws_signer = AwsProductSign(:access_key => "00000000000000000000", :secret_key => "1234567890")
+#  params =  {
+#      "Service" => "AWSECommerceService",      
+#      "Operation"=>"ItemLookup",
+#      "ItemId"=>"0679722769",
+#      "ResponseGroup"=>"ItemAttributes,Offers,Images,Reviews"
+#    }
+#  query_string = aws_signer.query_with_signature(  params   )
+#
+#  params will have a Timestamp AWSAccessKeyId added to it, unless input
+#  already had it.
+#
+#  Or you can get back a params hash instead of an encoded query string.
+#  Beware that the Signature parameter must be URL-encoded precisely, and
+#  not over-encoded: "the final signature you send in the request must be URL
+#  encoded as specified in RFC 3986
+
+#  Then you can go on to use those new params in rails url_for or the URI
+#  builder of your choice. Values are not URI-escaped yet. Or mutate the
+#  params passsed in with #add_signature! instead. 
+#
+#  Returning a new params hash, leaving your input untouched:
+#
+#  query_string_component = aws_signer.add_signature( params )
+#
+#  Or mutate your input:
+#  aws_signer.add_signature!(params)
+#
+#
+# At the moment this class can't handle a query string where you need the same
+# key twice. I don't think the AWS service ever uses that though?
+#
+# This class also assumes a GET request. 
+module Amazon
+  class AwsProductSign  
+  
+    def initialize(options = {})
+      @secret_key = options[:secret_key]
+      raise Exception.new("You must supply a :secret_key") unless @secret_key
+      @access_key = options[:access_key]
+    end
+
+    def query_with_signature(hash)
+      return hash_to_query( add_signature(hash)  )
+    end
+  
+    # Pass in a hash representing params for a query string.  
+    # param keys should be strings, not symbols please.
+    # Will return a param with the "Signature" key/value added, without
+    # modifying original. 
+    def add_signature(params)
+      # Make a copy to not modify original  
+      add_signature!( Hash[params]  )
+    end
+  
+    # Like #add_signature, but will mutate the hash passed in, 
+    # adding a "Signature" key/value to hash passed in, and return
+    # hash too.  
+    def add_signature!(params)
+    
+      # supply timestamp and access key if not already provided
+      params["Timestamp"] ||= Time.now.iso8601
+      params["AWSAccessKeyId"] ||= access_key
+      # Existing "Signature"? That's gotta go before we generate a new
+      # signature and add it. 
+      params.delete("Signature")
+
+      query_string = canonical_querystring(params)
+
+      string_to_sign = string_to_sign(query_string)
+
+      hmac = HMAC::SHA256.new( secret_key )
+      hmac.update( string_to_sign )
+      # chomp is important!  the base64 encoded version will have a newline at the end
+      signature = Base64.encode64(hmac.digest).chomp 
+
+      params["Signature"] = signature
+
+      #order doesn't matter for the actual request, we return the hash
+      #and let client turn it into a url.
+      return params
+    end
+
+    # Insist on specific method of URL encoding, RFC3986. 
+    def url_encode(string)
+      # It's kinda like CGI.escape, except CGI.escape is encoding a tilde when
+      # it ought not to be, so we turn it back. Also space NEEDS to be %20 not +.
+      return CGI.escape(string).gsub("%7E", "~").gsub("+", "%20")
+    end
+
+    # param keys should be strings, not symbols please. return a string joined
+    # by & in canonical order. 
+    def canonical_querystring(params)
+      # I hope this built-in sort sorts by byte order, that's what's required. 
+      values = params.keys.sort.collect {|key|  [url_encode(key), url_encode(params[key].to_s)].join("=") }
+    
+      return values.join("&")
+    end
+
+    def string_to_sign(query_string, options = {})
+      options[:verb] = "GET"
+      options[:request_uri] = "/onca/xml"
+      options[:host] = "webservices.amazon.com"
+
+    
+      return options[:verb] + "\n" + 
+          options[:host].downcase + "\n" +
+          options[:request_uri] + "\n" +
+          query_string
+    end
+
+    # Turns a hash into a query string, returns the query string.
+    # url-encodes everything to Amazon's specifications. 
+    def hash_to_query(hash)
+      hash.collect do |key, value|
+      
+        url_encode(key) + "=" + url_encode(value)
+    
+      end.join("&")
+    end
+
+    def secret_key
+      return @secret_key
+    end
+    def access_key
+      return @access_key
+    end
+    def access_key=(a)
+      @access_key = a
+    end
+  
+  end
+end

data/lib/amazon/ecs.rb

@@ -0,0 +1,326 @@
+#--
+# Copyright (c) 2006 Herryanto Siatono, Pluit Solutions
+#
+# 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.
+#++
+
+
+require 'net/http'
+require 'hpricot'
+require 'cgi'
+require 'openssl'
+require 'uri'
+require 'digest/sha2'
+require 'base64'
+
+module Amazon
+  class RequestError < StandardError; end
+  
+  class Ecs
+    SERVICE_URLS = {:us => 'http://webservices.amazon.com/onca/xml',
+        :uk => 'http://webservices.amazon.co.uk/onca/xml',
+        :ca => 'http://webservices.amazon.ca/onca/xml',
+        :de => 'http://webservices.amazon.de/onca/xml',
+        :jp => 'http://webservices.amazon.co.jp/onca/xml',
+        :fr => 'http://webservices.amazon.fr/onca/xml'
+    }
+    
+    @@options = {}
+    @@debug = false
+
+    # Default search options
+    def self.options
+      @@options
+    end
+    
+    # Set default search options
+    def self.options=(opts)
+      @@options = opts
+    end
+    
+    # Get debug flag.
+    def self.debug
+      @@debug
+    end
+    
+    # Set debug flag to true or false.
+    def self.debug=(dbg)
+      @@debug = dbg
+    end
+    
+    def self.configure(&proc)
+      raise ArgumentError, "Block is required." unless block_given?
+      yield @@options
+    end
+    
+    # Search amazon items with search terms. Default search index option is 'Books'.
+    # For other search type other than keywords, please specify :type => [search type param name].
+    def self.item_search(terms, opts = {})
+      opts[:operation] = 'ItemSearch'
+      opts[:search_index] = opts[:search_index] || 'Books'
+      
+      type = opts.delete(:type)
+      if type 
+        opts[type.to_sym] = terms
+      else 
+        opts[:keywords] = terms
+      end
+      
+      self.send_request(opts)
+    end
+
+    # Search an item by ASIN no.
+    def self.item_lookup(item_id, opts = {})
+      opts[:operation] = 'ItemLookup'
+      opts[:item_id] = item_id
+      
+      self.send_request(opts)
+    end    
+          
+    # Generic send request to ECS REST service. You have to specify the :operation parameter.
+    def self.send_request(opts)
+      opts = self.options.merge(opts) if self.options
+      request_url = prepare_url(opts)
+      log "Request URL: #{request_url}"
+      
+      res = Net::HTTP.get_response(URI::parse(request_url))
+      unless res.kind_of? Net::HTTPSuccess
+        raise Amazon::RequestError, "HTTP Response: #{res.code} #{res.message}"
+      end
+      Response.new(res.body)
+    end
+
+    # Response object returned after a REST call to Amazon service.
+    class Response
+      # XML input is in string format
+      def initialize(xml)
+        @doc = Hpricot(xml)
+      end
+
+      # Return Hpricot object.
+      def doc
+        @doc
+      end
+
+      # Return true if request is valid.
+      def is_valid_request?
+        (@doc/"isvalid").inner_html == "True"
+      end
+
+      # Return true if response has an error.
+      def has_error?
+        !(error.nil? || error.empty?)
+      end
+
+      # Return error message.
+      def error
+        Element.get(@doc, "error/message")
+      end
+      
+      # Return error code
+      def error_code
+        Element.get(@doc, "error/code")
+      end
+      
+      # Return an array of Amazon::Element item objects.
+      def items
+        unless @items
+          @items = (@doc/"item").collect {|item| Element.new(item)}
+        end
+        @items
+      end
+      
+      # Return the first item (Amazon::Element)
+      def first_item
+        items.first
+      end
+      
+      # Return current page no if :item_page option is when initiating the request.
+      def item_page
+        unless @item_page
+          @item_page = (@doc/"itemsearchrequest/itempage").inner_html.to_i
+        end
+        @item_page
+      end
+
+      # Return total results.
+      def total_results
+        unless @total_results
+          @total_results = (@doc/"totalresults").inner_html.to_i
+        end
+        @total_results
+      end
+      
+      # Return total pages.
+      def total_pages
+        unless @total_pages
+          @total_pages = (@doc/"totalpages").inner_html.to_i
+        end
+        @total_pages
+      end
+    end
+    
+    protected
+      def self.log(s)
+        return unless self.debug
+        if defined? RAILS_DEFAULT_LOGGER
+          RAILS_DEFAULT_LOGGER.error(s)
+        elsif defined? LOGGER
+          LOGGER.error(s)
+        else
+          puts s
+        end
+      end
+      
+    private 
+    def self.prepare_url(opts)
+      country = opts.delete(:country) || 'us'
+      request_url = SERVICE_URLS[country.to_sym]
+      raise Amazon::RequestError, "Invalid country '#{country}'" unless request_url
+      
+      access_key_id = opts.delete(:aWS_access_key_id)
+      secret_access_key = opts.delete(:secret_access_key)
+      raise Amazon::RequestError, "secret_access_key is nil" unless secret_access_key
+      
+      opts = Hash[*opts.map { |k, v| [camelize(k.to_s), v.to_s] }.flatten]
+      
+      aws_signer = AwsProductSign.new(:access_key => access_key_id, :secret_key => secret_access_key)
+      qs = aws_signer.query_with_signature(opts)
+
+      "#{request_url}?#{qs}"
+    end
+
+    IPAD = "\x36"
+    OPAD = "\x5c"
+    def self.hmac_sha256(key, message)
+      ikey = IPAD * 64
+      okey = OPAD * 64
+      key.size.times do |i|
+        ikey[i] = key[i] ^ ikey[i]
+        okey[i] = key[i] ^ okey[i]
+      end
+      value = Digest::SHA256.digest(ikey + message)
+      value = Digest::SHA256.digest(okey + value)
+    end
+
+    def self.camelize(s)
+      s.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+  end
+
+  # Internal wrapper class to provide convenient method to access Hpricot element value.
+  class Element
+    # Pass Hpricot::Elements object
+    def initialize(element)
+      @element = element
+    end
+
+    # Returns Hpricot::Elments object    
+    def elem
+      @element
+    end
+    
+    # Find Hpricot::Elements matching the given path. Example: element/"author".
+    def /(path)
+      elements = @element/path
+      return nil if elements.size == 0
+      elements
+    end
+    
+    # Find Hpricot::Elements matching the given path, and convert to Amazon::Element.
+    # Returns an array Amazon::Elements if more than Hpricot::Elements size is greater than 1.
+    def search_and_convert(path)
+      elements = self./(path)
+      return unless elements
+      elements = elements.map{|element| Element.new(element)}
+      return elements.first if elements.size == 1
+      elements
+    end
+
+    # Get the text value of the given path, leave empty to retrieve current element value.
+    def get(path='')
+      Element.get(@element, path)
+    end
+    
+    # Get the unescaped HTML text of the given path.
+    def get_unescaped(path='')
+      Element.get_unescaped(@element, path)
+    end
+    
+    # Get the array values of the given path.
+    def get_array(path='')
+      Element.get_array(@element, path)
+    end
+
+    # Get the children element text values in hash format with the element names as the hash keys.
+    def get_hash(path='')
+      Element.get_hash(@element, path)
+    end
+
+    # Similar to #get, except an element object must be passed-in.
+    def self.get(element, path='')
+      return unless element
+      result = element.at(path)
+      result = result.inner_html if result
+      result
+    end
+    
+    # Similar to #get_unescaped, except an element object must be passed-in.    
+    def self.get_unescaped(element, path='')
+      result = get(element, path)
+      CGI::unescapeHTML(result) if result
+    end
+
+    # Similar to #get_array, except an element object must be passed-in.
+    def self.get_array(element, path='')
+      return unless element
+      
+      result = element/path
+      if (result.is_a? Hpricot::Elements) || (result.is_a? Array)
+        parsed_result = []
+        result.each {|item|
+          parsed_result << Element.get(item)
+        }
+        parsed_result
+      else
+        [Element.get(result)]
+      end
+    end
+
+    # Similar to #get_hash, except an element object must be passed-in.
+    def self.get_hash(element, path='')
+      return unless element
+    
+      result = element.at(path)
+      if result
+        hash = {}
+        result = result.children
+        result.each do |item|
+          hash[item.name.to_sym] = item.inner_html
+        end 
+        hash
+      end
+    end
+    
+    def to_s
+      elem.to_s if elem
+    end
+  end
+end

data/test/amazon/aws_product_sign_test.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Example used for testing is from
+# http://docs.amazonwebservices.com/AWSECommerceService/latest/DG/rest-signature.html
+# Although that example itself has some bugs as of 12 may 09 doh.
+# it's output isn't actually valid.
+#
+class AwsProductSignTest < Test::Unit::TestCase
+
+  def setup
+    @example_params = {
+      "Service" => "AWSECommerceService",      
+      "Operation"=>"ItemLookup",
+      "ItemId"=>"0679722769",
+      "ResponseGroup"=>"ItemAttributes,Offers,Images,Reviews",
+      "Version" => "2009-01-06",
+      "Timestamp" => "2009-05-13T10:43:28-04:00" # fixed timestamp so we can test output
+    }
+    @access_key = "00000000000000000000"
+    @secret_key = "1234567890"
+
+    @test_obj = AwsProductSign.new(:secret_key => @secret_key, :access_key => @access_key)
+  end
+
+  
+  def test_url_encoding
+    # Make sure it doesn't encode what it shouldn't.
+    reserved_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~"
+    assert_equal(reserved_chars, 
+      @test_obj.url_encode(reserved_chars),
+      "Reserved chars are not encoded")
+
+    # Space better be %20 not plus.
+    assert_equal("%20", @test_obj.url_encode(" "), "Space is encoded as %20")
+
+    # Try a sample UTF-8 char, e acute.
+    assert_equal("%C3%A9", 
+      @test_obj.url_encode("\xC3\xA9"),
+      "Encodes a UTF-8 char properly")
+    
+    # Make sure it does escape a few other sample chars, although we won't
+    # try every possible char!
+    chars_to_escape = "%:,/+=" # that last one is a utf-8 e acute.
+
+    assert_equal( "%25%3A%2C%2F%2B%3D", 
+     @test_obj.url_encode(chars_to_escape),
+     "Some other chars are encoded properly")
+  end
+
+  def test_canonical_query_order
+      ordered_keys = 
+       @test_obj.canonical_querystring(@example_params).split("&").collect { |kv| kv.split("=")[0] }
+
+      # should be sorted byte-ordered
+      assert_equal(ordered_keys, 
+        ["ItemId", "Operation", "ResponseGroup", "Service", "Timestamp", "Version"])            
+  end
+
+  def test_add_signature
+    new_params = @test_obj.add_signature( @example_params )
+
+    assert_not_nil( new_params["Timestamp"], "Adds timestamp" )
+    assert_equal( @access_key, new_params["AWSAccessKeyId"], "Adds access key")
+    assert_equal("F3xmBlY91rML36hkQTZn/N2Bk3ABIVB8NI+e/JCYpDQ=" ,     
+        new_params["Signature"],
+        "Adds correct signature")
+
+    assert( @example_params != new_params, "Does not mutate input")    
+  end
+
+  def test_add_signature_mutate
+    params = Hash[@example_params]
+
+    @test_obj.add_signature!(params)
+
+    assert_not_nil( params["Signature"], "Mutates input")
+    
+  end
+
+  def test_query_string
+    require 'cgi'
+    params = @test_obj.add_signature(@example_params)
+    query_string = @test_obj.query_with_signature(params)
+
+    re_parsed = CGI.parse(query_string)
+    # cgi puts everything in an array, flatten it please. 
+    re_parsed.each {|k,v| re_parsed[k] = v.first} 
+
+    assert_equal( params, re_parsed, "query string generated" )
+    
+  end
+  
+end

data/test/amazon/ecs_test.rb

@@ -0,0 +1,110 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class Amazon::EcsTest < Test::Unit::TestCase
+
+  AWS_ACCESS_KEY_ID = '1ZD53WRGR730ZCVWBSG2'
+  raise "Please specify set your AWS_ACCESS_KEY_ID" if AWS_ACCESS_KEY_ID.empty?
+  
+  Amazon::Ecs.configure do |options|
+    options[:response_group] = 'Large'
+    options[:aWS_access_key_id] = AWS_ACCESS_KEY_ID
+  end
+
+  ## Test item_search
+
+  def test_item_search
+    resp = Amazon::Ecs.item_search('ruby')
+    assert(resp.is_valid_request?)
+    assert(resp.total_results >= 3600)
+    assert(resp.total_pages >= 360)
+  end
+
+  def test_item_search_with_paging
+    resp = Amazon::Ecs.item_search('ruby', :item_page => 2)
+    assert resp.is_valid_request?
+    assert 2, resp.item_page
+  end
+
+  def test_item_search_with_invalid_request
+    resp = Amazon::Ecs.item_search(nil)
+    assert !resp.is_valid_request?
+  end
+
+  def test_item_search_with_no_result
+    resp = Amazon::Ecs.item_search('afdsafds')
+    
+    assert resp.is_valid_request?
+    assert_equal "We did not find any matches for your request.", 
+      resp.error
+  end
+  
+  def test_item_search_uk
+    resp = Amazon::Ecs.item_search('ruby', :country => :uk)
+    assert resp.is_valid_request?
+  end
+  
+  def test_item_search_by_author
+    resp = Amazon::Ecs.item_search('dave', :type => :author)
+    assert resp.is_valid_request?
+  end
+  
+  def test_item_get
+    resp = Amazon::Ecs.item_search("0974514055")
+    item = resp.first_item
+        
+    # test get
+    assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition", 
+      item.get("itemattributes/title")
+      
+    # test get_array
+    assert_equal ['Dave Thomas', 'Chad Fowler', 'Andy Hunt'], 
+      item.get_array("author")
+
+    # test get_hash
+    small_image = item.get_hash("smallimage")
+    
+    assert_equal 3, small_image.keys.size
+    assert_match ".jpg", small_image[:url]
+    assert_equal "75", small_image[:height]
+    assert_equal "59", small_image[:width]
+    
+    # test /
+    reviews = item/"editorialreview"
+	reviews.each do |review|
+		# returns unescaped HTML content, Hpricot escapes all text values
+		assert Amazon::Element.get_unescaped(review, 'source')
+		assert Amazon::Element.get_unescaped(review, 'content')
+	end
+  end
+  
+  ## Test item_lookup
+  def test_item_lookup
+    resp = Amazon::Ecs.item_lookup('0974514055')
+    assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition", 
+    resp.first_item.get("itemattributes/title")
+  end
+  
+  def test_item_lookup_with_invalid_request
+    resp = Amazon::Ecs.item_lookup(nil)
+    assert resp.has_error?
+    assert resp.error
+  end
+
+  def test_item_lookup_with_no_result
+    resp = Amazon::Ecs.item_lookup('abc')
+    
+    assert resp.is_valid_request?
+    assert_match(/ABC is not a valid value for ItemId/, resp.error)
+  end  
+  
+  def test_search_and_convert
+    resp = Amazon::Ecs.item_lookup('0974514055')
+    title = resp.first_item.get("itemattributes/title")
+    authors = resp.first_item.search_and_convert("author")
+    
+    assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition", title
+    assert authors.is_a?(Array)
+    assert 3, authors.size
+    assert_equal "Dave Thomas", authors.first.get
+  end  
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: mct-amazon-ecs
+version: !ruby/object:Gem::Version 
+  version: 0.5.7
+platform: ruby
+authors: 
+- Herryanto Siatono
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: 
+description: 
+email: herryanto@pluitsolutions.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+files: 
+- lib/amazon-ecs.rb
+- lib/amazon/aws_product_sign.rb
+- lib/amazon/ecs.rb
+- README
+- CHANGELOG
+has_rdoc: true
+homepage: http://amazon-ecs.rubyforge.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: Generic Amazon E-commerce Service (ECS) REST API. Supports ECS 4.0.
+test_files: 
+- test/amazon/ecs_test.rb
+- test/amazon/aws_product_sign_test.rb