amazon-associates 0.6.3

data/spec/types/item_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Amazon
+  module Associates
+    describe Item do
+      before(:all) do
+        @item = Amazon::Associates::item_lookup("0545010225").item
+      end
+
+      it "should equal anything with the same #asin" do
+        asin = @item.asin
+        @item.should == Struct.new(:asin).new(asin)
+      end
+
+      describe "query for items", :shared => true do
+        it "should return a list of items" do
+          @result.should have_at_least(10).items
+          @result.each {|item| item.should be_an_instance_of(Item) }
+        end
+      end
+
+      describe "query for related items", :shared => true do
+        it_should_behave_like "query for items"
+        it "should not include the item related to the result" do
+          @result.should_not include(@item)
+        end
+      end
+
+      describe ".similar" do
+        before(:all) do
+          @result = Item.similar(@item.asin)
+        end
+        it_should_behave_like "query for related items"
+      end
+
+      describe ".all" do
+        before(:all) do
+          @result = Item.all("search_index"=>"Blended", "keywords"=>"potter")
+        end
+        it_should_behave_like "query for items"
+
+        it "should handle hashes with indifferent access" do
+          Item.all(HashWithIndifferentAccess.new("search_index"=>"Blended", "keywords"=>"hello")).should_not == nil
+        end
+      end
+
+      describe "#similar" do
+        before(:all) do
+          @result = @item.similar
+        end
+        it_should_behave_like "query for related items"
+      end
+    end
+  end
+end

data/spec/types/measurement_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "measurement object", :shared => true do
+  it "should take a quantity and units" do
+    m = measurement_with(:value => 11.3, :units => 'inches')
+    m.value.should == 11.3
+    m.units.should == 'inches'
+  end
+
+  it "should default units to 'pixels', as we use it mostly for images" do
+    m = measurement_with(:value => 22.19)
+    m.value.should == 22.19
+    m.units.should == 'pixels'
+  end
+
+  it "should translate 'hundredths-' units to standard quantities" do
+    m = measurement_with(:value => 1130, :units => 'hundredths-inches')
+    m.value.should == 11.3
+    m.units.should == 'inches'
+  end
+end
+
+describe Amazon::Associates::Measurement do
+  describe "#initialize" do
+    def measurement_with(opts)
+      Amazon::Associates::Measurement.new(*opts.values_at(:value, :units).compact)
+    end
+
+    it_should_behave_like "measurement object"
+  end
+
+  describe "#from_xml" do
+    def measurement_with(opts)
+      doc = ROXML::XML::Document.new
+      doc.root = ROXML::XML::Node.new('width', doc)
+      doc.root.add_child( Nokogiri::XML::Text.new(opts[:value].to_s, doc))
+      doc.root['Units'] = opts[:units] unless opts[:units].blank?
+      Amazon::Associates::Measurement.from_xml(doc.root)
+    end
+
+    it_should_behave_like "measurement object"
+  end
+end

data/test/amazon/browse_node_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class Amazon::Associates::BrowseNodeLookupTest < Test::Unit::TestCase
+  include FilesystemTestHelper
+
+  def setup
+    set_valid_caching_options
+  end
+
+  def test_browse_node_lookup_with_invalid_request
+    assert_raise(Amazon::Associates::RequiredParameterMissing) do
+      Amazon::Associates.browse_node_lookup(nil)
+    end
+  end
+
+  def test_browse_node_lookup_with_no_result
+    assert_raise(Amazon::Associates::InvalidParameterValue) do
+      Amazon::Associates.browse_node_lookup("abc")
+    end
+  end
+
+	def test_items_have_browsenodes
+	  item = Amazon::Associates.item_lookup('B000ROI682', :response_group => 'BrowseNodes').items.first
+	  assert item.browse_nodes.size > 1
+    item.browse_nodes.each do |browsenode|
+	    assert_kind_of Amazon::Associates::BrowseNode, browsenode
+	    assert !browsenode.to_s.include?('&amp;'), browsenode.to_s
+	  end
+	end
+
+  def test_browse_nodes_have_top_sellers
+    assert !Amazon::Associates.browse_node_lookup(:response_group => 'TopSellers', :browse_node_id => 493964).browse_nodes.first.top_sellers.empty?
+  end
+end

