2 files changed, 118 insertions, 35 deletions

diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 2358e2396d..170e9a49eb 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -54,12 +54,14 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal 'Jamis', DeveloperCalledJamis.create!.name
   end
 
-  def test_default_scoping_with_threads
-    2.times do
-      Thread.new {
-        assert DeveloperOrderedBySalary.all.to_sql.include?('salary DESC')
-        DeveloperOrderedBySalary.connection.close
-      }.join
+  unless in_memory_db?
+    def test_default_scoping_with_threads
+      2.times do
+        Thread.new {
+          assert DeveloperOrderedBySalary.all.to_sql.include?('salary DESC')
+          DeveloperOrderedBySalary.connection.close
+        }.join
+      end
     end
   end
 
@@ -101,7 +103,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_unscope_overrides_default_scope
     expected = Developer.all.collect { |dev| [dev.name, dev.id] }
-    received = Developer.order('name ASC, id DESC').unscope(:order).collect { |dev| [dev.name, dev.id] }
+    received = DeveloperCalledJamis.unscope(:where).collect { |dev| [dev.name, dev.id] }
     assert_equal expected, received
   end
 
@@ -120,17 +122,25 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_unscope_with_where_attributes
-    expected = Developer.order('salary DESC').collect { |dev| dev.name }
-    received = DeveloperOrderedBySalary.where(name: 'David').unscope(where: :name).collect { |dev| dev.name }
+    expected = Developer.order('salary DESC').collect(&:name)
+    received = DeveloperOrderedBySalary.where(name: 'David').unscope(where: :name).collect(&:name)
     assert_equal expected, received
 
-    expected_2 = Developer.order('salary DESC').collect { |dev| dev.name }
-    received_2 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope({:where => :name}, :select).collect { |dev| dev.name }
+    expected_2 = Developer.order('salary DESC').collect(&:name)
+    received_2 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope({:where => :name}, :select).collect(&:name)
     assert_equal expected_2, received_2
 
-    expected_3 = Developer.order('salary DESC').collect { |dev| dev.name }
-    received_3 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope(:select, :where).collect { |dev| dev.name }
+    expected_3 = Developer.order('salary DESC').collect(&:name)
+    received_3 = DeveloperOrderedBySalary.select("id").where("name" => "Jamis").unscope(:select, :where).collect(&:name)
     assert_equal expected_3, received_3
+
+    expected_4 = Developer.order('salary DESC').collect(&:name)
+    received_4 = DeveloperOrderedBySalary.where.not("name" => "Jamis").unscope(where: :name).collect(&:name)
+    assert_equal expected_4, received_4
+
+    expected_5 = Developer.order('salary DESC').collect(&:name)
+    received_5 = DeveloperOrderedBySalary.where.not("name" => ["Jamis", "David"]).unscope(where: :name).collect(&:name)
+    assert_equal expected_5, received_5
   end
 
   def test_unscope_multiple_where_clauses
@@ -139,6 +149,16 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
+  def test_unscope_string_where_clauses_involved
+    dev_relation = Developer.order('salary DESC').where("created_at > ?", 1.year.ago)
+    expected = dev_relation.collect { |dev| dev.name }
+
+    dev_ordered_relation = DeveloperOrderedBySalary.where(name: 'Jamis').where("created_at > ?", 1.year.ago)
+    received = dev_ordered_relation.unscope(where: [:name]).collect { |dev| dev.name }
+
+    assert_equal expected, received
+  end
+
   def test_unscope_with_grouping_attributes
     expected = Developer.order('salary DESC').collect { |dev| dev.name }
     received = DeveloperOrderedBySalary.group(:name).unscope(:group).collect { |dev| dev.name }
@@ -168,7 +188,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_unscope_select
     expected = Developer.order('salary ASC').collect { |dev| dev.name }
-    received = Developer.order('salary DESC').reverse_order.select(:name => "Jamis").unscope(:select).collect { |dev| dev.name }
+    received = Developer.order('salary DESC').reverse_order.select(:name).unscope(:select).collect { |dev| dev.name }
     assert_equal expected, received
 
     expected_2 = Developer.all.collect { |dev| dev.id }
@@ -252,6 +272,12 @@ class DefaultScopingTest < ActiveRecord::TestCase
     end
   end
 
