activerecord 1.13.2 → 1.14.0

data/test/fixtures/db_definitions/sybase2.drop.sql

@@ -0,0 +1,4 @@
+DROP TABLE courses
+go
+
+

data/test/fixtures/db_definitions/sybase2.sql

@@ -0,0 +1,5 @@
+CREATE TABLE courses (
+ id int NOT NULL PRIMARY KEY,
+ name varchar(255) NOT NULL
+)
+go

data/test/fixtures/developers.yml

@@ -13,4 +13,9 @@ dev_<%= digit %>:
   id: <%= digit %>
   name: fixture_<%= digit %>
   salary: 100000
-<% end %>
+<% end %>
+
+poor_jamis:
+  id: 11
+  name: Jamis
+  salary: 9000

data/test/fixtures/developers_projects.yml

@@ -11,3 +11,7 @@ david_active_record:
 jamis_active_record:
   developer_id: 2
   project_id: 1
+
+poor_jamis_active_record:
+  developer_id: 11
+  project_id: 1

data/test/fixtures/funny_jokes.yml

@@ -0,0 +1,14 @@
+a_joke:
+  id: 1
+  name: Knock knock
+
+another_joke:
+  id: 2
+  name: The Aristocrats
+a_joke:
+  id: 1
+  name: Knock knock
+
+another_joke:
+  id: 2
+  name: The Aristocrats

data/test/fixtures/joke.rb

@@ -0,0 +1,6 @@
+class Joke < ActiveRecord::Base
+  set_table_name 'funny_jokes'
+end
+class Joke < ActiveRecord::Base
+  set_table_name 'funny_jokes'
+end

data/test/fixtures/legacy_thing.rb

@@ -0,0 +1,3 @@
+class LegacyThing < ActiveRecord::Base
+  set_locking_column :version
+end

data/test/fixtures/legacy_things.yml

@@ -0,0 +1,3 @@
+obtuse:
+  id: 1
+  tps_report_number: 500

data/test/fixtures/mixin.rb

@@ -30,7 +30,7 @@ class ListWithStringScopeMixin < ActiveRecord::Base
 end
 
 class NestedSet < Mixin
-  acts_as_nested_set :scope => "ROOT_ID IS NULL"
+  acts_as_nested_set :scope => "root_id IS NULL"
   
   def self.table_name() "mixins" end
 end

data/test/fixtures/person.rb

@@ -1 +1,4 @@
-class Person < ActiveRecord::Base; end
+class Person < ActiveRecord::Base
+  has_many :readers
+  has_many :posts, :through => :readers
+end

data/test/fixtures/post.rb

@@ -18,8 +18,29 @@ class Post < ActiveRecord::Base
   has_many :special_comments
 
   has_and_belongs_to_many :categories
-  has_and_belongs_to_many :special_categories, :join_table => "categories_posts"
+  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'
+
+  has_many :taggings, :as => :taggable
+  has_many :tags, :through => :taggings, :include => :tagging do
+    def add_joins_and_select
+      find :all, :select => 'tags.*, authors.id as author_id', :include => false,
+        :joins => 'left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id'
+    end
+  end
   
+  has_many :funky_tags, :through => :taggings, :source => :tag
+  has_many :super_tags, :through => :taggings
+  has_one :tagging, :as => :taggable
+
+  has_many :invalid_taggings, :as => :taggable, :class_name => "Tagging", :conditions => 'taggings.id < 0'
+  has_many :invalid_tags, :through => :invalid_taggings, :source => :tag
+
+  has_many :categorizations, :foreign_key => :category_id
+  has_many :authors, :through => :categorizations
+
+  has_many :readers
+  has_many :people, :through => :readers
+
   def self.what_are_you
     'a post...'
   end
@@ -28,5 +49,9 @@ end
 class SpecialPost < Post; end;
 
 class StiPost < Post
+  self.abstract_class = true
   has_one :special_comment, :class_name => "SpecialComment"
 end
+
+class SubStiPost < StiPost
+end

data/test/fixtures/project.rb

@@ -1,5 +1,6 @@
 class Project < ActiveRecord::Base
   has_and_belongs_to_many :developers, :uniq => true