data/test/amazon/cache_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module Amazon
+  module Associates
+    class CacheTest < Test::Unit::TestCase
+      include FilesystemTestHelper
+      context "caching get" do
+        setup do
+          set_valid_caching_options(CACHE_TEST_PATH)
+        end
+
+        teardown do
+          reset_cache
+        end
+
+        should "optionally allow for a caching strategy in configuration" do
+          assert_nothing_raised do
+            set_valid_caching_options(CACHE_TEST_PATH)
+          end
+          assert Amazon::Associates.caching_enabled?
+        end
+
+        should "raise an exception if a caching strategy is specified that is not found" do
+          assert_raise Amazon::Associates::ConfigurationError do
+            Amazon::Associates.configure do |options|
+              options[:caching_strategy] = "foo"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/amazon/caching/filesystem_cache_test.rb

@@ -0,0 +1,198 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module Amazon
+  module Associates
+class FilesystemCacheTest < Test::Unit::TestCase
+  include FilesystemTestHelper
+  context "setting up filesystem caching" do
+    teardown do
+      Amazon::Associates.configure do |options|
+        options[:caching_strategy] = nil
+        options[:caching_options] = nil
+      end
+    end
+
+    should "require a caching options hash with a cache_path key" do
+      assert_raise Amazon::Associates::ConfigurationError do
+        Amazon::Associates.configure do |options|
+          options[:caching_strategy] = :filesystem
+          options[:caching_options] = nil
+        end
+      end
+    end
+
+    should "raise an exception when a cache_path is specified that doesn't exist" do
+      assert_raise Amazon::Associates::ConfigurationError do
+        Amazon::Associates.configure do |options|
+          options[:caching_strategy] = :filesystem
+          options[:caching_options] = {:cache_path => "foo123"}
+        end
+      end
+    end
+
+    should "set default values for disk_quota and sweep_frequency" do
+      Amazon::Associates.configure do |options|
+        options[:caching_strategy] = :filesystem
+        options[:caching_options] = {:cache_path => "."}
+      end
+
+      assert_equal Amazon::Associates::FilesystemCache.disk_quota, Amazon::Associates::FilesystemCache.disk_quota
+      assert_equal Amazon::Associates::FilesystemCache.sweep_frequency, Amazon::Associates::FilesystemCache.sweep_frequency
+    end
+
+    should "override the default value for disk quota if I specify one" do
+      quota = 400
+      Amazon::Associates.configure do |options|
+        options[:caching_strategy] = :filesystem
+        options[:caching_options] = {:cache_path => ".", :disk_quota => quota}
+      end
+
+      assert_equal quota, Amazon::Associates::FilesystemCache.disk_quota
+    end
+
+    should "override the default value for cache_frequency if I specify one" do
+      frequency = 4
+      Amazon::Associates.configure do |options|
+        options[:caching_strategy] = :filesystem
+        options[:caching_options] = {:cache_path => ".", :sweep_frequency => frequency}
+      end
+
+      assert_equal frequency, Amazon::Associates::FilesystemCache.sweep_frequency
+    end
+  end
+
+  context "caching a request" do
+
+    setup do
+      set_valid_caching_options(CACHE_TEST_PATH)
+      @resp = Amazon::Associates.item_lookup("0974514055")
+      @filename = Digest::SHA1.hexdigest(@resp.url)
+    end
+
+    teardown do
+      reset_cache
+    end
+
+    should "create a folder in the cache path with the first three letters of the digested filename" do
+      assert FileTest.exists?(File.join(CACHE_TEST_PATH, @filename[0..2]))
+    end
+
+    should "create a file in the cache path with a digested version of the url " do
+      assert FileTest.exists?(File.join(CACHE_TEST_PATH, @filename[0..2], @filename))
+    end
+
+    should "create a file in the cache path with the response inside it" do
+      open(File.join(CACHE_TEST_PATH + @filename[0..2], @filename)) do |f|
+        response = Marshal.load(f)
+        equivalent = eval(ROXML::XML::Parser.parse(response.body).root.name).from_xml(response.body, @resp.url)
+
+        assert_equal @resp, equivalent
+      end
+    end
+
+    should "not attemt to cache cart requests" do
+      Amazon::Associates::FilesystemCache.expects(:cache).never
+
+      resp = Amazon::Associates.cart_create(:items => {"0974514055" => 2})
+      filename = Digest::SHA1.hexdigest(resp.url)
+      assert !FileTest.exists?(File.join(CACHE_TEST_PATH, filename[0..2], filename))
+    end
+  end
+
+  context "getting a cached request" do
+    setup do
+      set_valid_caching_options(CACHE_TEST_PATH)
+      do_request
+    end
+
+    teardown do
+      reset_cache
+    end
+
+    should "not do an http request the second time the lookup is performed due a cached copy" do
+      Net::HTTP.expects(:get_response).never
+      do_request
+    end
+
+    should "return the same response as the original request" do
+      original = @resp
+      do_request
+      assert_equal(original, @resp)
+    end
+
+    should "not include cache parameters in the response" do
+      assert_no_match(/CachingOptions/, @resp.url)
+      assert_no_match(/caching_options/, @resp.url)
+      assert_no_match(/cache_path/, @resp.url)
+      assert_no_match(/disk_quota/, @resp.url)
+    end
+  end
+
+  context "sweeping cached requests" do
+    setup do
+      set_valid_caching_options(CACHE_TEST_PATH)
+      do_request
+    end
+
+    teardown do
+      reset_cache
+    end
+
+    should "not perform the sweep if the timestamp is within the range of the sweep frequency and quota is not exceeded" do
+      Amazon::Associates::FilesystemCache.expects(:sweep_time_expired?).returns(false)
+      Amazon::Associates::FilesystemCache.expects(:disk_quota_exceeded?).returns(false)
+
+      Amazon::Associates::FilesystemCache.expects(:perform_sweep).never
+
+      do_request
+    end
+
+    should "perform a sweep if the quota is exceeded" do
+      Amazon::Associates::FilesystemCache.stubs(:sweep_time_expired?).returns(false)
+      Amazon::Associates::FilesystemCache.expects(:disk_quota_exceeded?).once.returns(true)
+
+      Amazon::Associates::FilesystemCache.expects(:perform_sweep).once
+
+      do_request
+    end
+
+    should "perform a sweep if the sweep time is expired" do
+      Amazon::Associates::FilesystemCache.expects(:sweep_time_expired?).once.returns(true)
+      Amazon::Associates::FilesystemCache.stubs(:disk_quota_exceeded?).returns(false)
+      Amazon::Associates::FilesystemCache.expects(:perform_sweep).once
+
+      do_request
+    end
+
+    should "create a timestamp file after performing a sweep" do
+      Amazon::Associates::FilesystemCache.expects(:sweep_time_expired?).once.returns(true)
+
+      do_request
+      assert FileTest.exists?(File.join(CACHE_TEST_PATH, ".amz_timestamp"))
+    end
+
+    should "purge the cache when performing a sweep" do
+      (0..9).each do |n|
+        test = File.open(File.join(CACHE_TEST_PATH, "test_file_#{n}"), "w")
+        test.puts Time.now
+        test.close
+      end
+
+      Amazon::Associates::FilesystemCache.expects(:sweep_time_expired?).once.returns(true)
+      do_request
+
+      (0..9).each do |n|
+        assert !FileTest.exists?(File.join(CACHE_TEST_PATH, "test_file_#{n}"))
+      end
+    end
+
+  end
+
+  protected
+  def do_request
+    @resp = Amazon::Associates.item_lookup("0974514055")
+  end
+end
+
+  end
+end

