restforce 3.0.1 → 5.1.1

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+describe Restforce::Middleware::Authentication::JWTBearer do
+  let(:jwt_key) { File.read('spec/fixtures/test_private.key') }
+
+  let(:options) do
+    { host: 'login.salesforce.com',
+      client_id: 'client_id',
+      username: 'foo',
+      jwt_key: jwt_key,
+      instance_url: 'https://na1.salesforce.com',
+      adapter: :net_http }
+  end
+
+  it_behaves_like 'authentication middleware' 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))
+    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))
+    end
+  end
+
+  context 'allows jwt_key as string' do
+    let(:jwt_key) do
+      File.read('spec/fixtures/test_private.key')
+    end
+
+    let(:options) do
+      { host: 'login.salesforce.com',
+        client_id: 'client_id',
+        username: 'foo',
+        jwt_key: jwt_key,
+        instance_url: 'https://na1.salesforce.com',
+        adapter: :net_http }
+    end
+
+    it_behaves_like 'authentication middleware' 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))
+      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))
+      end
+    end
+  end
+end

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

@@ -17,14 +17,14 @@ 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"
+              "&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"
+              "&username=foo&password=barsecurity_token"
       ).to_return(status: 400, body: fixture(:auth_error_response))
     end
   end

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

@@ -15,14 +15,14 @@ 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"
+              "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"
+              "client_id=client_id&client_secret=client_secret"
       ).to_return(status: 400, body: fixture(:refresh_error_response))
     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 FaradayMiddleware::ParseJson
         }
         its(:handlers) { should_not include Restforce::Middleware::Logger }
+        its(:adapter) { should eq Faraday::Adapter::NetHttp }
       end
 
       context 'with logging enabled' do
@@ -70,8 +72,9 @@ describe Restforce::Middleware::Authentication do
 
         its(:handlers) {
           should include FaradayMiddleware::ParseJson,
-                         Restforce::Middleware::Logger, Faraday::Adapter::NetHttp
+                         Restforce::Middleware::Logger
         }
+        its(:adapter) { should eq Faraday::Adapter::NetHttp }
       end
 
       context 'with specified adapter' do
@@ -80,13 +83,37 @@ describe Restforce::Middleware::Authentication do
         end
 
         its(:handlers) {
-          should include FaradayMiddleware::ParseJson, Faraday::Adapter::Typhoeus
+          should include FaradayMiddleware::ParseJson
         }
+        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
+      let(:response) {
+        Faraday::Response.new(
+          response_body: { 'error' => 'error', 'error_description' => 'description' },
+          status: 401
+        )
+      }
+
+      subject { middleware.error_message(response) }
+      it { should eq "error: description (401)" }
+    end
+
+    context 'when response.body is nil' do
+      let(:response) { Faraday::Response.new(status: 401) }
+
+      subject { middleware.error_message(response) }
+      it { should eq "401" }
     end
   end
 end

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

@@ -13,55 +13,95 @@ describe Restforce::Middleware::RaiseError do
     context 'when the status code is 404' do
       let(:status) { 404 }
 
-      it "raises an error" do
-        expect { on_complete }.to raise_error Faraday::Error::ResourceNotFound,
-                                              'INVALID_FIELD: error_message'
+      it 'raises Restforce::NotFoundError' do
+        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
+        expect { on_complete }.to raise_error Faraday::ResourceNotFound
       end
     end
 
     context 'when the status code is 300' do
       let(:status) { 300 }
 
-      it "raises an error" do
-        expect { on_complete }.to raise_error Faraday::Error::ClientError,
+      it 'raises Restforce::MatchesMultipleError' do
+        expect { on_complete }.to raise_error Restforce::MatchesMultipleError,
                                               /300: The external ID provided/
       end
+
+      it 'raises an error that inherits from Faraday::ClientError' do
+        expect { on_complete }.to raise_error Faraday::ClientError
+      end
     end
 
     context 'when the status code is 400' do
       let(:status) { 400 }
 
-      it "raises an error" do
-        expect { on_complete }.to raise_error Faraday::Error::ClientError,
-                                              'INVALID_FIELD: error_message'
+      it "raises an error derived from the response's errorCode" do
+        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
+        expect { on_complete }.to raise_error Faraday::ClientError
       end
     end
 
     context 'when the status code is 401' do
       let(:status) { 401 }
 
-      it "raises an error" do
-        expect { on_complete }.to raise_error Restforce::UnauthorizedError,
-                                              'INVALID_FIELD: error_message'
+      it 'raises Restforce::UnauthorizedError' do
+        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
 
     context 'when the status code is 413' do
       let(:status) { 413 }
 
-      it "raises an error" do
-        expect { on_complete }.to raise_error Faraday::Error::ClientError,
+      it 'raises Restforce::EntityTooLargeError' do
+        expect { on_complete }.to raise_error Restforce::EntityTooLargeError,
                                               '413: Request Entity Too Large'
       end
+
+      it 'raises an error that inherits from Faraday::ClientError' do
+        expect { on_complete }.to raise_error Faraday::ClientError
+      end
     end
 
     context 'when status is 400+ and body is a string' do
       let(:body)   { 'An error occured' }
-      let(:status) { 404 }
+      let(:status) { 400 }
+
+      it 'raises a generic Restforce::ResponseError' do
+        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 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 an error with a non-existing error code' do
-        expect { on_complete }.to raise_error Faraday::Error::ClientError,
-                                              "(error code missing): #{body}"
+      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

data/spec/unit/sobject_spec.rb

@@ -45,13 +45,10 @@ describe Restforce::SObject do
     destroy: :destroy,
     destroy!: :destroy! }.each do |method, receiver|
     describe ".#{method}" do
-      subject(:send_method) { sobject.send(method) }
+      subject(:send_method) { lambda { sobject.send(method) } }
 
       context 'when an Id was not queried' do
-        it "raises an error" do
-          expect { send_method }.to raise_error ArgumentError,
-                                                /need to query the Id for the record/
-        end
+        it { should raise_error ArgumentError, /need to query the Id for the record/ }
       end
 
       context 'when an Id is present' do