restforce 1.3.0 → 1.4.0

data/spec/unit/concerns/authentication_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Restforce::Concerns::Authentication do
+  describe '.authenticate!' do
+    subject { lambda { client.authenticate! } }
+
+    context 'when there is no authentication middleware' do
+      before do
+        client.stub :authentication_middleware => nil
+      end
+
+      it { should raise_error Restforce::AuthenticationError, 'No authentication middleware present' }
+    end
+
+    context 'when there is authentication middleware' do
+      let(:authentication_middleware) { double('Authentication Middleware') }
+      subject(:result) { client.authenticate! }
+
+      it 'authenticates using the middleware' do
+        client.stub :authentication_middleware => authentication_middleware
+        client.stub :options
+        authentication_middleware.
+          should_receive(:new).
+          with(nil, client, client.options).
+          and_return(stub(:authenticate! => 'foo'))
+        expect(result).to eq 'foo'
+      end
+    end
+  end
+
+  describe '.authentication_middleware' do
+    subject { client.authentication_middleware }
+
+    context 'when username and password options are provided' do
+      before do
+        client.stub :username_password? => true
+      end
+
+      it { should eq Restforce::Middleware::Authentication::Password }
+    end
+
+    context 'when oauth options are provided' do
+      before do
+        client.stub :username_password? => false
+        client.stub :oauth_refresh? => true
+      end
+
+      it { should eq Restforce::Middleware::Authentication::Token }
+    end
+  end
+
+  describe '.username_password?' do
+    subject       { client.username_password? }
+    let(:options) { Hash.new }
+
+    before do
+      client.stub :options => options
+    end
+
+    context 'when username and password options are provided' do
+      let(:options) do
+        { :username      => 'foo',
+          :password      => 'bar',
+          :client_id     => 'client',
+          :client_secret => 'secret' }
+      end
+
+      it { should be_true }
+    end
+
+    context 'when username and password options are not provided' do
+      it { should_not be_true }
+    end
+  end
+
+  describe '.oauth_refresh?' do
+    subject       { client.oauth_refresh? }
+    let(:options) { Hash.new }
+
+    before do
+      client.stub :options => options
+    end
+
+    context 'when oauth options are provided' do
+      let(:options) do
+        { :refresh_token => 'token',
+          :client_id     => 'client',
+          :client_secret => 'secret' }
+      end
+
+      it { should be_true }
+    end
+
+    context 'when oauth options are not provided' do
+      it { should_not be_true }
+    end
+  end
+end

data/spec/unit/concerns/base_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Restforce::Concerns::Base do
+  describe '#new' do
+    context 'without options passed in' do
+      it 'does not raise an exception' do
+        expect {
+          klass.new
+        }.to_not raise_error
+      end
+    end
+
+    context 'with a non-hash value' do
+      it 'raises an ArgumentError exception' do
+        expect {
+          klass.new 'foo'
+        }.to raise_error ArgumentError, 'Please specify a hash of options'
+      end
+    end
+
+    it 'yields the builder to the block' do
+      klass.any_instance.stub :builder
+      expect { |b| klass.new(&b) }.to yield_control
+    end
+  end
+
+  describe '.options' do
+    subject { lambda { client.options } }
+    it { should_not raise_error }
+  end
+
+  describe '.instance_url' do
+    subject { client.instance_url }
+
+    context 'when options[:instance_url] is unset' do
+      it 'triggers an authentication' do
+        client.should_receive :authenticate!
+        subject
+      end
+    end
+
+    context 'when options[:instance_url] is set' do
+      before do
+        client.stub :options => { :instance_url => 'foo' }
+      end
+
+      it { should eq 'foo' }
+    end
+  end
+end

data/spec/unit/concerns/caching_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Restforce::Concerns::Caching do
+  describe '.without_caching' do
+    let(:options) { double('Options') }
+
+    before do
+      client.stub :options => options
+    end
+
+    it 'runs the block with caching disabled' do
+      options.should_receive(:[]=).with(:use_cache, false)
+      options.should_receive(:delete).with(:use_cache)
+      expect { |b| client.without_caching(&b) }.to yield_control
+    end
+
+    context 'when an exception is raised' do
+      it 'ensures the :use_cache is deleted' do
+        options.should_receive(:[]=).with(:use_cache, false)
+        options.should_receive(:delete).with(:use_cache)
+        expect {
+          client.without_caching do
+            raise 'Foo'
+          end
+        }.to raise_error 'Foo'
+      end
+    end
+  end
+end

