sucker 1.1.4 → 1.2.0

data/spec/integration/multiple_locales_spec.rb

@@ -1,70 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-
-module Sucker
-
-  describe "Item lookup" do
-
-    use_vcr_cassette "integration/multiple_locales", :record => :new_episodes
-
-    context "when using Curl::Multi to search all locales simultaneously" do
-
-      it "returns matches for all locales" do
-        worker = Sucker.new(
-          :key    => amazon["key"],
-          :secret => amazon["secret"])
-        worker << {
-          "Operation"     => "ItemLookup",
-          "IdType"        => "ASIN",
-          "ResponseGroup" => "ItemAttributes",
-          "ItemId"        => "0816614024" }
-
-        bindings = worker.get_all.map do |response|
-          item = response.find("Item").first
-          item["ItemAttributes"]["Binding"]
-        end
-
-        bindings.uniq.should =~ %w{ Paperback Taschenbuch Broché ペーパーバック }
-
-      end
-
-    end
-
-    context "when using threads to search all locales simultaneously" do
-
-      # Use this approach to be able to throttle requests individually.
-
-      it "returns matches for all locales" do
-        locales = %w{us uk de ca fr jp}
-
-        params = {
-          "Operation"     => "ItemLookup",
-          "IdType"        => "ASIN",
-          "ResponseGroup" => "ItemAttributes",
-          "ItemId"        => "0816614024" }
-
-        threads = locales.map do |locale|
-          Thread.new do
-            worker = Sucker.new(
-              :locale => locale,
-              :key    => amazon["key"],
-              :secret => amazon["secret"])
-            worker << params
-            Thread.current[:response] = worker.get
-          end
-        end
-
-        bindings = threads.map do |thread|
-          thread.join
-          item = thread[:response].find("Item").first
-          item["ItemAttributes"]["Binding"]
-        end
-
-        bindings.uniq.should =~ %w{ Paperback Taschenbuch Broché ペーパーバック }
-      end
-
-    end
-
-  end
-
-end

data/spec/integration/power_search_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-# http://docs.amazonwebservices.com/AWSECommerceService/2010-09-01/DG/index.html?PowerSearchSyntax.html
-#
-# author: ambrose and binding: (abridged or large print) and pubdate: after 11-1996
-# subject: history and (Spain or Mexico) and not military and language: Spanish
-# (subject: marketing and author: kotler) or (publisher: harper and subject: "high technology")
-# keywords: "high tech*" and not fiction and pubdate: during 1999
-# isbn: 0446394319 or 0306806819 or 1567993850
-
-module Sucker
-
-  describe "Power search" do
-
-    use_vcr_cassette "integration/power_search", :record => :new_episodes
-
-    let(:worker) do
-      worker = Sucker.new(
-        :locale => "us",
-        :key    => amazon["key"],
-        :secret => amazon["secret"])
-      worker << {
-        "Operation"   => "ItemSearch",
-        "SearchIndex" => "Books",
-        "Power"       => "author:lacan or deleuze and not fiction",
-        "Sort"        => "relevancerank" }
-      worker
-    end
-
-    it "returns matches" do
-      items  = worker.get.find("Item")
-      items.size.should > 0
-      items.each do |item|
-        item["ItemAttributes"]["Title"].should_not be_nil
-      end
-
-    end
-
-  end
-
-end

data/spec/integration/related_items_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-module Sucker
-
-  describe "Item lookup" do
-
-    context "when response group includes related items" do
-
-      let(:worker) do
-        worker = Sucker.new(
-          :locale => "us",
-          :key    => amazon["key"],
-          :secret => amazon["secret"])
-
-        worker << {
-          "Operation"         => "ItemLookup",
-          "IdType"            => "ASIN",
-          "ResponseGroup"     => ["RelatedItems"],
-          "RelationshipType"  => "AuthorityTitle" }
-
-        worker
-      end
-
-      context "when item is a child" do
-
-        use_vcr_cassette "integration/related_items/child", :record => :new_episodes
-
-        it "finds parent and related items" do
-          worker << { "ItemId" => "0415246334" }
-          response = worker.get
-          response.find("RelatedItem").size.should eql 1
-          parent_asin = response.find("RelatedItem").first["Item"]["ASIN"]
-        end
-
-      end
-
-      context "when item is a parent" do
-
-        use_vcr_cassette "integration/related_items/parent", :record => :new_episodes
-
-        it "finds related items" do
-          worker << { "ItemId" => "B000ASPUES" }
-          response = worker.get
-          response.find("RelatedItem").size.should > 1
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/spec/integration/seller_listing_search_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-module Sucker
-  describe "Seller listing search" do
-
-    use_vcr_cassette "integration/seller_listings_search", :record => :new_episodes
-
-    let(:listings) do
-      worker = Sucker.new(
-        :locale => "us",
-        :key    => amazon["key"],
-        :secret => amazon["secret"])
-
-      worker << {
-        "Operation"   => "SellerListingSearch",
-        "SellerId"    => "A2JYSO6W6KEP83" }
-
-      worker.get.find("SellerListings").first
-    end
-
-    it "returns page count" do
-      listings["TotalPages"].to_i.should be > 0
-    end
-
-    it "returns listings" do
-      listings["SellerListing"].size.should be > 0
-      listings["SellerListing"].first.has_key?("Price").should be_true
-    end
-
-  end
-
-end

