restforce 3.0.0 → 3.2.1

data/lib/restforce/concerns/streaming.rb

@@ -9,7 +9,8 @@ module Restforce
       # block    - A block to run when a new message is received.
       #
       # Returns a Faye::Subscription
-      def subscribe(channels, &block)
+      def subscribe(channels, options = {}, &block)
+        Array(channels).each { |channel| replay_handlers[channel] = options[:replay] }
         faye.subscribe Array(channels).map { |channel| "/topic/#{channel}" }, &block
       end
 
@@ -32,6 +33,62 @@ module Restforce
           client.bind 'transport:up' do
             Restforce.log "[COMETD UP]"
           end
+
+          client.add_extension ReplayExtension.new(replay_handlers)
+        end
+      end
+
+      def replay_handlers
+        @_replay_handlers ||= {}
+      end
+
+      class ReplayExtension
+        def initialize(replay_handlers)
+          @replay_handlers = replay_handlers
+        end
+
+        def incoming(message, callback)
+          callback.call(message).tap do
+            channel = message.fetch('channel').gsub('/topic/', '')
+            replay_id = message.fetch('data', {}).fetch('event', {})['replayId']
+
+            handler = @replay_handlers[channel]
+            if !replay_id.nil? && !handler.nil? && handler.respond_to?(:[]=)
+              # remember the last replay_id for this channel
+              handler[channel] = replay_id
+            end
+          end
+        end
+
+        def outgoing(message, callback)
+          # Leave non-subscribe messages alone
+          return callback.call(message) unless message['channel'] == '/meta/subscribe'
+
+          channel = message['subscription'].gsub('/topic/', '')
+
+          # Set the replay value for the channel
+          message['ext'] ||= {}
+          message['ext']['replay'] = {
+            "/topic/#{channel}" => replay_id(channel)
+          }
+
+          # Carry on and send the message to the server
+          callback.call message
+        end
+
+        private
+
+        def replay_id(channel)
+          handler = @replay_handlers[channel]
+          if handler.is_a?(Integer)
+            handler # treat it as a scalar
+          elsif handler.respond_to?(:[])
+            # Ask for the latest replayId for this channel
+            handler[channel]
+          else
+            # Just pass it along
+            handler
+          end
         end
       end
     end

data/lib/restforce/config.rb

@@ -34,6 +34,7 @@ module Restforce
 
     def log(message)
       return unless Restforce.log?
+
       configuration.logger.send(configuration.log_level, message)
     end
   end

data/lib/restforce/document.rb

@@ -17,6 +17,7 @@ module Restforce
 
     def ensure_body
       return true if self.Body?
+
       raise 'You need to query the Body for the record first.'
     end
   end

data/lib/restforce/middleware/multipart.rb

@@ -49,6 +49,7 @@ module Restforce
       # Files
       params.each do |k, v|
         next unless v.respond_to? :content_type
+
         parts << Faraday::Parts::Part.new(boundary,
                                           k.to_s,
                                           v)

data/lib/restforce/middleware/raise_error.rb

@@ -6,23 +6,30 @@ module Restforce
       @env = env
       case env[:status]
       when 300
-        raise Faraday::Error::ClientError.new("300: The external ID provided matches " \
-                                              "more than one record",
-                                              response_values)
+        raise Restforce::MatchesMultipleError.new(
+          "300: The external ID provided matches more than one record",
+          response_values
+        )
       when 401
         raise Restforce::UnauthorizedError, message
       when 404
-        raise Faraday::Error::ResourceNotFound, message
+        raise Restforce::NotFoundError, message
       when 413
-        raise Faraday::Error::ClientError.new("413: Request Entity Too Large",
-                                              response_values)
+        raise Restforce::EntityTooLargeError.new(
+          "413: Request Entity Too Large",
+          response_values
+        )
       when 400...600
-        raise Faraday::Error::ClientError.new(message, response_values)
+        klass = exception_class_for_error_code(body['errorCode'])
+        raise klass.new(message, response_values)
       end
     end
 
     def message
