restforce 4.2.1 → 6.0.0

data/spec/unit/concerns/caching_spec.rb

@@ -28,4 +28,30 @@ describe Restforce::Concerns::Caching do
       end
     end
   end
+
+  describe '.with_caching' do
+    let(:options) { double('Options') }
+
+    before do
+      client.stub options: options
+    end
+
+    it 'runs the block with caching enabled' do
+      options.should_receive(:[]=).with(:use_cache, true)
+      options.should_receive(:[]=).with(:use_cache, false)
+      expect { |b| client.with_caching(&b) }.to yield_control
+    end
+
+    context 'when an exception is raised' do
+      it 'ensures the :use_cache is set to false' do
+        options.should_receive(:[]=).with(:use_cache, true)
+        options.should_receive(:[]=).with(:use_cache, false)
+        expect {
+          client.with_caching do
+            raise 'Foo'
+          end
+        }.to raise_error 'Foo'
+      end
+    end
+  end
 end

data/spec/unit/concerns/composite_api_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restforce::Concerns::CompositeAPI do
+  let(:endpoint) { 'composite' }
+
+  before do
+    client.should_receive(:options).and_return(api_version: 38.0)
+  end
+
+  shared_examples_for 'composite requests' do
+    it '#create' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { compositeRequest: [
+          {
+            method: 'POST',
+            url: '/services/data/v38.0/sobjects/Object',
+            body: { name: 'test' },
+            referenceId: 'create_ref'
+          }
+        ], allOrNone: all_or_none, collateSubrequests: false }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.create('Object', 'create_ref', name: 'test')
+      end
+    end
+
+    it '#update' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { compositeRequest: [
+          {
+            method: 'PATCH',
+            url: '/services/data/v38.0/sobjects/Object/123',
+            body: { name: 'test' },
+            referenceId: 'update_ref'
+          }
+        ], allOrNone: all_or_none, collateSubrequests: false }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.update('Object', 'update_ref', id: '123', name: 'test')
+      end
+    end
+
+    it '#destroy' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { compositeRequest: [
+          {
+            method: 'DELETE',
+            url: '/services/data/v38.0/sobjects/Object/123',
+            referenceId: 'destroy_ref'
+          }
+        ], allOrNone: all_or_none, collateSubrequests: false }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.destroy('Object', 'destroy_ref', '123')
+      end
+    end
+
+    it '#upsert' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { compositeRequest: [
+          {
+            method: 'PATCH',
+            url: '/services/data/v38.0/sobjects/Object/extIdField__c/456',
+            body: { name: 'test' },
+            referenceId: 'upsert_ref'
+          }
+        ], allOrNone: all_or_none, collateSubrequests: false }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.upsert('Object', 'upsert_ref', 'extIdField__c',
+                           extIdField__c: '456', name: 'test')
+      end
+    end
+
+    it 'multiple subrequests' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { compositeRequest: [
+          {
+            method: 'POST',
+            url: '/services/data/v38.0/sobjects/Object',
+            body: { name: 'test' },
+            referenceId: 'create_ref'
+          },
+          {
+            method: 'PATCH',
+            url: '/services/data/v38.0/sobjects/Object/123',
+            body: { name: 'test' },
+            referenceId: 'update_ref'
+          },
+          {
+            method: 'DELETE',
+            url: '/services/data/v38.0/sobjects/Object/123',
+            referenceId: 'destroy_ref'
+          }
+        ], allOrNone: all_or_none, collateSubrequests: false }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.create('Object', 'create_ref', name: 'test')
+        subrequests.update('Object', 'update_ref', id: '123', name: 'test')
+        subrequests.destroy('Object', 'destroy_ref', '123')
+      end
+    end
+
+    it 'fails if more than 25 requests' do
+      expect do
+        client.send(method) do |subrequests|
+          26.times do |i|
+            subrequests.upsert('Object', "upsert_ref_#{i}", 'extIdField__c',
+                               extIdField__c: '456', name: 'test')
+          end
+        end
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#composite' do
+    let(:method) { :composite }
+    let(:all_or_none) { false }
+    let(:response) { double('Faraday::Response', body: { 'compositeResponse' => [] }) }
+    it_behaves_like 'composite requests'
+  end
+
+  describe '#composite!' do
+    let(:method) { :composite! }
+    let(:all_or_none) { true }
+    let(:response) do
+      double('Faraday::Response', body: { 'compositeResponse' => [] })
+    end
+    it_behaves_like 'composite requests'
+  end
+end

data/spec/unit/concerns/connection_spec.rb

@@ -73,9 +73,9 @@ describe Restforce::Concerns::Connection do
         Restforce.stub(log?: true)
       end
 
