bigcommerce 1.0.0.beta → 1.0.1

data/spec/bigcommerce/bigcommerce_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce do
-  let(:middleware) do
-    api.instance_variable_get('@builder').instance_variable_get('@handlers')
-  end
-
-  it 'should return a faraday object when configured' do
-    Bigcommerce.configure do |config|
-      config.url = 'http://foobar.com'
-      config.auth = 'legacy'
-      config.api_key = '214789175'
-      config.username = 'admin'
-    end
-    expect(Bigcommerce.api).to be_a_kind_of(Faraday::Connection)
-  end
-
-  describe '.build_connection' do
-    context 'when using legacy' do
-      let(:api) do
-        Bigcommerce.configure do |config|
-          config.url = 'http://foobar.com'
-          config.auth = 'legacy'
-          config.api_key = '214789175'
-          config.username = 'admin'
-        end
-      end
-
-      it 'should have the correct auth middleware' do
-        expect(middleware).to include(Faraday::Request::BasicAuthentication)
-      end
-    end
-
-    context 'when not using legacy' do
-      let(:api) do
-        Bigcommerce.configure do |config|
-          config.access_token = 'jksdgkjbhksjdb'
-          config.client_id = 'negskjgdjkbg'
-        end
-      end
-
-      it 'should have the correct auth middleware' do
-        expect(middleware).to include(Bigcommerce::Middleware::Auth)
-      end
-    end
-  end
-
-  describe 'multiple configurations' do
-    it 'should use the configuration for the most recently defined' do
-      Bigcommerce.configure do |config|
-        config.access_token = 'jksdgkjbhksjdb'
-        config.client_id = 'negskjgdjkbg'
-      end
-
-      Bigcommerce.configure do |config|
-        config.url = 'http://foobar.com'
-        config.auth = 'legacy'
-        config.api_key = '214789175'
-        config.username = 'admin'
-      end
-
-      expect(Bigcommerce.api.instance_variable_get('@builder')
-                .instance_variable_get('@handlers'))
-                .to include(Faraday::Request::BasicAuthentication)
-
-      Bigcommerce.configure do |config|
-        config.access_token = 'jksdgkjbhksjdb'
-        config.client_id = 'negskjgdjkbg'
-      end
-
-      expect(Bigcommerce.api.instance_variable_get('@builder')
-                .instance_variable_get('@handlers'))
-                .to include(Bigcommerce::Middleware::Auth)
-    end
-  end
-end

data/spec/bigcommerce/unit/actions_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce::ResourceActions do
-  before do
-    module Bigcommerce
-      class DummyClass
-        include ResourceActions.new(uri: 'http://foo.bar/%d')
-      end
-    end
-    @klass = Bigcommerce::DummyClass
-  end
-
-  let(:params) do
-    { page: 1 }
-  end
-
-  it 'should have options' do
-    mod = Bigcommerce::ResourceActions.new(
-      uri: 'http://foo.bar',
-      disable: [:find,:all]
-    )
-    options = {
-      uri: 'http://foo.bar',
-      disable: [:find,:all]
-    }
-    expect(mod._options).to eq options
-  end
-
-  describe '.all' do
-    it 'should make a get request to the correct route with query params' do
-      expect(@klass).to receive(:get).with('http://foo.bar', page: 1)
-      @klass.all(params)
-    end
-
-    it 'should make a get request to the correct route' do
-      expect(@klass).to receive(:get).with('http://foo.bar', {})
-      params.delete(:params)
-      @klass.all
-    end
-  end
-
-  describe '.find' do
-    it 'should make a get request to the correct route' do
-      expect(@klass).to receive(:get).with('http://foo.bar/1')
-      @klass.find(1)
-    end
-  end
-
-  describe '.create' do
-    it 'should make a post request to the correct route with params' do
-      expect(@klass).to receive(:post).with('http://foo.bar', page: 1)
-      @klass.create(params)
-    end
-  end
-
-  describe '.update' do
-    it 'should make a put request to the correct route with params' do
-      expect(@klass).to receive(:put).with('http://foo.bar/1', page: 1)
-      @klass.update(1, params)
-    end
-  end
-
-  describe '.destroy' do
-    it 'should make a delete request to the correct route with params' do
-      expect(@klass).to receive(:delete).with('http://foo.bar/1')
-      @klass.destroy(1)
-    end
-  end
-
-  describe '.destroy_all' do
-    it 'should make a delete request to the correct route with params' do
-      expect(@klass).to receive(:delete).with('http://foo.bar')
-      @klass.destroy_all
-    end
-  end
-end
-
-describe Bigcommerce::SubresourceActions do
-  before do
-    module Bigcommerce
-      class DummyClass
-        include SubresourceActions.new(uri: 'http://foo.bar/%d/%d')
-      end
-    end
-    @klass = Bigcommerce::DummyClass
-  end
-
-  let(:params) do
-    { page: 1 }
-  end
-
-  it 'should have options' do
-    mod = Bigcommerce::SubresourceActions.new(
-      uri: 'http://foo.bar',
-      disable: [:find,:all]
-    )
-    options = {
-      uri: 'http://foo.bar',
-      disable: [:find,:all]
-    }
-    expect(mod._options).to eq options
-  end
-
-  describe '.all' do
-    it 'should make a get request to the correct route with query params' do
-      expect(@klass).to receive(:get).with('http://foo.bar/1', page: 1)
-      @klass.all(1, params)
-    end
-
-    it 'should make a get request to the correct route' do
-      expect(@klass).to receive(:get).with('http://foo.bar/1', {})
-      params.delete(:params)
-      @klass.all(1)
-    end
-  end
-
-  describe '.find' do
-    it 'should make a get request to the correct route' do
-      expect(@klass).to receive(:get).with('http://foo.bar/1/2')
-      @klass.find(1,2)
-    end
-  end
-
-  describe '.create' do
-    it 'should make a post request to the correct route with params' do
-      expect(@klass).to receive(:post).with('http://foo.bar/1', page: 1)
-      @klass.create(1, params)
-    end
-  end
-
-  describe '.update' do
-    it 'should make a put request to the correct route with params' do
-      expect(@klass).to receive(:put).with('http://foo.bar/1/2', page: 1)
-      @klass.update(1, 2, params)
-    end
-  end
-
-  describe '.destroy' do
-    it 'should make a delete request to the correct route with params' do
-      expect(@klass).to receive(:delete).with('http://foo.bar/1/2')
-      @klass.destroy(1, 2)
-    end
-  end
-
-  describe '.destroy_all' do
-    it 'should make a delete request to the correct route with params' do
-      expect(@klass).to receive(:delete).with('http://foo.bar/1')
-      @klass.destroy_all(1)
-    end
-  end
-end