+  def test_unscope_merging
+    merged = Developer.where(name: "Jamis").merge(Developer.unscope(:where))
+    assert merged.where_values.empty?
+    assert !merged.where(name: "Jon").where_values.empty?
+  end
+
   def test_order_in_default_scope_should_not_prevail
     expected = Developer.all.merge!(order: 'salary desc').to_a.collect { |dev| dev.salary }
     received = DeveloperOrderedBySalary.all.merge!(order: 'salary').to_a.collect { |dev| dev.salary }
@@ -352,23 +378,21 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal 1, DeveloperWithIncludes.where(:audit_logs => { :message => 'foo' }).count
   end
 
-  def test_default_scope_is_threadsafe
-    if in_memory_db?
-      skip "in memory db can't share a db between threads"
-    end
-
-    threads = []
-    assert_not_equal 1, ThreadsafeDeveloper.unscoped.count
-
-    threads << Thread.new do
-      Thread.current[:long_default_scope] = true
-      assert_equal 1, ThreadsafeDeveloper.all.to_a.count
-      ThreadsafeDeveloper.connection.close
-    end
-    threads << Thread.new do
-      assert_equal 1, ThreadsafeDeveloper.all.to_a.count
-      ThreadsafeDeveloper.connection.close
+  unless in_memory_db?
+    def test_default_scope_is_threadsafe
+      threads = []
+      assert_not_equal 1, ThreadsafeDeveloper.unscoped.count
+
+      threads << Thread.new do
+        Thread.current[:long_default_scope] = true
+        assert_equal 1, ThreadsafeDeveloper.all.to_a.count
+        ThreadsafeDeveloper.connection.close
+      end
+      threads << Thread.new do
+        assert_equal 1, ThreadsafeDeveloper.all.to_a.count
+        ThreadsafeDeveloper.connection.close
+      end
+      threads.each(&:join)
     end
-    threads.each(&:join)
   end
 end
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 72c9787b84..f0ad9ebb8a 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -266,6 +266,65 @@ class NamedScopingTest < ActiveRecord::TestCase
     assert_equal 'lifo', topic.author_name
   end
 
+  def test_reserved_scope_names
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+
+      scope :approved, -> { where(approved: true) }
+
+      class << self
+        public
+          def pub; end
+
+        private
+          def pri; end
+
+        protected
+          def pro; end
+      end
+    end
+
+    subklass = Class.new(klass)
+
+    conflicts = [
+      :create,        # public class method on AR::Base
+      :relation,      # private class method on AR::Base
+      :new,           # redefined class method on AR::Base
+      :all,           # a default scope
+    ]
+
+    non_conflicts = [
+      :find_by_title, # dynamic finder method
+      :approved,      # existing scope
+      :pub,           # existing public class method
+      :pri,           # existing private class method
+      :pro,           # existing protected class method
+      :open,          # a ::Kernel method
+    ]
+
+    conflicts.each do |name|
+      assert_raises(ArgumentError, "scope `#{name}` should not be allowed") do
+        klass.class_eval { scope name, ->{ where(approved: true) } }
+      end
+
+      assert_raises(ArgumentError, "scope `#{name}` should not be allowed") do
+        subklass.class_eval { scope name, ->{ where(approved: true) } }
+      end
+    end
+
+    non_conflicts.each do |name|
+      assert_nothing_raised do
+        silence_warnings do
+          klass.class_eval { scope name, ->{ where(approved: true) } }
+        end
+      end
+
+      assert_nothing_raised do
+        subklass.class_eval { scope name, ->{ where(approved: true) } }
+      end
+    end
+  end
+
   # Method delegation for scope names which look like /\A[a-zA-Z_]\w*[!?]?\z/
   # has been done by evaluating a string with a plain def statement. For scope
   # names which contain spaces this approach doesn't work.
@@ -344,13 +403,13 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_scopes_batch_finders
-    assert_equal 3, Topic.approved.count
+    assert_equal 4, Topic.approved.count
 
-    assert_queries(4) do
+    assert_queries(5) do
       Topic.approved.find_each(:batch_size => 1) {|t| assert t.approved? }
     end
 
-    assert_queries(2) do
+    assert_queries(3) do
       Topic.approved.find_in_batches(:batch_size => 2) do |group|
         group.each {|t| assert t.approved? }
       end
@@ -366,7 +425,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   def test_scopes_on_relations
     # Topic.replied
     approved_topics = Topic.all.approved.order('id DESC')
-    assert_equal topics(:fourth), approved_topics.first
+    assert_equal topics(:fifth), approved_topics.first
 
     replied_approved_topics = approved_topics.replied
     assert_equal topics(:third), replied_approved_topics.first