-      it "must always be used last before the Faraday Adapter" do
+      it "must always be used as the last handler before the adapter" do
         client.middleware.handlers.reverse.index(Restforce::Middleware::Logger).
-          should eq 1
+          should eq 0
       end
     end
   end

data/spec/unit/concerns/streaming_spec.rb

@@ -13,10 +13,10 @@ describe Restforce::Concerns::Streaming, event_machine: true do
     it 'subscribes to the topics with faye' do
       faye_double.
         should_receive(:subscribe).
-        with(channels, &subscribe_block)
+        with(channels)
       client.stub faye: faye_double
 
-      client.subscription(channels, &subscribe_block)
+      client.subscription(channels)
     end
 
     context "replay_handlers" do
@@ -87,7 +87,7 @@ describe Restforce::Concerns::Streaming, event_machine: true do
       end
 
       it 'connects to the streaming api' do
-        client.stub authenticate!: OpenStruct.new(access_token: 'secret2')
+        client.stub authenticate!: double(access_token: 'secret2')
         faye_double = double('Faye::Client')
         Faye::Client.
           should_receive(:new).
@@ -110,7 +110,7 @@ describe Restforce::Concerns::Streaming, event_machine: true do
     end
   end
 
-  describe Restforce::Concerns::Streaming::ReplayExtension do
+  describe "ReplayExtension" do
     let(:handlers) { {} }
     let(:extension) { Restforce::Concerns::Streaming::ReplayExtension.new(handlers) }
 

data/spec/unit/config_spec.rb

@@ -44,7 +44,7 @@ describe Restforce do
           'SALESFORCE_PROXY_URI'      => 'proxy',
           'SALESFORCE_HOST'           => 'test.host.com',
           'SALESFORCE_API_VERSION'    => '37.0' }.
-          each { |var, value| ENV.stub(:[]).with(var).and_return(value) }
+          each { |var, value| ENV.stub(:fetch).with(var, anything).and_return(value) }
       end
 
       its(:username)       { should eq 'foo' }
@@ -76,7 +76,7 @@ describe Restforce do
     subject { Restforce.log? }
 
     context 'by default' do
-      it { should be_false }
+      it { should be false }
     end
   end
 

data/spec/unit/error_code_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restforce::ErrorCode do
+  describe "mapping of error codes to classes" do
+    subject(:error_exception_classes) { described_class::ERROR_EXCEPTION_CLASSES }
+
+    let(:exception_classes) do
+      described_class.constants.
+        map { |constant_name| described_class.const_get(constant_name) }.
+        select { |constant| constant.is_a?(Class) }
+    end
+
+    it "maps all defined exception classes to an error code" do
+      exception_classes.each do |exception_class|
+        expect(error_exception_classes.values).to include(exception_class)
+      end
+    end
+
+    it "maps all error codes to a defined exception class" do
+      error_exception_classes.each_value do |mapped_exception_class|
+        expect(exception_classes).to include(mapped_exception_class)
+      end
+    end
+  end
+
+  describe '.get_exception_class' do
+    context 'when a non-existent error code is looked up' do
+      let(:new_error_code) { 'ANOTHER_NEW_ERROR_CODE' }
+      subject              { described_class.get_exception_class(new_error_code) }
+
+      it { should be Restforce::ResponseError }
+
+      it 'outputs a warning' do
+        expect(Warning).to receive(:warn)
+        subject
+      end
+    end
+
+    context 'when a known error code is looked up' do
+      let(:existing_error_code) { "ALL_OR_NONE_OPERATION_ROLLED_BACK" }
+      let(:existing_error)      { described_class::AllOrNoneOperationRolledBack }
+
+      subject do
+        described_class.get_exception_class(existing_error_code)
+      end
+
+      it { should < Restforce::ResponseError }
+
+      it 'returns existing error' do
+        should be(existing_error)
+      end
+
+      it 'does not output a warning' do
+        expect(Warning).to_not receive(:warn)
+        subject
+      end
+    end
+  end
+end

data/spec/unit/mash_spec.rb

@@ -33,6 +33,11 @@ describe Restforce::Mash do
         let(:input) { { 'attributes' => { 'type' => 'Document' } } }
         it { should eq Restforce::Document }
       end
+
+      context 'when the attributes value is nil' do
+        let(:input) { { 'attributes' => nil } }
+        it { should eq Restforce::SObject }
+      end
     end
 
     context 'else' do

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

