bigcommerce 0.0.6 → 0.8.0

data/README.md

@@ -6,16 +6,12 @@ Ruby apps or via the console.
 
 Note
 ----
-
-**The Ruby Client is still in alpha and core features of the API may be
-unsupported and undocumented.**
+If you find anything that is missing or needs clean up, please feel free to fork it and submit a changes with your pull request.
 
 Requirements
 ------------
 
-- Ruby 1.8.7+
-- Rubygems
-- JSON
+- Ruby 1.9+
 
 To connect to the API, you need the following credentials:
 
@@ -25,7 +21,7 @@ To connect to the API, you need the following credentials:
 
 A valid API key is required to authenticate requests. To grant API access for
 user, go to Control Panel > Users > Edit User and make sure that the
-'Enable the XML API?' checkbox is ticked.
+'Enable API access?' checkbox is ticked.
 
 Installation
 ------------
@@ -37,6 +33,13 @@ install the package directly from Rubygems:
 gem install bigcommerce
 ```
 
+Note - the current gem version is 1.0. The Rubygems version might be older. You can install the gem directly from this repo. If you are using rails, you can point your gemfile to this git repo directly or do a local install of the gem by -
+
+```
+gem build bigcommerce
+gem install bigcommerce-1.0.gem
+```
+
 Configuration
 -------------
 
@@ -46,12 +49,28 @@ follows:
 ```
 require 'bigcommerce'
 
-api = Bigcommerce::Api.new({
+api = BigCommerce::Api.new({
+	:store_url => "https://store.mybigcommerce.com",
+	:username  => "admin",
+	:api_key   => "d81aada4c19c34d913e18f07fd7f36ca"
+})
+```
+
+If you want to enable SSL certificates -
+
+```
+require 'bigcommerce'
+api = BigCommerce::Api.new({
 	:store_url => "https://store.mybigcommerce.com",
 	:username  => "admin",
 	:api_key   => "d81aada4c19c34d913e18f07fd7f36ca"
+	:ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read("cert.pem")),
+  	:ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read("key.pem"), "passphrase, if any"),
+  	:ssl_ca_file      =>  "ca_certificate.pem",
+  	:verify_ssl       =>  OpenSSL::SSL::VERIFY_PEER 
 })
 ```
+Remember that the fields :ssl_client_cert, :ssl_client_key, :ssl_ca_file and :verify_ssl are all requrired when enabling SSL certs.
 
 Connecting to the store
 -----------------------
@@ -68,27 +87,35 @@ Usage
 
 The API object acts as a gateway to all top level resources in the V2 API.
 
+Fetch Data
 ```