data/spec/unit/concerns/canvas_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Restforce::Concerns::Canvas do
+  let(:options) { Hash.new }
+
+  before do
+    client.stub :options => options
+  end
+
+  describe '.decode_signed_request' do
+    subject              { client.decode_signed_request(signed_request) }
+    let(:signed_request) { double('Signed Request') }
+
+    context 'when the client_secret is set' do
+      let(:options) { { :client_secret => 'secret' } }
+
+      it 'delegates to Restforce::SignedRequest' do
+        Restforce::SignedRequest.should_receive(:decode).
+          with(signed_request, options[:client_secret])
+        client.decode_signed_request(signed_request)
+      end
+    end
+
+    context 'when the client_secret is not set' do
+      it 'raises an exception' do
+        expect { subject }.to raise_error 'client_secret not set.'
+      end
+    end
+  end
+end

data/spec/unit/concerns/connection_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Restforce::Concerns::Connection do
+  describe '.middleware' do
+    subject       { client.middleware }
+    let(:builder) { double('Faraday::Builder') }
+
+    before do
+      client.stub_chain :connection, :builder => builder
+    end
+
+    it { should eq builder }
+  end
+end

data/spec/{lib → unit}/config_spec.rb

@@ -32,21 +32,14 @@ describe Restforce do
 
     context 'when environment variables are defined' do
       before do
-        ENV['SALESFORCE_USERNAME']       = 'foo'
-        ENV['SALESFORCE_PASSWORD']       = 'bar'
-        ENV['SALESFORCE_SECURITY_TOKEN'] = 'foobar'
-        ENV['SALESFORCE_CLIENT_ID']      = 'client id'
-        ENV['SALESFORCE_CLIENT_SECRET']  = 'client secret'
-        ENV['PROXY_URI']                 = 'proxy'
-      end
-
-      after do
-        ENV.delete('SALESFORCE_USERNAME')
-        ENV.delete('SALESFORCE_PASSWORD')
-        ENV.delete('SALESFORCE_SECURITY_TOKEN')
-        ENV.delete('SALESFORCE_CLIENT_ID')
-        ENV.delete('SALESFORCE_CLIENT_SECRET')
-        ENV.delete('PROXY_URI')
+        { 'SALESFORCE_USERNAME'       => 'foo',
+          'SALESFORCE_PASSWORD'       => 'bar',
+          'SALESFORCE_SECURITY_TOKEN' => 'foobar',
+          'SALESFORCE_CLIENT_ID'      => 'client id',
+          'SALESFORCE_CLIENT_SECRET'  => 'client secret',
+          'PROXY_URI'                 => 'proxy',
+          'SALESFORCE_HOST'           => 'test.host.com' }.
+        each { |var, value| ENV.stub(:[]).with(var).and_return(value) }
       end
 
       its(:username)       { should eq 'foo' }
@@ -55,6 +48,7 @@ describe Restforce do
       its(:client_id)      { should eq 'client id' }
       its(:client_secret)  { should eq 'client secret' }
       its(:proxy_uri)      { should eq 'proxy' }
+      its(:host)           { should eq 'test.host.com' }
     end
   end
 
@@ -80,24 +74,20 @@ describe Restforce do
   end
 
   describe '#log' do
-    after do
-      Restforce.log = false
-    end
-
     context 'with logging disabled' do
       before do
-        Restforce.log = false
-        Restforce.configuration.logger.should_not_receive(:debug)
+        Restforce.stub :log? => false
       end
 
       it 'doesnt log anytning' do
+        Restforce.configuration.logger.should_not_receive(:debug)
         Restforce.log 'foobar'
       end
     end
-    
+
     context 'with logging enabled' do
       before do
-        Restforce.log = true
+        Restforce.stub :log? => true
         Restforce.configuration.logger.should_receive(:debug).with('foobar')
       end
 

data/spec/unit/data/client_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Restforce::Client do
+  subject { described_class }
+
+  it { should < Restforce::AbstractClient }
+  it { should < Restforce::Concerns::Picklists }
+  it { should < Restforce::Concerns::Streaming }
+  it { should < Restforce::Concerns::Canvas }
+end

data/spec/{lib → unit}/middleware/authentication/password_spec.rb

@@ -1,10 +1,6 @@
 require 'spec_helper'
 
 describe Restforce::Middleware::Authentication::Password do