+  has_and_belongs_to_many :limited_developers, :class_name => "Developer", :limit => 1
   has_and_belongs_to_many :developers_named_david, :class_name => "Developer", :conditions => "name = 'David'", :uniq => true
   has_and_belongs_to_many :salaried_developers, :class_name => "Developer", :conditions => "salary > 0"
   has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => 'SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id}'

data/test/fixtures/reader.rb

@@ -0,0 +1,4 @@
+class Reader < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :person
+end

data/test/fixtures/readers.yml

@@ -0,0 +1,4 @@
+michael_welcome:
+  id: 1
+  post_id: 1
+  person_id: 1

data/test/fixtures/reply.rb

@@ -2,7 +2,7 @@ require 'fixtures/topic'
 
 class Reply < Topic
   belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true
-  has_many :silly_replies, :dependent => true, :foreign_key => "parent_id"
+  has_many :replies, :class_name => "SillyReply", :dependent => :destroy, :foreign_key => "parent_id"
 
   validate :errors_on_empty_content
   validate_on_create :title_is_wrong_create
@@ -33,4 +33,5 @@ class Reply < Topic
 end
 
 class SillyReply < Reply
+  belongs_to :reply, :foreign_key => "parent_id", :counter_cache => :replies_count
 end

data/test/fixtures/tag.rb

@@ -0,0 +1,5 @@
+class Tag < ActiveRecord::Base
+  has_many :taggings,  :as => :taggable
+  has_many :taggables, :through => :taggings
+  has_one  :tagging,   :as => :taggable
+end

data/test/fixtures/tagging.rb

@@ -0,0 +1,6 @@
+class Tagging < ActiveRecord::Base
+  belongs_to :tag, :include => :tagging
+  belongs_to :super_tag,   :class_name => 'Tag', :foreign_key => 'super_tag_id'
+  belongs_to :invalid_tag, :class_name => 'Tag', :foreign_key => 'tag_id'
+  belongs_to :taggable, :polymorphic => true, :counter_cache => true
+end

data/test/fixtures/taggings.yml

@@ -0,0 +1,18 @@
+welcome_general:
+  id: 1
+  tag_id: 1
+  super_tag_id: 2
+  taggable_id: 1
+  taggable_type: Post
+
+thinking_general:
+  id: 2
+  tag_id: 1
+  taggable_id: 2
+  taggable_type: Post
+
+fake: 
+  id: 3
+  tag_id: 1
+  taggable_id: 1
+  taggable_type: FakeModel

data/test/fixtures/tags.yml

@@ -0,0 +1,7 @@
+general:
+  id: 1
+  name: General
+  
+misc:
+  id: 2
+  name: Misc

data/test/fixtures/tasks.yml

@@ -1,7 +1,7 @@
 # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
 first_task:
   id: 1
-  starting: "2005-03-30 06:30:00"
-  ending: "2005-03-30 08:30:00"
+  starting: 2005-03-30t06:30:00.00+01:00
+  ending: 2005-03-30t08:30:00.00+01:00
 another_task:
   id: 2

data/test/fixtures/topic.rb

@@ -1,12 +1,12 @@
 class Topic < ActiveRecord::Base
-  has_many :replies, :dependent => true, :foreign_key => "parent_id"
+  has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
   serialize :content
   
   before_create  :default_written_on
   before_destroy :destroy_children
 
   def parent
-    self.class.find(parent_id)
+    Topic.find(parent_id)
   end
   
   protected

data/test/fixtures/topics.yml

@@ -19,3 +19,4 @@ second:
   approved: true
   replies_count: 2
   parent_id: 1
+  type: Reply

data/test/fixtures_test.rb

@@ -4,12 +4,14 @@ require 'fixtures/developer'
 require 'fixtures/company'
 require 'fixtures/task'
 require 'fixtures/reply'
+require 'fixtures/joke'
+require 'fixtures/category'
 
 class FixturesTest < Test::Unit::TestCase
   self.use_instantiated_fixtures = true
   self.use_transactional_fixtures = false
 