data/test/amazon/item_test.rb

@@ -0,0 +1,397 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+module Amazon
+  module Associates
+    class ItemTest < Test::Unit::TestCase
+      include FilesystemTestHelper
+      
+      ## Test item_search
+      def setup
+        set_valid_caching_options
+        @ruby_search = Amazon::Associates.item_search('ruby')
+      end
+
+      def test_item_search
+        assert @ruby_search.request.valid?
+        assert @ruby_search.total_results >= 3600
+        assert @ruby_search.total_pages >= 360
+      end
+
+      def test_page_should_be_one_for_first_page
+        assert_equal 1, @ruby_search.current_page
+      end
+
+      def test_item_search_response_type
+        assert_equal ItemSearchResponse, @ruby_search.class
+      end
+
+      def test_argument_hash
+        assert_equal Hash, @ruby_search.operation_request.arguments.class
+      end
+
+      def test_item_search_with_paging
+        resp = Amazon::Associates.item_search('ruby', :item_page => 2)
+        assert resp.request.valid?
+        assert 2, resp.current_page
+      end
+
+      def test_item_search_with_response_group_array
+        resp = Amazon::Associates.item_search('ruby', :response_group => %w{Small ItemAttributes Images})
+        assert resp.request.valid?
+      end
+
+      def test_item_search_with_invalid_request
+        assert_raise Amazon::Associates::RequiredParameterMissing do
+          Amazon::Associates.item_search(nil)
+        end
+      end
+
+      def test_item_search_with_no_result
+        assert_raise Amazon::Associates::ItemNotFound, ' We did not find any matches for your request.' do
+          Amazon::Associates.item_search('afdsafds')
+        end
+      end
+
+      def test_item_search_uk
+        resp = Amazon::Associates.item_search('ruby', :country => 'uk')
+        assert resp.request.valid?
+      end
+
+      def test_item_search_not_keywords
+        resp = Amazon::Associates.item_search(:author => 'rowling')
+        assert resp.request.valid?
+      end
+
+      def test_item_search_by_author
+        resp = Amazon::Associates.item_search('dave', :type => :author)
+        assert resp.request.valid?
+      end
+
+      def test_text_at
+        item = Amazon::Associates.item_search("0974514055", :response_group => 'Large').items.first
+
+        # one item
+        assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition",
+          item.attributes['Title']
+
+        # multiple items
+        assert_equal ['Dave Thomas', 'Chad Fowler', 'Andy Hunt'],
+          item.authors
+
+        #ordinals
+        assert_equal Amazon::Associates::Ordinal.new(2), item.edition
+      end
+
+      def test_item_search_should_handle_string_argument_keys_as_well_as_symbols
+        Amazon::Associates.item_search('potter', 'search_index' => 'Books')
+      end
+
+      def test_hash_at_handles_specific_types
+        item = Amazon::Associates.item_search('ipod', :search_index => 'All', :response_group => 'Small,Offers,ItemAttributes,VariationSummary,Images,BrowseNodes').items.first
+
+        # Measurements & Image
+        assert_equal(Amazon::Associates::Image.new("http://ecx.images-amazon.com/images/I/41zt-RXYhfL._SL75_.jpg",
+            Amazon::Associates::Measurement.new(56, 'pixels'),
+            Amazon::Associates::Measurement.new(75, 'pixels')),
+          item.small_image)
+
+        # bools
+        assert !item.offers.empty?
+        assert_equal true, item.offers.first.is_eligible_for_super_saver_shipping?
+        assert_equal false, item.batteries_included?
+
+        # price
+        assert_equal Amazon::Associates::Price.new('$249.99', 24999, 'USD'), item.list_price
+
+        # integers
+        assert_instance_of Fixnum, item.total_new_offers
+        assert_instance_of Fixnum, item.total_offers
+
+        # attributes
+        assert item.image_sets['primary'], item.image_sets.inspect
+        assert_equal "Mary GrandPré", Amazon::Associates.item_lookup('0545010225').item.creators['Illustrator']
+
+        # browsenodes
+        nodes = item.browse_nodes.detect {|n| n.name == 'MP3 Players' }
+        assert_equal 'MP3 Players', nodes.name
+        assert_equal 'Audio & Video', nodes.parent.name
+        assert_equal 'Apple', nodes.parent.parent.name
+        assert_equal 'Custom Brands', nodes.parent.parent.parent.name
+
+        # ordinals
+        # in test_text_at, above
+      end
+
+      def test_price_should_handle_price_too_low_to_display
+        assert_equal 'Too low to display', Amazon::Associates.item_lookup('B000W79GQA', :response_group => 'Offers').item.lowest_new_price.to_s
+      end
+
+      def test_hash_at_handles_string_editions
+        Amazon::Associates.item_search("potter", :item_page => 3, :response_group => 'Small,Offers,ItemAttributes,VariationSummary,Images').items.each do |item|
+          assert item
+        end
+      end
+
+      def test_hash_at_makes_arrays_from_lists
+        item = Amazon::Associates.item_search("0974514055", :response_group => 'Large').items.first
+
+        # when <listmanialists> contains a bunch of <listmanialist>s, return an array
+        assert_equal(["R35BVGTHX7WEKZ",  "R195F9SN6I3YQH",  "R14L8RHCLAYQMY",  "RCWKKCCVL5FGL",  "R2IJ2M3X3ITVAR",
+            "R3MGYO2P65FC8J",  "R2VY37TQWQM0VJ",  "R3DB3MYO22PHZ6",  "R192F79G3UXHJ5",  "R1L6QNM215M7FB"],
+          item.listmania_lists.map(&:id))
+
+        review = item.editorial_reviews.first
+        # when there's a single child, make sure it's parsed rather than returned as a string
+        assert_equal "Product Description", review.source
+        assert review.content.is_a?(String)
+        assert review.content.size > 100
+        assert review.content.starts_with?("Ruby is an increasingly popular, fully object-oriented d")
+      end
+
+      ## Test item_lookup
+      def test_item_lookup
+        resp = Amazon::Associates.item_lookup('0974514055')
+        assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition",
+          resp.item.attributes['Title']
+      end
+
+      def test_item_lookup_with_invalid_request
+        assert_raise Amazon::Associates::RequiredParameterMissing, 'Your request is missing required parameters. Required parameters include ItemId.' do
+          Amazon::Associates.item_lookup(nil)
+        end
+      end
+
+      def test_item_lookup_with_no_result
+        assert_raise Amazon::Associates::InvalidParameterValue, 'ABC is not a valid value for ItemId. Please change this value and retry your request.' do
+          resp = Amazon::Associates.item_lookup('abc')
+          raise resp.inspect
+        end
+      end
+
+      def test_hpricot_extensions
+        item = Amazon::Associates.item_lookup('0974514055').item
+
+        assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition", item.attributes['Title']
+        assert item.authors.is_a?(Array)
+        assert 3, item.authors.size
+        assert_equal "Dave Thomas", item.authors.first
+      end
+    end
+
+    class Amazon::Associates::ItemTestsBroughtInFromAssociateGem < Test::Unit::TestCase
+      include FilesystemTestHelper
+      
+      def setup
+        set_valid_caching_options
+        Amazon::Associates.options.merge!(:response_group => "Large")
+      end
+
+      ## Test item_search
+      def test_item_search
+        resp = Amazon::Associates.item_search("ruby")
+        assert(resp.request.valid?, resp.inspect)
+        assert(resp.total_results >= 3600)
+        assert(resp.total_pages >= 360)
+      end
+
+      def test_item_search_with_paging
+        resp = Amazon::Associates.item_search("ruby", :item_page => 2)
+        assert resp.request.valid?, resp.inspect
+        assert 2, resp.current_page
+      end
+
+      def test_item_search_with_no_result
+        assert_raise(Amazon::Associates::ItemNotFound) do
+          Amazon::Associates.item_search("afdsafds")
+        end
+      end
+
+      def test_item_search_uk
+        resp = Amazon::Associates.item_search("ruby", :country => :uk)
+        assert resp.request.valid?
+      end
+
+      def test_item_search_by_author
+        resp = Amazon::Associates.item_search("dave", :type => :author)
+        assert resp.request.valid?
+      end
+
+      def test_item_get
+        resp = Amazon::Associates.item_search("0974514055")
+        item = resp.items.first
+
+        # test get
+        assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition",
+          item.attributes['Title']
+
+        # test get_array
+        assert_equal ['Dave Thomas', 'Chad Fowler', 'Andy Hunt'], item.authors
+
+        # test get_hash
+        small_image = item.image_sets.values.first.small
+
+        assert small_image.url != nil
+        assert_equal 75, small_image.height.value
+        assert_equal 59, small_image.width.value
+      end
+
+      ## Test item_lookup
+      def test_item_lookup
+        resp = Amazon::Associates.item_lookup("0974514055")
+        assert_equal "Programming Ruby: The Pragmatic Programmers' Guide, Second Edition",
+        resp.items.first.attributes['Title']
+      end
+
+      def test_item_lookup_with_invalid_request
+        assert_raise(Amazon::Associates::RequiredParameterMissing) do
+          Amazon::Associates.item_lookup(nil)
+        end
+      end
+
+      def test_item_lookup_with_no_result
+        assert_raise(Amazon::Associates::InvalidParameterValue) do
+          resp = Amazon::Associates.item_lookup("abc")
+        end
+      end
+
+      def test_search_and_convert
+        resp = Amazon::Associates.item_lookup("0974514055")
+        title = resp.items.first.attributes['Title']
+        authors = resp.items.first.authors
+
+        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
+      end
+    end
+
+    class ItemTestBroughtIn < Test::Unit::TestCase
+      include FilesystemTestHelper
+      
+      def setup
+        set_valid_caching_options
+      end
+
+      def test_find_all_should_return_items
+        item = Item.find(:all, :keywords => 'upside').first
+        assert item
+        assert_kind_of Item, item
+      end
+
+      def test_find_all_and_find_first_should_yield_same_first
+        params = {:keywords => 'jelly'}
+        assert_equal Item.find(:all, params).first, Item.find(:first, params)
+      end
+
+      def test_find_second_page_returns_different_items_than_first
+        params = {:keywords => 'potter'}
+        assert_not_equal Item.find(:first, params.merge(:page => 1)),
+          Item.find(:first, params.merge(:page => 2))
+      end
+
+      def test_item_creator_should_be_unpacked
+        p "Pending: we're losing info from attributes..."
+#        asin = '0545010225'
+#        item = Item.find(asin)
+#        assert_equal("Mary GrandPré",
+#          Amazon::Associates.item_lookup(asin).items.first.attributes["Creator"])
+      end
+
+      def test_item_list_price_present
+        assert Item.find('0545010225').list_price
+      end
+
+      def test_item_performers_unpacked_to_array
+        assert_equal(["Robert Downey Jr.", "Gwyneth Paltrow", "Terrence Howard", "Jeff Bridges", "Leslie Bibb"],
+          Item.find('B00005JPS8').attributes['Actor'])
+      end
+
+      def test_image_sets_should_be_unpacked
+        item = Item.find(:first, :keywords => 'potter')
+        assert !item.image_sets.empty?
+      end
+
+      def test_missing_item_should_throw
+        assert_raise Amazon::Associates::InvalidParameterValue do
+          Item.find('abc')
+        end
+      end
+
+      def test_find_no_page_returns_same_items_as_first
+        params = {:keywords => 'potter'}
+        assert_equal Item.find(:first, params),
+          Item.find(:first, params.merge(:page => 1))
+      end
+
+      def test_find_with_different_sort_returns_different
+        params = {:keywords => 'potter'}
+        assert_not_equal Item.find(:first, params.merge(:sort => Amazon::Associates::SORT_TYPES['Books'][3])),
+          Item.find(:first, params.merge(:sort => Amazon::Associates::SORT_TYPES['Books'][7]))
+        assert_equal Item.find(:first, params.merge(:sort => Amazon::Associates::SORT_TYPES['Books'][3])),
+          Item.find(:first, params.merge(:sort => Amazon::Associates::SORT_TYPES['Books'][3]))
+      end
+
+      def test_find_too_far_a_page_is_error
+        assert_raise Amazon::Associates::ParameterOutOfRange do
+          Item.find(:first, :keywords => 'potter', :page => 9999)
+        end
+      end
+
+      def test_none_found_is_error
+        assert_raise Amazon::Associates::ItemNotFound do
+          Item.find(:first, :keywords => 'zjvalk', :page => 400)
+        end
+      end
+
+      def test_pagination_basics
+        results = Item.find(:all, :keywords => 'potter', :search_index => 'All')
+        assert_equal 4000, results.total_entries
+        assert_equal 1, results.current_page
+      end
+
+      def test_pagination_sets_current_page
+        [3, 7].each do |page|
+          assert_equal page, Item.find(:all, :keywords => 'potter', :page => page).current_page
+        end
+      end
+
+      def test_should_reject_unknown_args
+        assert_raise ArgumentError do
+          Item.find(:first, :keywords => 'potter', :itempage => 12)
+        end
+      end
+
+      def test_find_should_work_for_blended_merchants_and_all
+        assert Item.find(:first, :keywords => 'blackberry', :search_index => 'Blended')
+        assert Item.find(:first, :keywords => 'blackberry', :search_index => 'All')
+        assert Item.find(:first, :keywords => 'blackberry', :search_index => 'Merchants')
+      end
+
+      def test_find_top_sellers_should_return_items
+        assert !Item.find(:top_sellers, :browse_node_id => 520432).empty?
+      end
+
+      def test_should_find_one
+        item_asin = '0545010225'
+        item = Item.find(item_asin)
+        assert item
+        assert item.is_a?(Item)
+        assert_equal item_asin, item.asin
+      end
+
+      def test_find_one_and_first_should_be_equivalent
+        # TODO: or maybe a subset?
+        item1 = Item.find(:first, :keywords => 'potter')
+        item2 = Item.find(item1.asin)
+        assert_equal item1, item2
+      end
+
+      def test_should_raise_on_bad_request
+        assert_raise ArgumentError do
+          Item.find(20)
+        end
+      end
+    end
+  end
+end