force 0.0.1

data/spec/unit/concerns/authentication_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Force::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 Force::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(double(: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 Force::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 Force::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,42 @@
+require 'spec_helper'
+
+describe Force::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
+
+    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 Force::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 Force::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 Force::SignedRequest' do
+        Force::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,22 @@
+require 'spec_helper'
+
+describe Force::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
+
+  describe '#adapter' do
+    before do
+      client.stub :options => {:adapter => :typhoeus}
+    end
+
+    its(:adapter) { should eq(:typhoeus) }
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Force do
+  before do
+    ENV['SALESFORCE_USERNAME']       = nil
+    ENV['SALESFORCE_PASSWORD']       = nil
+    ENV['SALESFORCE_SECURITY_TOKEN'] = nil
+    ENV['SALESFORCE_CLIENT_ID']      = nil
+    ENV['SALESFORCE_CLIENT_SECRET']  = nil
+  end
+
+  after do
+    Force.instance_variable_set :@configuration, nil
+  end
+
+  describe '#configuration' do
+    subject { Force.configuration }
+
+    it { should be_a Force::Configuration }
+
+    context 'by default' do
+      its(:api_version)            { should eq '26.0' }
+      its(:host)                   { should eq 'login.salesforce.com' }
+      its(:authentication_retries) { should eq 3 }
+      its(:adapter)                { should eq Faraday.default_adapter }
+      [:username, :password, :security_token, :client_id, :client_secret,
+       :oauth_token, :refresh_token, :instance_url, :compress, :timeout,
+       :proxy_uri, :authentication_callback].each do |attr|
+        its(attr) { should be_nil }
+      end
+    end
+
+    context 'when environment variables are defined' do
+      before do
+        { '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' }
+      its(:password)       { should eq 'bar'}
+      its(:security_token) { should eq 'foobar' }
+      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
+
+  describe '#configure' do
+    [:username, :password, :security_token, :client_id, :client_secret, :compress, :timeout,
+     :oauth_token, :refresh_token, :instance_url, :api_version, :host, :authentication_retries,
+     :proxy_uri, :authentication_callback].each do |attr|
+      it "allows #{attr} to be set" do
+        Force.configure do |config|
+          config.send("#{attr}=", 'foobar')
+        end
+        expect(Force.configuration.send(attr)).to eq 'foobar'
+      end
+    end
+  end
+
+  describe '#log?' do
+    subject { Force.log? }
+
+    context 'by default' do
+      it { should be_false }
+    end
+  end
+
+  describe '#log' do
+    context 'with logging disabled' do
+      before do
+        Force.stub :log? => false
+      end
+
+      it 'doesnt log anytning' do
+        Force.configuration.logger.should_not_receive(:debug)
+        Force.log 'foobar'
+      end
+    end
+
+    context 'with logging enabled' do
+      before do
+        Force.stub :log? => true
+        Force.configuration.logger.should_receive(:debug).with('foobar')
+      end
+
+      it 'logs something' do
+        Force.log 'foobar'
+      end
+    end
+  end
+end

data/spec/unit/data/client_spec.rb

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

data/spec/unit/mash_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Force::Mash do
+  describe '#build' do
+    subject { described_class.build(input, nil) }
+
+    context 'when array' do
+      let(:input) { [{ :foo => 'hello' }, { :bar => 'world' }] }
+      it { should be_all { |obj| expect(obj).to be_a Force::Mash } }
+    end
+  end
+
+  describe '#klass' do
+    subject { described_class.klass(input) }
+
+    context 'when the hash has a "records" key' do
+      let(:input) { { 'records' => nil } }
+      it { should eq Force::Collection }
+    end
+
+    context 'when the hash has an "attributes" key' do
+      let(:input) { { 'attributes' => { 'type' => 'Account' } } }
+      it { should eq Force::SObject }
+
+      context 'when the sobject type is an Attachment' do
+        let(:input) { { 'attributes' => { 'type' => 'Attachment' } } }
+        it { should eq Force::Attachment }
+      end
+    end
+
+    context 'else' do
+      let(:input) { {} }
+      it { should eq Force::Mash }
+    end
+  end
+end

data/spec/unit/middleware/authentication/password_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Force::Middleware::Authentication::Password do
+  let(:options) do
+    { :host => 'login.salesforce.com',
+      :username => 'foo',
+      :password => 'bar',
+      :security_token => 'security_token',
+      :client_id => 'client_id',
+      :client_secret => 'client_secret' }
+  end
+
+  it_behaves_like 'authentication middleware' do
+    let(:success_request) do
+      stub_login_request(:body => "grant_type=password&client_id=client_id&client_secret=" \
+        "client_secret&username=foo&password=barsecurity_token").
+        to_return(:status => 200, :body => fixture(:auth_success_response))
+    end
+
+    let(:fail_request) do
+      stub_login_request(:body => "grant_type=password&client_id=client_id&client_secret=" \
+        "client_secret&username=foo&password=barsecurity_token").
+        to_return(:status => 400, :body => fixture(:auth_error_response))
+    end
+  end
+
+  describe '.password' do
+    subject { middleware.password }
+    it      { should eq 'barsecurity_token' }
+  end
+end

data/spec/unit/middleware/authentication/token_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Force::Middleware::Authentication::Token do
+  let(:options) do
+    { :host => 'login.salesforce.com',
+      :refresh_token => 'refresh_token',
+      :client_id => 'client_id',
+      :client_secret => 'client_secret' }
+  end
+
+  it_behaves_like 'authentication middleware' do
+    let(:success_request) do
+      stub_login_request(:body => "grant_type=refresh_token&refresh_token=refresh_token&" \
+        "client_id=client_id&client_secret=client_secret").
+        to_return(:status => 200, :body => fixture(:auth_success_response))
+    end
+
+    let(:fail_request) do
+      stub_login_request(:body => "grant_type=refresh_token&refresh_token=refresh_token&" \
+        "client_id=client_id&client_secret=client_secret").
+        to_return(:status => 400, :body => fixture(:refresh_error_response))
+    end
+  end
+end

data/spec/unit/middleware/authentication_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Force::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(Force::UnauthorizedError.new('something bad'))
+      end
+
+      it { should raise_error Force::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
+          Force.stub :log? => false
+        end
+
+        its(:handlers) { should include FaradayMiddleware::ParseJson,
+          Faraday::Adapter::NetHttp }
+        its(:handlers) { should_not include Force::Middleware::Logger  }
+      end
+
+      context 'with logging enabled' do
+        before do
+          Force.stub :log? => true
+        end
+
+        its(:handlers) { should include FaradayMiddleware::ParseJson,
+          Force::Middleware::Logger, Faraday::Adapter::NetHttp }
+      end
+    end
+  end
+end