-  fixtures :topics, :developers, :accounts, :tasks
+  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes
 
   FIXTURES = %w( accounts companies customers
                  developers developers_projects entrants
@@ -60,7 +62,7 @@ class FixturesTest < Test::Unit::TestCase
         t.column :written_on, :datetime
         t.column :bonus_time, :time
         t.column :last_read, :date
-        t.column :content, :text
+        t.column :content, :string
         t.column :approved, :boolean, :default => true
         t.column :replies_count, :integer, :default => 0
         t.column :parent_id, :integer
@@ -77,16 +79,16 @@ class FixturesTest < Test::Unit::TestCase
 
       topics = create_fixtures("topics")
 
-      # Restore prefix/suffix to its previous values
-      ActiveRecord::Base.table_name_prefix = old_prefix 
-      ActiveRecord::Base.table_name_suffix = old_suffix 
-
       firstRow = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'David'")
       assert_equal("The First Topic", firstRow["title"])
 
       secondRow = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'Mary'")
       assert_nil(secondRow["author_email_address"])        
     ensure
+      # Restore prefix/suffix to its previous values
+      ActiveRecord::Base.table_name_prefix = old_prefix 
+      ActiveRecord::Base.table_name_suffix = old_suffix 
+
       ActiveRecord::Base.connection.drop_table :prefix_topics_suffix rescue nil
     end
   end
@@ -110,7 +112,7 @@ class FixturesTest < Test::Unit::TestCase
 
   def test_deprecated_yaml_extension
     assert_raise(Fixture::FormatError) {
-      Fixtures.new(nil, 'bad_extension', File.join(File.dirname(__FILE__), 'fixtures'))
+      Fixtures.new(nil, 'bad_extension', 'BadExtension', File.join(File.dirname(__FILE__), 'fixtures'))
     }
   end
 
@@ -136,31 +138,31 @@ class FixturesTest < Test::Unit::TestCase
   end
 
   def test_erb_in_fixtures
-    assert_equal 10, @developers.size
+    assert_equal 11, @developers.size
     assert_equal "fixture_5", @dev_5.name
   end
 
   def test_empty_yaml_fixture
-    assert_not_nil Fixtures.new( Account.connection, "accounts", File.dirname(__FILE__) + "/fixtures/naked/yml/accounts")
+    assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', File.dirname(__FILE__) + "/fixtures/naked/yml/accounts")
   end
 
   def test_empty_yaml_fixture_with_a_comment_in_it
-    assert_not_nil Fixtures.new( Account.connection, "companies", File.dirname(__FILE__) + "/fixtures/naked/yml/companies")
+    assert_not_nil Fixtures.new( Account.connection, "companies", 'Company', File.dirname(__FILE__) + "/fixtures/naked/yml/companies")
   end
 
   def test_dirty_dirty_yaml_file
     assert_raises(Fixture::FormatError) do
-      Fixtures.new( Account.connection, "courses", File.dirname(__FILE__) + "/fixtures/naked/yml/courses")
+      Fixtures.new( Account.connection, "courses", 'Course', File.dirname(__FILE__) + "/fixtures/naked/yml/courses")
     end
   end
 
   def test_empty_csv_fixtures
-    assert_not_nil Fixtures.new( Account.connection, "accounts", File.dirname(__FILE__) + "/fixtures/naked/csv/accounts")
+    assert_not_nil Fixtures.new( Account.connection, "accounts", 'Account', File.dirname(__FILE__) + "/fixtures/naked/csv/accounts")
   end
 
   def test_omap_fixtures
     assert_nothing_raised do
-      fixtures = Fixtures.new(Account.connection, 'categories', File.dirname(__FILE__) + '/fixtures/categories_ordered')
+      fixtures = Fixtures.new(Account.connection, 'categories', 'Category', File.dirname(__FILE__) + '/fixtures/categories_ordered')
 
       i = 0
       fixtures.each do |name, fixture|
@@ -170,6 +172,19 @@ class FixturesTest < Test::Unit::TestCase
       end
     end
   end
+
+
+  def test_yml_file_in_subdirectory
+    assert_equal(categories(:sub_special_1).name, "A special category in a subdir file")
+    assert_equal(categories(:sub_special_1).class, SpecialCategory)
+  end
+
+  def test_subsubdir_file_with_arbitrary_name
+    assert_equal(categories(:sub_special_3).name, "A special category in an arbitrarily named subsubdir file")
+    assert_equal(categories(:sub_special_3).class, SpecialCategory)
+  end
+
+
 end
 
 if Account.connection.respond_to?(:reset_pk_sequence!)
@@ -309,3 +324,22 @@ class ForeignKeyFixturesTest < Test::Unit::TestCase
     assert true
   end
 end
+
+class SetTableNameFixturesTest < Test::Unit::TestCase
+  set_fixture_class :funny_jokes => 'Joke'
+  fixtures :funny_jokes
+  
+  def test_table_method
+    assert_kind_of Joke, funny_jokes(:a_joke)
+  end
+end
+
+class InvalidTableNameFixturesTest < Test::Unit::TestCase
+  fixtures :funny_jokes
+
+  def test_raises_error
+    assert_raises FixtureClassNotFound do
+      funny_jokes(:a_joke)
+    end
+  end
+end

data/test/inheritance_test.rb

@@ -8,13 +8,13 @@ class InheritanceTest < Test::Unit::TestCase
 
   def test_a_bad_type_column
     #SQLServer need to turn Identity Insert On before manually inserting into the Identity column
-    if current_adapter?(:SQLServerAdapter)
+    if current_adapter?(:SQLServerAdapter) || current_adapter?(:SybaseAdapter)
       Company.connection.execute "SET IDENTITY_INSERT companies ON"
     end
     Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
 
     #We then need to turn it back Off before continuing.
-    if current_adapter?(:SQLServerAdapter)
+    if current_adapter?(:SQLServerAdapter) || current_adapter?(:SybaseAdapter)
       Company.connection.execute "SET IDENTITY_INSERT companies OFF"
     end
     assert_raises(ActiveRecord::SubclassNotFound) { Company.find(100) }

data/test/locking_test.rb

@@ -1,8 +1,9 @@
 require 'abstract_unit'
 require 'fixtures/person'
+require 'fixtures/legacy_thing'
 
 class LockingTest < Test::Unit::TestCase
-  fixtures :people
+  fixtures :people, :legacy_things
 
   def test_lock_existing
     p1 = Person.find(1)
@@ -28,5 +29,18 @@ class LockingTest < Test::Unit::TestCase
       p2.first_name = "should fail"
       p2.save
     }