@@ -17,15 +17,23 @@ describe Restforce::Middleware::Authentication::JWTBearer do
     let(:success_request) do
       stub_login_request(
         body: "grant_type=grant_type—urn:ietf:params:oauth:grant-type:jwt-bearer&" \
-             "assertion=abc1234567890"
-      ).to_return(status: 200, body: fixture(:auth_success_response))
+              "assertion=abc1234567890"
+      ).to_return(
+        status: 200,
+        body: fixture(:auth_success_response),
+        headers: { "Content-Type" => "application/json" }
+      )
     end
 
     let(:fail_request) do
       stub_login_request(
         body: "grant_type=grant_type—urn:ietf:params:oauth:grant-type:jwt-bearer&" \
-             "assertion=abc1234567890"
-      ).to_return(status: 400, body: fixture(:refresh_error_response))
+              "assertion=abc1234567890"
+      ).to_return(
+        status: 400,
+        body: fixture(:refresh_error_response),
+        headers: { "Content-Type" => "application/json" }
+      )
     end
   end
 
@@ -47,15 +55,23 @@ describe Restforce::Middleware::Authentication::JWTBearer do
       let(:success_request) do
         stub_login_request(
           body: "grant_type=grant_type—urn:ietf:params:oauth:grant-type:jwt-bearer&" \
-            "assertion=abc1234567890"
-        ).to_return(status: 200, body: fixture(:auth_success_response))
+                "assertion=abc1234567890"
+        ).to_return(
+          status: 200,
+          body: fixture(:auth_success_response),
+          headers: { "Content-Type" => "application/json" }
+        )
       end
 
       let(:fail_request) do
         stub_login_request(
           body: "grant_type=grant_type—urn:ietf:params:oauth:grant-type:jwt-bearer&" \
-            "assertion=abc1234567890"
-        ).to_return(status: 400, body: fixture(:refresh_error_response))
+                "assertion=abc1234567890"
+        ).to_return(
+          status: 400,
+          body: fixture(:refresh_error_response),
+          headers: { "Content-Type" => "application/json" }
+        )
       end
     end
   end

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

@@ -17,15 +17,23 @@ describe Restforce::Middleware::Authentication::Password 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))
+              "&username=foo&password=barsecurity_token"
+      ).to_return(
+        status: 200,
+        body: fixture(:auth_success_response),
+        headers: { "Content-Type" => "application/json" }
+      )
     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))
+              "&username=foo&password=barsecurity_token"
+      ).to_return(
+        status: 400,
+        body: fixture(:auth_error_response),
+        headers: { "Content-Type" => "application/json" }
+      )
     end
   end
 

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

@@ -15,15 +15,23 @@ describe Restforce::Middleware::Authentication::Token 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))
+              "client_id=client_id&client_secret=client_secret"
+      ).to_return(
+        status: 200,
+        body: fixture(:auth_success_response),
+        headers: { "Content-Type" => "application/json" }
+      )
     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))
+              "client_id=client_id&client_secret=client_secret"
+      ).to_return(
+        status: 400,
+        body: fixture(:refresh_error_response),
+        headers: { "Content-Type" => "application/json" }
+      )
     end
   end
 end

data/spec/unit/middleware/authentication_spec.rb

@@ -8,7 +8,9 @@ describe Restforce::Middleware::Authentication do
       proxy_uri: 'https://not-a-real-site.com',
       authentication_retries: retries,
       adapter: :net_http,
+      # rubocop:disable Naming/VariableNumber
       ssl: { version: :TLSv1_2 } }
+    # rubocop:enable Naming/VariableNumber
   end
 
   describe '.authenticate!' do
@@ -57,10 +59,10 @@ describe Restforce::Middleware::Authentication do
         end
 
         its(:handlers) {
-          should include FaradayMiddleware::ParseJson,
-                         Faraday::Adapter::NetHttp
+          should include Restforce::Middleware::JsonResponse
         }
         its(:handlers) { should_not include Restforce::Middleware::Logger }
+        its(:adapter) { should eq Faraday::Adapter::NetHttp }
       end
 
       context 'with logging enabled' do
@@ -69,9 +71,10 @@ describe Restforce::Middleware::Authentication do
         end
 
         its(:handlers) {
-          should include FaradayMiddleware::ParseJson,
-                         Restforce::Middleware::Logger, Faraday::Adapter::NetHttp
+          should include Restforce::Middleware::JsonResponse,
+                         Restforce::Middleware::Logger
         }
+        its(:adapter) { should eq Faraday::Adapter::NetHttp }
       end
 
       context 'with specified adapter' do
@@ -80,21 +83,24 @@ describe Restforce::Middleware::Authentication do
         end
 
         its(:handlers) {
-          should include FaradayMiddleware::ParseJson, Faraday::Adapter::Typhoeus
+          should include Restforce::Middleware::JsonResponse
         }
