flexirest 1.12.4 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b2b1b6afc271ee5ca051d711746396685574b2a7f18ca06919f48dbdd4bbafc
-  data.tar.gz: 10a84526cef840be253ff7fc36fc1571f7fbb463e11a900a11142b895cd8ebaa
+  metadata.gz: 4953df31ca4ca1d055e7a80ce2cd7a0df8e53cc4b67544b80d1a91ee2aa366a4
+  data.tar.gz: 0f500061fd78240f0f2c2d8c19934d5c6c5f777f32de82c8bc2330415fd6c768
 SHA512:
-  metadata.gz: bb7b781df1bd6f64482c6b672ac397bef31b5a0717f677db8c03988aee79253b95962136e835131fc55794f48828df6f35b3d9b36f9156e7fce5d41d3af9098d
-  data.tar.gz: 586b813a1a098c15a7c0f56267c044ac46649c97cd0a933960bbcc19e3b27397083cd05802c30ca042d280417ff68d9dcae3eb8b152f9373afd712e794e863d4
+  metadata.gz: 6c45c501ef89cc34a66a66ca585088e7af146348b2c42ffd0c36fe4559a957ae4bc5f579b207b238c5d0e5a0625bb1000f937a144a2107ce3eff79272d07286a
+  data.tar.gz: 9ea32ee11733ee70ea539d37f094fb8e9f730c82c4a14f84e5322102ab380af0c5dc12a3ac258968e8ec9a6ebd6b84ae780e54ec9a518744888c6ee62be40e7f

data/.github/workflows/build.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['3.0', '3.1', '3.2', '3.3']
+        ruby-version: ['3.0', '3.1', '3.2', '3.3', '3.4']
 
     steps:
     - uses: actions/checkout@v4

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.13.0
+
+Bugfix:
+
+- Major changes to internals to better support thread-safe usage. Thanks to Kurtis for the bug report
+
+## 1.12.5
+
+Feature:
+
+- Some broken APIs require a GET body, even though this is against HTTP spec. Added a `send_get_body` parameter like we already have for DELETE requests (thanks to Jan Schroeder for the request)
+
 ## 1.12.4
 
 Bugfix:

data/docs/basic-usage.md

@@ -52,6 +52,12 @@ For `delete` requests whether an API can handle a body or not is undefined. The
   delete :remove, "/people/:id", send_delete_body: true
 ```
 
+In a similar way, although it's against the HTTP specification, you can force a GET request to send a request body if your API requires that:
+
+```
+  get :people_search, "/people/search", send_get_body: true
+```
+
 If an API returns an array of results and you have [will_paginate](https://rubygems.org/gems/will_paginate) installed then you can call the paginate method to return a particular page of the results (note: this doesn't reduce the load on the server, but it can help with pagination if you have a cached response).
 
 ```ruby

data/lib/flexirest/associations.rb

@@ -51,17 +51,22 @@ module Flexirest
         end
       end
 
+      # The keys passed to `.includes(...)` travel from this class-method call
+      # into the Request built by the subsequent finder call. Storing them in a
+      # class instance variable meant concurrent threads calling `.includes` on
+      # the same model shared (and corrupted) one slot, so they're held in
+      # thread-local storage keyed by the class instead.
       def includes(*keys)
-        @_include_associations = keys
+        (Thread.current[:flexirest_include_associations] ||= {})[self] = keys
         self
       end
 
       def _include_associations
-        @_include_associations
+        (Thread.current[:flexirest_include_associations] ||= {})[self] || []
       end
 
       def _reset_include_associations!
-        @_include_associations = []
+        (Thread.current[:flexirest_include_associations] ||= {}).delete(self)
       end
 
       def parse_date(*keys)
@@ -80,7 +85,6 @@ module Flexirest
       def inherited(subclass)
         subclass.instance_variable_set(:@_date_fields, [])
         subclass.instance_variable_set(:@_associations, {})
-        subclass.instance_variable_set(:@_include_associations, [])
         super
       end
     end

data/lib/flexirest/connection.rb

