bigcommerce 0.10.0 → 1.0.0.beta

data/lib/bigcommerce/connection.rb

@@ -1,171 +0,0 @@
-module Bigcommerce
-  class Connection
-    attr_reader :configuration, :remaining_rate_limit
-
-    def initialize(configuration)
-      @configuration = {}
-      configuration.each do |key, val|
-        send(key.to_s + "=", val)
-      end
-    end
-
-    def store_hash=(store_hash)
-      @configuration[:store_hash] = store_hash
-    end
-
-    def client_id=(client_id)
-      @configuration[:client_id] = client_id
-    end
-
-    def access_token=(access_token)
-      @configuration[:access_token] = access_token
-    end
-
-    def store_url=(store_url)
-      url = URI.parse(store_url)
-      @configuration[:store_url] = url.scheme + "://" + url.host
-    end
-
-    def username=(username)
-      @configuration[:username] = username
-    end
-
-    def api_key=(api_key)
-      @configuration[:api_key] = api_key
-    end
-
-    def verify_peer=(verify)
-      @configuration[:verify_ssl] = verify
-    end
-
-    def ssl_ca_file=(path)
-      @configuration.ssl_ca_file = path
-    end
-
-    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 ssl_client_cert=(path)
-      @configuration.client_cert = OpenSSL::X509::Certificate.new(File.read(path))
-    end
-
-    def get(path, options = {}, headers = {})
-      request(:get, path, options, headers)
-    end
-
-    def post(path, options = {}, headers = {})
-      request(:post, path, options, headers)
-    end
-
-    def put(path, options = {}, headers = {})
-      request(:put, path, options, headers)
-    end
-
-    def delete(path, options = {}, headers = {})
-      request(:delete, path, options, headers)
-    end
-
-    # Make a request to the bigcommerce API using either Legacy or OAuth
-    def request(method, path, options,headers={})
-      if oauth?
-        request_oauth(method, path, options, headers)
-      else
-        request_legacy(method, path, options, headers)
-      end
-    end
-
-    private
-
-    def oauth?
-      @configuration[:store_hash] && @configuration[:client_id] && @configuration[:access_token]
-    end
-
-    def request_oauth(method, path, options, headers={})
-      uri = File.join((ENV['BC_API_ENDPOINT'] || 'https://api.bigcommerce.com'), '/stores', @configuration[:store_hash], '/v2', path)
-
-      rest_client = RestClient::Resource.new uri.to_s, {
-        headers: headers.merge({
-          'X-Auth-Client' => @configuration[:client_id],
-          'X-Auth-Token' => @configuration[:access_token],
-          :accept => :json,
-          :content_type => :json
-        })
-      }
-
-      response = case method
-        when :get then
-          rest_client.get :params => options
-        when :post then
-          rest_client.post(options.to_json)
-        when :put then
-          rest_client.put(options.to_json)
-        when :delete then
-          rest_client.delete
-        when :head then
-          rest_client.head
-        when :options then
-          rest_client.options
-        else
-          raise 'Unsupported method!'
-      end
-
-      if (200..201) === response.code
-        JSON.parse response
-      elsif response.code == 204
-        {}
-      end
-    end
-
-    def request_legacy(method, path, options, headers={})
-      resource_options = {
-          :user => @configuration[:username],
-          :password => @configuration[:api_key],
-          :headers => headers
-      }
-
-      rest_client = RestClient::Resource.new "#{@configuration[:store_url]}/api/v2#{path}.json", resource_options
-
-      if @configuration[:ssl_client_key] && @configuration[:ssl_client_cert] && @configuration[:ssl_ca_file]
-        rest_client = 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
-
-      response = case method
-        when :get then
-          rest_client.get :params => options, :accept => :json, :content_type => :json
-        when :post then
-          rest_client.post(options.to_json, :content_type => :json, :accept => :json)
-        when :put then
-          rest_client.put(options.to_json, :content_type => :json, :accept => :json)
-        when :delete then
-          rest_client.delete
-        when :head then
-          rest_client.head
-        when :options then
-          rest_client.options
-        else
-          raise 'Unsupported method!'
-      end
-
-      @remaining_rate_limit = response.headers[:x_bc_apilimit_remaining]
-      if (200..201) === response.code
-        JSON.parse response
-      elsif response.code == 204
-        {}
-      end
-    end
-
-  end
-end