data/spec/integration/twenty_items_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-module Sucker
-  describe "Item lookup" do
-
-    context "when querying for twenty items" do
-
-      use_vcr_cassette "integration/twenty_items", :record => :new_episodes
-
-      let(:asins) do
-        %w{
-          0816614024 0143105825 0485113600 0816616779 0942299078
-          0816614008 144006654X 0486400360 0486417670 087220474X
-          0486454398 0268018359 1604246014 184467598X 0312427182
-          1844674282 0745640974 0745646441 0826489540 1844672972 }
-      end
-
-      let(:items) do
-        worker = Sucker.new(
-          :locale => "us",
-          :key    => amazon["key"],
-          :secret => amazon["secret"])
-
-        # Prep worker
-        worker << {
-          "Operation"                       => "ItemLookup",
-          "ItemLookup.Shared.IdType"        => "ASIN",
-          "ItemLookup.Shared.Condition"     => "All",
-          "ItemLookup.Shared.MerchantId"    => "All",
-          "ItemLookup.Shared.ResponseGroup" => "OfferFull" }
-
-        # Push twenty ASINs to worker
-        worker << {
-          "ItemLookup.1.ItemId" => asins[0, 10],
-          "ItemLookup.2.ItemId" => asins[10, 10] }
-
-        worker.get.find("Item")
-      end
-
-      it "returns all items" do
-        items.count.should eql 20
-        items.map { |item| item["ASIN"] }.should eql asins
-      end
-
-    end
-
-  end
-
-end

data/spec/unit/sucker/request_spec.rb