@@ -41,6 +41,18 @@ module Flexirest
       end
     end
 
+    def get_with_body(path, data, options={})
+      set_defaults(options)
+      make_safe_request(path) do
+        @session.get(path) do |req|
+          set_per_request_timeout(req, options) if options[:timeout]
+          req.headers = req.headers.merge(options[:headers])
+          req.body = data
+          sign_request(req, options[:api_auth])
+        end
+      end
+    end
+
     def get(path, options={})
       set_defaults(options)
       make_safe_request(path) do

data/lib/flexirest/instrumentation.rb

@@ -7,25 +7,28 @@ module Flexirest
       Flexirest::Logger.debug "  \033[1;4;32m#{name}\033[0m #{event.payload[:name]}" unless event.payload[:quiet]
     end
 
+    # These counters accumulate per request and are reported/reset per
+    # controller action. Held per-thread so concurrent requests each track their
+    # own totals instead of sharing (and losing updates to) one class variable.
     def self.time_spent=(value)
-      @@time_spent = value
+      Thread.current[:flexirest_time_spent] = value
     end
 
     def self.time_spent
-      @@time_spent ||= 0
+      Thread.current[:flexirest_time_spent] ||= 0
     end
 
     def self.calls_made=(value)
-      @@calls_made = value
+      Thread.current[:flexirest_calls_made] = value
     end
 
     def self.calls_made
-      @@calls_made ||= 0
+      Thread.current[:flexirest_calls_made] ||= 0
     end
 
     def self.reset
-      @@time_spent = 0
-      @@calls_made = 0
+      Thread.current[:flexirest_time_spent] = 0
+      Thread.current[:flexirest_calls_made] = 0
     end
 
     def logger

data/lib/flexirest/json_api_proxy.rb

@@ -172,10 +172,18 @@ module Flexirest
     # Creating JSON API header
     module Headers
       extend self
+      # `extend self` makes this module a single process-wide object, so the
+      # headers used while building a request must not be stashed in an ivar
+      # here — concurrent requests would overwrite each other's (and leak
+      # authentication headers across requests). Hold them per-thread instead.
       def save(headers)
         # Save headers used in a request for building lazy association
         # loaders when parsing the response
-        @headers = headers
+        Thread.current[:flexirest_jsonapi_headers] = headers
+      end
+
+      def headers
+        Thread.current[:flexirest_jsonapi_headers]
       end
     end
 
@@ -185,8 +193,16 @@ module Flexirest
       extend Flexirest::JsonAPIProxy::Helpers
       ID_PFIX = '_id_'
 
+      # `extend self` makes Response a single shared object too. The resource
+      # class saved here is read again while building lazy association loaders
+      # during the same parse, so it must be per-thread: otherwise a concurrent
+      # parse of a different model would corrupt association resolution.
       def save_resource_class(object)
-        @resource_class = object.is_a?(Class) ? object : object.class
+        Thread.current[:flexirest_jsonapi_resource_class] = object.is_a?(Class) ? object : object.class
+      end
+
+      def resource_class
+        Thread.current[:flexirest_jsonapi_resource_class]
       end
 
       def parse(body, object)
@@ -387,7 +403,7 @@ module Flexirest
 
       def find_association_class(base, name)
         stack = base + [name]
-        klass = @resource_class
+        klass = resource_class
 
         until stack.empty?
           shift = stack.shift
@@ -424,7 +440,7 @@ module Flexirest
 
         # Also add the previous request's header, which may contain
         # crucial authentication headers (or so), to connect with the service
-        request.headers = @headers
+        request.headers = Flexirest::JsonAPIProxy::Headers.headers
         request.url = request.forced_url = url
 
         Flexirest::LazyAssociationLoader.new(name, url, request)

data/lib/flexirest/logger.rb

@@ -2,18 +2,25 @@ module Flexirest
   class Logger
     @logfile = nil
     @messages = []