-      "#{body['errorCode']}: #{body['message']}"
+      message = "#{body['errorCode']}: #{body['message']}"
+      message << "\nRESPONSE: #{JSON.dump(@env[:body])}"
+    rescue StandardError
+      message # if JSON.dump fails, return message without extra detail
     end
 
     def body
@@ -43,5 +50,14 @@ module Restforce
         body: @env[:body]
       }
     end
+
+    ERROR_CODE_MATCHER = /\A[A-Z_]+\z/.freeze
+
+    def exception_class_for_error_code(error_code)
+      return Restforce::ResponseError unless ERROR_CODE_MATCHER.match?(error_code)
+
+      constant_name = error_code.split('_').map(&:capitalize).join.to_sym
+      Restforce::ErrorCode.const_get(constant_name)
+    end
   end
 end

data/lib/restforce/signed_request.rb

@@ -27,6 +27,7 @@ module Restforce
     # Returns nil if the signed request is invalid.
     def decode
       return nil if signature != hmac
+
       JSON.parse(Base64.decode64(payload))
     end
 

data/lib/restforce/sobject.rb

@@ -63,6 +63,7 @@ module Restforce
 
     def ensure_id
       return true if self.Id?
+
       raise ArgumentError, 'You need to query the Id for the record first.'
     end
   end

data/lib/restforce/tooling/client.rb

@@ -5,9 +5,9 @@ module Restforce
     class Client < AbstractClient
       private
 
-        def api_path(path)
-          super("tooling/#{path}")
-        end
+      def api_path(path)
+        super("tooling/#{path}")
+      end
     end
   end
 end

data/lib/restforce/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Restforce
-  VERSION = '3.0.0'
+  VERSION = '3.2.1'
 end

data/lib/restforce.rb

@@ -29,6 +29,7 @@ module Restforce
     autoload :Verbs,          'restforce/concerns/verbs'
     autoload :Base,           'restforce/concerns/base'
     autoload :API,            'restforce/concerns/api'
+    autoload :BatchAPI,       'restforce/concerns/batch_api'
   end
 
   module Data
@@ -44,6 +45,25 @@ module Restforce
   AuthenticationError = Class.new(Error)
   UnauthorizedError   = Class.new(Error)
   APIVersionError     = Class.new(Error)
+  BatchAPIError       = Class.new(Error)
+
+  # Inherit from Faraday::Error::ResourceNotFound for backwards-compatibility
+  # Consumers of this library that rescue and handle Faraday::Error::ResourceNotFound
+  # can continue to do so.
+  NotFoundError       = Class.new(Faraday::Error::ResourceNotFound)
+
+  # Inherit from Faraday::Error::ClientError for backwards-compatibility
+  # Consumers of this library that rescue and handle Faraday::Error::ClientError
+  # can continue to do so.
+  ResponseError       = Class.new(Faraday::Error::ClientError)
+  MatchesMultipleError= Class.new(ResponseError)
+  EntityTooLargeError = Class.new(ResponseError)
+
+  module ErrorCode
+    def self.const_missing(constant_name)
+      const_set constant_name, Class.new(ResponseError)
+    end
+  end
 
   class << self
     # Alias for Restforce::Data::Client.new
@@ -74,7 +94,7 @@ module Restforce
       self
     end
   end
-  Object.send :include, Restforce::CoreExtensions unless Object.respond_to? :tap
+  Object.include Restforce::CoreExtensions unless Object.respond_to? :tap
 end
 
 if ENV['PROXY_URI']