@@ -1,282 +0,0 @@
-require "spec_helper"
-
-module Sucker
-
-  describe Request do
-
-    use_vcr_cassette "unit/sucker/request", :record => :new_episodes
-
-    let(:worker) do
-      Sucker.new(
-        :locale => "us",
-        :key    => "key",
-        :secret => "secret")
-    end
-
-    describe ".new" do
-
-      it "sets default parameters" do
-        default_parameters = {
-          "Service" => "AWSECommerceService",
-          "Version" => Sucker::CURRENT_AMAZON_API_VERSION }
-        worker.parameters.should include default_parameters
-      end
-
-    end
-
-    describe "#<<" do
-
-      it "merges a hash into the parameters" do
-        worker << { "foo" => "bar" }
-        worker.parameters["foo"].should eql "bar"
-      end
-
-    end
-
-    describe "#version=" do
-
-      it "sets the Amazon API version" do
-        worker.version = "foo"
-        worker.parameters["Version"].should eql "foo"
-      end
-
-    end
-
-    describe "#associate_tag" do
-
-      it "returns the associate tag for the current locale" do
-        worker.instance_variable_set(:@associate_tags, { :us => 'foo-bar'})
-
-        worker.associate_tag.should eql 'foo-bar'
-      end
-
-      it "returns nil if an associate tag is not set for the current locale" do
-        worker.associate_tag.should eql nil
-      end
-
-    end
-
-    describe "#associate_tag=" do
-
-      it "sets the associate tag for the current locale" do
-        worker.associate_tag = "foo-bar"
-        associate_tags = worker.instance_variable_get(:@associate_tags)
-
-        associate_tags.keys.size.should eql 1
-        associate_tags[:us].should eql 'foo-bar'
-        worker.associate_tag.should eql 'foo-bar'
-      end
-
-    end
-
-    describe "#associate_tags=" do
-
-      it "sets associate tags for the locales" do
-        tags = {
-          :us => 'foo',
-          :uk => 'bar',
-          :de => 'baz',
-          :ca => 'foo',
-          :fr => 'bar',
-          :jp => 'baz' }
-        worker.associate_tags = tags
-
-        worker.instance_variable_get(:@associate_tags).should eql tags
-      end
-
-    end
-
-    describe "#curl_opts" do
-
-      it "returns options for curl" do
-        worker.curl_opts.should be_an_instance_of Hash
-      end
-
-      context "when given a block" do
-
-        it "yields options for curl" do
-          worker.curl_opts { |c| c.interface = "eth1" }
-
-          worker.curl_opts[:interface].should eql "eth1"
-        end
-
-      end
-
-    end
-
-    describe "#get" do
-
-      it "returns a response" do
-        worker.get.class.ancestors.should include Response
-      end
-
-      it "raises an argument error if no key is provided" do
-        worker.key = nil
-        expect do
-          worker.get
-        end.to raise_error(/AWS access key missing/)
-      end
-
-      it "raises an argument error if no locale is provided" do
-        worker.locale = nil
-        expect do
-          worker.get
-        end.to raise_error(/Locale missing/)
-      end
-
-      it "sets options on curl" do
-        easy = mock
-        easy.should_receive(:interface=).once.with("eth1")
-        Curl::Easy.stub!(:perform).and_yield(easy)
-        Response.should_receive(:new).once
-
-        worker.curl_opts { |c| c.interface = 'eth1' }
-        worker.get
-      end
-
-    end
-
-    describe "#get_all" do
-
-      it "returns an array of responses" do
-        responses = worker.get_all
-
-        responses.should be_an_instance_of Array
-        responses.each { |resp| resp.should be_an_instance_of Response }
-      end
-
-      context "when given a block" do
-
-        it "yields responses" do
-          count = 0
-          worker.get_all do |resp|
-            resp.should be_an_instance_of Response
-            count += 1
-          end
-
-          count.should eql Request::HOSTS.size
-        end
-
-      end
-
-    end
-
-    describe "#key" do
-
-      it "returns the Amazon AWS access key for the current locale" do
-        worker.instance_variable_set(:@keys, { :us => 'foo' })
-
-        worker.key.should eql 'foo'
-      end
-
-    end
-
-    describe "#key=" do
-
-      it "sets a global Amazon AWS access key" do
-        worker.key = "foo"
-        keys = worker.instance_variable_get(:@keys)
-
-        keys.size.should eql Request::HOSTS.size
-        keys.values.uniq.should eql ["foo"]
-      end
-
-    end
-
-    describe "#keys=" do
-
-      it "sets distinct Amazon AWS access keys for the locales" do
-        keys = {
-          :us => 'foo',
-          :uk => 'bar',
-          :de => 'baz',
-          :ca => 'foo',
-          :fr => 'bar',
-          :jp => 'baz' }
-        worker.keys = keys
-
-        worker.instance_variable_get(:@keys).should eql keys
-      end
-
-    end
-
-    context "private methods" do
-
-      describe "#build_query" do
-
-        let(:query) { worker.send(:build_query) }
-
-        it "canonicalizes parameters" do
-          query.should match /Service=([^&]+)&Timestamp=([^&]+)&Version=([^&]+)/
-        end
-
-        it "includes the key for the current locale" do
-          worker.instance_variable_set(:@keys, { :us => 'foo' })
-          query.should include 'AWSAccessKeyId=foo'
-        end
-
-        it "includes a timestamp" do
-          query.should include 'Timestamp='
-        end
-
-        it "sorts parameters" do
-          worker.parameters["AAA"] = "foo"
-          query.should match /^AAA=foo/
-        end
-
-        it "converts a parameter whose value is an array to a string" do
-          worker.parameters["Foo"] = ["bar", "baz"]
-          query.should match /Foo=bar%2Cbaz/
-        end
-
-        it "handles integer parameter values" do
-          worker.parameters["Foo"] = 1
-          query.should match /Foo=1/
-        end
-
-        it "handles floating-point parameter values" do
-          worker.parameters["Foo"] = 1.0
-          query.should match /Foo=1/
-        end
-
-      end
-
-      describe "#host" do
-
-        it "returns a host" do
-          worker.locale = "fr"
-          worker.send(:host).should eql "ecs.amazonaws.fr"
-        end
-
-      end
-
-      describe "#build_signed_query" do
-
-        it "returns a signed query string" do
-          query = worker.send :build_signed_query
-          query.should match /&Signature=.*/
-        end
-
-      end
-
-      describe "#timestamp" do
-
-        it "returns a timestamp" do
-          worker.send(:timestamp)["Timestamp"].should match /^\d+-\d+-\d+T\d+:\d+:\d+Z$/
-        end
-
-      end
-
-      describe "#uri" do
-
-        it "returns the URI with which to query Amazon" do
-          worker.send(:uri).should be_an_instance_of URI::HTTP
-        end
-
-      end
-
-    end
-
-  end
-
-end