-  let(:app)        { double('app')            }
-  let(:env)        { { }  }
-  let(:middleware) { described_class.new app, nil, options }
-
   let(:options) do
     { :host => 'login.salesforce.com',
       :username => 'foo',

data/spec/{lib → unit}/middleware/authentication/token_spec.rb

@@ -1,10 +1,6 @@
 require 'spec_helper'
 
 describe Restforce::Middleware::Authentication::Token do
-  let(:app)        { double('app')            }
-  let(:env)        { { }  }
-  let(:middleware) { described_class.new app, nil, options }
-
   let(:options) do
     { :host => 'login.salesforce.com',
       :refresh_token => 'refresh_token',

data/spec/unit/middleware/authentication_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Restforce::Middleware::Authentication do
+  let(:options) do
+    { :host => 'login.salesforce.com',
+      :proxy_uri => 'https://not-a-real-site.com',
+      :authentication_retries => retries }
+  end
+
+  describe '.authenticate!' do
+    subject { lambda { middleware.authenticate! }}
+    it      { should raise_error NotImplementedError }
+  end
+
+  describe '.call' do
+    subject { lambda { middleware.call(env) } }
+
+    context 'when successfull' do
+      before do
+        app.should_receive(:call).once
+      end
+
+      it { should_not raise_error }
+    end
+
+    context 'when an exception is thrown' do
+      before do
+        env.stub :body => 'foo', :request => { :proxy => nil }
+        middleware.stub :authenticate!
+        app.should_receive(:call).once.
+          and_raise(Restforce::UnauthorizedError.new('something bad'))
+      end
+
+      it { should raise_error Restforce::UnauthorizedError }
+    end
+  end
+
+  describe '.connection' do
+    subject(:connection) { middleware.connection }
+
+    its(:url_prefix)     { should eq(URI.parse('https://login.salesforce.com')) }
+    its(:proxy)          { should eq({ :uri => URI.parse('https://not-a-real-site.com') }) }
+
+    describe '.builder' do
+      subject(:builder) { connection.builder }
+
+      context 'with logging disabled' do
+        before do
+          Restforce.stub :log? => false
+        end
+
+        its(:handlers) { should include FaradayMiddleware::ParseJson,
+          Faraday::Adapter::NetHttp }
+        its(:handlers) { should_not include Restforce::Middleware::Logger  }
+      end
+
+      context 'with logging enabled' do
+        before do
+          Restforce.stub :log? => true
+        end
+
+        its(:handlers) { should include FaradayMiddleware::ParseJson,
+          Restforce::Middleware::Logger, Faraday::Adapter::NetHttp }
+      end
+    end
+  end
+end

data/spec/unit/middleware/authorization_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Restforce::Middleware::Authorization do
+  let(:options) { { :oauth_token => 'token' } }
+
+  describe '.call' do
+    subject { lambda { middleware.call(env) } }
+
+    it { should change { env[:request_headers]['Authorization'] }.to eq 'OAuth token' }
+  end
+end

data/spec/{lib → unit}/middleware/gzip_spec.rb

@@ -1,10 +1,7 @@
 require 'spec_helper'
 
 describe Restforce::Middleware::Gzip do
-  let(:app)        { double('app')            }
-  let(:env)        { { :request_headers => {}, :response_headers => {} }  }
-  let(:options)    { { :oauth_token => 'token' } }
-  let(:middleware) { described_class.new app, nil, options }
+  let(:options) { { :oauth_token => 'token' } }
 
   # Return a gzipped string.
   def gzip(str)
@@ -15,17 +12,24 @@ describe Restforce::Middleware::Gzip do
     end.string
   end
 
-  describe 'request' do
+  describe '.call' do
+    subject { lambda { middleware.call(env) } }
+
     before do
       app.should_receive(:on_complete) { middleware.on_complete(env) }
-      app.should_receive(:call).and_return(app)
+      app.should_receive(:call) do
+        env[:body] = gzip fixture('sobject/query_success_response')
+        env[:response_headers]['Content-Encoding'] = 'gzip'
+        app
+      end
+    end
+
+    it 'decompresses the body' do
+      should change { env[:body] }.to(fixture('sobject/query_success_response'))
     end
 
     context 'when :compress is false' do
-      it 'does not add the Accept-Encoding header' do
-        middleware.call(env)
-        expect(env[:request_headers]['Accept-Encoding']).to be_nil
-      end
+      it { should_not change { env[:request_headers]['Accept-Encoding'] } }
     end
 
     context 'when :compress is true' do
@@ -33,26 +37,7 @@ describe Restforce::Middleware::Gzip do
         options[:compress] = true
       end
 
-      it 'adds the Accept-Encoding header' do
-        middleware.call(env)
-        expect(env[:request_headers]['Accept-Encoding']).to eq 'gzip'
-      end
-    end
-  end
-
-  describe 'response' do
-    before do
-      app.should_receive(:on_complete) { middleware.on_complete(env) }
-      app.should_receive(:call) do
-        env[:body] = gzip fixture('sobject/query_success_response')
-        env[:response_headers]['Content-Encoding'] = 'gzip'
-        app
-      end
-    end
-
-    it 'decompresses the response body' do
-      middleware.call(env)
-      expect(env[:body]).to eq fixture('sobject/query_success_response')
+      it { should change { env[:request_headers]['Accept-Encoding'] }.to('gzip') }
     end
   end