+        its(:adapter) { should eq Faraday::Adapter::Typhoeus }
       end
     end
 
     it "should have SSL config set" do
+      # rubocop:disable Naming/VariableNumber
       connection.ssl[:version].should eq(:TLSv1_2)
+      # rubocop:enable Naming/VariableNumber
     end
   end
 
   describe '.error_message' do
-    context 'when response.body is present' do
+    context 'when response_body is present' do
       let(:response) {
         Faraday::Response.new(
-          body: { 'error' => 'error', 'error_description' => 'description' },
+          response_body: { 'error' => 'error', 'error_description' => 'description' },
           status: 401
         )
       }
@@ -103,7 +109,7 @@ describe Restforce::Middleware::Authentication do
       it { should eq "error: description (401)" }
     end
 
-    context 'when response.body is nil' do
+    context 'when response_body is nil' do
       let(:response) { Faraday::Response.new(status: 401) }
 
       subject { middleware.error_message(response) }

data/spec/unit/middleware/gzip_spec.rb

@@ -58,11 +58,11 @@ describe Restforce::Middleware::Gzip do
         env[:response_headers]['Content-Encoding'] = 'gzip'
       end
 
-      it { should be_true }
+      it { should be true }
     end
 
     context 'when not gzipped' do
-      it { should be_false }
+      it { should be false }
     end
   end
 end

data/spec/unit/middleware/raise_error_spec.rb

@@ -14,8 +14,10 @@ describe Restforce::Middleware::RaiseError do
       let(:status) { 404 }
 
       it 'raises Restforce::NotFoundError' do
-        expect { on_complete }.to raise_error Restforce::NotFoundError,
-                                              'INVALID_FIELD: error_message'
+        expect { on_complete }.to raise_error do |error|
+          expect(error).to be_a Restforce::NotFoundError
+          expect(error.message).to start_with("INVALID_FIELD: error_message")
+        end
       end
 
       it 'raises an error that inherits from Faraday::ResourceNotFound' do
@@ -40,8 +42,10 @@ describe Restforce::Middleware::RaiseError do
       let(:status) { 400 }
 
       it "raises an error derived from the response's errorCode" do
-        expect { on_complete }.to raise_error Restforce::ErrorCode::InvalidField,
-                                              'INVALID_FIELD: error_message'
+        expect { on_complete }.to raise_error do |error|
+          expect(error).to be_a Restforce::ErrorCode::InvalidField
+          expect(error.message).to start_with("INVALID_FIELD: error_message")
+        end
       end
 
       it 'raises an error that inherits from Faraday::ClientError' do
@@ -53,8 +57,10 @@ describe Restforce::Middleware::RaiseError do
       let(:status) { 401 }
 
       it 'raises Restforce::UnauthorizedError' do
-        expect { on_complete }.to raise_error Restforce::UnauthorizedError,
-                                              'INVALID_FIELD: error_message'
+        expect { on_complete }.to raise_error do |error|
+          expect(error).to be_a Restforce::UnauthorizedError
+          expect(error.message).to start_with("INVALID_FIELD: error_message")
+        end
       end
     end
 
@@ -76,13 +82,26 @@ describe Restforce::Middleware::RaiseError do
       let(:status) { 400 }
 
       it 'raises a generic Restforce::ResponseError' do
-        expect { on_complete }.to raise_error Restforce::ResponseError,
-                                              "(error code missing): #{body}"
+        expect { on_complete }.to raise_error do |error|
+          expect(error).to be_a Restforce::ResponseError
+          expect(error.message).to start_with("(error code missing): An error occured")
+        end
       end
 
       it 'raises an error that inherits from Faraday::ClientError' do
-        expect { on_complete }.to raise_error Faraday::ClientError,
-                                              "(error code missing): #{body}"
+        expect { on_complete }.to raise_error do |error|
+          expect(error).to be_a Faraday::ClientError
+          expect(error.message).to start_with("(error code missing): An error occured")
+        end
+      end
+    end
+
+    context 'when error code is not already defined' do
+      let(:body) { { 'errorCode' => 'SOMETHING_UNDEFINED' } }
+      let(:status) { 400 }
+
+      it 'raises a generic Restforce::ResponseError' do
+        expect { on_complete }.to raise_error Restforce::ResponseError
       end
     end
   end

data/spec/unit/signed_request_spec.rb

@@ -6,7 +6,7 @@ describe Restforce::SignedRequest do
   let(:client_secret) { 'foo' }
   let(:digest) do
     if RUBY_VERSION < '2.1'
-      OpenSSL::Digest::Digest.new('sha256')
+      OpenSSL::Digest.new('Digest', 'sha256')
     else
       OpenSSL::Digest.new('sha256')
     end