+    # Guards the shared in-memory buffer / logfile handle below, which are
+    # written on every log call during request handling. Without this,
+    # concurrent requests racing on `@messages << ...` (or a shared IO) can
+    # interleave and lose or corrupt entries.
+    @mutex = Mutex.new
 
     def self.logfile=(value)
-      @logfile = value
+      @mutex.synchronize { @logfile = value }
     end
 
     def self.messages
-      @messages
+      @mutex.synchronize { @messages.dup }
     end
 
     def self.reset!
-      @logfile = nil
-      @messages = []
+      @mutex.synchronize do
+        @logfile = nil
+        @messages = []
+      end
     end
 
     def self.level
@@ -27,65 +34,52 @@ module Flexirest
     def self.debug(message)
       if defined?(Rails) && Rails.logger.present?
         Rails.logger.debug(message)
-      elsif @logfile
-        if @logfile.is_a?(String)
-          File.open(@logfile, "a") do |f|
-            f << "#{message}\n"
-          end
-        else
-          @logfile << "#{message}\n"
-        end
       else
-        @messages << message
+        write_fallback(message)
       end
     end
 
     def self.info(message)
       if defined?(Rails) && Rails.logger.present?
         Rails.logger.info(message)
-      elsif @logfile
-        if @logfile.is_a?(String)
-          File.open(@logfile, "a") do |f|
-            f << "#{message}\n"
-          end
-        else
-          @logfile << "#{message}\n"
-        end
       else
-        @messages << message
+        write_fallback(message)
       end
     end
 
     def self.warn(message)
       if defined?(Rails) && Rails.logger.present?
         Rails.logger.warn(message)
-      elsif @logfile
-        if @logfile.is_a?(String)
-          File.open(@logfile, "a") do |f|
-            f << "#{message}\n"
-          end
-        else
-          @logfile << "#{message}\n"
-        end
       else
-        @messages << message
+        write_fallback(message)
       end
     end
 
     def self.error(message)
       if defined?(Rails) && Rails.logger.present?
         Rails.logger.error(message)
-      elsif @logfile
-        if @logfile.is_a?(String)
-          File.open(@logfile, "a") do |f|
-            f << "#{message}\n"
+      else
+        write_fallback(message)
+      end
+    end
+
+    # Writes to the configured logfile, or falls back to the in-memory buffer.
+    # Synchronised because both destinations are shared across threads.
+    def self.write_fallback(message)
+      @mutex.synchronize do
+        if @logfile
+          if @logfile.is_a?(String)
+            File.open(@logfile, "a") do |f|
+              f << "#{message}\n"
+            end
+          else
+            @logfile << "#{message}\n"
           end
         else
-          @logfile << "#{message}\n"
+          @messages << message
         end
-      else
-        @messages << message
       end
     end
+    private_class_method :write_fallback
   end
 end

data/lib/flexirest/proxy_base.rb

@@ -2,10 +2,19 @@ require "uri"
 
 module Flexirest
   class ProxyBase
-    cattr_accessor :mappings, :request, :original_handler
-    cattr_accessor :original_body, :original_get_params, :original_post_params, :original_url
-
     module ClassMethods
+      # Per-request state used while handling a proxied request is stored in
+      # thread-local storage (keyed by the proxy class) rather than on the
+      # class itself. The DSL is implemented as class methods run via
+      # class_eval, so historically "the current request" was stored in class
+      # instance variables/class variables, which are shared across every
+      # thread calling through the same proxy class. That caused request data
+      # to be dropped or corrupted under concurrency. Keeping it per-thread
+      # isolates concurrent requests while preserving the existing DSL.
+      def _proxy_state
+        states = (Thread.current[:flexirest_proxy_state] ||= {})
+        states[self] ||= {}
+      end
       def get(match, &block)
         add_mapping(:get, match, block)
       end
@@ -41,33 +50,34 @@ module Flexirest
       end
 
       def body(value = nil)
-        @body = value if value
-        @body
+        _proxy_state[:body] = value if value
+        _proxy_state[:body]
       end
 
       def url(value = nil)