data/restforce.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require File.expand_path('../lib/restforce/version', __FILE__)
+require File.expand_path('lib/restforce/version', __dir__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Eric J. Holmes", "Tim Rogers"]
@@ -25,16 +25,16 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 2.3'
 
   gem.add_dependency 'faraday', '<= 1.0', '>= 0.9.0'
-  gem.add_dependency 'faraday_middleware', ['>= 0.8.8', '<= 1.0']
+  gem.add_dependency 'faraday_middleware', ['>= 0.8.8', '< 1.0']
 
   gem.add_dependency 'json', '>= 1.7.5'
 
   gem.add_dependency 'hashie', ['>= 1.2.0', '< 4.0']
 
+  gem.add_development_dependency 'faye' unless RUBY_PLATFORM == 'java'
   gem.add_development_dependency 'rspec', '~> 2.14.0'
-  gem.add_development_dependency 'webmock', '~> 3.4.0'
-  gem.add_development_dependency 'simplecov', '~> 0.15.0'
-  gem.add_development_dependency 'rubocop', '~> 0.50.0'
   gem.add_development_dependency 'rspec_junit_formatter', '~> 0.3.0'
-  gem.add_development_dependency 'faye' unless RUBY_PLATFORM == 'java'
+  gem.add_development_dependency 'rubocop', '~> 0.75.0'
+  gem.add_development_dependency 'simplecov', '~> 0.17.1'
+  gem.add_development_dependency 'webmock', '~> 3.7.6'
 end

data/spec/integration/abstract_client_spec.rb

@@ -96,7 +96,7 @@ shared_examples_for Restforce::AbstractClient do
       subject do
         client.create('Account', Name: 'Foobar',
                                  Blob: Restforce::UploadIO.new(
-                                   File.expand_path('../../fixtures/blob.jpg', __FILE__),
+                                   File.expand_path('../fixtures/blob.jpg', __dir__),
                                    'image/jpeg'
                                  ))
       end
@@ -209,6 +209,24 @@ shared_examples_for Restforce::AbstractClient do
         end
       end
     end
+
+    context 'when created with a space in the id' do
+      requests 'sobjects/Account/External__c/foo%20bar',
+               method: :patch,
+               with_body: "{\"Name\":\"Foobar\"}",
+               fixture: 'sobject/upsert_created_success_response'
+
+      [:External__c, 'External__c', :external__c, 'external__c'].each do |key|
+        context "with #{key.inspect} as the external id" do
+          subject do
+            client.upsert!('Account', 'External__c', key => 'foo bar',
+                                                     :Name => 'Foobar')
+          end
+
+          it { should eq 'foo' }
+        end
+      end
+    end
   end
 
   describe '.destroy!' do
@@ -229,6 +247,13 @@ shared_examples_for Restforce::AbstractClient do
 
       it { should be_true }
     end
+
+    context 'with a space in the id' do
+      subject(:destroy!) { client.destroy!('Account', '001D000000 INjVe') }
+      requests 'sobjects/Account/001D000000%20INjVe', method: :delete
+
+      it { should be_true }
+    end
   end
 
   describe '.destroy' do
@@ -266,6 +291,14 @@ shared_examples_for Restforce::AbstractClient do
       subject { client.find('Account', '1234', 'External_Field__c') }
       it { should be_a Hash }
     end
+
+    context 'with a space in an external id' do
+      requests 'sobjects/Account/External_Field__c/12%2034',
+               fixture: 'sobject/sobject_find_success_response'
+
+      subject { client.find('Account', '12 34', 'External_Field__c') }
+      it { should be_a Hash }
+    end
   end
 
   describe '.select' do
@@ -284,6 +317,14 @@ shared_examples_for Restforce::AbstractClient do
         subject { client.select('Account', '1234', ['External_Field__c']) }
         it { should be_a Hash }
       end
+
+      context 'with a space in the id' do
+        requests 'sobjects/Account/12%2034',
+                 fixture: 'sobject/sobject_select_success_response'
+
+        subject { client.select('Account', '12 34', nil, nil) }
+        it { should be_a Hash }
+      end
     end
 
     context 'when an external id is specified' do

data/spec/support/fixture_helpers.rb

@@ -27,8 +27,8 @@ module FixtureHelpers
       stub
     end
 
-    def fixture(f)
-      File.read(File.expand_path("../../fixtures/#{f}.json", __FILE__))
+    def fixture(filename)
+      File.read(File.expand_path("../../fixtures/#{filename}.json", __FILE__))
     end
   end
 

data/spec/unit/concerns/api_spec.rb

@@ -350,6 +350,16 @@ describe Restforce::Concerns::API do
             and_return(response)
           expect(result).to be_true
         end
+
+        context 'and the response body is a string' do
+          it 'returns true' do
+            response.stub(:body) { '' }
+            client.should_receive(:api_patch).
+              with('sobjects/Whizbang/External_ID__c/1234', {}).
+              and_return(response)
+            expect(result).to be_true
+          end
+        end
       end
 
       context 'when the record is found and created' do

data/spec/unit/concerns/batch_api_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restforce::Concerns::BatchAPI do
+  let(:endpoint) { 'composite/batch' }
+
+  before do
+    client.should_receive(:options).and_return(api_version: 34.0)
+  end
+
+  shared_examples_for 'batched requests' do
+    it '#create' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { batchRequests: [
+          { method: 'POST', url: 'v34.0/sobjects/Object', richInput: { name: 'test' } }
+        ], haltOnError: halt_on_error }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.create('Object', name: 'test')
+      end
+    end
+
+    it '#update' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { batchRequests: [
+          { method: 'PATCH', url: "v34.0/sobjects/Object/123", richInput: {
+            name: 'test'
+          } }
+        ], haltOnError: halt_on_error }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.update('Object', id: '123', name: 'test')
+      end
+    end
+
+    it '#destroy' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { batchRequests: [
+          { method: 'DELETE', url: "v34.0/sobjects/Object/123" }
+        ], haltOnError: halt_on_error }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.destroy('Object', '123')
+      end
+    end
+
+    it '#upsert' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { batchRequests: [
+          { method: 'PATCH', url: 'v34.0/sobjects/Object/extIdField__c/456', richInput: {
+            name: 'test'
+          } }
+        ], haltOnError: halt_on_error }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.upsert('Object', 'extIdField__c',
+                           extIdField__c: '456', name: 'test')
+      end
+    end
+
+    it 'multiple subrequests' do
+      client.
+        should_receive(:api_post).
+        with(endpoint, { batchRequests: [
+          { method: 'POST', url: 'v34.0/sobjects/Object', richInput: {
+            name: 'test'
+          } },
+          { method: 'PATCH', url: "v34.0/sobjects/Object/123", richInput: {
+            name: 'test'
+          } },
+          { method: 'DELETE', url: "v34.0/sobjects/Object/123" }
+        ], haltOnError: halt_on_error }.to_json).
+        and_return(response)
+
+      client.send(method) do |subrequests|
+        subrequests.create('Object', name: 'test')
+        subrequests.update('Object', id: '123', name: 'test')
+        subrequests.destroy('Object', '123')
+      end
+    end
+  end
+
+  describe '#batch' do
+    let(:method) { :batch }
+    let(:halt_on_error) { false }
+    let(:response) { double('Faraday::Response', body: { 'results' => [] }) }
+    it_behaves_like 'batched requests'
+  end
+
+  describe '#batch!' do
+    let(:method) { :batch! }
+    let(:halt_on_error) { true }
+    let(:response) {
+      double('Faraday::Response', body: { 'hasErrors' => false, 'results' => [] })
+    }
+    it_behaves_like 'batched requests'
+  end
+end

data/spec/unit/concerns/streaming_spec.rb

@@ -17,6 +17,33 @@ describe Restforce::Concerns::Streaming, event_machine: true do
 
       client.subscribe(channels, &subscribe_block)
     end
+
+    context "replay_handlers" do
+      before {
+        faye_double.should_receive(:subscribe).at_least(1)
+        client.stub faye: faye_double
+      }
+
+      it 'registers nil handlers when no replay option is given' do
+        client.subscribe(channels, &subscribe_block)
+        client.replay_handlers.should eq('channel1' => nil, 'channel2' => nil)
+      end
+
+      it 'registers a replay_handler for each channel given' do
+        client.subscribe(channels, replay: -2, &subscribe_block)
+        client.replay_handlers.should eq('channel1' => -2, 'channel2' => -2)
+      end
+
+      it 'replaces earlier handlers in subsequent calls' do
+        client.subscribe(%w[channel1 channel2], replay: 2, &subscribe_block)
+        client.subscribe(%w[channel2 channel3], replay: 3, &subscribe_block)
+        client.replay_handlers.should eq(
+          'channel1' => 2,
+          'channel2' => 3,
+          'channel3' => 3
+        )
+      end
+    end
   end
 
   describe '.faye' do
@@ -42,6 +69,8 @@ describe Restforce::Concerns::Streaming, event_machine: true do
         faye_double.should_receive(:set_header).with('Authorization', 'OAuth secret2')
         faye_double.should_receive(:bind).with('transport:down').and_yield
         faye_double.should_receive(:bind).with('transport:up').and_yield
+        faye_double.should_receive(:add_extension).with \
+          kind_of(Restforce::Concerns::Streaming::ReplayExtension)
         subject
       end
     end
@@ -52,4 +81,87 @@ describe Restforce::Concerns::Streaming, event_machine: true do
       end
     end
   end
+
+  describe Restforce::Concerns::Streaming::ReplayExtension do
+    let(:handlers) { {} }
+    let(:extension) { Restforce::Concerns::Streaming::ReplayExtension.new(handlers) }
+
+    it 'sends nil without a specified handler' do
+      output = subscribe(extension, to: "channel1")
+      read_replay(output).should eq('/topic/channel1' => nil)
+    end
+
+    it 'with a scalar replay id' do
+      handlers['channel1'] = -2
+      output = subscribe(extension, to: "channel1")
+      read_replay(output).should eq('/topic/channel1' => -2)
+    end
+
+    it 'with a hash' do
+      hash_handler = { 'channel1' => -1, 'channel2' => -2 }
+
+      handlers['channel1'] = hash_handler
+      handlers['channel2'] = hash_handler
+
+      output = subscribe(extension, to: "channel1")
+      read_replay(output).should eq('/topic/channel1' => -1)
+
+      output = subscribe(extension, to: "channel2")
+      read_replay(output).should eq('/topic/channel2' => -2)
+    end
+
+    it 'with an object' do
+      custom_handler = double('custom_handler')
+      custom_handler.should_receive(:[]).and_return(123)
+      handlers['channel1'] = custom_handler
+
+      output = subscribe(extension, to: "channel1")
+      read_replay(output).should eq('/topic/channel1' => 123)
+    end
+
+    it 'remembers the last replayId' do
+      handler = { 'channel1' => 41 }
+      handlers['channel1'] = handler
+      message = {
+        'channel' => '/topic/channel1',
+        'data' => {
+          'event' => { 'replayId' => 42 }
+        }
+      }
+
+      extension.incoming(message, ->(m) {})
+      handler.should eq('channel1' => 42)
+    end
+
+    it 'when an incoming message has no replayId' do
+      handler = { 'channel1' => 41 }
+      handlers['channel1'] = handler
+
+      message = {
+        'channel' => '/topic/channel1',
+        'data' => {}
+      }
+
+      extension.incoming(message, ->(m) {})
+      handler.should eq('channel1' => 41)
+    end
+
+    private
+
+    def subscribe(extension, options = {})
+      output = nil
+      message = {
+        'channel' => '/meta/subscribe',
+        'subscription' => "/topic/#{options[:to]}"
+      }
+      extension.outgoing(message, ->(m) {
+        output = m
+      })
+      output
+    end
+
+    def read_replay(message)
+      message.fetch('ext', {})['replay']
+    end
+  end
 end