etsy 0.1.0 → 0.2.0

data/test/unit/etsy/listing_test.rb

@@ -1,92 +1,110 @@
-require File.dirname(__FILE__) + '/../../test_helper'
+require File.expand_path('../../../test_helper', __FILE__)
 
 module Etsy
   class ListingTest < Test::Unit::TestCase
 
-    describe "The Listing class" do
-      
-      it "should be able to find all listings by :user_id" do
-        user_id = 122345
-        
-        response = mock_request_cycle :for => "/shops/#{user_id}/listings", :data => 'getShopListings'
-        
-        listing_1, listing_2 = response.result
-        
-        Listing.expects(:new).with(listing_1).returns('listing_1')
-        Listing.expects(:new).with(listing_2).returns('listing_2')
-        
-        Listing.find_all_by_user_id(user_id).should == ['listing_1', 'listing_2']
+    context "The Listing class" do
+
+      should "be able to find all listings for a shop" do
+        listings = mock_request('/shops/1/listings/active', {}, 'Listing', 'findAllShopListingsActive.json')
+        Listing.find_all_by_shop_id(1).should == listings
       end
-      
+
     end
-    
-    describe "An instance of the Listing class" do
-
-      when_populating Listing, :from => 'getShopListings' do
-
-        value_for :id,          :is => 24165902
-        value_for :state,       :is => 'active'
-        value_for :title,       :is => 'hanging with the bad boys matchbox'
-        value_for :description, :is => 'standard size matchbox ...'
-        value_for :url,         :is => 'http://www.etsy.com/view_listing.php?listing_id=24165902'
-        value_for :view_count,  :is => 18
-        value_for :created,     :is => 1240673494.49
-        value_for :price,       :is => 3
-        value_for :quantity,    :is => 1
-        value_for :currency,    :is => 'USD'
-        value_for :ending,      :is => 1251214294.49
-        value_for :tags,        :is => %w(accessories matchbox)
-        value_for :materials,   :is => %w(standard_matchbox notebook_paper)
-        
+
+    context "An instance of the Listing class" do
+
+      context "with response data" do
+        setup do
+          data = read_fixture('listing/findAllShopListingsActive.json')
+          @listing = Listing.new(data.first)
+        end
+
+        should "have a value for :id" do
+          @listing.id.should == 59495892
+        end
+
+        should "have a value for :state" do
+          @listing.state.should == 'active'
+        end
+
+        should "have a value for :title" do
+          @listing.title.should == "initials carved into tree love stamp"
+        end
+
+        should "have a value for :description" do
+          @listing.description.should == "there! our initials are now carved deeply into this rough tree bark of memory"
+        end
+
+        should "have a value for :url" do
+          @listing.url.should == "http://www.etsy.com/listing/59495892/initials-carved-into-tree-love-stamp"
+        end
+
+        should "have a value for :view_count" do
+          @listing.view_count.should == 37
+        end
+
+        should "have a value for :created_at" do
+          @listing.created_at.should == Time.at(1287602289)
+        end
+
+        should "have a value for :price" do
+          @listing.price.should == "15.00"
+        end
+
+        should "have a value for :quantity" do
+          @listing.quantity.should == 1
+        end
+
+        should "have a value for :currency" do
+          @listing.currency.should == "USD"
+        end
+
+        should "have a value for :ending_at" do
+          @listing.ending_at.should == Time.at(1298178000)
+        end
+
+        should "have a value for :tags" do
+          @listing.tags.should == %w(tag_1 tag_2)
+        end
+
+        should "have a value for :materials" do
+          @listing.materials.should == %w(material_1 material_2)
+        end
       end
-      
+
       %w(active removed sold_out expired alchemy).each do |state|
-        it "should know that the listing is #{state}" do
+        should "know that the listing is #{state}" do
           listing = Listing.new
           listing.expects(:state).with().returns(state.sub('_', ''))
 
           listing.send("#{state}?".to_sym).should be(true)
         end
 
-        it "should know that the listing is not #{state}" do
+        should "know that the listing is not #{state}" do
           listing = Listing.new
           listing.expects(:state).with().returns(state.reverse)
 
           listing.send("#{state}?".to_sym).should be(false)
-        end        
-      end
-      
-      it "should know the create date" do
-        listing = Listing.new
-        listing.expects(:created).with().returns(1240673494.49)
-        
-        listing.created_at.should == Time.at(1240673494.49)
+        end
       end