-        @url = value if value
-        @url
+        _proxy_state[:url] = value if value
+        _proxy_state[:url]
       end
 
       def get_params(value = nil)
-        @get_params = value if value
-        @get_params
+        _proxy_state[:get_params] = value if value
+        _proxy_state[:get_params]
       end
 
       def post_params(value = nil)
-        @post_params = value if value
-        @post_params
+        _proxy_state[:post_params] = value if value
+        _proxy_state[:post_params]
       end
 
       def params(value = nil)
-        @params = value if value
-        @params
+        _proxy_state[:params] = value if value
+        _proxy_state[:params]
       end
 
       def passthrough
         rebuild_request
-        @original_handler.call(@request)
+        state = _proxy_state
+        state[:original_handler].call(state[:request])
       end
 
       def result_is_json_or_unspecified?(result)
@@ -93,56 +103,73 @@ module Flexirest
       end
 
       def rebuild_request
-        if @url != @original_url
-          @request.forced_url = @request.url = @url
+        state = _proxy_state
+        request = state[:request]
+        if state[:url] != state[:original_url]
+          request.forced_url = request.url = state[:url]
         end
-        if @body != @original_body
-          @request.body = @body
-        elsif @post_params != @original_post_params
-          @request.body = nil
-          @request.prepare_request_body(@post_params)
+        if state[:body] != state[:original_body]
+          request.body = state[:body]
+        elsif state[:post_params] != state[:original_post_params]
+          request.body = nil
+          request.prepare_request_body(state[:post_params])
         end
-        if @get_params != @original_get_params
-          @request.get_params = @get_params
-          @request.prepare_url
-          @request.append_get_parameters
+        if state[:get_params] != state[:original_get_params]
+          request.get_params = state[:get_params]
+          request.prepare_url
+          request.append_get_parameters
         end
       end
 
       def handle(request, &block)
-        @request = request
-        @original_handler = block
+        # Preserve any state already in flight on this thread (e.g. a proxied
+        # request that itself triggers another request through the same proxy
+        # class) and restore it when we're done, so nested calls can't clobber
+        # each other.
+        states = (Thread.current[:flexirest_proxy_state] ||= {})
+        previous_state = states[self]
+
+        state = states[self] = {}
+        state[:request] = request
+        state[:original_handler] = block
 
-        @original_body = request.body
-        @body = @original_body.dup
+        state[:original_body] = request.body
+        state[:body] = state[:original_body].dup
 
-        @original_get_params = request.get_params
-        @get_params = @original_get_params.dup
+        state[:original_get_params] = request.get_params
+        state[:get_params] = state[:original_get_params].dup
 
-        @original_post_params = request.post_params
-        @post_params = (@original_post_params || {}).dup
+        state[:original_post_params] = request.post_params
+        state[:post_params] = (state[:original_post_params] || {}).dup
 
-        @original_url = request.url
-        @url = @original_url.dup
+        state[:original_url] = request.url
+        state[:url] = state[:original_url].dup
 
         if mapping = find_mapping_for_current_request
           self.class_eval(&mapping.block)
         else
           passthrough
         end
+      ensure
+        if previous_state
+          states[self] = previous_state
+        else
+          states.delete(self)
+        end
       end
 
       def find_mapping_for_current_request
-        uri = URI.parse(@original_url)
+        state = _proxy_state
+        uri = URI.parse(state[:original_url])
         @mappings ||= []
-        @params = {}
+        state[:params] = {}
         @mappings.each do |mapping|
           match = mapping.match
-          if (match_data = uri.path.match(match)) && @request.http_method.to_sym == mapping.http_method
+          if (match_data = uri.path.match(match)) && state[:request].http_method.to_sym == mapping.http_method
             matches = match_data.to_a
             matches.shift
             matches.each_with_index do |value, index|
-              @params[mapping.param_keys[index]] = value
+              state[:params][mapping.param_keys[index]] = value
             end
             return mapping
           end

data/lib/flexirest/request.rb

@@ -361,10 +361,10 @@ module Flexirest
       if @explicit_parameters
         params = @explicit_parameters
       end