data/spec/bigcommerce/unit/exception_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce::HttpErrors do
-  let(:dummy_class) { Class.new { extend Bigcommerce::HttpErrors } }
-
-  it '::ERRORS is not nil' do
-    expect(Bigcommerce::HttpErrors::ERRORS).not_to be_nil
-  end
-
-  context 'invalid response status' do
-    it 'should throw an exception' do
-      code = 404
-      expect { dummy_class.throw_http_exception!(code) }.to raise_exception
-    end
-
-    it 'should have a valid error' do
-      codes = Bigcommerce::HttpErrors::ERRORS.keys
-      codes.each do |code|
-        expect { dummy_class.throw_http_exception!(code) }.to raise_exception
-      end
-    end
-
-    it 'should allow you to pass in an error message when throwing exception' do
-      code = 404
-      env = double
-      allow(env).to receive(:body) { {} }
-      allow(env).to receive(:[]) { {} }
-      expect do
-        dummy_class.throw_http_exception!(code, env)
-      end.to raise_exception(Bigcommerce::HttpErrors::ERRORS[code])
-    end
-
-    it 'should parse out a retry-after header if present' do
-      code = 429
-      env = double
-      allow(env).to receive(:body) { "{\"time\":1426184190}" }
-      allow(env).to receive(:[]).with(:response_headers).and_return('X-Retry-After' => 1)
-      begin
-        dummy_class.throw_http_exception!(code, env)
-      rescue Bigcommerce::TooManyRequests => e
-        expect(e.response_headers[:retry_after]).to eq 1
-      end
-    end
-  end
-
-  context 'valid response status' do
-    it 'should not throw an exception' do
-      code = 200
-      env = double
-      expect { dummy_class.throw_http_exception!(code, env) }.to_not raise_exception
-    end
-  end
-end

data/spec/bigcommerce/unit/middleware/auth_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce::Middleware::Auth do
-  it 'should set the correct headers' do
-    app = double
-    options = {
-      client_id: 'client_id',
-      access_token: 'access_token'
-    }
-    @api = Bigcommerce::Middleware::Auth.new(app, options)
-    expect(app).to receive(:call).with(
-      request_headers: {
-        'X-Auth-Client' => 'client_id',
-        'X-Auth-Token' => 'access_token'
-      })
-    @api.call(request_headers: {})
-  end
-end

data/spec/bigcommerce/unit/middleware/http_exception_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce::Middleware::HttpException do
-  before(:each) { @e = Bigcommerce::Middleware::HttpException.new }
-
-  it 'should check for an error on all responses' do
-    env = {
-      status: '200',
-      body: 'Valid'
-    }
-    expect(@e).to receive(:throw_http_exception!).with(200, env)
-    @e.on_complete env
-  end
-
-  context 'when valid response' do
-    let(:env) do
-      {
-        status: '200',
-        body: 'Valid'
-      }
-    end
-
-    it 'should return its argument if no errors' do
-      expect(@e.on_complete(env)).to eq env
-    end
-  end
-
-  context 'when invalid response' do
-    let(:env) do
-      {
-        status: '404',
-        body: 'Error'
-      }
-    end
-
-    it 'should throw an exception' do
-      expect { @e.on_complete(env) }.to raise_exception
-    end
-  end
-end