-      
-      it "should know the ending date" do
+
+      should "have a collection of images" do
         listing = Listing.new
-        listing.expects(:ending).with().returns(1240673494.49)
-        
-        listing.ending_at.should == Time.at(1240673494.49)
-      end
-      
-      it "should have associated images" do
-        data = read_fixture('getShopListings')[0]
-        listing = Listing.new(data)
-
-        Image.expects(:new).with(data['all_images'][0]).returns('image_1')
-        Image.expects(:new).with(data['all_images'][1]).returns('image_2')
-        
-        listing.images.should == ['image_1', 'image_2']
+        listing.stubs(:id).with().returns(1)
+
+        Image.stubs(:find_all_by_listing_id).with(1).returns('images')
+
+        listing.images.should == 'images'
       end
-      
-      it "should have a primary image" do
+
+      should "have a default image" do
         listing = Listing.new
-        listing.expects(:images).with().returns(%w(one two))
-        
-        listing.image.should == 'one'
+        listing.stubs(:images).with().returns(%w(image_1 image_2))
+
+        listing.image.should == 'image_1'
       end
-      
+
     end
   end
 end

data/test/unit/etsy/request_test.rb

@@ -1,74 +1,156 @@
-require File.dirname(__FILE__) + '/../../test_helper'
+require File.expand_path('../../../test_helper', __FILE__)
 
 module Etsy
   class RequestTest < Test::Unit::TestCase
-    
-    describe "The Request class" do
 
-      it "should know the base URL" do
-        Request.base_url.should == 'http://beta-api.etsy.com/v1'
+    context "The Request class" do
+
+      should "know the host" do
+        Request.host.should == 'openapi.etsy.com'
       end
 
-      it "should be able to retrieve a response" do
+      should "be able to retrieve a response" do
         http_response = stub()
         response      = stub()
-        
+
         Response.expects(:new).with(http_response).returns(response)
-        
+
         request = mock {|m| m.expects(:get).with().returns(http_response) }
         Request.expects(:new).with('/user', :one => 'two').returns(request)
-        
+
         Request.get('/user', :one => 'two').should == response
       end
     end
-   
-    describe "An instance of the Request class" do
 
-      it "should append the api_key and detail_level to the parameters" do
+    context "An instance of the Request class" do
+
+      should "know the base path for the sandbox read-only environment" do
+        Etsy.stubs(:environment).returns(:sandbox)
+        Etsy.stubs(:access_mode).returns(:read_only)
+
+        Request.new('').base_path.should == '/v2/sandbox/public'
+      end
+
+      should "know the base path for the sandbox read/write environment when the access information is present" do
+        Etsy.stubs(:environment).returns(:sandbox)
+        Etsy.stubs(:access_mode).returns(:read_write)
+
+        r = Request.new('', :access_token => 'toke', :access_secret => 'secret')
+        r.base_path.should == '/v2/sandbox/private'
+      end
+
+      should "know the base path for the sandbox read/write environment when the access information is not present" do
+        Etsy.stubs(:environment).returns(:sandbox)
+        Etsy.stubs(:access_mode).returns(:read_write)
+
+        Request.new('').base_path.should == '/v2/sandbox/public'
+      end
+
+      should "know the base path for the production read-only environment" do
+        Etsy.stubs(:environment).returns(:production)
+        Etsy.stubs(:access_mode).returns(:read_only)
+
+        Request.new('').base_path.should == '/v2/public'
+      end
+
+      should "know the base path for the production read-write environment when access information is present" do
+        Etsy.stubs(:environment).returns(:production)
+        Etsy.stubs(:access_mode).returns(:read_write)
+
+        r = Request.new('', :access_token => 'toke', :access_secret => 'secret')
+        r.base_path.should == '/v2/private'
+      end
+
+      should "know the base path for the production read-write environment when access information is not present" do
+        Etsy.stubs(:environment).returns(:production)
+        Etsy.stubs(:access_mode).returns(:read_write)
+
+        Request.new('').base_path.should == '/v2/public'
+      end
+
+      should "append the api_key and detail_level to the parameters" do
         Etsy.expects(:api_key).with().returns('key')