-      if http_method == :get || (http_method == :delete && !@method[:options][:send_delete_body] && proxy != :json_api)
+      if (http_method == :get && !@method[:options][:send_get_body]) || (http_method == :delete && !@method[:options][:send_delete_body] && proxy != :json_api)
         @get_params = default_params.merge(params || {})
         @post_params = nil
-      elsif http_method == :delete && @method[:options][:send_delete_body]
+      elsif (http_method == :get && @method[:options][:send_get_body]) || (http_method == :delete && @method[:options][:send_delete_body])
         @post_params = default_params.merge(params || {})
         @get_params = {}
       elsif params.is_a? String
@@ -476,7 +476,7 @@ module Flexirest
 
         headers["Accept"] ||= "application/vnd.api+json"
         JsonAPIProxy::Headers.save(headers)
-      elsif http_method == :get || (http_method == :delete && !@method[:options][:send_delete_body])
+      elsif (http_method == :get && !@method[:options][:send_get_body]) || (http_method == :delete && !@method[:options][:send_delete_body])
         if request_body_type == :form_encoded
           headers["Content-Type"] ||= "application/x-www-form-urlencoded; charset=utf-8"
         elsif request_body_type == :form_multipart
@@ -607,16 +607,17 @@ module Flexirest
         request_options[:timeout] = @method[:options][:timeout]
       end
 
-      case http_method
-      when :get
+      if http_method == :get && !@method[:options][:send_get_body]
         response = connection.get(@url, request_options)
-      when :put
+      elsif http_method == :get
+        response = connection.get_with_body(@url, @body, request_options)
+      elsif http_method == :put
         response = connection.put(@url, @body, request_options)
-      when :post
+      elsif http_method == :post
         response = connection.post(@url, @body, request_options)
-      when :patch
+      elsif http_method == :patch
         response = connection.patch(@url, @body, request_options)
-      when :delete
+      elsif http_method == :delete
         response = connection.delete(@url, @body, request_options)
       else
         raise InvalidRequestException.new("Invalid method #{http_method}")

data/lib/flexirest/version.rb

@@ -1,3 +1,3 @@
 module Flexirest
-  VERSION = "1.12.4"
+  VERSION = "1.13.0"
 end

data/spec/lib/associations_spec.rb

@@ -84,6 +84,37 @@ describe "Has Many Associations" do
   end
 end
 
+describe "includes association thread safety" do
+  it "keeps .includes state isolated across concurrent threads" do
+    thread_count = 10
+
+    # All threads set their own includes, then wait until every thread has done
+    # so before reading it back. Before the fix, the shared class instance
+    # variable meant each thread read whichever value was written last.
+    count = 0
+    mutex = Mutex.new
+    cond = ConditionVariable.new
+    results = {}
+
+    threads = thread_count.times.map do |i|
+      Thread.new do
+        AssociationExampleBase.includes(:"assoc_#{i}")
+        mutex.synchronize do
+          count += 1
+          cond.broadcast
+          cond.wait(mutex) while count < thread_count
+        end
+        results[i] = AssociationExampleBase._include_associations
+      end
+    end
+    threads.each { |t| t.join(5) }
+
+    thread_count.times do |i|
+      expect(results[i]).to eq([:"assoc_#{i}"])
+    end
+  end
+end
+
 describe "Has One Associations" do
   let(:subject) {AssociationExampleBase.new}
 

data/spec/lib/json_api_spec.rb

@@ -567,3 +567,64 @@ describe 'JSON API' do
     end
   end
 end