+  end
+  
+  def test_lock_column_name_existing
+    t1 = LegacyThing.find(1)
+    t2 = LegacyThing.find(1)
+    t1.tps_report_number = 400
+    t1.save
+
+    assert_raises(ActiveRecord::StaleObjectError) {
+      t2.tps_report_number = 300
+      t2.save
+    }
   end 
+
 end

data/test/method_scoping_test.rb

@@ -1,15 +1,16 @@
 require 'abstract_unit'
 require 'fixtures/developer'
+require 'fixtures/project'
 require 'fixtures/comment'
 require 'fixtures/post'
 require 'fixtures/category'
 
 class MethodScopingTest < Test::Unit::TestCase
-  fixtures :developers, :comments, :posts
+  fixtures :developers, :projects, :comments, :posts
   
   def test_set_conditions
     Developer.with_scope(:find => { :conditions => 'just a test...' }) do
-      assert_equal 'just a test...', Thread.current[:scoped_methods][Developer][:find][:conditions]
+      assert_equal 'just a test...', Developer.send(:current_scoped_methods)[:find][:conditions]
     end
   end
 
@@ -25,9 +26,27 @@ class MethodScopingTest < Test::Unit::TestCase
     end
   end
   
+  def test_scoped_find_combines_conditions
+    Developer.with_scope(:find => { :conditions => "salary = 9000" }) do
+      assert_equal developers(:poor_jamis), Developer.find(:first, :conditions => "name = 'Jamis'")
+    end
+  end
+  
+  def test_scoped_find_sanitizes_conditions
+    Developer.with_scope(:find => { :conditions => ['salary = ?', 9000] }) do
+      assert_equal developers(:poor_jamis), Developer.find(:first)
+    end  
+  end
+  
+  def test_scoped_find_combines_and_sanitizes_conditions
+    Developer.with_scope(:find => { :conditions => ['salary = ?', 9000] }) do
+      assert_equal developers(:poor_jamis), Developer.find(:first, :conditions => ['name = ?', 'Jamis'])
+    end  
+  end
+  
   def test_scoped_find_all
     Developer.with_scope(:find => { :conditions => "name = 'David'" }) do