-        
+
         r = Request.new('/user', :limit => '1')
         r.parameters.should == {:limit => '1', :api_key => 'key', :detail_level => 'high'}
       end
 
-      it "should be able to generate query parameters" do
+      should "be able to generate query parameters" do
         r = Request.new('/user')
         r.expects(:parameters).with().returns(:api_key => 'foo')
         r.query.should == 'api_key=foo'
       end
-      
-      it "should be able to join multiple query parameters" do
+
+      should "be able to join multiple query parameters" do
         params = {:limit => '1', :other => 'yes'}
-        
+
         r = Request.new('/user', params)
         r.stubs(:parameters).with().returns(params)
-        
+
         r.query.split('&').sort.should == %w(limit=1 other=yes)
       end
-      
-      it "should be able to determine the endpoint URI" do
-        Request.stubs(:base_url).with().returns('http://example.com')
-        
+
+      should "be able to determine the endpoint URI when in read-only mode" do
         r = Request.new('/user')
+        r.stubs(:base_path).with().returns('/base')
         r.stubs(:query).with().returns('a=b')
-        
-        r.endpoint_uri.to_s.should == 'http://example.com/user?a=b'
-      end
-      
-      it "should be able to make a successful request" do
-        uri = URI.parse('http://example.com')
-        response = stub()
-        
+
+        r.endpoint_url.should == '/base/user?a=b'
+      end
+
+      should "be able to determine the endpoint URI when in read-write mode" do
+        Etsy.stubs(:access_mode).returns(:read_write)
+
+        r = Request.new('/user', :access_token => 'toke', :access_secret => 'secret')
+        r.stubs(:base_path).with().returns('/base')
+        r.stubs(:query).with().returns('a=b')
+
+        r.endpoint_url.should == '/base/user?a=b'
+      end
+
+      should "know the client for read-only mode" do
+        Etsy.stubs(:access_mode).returns(:read_only)
+        Request.stubs(:host).returns('example.com')
+
+        BasicClient.stubs(:new).with('example.com').returns('client')
+
+        r = Request.new('')
+
+        r.client.should == 'client'
+      end
+
+      should "know the client for read-write mode when there is no access token information" do
+        Etsy.stubs(:access_mode).returns(:read_write)
+        Request.stubs(:host).returns('example.com')
+
+        BasicClient.stubs(:new).with('example.com').returns('client')
+
+        r = Request.new('')
+
+        r.client.should == 'client'
+      end
+
+      should "know the client for read-write mode when there is access token information" do
+        Etsy.stubs(:access_mode).returns(:read_write)
+        SecureClient.stubs(:new).with(:access_token => 'toke', :access_secret => 'secret').returns('client')
+
+        r = Request.new('', :access_token => 'toke', :access_secret => 'secret')
+        r.client.should == 'client'
+      end
+
+      should "be able to make a successful request" do
+        client = stub()
+        client.stubs(:get).with('endpoint_url').returns('response')
+
         r = Request.new('/user')
-        r.expects(:endpoint_uri).with().returns(uri)
-        
-        Net::HTTP.expects(:get).with(uri).returns(response)
-        
-        r.get.should == response
+        r.stubs(:endpoint_url).with().returns('endpoint_url')
+        r.stubs(:client).returns(client)
+
+        r.get.should == 'response'
       end
-      
+
     end
-    
-    
+
+
   end
-end
+end

data/test/unit/etsy/response_test.rb

@@ -1,47 +1,47 @@
-require File.dirname(__FILE__) + '/../../test_helper'
+require File.expand_path('../../../test_helper', __FILE__)
 
 module Etsy
   class ResponseTest < Test::Unit::TestCase
 
-    describe "An instance of the Response class" do
-      
-      it "should be able to decode the JSON data to a hash" do
+    context "An instance of the Response class" do
+
+      should "be able to decode the JSON data to a hash" do
         data = '{ "foo":"bar" }'
-        
-        r = Response.new(data)
+
+        r = Response.new(stub(:body => data))
         r.to_hash.should == {'foo' => 'bar'}
       end
-      
-      it "should only decode the JSON data once" do
+
+      should "only decode the JSON data once" do
         JSON.expects(:parse).once.returns({})
-        
-        r = Response.new('{ "foo":"bar" }')
+
+        r = Response.new(stub(:body => '{ "foo":"bar" }'))
         2.times { r.to_hash }
       end