+
+# A simple N-party rendezvous forcing concurrent parses to interleave, so the
+# per-request state the JSON:API proxy stashes (resource class + headers) is
+# provably isolated per thread rather than shared on the singleton modules.
+class JsonAPIThreadBarrier
+  def initialize(parties)
+    @parties = parties
+    @count = 0
+    @mutex = Mutex.new
+    @cond = ConditionVariable.new
+  end
+
+  def wait
+    @mutex.synchronize do
+      @count += 1
+      if @count >= @parties
+        @cond.broadcast
+      else
+        @cond.wait(@mutex) while @count < @parties
+      end
+    end
+  end
+end
+
+describe Flexirest::JsonAPIProxy do
+  it 'keeps the parsed resource class isolated across concurrent threads' do
+    classes = [JsonAPIExampleArticle, JsonAPIAssociationExampleTag, JsonAPIAssociationExampleAuthor]
+    thread_count = 9
+    barrier = JsonAPIThreadBarrier.new(thread_count)
+
+    threads = thread_count.times.map do |i|
+      klass = classes[i % classes.size]
+      Thread.new do
+        Flexirest::JsonAPIProxy::Response.save_resource_class(klass)
+        # All threads have now saved a class; if it were shared they'd all read
+        # whichever was written last.
+        barrier.wait
+        [i, Flexirest::JsonAPIProxy::Response.resource_class]
+      end
+    end
+    results = threads.to_h(&:value)
+
+    thread_count.times { |i| expect(results[i]).to eq(classes[i % classes.size]) }
+  end
+
+  it 'keeps the saved request headers isolated across concurrent threads' do
+    thread_count = 10
+    barrier = JsonAPIThreadBarrier.new(thread_count)
+
+    threads = thread_count.times.map do |i|
+      Thread.new do
+        Flexirest::JsonAPIProxy::Headers.save('X-Marker' => i.to_s)
+        barrier.wait
+        [i, Flexirest::JsonAPIProxy::Headers.headers]
+      end
+    end
+    results = threads.to_h(&:value)
+
+    thread_count.times { |i| expect(results[i]).to eq('X-Marker' => i.to_s) }
+  end
+end

data/spec/lib/proxy_spec.rb

@@ -2,6 +2,29 @@ require 'spec_helper'
 require 'active_support/core_ext/hash'
 require 'base64'
 
+# A simple N-party rendezvous used to force concurrent proxy requests to be
+# interleaved inside `handle` at the same time, deterministically reproducing
+# the thread-safety bug where per-request state was stored on the class.
+class ProxyTestBarrier
+  def initialize(parties)
+    @parties = parties
+    @count = 0
+    @mutex = Mutex.new
+    @cond = ConditionVariable.new
+  end
+
+  def wait
+    @mutex.synchronize do
+      @count += 1
+      if @count >= @parties
+        @cond.broadcast
+      else
+        @cond.wait(@mutex) while @count < @parties
+      end
+    end
+  end
+end
+
 class ProxyExample < Flexirest::ProxyBase
   get "/all" do
     url.gsub!("/all", "/getAll")
@@ -72,6 +95,22 @@ class ProxyExample < Flexirest::ProxyBase
   get "/fake" do
     render "{\"id\":1234}"
   end
+
+  def self.thread_barrier=(barrier)
+    @thread_barrier = barrier
+  end
+
+  def self.thread_barrier
+    @thread_barrier
+  end
+
+  get "/thread_test/:marker" do
+    url "/thread_result/#{params[:marker]}"
+    # Pause every concurrent request here, after it has set its own URL but
+    # before it is sent, so all threads are inside `handle` simultaneously.
+    ProxyExample.thread_barrier.wait
+    passthrough
+  end
 end
 
 class ProxyClientExample < Flexirest::Base
@@ -91,6 +130,7 @@ class ProxyClientExample < Flexirest::Base
   get :not_proxied, "/not_proxied"
   delete :remove, "/remove"
   get :hal_test, "/hal_test/:id"
+  get :thread_test, "/thread_test/:marker"
 end
 
 describe Flexirest::Base do
@@ -200,6 +240,31 @@ describe Flexirest::Base do
     expect(ProxyClientExample.hal_test(id:1).test.result).to eq(true)
   end
 