-      assert_equal [Developer.find(1)], Developer.find(:all)
+      assert_equal [developers(:david)], Developer.find(:all)
     end      
   end
   
@@ -42,11 +61,28 @@ class MethodScopingTest < Test::Unit::TestCase
     end        
   end
 
+  def test_scoped_find_include
+    # with the include, will retrieve only developers for the given project
+    scoped_developers = Developer.with_scope(:find => { :include => :projects }) do
+      Developer.find(:all, :conditions => 'projects.id = 2')
+    end
+    assert scoped_developers.include?(developers(:david))
+    assert !scoped_developers.include?(developers(:jamis))
+    assert_equal 1, scoped_developers.size
+  end
+  
+  def test_scoped_count_include
+    # with the include, will retrieve only developers for the given project
+    Developer.with_scope(:find => { :include => :projects }) do
+      assert_equal 1, Developer.count('projects.id = 2')
+    end
+  end
+
   def test_scoped_create
     new_comment = nil
 
     VerySpecialComment.with_scope(:create => { :post_id => 1 }) do
-      assert_equal({ :post_id => 1 }, Thread.current[:scoped_methods][VerySpecialComment][:create])
+      assert_equal({ :post_id => 1 }, VerySpecialComment.send(:current_scoped_methods)[:create])
       new_comment = VerySpecialComment.create :body => "Wonderful world"
     end
 
@@ -69,11 +105,210 @@ class MethodScopingTest < Test::Unit::TestCase
     end
   end
 