-      
-      it "should have a record count" do
+
+      should "have a record count" do
         r = Response.new('')
         r.expects(:to_hash).with().returns('count' => 1)
-        
+
         r.count.should == 1
       end
-      
-      it "should return an array if there are multiple results entries" do
+
+      should "return an array if there are multiple results entries" do
         r = Response.new('')
         r.expects(:count).with().returns(2)
         r.expects(:to_hash).with().returns('results' => %w(one two))
-        
+
         r.result.should == %w(one two)
       end
-      
-      it "should return a single value for results if there is only 1 result" do
+
+      should "return a single value for results if there is only 1 result" do
         r = Response.new('')
         r.expects(:count).with().returns(1)
         r.expects(:to_hash).with().returns('results' => ['foo'])
-        
+
         r.result.should == 'foo'
       end
-      
+
     end
 
 

data/test/unit/etsy/secure_client_test.rb

@@ -0,0 +1,110 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+module Etsy
+  class SecureClientTest < Test::Unit::TestCase
+
+    context "An instance of the SecureClient class" do
+
+      should "be able to generate an OAuth consumer" do
+        Etsy.stubs(:api_key).returns('key')
+        Etsy.stubs(:api_secret).returns('secret')
+
+        OAuth::Consumer.stubs(:new).with('key', 'secret', {
+          :site               => 'http://openapi.etsy.com',
+          :request_token_path => '/v2/sandbox/oauth/request_token',
+          :access_token_path  => '/v2/sandbox/oauth/access_token',
+          :authorize_url      => 'https://www.etsy.com/oauth/signin'
+        }).returns('consumer')
+
+        client = SecureClient.new
+
+        client.consumer.should == 'consumer'
+      end
+
+      should "be able to generate a request token" do
+        Etsy.stubs(:callback_url).with().returns('callback_url')
+        consumer = stub() {|c| c.stubs(:get_request_token).with(:oauth_callback => 'callback_url').returns('toke') }
+
+        client = SecureClient.new
+        client.stubs(:consumer).returns(consumer)
+
+        client.request_token.should == 'toke'
+      end
+
+      context "with request data" do
+        setup do
+          @client = SecureClient.new(:request_token => 'toke', :request_secret => 'secret', :verifier => 'verify')
+          @client.stubs(:consumer).returns('consumer')
+        end
+
+        should "be able to generate an oauth client" do
+          request_token = stub()
+          request_token.stubs(:get_access_token).with(:oauth_verifier => 'verify').returns('client')
+
+          OAuth::RequestToken.stubs(:new).with('consumer', 'toke', 'secret').returns(request_token)
+
+          @client.client_from_request_data.should == 'client'
+        end
+
+        should "know to generate a client from request data" do
+          @client.stubs(:client_from_request_data).returns('client')
+          @client.client.should == 'client'
+        end
+      end
+
+      context "with access data" do
+        setup do
+          @client = SecureClient.new(:access_token => 'toke', :access_secret => 'secret')
+          @client.stubs(:consumer).returns('consumer')
+        end
+
+        should "know the :access_token" do
+          @client.access_token.should == 'toke'
+        end
+
+        should "know the access secret" do
+          @client.access_secret.should == 'secret'
+        end
+
+        should "be able to generate an oauth client" do
+          OAuth::AccessToken.stubs(:new).with('consumer', 'toke', 'secret').returns('client')
+          @client.client_from_access_data.should == 'client'
+        end
+
+        should "be able to generate a client" do
+          @client.stubs(:client_from_access_data).returns('client')
+          @client.client.should == 'client'
+        end
+      end
+
+      context "with a client" do
+        setup do
+          @client = SecureClient.new
+          @client.stubs(:client).returns(stub(:token => 'toke', :secret => 'secret'))
+        end
+
+        should "know the access token" do
+          @client.access_token.should == 'toke'
+        end
+
+        should "know the access_secret" do
+          @client.access_secret.should == 'secret'
+        end
+      end
+
+      should "delegate :get to :client" do
+        url = 'http://etsy.com/'
+
+        oauth_client = stub()
+        oauth_client.stubs(:get).with(url).returns('something')
+
+        client = SecureClient.new
+        client.stubs(:client).returns(oauth_client)
+
+        client.get(url).should == 'something'
+      end
+
+    end
+
+  end
+end