data/lib/bigcommerce/product.rb

@@ -1,13 +0,0 @@
-module Bigcommerce
-  class Product < Resource
-
-    # Here we memoize brand, so we can re-use it across different products
-    # Note we store this across the class
-    def brand
-      key = @hash["brand"]["resource"]
-      @@some_method ||= {}
-      @@some_method[key] ||= @connection.get(@hash["brand"]["resource"])
-    end
-
-  end
-end

data/lib/bigcommerce/resource.rb

@@ -1,50 +0,0 @@
-module Bigcommerce
-  class Resource
-
-    def metaclass
-      class << self; self; end
-    end
-
-    def initialize hash, connection
-      @connection = connection
-      @hash = hash
-      @hash.each do |key, value|
-        if (value.class == Hash)
-          self.resourceify(key, value)
-        end
-      end
-      @full_hash = @hash
-    end
-
-    def [](key)
-      @hash[key]
-    end
-
-    def []=(key,value)
-      @hash[key] = value
-    end
-
-    def resourceify(name, data)
-      if (!self.respond_to?(name.to_sym))
-        self.metaclass.send(:define_method, name) do
-          @connection.get data["resource"]
-        end
-      end
-    end
-
-    def load(*sub_resources)
-      sub_resources.each do |sub_resource|
-        begin
-          @full_hash[sub_resource.to_s] = self.send(sub_resource)
-        rescue RuntimeError => e
-          puts e
-        end
-      end
-    end
-
-    def to_json
-      @full_hash.to_json
-    end
-
-  end
-end

data/spec/big_commerce_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe "BigCommerce" do
-  describe "require 'big_commerce'" do
-    it "should raise exception when required" do
-      lambda { (require 'big_commerce').should raise(RuntimeError) }
-    end
-  end
-end

data/spec/integration/orders_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe "/api/v2/orders" do
-  include_context "integration"
-
-  it "gets the orders collection", :vcr do
-    orders = api.orders
-    orders.should be_a_kind_of(Enumerable)
-    orders.size.should be > 0
-  end
-
-  it "filters orders by date", :vcr do
-    orders = api.orders_by_date('2013-03-01')
-    orders.should be_a_kind_of(Enumerable)
-    orders.size.should be > 0
-  end
-
-end

data/spec/support/integration_context.rb

@@ -1,13 +0,0 @@
-shared_context "integration" do
-  let :api do
-    ENV['API_URL'] = ENV['API_URL'] || 'https://store-vnh06c71.mybigcommerce.com'
-    ENV['API_USER'] = ENV['API_USER'] || 'apiuser'
-    ENV['API_PASS'] = ENV['API_PASS'] || '123456'
-    
-    Bigcommerce::Api.new({
-      :store_url => ENV['API_URL'],
-      :username => ENV['API_USER'],
-      :api_key => ENV['API_PASS']
-    })
-  end
-end

data/spec/support/mock_api_context.rb

@@ -1,10 +0,0 @@
-shared_context "mock api" do
-  let :api do
-    connection = double(Bigcommerce::Connection)
-    api = Bigcommerce::Api.new
-    api.instance_eval do
-      @connection = connection
-    end
-    api
-  end
-end

data/spec/unit/api_request_spec.rb