-$ irb
->
-> api = Bigcommerce::Api.new(...)
->
-> api.get_products.each { |product| puts product.name }
->
-> api.get_customers.each { |customer| puts customer.email }
->
-> puts api.get_orders_count
->
-> category = api.get_category(11)
-> category.name = "Laptops"
-> category.update
->
-> brand = Bigcommerce::Api::Brand.new
-> brand.name = "Samsung"
-> brand.create
->
-> option = api.get_option(22)
-> option.delete
->
+orders = api.get_orders
+orders = api.get_orders({:min_id=>100,:max_id=>101})
+orders = api.get_orders(:is_deleted => true)
+
+products = api.get_products
+products = api.get_products(:description=>"iphone", :condition=>"New")
+
+options = api.get_options
+options = api.get_options(:type=>"MT")
+...
+
+```
+Create Data
+```
+api.create_products({:name => "Spiderman - The best return",:price => 9.99,:categories => [17],:type =>"physical",:availability => "available", :weight => 1})
+
+api.update_products(31,{:name => "marvel comics spiderman",:sku => "marvel-spidey-1", :inventory_tracking => "simple", :inventory_level => 500})
+
+api.update_orders(101,{:status_id => 12, :is_deleted => true})
+
+```
+Update Data
+
+```
+api.update_products(31,{:name => "marvel comics spiderman",:sku => "marvel-spidey-1", :inventory_tracking => "simple", :inventory_level => 500})
+
+api.update_optionsets(13,{:name => "Marvel toys"})
+
 ```
 

data/bigcommerce.gemspec

@@ -4,6 +4,7 @@ require File.expand_path('../lib/bigcommerce/version', __FILE__)
 Gem::Specification.new do |s|
   s.add_dependency('activesupport')
   s.add_dependency('json')
+  s.add_dependency('rest-client')
   s.add_development_dependency("ci_reporter")
   s.add_development_dependency("fakeweb")
   s.add_development_dependency("mocha")

data/lib/bigcommerce.rb

@@ -1,6 +1,6 @@
 require "cgi"
 require "json"
-require "net/https"
+require 'rest-client'
 require "uri"
 require 'bigcommerce/api'
 require 'bigcommerce/connection'

data/lib/bigcommerce/api.rb

@@ -5,7 +5,6 @@ module Bigcommerce
       @connection = Connection.new(configuration)
     end
 
-    # Added getter to ensure configuration is correct
     def connection
       @connection
     end
@@ -22,16 +21,14 @@ module Bigcommerce
       @connection.api_key = api_key
     end
 
-    def verify_peer=(verify)
-      @connection.verify_peer = verify
+    def verify_ssl=(verify)
+      @connection.verify_ssl = verify
     end
 
     def ca_file=(path)
       @connection.ca_file = path
     end
 
-    # Returns the date formatted as
-    # RFC 2822 string
     def to_rfc2822(datetime)
       datetime.strftime("%a, %d %b %Y %H:%M:%S %z")
     end
@@ -40,24 +37,24 @@ module Bigcommerce
       @connection.get '/time'
     end
 
-    def get_products(params={})
-      @connection.get '/products'
+    def get_brands(options={})
+      @connection.get("/brands", options)
     end
 
-    def get_products_count
-      @connection.get '/products/count/'
+    def get_brand(id)
+      @connection.get("/brands/#{id}", {})
     end
 
-    def get_brands
-      @connection.get '/brands'
+    def create_brands(options={})
+       @connection.post("/brands", options)
     end
 
-    def get_product(id)
-      @connection.get '/products/' + id.to_s
+    def update_brand(id, options={})
+       @connection.put("/brands/#{id}", options)
     end
 
-    def get_categories
-      @connection.get '/categories'
+    def get_categories(options={})
+       @connection.get("/categories", options)
     end
 
     def get_categories_count
@@ -65,56 +62,288 @@ module Bigcommerce
     end
 
     def get_category(id)
-      @connection.get '/categories/' + id.to_s
+      @connection.get("/categories/#{id}", {})
+    end
+
+    def create_categories(options={})
+       @connection.post("/categories", options)
+    end
+
+    def update_category(id, options={})
+       @connection.put("/categories/#{id}", options)
+    end
+
+    def get_countries(options={})
+      @connection.get("/countries", options)
+    end
+
+    def get_country(id)
+      @connection.get("/countries/#{id}", {})
+    end
+
+    def get_countries_states(options={})
+      @connection.get("/countries/states", options)
+    end
+
+    def get_countries_state(id, options={})
+      @connection.get("/countries/#{id}/states", {})
+    end
+
+    def get_customers(options = {})
+      @connection.get("/customers", options)
+    end
+
+    def get_customer(id)
+      @connection.get('/customers/' + id.to_s, {})
+    end
+
+    def get_customer_addresses(id, options = {})
+      @connection.get("/customers/#{id}/addresses", options)
+    end
+
+    def get_customer_address(customer_id, address_id)
+      @connection.get("/customers/#{customer_id}/addresses/#{address_id}",{})
+    end
+
+    def get_options(options={})
+       @connection.get("/options", options)
+    end
+
+    def get_option(id)
+      @connection.get("/options/#{id}",{})
+    end
+
+    def create_options(options={})
+      @connection.post("/options", options)
+    end
+
+    def update_option(id, options={})
+      @connection.put("/options/#{id}", options)
     end
 
-    def get_orders(params={})
-      @connection.get('/orders', :params => params)
+    def get_options_values(options={})
+       @connection.get("/options/values", options)
     end
 
-    def get_orders_by_date(date, params={})
+    def get_options_value(id)
+      @connection.get("/options/#{id}/values",{})
+    end
+
+    def create_options_values(options_id, options={})
+      @connection.post("/options/#{options_id}/values", options)
+    end
+
+    def update_options_value(options_id, values_id, options={})
+      @connection.put("/options/#{options_id}/values/#{values_id}", options)
+    end   
+
+    def get_optionsets(options={})
+       @connection.get("/optionsets", options)
+    end
+
+    def get_optionset(id)
+      @connection.get("/optionsets/#{id}", {})
+    end
+
+    def create_optionsets(options={})
+      @connection.post("/optionsets", options)
+    end
+
+    def update_optionset(id,options={})
+      @connection.put("/optionsets/#{id}", options)
+    end
+
+    def get_optionsets_options(options={})
+       @connection.get("/optionsets/options", options)
+    end
+
+    def get_optionsets_option(id)
+      @connection.get("/optionsets/options/#{id}", {})
+    end
+
+    def create_optionsets_options(options={})
+      @connection.post("/optionsets/options", options)
+    end
+
+    def update_optionsets_option(id,options={})
+      @connection.put("/optionsets/options/#{id}", options)
+    end
+
+    def get_orders(options={})
+      @connection.get("/orders", options)
+    end
+
+    def get_orders_by_date(date, options={})
       if date.is_a?(String)
         date = DateTime.parse(date)
       end
       date = to_rfc2822(date)
-      @connection.get('/orders', :params => params.merge!(:min_date_created => CGI::escape(date)))
+      @connection.get('/orders', options.merge!(:min_date_created => CGI::escape(date)))
     end
 
-    def get_orders_count
-      get_count @connection.get '/orders/count'
+    def get_orders_modified_since(date)
+      @connection.get('/orders', {}, {'If-Modified-Since' => CGI::escape(to_rfc2822(date))})
     end
 
     def get_order(id)
-      @connection.get '/orders/' + id.to_s
+      @connection.get("/orders/#{id}", {})
     end
 
-    def get_order_products(id)
-      @connection.get '/orders/' + id.to_s + '/products'
+    def update_order(id,options={})
+      @connection.put("/orders/#{id}", options)
     end
 
-    def get_orders_modified_since(datetime)
-      @connection.get('/orders', :headers => {'If-Modified-Since' => CGI::escape(to_rfc2822(datetime))})
+    def get_orders_coupons(id)
+      @connection.get("/orders/#{id}/coupons", {})
     end
 
-    def get_customers(_filters = {})
-      url_filters = _filters.map{|k,v| "#{k}=#{v}"}.join("&")
-      @connection.get "/customers#{url_filters.present? ? ("?" + url_filters) : ""}"
+    def get_orders_product(order_id,coupon_id)
+      @connection.get("/orders/#{order_id}/coupons/#{coupon_id}", {})
     end
 
-    def get_customer(id)
-      @connection.get '/customers/' + id.to_s
+    def get_orders_products(id)
+      @connection.get("/orders/#{id}/products", {})
+    end
+
+    def get_orders_product(order_id,product_id)
+      @connection.get("/orders/#{order_id}/products/#{product_id}", {})
+    end
+
+    def get_orders_shipments(id)
+      @connection.get("/orders/#{id}/shipments", {})
+    end
+
+    def create_orders_shipments(id)
+      @connection.post("/orders/#{id}/shipments", {})
     end
 
-    def get_customer_count
-      @connection.get '/customers/count'
+    def get_orders_shipment(order_id,shipment_id)
+      @connection.get("/orders/#{order_id}/shipments/#{shipment_id}", {})
     end
 
-    def create_product(attributes)
-      @connection.post('/products', :body => attributes.to_xml(:root => 'product'))
+    def update_orders_shipment(order_id,shipment_id,options={})
+      @connection.put("/orders/#{order_id}/shipments/#{shipment_id}", options)
     end
 
-    def update_product(id, attributes)
-      @connection.put("/products/#{id}", :body => attributes.to_xml(:root => 'product'))
+    def get_orders_shippingaddresses(id)
+      @connection.get("/orders/#{id}/shippingaddresses", {})
+    end
+
+    def get_orders_shippingaddress(order_id,shippingaddress_id)
+      @connection.get("/orders/#{order_id}/shippingaddresses/#{shippingaddress_id}", {})
+    end
+
+    def get_orderstatuses(options={})
+      @connection.get("/orderstatuses", options)
+    end
+
+    def get_orderstatuses(id)
+      @connection.get("/orderstatuses/#{id}", {})
+    end
+
+    def get_products(options={})
+      @connection.get("/products", options)
+    end
+
+    def get_product(id)
+      @connection.get("/products/#{id}", {})
+    end
+
+     def create_products(options={})
+      @connection.post('/products', options)
+    end
+
+    def update_products(id, options={})
+      @connection.put("/products/#{id}", options)
+    end
+    
+    def get_products_discountrules(options={})
+      @connection.get("/products/discountrules", options)
+    end
+
+    def get_products_discountrule(product_id, discountrule_id)
+      @connection.get("/products/#{product_id}/discountrules/#{discountrule_id}", {})
+    end
+
+    def get_products_configurablefields(options={})
+      @connection.get("/products/configurablefields", options)
+    end
+
+    def get_products_configurablefield(product_id, configurable_field_id)
+      @connection.get("/products/#{product_id}/configurablefields/#{configurable_field_id}", {})
+    end
+
+    def get_products_customfields(options={})
+      @connection.get("/products/customfields", options)
+    end
+
+    def get_products_customfield(product_id, custom_field_id)
+      @connection.get("/products/#{product_id}/customfields/#{custom_field_id}", {})
+    end
+
+    def get_products_images(options={})
+      @connection.get("/products/images", options)
+    end
+
+    def create_products_images(options={})
+      @connection.post("/products/images", options)
+    end
+
+    def get_products_image(product_id, image_id)
+      @connection.get("/products/#{product_id}/images/#{image_id}", {})
+    end
+
+    def update_products_image(product_id,image_id,options={})
+      @connection.put("/products/#{product_id}/images/#{image_id}", options)
+    end
+
+    def get_products_customfields(options={})
+      @connection.get("/products/options", options)
+    end
+
+    def get_products_option(product_id,option_id)
+      @connection.get("/products/#{product_id}/options/#{option_id}", {})
+    end
+
+    def get_products_rules(options={})
+      @connection.get("/products/rules", options)
+    end
+
+    def create_products_rules(options={})
+      @connection.post("/products/rules", options)
+    end
+
+    def get_products_rule(product_id,rule_id)
+      @connection.get("/products/#{product_id}/rules/#{rule_id}", {})
+    end
+
+    def update_products_rule(product_id, rule_id, options={})
+      @connection.put("/products/#{product_id}/rules/#{rule_id}", options)
+    end
+
+    #products/skus
+    def get_products_skus(options={})
+      @connection.get("/products/skus", options)
+    end
+
+    def create_products_skus(options={})
+      @connection.post("/products/skus", options)
+    end
+
+    def get_products_sku(product_id, sku_id)
+      @connection.get("/products/#{product_id}/skus/#{sku_id}", {})
+    end
+
+    def update_products_sku(product_id, sku_id, options={})
+      @connection.put("/products/#{product_id}/skus/#{sku_id}", options)
+    end
+
+    def get_products_videos(options={})
+      @connection.get("/products/videos", options)
+    end
+
+    def get_products_video(product_id, video_id)
+      @connection.get("/products/#{product_id}/videos/#{video_id}", {})
     end
 
     private
@@ -124,11 +353,11 @@ module Bigcommerce
     end
 
     def get_resource(result)
-
+      result
     end
 
     def get_collection(result)
-
+      result
     end
 
   end

data/lib/bigcommerce/connection.rb

@@ -18,90 +18,70 @@ module Bigcommerce
     end
 
     def verify_peer=(verify)
-      @configuration[:verify_peer] = verify
+      @configuration[:verify_ssl] = verify
     end
 
-    def ca_file=(path)
-      @configuration.ca_file = path
+    def ssl_ca_file=(path)
+      @configuration.ssl_ca_file = path
     end
 
-    def get(path, options = {})
-      request(:get, path, options)
+    def ssl_client_key=(path,passphrase=nil)
+      if passphrase.nil?
+        @configuration.ssl_client_key = OpenSSL::PKey::RSA.new(File.read(path))
+      else
+        @configuration.ssl_client_key = OpenSSL::PKey::RSA.new(File.read(path), passphrase)
+      end
     end
 
-    def post(path, options = {})
-      request(:post, path, options)
+    def ssl_client_cert=(path)
+      @configuration.client_cert = OpenSSL::X509::Certificate.new(File.read(path))
     end
 
-    def put(path, options = {})
-      request(:put, path, options)
+    def get(path, options = {}, headers = {})
+      request(:get, path, options, headers)
     end
 
-    def delete(path, options = {})
-      request(:delete, path, options)
+    def post(path, options = {}, headers = {})
+      request(:post, path, options, headers)
     end
 
-    def request(method, path, options = {})
-      body, params = options.values_at(:body, :params)
-      headers = options[:headers] || {}
-      url = @configuration[:store_url] + '/api/v2' + path
-      param_string = hash_to_params(params) unless params.nil? || params.empty?
-
-      unless (param_string.nil? || param_string.empty?)
-        uri = URI.parse("#{url}?#{param_string}")
-      else
-        uri = URI.parse(url)
-      end
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-
-      if @configuration.has_key?(:verify_peer) && @configuration[:verify_peer]
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      else
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-
-      http.ca_file = @configuration[:ca_path] if @configuration.has_key?(:ca_path)
-
-      request = case method
-                  when :get then
-                    Net::HTTP::Get.new(uri.request_uri)
-                  when :post then
-                    Net::HTTP::Post.new(uri.request_uri)
-                  when :put then
-                    Net::HTTP::Put.new(uri.request_uri)
-                  when :delete then
-                    Net::HTTP::Delete.new(uri.request_uri)
-                end
-
-      request.basic_auth(@configuration[:username], @configuration[:api_key])
-      request.add_field 'Accept', 'application/json'
-      request.add_field 'Content-Type', 'application/json'
-      headers.each { |k,v| request.add_field(k, v) }
-
-      response = http.request(request)
-
-      return case response
-               when Net::HTTPSuccess, Net::HTTPRedirection
-                 JSON.parse(response.body || "{}")
-               else
-                 false
-             end
+    def put(path, options = {}, headers = {})
+      request(:put, path, options, headers)
     end
 
-    def hash_to_params(hash)
-      return nil if hash.nil? || hash.empty?
-
-      # convert the hash to URL params
-      return hash.map {|pair| pair.join("=")}.join("&")
-
-
+    def delete(path, options = {}, headers = {})
+      request(:delete, path, options, headers)
     end
-  end
-
-
-  class HttpError < Exception
 
+    def request(method, path, options,headers={})
+      restclient = RestClient::Resource.new "#{@configuration[:store_url]}/api/v2#{path}.json", @configuration[:username], @configuration[:api_key]
+      if @configuration[:ssl_client_key] && @configuration[:ssl_client_cert] && @configuration[:ssl_ca_file]
+        restclient = RestClient::Resource.new(
+          "#{@configuration[:store_url]}/api/v2#{path}.json",
+          :username => @configuration[:username], 
+          :password => @configuration[:api_key],
+          :ssl_client_cert  =>  @configuration[:ssl_client_cert],
+          :ssl_client_key   =>  @configuration[:ssl_client_key],
+          :ssl_ca_file      =>  @configuration[:ssl_ca_file],
+          :verify_ssl       =>  @configuration[:verify_ssl]
+        )
+      end
+      begin
+        response = case method
+                   when :get then
+                     restclient.get :params => options, :accept => :json, :content_type => :json
+                   when :post then
+                     restclient.post(options.to_json, :content_type => :json, :accept => :json)
+                   when :put then
+                     restclient.put(options.to_json, :content_type => :json, :accept => :json)
+                   when :delete then
+                     restclient.delete
+                   end
+        JSON.parse response
+      rescue => e
+         {"error"=>"Nothing to parse. Possibly no data?"}.to_json
+      end
+    end
+ 
   end
 end

data/lib/bigcommerce/version.rb

@@ -1,6 +1,6 @@
 module Bigcommerce
   major = 0
-  minor = 0
-  patch = 6
+  minor = 8
+  patch = 0
   VERSION = [major, minor, patch].join('.') unless defined? Bigcommerce::VERSION
 end

data/spec/models/api_spec.rb

@@ -35,48 +35,48 @@ describe Bigcommerce::Api do
 
   describe "Orders" do
     it "retrieves an order by ID" do
-      api.connection.should_receive(:get).once.with("/orders/100")
+      api.connection.should_receive(:get).once.with("/orders/100", {})
       api.get_order(100)
     end
 
     it "retrieves orders" do
-      api.connection.should_receive(:get).once.with("/orders", :params => {})
+      api.connection.should_receive(:get).once.with("/orders", {})
       api.get_orders
     end
 
     it "retrieves orders with pagination" do
-      api.connection.should_receive(:get).once.with("/orders", :params => {:page => 2})
+      api.connection.should_receive(:get).once.with("/orders", {:page => 2})
       api.get_orders(:page => 2)
     end
 
     it "retrieves orders with limit" do
-      api.connection.should_receive(:get).once.with("/orders", :params => {:limit => 10})
+      api.connection.should_receive(:get).once.with("/orders", {:limit => 10})
       api.get_orders(:limit => 10)
     end
 
     it "retrieves orders with pagination and limit" do
-      api.connection.should_receive(:get).once.with("/orders", :params => {:limit => 10, :page => 2})
+      api.connection.should_receive(:get).once.with("/orders", {:limit => 10, :page => 2})
       api.get_orders(:limit => 10, :page => 2)
     end
 
     it "converts from DateTime when retrieving orders by date" do
-      api.connection.should_receive(:get).once.with("/orders", :params => {:min_date_created => CGI::escape(rfc2822_datetime)})
+      api.connection.should_receive(:get).once.with("/orders", {:min_date_created => CGI::escape(rfc2822_datetime)})
       api.get_orders_by_date(DateTime.parse('2012-03-13 12:45:26 GMT'))
     end
 
     it "converts from DateTime when retrieving orders by date with pagination" do
-      api.connection.should_receive(:get).once.with("/orders", :params => {:min_date_created => CGI::escape(rfc2822_datetime), :page => 2})
+      api.connection.should_receive(:get).once.with("/orders", {:min_date_created => CGI::escape(rfc2822_datetime), :page => 2})
       api.get_orders_by_date(DateTime.parse('2012-03-13 12:45:26 GMT'), :page => 2)
     end
 
     it "converts from Date when retrieving orders by date" do
-      api.connection.should_receive(:get).once.with("/orders", :params => {:min_date_created => CGI::escape(rfc2822_date)})
+      api.connection.should_receive(:get).once.with("/orders", {:min_date_created => CGI::escape(rfc2822_date)})
       api.get_orders_by_date(Date.parse("2012-03-12"))
     end
 
     it "converts from a datetime string when retrieving orders by date" do
-      api.connection.should_receive(:get).once.with("/orders", :params => {:min_date_created=> CGI::escape(rfc2822_datetime)})
-      api.connection.should_receive(:get).once.with("/orders", :params => {:min_date_created=> CGI::escape(rfc2822_date)})
+      api.connection.should_receive(:get).once.with("/orders", {:min_date_created=> CGI::escape(rfc2822_datetime)})
+      api.connection.should_receive(:get).once.with("/orders", {:min_date_created=> CGI::escape(rfc2822_date)})
 
       api.get_orders_by_date('2012-03-13 12:45:26 GMT')
       api.get_orders_by_date('2012-03-12')
@@ -84,29 +84,10 @@ describe Bigcommerce::Api do
 
     describe '#get_orders_modified_since' do
       it "retrieves orders modified since date-time" do
-        api.connection.should_receive(:get).with('/orders', :headers => {'If-Modified-Since' => CGI::escape(rfc2822_datetime)})
+        api.connection.should_receive(:get).with('/orders', {}, {'If-Modified-Since' => CGI::escape(rfc2822_datetime)})
         api.get_orders_modified_since(DateTime.parse(rfc2822_datetime))
       end
     end
-
-    describe "Products" do
-      describe '#create_product' do
-        before { attributes.stub(:to_xml).with(:root => 'product') { 'product_xml' } }
-        let(:attributes) { stub(:attributes) }
-        it "creates product with passed attributes" do
-          api.connection.should_receive(:post).with('/products', :body => 'product_xml')
-          api.create_product(attributes)
-        end
-      end
-
-      describe '#update_product' do
-        before { attributes.stub(:to_xml).with(:root => 'product') { 'product_xml' } }
-        let(:attributes) { stub(:attributes) }
-        it "updates product with passed attributes" do
-          api.connection.should_receive(:put).with('/products/123', :body => 'product_xml')
-          api.update_product(123, attributes)
-        end
-      end
-    end
+    
   end
 end

data/spec/models/connection_spec.rb

@@ -2,90 +2,23 @@ require 'spec_helper'
 
 shared_examples_for "request method accepting optional params and headers" do
   it "sends request with no params" do
-    connection.should_receive(:request).once.with(http_method, path, {})
+    connection.should_receive(:request).once.with(http_method, path, {}, {})
     connection.send(http_method, path)
   end
 
   it "sends request with params" do
-    connection.should_receive(:request).once.with(http_method, path, :params => {:page => 3})
-    connection.send(http_method, path, :params => {:page => 3})
+    connection.should_receive(:request).once.with(http_method, path, {:page => 3}, {})
+    connection.send(http_method, path, {:page => 3})
   end
 
   it "sends request with headers" do
-    connection.should_receive(:request).once.with(http_method, "/orders", :headers =>  {'Some-Header' => 'abc'})
-    connection.send(http_method, path, :headers => {'Some-Header' => 'abc'})
+    connection.should_receive(:request).once.with(http_method, "/orders", {}, {'Some-Header' => 'abc'})
+    connection.send(http_method, path, {}, {'Some-Header' => 'abc'})
   end
-end
-
-describe Bigcommerce::Connection do
-  before { FakeWeb.allow_net_connect = false }
-  after { FakeWeb.clean_registry }
-  subject(:connection) do
-    Bigcommerce::Connection.new(
-      :store_url => "https://store-12345.mybigcommerce.com",
-      :username => "test",
-      :api_key => "12345"
-    )
-  end
-
-  [:get, :post, :put, :delete].each do |http_method|
-    let(:path) { '/orders' }
-    describe "##{http_method}" do
-      eval "let(:http_method) { :#{http_method} }"
-      it_behaves_like "request method accepting optional params and headers"
-    end
-
-    describe '#request' do
-      context "when #{http_method.to_s.upcase} request" do
-        before do
-          http_class.stub(:new) { request }
-          Net::HTTP.stub(:new) { stub.as_null_object }
-        end
-        let(:http_class) { eval "Net::HTTP::#{http_method.to_s.gsub(/^(.)/) { $1.upcase }}" }
-        let(:args) { [http_method, path, options] }
-        let(:body) { nil }
-        let(:params) { {} }
-        let(:headers) { {} }
-        let(:options) { {:body => body, :params => params, :headers => headers}.reject { |k,v| v.nil? } }
-        let(:request) { stub.as_null_object }
-
-        it "requests path with API prefix" do
-          http_class.should_receive(:new).with("/api/v2#{path}")
-          connection.request(*args)
-        end
-
-        context "with querystring" do
-          let(:params) { {:foo => 'bar'} }
-
-          it "includes querystring" do
-            http_class.should_receive(:new).with("/api/v2#{path}?foo=bar")
-            connection.request(*args)
-          end
-        end
-
-        context "with custom header" do
-          let(:headers) { {'Some-Header' => 'abc'} }
-
-          it "includes custom header" do
-            request.should_receive(:add_field).with('Some-Header', 'abc')
-            request.stub(:add_field) # ignoring other headers
-            connection.request(*args)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#hash_to_params" do
-    # TODO: Consider using addressable gem; see <http://stackoverflow.com/a/803067/3528> for examples.
-    it "converts flat hashes to query strings" do
-      connection.hash_to_params({:a => 1, :b => 2}).should eql "a=1&b=2"
-    end
-    it "converts empty hashes to nil" do
-      connection.hash_to_params({}).should be_nil
-    end
-    it "leaves nil as nil" do
-      connection.hash_to_params(nil).should be_nil
-    end
+  
+  it "sends request with params and headers" do
+    connection.should_receive(:request).once.with(http_method, "/orders", {:page => 6}, {'Some-Header' => 'abc'})
+    connection.send(http_method, path, {:page => 6}, {'Some-Header' => 'abc'})
   end
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bigcommerce
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-14 00:00:00.000000000 Z
+date: 2013-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -43,6 +43,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ci_reporter
   requirement: !ruby/object:Gem::Requirement
@@ -164,11 +180,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Enables Ruby applications to communicate with the Bigcommerce API
 test_files:
 - spec/models/api_spec.rb
 - spec/models/connection_spec.rb
-has_rdoc: false