-  def test_raise_on_nested_scope
-    Developer.with_scope(:find => { :conditions => '1=1' }) do
-      assert_raise(ArgumentError) do
-        Developer.with_scope(:find => { :conditions => '2=2' }) { }
+  def test_scoped_with_duck_typing
+    scoping = Struct.new(:method_scoping).new(:find => { :conditions => ["name = ?", 'David'] })
+    Developer.with_scope(scoping) do
+       assert_equal %w(David), Developer.find(:all).map { |d| d.name }
+    end
+  end
+
+  def test_ensure_that_method_scoping_is_correctly_restored
+    scoped_methods = Developer.instance_eval('current_scoped_methods')
+
+    begin
+      Developer.with_scope(:find => { :conditions => "name = 'Jamis'" }) do
+        raise "an exception"
+      end
+    rescue
+    end
+    assert_equal scoped_methods, Developer.instance_eval('current_scoped_methods')
+  end
+end
+
+class NestedScopingTest < Test::Unit::TestCase
+  fixtures :developers, :projects, :comments, :posts
+
+  def test_merge_options
+    Developer.with_scope(:find => { :conditions => 'salary = 80000' }) do
+      Developer.with_scope(:find => { :limit => 10 }) do
+        merged_option = Developer.instance_eval('current_scoped_methods')[:find]
+        assert_equal({ :conditions => 'salary = 80000', :limit => 10 }, merged_option)
+      end
+    end
+  end
+
+  def test_replace_options
+    Developer.with_scope(:find => { :conditions => "name = 'David'" }) do
+      Developer.with_exclusive_scope(:find => { :conditions => "name = 'Jamis'" }) do
+        assert_equal({:find => { :conditions => "name = 'Jamis'" }}, Developer.instance_eval('current_scoped_methods'))
+        assert_equal({:find => { :conditions => "name = 'Jamis'" }}, Developer.send(:scoped_methods)[-1])
+      end
+    end
+  end
+
+  def test_append_conditions
+    Developer.with_scope(:find => { :conditions => "name = 'David'" }) do
+      Developer.with_scope(:find => { :conditions => 'salary = 80000' }) do
+        appended_condition = Developer.instance_eval('current_scoped_methods')[:find][:conditions]
+        assert_equal("( name = 'David' ) AND ( salary = 80000 )", appended_condition)
+        assert_equal(1, Developer.count)
+      end
+      Developer.with_scope(:find => { :conditions => "name = 'Maiha'" }) do
+        assert_equal(0, Developer.count)
+      end
+    end
+  end
+
+  def test_merge_and_append_options
+    Developer.with_scope(:find => { :conditions => 'salary = 80000', :limit => 10 }) do
+      Developer.with_scope(:find => { :conditions => "name = 'David'" }) do
+        merged_option = Developer.instance_eval('current_scoped_methods')[:find]
+        assert_equal({ :conditions => "( salary = 80000 ) AND ( name = 'David' )", :limit => 10 }, merged_option)
+      end
+    end
+  end
+
+  def test_nested_scoped_find
+    Developer.with_scope(:find => { :conditions => "name = 'Jamis'" }) do
+      Developer.with_exclusive_scope(:find => { :conditions => "name = 'David'" }) do
+        assert_nothing_raised { Developer.find(1) }
+        assert_equal('David', Developer.find(:first).name)
+      end
+      assert_equal('Jamis', Developer.find(:first).name)
+    end
+  end
+
+  def test_nested_scoped_find_include
+    Developer.with_scope(:find => { :include => :projects }) do
+      Developer.with_scope(:find => { :conditions => "projects.id = 2" }) do
+        assert_nothing_raised { Developer.find(1) }
+        assert_equal('David', Developer.find(:first).name)
+      end
+    end  
+  end
+
+  def test_nested_scoped_find_merged_include
+    # :include's remain unique and don't "double up" when merging
+    Developer.with_scope(:find => { :include => :projects, :conditions => "projects.id = 2" }) do
+      Developer.with_scope(:find => { :include => :projects }) do
+        assert_equal 1, Developer.instance_eval('current_scoped_methods')[:find][:include].length
+        assert_equal('David', Developer.find(:first).name)
+      end
+    end  
+    
+    # the nested scope doesn't remove the first :include
+    Developer.with_scope(:find => { :include => :projects, :conditions => "projects.id = 2" }) do
+      Developer.with_scope(:find => { :include => [] }) do
+        assert_equal 1, Developer.instance_eval('current_scoped_methods')[:find][:include].length
+        assert_equal('David', Developer.find(:first).name)
+      end
+    end  
+    
+    # mixing array and symbol include's will merge correctly
+    Developer.with_scope(:find => { :include => [:projects], :conditions => "projects.id = 2" }) do
+      Developer.with_scope(:find => { :include => :projects }) do
+        assert_equal 1, Developer.instance_eval('current_scoped_methods')[:find][:include].length
+        assert_equal('David', Developer.find(:first).name)
+      end
+    end  
+  end
+  
+  def test_nested_scoped_find_replace_include
+    Developer.with_scope(:find => { :include => :projects }) do
+      Developer.with_exclusive_scope(:find => { :include => [] }) do
+        assert_equal 0, Developer.instance_eval('current_scoped_methods')[:find][:include].length
+      end
+    end  
+  end
+
+  def test_three_level_nested_exclusive_scoped_find
+    Developer.with_scope(:find => { :conditions => "name = 'Jamis'" }) do
+      assert_equal('Jamis', Developer.find(:first).name)
+
+      Developer.with_exclusive_scope(:find => { :conditions => "name = 'David'" }) do
+        assert_equal('David', Developer.find(:first).name)
+
+        Developer.with_exclusive_scope(:find => { :conditions => "name = 'Maiha'" }) do
+          assert_equal(nil, Developer.find(:first))
+        end
+
+        # ensure that scoping is restored
+        assert_equal('David', Developer.find(:first).name)
+      end
+
+      # ensure that scoping is restored
+      assert_equal('Jamis', Developer.find(:first).name)
+    end
+  end
+
+  def test_merged_scoped_find
+    poor_jamis = developers(:poor_jamis)
+    Developer.with_scope(:find => { :conditions => "salary < 100000" }) do
+      Developer.with_scope(:find => { :offset => 1 }) do
+        assert_equal(poor_jamis, Developer.find(:first, :order => 'id asc'))
+      end
+    end
+  end
+
+  def test_merged_scoped_find_sanitizes_conditions
+    Developer.with_scope(:find => { :conditions => ["name = ?", 'David'] }) do
+      Developer.with_scope(:find => { :conditions => ['salary = ?', 9000] }) do
+        assert_raise(ActiveRecord::RecordNotFound) { developers(:poor_jamis) }
+      end
+    end
+  end
+
+  def test_nested_scoped_find_combines_and_sanitizes_conditions
+    Developer.with_scope(:find => { :conditions => ["name = ?", 'David'] }) do
+      Developer.with_exclusive_scope(:find => { :conditions => ['salary = ?', 9000] }) do
+        assert_equal developers(:poor_jamis), Developer.find(:first)
+        assert_equal developers(:poor_jamis), Developer.find(:first, :conditions => ['name = ?', 'Jamis'])
+      end
+    end
+  end
+
+  def test_merged_scoped_find_combines_and_sanitizes_conditions
+    Developer.with_scope(:find => { :conditions => ["name = ?", 'David'] }) do
+      Developer.with_scope(:find => { :conditions => ['salary > ?', 9000] }) do
+        assert_equal %w(David), Developer.find(:all).map { |d| d.name }
+      end
+    end
+  end
+
+  def test_immutable_nested_scope
+    options1 = { :conditions => "name = 'Jamis'" }
+    options2 = { :conditions => "name = 'David'" }
+    Developer.with_scope(:find => options1) do
+      Developer.with_exclusive_scope(:find => options2) do
+        assert_equal %w(David), Developer.find(:all).map { |d| d.name }
+        options1[:conditions] = options2[:conditions] = nil
+        assert_equal %w(David), Developer.find(:all).map { |d| d.name }
+      end
+    end
+  end
+
+  def test_immutable_merged_scope
+    options1 = { :conditions => "name = 'Jamis'" }
+    options2 = { :conditions => "salary > 10000" }
+    Developer.with_scope(:find => options1) do
+      Developer.with_scope(:find => options2) do
+        assert_equal %w(Jamis), Developer.find(:all).map { |d| d.name }
+        options1[:conditions] = options2[:conditions] = nil
+        assert_equal %w(Jamis), Developer.find(:all).map { |d| d.name }
+      end
+    end
+  end
+
+  def test_ensure_that_method_scoping_is_correctly_restored
+    Developer.with_scope(:find => { :conditions => "name = 'David'" }) do
+      scoped_methods = Developer.instance_eval('current_scoped_methods')
+      begin
+        Developer.with_scope(:find => { :conditions => "name = 'Maiha'" }) do
+          raise "an exception"
+        end
+      rescue
       end