data/spec/bigcommerce/unit/request_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-describe Bigcommerce::Request do
-  before do
-    module Bigcommerce
-      class DummyClass
-        include Request.new 'foo/%d'
-      end
-    end
-    @klass = Bigcommerce::DummyClass
-  end
-
-  describe '.path' do
-    it 'should have a path method to expose the path_builder' do
-      expect(@klass.path).to be_kind_of Bigcommerce::PathBuilder
-    end
-  end
-
-  describe 'ClassMethods' do
-    before do
-      double Bigcommerce.api
-    end
-
-    let(:json) { "{\"body\":[{\"time\":1426184190},{\"time\":1426184190}]}" }
-
-    describe '.get' do
-      it 'should call raw_request and build_response_object' do
-        allow(@klass).to receive(:raw_request) { json }
-        expect(@klass).to receive(:raw_request).with(:get, @klass.path, {})
-        expect(@klass).to receive(:build_response_object).with(json)
-        @klass.get(@klass.path, {})
-      end
-    end
-
-    describe '.delete' do
-      it 'should call raw_request' do
-        response = double
-        allow(response).to receive(:body) { '' }
-        allow(@klass).to receive(:raw_request) { response }
-        expect(@klass).to receive(:raw_request).with(:delete, @klass.path)
-        @klass.delete(@klass.path)
-      end
-    end
-
-    describe '.post' do
-      it 'should call raw_request and build_response_object' do
-        allow(@klass).to receive(:raw_request) { json }
-        expect(@klass).to receive(:raw_request).with(:post, @klass.path, {})
-        expect(@klass).to receive(:build_response_object).with(json)
-        @klass.post(@klass.path, {})
-      end
-    end
-
-    describe '.put' do
-      it 'should call raw_request and build_response_object' do
-        allow(@klass).to receive(:raw_request) { json }
-        expect(@klass).to receive(:raw_request).with(:put, @klass.path, {})
-        expect(@klass).to receive(:build_response_object).with(json)
-        @klass.put(@klass.path, {})
-      end
-    end
-
-    describe '.raw_request' do
-      before do
-        Bigcommerce.configure do |config|
-          config.client_id = 'sdbgksjbg4'
-          config.access_token = 'jkdgbdsgbg'
-          config.store_hash = 'sdgjnsdjg'
-        end
-        @api = Bigcommerce.api
-      end
-
-      it 'send its method to Bigcommerce.api' do
-        response = double
-        allow(@api).to receive(:get) { response }
-        allow(response).to receive(:headers) { '' }
-        expect(@api).to receive(:get).with('path/1', nil)
-        expect(response).to receive(:headers)
-        @klass.raw_request(:get, 'path/1')
-      end
-    end
-
-    describe 'private methods' do
-      describe '.build_response_object' do
-        before do
-          module Bigcommerce
-            class DummyClass
-              include Request.new 'foo/%d'
-              def initialize(params)
-                @params = params
-              end
-            end
-          end
-          @klass_with_init = Bigcommerce::DummyClass
-        end
-
-        describe 'json array' do
-          let(:json) { "[{\"time\":1426184190},{\"time\":1426184190}]" }
-
-          it 'should build an array of objects' do
-            response = double
-            allow(response).to receive(:body) { json }
-            objs = @klass_with_init.send(:build_response_object, response)
-            expect(objs).to be_kind_of Array
-            objs.each do |obj|
-              expect(obj).to be_kind_of Bigcommerce::DummyClass
-            end
-          end
-        end
-        describe 'json object' do
-          let(:json) { "{\"time\":1426184190}" }
-          it 'should build an object' do
-            response = double
-            allow(response).to receive(:body) { json }
-            objs = @klass_with_init.send(:build_response_object, response)
-            expect(objs).to be_kind_of Bigcommerce::DummyClass
-          end
-        end
-      end
-
-      describe '.parse' do
-        describe 'empty string' do
-          let(:json) { "" }
-
-          it 'should return an array' do
-            expect(@klass.send(:parse, json)).to be_kind_of Array
-          end
-        end
-
-        describe 'valid json' do
-          let(:json) { "{\"time\":1426184190}" }
-
-          it 'should symbolize keys' do
-            expect(@klass.send(:parse, json)).to eq({time:1426184190})
-          end
-
-          it 'should return a hash' do
-            expect(@klass.send(:parse, json)).to be_kind_of Hash
-          end
-        end
-      end
-    end
-  end
-end
-
-describe Bigcommerce::PathBuilder do
-  let(:uri) { 'bar/%d' }
-  before do
-    @path_builder = Bigcommerce::PathBuilder.new uri
-  end
-
-  describe '.to_s' do
-    it 'should return uri' do
-      expect(@path_builder.to_s).to eq uri
-    end
-  end
-
-  describe '.build' do
-    context 'hash of keys' do
-      let(:keys) { 1 }
-      it 'should build a formed path' do
-        expect(@path_builder.build keys).to eq 'bar/1'
-      end
-    end
-
-    context 'integer keys' do
-      let(:keys) { 1 }
-      it 'should build a formed path' do
-        expect(@path_builder.build keys).to eq 'bar/1'
-      end
-    end
-
-    context 'integer keys' do
-      let(:keys) { nil }
-      it 'should build a formed path' do
-        expect(@path_builder.build keys).to eq 'bar'
-      end
-    end
-  end
-end