+  it "keeps proxied request data isolated across concurrent threads" do
+    thread_count = 10
+    ProxyExample.thread_barrier = ProxyTestBarrier.new(thread_count)
+
+    requested_paths = Queue.new
+    allow_any_instance_of(Flexirest::Connection).to receive(:get) do |_connection, path, _options|
+      requested_paths << path
+      ::FaradayResponseMock.new(OpenStruct.new(body: "{\"result\":true}", status: 200, response_headers: {}))
+    end
+
+    threads = thread_count.times.map do |i|
+      Thread.new { ProxyClientExample.thread_test(marker: i) }
+    end
+    threads.each { |t| t.join(5) }
+
+    paths = []
+    paths << requested_paths.pop until requested_paths.empty?
+
+    # Each thread must reach the server with its own marker. Before the fix the
+    # shared class-level state meant every thread sent whichever URL was written
+    # last, so the paths collided instead of covering 0..9.
+    expected = (0...thread_count).map { |i| "/thread_result/#{i}" }
+    expect(paths.sort).to eq(expected.sort)
+  end
+
   it "properly passes basic HTTP auth credentials" do
     host, credentials, url_path = 'www.example.com', 'user:pass', '/getAll?id=1'
     ProxyClientExample.base_url "http://#{credentials}@#{host}"

data/spec/lib/request_spec.rb

@@ -54,6 +54,7 @@ describe Flexirest::Request do
       put :conversion_child, "/put/:id", parse_fields: [:converted_child]
       delete :remove, "/remove/:id"
       delete :remove_body, "/remove/:id", send_delete_body: true
+      get :get_body, "/get-body", send_get_body: true
       get :hal, "/hal", fake:"{\"_links\":{\"child\": {\"href\": \"/child/1\"}, \"other\": {\"href\": \"/other/1\"}, \"cars\":[{\"href\": \"/car/1\", \"name\":\"car1\"}, {\"href\": \"/car/2\", \"name\":\"car2\"}, {\"href\": \"/car/not-embed\", \"name\":\"car_not_embed\"} ], \"lazy\": {\"href\": \"/lazy/load\"}, \"invalid\": [{\"href\": \"/invalid/1\"}]}, \"_embedded\":{\"other\":{\"name\":\"Jane\"},\"child\":{\"name\":\"Billy\"}, \"cars\":[{\"_links\": {\"self\": {\"href\": \"/car/1\"} }, \"make\": \"Bugatti\", \"model\": \"Veyron\"}, {\"_links\": {\"self\": {\"href\": \"/car/2\"} }, \"make\": \"Ferrari\", \"model\": \"F458 Italia\"} ], \"invalid\": [{\"present\":true, \"_links\": {} } ] } }", has_many:{other:ExampleOtherClient}
       get :fake_object, "/fake", fake:"{\"result\":true, \"list\":[1,2,3,{\"test\":true}], \"child\":{\"grandchild\":{\"test\":true}}}"
       get :fake_proc_object, "/fake", fake:->(request) { "{\"result\":#{request.get_params[:id]}}" }
@@ -451,6 +452,11 @@ describe Flexirest::Request do
     ExampleClient.all
   end
 
+  it "should get an HTTP connection when called and call get with a body if send_get_body is specified" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get_with_body).with("/get-body", "something=else", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{})))
+    ExampleClient.get_body(something: "else")
+  end
+
   it "should get an HTTP connection when called and call delete on it" do
     expect_any_instance_of(Flexirest::Connection).to receive(:delete).with("/remove/1", "", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{})))
     ExampleClient.remove(id:1)

data/spec/spec_helper.rb

@@ -13,8 +13,6 @@ elsif ENV["TRAVIS"]
   Coveralls.wear!
 end
 
-ActiveSupport::Deprecation.silenced = true
-
 RSpec.configure do |config|
   config.color = true
   # config.formatter     = 'documentation'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: flexirest
 version: !ruby/object:Gem::Version
-  version: 1.12.4
+  version: 1.13.0
 platform: ruby
 authors:
 - Andy Jeffries
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-31 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -392,7 +391,6 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/flexirest/flexirest
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -407,8 +405,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: This gem is for accessing REST services in a flexible way.  ActiveResource
   already exists for this, but it doesn't work where the resource naming doesn't follow