Add a way to temporarily opt-out to #all now lazily making requests:

- ### Problem

  In 9372d5a we made a change that
  defer the http request submission until the collection is used.

  ```ruby
  # Before

  Product.all #=> HTTP request is made

  # After

  products = Product.all #=> No HTTP request is made
  products.each { ... } #=> HTTP request is made here
  ```

  This create issues for codepaths that used to expect the
  `Product.all` to make the http request and this feels like
  a breaking change that should go through a deprecation cycle
  (too late now but let's have a way to opt-out to the new behaviour).

  ### Context

  We have a safety net in our application that does something like
  this:

  ```ruby
    products = allow_explicit_http_connections do
      Product.all
    end

    products.each { ... }
  ```

  This is now broken because we make the request outside of the
  explictly allowed resiliency block.

  ### Solution

  Introduce a way to opt out to the new behaviour and trigger a
  deprecation warning.

Author: Edouard-chin

lib/active_resource/base.rb

@@ -375,6 +375,7 @@ def self.logger=(logger)
     class_attribute :_format
     class_attribute :_collection_parser
     class_attribute :include_format_in_path
+    class_attribute :find_all_lazy_load, default: true
     self.include_format_in_path = true
 
     class_attribute :connection_class
@@ -1126,7 +1127,18 @@ def last(*args)
       # This is an alias for find(:all). You can pass in all the same
       # arguments to this method as you can to <tt>find(:all)</tt>
       def all(*args)
-        WhereClause.new(self, *args)
+        if find_all_lazy_load
+          WhereClause.new(self, *args)
+        else
+          ActiveResource.deprecator.warn(<<~MSG)
+            In the next Active Resource release, calling ActiveResource::Base#all will defer the http request submission
+            until the collection is used.
+
+            To fix this warning, ensure your code doesn't rely on eagerly loading collection and
+            remove the `ActiveResource::Base.find_all_lazy_load` flag from your configuration.
+          MSG
+          find(:all, *args)
+        end
       end
 
       # This is an alias for all. You can pass in all the same

test/cases/finder_test.rb

@@ -61,6 +61,29 @@ def test_all
     assert_equal "David", all.last.name
   end
 
+  def test_all_loads_the_collection_lazily
+    all = Person.all
+    assert_empty(ActiveResource::HttpMock.requests)
+
+    assert_equal(2, all.size)
+    assert_not_empty(ActiveResource::HttpMock.requests)
+  end
+
+  def test_all_loads_the_collection_eagerly
+    previous_value = ActiveResource::Base.find_all_lazy_load
+    ActiveResource::Base.find_all_lazy_load = false
+
+    all = nil
+
+    assert_deprecated(/defer the http request submission/, ActiveResource.deprecator) do
+      all = Person.all
+    end
+    assert_not_empty(ActiveResource::HttpMock.requests)
+    assert_equal(2, all.size)
+  ensure
+    ActiveResource::Base.find_all_lazy_load = previous_value
+  end
+
   def test_all_with_params
     all = StreetAddress.all(params: { person_id: 1 })
     assert_equal 1, all.size