ibm_db 5.6.1 → 5.7.0

data/test/cases/scoping/default_scoping_test.rb

@@ -7,6 +7,7 @@ require "models/developer"
 require "models/project"
 require "models/computer"
 require "models/cat"
+require "models/mentor"
 require "concurrent/atomic/cyclic_barrier"
 
 class DefaultScopingTest < ActiveRecord::TestCase
@@ -79,6 +80,174 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal 50000,   wheres["salary"]
   end
 
+  def test_combined_default_scope_without_and_with_all_queries_works
+    Mentor.create!
+    klass = DeveloperWithIncludedMentorDefaultScopeNotAllQueriesAndDefaultScopeFirmWithAllQueries
+
+    create_sql = capture_sql { klass.create!(name: "Steve") }.second
+
+    assert_match(/mentor_id/, create_sql)
+    assert_match(/firm_id/, create_sql)
+
+    developer = klass.find_by!(name: "Steve")
+
+    update_sql = capture_sql { developer.update(name: "Stephen") }.second
+
+    assert_no_match(/mentor_id/, update_sql)
+    assert_match(/firm_id/, update_sql)
+  end
+
+  def test_default_scope_runs_on_create
+    Mentor.create!
+    create_sql = capture_sql { DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen") }.second
+
+    assert_match(/mentor_id/, create_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_create
+    Mentor.create!
+    create_sql = capture_sql { DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen") }.second
+
+    assert_match(/mentor_id/, create_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_create
+    create_sql = capture_sql { DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita") }.first
+
+    assert_no_match(/AND$/, create_sql)
+  end
+
+  def test_default_scope_runs_on_select
+    Mentor.create!
+    DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    select_sql = capture_sql { DeveloperwithDefaultMentorScopeNot.find_by(name: "Eileen") }.first
+
+    assert_match(/mentor_id/, select_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_select
+    Mentor.create!
+    DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    select_sql = capture_sql { DeveloperWithDefaultMentorScopeAllQueries.find_by(name: "Eileen") }.first
+
+    assert_match(/mentor_id/, select_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_select
+    DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    select_sql = capture_sql { DeveloperWithDefaultNilableFirmScopeAllQueries.find_by(name: "Nikita") }.first
+
+    assert_no_match(/AND$/, select_sql)
+  end
+
+  def test_default_scope_doesnt_run_on_update
+    Mentor.create!
+    dev = DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    update_sql = capture_sql { dev.update!(name: "Not Eileen") }.first
+
+    assert_no_match(/mentor_id/, update_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_update
+    Mentor.create!
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    update_sql = capture_sql { dev.update!(name: "Not Eileen") }.second
+
+    assert_match(/mentor_id/, update_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_update
+    dev = DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    update_sql = capture_sql { dev.update!(name: "Not Nikita") }.first
+
+    assert_no_match(/AND$/, update_sql)
+  end
+
+  def test_default_scope_doesnt_run_on_update_columns
+    Mentor.create!
+    dev = DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    update_sql = capture_sql { dev.update_columns(name: "Not Eileen") }.first
+
+    assert_no_match(/mentor_id/, update_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_update_columns
+    Mentor.create!
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    update_sql = capture_sql { dev.update_columns(name: "Not Eileen") }.first
+
+    assert_match(/mentor_id/, update_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_update_columns
+    dev = DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    update_sql = capture_sql { dev.update_columns(name: "Not Nikita") }.first
+
+    assert_no_match(/AND$/, update_sql)
+  end
+
+  def test_default_scope_doesnt_run_on_destroy
+    Mentor.create!
+    dev = DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    destroy_sql = capture_sql { dev.destroy }.first
+
+    assert_no_match(/mentor_id/, destroy_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_destroy
+    Mentor.create!
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    destroy_sql = capture_sql { dev.destroy }.second
+
+    assert_match(/mentor_id/, destroy_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_destroy
+    dev = DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    destroy_sql = capture_sql { dev.destroy }.first
+
+    assert_no_match(/AND$/, destroy_sql)
+  end
+
+  def test_default_scope_doesnt_run_on_reload
+    Mentor.create!
+    dev = DeveloperwithDefaultMentorScopeNot.create!(name: "Eileen")
+    reload_sql = capture_sql { dev.reload }.first
+
+    assert_no_match(/mentor_id/, reload_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_reload
+    Mentor.create!
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen")
+    reload_sql = capture_sql { dev.reload }.first
+
+    assert_match(/mentor_id/, reload_sql)
+  end
+
+  def test_default_scope_with_all_queries_runs_on_reload_but_default_scope_without_all_queries_does_not
+    Mentor.create!
+    dev = DeveloperWithIncludedMentorDefaultScopeNotAllQueriesAndDefaultScopeFirmWithAllQueries.create!(name: "Eileen")
+    reload_sql = capture_sql { dev.reload }.first
+
+    assert_no_match(/mentor_id/, reload_sql)
+    assert_match(/firm_id/, reload_sql)
+  end
+
+  def test_nilable_default_scope_with_all_queries_runs_on_reload
+    dev = DeveloperWithDefaultNilableFirmScopeAllQueries.create!(name: "Nikita")
+    reload_sql = capture_sql { dev.reload }.first
+
+    assert_no_match(/AND$/, reload_sql)
+  end
+
+  def test_default_scope_with_all_queries_doesnt_run_on_destroy_when_unscoped
+    dev = DeveloperWithDefaultMentorScopeAllQueries.create!(name: "Eileen", mentor_id: 2)
+    reload_sql = capture_sql { dev.reload({ unscoped: true }) }.first
+
+    assert_no_match(/mentor_id/, reload_sql)
+  end
+
   def test_scope_overwrites_default
     expected = Developer.all.merge!(order: "salary DESC, name DESC").to_a.collect(&:name)
     received = DeveloperOrderedBySalary.by_name.to_a.collect(&:name)
@@ -242,6 +411,20 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
+  def test_unscope_eager_load
+    expected = Developer.all.collect(&:name)
+    received = Developer.eager_load(:projects).select(:id).unscope(:eager_load, :select)
+    assert_equal expected, received.collect(&:name)
+    assert_equal false, received.first.projects.loaded?
+  end
+
+  def test_unscope_preloads
+    expected = Developer.all.collect(&:name)
+    received = Developer.preload(:projects).select(:id).unscope(:preload, :select)
+    assert_equal expected, received.collect(&:name)
+    assert_equal false, received.first.projects.loaded?
+  end
+
   def test_unscope_having
     expected = DeveloperOrderedBySalary.all.collect(&:name)
     received = DeveloperOrderedBySalary.having("name IN ('Jamis', 'David')").unscope(:having).collect(&:name)
@@ -260,7 +443,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_unscope_errors_with_invalid_value
     assert_raises(ArgumentError) do
-      Developer.includes(:projects).where(name: "Jamis").unscope(:stupidly_incorrect_value)
+      Developer.includes(:projects).where(name: "Jamis").unscope(:incorrect_value)
     end
 
     assert_raises(ArgumentError) do
@@ -522,48 +705,49 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_with_abstract_class_scope_should_be_executed_in_correct_context
-    vegetarian_pattern = /#{Regexp.escape(Lion.connection.quote_table_name("lions.is_vegetarian"))}/i
-    gender_pattern     = /#{Regexp.escape(Lion.connection.quote_table_name("lions.gender"))}/i
-
-    assert_match vegetarian_pattern, Lion.all.to_sql
-    assert_match gender_pattern, Lion.female.to_sql
+    assert_match %r/#{Regexp.escape(quote_table_name("lions.is_vegetarian"))}/i, Lion.all.to_sql
+    assert_match %r/#{Regexp.escape(quote_table_name("lions.gender"))}/i, Lion.female.to_sql
   end
 end
 
 class DefaultScopingWithThreadTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-
-  def test_default_scoping_with_threads
-    2.times do
-      Thread.new {
-        assert_includes DeveloperOrderedBySalary.all.to_sql, "salary DESC"
-        DeveloperOrderedBySalary.connection.close
-      }.join
+  unless in_memory_db?
+    self.use_transactional_tests = false
+
+    def test_default_scoping_with_threads
+      2.times do
+        Thread.new {
+          assert_includes DeveloperOrderedBySalary.all.to_sql, "salary DESC"
+          DeveloperOrderedBySalary.lease_connection.close
+        }.join
+      end
     end
-  end
 
-  def test_default_scope_is_threadsafe
-    2.times { ThreadsafeDeveloper.unscoped.create! }
+    def test_default_scope_is_threadsafe
+      skip "DB2 IBM_DB adapter has a threading race condition in INSERT statement generation (SQL0117N column count mismatch)" if ActiveRecord::Base.lease_connection.adapter_name == "IBM_DB"
+      
+      2.times { ThreadsafeDeveloper.unscoped.create! }
 
-    threads = []
-    assert_not_equal 1, ThreadsafeDeveloper.unscoped.count
+      threads = []
+      assert_not_equal 1, ThreadsafeDeveloper.unscoped.count
 
-    barrier_1 = Concurrent::CyclicBarrier.new(2)
-    barrier_2 = Concurrent::CyclicBarrier.new(2)
+      barrier_1 = Concurrent::CyclicBarrier.new(2)
+      barrier_2 = Concurrent::CyclicBarrier.new(2)
 
-    threads << Thread.new do
-      Thread.current[:default_scope_delay] = -> { barrier_1.wait; barrier_2.wait }
-      assert_equal 1, ThreadsafeDeveloper.all.to_a.count
-      ThreadsafeDeveloper.connection.close
-    end
-    threads << Thread.new do
-      Thread.current[:default_scope_delay] = -> { barrier_2.wait }
-      barrier_1.wait
-      assert_equal 1, ThreadsafeDeveloper.all.to_a.count
-      ThreadsafeDeveloper.connection.close
+      threads << Thread.new do
+        Thread.current[:default_scope_delay] = -> { barrier_1.wait; barrier_2.wait }
+        assert_equal 1, ThreadsafeDeveloper.all.to_a.count
+        ThreadsafeDeveloper.lease_connection.close
+      end
+      threads << Thread.new do
+        Thread.current[:default_scope_delay] = -> { barrier_2.wait }
+        barrier_1.wait
+        assert_equal 1, ThreadsafeDeveloper.all.to_a.count
+        ThreadsafeDeveloper.lease_connection.close
+      end
+      threads.each(&:join)
+    ensure
+      ThreadsafeDeveloper.unscoped.destroy_all
     end
-    threads.each(&:join)
-  ensure
-    ThreadsafeDeveloper.unscoped.destroy_all
   end
-end unless in_memory_db?
+end

data/test/cases/scoping/named_scoping_test.rb

@@ -24,7 +24,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_found_items_are_cached
     all_posts = Topic.base
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       all_posts.collect { true }
       all_posts.collect { true }
     end
@@ -194,7 +194,7 @@ class NamedScopingTest < ActiveRecord::TestCase
       e = assert_raises ArgumentError do
         Class.new(Post).class_eval { scope name, -> { where(approved: true) } }
       end
-      assert_match(/You tried to define a scope named \"#{name}\" on the model/, e.message)
+      assert_match(/You tried to define a scope named "#{name}" on the model/, e.message)
     end
   end
 
@@ -227,7 +227,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_empty_should_not_load_results
     topics = Topic.base
-    assert_queries(2) do
+    assert_queries_count(2) do
       topics.empty?  # use count query
       topics.load    # force load
       topics.empty?  # use loaded (no query)
@@ -236,7 +236,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_any_should_not_load_results
     topics = Topic.base
-    assert_queries(2) do
+    assert_queries_count(2) do
       topics.any?    # use count query
       topics.load    # force load
       topics.any?    # use loaded (no query)
@@ -245,7 +245,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_any_should_call_proxy_found_if_using_a_block
     topics = Topic.base
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_not_called(topics, :empty?) do
         topics.any? { true }
       end
@@ -255,7 +255,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_any_should_not_fire_query_if_scope_loaded
     topics = Topic.base
     topics.load # force load
-    assert_no_queries { assert topics.any? }
+    assert_no_queries { assert_predicate topics, :any? }
   end
 
   def test_model_class_should_respond_to_any
@@ -266,7 +266,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_many_should_not_load_results
     topics = Topic.base
-    assert_queries(2) do
+    assert_queries_count(2) do
       topics.many?   # use count query
       topics.load    # force load
       topics.many?   # use loaded (no query)
@@ -275,7 +275,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_many_should_call_proxy_found_if_using_a_block
     topics = Topic.base
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_not_called(topics, :size) do
         topics.many? { true }
       end
@@ -285,7 +285,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_many_should_not_fire_query_if_scope_loaded
     topics = Topic.base
     topics.load # force load
-    assert_no_queries { assert topics.many? }
+    assert_no_queries { assert_predicate topics, :many? }
   end
 
   def test_many_should_return_false_if_none_or_one
@@ -363,7 +363,6 @@ class NamedScopingTest < ActiveRecord::TestCase
       :protected,
       :private,
       :name,
-      :parent,
       :superclass
     ]
 
@@ -380,12 +379,12 @@ class NamedScopingTest < ActiveRecord::TestCase
       e = assert_raises(ArgumentError, "scope `#{name}` should not be allowed") do
         klass.class_eval { scope name, -> { where(approved: true) } }
       end
-      assert_match(/You tried to define a scope named \"#{name}\" on the model/, e.message)
+      assert_match(/You tried to define a scope named "#{name}" on the model/, e.message)
 
       e = assert_raises(ArgumentError, "scope `#{name}` should not be allowed") do
         subklass.class_eval { scope name, -> { where(approved: true) } }
       end
-      assert_match(/You tried to define a scope named \"#{name}\" on the model/, e.message)
+      assert_match(/You tried to define a scope named "#{name}" on the model/, e.message)
     end
 
     non_conflicts.each do |name|
@@ -428,8 +427,8 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_size_should_use_count_when_results_are_not_loaded
     topics = Topic.base
-    assert_queries(1) do
-      assert_sql(/COUNT/i) { topics.size }
+    assert_queries_count(1) do
+      assert_queries_match(/COUNT/i) { topics.size }
     end
   end
 
@@ -495,13 +494,13 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_scopes_batch_finders
     assert_equal 4, Topic.approved.count
 
-    assert_queries(5) do
-      Topic.approved.find_each(batch_size: 1) { |t| assert t.approved? }
+    assert_queries_count(5) do
+      Topic.approved.find_each(batch_size: 1) { |t| assert_predicate t, :approved? }
     end
 
-    assert_queries(3) do
+    assert_queries_count(3) do
       Topic.approved.find_in_batches(batch_size: 2) do |group|
-        group.each { |t| assert t.approved? }
+        group.each { |t| assert_predicate t, :approved? }
       end
     end
   end
@@ -512,26 +511,6 @@ class NamedScopingTest < ActiveRecord::TestCase
     end
   end
 
-  def test_scopes_with_reserved_names
-    class << Topic
-      def public_method; end
-      public :public_method
-
-      def protected_method; end
-      protected :protected_method
-
-      def private_method; end
-      private :private_method
-    end
-
-    [:public_method, :protected_method, :private_method].each do |reserved_method|
-      assert Topic.respond_to?(reserved_method, true)
-      assert_called(ActiveRecord::Base.logger, :warn) do
-        silence_warnings { Topic.scope(reserved_method, -> { }) }
-      end
-    end
-  end
-
   def test_scopes_on_relations
     # Topic.replied
     approved_topics = Topic.all.approved.order("id DESC")
@@ -548,19 +527,19 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_nested_scopes_queries_size
-    assert_queries(1) do
+    assert_queries_count(1) do
       Topic.approved.by_lifo.replied.written_before(Time.now).to_a
     end
   end
 
   # Note: these next two are kinda odd because they are essentially just testing that the
-  # query cache works as it should, but they are here for legacy reasons as they was previously
+  # query cache works as it should, but they are here for legacy reasons as there was previously
   # a separate cache on association proxies, and these show that that is not necessary.
   def test_scopes_are_cached_on_associations
     post = posts(:welcome)
 
     Post.cache do
-      assert_queries(1) { post.comments.containing_the_letter_e.to_a }
+      assert_queries_count(1) { post.comments.containing_the_letter_e.to_a }
       assert_no_queries { post.comments.containing_the_letter_e.to_a }
     end
   end
@@ -569,10 +548,10 @@ class NamedScopingTest < ActiveRecord::TestCase
     post = posts(:welcome)
 
     Post.cache do
-      one = assert_queries(1) { post.comments.limit_by(1).to_a }
+      one = assert_queries_count(1) { post.comments.limit_by(1).to_a }
       assert_equal 1, one.size
 
-      two = assert_queries(1) { post.comments.limit_by(2).to_a }
+      two = assert_queries_count(1) { post.comments.limit_by(2).to_a }
       assert_equal 2, two.size
 
       assert_no_queries { post.comments.limit_by(1).to_a }
@@ -614,7 +593,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_subclass_merges_scopes_properly
-    assert_equal 1, SpecialComment.where(body: "go crazy").created.count
+    assert_equal 1, SpecialComment.where(body: "go wild").created.count
   end
 
   def test_model_class_should_respond_to_extending
@@ -642,8 +621,8 @@ class NamedScopingTest < ActiveRecord::TestCase
       scope :including_annotate_in_scope, Proc.new { annotate("from-scope") }
     end
 
-    assert_sql(%r{/\* from-scope \*/}) do
-      assert Topic.including_annotate_in_scope.to_a, Topic.all.to_a
+    assert_queries_match(%r{/\* from-scope \*/}) do
+      assert_equal Topic.including_annotate_in_scope.to_a, Topic.all.to_a
     end
   end
 end

data/test/cases/scoping/relation_scoping_test.rb

@@ -42,15 +42,24 @@ class RelationScopingTest < ActiveRecord::TestCase
     assert_equal Developer.order("id DESC").to_a.reverse, Developer.order("id DESC").reverse_order
   end
 
-  def test_reverse_order_with_arel_node
+  def test_reverse_order_with_arel_attribute
     assert_equal Developer.order("id DESC").to_a.reverse, Developer.order(Developer.arel_table[:id].desc).reverse_order
   end
 
-  def test_reverse_order_with_multiple_arel_nodes
+  def test_reverse_order_with_arel_attribute_as_hash
+    assert_equal Developer.order("id DESC").to_a.reverse, Developer.order(Developer.arel_table[:id] => :desc).reverse_order
+  end
+
+  def test_reverse_order_with_arel_node_as_hash
+    node = Developer.arel_table[:id] + 0 # converts to Arel::Nodes::Grouping
+    assert_equal Developer.order("id DESC").to_a.reverse, Developer.order(node => :desc).reverse_order
+  end
+
+  def test_reverse_order_with_multiple_arel_attributes
     assert_equal Developer.order("id DESC").order("name DESC").to_a.reverse, Developer.order(Developer.arel_table[:id].desc).order(Developer.arel_table[:name].desc).reverse_order
   end
 
-  def test_reverse_order_with_arel_nodes_and_strings
+  def test_reverse_order_with_arel_attributes_and_strings
     assert_equal Developer.order("id DESC").order("name DESC").to_a.reverse, Developer.order("id DESC").order(Developer.arel_table[:name].desc).reverse_order
   end
 
@@ -147,7 +156,7 @@ class RelationScopingTest < ActiveRecord::TestCase
   def test_scoped_find_with_annotation
     Developer.annotate("scoped").scoping do
       developer = nil
-      assert_sql(%r{/\* scoped \*/}) do
+      assert_queries_match(%r{/\* scoped \*/}) do
         developer = Developer.where("name = 'David'").first
       end
       assert_equal "David", developer.name
@@ -349,6 +358,90 @@ class RelationScopingTest < ActiveRecord::TestCase
     end
     assert_equal posts, Post.left_joins(comments: :post).first(10)
   end
+
+  def test_scoping_applies_to_update_with_all_queries
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    dev = Author.where(organization_id: 1).first
+
+    Author.where(organization_id: 1).scoping do
+      update_sql = capture_sql { dev.update(name: "Eileen") }.first
+      assert_no_match(/organization_id/, update_sql)
+    end
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      update_scoped_sql = capture_sql { dev.update(name: "Not Eileen") }.second
+      assert_match(/organization_id/, update_scoped_sql)
+    end
+  end
+
+  def test_scoping_applies_to_delete_with_all_queries
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    dev1 = Author.where(organization_id: 1).first
+    dev2 = Author.where(organization_id: 1).last
+
+    Author.where(organization_id: 1).scoping do
+      delete_sql = capture_sql { dev1.delete }.first
+      assert_no_match(/organization_id/, delete_sql)
+    end
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      delete_scoped_sql = capture_sql { dev2.delete }.first
+      assert_match(/organization_id/, delete_scoped_sql)
+    end
+  end
+
+  def test_scoping_applies_to_reload_with_all_queries
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    dev1 = Author.where(organization_id: 1).first
+
+    Author.where(organization_id: 1).scoping do
+      reload_sql = capture_sql { dev1.reload }.first
+      assert_no_match(/organization_id/, reload_sql)
+    end
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      scoped_reload_sql = capture_sql { dev1.reload }.first
+      assert_match(/organization_id/, scoped_reload_sql)
+    end
+  end
+
+  def test_nested_scoping_applies_with_all_queries_set
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      select_sql = capture_sql { Author.first }.first
+      assert_match(/organization_id/, select_sql)
+
+      Author.where(owned_essay_id: nil).scoping do
+        second_select_sql = capture_sql { Author.first }.first
+        assert_match(/organization_id/, second_select_sql)
+        assert_match(/owned_essay_id/, second_select_sql)
+      end
+
+      third_select_sql = capture_sql { Author.first }.first
+      assert_match(/organization_id/, third_select_sql)
+      assert_no_match(/owned_essay_id/, third_select_sql)
+    end
+  end
+
+  def test_raises_error_if_all_queries_is_set_to_false_while_nested
+    Author.all.limit(5).update_all(organization_id: 1)
+
+    Author.where(organization_id: 1).scoping(all_queries: true) do
+      select_sql = capture_sql { Author.first }.first
+      assert_match(/organization_id/, select_sql)
+
+      error = assert_raises ArgumentError do
+        Author.where(organization_id: 1).scoping(all_queries: false) { }
+      end
+
+      assert_equal "Scoping is set to apply to all queries and cannot be " \
+       "unset in a nested block.", error.message
+    end
+  end
 end
 
 class NestedRelationScopingTest < ActiveRecord::TestCase
@@ -482,6 +575,21 @@ class HasManyScopingTest < ActiveRecord::TestCase
     magician = BadReference.find(1)
     assert_equal [magician], michael.bad_references
   end
+
+  def test_scoping_applies_to_all_queries_on_has_many_when_set
+    @welcome.comments.update_all(author_id: 1)
+
+    comments_sql = capture_sql { @welcome.comments.to_a }.last
+    assert_no_match(/author_id/, comments_sql)
+
+    Comment.where(author_id: 1).scoping(all_queries: true) do
+      scoped_comments_sql = capture_sql { @welcome.comments.reload.to_a }.last
+      assert_match(/author_id/, scoped_comments_sql)
+    end
+
+    unscoped_comments_sql = capture_sql { @welcome.comments.reload.to_a }.last
+    assert_no_match(/author_id/, unscoped_comments_sql)
+  end
 end
 
 class HasAndBelongsToManyScopingTest < ActiveRecord::TestCase