@@ -1,34 +0,0 @@
-describe "API request delegation" do
-  include_context "mock api"
-
-  it "requests a resource" do
-    api.connection.should_receive(:get).once.with("/time")
-    api.time
-  end
-
-  it "requests a resource by id" do
-    api.connection.should_receive(:get).once.with("/products/333", {})
-    api.product(333)
-  end
-
-  it "requests a compound resource by ids" do
-    api.connection.should_receive(:get).once.with("/orders/999/products/333", {})
-    api.orders_product(999, 333)
-  end
-
-  it "requests a resource with pagination" do
-    api.connection.should_receive(:get).once.with("/orders", {:page => 2})
-    api.orders(:page => 2)
-  end
-
-  it "requests a resource with limit" do
-    api.connection.should_receive(:get).once.with("/categories", {:limit => 10})
-    api.categories(:limit => 10)
-  end
-
-  it "request a resource with pagination and limit" do
-    api.connection.should_receive(:get).once.with("/customers", {:limit => 10, :page => 2})
-    api.customers(:limit => 10, :page => 2)
-  end
-
-end

data/spec/unit/api_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce::Api do
-  include_context "mock api"
-
-  describe "orders_by_date" do
-    it "should accept a valid Date object" do
-      date = DateTime.now
-      parsed_date = described_class.new.to_rfc2822(date)
-      api.connection.should_receive(:get).once.with("/orders",
-                                                    {:min_date_created => parsed_date})
-      api.orders_by_date(date)
-    end
-
-    it "should parse a valid date string" do
-      date = described_class.new.to_rfc2822(DateTime.parse('2012-1-1'))
-      api.connection.should_receive(:get).once.with("/orders",
-                                                    {:min_date_created => date})
-      api.orders_by_date('2012-1-1')
-    end
-  end
-
-  describe "#create-orders-shipments" do
-    it "should accept an order id parameter" do
-      api.connection.should_receive(:post).once.with("/orders/123/shipments", {})
-      api.create_orders_shipments(123)
-    end
-
-    it "should accept an order id parameter and an options hash" do
-      options = Hash[*('A'..'Z').to_a.flatten]
-      api.connection.should_receive(:post).once.with("/orders/123/shipments", options)
-      api.create_orders_shipments(123, options)
-    end
-  end
-
-  describe "#get-options-value" do
-    it "should accept an option id parameter" do
-      api.connection.should_receive(:get).once.with("/options/123/values", {})
-      api.options_value(123)
-    end
-
-    it "should accept an option id parameter and an options hash" do
-      options = Hash[*('A'..'Z').to_a.flatten]
-      api.connection.should_receive(:get).once.with("/options/123/values", options)
-      api.options_value(123, options)
-    end
-  end
-
-end

data/spec/unit/connection_spec.rb

@@ -1,23 +0,0 @@
-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.send(http_method, path)
-  end
-
-  it "sends request with params" do
-    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", {}, {'Some-Header' => 'abc'})
-    connection.send(http_method, path, {}, {'Some-Header' => 'abc'})
-  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

data/spec/unit/date_time_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce::Api do
-
-  let(:api) do
-    Bigcommerce::Api.new({
-      :store_url => "https://store-12345.mybigcommerce.com",
-      :username => "test", :api_key => "12345"
-    })
-  end
-
-  let(:rfc2822_datetime) { "Tue, 13 Mar 2012 12:45:26 +0000" }
-  let(:rfc2822_date)     { "Mon, 12 Mar 2012 00:00:00 +0000" }
-
-  describe "RFC 2822 DateTime format" do
-
-    it "converts raw date times to RFC 2822 format" do
-      api.to_rfc2822(DateTime.parse('2012-03-13 12:45:26 +0000')).should eql rfc2822_datetime
-    end
-    
-    it "converts textual date times to RFC 2822 format" do
-      api.to_rfc2822(DateTime.parse('12th March 2012')).should eql rfc2822_date
-    end
-
-    it "converts ISO 8601 dates to RFC 2822 format" do
-      api.to_rfc2822(DateTime.parse('2012-03-12')).should eql rfc2822_date
-    end
-
-  end
-  
-end

data/spec/unit/version_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce do
-  describe 'VERSION' do
-    it "should have a version number set" do
-      expect(Bigcommerce::VERSION).to_not be_nil
-    end
-
-    it "should use a semantic version format" do
-      expect(Bigcommerce::VERSION).to match(/\d+\.\d+\.\d+(rc\d?)?/)
-    end
-  end
-end