+      assert_equal scoped_methods, Developer.instance_eval('current_scoped_methods')
     end
   end
 end
@@ -100,9 +335,9 @@ class HasManyScopingTest< Test::Unit::TestCase
     assert_equal 2, @welcome.comments.find_all_by_type('Comment').size
   end
 
-  def test_raise_on_nested_scope
+  def test_nested_scope
     Comment.with_scope(:find => { :conditions => '1=1' }) do
-      assert_raise(ArgumentError) { @welcome.comments.what_are_you }
+      assert_equal 'a comment...', @welcome.comments.what_are_you
     end
   end
 end
@@ -121,14 +356,14 @@ class HasAndBelongsToManyScopingTest< Test::Unit::TestCase
   end
 
   def test_forwarding_to_dynamic_finders
-    assert_equal 1, Category.find_all_by_type('SpecialCategory').size
+    assert_equal 4, Category.find_all_by_type('SpecialCategory').size
     assert_equal 0, @welcome.categories.find_all_by_type('SpecialCategory').size
     assert_equal 2, @welcome.categories.find_all_by_type('Category').size
   end
 
-  def test_raise_on_nested_scope
+  def test_nested_scope
     Category.with_scope(:find => { :conditions => '1=1' }) do
-      assert_raise(ArgumentError) { @welcome.categories.what_are_you }
+      assert_equal 'a comment...', @welcome.comments.what_are_you
     end
   end
 end