sequel 4.22.0 → 4.23.0

data/spec/extensions/xml_serializer_spec.rb

@@ -34,8 +34,8 @@ describe "Sequel::Plugins::XmlSerializer" do
   end
 
   it "should round trip successfully" do
-    Artist.from_xml(@artist.to_xml).should == @artist
-    Album.from_xml(@album.to_xml).should == @album
+    Artist.from_xml(@artist.to_xml).must_equal @artist
+    Album.from_xml(@album.to_xml).must_equal @album
   end
 
   it "should round trip successfully for namespaced models" do
@@ -48,160 +48,160 @@ describe "Sequel::Plugins::XmlSerializer" do
       end 
     end
     artist = XmlSerializerTest::Artist.load(:id=>2, :name=>'YJM')
-    XmlSerializerTest::Artist.from_xml(artist.to_xml).should == artist
+    XmlSerializerTest::Artist.from_xml(artist.to_xml).must_equal artist
   end
 
   it "should round trip successfully with empty strings" do
     artist = Artist.load(:id=>2, :name=>'')
-    Artist.from_xml(artist.to_xml).should == artist
+    Artist.from_xml(artist.to_xml).must_equal artist
   end
 
   it "should round trip successfully with nil values" do
     artist = Artist.load(:id=>2, :name=>nil)
-    Artist.from_xml(artist.to_xml).should == artist
+    Artist.from_xml(artist.to_xml).must_equal artist
   end
 
   it "should handle the :only option" do
-    Artist.from_xml(@artist.to_xml(:only=>:name)).should == Artist.load(:name=>@artist.name)
-    Album.from_xml(@album.to_xml(:only=>[:id, :name])).should == Album.load(:id=>@album.id, :name=>@album.name)
+    Artist.from_xml(@artist.to_xml(:only=>:name)).must_equal Artist.load(:name=>@artist.name)
+    Album.from_xml(@album.to_xml(:only=>[:id, :name])).must_equal Album.load(:id=>@album.id, :name=>@album.name)
   end
 
   it "should handle the :except option" do
-    Artist.from_xml(@artist.to_xml(:except=>:id)).should == Artist.load(:name=>@artist.name)
-    Album.from_xml(@album.to_xml(:except=>[:id, :artist_id])).should == Album.load(:name=>@album.name)
+    Artist.from_xml(@artist.to_xml(:except=>:id)).must_equal Artist.load(:name=>@artist.name)
+    Album.from_xml(@album.to_xml(:except=>[:id, :artist_id])).must_equal Album.load(:name=>@album.name)
   end
 
   it "should handle the :include option for associations" do
-    Artist.from_xml(@artist.to_xml(:include=>:albums), :associations=>:albums).albums.should == [@album]
-    Album.from_xml(@album.to_xml(:include=>:artist), :associations=>:artist).artist.should == @artist
+    Artist.from_xml(@artist.to_xml(:include=>:albums), :associations=>:albums).albums.must_equal [@album]
+    Album.from_xml(@album.to_xml(:include=>:artist), :associations=>:artist).artist.must_equal @artist
   end
 
   it "should handle the :include option for arbitrary attributes" do
-    Album.from_xml(@album.to_xml(:include=>:blah)).blah.should == @album.blah
+    Album.from_xml(@album.to_xml(:include=>:blah)).blah.must_equal @album.blah
   end
 
   it "should handle multiple inclusions using an array for the :include option" do
     a = Album.from_xml(@album.to_xml(:include=>[:blah, :artist]), :associations=>:artist)
-    a.blah.should == @album.blah
-    a.artist.should == @artist
+    a.blah.must_equal @album.blah
+    a.artist.must_equal @artist
   end
 
   it "should handle cascading using a hash for the :include option" do
-    Artist.from_xml(@artist.to_xml(:include=>{:albums=>{:include=>:artist}}), :associations=>{:albums=>{:associations=>:artist}}).albums.map{|a| a.artist}.should == [@artist]
-    Album.from_xml(@album.to_xml(:include=>{:artist=>{:include=>:albums}}), :associations=>{:artist=>{:associations=>:albums}}).artist.albums.should == [@album]
+    Artist.from_xml(@artist.to_xml(:include=>{:albums=>{:include=>:artist}}), :associations=>{:albums=>{:associations=>:artist}}).albums.map{|a| a.artist}.must_equal [@artist]
+    Album.from_xml(@album.to_xml(:include=>{:artist=>{:include=>:albums}}), :associations=>{:artist=>{:associations=>:albums}}).artist.albums.must_equal [@album]
 
-    Artist.from_xml(@artist.to_xml(:include=>{:albums=>{:only=>:name}}), :associations=>{:albums=>{:fields=>%w'name'}}).albums.should == [Album.load(:name=>@album.name)]
-    Album.from_xml(@album.to_xml(:include=>{:artist=>{:except=>:name}}), :associations=>:artist).artist.should == Artist.load(:id=>@artist.id)
+    Artist.from_xml(@artist.to_xml(:include=>{:albums=>{:only=>:name}}), :associations=>{:albums=>{:fields=>%w'name'}}).albums.must_equal [Album.load(:name=>@album.name)]
+    Album.from_xml(@album.to_xml(:include=>{:artist=>{:except=>:name}}), :associations=>:artist).artist.must_equal Artist.load(:id=>@artist.id)
 
-    Artist.from_xml(@artist.to_xml(:include=>{:albums=>{:include=>{:artist=>{:include=>:albums}}}}), :associations=>{:albums=>{:associations=>{:artist=>{:associations=>:albums}}}}).albums.map{|a| a.artist.albums}.should == [[@album]]
-    Album.from_xml(@album.to_xml(:include=>{:artist=>{:include=>{:albums=>{:only=>:name}}}}), :associations=>{:artist=>{:associations=>{:albums=>{:fields=>%w'name'}}}}).artist.albums.should == [Album.load(:name=>@album.name)]
+    Artist.from_xml(@artist.to_xml(:include=>{:albums=>{:include=>{:artist=>{:include=>:albums}}}}), :associations=>{:albums=>{:associations=>{:artist=>{:associations=>:albums}}}}).albums.map{|a| a.artist.albums}.must_equal [[@album]]
+    Album.from_xml(@album.to_xml(:include=>{:artist=>{:include=>{:albums=>{:only=>:name}}}}), :associations=>{:artist=>{:associations=>{:albums=>{:fields=>%w'name'}}}}).artist.albums.must_equal [Album.load(:name=>@album.name)]
   end
 
   it "should handle the :include option cascading with an empty hash" do
-    Album.from_xml(@album.to_xml(:include=>{:artist=>{}}), :associations=>:artist).artist.should == @artist
-    Album.from_xml(@album.to_xml(:include=>{:blah=>{}})).blah.should == @album.blah
+    Album.from_xml(@album.to_xml(:include=>{:artist=>{}}), :associations=>:artist).artist.must_equal @artist
+    Album.from_xml(@album.to_xml(:include=>{:blah=>{}})).blah.must_equal @album.blah
   end
 
   it "should support #from_xml to set column values" do
     @artist.from_xml('<album><name>AS</name></album>')
-    @artist.name.should == 'AS'
-    @artist.id.should == 2
+    @artist.name.must_equal 'AS'
+    @artist.id.must_equal 2
   end
 
   it "should support a :name_proc option when serializing and deserializing" do
-    Album.from_xml(@album.to_xml(:name_proc=>proc{|s| s.reverse}), :name_proc=>proc{|s| s.reverse}).should == @album
+    Album.from_xml(@album.to_xml(:name_proc=>proc{|s| s.reverse}), :name_proc=>proc{|s| s.reverse}).must_equal @album
   end
 
   it "should support a :camelize option when serializing and :underscore option when deserializing" do
-    Album.from_xml(@album.to_xml(:camelize=>true), :underscore=>true).should == @album
+    Album.from_xml(@album.to_xml(:camelize=>true), :underscore=>true).must_equal @album
   end
 
   it "should support a :camelize option when serializing and :underscore option when deserializing" do
-    Album.from_xml(@album.to_xml(:dasherize=>true), :underscore=>true).should == @album
+    Album.from_xml(@album.to_xml(:dasherize=>true), :underscore=>true).must_equal @album
   end
 
   it "should support an :encoding option when serializing" do
     ["<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><id>2</id><name>YJM</name></artist>",
-     "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><name>YJM</name><id>2</id></artist>"].should include(@artist.to_xml(:encoding=>'UTF-8').gsub(/\n */m, ''))
+     "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><name>YJM</name><id>2</id></artist>"].must_include(@artist.to_xml(:encoding=>'UTF-8').gsub(/\n */m, ''))
   end
 
   it "should support a :builder_opts option when serializing" do
     ["<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><id>2</id><name>YJM</name></artist>",
-     "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><name>YJM</name><id>2</id></artist>"].should include(@artist.to_xml(:builder_opts=>{:encoding=>'UTF-8'}).gsub(/\n */m, ''))
+     "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><name>YJM</name><id>2</id></artist>"].must_include(@artist.to_xml(:builder_opts=>{:encoding=>'UTF-8'}).gsub(/\n */m, ''))
   end
 
   it "should support an :types option when serializing" do
     ["<?xml version=\"1.0\"?><artist><id type=\"integer\">2</id><name type=\"string\">YJM</name></artist>",
-     "<?xml version=\"1.0\"?><artist><name type=\"string\">YJM</name><id type=\"integer\">2</id></artist>"].should include(@artist.to_xml(:types=>true).gsub(/\n */m, ''))
+     "<?xml version=\"1.0\"?><artist><name type=\"string\">YJM</name><id type=\"integer\">2</id></artist>"].must_include(@artist.to_xml(:types=>true).gsub(/\n */m, ''))
   end
 
   it "should support an :root_name option when serializing" do
     ["<?xml version=\"1.0\"?><ar><id>2</id><name>YJM</name></ar>",
-     "<?xml version=\"1.0\"?><ar><name>YJM</name><id>2</id></ar>"].should include(@artist.to_xml(:root_name=>'ar').gsub(/\n */m, ''))
+     "<?xml version=\"1.0\"?><ar><name>YJM</name><id>2</id></ar>"].must_include(@artist.to_xml(:root_name=>'ar').gsub(/\n */m, ''))
   end
 
   it "should support an :array_root_name option when serializing arrays" do
     artist = @artist
     Artist.dataset.meta_def(:all){[artist]}
     ["<?xml version=\"1.0\"?><ars><ar><id>2</id><name>YJM</name></ar></ars>",
-     "<?xml version=\"1.0\"?><ars><ar><name>YJM</name><id>2</id></ar></ars>"].should include(Artist.to_xml(:array_root_name=>'ars', :root_name=>'ar').gsub(/\n */m, ''))
+     "<?xml version=\"1.0\"?><ars><ar><name>YJM</name><id>2</id></ar></ars>"].must_include(Artist.to_xml(:array_root_name=>'ars', :root_name=>'ar').gsub(/\n */m, ''))
   end
 
   it "should raise an exception for xml tags that aren't associations, columns, or setter methods" do
     Album.send(:undef_method, :blah=)
-    proc{Album.from_xml(@album.to_xml(:include=>:blah))}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{Album.from_xml(@album.to_xml(:include=>:blah))}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
   it "should support a to_xml class and dataset method" do
     album = @album
     Album.dataset.meta_def(:all){[album]}
-    Album.array_from_xml(Album.to_xml).should == [@album]
-    Album.array_from_xml(Album.to_xml(:include=>:artist), :associations=>:artist).map{|x| x.artist}.should == [@artist]
-    Album.array_from_xml(Album.dataset.to_xml(:only=>:name)).should == [Album.load(:name=>@album.name)]
+    Album.array_from_xml(Album.to_xml).must_equal [@album]
+    Album.array_from_xml(Album.to_xml(:include=>:artist), :associations=>:artist).map{|x| x.artist}.must_equal [@artist]
+    Album.array_from_xml(Album.dataset.to_xml(:only=>:name)).must_equal [Album.load(:name=>@album.name)]
   end
 
   it "should have to_xml dataset method respect an :array option" do
     a = Album.load(:id=>1, :name=>'RF', :artist_id=>3)
-    Album.array_from_xml(Album.to_xml(:array=>[a])).should == [a]
+    Album.array_from_xml(Album.to_xml(:array=>[a])).must_equal [a]
 
     a.associations[:artist] = artist = Artist.load(:id=>3, :name=>'YJM')
-    Album.array_from_xml(Album.to_xml(:array=>[a], :include=>:artist), :associations=>:artist).first.artist.should == artist
+    Album.array_from_xml(Album.to_xml(:array=>[a], :include=>:artist), :associations=>:artist).first.artist.must_equal artist
 
     artist.associations[:albums] = [a]
     x = Artist.array_from_xml(Artist.to_xml(:array=>[artist], :include=>:albums), :associations=>[:albums])
-    x.should == [artist]
-    x.first.albums.should == [a]
+    x.must_equal [artist]
+    x.first.albums.must_equal [a]
   end
 
   it "should raise an error if the dataset does not have a row_proc" do
-    proc{Album.dataset.naked.to_xml}.should raise_error(Sequel::Error)
+    proc{Album.dataset.naked.to_xml}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if using parsing empty xml" do
-    proc{Artist.from_xml("<?xml version=\"1.0\"?>\n")}.should raise_error(Sequel::Error)
-    proc{Artist.array_from_xml("<?xml version=\"1.0\"?>\n")}.should raise_error(Sequel::Error)
+    proc{Artist.from_xml("<?xml version=\"1.0\"?>\n")}.must_raise(Sequel::Error)
+    proc{Artist.array_from_xml("<?xml version=\"1.0\"?>\n")}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if attempting to set a restricted column and :all_columns is not used" do
     Artist.restrict_primary_key
-    proc{Artist.from_xml(@artist.to_xml)}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{Artist.from_xml(@artist.to_xml)}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
   it "should raise an error if an unsupported association is passed in the :associations option" do
     Artist.association_reflections.delete(:albums)
-    proc{Artist.from_xml(@artist.to_xml(:include=>:albums), :associations=>:albums)}.should raise_error(Sequel::Error)
+    proc{Artist.from_xml(@artist.to_xml(:include=>:albums), :associations=>:albums)}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if using from_xml and XML represents an array" do
-    proc{Artist.from_xml(Artist.to_xml(:array=>[@artist]))}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{Artist.from_xml(Artist.to_xml(:array=>[@artist]))}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
   it "should raise an error if using array_from_xml and XML does not represent an array" do
-    proc{Artist.array_from_xml(@artist.to_xml)}.should raise_error(Sequel::Error)
+    proc{Artist.array_from_xml(@artist.to_xml)}.must_raise(Sequel::Error)
   end
 
   it "should raise an error if using an unsupported :associations option" do
-    proc{Artist.from_xml(@artist.to_xml, :associations=>'')}.should raise_error(Sequel::Error)
+    proc{Artist.from_xml(@artist.to_xml, :associations=>'')}.must_raise(Sequel::Error)
   end
 end
 end

data/spec/guards_helper.rb

@@ -0,0 +1,55 @@
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/hooks/default'
+require 'minitest/shared_description'
+
+def Sequel.guarded?(*checked)
+  unless ENV['SEQUEL_NO_PENDING']
+    checked.each do |c|
+      case c
+      when DB.database_type
+        return c
+      when Array
+        case c.length
+        when 1
+          return c if c.first == DB.adapter_scheme
+        when 2
+          if c.first.is_a?(Proc)
+            return c if c.last == DB.database_type && c.first.call(DB)
+          elsif c.last.is_a?(Proc)
+            return c if c.first == DB.adapter_scheme && c.last.call(DB)
+          else
+            return c if c.first == DB.adapter_scheme && c.last == DB.database_type
+          end
+        when 3
+          return c if c[0] == DB.adapter_scheme && c[1] == DB.database_type && c[2].call(DB)
+        end          
+      end
+    end
+  end
+  false
+end
+
+module Minitest::Spec::DSL
+  def cspecify(message, *checked, &block)
+    if pending = Sequel.guarded?(*checked)
+      it(message) do
+        skip "Not yet working on #{Array(pending).map{|x| x.is_a?(Proc) ? :proc : x}.join(', ')}"
+      end
+    else
+      it(message, &block)
+    end
+  end
+end
+
+class Minitest::HooksSpec
+  def log
+    begin
+      DB.loggers << Logger.new(STDOUT)
+      yield
+    ensure
+     DB.loggers.pop
+    end
+  end
+end
+

data/spec/integration/associations_test.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
-shared_examples_for "one_to_one eager limit strategies" do
-  specify "eager loading one_to_one associations should work correctly" do
+OneToOneEagerLimitStrategies = shared_description do
+  it "eager loading one_to_one associations should work correctly" do
     Artist.one_to_one :first_album, {:clone=>:first_album}.merge(@els) if @els
     Artist.one_to_one  :last_album, {:clone=>:last_album}.merge(@els) if @els
     Artist.one_to_one  :second_album, {:clone=>:second_album}.merge(@els) if @els && @els[:eager_limit_strategy] != :distinct_on
@@ -10,29 +10,29 @@ shared_examples_for "one_to_one eager limit strategies" do
     ar = @pr.call[1]
     
     a = Artist.eager(:first_album, :last_album, :second_album).order(:name).all
-    a.should == [@artist, ar]
-    a.first.first_album.should == @album
-    a.first.last_album.should == diff_album
-    a.first.second_album.should == diff_album
-    a.last.first_album.should == nil
-    a.last.last_album.should == nil
-    a.last.second_album.should == nil
+    a.must_equal [@artist, ar]
+    a.first.first_album.must_equal @album
+    a.first.last_album.must_equal diff_album
+    a.first.second_album.must_equal diff_album
+    a.last.first_album.must_equal nil
+    a.last.last_album.must_equal nil
+    a.last.second_album.must_equal nil
 
     # Check that no extra columns got added by the eager loading
-    a.first.first_album.values.should == @album.values
-    a.first.last_album.values.should == diff_album.values
-    a.first.second_album.values.should == diff_album.values
+    a.first.first_album.values.must_equal @album.values
+    a.first.last_album.values.must_equal diff_album.values
+    a.first.second_album.values.must_equal diff_album.values
 
     same_album = @same_album.call
     a = Artist.eager(:first_album).order(:name).all
-    a.should == [@artist, ar]
-    [@album, same_album].should include(a.first.first_album)
-    a.last.first_album.should == nil
+    a.must_equal [@artist, ar]
+    [@album, same_album].must_include(a.first.first_album)
+    a.last.first_album.must_equal nil
   end
 end
 
-shared_examples_for "one_to_one eager_graph limit strategies" do
-  specify "eager graphing one_to_one associations should work correctly" do
+OneToOneEagerGraphLimitStrategies = shared_description do
+  it "eager graphing one_to_one associations should work correctly" do
     @album.update(:artist => @artist)
     diff_album = @diff_album.call
     ar = @pr.call[1]
@@ -40,37 +40,37 @@ shared_examples_for "one_to_one eager_graph limit strategies" do
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     a = ds.eager_graph_with_options(:first_album, limit_strategy).all
-    a.should == [@artist, ar]
-    a.first.first_album.should == @album
-    a.last.first_album.should == nil
-    a.first.first_album.values.should == @album.values
+    a.must_equal [@artist, ar]
+    a.first.first_album.must_equal @album
+    a.last.first_album.must_equal nil
+    a.first.first_album.values.must_equal @album.values
 
     a = ds.eager_graph_with_options(:last_album, limit_strategy).all
     a = ds.eager_graph(:last_album).all
-    a.should == [@artist, ar]
-    a.first.last_album.should == diff_album
-    a.last.last_album.should == nil
-    a.first.last_album.values.should == diff_album.values
+    a.must_equal [@artist, ar]
+    a.first.last_album.must_equal diff_album
+    a.last.last_album.must_equal nil
+    a.first.last_album.values.must_equal diff_album.values
 
     if @els[:eager_limit_strategy] != :distinct_on && (@els[:eager_limit_strategy] != :correlated_subquery || Album.dataset.supports_offsets_in_correlated_subqueries?) 
       a = ds.eager_graph_with_options(:second_album, limit_strategy).all
       a = ds.eager_graph(:second_album).all
-      a.should == [@artist, ar]
-      a.first.second_album.should == diff_album
-      a.last.second_album.should == nil
-      a.first.second_album.values.should == diff_album.values
+      a.must_equal [@artist, ar]
+      a.first.second_album.must_equal diff_album
+      a.last.second_album.must_equal nil
+      a.first.second_album.values.must_equal diff_album.values
     end
 
     same_album = @same_album.call
     a = ds.eager_graph_with_options(:first_album, limit_strategy).all
-    a.should == [@artist, ar]
-    [@album, same_album].should include(a.first.first_album)
-    a.last.first_album.should == nil
+    a.must_equal [@artist, ar]
+    [@album, same_album].must_include(a.first.first_album)
+    a.last.first_album.must_equal nil
   end
 end
 
-shared_examples_for "one_to_many eager limit strategies" do
-  specify "should correctly handle limits and offsets when eager loading one_to_many associations" do
+OneToManyEagerLimitStrategies = shared_description do
+  it "should correctly handle limits and offsets when eager loading one_to_many associations" do
     Artist.one_to_many :first_two_albums, {:clone=>:first_two_albums}.merge(@els) if @els
     Artist.one_to_many :second_two_albums, {:clone=>:second_two_albums}.merge(@els) if @els
     Artist.one_to_many :not_first_albums, {:clone=>:not_first_albums}.merge(@els) if @els
@@ -81,26 +81,26 @@ shared_examples_for "one_to_many eager limit strategies" do
     ar = @pr.call[1]
     
     ars = Artist.eager(:first_two_albums, :second_two_albums, :not_first_albums, :last_two_albums).order(:name).all
-    ars.should == [@artist, ar]
-    ars.first.first_two_albums.should == [@album, middle_album]
-    ars.first.second_two_albums.should == [middle_album, diff_album]
-    ars.first.not_first_albums.should == [middle_album, diff_album]
-    ars.first.last_two_albums.should == [diff_album, middle_album]
-    ars.last.first_two_albums.should == []
-    ars.last.second_two_albums.should == []
-    ars.last.not_first_albums.should == []
-    ars.last.last_two_albums.should == []
+    ars.must_equal [@artist, ar]
+    ars.first.first_two_albums.must_equal [@album, middle_album]
+    ars.first.second_two_albums.must_equal [middle_album, diff_album]
+    ars.first.not_first_albums.must_equal [middle_album, diff_album]
+    ars.first.last_two_albums.must_equal [diff_album, middle_album]
+    ars.last.first_two_albums.must_equal []
+    ars.last.second_two_albums.must_equal []
+    ars.last.not_first_albums.must_equal []
+    ars.last.last_two_albums.must_equal []
     
     # Check that no extra columns got added by the eager loading
-    ars.first.first_two_albums.map{|x| x.values}.should == [@album, middle_album].map{|x| x.values}
-    ars.first.second_two_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
-    ars.first.not_first_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
-    ars.first.last_two_albums.map{|x| x.values}.should == [diff_album, middle_album].map{|x| x.values}
+    ars.first.first_two_albums.map{|x| x.values}.must_equal [@album, middle_album].map{|x| x.values}
+    ars.first.second_two_albums.map{|x| x.values}.must_equal [middle_album, diff_album].map{|x| x.values}
+    ars.first.not_first_albums.map{|x| x.values}.must_equal [middle_album, diff_album].map{|x| x.values}
+    ars.first.last_two_albums.map{|x| x.values}.must_equal [diff_album, middle_album].map{|x| x.values}
   end
 end
 
-shared_examples_for "one_to_many eager_graph limit strategies" do
-  specify "should correctly handle limits and offsets when eager graphing one_to_many associations" do
+OneToManyEagerGraphLimitStrategies = shared_description do
+  it "should correctly handle limits and offsets when eager graphing one_to_many associations" do
     @album.update(:artist => @artist)
     middle_album = @middle_album.call
     diff_album = @diff_album.call
@@ -109,35 +109,35 @@ shared_examples_for "one_to_many eager_graph limit strategies" do
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     ars = ds.eager_graph_with_options(:first_two_albums, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.first_two_albums.should == [@album, middle_album]
-    ars.last.first_two_albums.should == []
-    ars.first.first_two_albums.map{|x| x.values}.should == [@album, middle_album].map{|x| x.values}
+    ars.must_equal [@artist, ar]
+    ars.first.first_two_albums.must_equal [@album, middle_album]
+    ars.last.first_two_albums.must_equal []
+    ars.first.first_two_albums.map{|x| x.values}.must_equal [@album, middle_album].map{|x| x.values}
 
     if @els[:eager_limit_strategy] != :correlated_subquery || Album.dataset.supports_offsets_in_correlated_subqueries?
       ars = ds.eager_graph_with_options(:second_two_albums, limit_strategy).all
-      ars.should == [@artist, ar]
-      ars.first.second_two_albums.should == [middle_album, diff_album]
-      ars.last.second_two_albums.should == []
-      ars.first.second_two_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
+      ars.must_equal [@artist, ar]
+      ars.first.second_two_albums.must_equal [middle_album, diff_album]
+      ars.last.second_two_albums.must_equal []
+      ars.first.second_two_albums.map{|x| x.values}.must_equal [middle_album, diff_album].map{|x| x.values}
 
       ars = ds.eager_graph_with_options(:not_first_albums, limit_strategy).all
-      ars.should == [@artist, ar]
-      ars.first.not_first_albums.should == [middle_album, diff_album]
-      ars.last.not_first_albums.should == []
-      ars.first.not_first_albums.map{|x| x.values}.should == [middle_album, diff_album].map{|x| x.values}
+      ars.must_equal [@artist, ar]
+      ars.first.not_first_albums.must_equal [middle_album, diff_album]
+      ars.last.not_first_albums.must_equal []
+      ars.first.not_first_albums.map{|x| x.values}.must_equal [middle_album, diff_album].map{|x| x.values}
     end
 
     ars = ds.eager_graph_with_options(:last_two_albums, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.last_two_albums.should == [diff_album, middle_album]
-    ars.last.last_two_albums.should == []
-    ars.first.last_two_albums.map{|x| x.values}.should == [diff_album, middle_album].map{|x| x.values}
+    ars.must_equal [@artist, ar]
+    ars.first.last_two_albums.must_equal [diff_album, middle_album]
+    ars.last.last_two_albums.must_equal []
+    ars.first.last_two_albums.map{|x| x.values}.must_equal [diff_album, middle_album].map{|x| x.values}
   end
 end
 
-shared_examples_for "one_through_one eager limit strategies" do
-  specify "should correctly handle offsets when eager loading one_through_one associations" do
+OneThroughOneEagerLimitStrategies = shared_description do
+  it "should correctly handle offsets when eager loading one_through_one associations" do
     Album.one_through_one :first_tag, {:clone=>:first_tag}.merge(@els) if @els
     Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els) if @els && @els[:eager_limit_strategy] != :distinct_on
     Album.one_through_one :last_tag, {:clone=>:last_tag}.merge(@els) if @els
@@ -145,50 +145,50 @@ shared_examples_for "one_through_one eager limit strategies" do
     al = @pr.call.first
     
     als = Album.eager(:first_tag, :second_tag, :last_tag).order(:name).all
-    als.should == [@album, al]
-    als.first.first_tag.should == @tag
-    als.first.second_tag.should == tu
-    als.first.last_tag.should == tv
-    als.last.first_tag.should == nil
-    als.last.second_tag.should == nil
-    als.last.last_tag.should == nil
+    als.must_equal [@album, al]
+    als.first.first_tag.must_equal @tag
+    als.first.second_tag.must_equal tu
+    als.first.last_tag.must_equal tv
+    als.last.first_tag.must_equal nil
+    als.last.second_tag.must_equal nil
+    als.last.last_tag.must_equal nil
     
     # Check that no extra columns got added by the eager loading
-    als.first.first_tag.values.should == @tag.values
-    als.first.second_tag.values.should == tu.values
-    als.first.last_tag.values.should == tv.values
+    als.first.first_tag.values.must_equal @tag.values
+    als.first.second_tag.values.must_equal tu.values
+    als.first.last_tag.values.must_equal tv.values
   end
 end
 
-shared_examples_for "one_through_one eager_graph limit strategies" do
-  specify "should correctly handle offsets when eager graphing one_through_one associations" do
+OneThroughOneEagerGraphLimitStrategies = shared_description do
+  it "should correctly handle offsets when eager graphing one_through_one associations" do
     tu, tv = @other_tags.call
     al = @pr.call.first
     ds = Album.order(:albums__name)
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     als = ds.eager_graph_with_options(:first_tag, limit_strategy).all
-    als.should == [@album, al]
-    als.first.first_tag.should == @tag
-    als.last.first_tag.should == nil
-    als.first.first_tag.values.should == @tag.values
+    als.must_equal [@album, al]
+    als.first.first_tag.must_equal @tag
+    als.last.first_tag.must_equal nil
+    als.first.first_tag.values.must_equal @tag.values
 
     als = ds.eager_graph_with_options(:second_tag, @els[:eager_limit_strategy] != :distinct_on ? limit_strategy : {}).all
-    als.should == [@album, al]
-    als.first.second_tag.should == tu
-    als.last.second_tag.should == nil
-    als.first.second_tag.values.should == tu.values
+    als.must_equal [@album, al]
+    als.first.second_tag.must_equal tu
+    als.last.second_tag.must_equal nil
+    als.first.second_tag.values.must_equal tu.values
 
     als = ds.eager_graph_with_options(:last_tag, limit_strategy).all
-    als.should == [@album, al]
-    als.first.last_tag.should == tv
-    als.last.last_tag.should == nil
-    als.first.last_tag.values.should == tv.values
+    als.must_equal [@album, al]
+    als.first.last_tag.must_equal tv
+    als.last.last_tag.must_equal nil
+    als.first.last_tag.values.must_equal tv.values
   end
 end
 
-shared_examples_for "many_to_many eager limit strategies" do
-  specify "should correctly handle limits and offsets when eager loading many_to_many associations" do
+ManyToManyEagerLimitStrategies = shared_description do
+  it "should correctly handle limits and offsets when eager loading many_to_many associations" do
     Album.send @many_to_many_method||:many_to_many, :first_two_tags, {:clone=>:first_two_tags}.merge(@els) if @els
     Album.send @many_to_many_method||:many_to_many, :second_two_tags, {:clone=>:second_two_tags}.merge(@els) if @els
     Album.send @many_to_many_method||:many_to_many, :not_first_tags, {:clone=>:not_first_tags}.merge(@els) if @els
@@ -198,25 +198,25 @@ shared_examples_for "many_to_many eager limit strategies" do
     al.add_tag(tu)
     
     als = Album.eager(:first_two_tags, :second_two_tags, :not_first_tags, :last_two_tags).order(:name).all
-    als.should == [@album, al]
-    als.first.first_two_tags.should == [@tag, tu]
-    als.first.second_two_tags.should == [tu, tv]
-    als.first.not_first_tags.should == [tu, tv]
-    als.first.last_two_tags.should == [tv, tu]
-    als.last.first_two_tags.should == [tu]
-    als.last.second_two_tags.should == []
-    als.last.last_two_tags.should == [tu]
+    als.must_equal [@album, al]
+    als.first.first_two_tags.must_equal [@tag, tu]
+    als.first.second_two_tags.must_equal [tu, tv]
+    als.first.not_first_tags.must_equal [tu, tv]
+    als.first.last_two_tags.must_equal [tv, tu]
+    als.last.first_two_tags.must_equal [tu]
+    als.last.second_two_tags.must_equal []
+    als.last.last_two_tags.must_equal [tu]
     
     # Check that no extra columns got added by the eager loading
-    als.first.first_two_tags.map{|x| x.values}.should == [@tag, tu].map{|x| x.values}
-    als.first.second_two_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
-    als.first.not_first_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
-    als.first.last_two_tags.map{|x| x.values}.should == [tv, tu].map{|x| x.values}
+    als.first.first_two_tags.map{|x| x.values}.must_equal [@tag, tu].map{|x| x.values}
+    als.first.second_two_tags.map{|x| x.values}.must_equal [tu, tv].map{|x| x.values}
+    als.first.not_first_tags.map{|x| x.values}.must_equal [tu, tv].map{|x| x.values}
+    als.first.last_two_tags.map{|x| x.values}.must_equal [tv, tu].map{|x| x.values}
   end
 end
 
-shared_examples_for "many_to_many eager_graph limit strategies" do
-  specify "should correctly handle limits and offsets when eager loading many_to_many associations" do
+ManyToManyEagerGraphLimitStrategies = shared_description do
+  it "should correctly handle limits and offsets when eager loading many_to_many associations" do
     tu, tv = @other_tags.call
     al = @pr.call.first
     al.add_tag(tu)
@@ -224,33 +224,33 @@ shared_examples_for "many_to_many eager_graph limit strategies" do
     limit_strategy = {:limit_strategy=>(@els||{})[:eager_limit_strategy]}
     
     als = ds.eager_graph_with_options(:first_two_tags, limit_strategy).all
-    als.should == [@album, al]
-    als.first.first_two_tags.should == [@tag, tu]
-    als.last.first_two_tags.should == [tu]
-    als.first.first_two_tags.map{|x| x.values}.should == [@tag, tu].map{|x| x.values}
+    als.must_equal [@album, al]
+    als.first.first_two_tags.must_equal [@tag, tu]
+    als.last.first_two_tags.must_equal [tu]
+    als.first.first_two_tags.map{|x| x.values}.must_equal [@tag, tu].map{|x| x.values}
 
     als = ds.eager_graph_with_options(:second_two_tags, limit_strategy).all
-    als.should == [@album, al]
-    als.first.second_two_tags.should == [tu, tv]
-    als.last.second_two_tags.should == []
-    als.first.second_two_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
+    als.must_equal [@album, al]
+    als.first.second_two_tags.must_equal [tu, tv]
+    als.last.second_two_tags.must_equal []
+    als.first.second_two_tags.map{|x| x.values}.must_equal [tu, tv].map{|x| x.values}
 
     als = ds.eager_graph_with_options(:not_first_tags, limit_strategy).all
-    als.should == [@album, al]
-    als.first.not_first_tags.should == [tu, tv]
-    als.last.not_first_tags.should == []
-    als.first.not_first_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
+    als.must_equal [@album, al]
+    als.first.not_first_tags.must_equal [tu, tv]
+    als.last.not_first_tags.must_equal []
+    als.first.not_first_tags.map{|x| x.values}.must_equal [tu, tv].map{|x| x.values}
 
     als = ds.eager_graph_with_options(:last_two_tags, limit_strategy).all
-    als.should == [@album, al]
-    als.first.last_two_tags.should == [tv, tu]
-    als.last.last_two_tags.should == [tu]
-    als.first.last_two_tags.map{|x| x.values}.should == [tv, tu].map{|x| x.values}
+    als.must_equal [@album, al]
+    als.first.last_two_tags.must_equal [tv, tu]
+    als.last.last_two_tags.must_equal [tu]
+    als.first.last_two_tags.map{|x| x.values}.must_equal [tv, tu].map{|x| x.values}
   end
 end
 
-shared_examples_for "many_through_many eager limit strategies" do
-  specify "should correctly handle limits and offsets when eager loading many_through_many associations" do
+ManyThroughManyEagerLimitStrategies = shared_description do
+  it "should correctly handle limits and offsets when eager loading many_through_many associations" do
     Artist.many_through_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els) if @els
     Artist.many_through_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els) if @els
     Artist.many_through_many :not_first_tags, {:clone=>:not_first_tags}.merge(@els) if @els
@@ -262,26 +262,26 @@ shared_examples_for "many_through_many eager limit strategies" do
     al.add_tag(tu)
     
     ars = Artist.eager(:first_two_tags, :second_two_tags, :not_first_tags, :last_two_tags).order(:name).all
-    ars.should == [@artist, ar]
-    ars.first.first_two_tags.should == [@tag, tu]
-    ars.first.second_two_tags.should == [tu, tv]
-    ars.first.not_first_tags.should == [tu, tv]
-    ars.first.last_two_tags.should == [tv, tu]
-    ars.last.first_two_tags.should == [tu]
-    ars.last.second_two_tags.should == []
-    ars.last.not_first_tags.should == []
-    ars.last.last_two_tags.should == [tu]
+    ars.must_equal [@artist, ar]
+    ars.first.first_two_tags.must_equal [@tag, tu]
+    ars.first.second_two_tags.must_equal [tu, tv]
+    ars.first.not_first_tags.must_equal [tu, tv]
+    ars.first.last_two_tags.must_equal [tv, tu]
+    ars.last.first_two_tags.must_equal [tu]
+    ars.last.second_two_tags.must_equal []
+    ars.last.not_first_tags.must_equal []
+    ars.last.last_two_tags.must_equal [tu]
     
     # Check that no extra columns got added by the eager loading
-    ars.first.first_two_tags.map{|x| x.values}.should == [@tag, tu].map{|x| x.values}
-    ars.first.second_two_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
-    ars.first.not_first_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
-    ars.first.last_two_tags.map{|x| x.values}.should == [tv, tu].map{|x| x.values}
+    ars.first.first_two_tags.map{|x| x.values}.must_equal [@tag, tu].map{|x| x.values}
+    ars.first.second_two_tags.map{|x| x.values}.must_equal [tu, tv].map{|x| x.values}
+    ars.first.not_first_tags.map{|x| x.values}.must_equal [tu, tv].map{|x| x.values}
+    ars.first.last_two_tags.map{|x| x.values}.must_equal [tv, tu].map{|x| x.values}
   end
 end
 
-shared_examples_for "many_through_many eager_graph limit strategies" do
-  specify "should correctly handle limits and offsets when eager loading many_through_many associations" do
+ManyThroughManyEagerGraphLimitStrategies = shared_description do
+  it "should correctly handle limits and offsets when eager loading many_through_many associations" do
     @album.update(:artist => @artist)
     tu, tv = @other_tags.call
     al, ar, _ = @pr.call
@@ -291,33 +291,33 @@ shared_examples_for "many_through_many eager_graph limit strategies" do
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     ars = ds.eager_graph_with_options(:first_two_tags, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.first_two_tags.should == [@tag, tu]
-    ars.last.first_two_tags.should == [tu]
-    ars.first.first_two_tags.map{|x| x.values}.should == [@tag, tu].map{|x| x.values}
+    ars.must_equal [@artist, ar]
+    ars.first.first_two_tags.must_equal [@tag, tu]
+    ars.last.first_two_tags.must_equal [tu]
+    ars.first.first_two_tags.map{|x| x.values}.must_equal [@tag, tu].map{|x| x.values}
 
     ars = ds.eager_graph_with_options(:second_two_tags, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.second_two_tags.should == [tu, tv]
-    ars.last.second_two_tags.should == []
-    ars.first.second_two_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
+    ars.must_equal [@artist, ar]
+    ars.first.second_two_tags.must_equal [tu, tv]
+    ars.last.second_two_tags.must_equal []
+    ars.first.second_two_tags.map{|x| x.values}.must_equal [tu, tv].map{|x| x.values}
 
     ars = ds.eager_graph_with_options(:not_first_tags, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.not_first_tags.should == [tu, tv]
-    ars.last.not_first_tags.should == []
-    ars.first.not_first_tags.map{|x| x.values}.should == [tu, tv].map{|x| x.values}
+    ars.must_equal [@artist, ar]
+    ars.first.not_first_tags.must_equal [tu, tv]
+    ars.last.not_first_tags.must_equal []
+    ars.first.not_first_tags.map{|x| x.values}.must_equal [tu, tv].map{|x| x.values}
 
     ars = ds.eager_graph_with_options(:last_two_tags, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.last_two_tags.should == [tv, tu]
-    ars.last.last_two_tags.should == [tu]
-    ars.first.last_two_tags.map{|x| x.values}.should == [tv, tu].map{|x| x.values}
+    ars.must_equal [@artist, ar]
+    ars.first.last_two_tags.must_equal [tv, tu]
+    ars.last.last_two_tags.must_equal [tu]
+    ars.first.last_two_tags.map{|x| x.values}.must_equal [tv, tu].map{|x| x.values}
   end
 end
 
-shared_examples_for "one_through_many eager limit strategies" do
-  specify "should correctly handle offsets when eager loading one_through_many associations" do
+OneThroughManyEagerLimitStrategies = shared_description do
+  it "should correctly handle offsets when eager loading one_through_many associations" do
     Artist.one_through_many :first_tag, {:clone=>:first_tag}.merge(@els) if @els
     Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els) if @els && @els[:eager_limit_strategy] != :distinct_on
     Artist.one_through_many :last_tag, {:clone=>:last_tag}.merge(@els) if @els
@@ -328,23 +328,23 @@ shared_examples_for "one_through_many eager limit strategies" do
     al.add_tag(tu)
     
     ars = Artist.eager(:first_tag, :second_tag, :last_tag).order(:name).all
-    ars.should == [@artist, ar]
-    ars.first.first_tag.should == @tag
-    ars.first.second_tag.should == tu
-    ars.first.last_tag.should == tv
-    ars.last.first_tag.should == tu
-    ars.last.second_tag.should == nil
-    ars.last.last_tag.should == tu
+    ars.must_equal [@artist, ar]
+    ars.first.first_tag.must_equal @tag
+    ars.first.second_tag.must_equal tu
+    ars.first.last_tag.must_equal tv
+    ars.last.first_tag.must_equal tu
+    ars.last.second_tag.must_equal nil
+    ars.last.last_tag.must_equal tu
     
     # Check that no extra columns got added by the eager loading
-    ars.first.first_tag.values.should == @tag.values
-    ars.first.second_tag.values.should == tu.values
-    ars.first.last_tag.values.should == tv.values
+    ars.first.first_tag.values.must_equal @tag.values
+    ars.first.second_tag.values.must_equal tu.values
+    ars.first.last_tag.values.must_equal tv.values
   end
 end
 
-shared_examples_for "one_through_many eager_graph limit strategies" do
-  specify "should correctly handle offsets when eager graphing one_through_many associations" do
+OneThroughManyEagerGraphLimitStrategies = shared_description do
+  it "should correctly handle offsets when eager graphing one_through_many associations" do
     @album.update(:artist => @artist)
     tu, tv = @other_tags.call
     al, ar, _ = @pr.call
@@ -354,331 +354,331 @@ shared_examples_for "one_through_many eager_graph limit strategies" do
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     ars = ds.eager_graph_with_options(:first_tag, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.first_tag.should == @tag
-    ars.last.first_tag.should == tu
-    ars.first.first_tag.values.should == @tag.values
+    ars.must_equal [@artist, ar]
+    ars.first.first_tag.must_equal @tag
+    ars.last.first_tag.must_equal tu
+    ars.first.first_tag.values.must_equal @tag.values
 
     ars = ds.eager_graph_with_options(:second_tag, @els[:eager_limit_strategy] != :distinct_on ? limit_strategy : {}).all
-    ars.should == [@artist, ar]
-    ars.first.second_tag.should == tu
-    ars.last.second_tag.should == nil
-    ars.first.second_tag.values.should == tu.values
+    ars.must_equal [@artist, ar]
+    ars.first.second_tag.must_equal tu
+    ars.last.second_tag.must_equal nil
+    ars.first.second_tag.values.must_equal tu.values
 
     ars = ds.eager_graph_with_options(:last_tag, limit_strategy).all
-    ars.should == [@artist, ar]
-    ars.first.last_tag.should == tv
-    ars.last.last_tag.should == tu
-    ars.first.last_tag.values.should == tv.values
+    ars.must_equal [@artist, ar]
+    ars.first.last_tag.must_equal tv
+    ars.last.last_tag.must_equal tu
+    ars.first.last_tag.values.must_equal tv.values
   end
 end
 
-shared_examples_for "eager limit strategies" do
-  it_should_behave_like "one_to_one eager limit strategies"
-  it_should_behave_like "one_to_many eager limit strategies"
-  it_should_behave_like "many_to_many eager limit strategies"
-  it_should_behave_like "one_through_one eager limit strategies"
-  it_should_behave_like "many_through_many eager limit strategies"
-  it_should_behave_like "one_through_many eager limit strategies"
+EagerLimitStrategies = shared_description do
+  include OneToOneEagerLimitStrategies
+  include OneToManyEagerLimitStrategies
+  include ManyToManyEagerLimitStrategies
+  include OneThroughOneEagerLimitStrategies
+  include ManyThroughManyEagerLimitStrategies
+  include OneThroughManyEagerLimitStrategies
 end
 
-shared_examples_for "eager_graph limit strategies" do
-  it_should_behave_like "one_to_one eager_graph limit strategies"
-  it_should_behave_like "one_to_many eager_graph limit strategies"
-  it_should_behave_like "many_to_many eager_graph limit strategies"
-  it_should_behave_like "one_through_one eager_graph limit strategies"
-  it_should_behave_like "many_through_many eager_graph limit strategies"
-  it_should_behave_like "one_through_many eager_graph limit strategies"
+EagerGraphLimitStrategies = shared_description do
+  include OneToOneEagerGraphLimitStrategies
+  include OneToManyEagerGraphLimitStrategies
+  include ManyToManyEagerGraphLimitStrategies
+  include OneThroughOneEagerGraphLimitStrategies
+  include ManyThroughManyEagerGraphLimitStrategies
+  include OneThroughManyEagerGraphLimitStrategies
 end
 
-shared_examples_for "filtering/excluding by associations" do
-  specify "should handle association inner joins" do
-    @Artist.association_join(:albums).all.should == []
-    @Artist.association_join(:first_album).all.should == []
-    @Album.association_join(:artist).all.should == []
-    @Album.association_join(:tags).all.should == []
-    @Album.association_join(:alias_tags).all.should == []
-    @Tag.association_join(:albums).all.should == []
+FilterByAssociations = shared_description do
+  it "should handle association inner joins" do
+    @Artist.association_join(:albums).all.must_equal []
+    @Artist.association_join(:first_album).all.must_equal []
+    @Album.association_join(:artist).all.must_equal []
+    @Album.association_join(:tags).all.must_equal []
+    @Album.association_join(:alias_tags).all.must_equal []
+    @Tag.association_join(:albums).all.must_equal []
     unless @no_many_through_many
-      @Artist.association_join(:tags).all.should == []
-      @Artist.association_join(:first_tag).all.should == []
+      @Artist.association_join(:tags).all.must_equal []
+      @Artist.association_join(:first_tag).all.must_equal []
     end
 
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
-    @Artist.association_join(:albums).select_all(:artists).all.should == [@artist]
-    @Artist.association_join(:first_album).select_all(:artists).all.should == [@artist]
-    @Album.association_join(:artist).select_all(:albums).all.should == [@album]
-    @Album.association_join(:tags).select_all(:albums).all.should == [@album]
-    @Album.association_join(:alias_tags).select_all(:albums).all.should == [@album]
-    @Tag.association_join(:albums).select_all(:tags).all.should == [@tag]
+    @Artist.association_join(:albums).select_all(:artists).all.must_equal [@artist]
+    @Artist.association_join(:first_album).select_all(:artists).all.must_equal [@artist]
+    @Album.association_join(:artist).select_all(:albums).all.must_equal [@album]
+    @Album.association_join(:tags).select_all(:albums).all.must_equal [@album]
+    @Album.association_join(:alias_tags).select_all(:albums).all.must_equal [@album]
+    @Tag.association_join(:albums).select_all(:tags).all.must_equal [@tag]
     unless @no_many_through_many
-      @Artist.association_join(:tags).select_all(:artists).all.should == [@artist]
-      @Artist.association_join(:first_tag).select_all(:artists).all.should == [@artist]
+      @Artist.association_join(:tags).select_all(:artists).all.must_equal [@artist]
+      @Artist.association_join(:first_tag).select_all(:artists).all.must_equal [@artist]
     end
 
-    @Artist.association_join(:albums).select_all(:albums).naked.all.should == [@album.values]
-    @Artist.association_join(:first_album).select_all(:first_album).naked.all.should == [@album.values]
-    @Album.association_join(:artist).select_all(:artist).naked.all.should == [@artist.values]
-    @Album.association_join(:tags).select_all(:tags).naked.all.should == [@tag.values]
-    @Album.association_join(:alias_tags).select_all(:alias_tags).naked.all.should == [@tag.values]
-    @Tag.association_join(:albums).select_all(:albums).naked.all.should == [@album.values]
+    @Artist.association_join(:albums).select_all(:albums).naked.all.must_equal [@album.values]
+    @Artist.association_join(:first_album).select_all(:first_album).naked.all.must_equal [@album.values]
+    @Album.association_join(:artist).select_all(:artist).naked.all.must_equal [@artist.values]
+    @Album.association_join(:tags).select_all(:tags).naked.all.must_equal [@tag.values]
+    @Album.association_join(:alias_tags).select_all(:alias_tags).naked.all.must_equal [@tag.values]
+    @Tag.association_join(:albums).select_all(:albums).naked.all.must_equal [@album.values]
     unless @no_many_through_many
-      @Artist.association_join(:tags).select_all(:tags).naked.all.should == [@tag.values]
-      @Artist.association_join(:first_tag).select_all(:first_tag).naked.all.should == [@tag.values]
+      @Artist.association_join(:tags).select_all(:tags).naked.all.must_equal [@tag.values]
+      @Artist.association_join(:first_tag).select_all(:first_tag).naked.all.must_equal [@tag.values]
     end
   end
 
-  specify "should handle association left joins" do
-    @Artist.association_left_join(:albums).select_all(:artists).all.should == [@artist]
-    @Artist.association_left_join(:first_album).select_all(:artists).all.should == [@artist]
-    @Album.association_left_join(:artist).select_all(:albums).all.should == [@album]
-    @Album.association_left_join(:tags).select_all(:albums).all.should == [@album]
-    @Album.association_left_join(:alias_tags).select_all(:albums).all.should == [@album]
-    @Tag.association_left_join(:albums).select_all(:tags).all.should == [@tag]
+  it "should handle association left joins" do
+    @Artist.association_left_join(:albums).select_all(:artists).all.must_equal [@artist]
+    @Artist.association_left_join(:first_album).select_all(:artists).all.must_equal [@artist]
+    @Album.association_left_join(:artist).select_all(:albums).all.must_equal [@album]
+    @Album.association_left_join(:tags).select_all(:albums).all.must_equal [@album]
+    @Album.association_left_join(:alias_tags).select_all(:albums).all.must_equal [@album]
+    @Tag.association_left_join(:albums).select_all(:tags).all.must_equal [@tag]
     unless @no_many_through_many
-      @Artist.association_left_join(:tags).select_all(:artists).all.should == [@artist]
-      @Artist.association_left_join(:first_tag).select_all(:artists).all.should == [@artist]
+      @Artist.association_left_join(:tags).select_all(:artists).all.must_equal [@artist]
+      @Artist.association_left_join(:first_tag).select_all(:artists).all.must_equal [@artist]
     end
 
     nil_hash = lambda{|obj| [obj.values.keys.inject({}){|h,k| h[k] = nil; h}]}
-    @Artist.association_left_join(:albums).select_all(:albums).naked.all.should == nil_hash[@album]
-    @Artist.association_left_join(:first_album).select_all(:first_album).naked.all.should == nil_hash[@album]
-    @Album.association_left_join(:artist).select_all(:artist).naked.all.should == nil_hash[@artist]
-    @Album.association_left_join(:tags).select_all(:tags).naked.all.should == nil_hash[@tag]
-    @Album.association_left_join(:alias_tags).select_all(:alias_tags).naked.all.should == nil_hash[@tag]
-    @Tag.association_left_join(:albums).select_all(:albums).naked.all.should == nil_hash[@album]
+    @Artist.association_left_join(:albums).select_all(:albums).naked.all.must_equal nil_hash[@album]
+    @Artist.association_left_join(:first_album).select_all(:first_album).naked.all.must_equal nil_hash[@album]
+    @Album.association_left_join(:artist).select_all(:artist).naked.all.must_equal nil_hash[@artist]
+    @Album.association_left_join(:tags).select_all(:tags).naked.all.must_equal nil_hash[@tag]
+    @Album.association_left_join(:alias_tags).select_all(:alias_tags).naked.all.must_equal nil_hash[@tag]
+    @Tag.association_left_join(:albums).select_all(:albums).naked.all.must_equal nil_hash[@album]
     unless @no_many_through_many
-      @Artist.association_left_join(:tags).select_all(:tags).naked.all.should == nil_hash[@tag]
-      @Artist.association_left_join(:first_tag).select_all(:first_tag).naked.all.should == nil_hash[@tag]
+      @Artist.association_left_join(:tags).select_all(:tags).naked.all.must_equal nil_hash[@tag]
+      @Artist.association_left_join(:first_tag).select_all(:first_tag).naked.all.must_equal nil_hash[@tag]
     end
 
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
 
-    @Artist.association_left_join(:albums).select_all(:albums).naked.all.should == [@album.values]
-    @Artist.association_left_join(:first_album).select_all(:first_album).naked.all.should == [@album.values]
-    @Album.association_left_join(:artist).select_all(:artist).naked.all.should == [@artist.values]
-    @Album.association_left_join(:tags).select_all(:tags).naked.all.should == [@tag.values]
-    @Album.association_left_join(:alias_tags).select_all(:alias_tags).naked.all.should == [@tag.values]
-    @Tag.association_left_join(:albums).select_all(:albums).naked.all.should == [@album.values]
+    @Artist.association_left_join(:albums).select_all(:albums).naked.all.must_equal [@album.values]
+    @Artist.association_left_join(:first_album).select_all(:first_album).naked.all.must_equal [@album.values]
+    @Album.association_left_join(:artist).select_all(:artist).naked.all.must_equal [@artist.values]
+    @Album.association_left_join(:tags).select_all(:tags).naked.all.must_equal [@tag.values]
+    @Album.association_left_join(:alias_tags).select_all(:alias_tags).naked.all.must_equal [@tag.values]
+    @Tag.association_left_join(:albums).select_all(:albums).naked.all.must_equal [@album.values]
     unless @no_many_through_many
-      @Artist.association_left_join(:tags).select_all(:tags).naked.all.should == [@tag.values]
-      @Artist.association_left_join(:first_tag).select_all(:first_tag).naked.all.should == [@tag.values]
+      @Artist.association_left_join(:tags).select_all(:tags).naked.all.must_equal [@tag.values]
+      @Artist.association_left_join(:first_tag).select_all(:first_tag).naked.all.must_equal [@tag.values]
     end
   end
 
-  specify "should work correctly when filtering by associations" do
+  it "should work correctly when filtering by associations" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
-    @Artist.filter(:albums=>@album).all.should == [@artist]
-    @Artist.filter(:first_album=>@album).all.should == [@artist]
+    @Artist.filter(:albums=>@album).all.must_equal [@artist]
+    @Artist.filter(:first_album=>@album).all.must_equal [@artist]
     unless @no_many_through_many
-      @Artist.filter(:tags=>@tag).all.should == [@artist]
-      @Artist.filter(:first_tag=>@tag).all.should == [@artist]
+      @Artist.filter(:tags=>@tag).all.must_equal [@artist]
+      @Artist.filter(:first_tag=>@tag).all.must_equal [@artist]
     end
-    @Album.filter(:artist=>@artist).all.should == [@album]
-    @Album.filter(:tags=>@tag).all.should == [@album]
-    @Album.filter(:alias_tags=>@tag).all.should == [@album]
-    @Tag.filter(:albums=>@album).all.should == [@tag]
-    @Album.filter(:artist=>@artist, :tags=>@tag).all.should == [@album]
-    @artist.albums_dataset.filter(:tags=>@tag).all.should == [@album]
+    @Album.filter(:artist=>@artist).all.must_equal [@album]
+    @Album.filter(:tags=>@tag).all.must_equal [@album]
+    @Album.filter(:alias_tags=>@tag).all.must_equal [@album]
+    @Tag.filter(:albums=>@album).all.must_equal [@tag]
+    @Album.filter(:artist=>@artist, :tags=>@tag).all.must_equal [@album]
+    @artist.albums_dataset.filter(:tags=>@tag).all.must_equal [@album]
   end
 
-  specify "should work correctly when excluding by associations" do
+  it "should work correctly when excluding by associations" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     album, artist, tag = @pr.call
 
-    @Artist.exclude(:albums=>@album).all.should == [artist]
-    @Artist.exclude(:first_album=>@album).all.should == [artist]
+    @Artist.exclude(:albums=>@album).all.must_equal [artist]
+    @Artist.exclude(:first_album=>@album).all.must_equal [artist]
     unless @no_many_through_many
-      @Artist.exclude(:tags=>@tag).all.should == [artist]
-      @Artist.exclude(:first_tag=>@tag).all.should == [artist]
+      @Artist.exclude(:tags=>@tag).all.must_equal [artist]
+      @Artist.exclude(:first_tag=>@tag).all.must_equal [artist]
     end
-    @Album.exclude(:artist=>@artist).all.should == [album]
-    @Album.exclude(:tags=>@tag).all.should == [album]
-    @Album.exclude(:alias_tags=>@tag).all.should == [album]
-    @Tag.exclude(:albums=>@album).all.should == [tag]
-    @Album.exclude(:artist=>@artist, :tags=>@tag).all.should == [album]
+    @Album.exclude(:artist=>@artist).all.must_equal [album]
+    @Album.exclude(:tags=>@tag).all.must_equal [album]
+    @Album.exclude(:alias_tags=>@tag).all.must_equal [album]
+    @Tag.exclude(:albums=>@album).all.must_equal [tag]
+    @Album.exclude(:artist=>@artist, :tags=>@tag).all.must_equal [album]
   end
 
-  specify "should work correctly when filtering by associations with conditions" do
+  it "should work correctly when filtering by associations with conditions" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
-    @Artist.filter(:a_albums=>@album).all.should == [@artist]
-    @Artist.filter(:first_a_album=>@album).all.should == [@artist]
+    @Artist.filter(:a_albums=>@album).all.must_equal [@artist]
+    @Artist.filter(:first_a_album=>@album).all.must_equal [@artist]
     @album.update(:name=>'Foo')
-    @Artist.filter(:a_albums=>@album).all.should == []
-    @Artist.filter(:first_a_album=>@album).all.should == []
+    @Artist.filter(:a_albums=>@album).all.must_equal []
+    @Artist.filter(:first_a_album=>@album).all.must_equal []
 
-    @Album.filter(:a_artist=>@artist).all.should == [@album]
+    @Album.filter(:a_artist=>@artist).all.must_equal [@album]
     @artist.update(:name=>'Foo')
-    @Album.filter(:a_artist=>@artist).all.should == []
+    @Album.filter(:a_artist=>@artist).all.must_equal []
 
-    @Album.filter(:t_tags=>@tag).all.should == [@album]
-    @Album.filter(:alias_t_tags=>@tag).all.should == [@album]
+    @Album.filter(:t_tags=>@tag).all.must_equal [@album]
+    @Album.filter(:alias_t_tags=>@tag).all.must_equal [@album]
     unless @no_many_through_many
-      @Album.filter(:t_tag=>@tag).all.should == [@album]
-      @Album.filter(:alias_t_tag=>@tag).all.should == [@album]
-      @Artist.filter(:t_tags=>@tag).all.should == [@artist]
-      @Artist.filter(:t_tag=>@tag).all.should == [@artist]
+      @Album.filter(:t_tag=>@tag).all.must_equal [@album]
+      @Album.filter(:alias_t_tag=>@tag).all.must_equal [@album]
+      @Artist.filter(:t_tags=>@tag).all.must_equal [@artist]
+      @Artist.filter(:t_tag=>@tag).all.must_equal [@artist]
     end
     @tag.update(:name=>'Foo')
-    @Album.filter(:t_tags=>@tag).all.should == []
-    @Album.filter(:alias_t_tags=>@tag).all.should == []
+    @Album.filter(:t_tags=>@tag).all.must_equal []
+    @Album.filter(:alias_t_tags=>@tag).all.must_equal []
     unless @no_many_through_many
-      @Album.filter(:t_tag=>@tag).all.should == []
-      @Album.filter(:alias_t_tag=>@tag).all.should == []
-      @Artist.filter(:t_tags=>@tag).all.should == []
-      @Artist.filter(:t_tag=>@tag).all.should == []
+      @Album.filter(:t_tag=>@tag).all.must_equal []
+      @Album.filter(:alias_t_tag=>@tag).all.must_equal []
+      @Artist.filter(:t_tags=>@tag).all.must_equal []
+      @Artist.filter(:t_tag=>@tag).all.must_equal []
     end
   end
   
-  specify "should work correctly when excluding by associations with conditions" do
+  it "should work correctly when excluding by associations with conditions" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
-    @Artist.exclude(:a_albums=>@album).all.should == []
-    @Artist.exclude(:first_a_album=>@album).all.should == []
+    @Artist.exclude(:a_albums=>@album).all.must_equal []
+    @Artist.exclude(:first_a_album=>@album).all.must_equal []
     @album.update(:name=>'Foo')
-    @Artist.exclude(:a_albums=>@album).all.should == [@artist]
-    @Artist.exclude(:first_a_album=>@album).all.should == [@artist]
+    @Artist.exclude(:a_albums=>@album).all.must_equal [@artist]
+    @Artist.exclude(:first_a_album=>@album).all.must_equal [@artist]
 
-    @Album.exclude(:a_artist=>@artist).all.should == []
+    @Album.exclude(:a_artist=>@artist).all.must_equal []
     @artist.update(:name=>'Foo')
-    @Album.exclude(:a_artist=>@artist).all.should == [@album]
+    @Album.exclude(:a_artist=>@artist).all.must_equal [@album]
 
-    @Album.exclude(:t_tags=>@tag).all.should == []
-    @Album.exclude(:alias_t_tags=>@tag).all.should == []
+    @Album.exclude(:t_tags=>@tag).all.must_equal []
+    @Album.exclude(:alias_t_tags=>@tag).all.must_equal []
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>@tag).all.should == []
-      @Album.exclude(:alias_t_tag=>@tag).all.should == []
-      @Artist.exclude(:t_tags=>@tag).all.should == []
-      @Artist.exclude(:t_tag=>@tag).all.should == []
+      @Album.exclude(:t_tag=>@tag).all.must_equal []
+      @Album.exclude(:alias_t_tag=>@tag).all.must_equal []
+      @Artist.exclude(:t_tags=>@tag).all.must_equal []
+      @Artist.exclude(:t_tag=>@tag).all.must_equal []
     end
     @tag.update(:name=>'Foo')
-    @Album.exclude(:t_tags=>@tag).all.should == [@album]
-    @Album.exclude(:alias_t_tags=>@tag).all.should == [@album]
+    @Album.exclude(:t_tags=>@tag).all.must_equal [@album]
+    @Album.exclude(:alias_t_tags=>@tag).all.must_equal [@album]
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>@tag).all.should == [@album]
-      @Album.exclude(:alias_t_tag=>@tag).all.should == [@album]
-      @Artist.exclude(:t_tags=>@tag).all.should == [@artist]
-      @Artist.exclude(:t_tag=>@tag).all.should == [@artist]
+      @Album.exclude(:t_tag=>@tag).all.must_equal [@album]
+      @Album.exclude(:alias_t_tag=>@tag).all.must_equal [@album]
+      @Artist.exclude(:t_tags=>@tag).all.must_equal [@artist]
+      @Artist.exclude(:t_tag=>@tag).all.must_equal [@artist]
     end
   end
   
-  specify "should work correctly when filtering by multiple associations" do
+  it "should work correctly when filtering by multiple associations" do
     album, artist, tag = @pr.call
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
-    @Artist.filter(:albums=>[@album, album]).all.should == [@artist]
-    @Artist.filter(:first_album=>[@album, album]).all.should == [@artist]
-    @Album.filter(:artist=>[@artist, artist]).all.should == [@album]
-    @Album.filter(:tags=>[@tag, tag]).all.should == [@album]
-    @Album.filter(:alias_tags=>[@tag, tag]).all.should == [@album]
-    @Tag.filter(:albums=>[@album, album]).all.should == [@tag]
-    @Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.should == [@album]
-    @artist.albums_dataset.filter(:tags=>[@tag, tag]).all.should == [@album]
+    @Artist.filter(:albums=>[@album, album]).all.must_equal [@artist]
+    @Artist.filter(:first_album=>[@album, album]).all.must_equal [@artist]
+    @Album.filter(:artist=>[@artist, artist]).all.must_equal [@album]
+    @Album.filter(:tags=>[@tag, tag]).all.must_equal [@album]
+    @Album.filter(:alias_tags=>[@tag, tag]).all.must_equal [@album]
+    @Tag.filter(:albums=>[@album, album]).all.must_equal [@tag]
+    @Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.must_equal [@album]
+    @artist.albums_dataset.filter(:tags=>[@tag, tag]).all.must_equal [@album]
     unless @no_many_through_many
-      @Artist.filter(:tags=>[@tag, tag]).all.should == [@artist]
-      @Artist.filter(:first_tag=>[@tag, tag]).all.should == [@artist]
+      @Artist.filter(:tags=>[@tag, tag]).all.must_equal [@artist]
+      @Artist.filter(:first_tag=>[@tag, tag]).all.must_equal [@artist]
     end
 
     album.add_tag(tag)
 
-    @Artist.filter(:albums=>[@album, album]).all.should == [@artist]
-    @Artist.filter(:first_album=>[@album, album]).all.should == [@artist]
-    @Album.filter(:artist=>[@artist, artist]).all.should == [@album]
-    @Album.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.filter(:alias_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Tag.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
-    @Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.should == [@album]
+    @Artist.filter(:albums=>[@album, album]).all.must_equal [@artist]
+    @Artist.filter(:first_album=>[@album, album]).all.must_equal [@artist]
+    @Album.filter(:artist=>[@artist, artist]).all.must_equal [@album]
+    @Album.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.filter(:alias_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Tag.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@tag, tag]
+    @Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.must_equal [@album]
     unless @no_many_through_many
-      @Artist.filter(:tags=>[@tag, tag]).all.should == [@artist]
-      @Artist.filter(:first_tag=>[@tag, tag]).all.should == [@artist]
+      @Artist.filter(:tags=>[@tag, tag]).all.must_equal [@artist]
+      @Artist.filter(:first_tag=>[@tag, tag]).all.must_equal [@artist]
     end
 
     album.update(:artist => artist)
 
-    @Artist.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Artist.filter(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Album.filter(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.filter(:alias_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Tag.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
-    @Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
+    @Artist.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Artist.filter(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Album.filter(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.filter(:alias_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Tag.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@tag, tag]
+    @Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
     unless @no_many_through_many
-      @Artist.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@artist, artist]
-      @Artist.filter(:first_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@artist, artist]
+      @Artist.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+      @Artist.filter(:first_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
     end
   end
 
-  specify "should work correctly when excluding by multiple associations" do
+  it "should work correctly when excluding by multiple associations" do
     album, artist, tag = @pr.call
 
-    @Artist.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Artist.exclude(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Album.exclude(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:alias_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Tag.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
-    @Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
+    @Artist.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Artist.exclude(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Album.exclude(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:alias_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Tag.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@tag, tag]
+    @Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
     unless @no_many_through_many
-      @Artist.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@artist, artist]
-      @Artist.exclude(:first_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@artist, artist]
+      @Artist.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+      @Artist.exclude(:first_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
     end
 
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
 
-    @Artist.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [artist]
-    @Artist.exclude(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.should == [artist]
-    @Album.exclude(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [album]
-    @Album.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [album]
-    @Album.exclude(:alias_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [album]
-    @Tag.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [tag]
-    @Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [album]
+    @Artist.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [artist]
+    @Artist.exclude(:first_album=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [artist]
+    @Album.exclude(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.exclude(:alias_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [album]
+    @Tag.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [tag]
+    @Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [album]
     unless @no_many_through_many
-      @Artist.exclude(:tags=>[@tag, tag]).all.should == [artist]
-      @Artist.exclude(:first_tag=>[@tag, tag]).all.should == [artist]
+      @Artist.exclude(:tags=>[@tag, tag]).all.must_equal [artist]
+      @Artist.exclude(:first_tag=>[@tag, tag]).all.must_equal [artist]
     end
 
     album.add_tag(tag)
 
-    @Artist.exclude(:albums=>[@album, album]).all.should == [artist]
-    @Artist.exclude(:first_album=>[@album, album]).all.should == [artist]
-    @Album.exclude(:artist=>[@artist, artist]).all.should == [album]
-    @Album.exclude(:tags=>[@tag, tag]).all.should == []
-    @Album.exclude(:alias_tags=>[@tag, tag]).all.should == []
-    @Tag.exclude(:albums=>[@album, album]).all.should == []
-    @Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.should == [album]
+    @Artist.exclude(:albums=>[@album, album]).all.must_equal [artist]
+    @Artist.exclude(:first_album=>[@album, album]).all.must_equal [artist]
+    @Album.exclude(:artist=>[@artist, artist]).all.must_equal [album]
+    @Album.exclude(:tags=>[@tag, tag]).all.must_equal []
+    @Album.exclude(:alias_tags=>[@tag, tag]).all.must_equal []
+    @Tag.exclude(:albums=>[@album, album]).all.must_equal []
+    @Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.must_equal [album]
     unless @no_many_through_many
-      @Artist.exclude(:tags=>[@tag, tag]).all.should == [artist]
-      @Artist.exclude(:first_tag=>[@tag, tag]).all.should == [artist]
+      @Artist.exclude(:tags=>[@tag, tag]).all.must_equal [artist]
+      @Artist.exclude(:first_tag=>[@tag, tag]).all.must_equal [artist]
     end
 
     album.update(:artist => artist)
 
-    @Artist.exclude(:albums=>[@album, album]).all.should == []
-    @Artist.exclude(:first_album=>[@album, album]).all.should == []
-    @Album.exclude(:artist=>[@artist, artist]).all.should == []
-    @Album.exclude(:tags=>[@tag, tag]).all.should == []
-    @Album.exclude(:alias_tags=>[@tag, tag]).all.should == []
-    @Tag.exclude(:albums=>[@album, album]).all.should == []
-    @Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.should == []
+    @Artist.exclude(:albums=>[@album, album]).all.must_equal []
+    @Artist.exclude(:first_album=>[@album, album]).all.must_equal []
+    @Album.exclude(:artist=>[@artist, artist]).all.must_equal []
+    @Album.exclude(:tags=>[@tag, tag]).all.must_equal []
+    @Album.exclude(:alias_tags=>[@tag, tag]).all.must_equal []
+    @Tag.exclude(:albums=>[@album, album]).all.must_equal []
+    @Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.must_equal []
     unless @no_many_through_many
-      @Artist.exclude(:tags=>[@tag, tag]).all.should == []
-      @Artist.exclude(:first_tag=>[@tag, tag]).all.should == []
+      @Artist.exclude(:tags=>[@tag, tag]).all.must_equal []
+      @Artist.exclude(:first_tag=>[@tag, tag]).all.must_equal []
     end
   end
   
-  specify "should work correctly when filtering associations with conditions with multiple objects" do
+  it "should work correctly when filtering associations with conditions with multiple objects" do
     album, artist, tag = @pr.call
     album.update(:name=>@album.name)
     artist.update(:name=>@artist.name)
@@ -689,52 +689,52 @@ shared_examples_for "filtering/excluding by associations" do
     album.update(:artist => @artist)
     tag.add_album(@album)
     
-    @Artist.filter(:a_albums=>[@album, album]).all.should == [@artist]
-    @Artist.filter(:first_a_album=>[@album, album]).all.should == [@artist]
+    @Artist.filter(:a_albums=>[@album, album]).all.must_equal [@artist]
+    @Artist.filter(:first_a_album=>[@album, album]).all.must_equal [@artist]
     @album.update(:name=>'Foo')
-    @Artist.filter(:a_albums=>[@album, album]).all.should == [@artist]
-    @Artist.filter(:first_a_album=>[@album, album]).all.should == [@artist]
+    @Artist.filter(:a_albums=>[@album, album]).all.must_equal [@artist]
+    @Artist.filter(:first_a_album=>[@album, album]).all.must_equal [@artist]
     album.update(:name=>'Foo')
-    @Artist.filter(:a_albums=>[@album, album]).all.should == []
-    @Artist.filter(:first_a_album=>[@album, album]).all.should == []
+    @Artist.filter(:a_albums=>[@album, album]).all.must_equal []
+    @Artist.filter(:first_a_album=>[@album, album]).all.must_equal []
 
     album.update(:artist => nil)
     artist.add_album(@album)
-    @Album.filter(:a_artist=>[@artist, artist]).all.should == [@album]
+    @Album.filter(:a_artist=>[@artist, artist]).all.must_equal [@album]
     @artist.update(:name=>'Foo')
-    @Album.filter(:a_artist=>[@artist, artist]).all.should == [@album]
+    @Album.filter(:a_artist=>[@artist, artist]).all.must_equal [@album]
     artist.update(:name=>'Foo')
-    @Album.filter(:a_artist=>[@artist, artist]).all.should == []
+    @Album.filter(:a_artist=>[@artist, artist]).all.must_equal []
 
-    @Album.filter(:t_tags=>[@tag, tag]).all.should == [@album]
-    @Album.filter(:alias_t_tags=>[@tag, tag]).all.should == [@album]
+    @Album.filter(:t_tags=>[@tag, tag]).all.must_equal [@album]
+    @Album.filter(:alias_t_tags=>[@tag, tag]).all.must_equal [@album]
     unless @no_many_through_many
-      @Album.filter(:t_tag=>[@tag, tag]).all.should == [@album]
-      @Album.filter(:alias_t_tag=>[@tag, tag]).all.should == [@album]
-      @Artist.filter(:t_tags=>[@tag, tag]).all.should == [artist]
-      @Artist.filter(:t_tag=>[@tag, tag]).all.should == [artist]
+      @Album.filter(:t_tag=>[@tag, tag]).all.must_equal [@album]
+      @Album.filter(:alias_t_tag=>[@tag, tag]).all.must_equal [@album]
+      @Artist.filter(:t_tags=>[@tag, tag]).all.must_equal [artist]
+      @Artist.filter(:t_tag=>[@tag, tag]).all.must_equal [artist]
     end
     @tag.update(:name=>'Foo')
-    @Album.filter(:t_tags=>[@tag, tag]).all.should == [@album]
-    @Album.filter(:alias_t_tags=>[@tag, tag]).all.should == [@album]
+    @Album.filter(:t_tags=>[@tag, tag]).all.must_equal [@album]
+    @Album.filter(:alias_t_tags=>[@tag, tag]).all.must_equal [@album]
     unless @no_many_through_many
-      @Album.filter(:t_tag=>[@tag, tag]).all.should == [@album]
-      @Album.filter(:alias_t_tag=>[@tag, tag]).all.should == [@album]
-      @Artist.filter(:t_tags=>[@tag, tag]).all.should == [artist]
-      @Artist.filter(:t_tag=>[@tag, tag]).all.should == [artist]
+      @Album.filter(:t_tag=>[@tag, tag]).all.must_equal [@album]
+      @Album.filter(:alias_t_tag=>[@tag, tag]).all.must_equal [@album]
+      @Artist.filter(:t_tags=>[@tag, tag]).all.must_equal [artist]
+      @Artist.filter(:t_tag=>[@tag, tag]).all.must_equal [artist]
     end
     tag.update(:name=>'Foo')
-    @Album.filter(:t_tags=>[@tag, tag]).all.should == []
-    @Album.filter(:alias_t_tags=>[@tag, tag]).all.should == []
+    @Album.filter(:t_tags=>[@tag, tag]).all.must_equal []
+    @Album.filter(:alias_t_tags=>[@tag, tag]).all.must_equal []
     unless @no_many_through_many
-      @Album.filter(:t_tag=>[@tag, tag]).all.should == []
-      @Album.filter(:alias_t_tag=>[@tag, tag]).all.should == []
-      @Artist.filter(:t_tags=>[@tag, tag]).all.should == []
-      @Artist.filter(:t_tag=>[@tag, tag]).all.should == []
+      @Album.filter(:t_tag=>[@tag, tag]).all.must_equal []
+      @Album.filter(:alias_t_tag=>[@tag, tag]).all.must_equal []
+      @Artist.filter(:t_tags=>[@tag, tag]).all.must_equal []
+      @Artist.filter(:t_tag=>[@tag, tag]).all.must_equal []
     end
   end
   
-  specify "should work correctly when excluding associations with conditions with multiple objects" do
+  it "should work correctly when excluding associations with conditions with multiple objects" do
     album, artist, tag = @pr.call
     album.update(:name=>@album.name)
     artist.update(:name=>@artist.name)
@@ -746,295 +746,295 @@ shared_examples_for "filtering/excluding by associations" do
     tag.add_album(@album)
     
     artist.add_album(@album)
-    @Artist.exclude(:a_albums=>[@album, album]).all.should == []
-    @Artist.exclude(:first_a_album=>[@album, album]).all.should == []
+    @Artist.exclude(:a_albums=>[@album, album]).all.must_equal []
+    @Artist.exclude(:first_a_album=>[@album, album]).all.must_equal []
     @album.update(:name=>'Foo')
-    @Artist.exclude(:a_albums=>[@album, album]).all.should == [artist]
-    @Artist.exclude(:first_a_album=>[@album, album]).all.should == [artist]
+    @Artist.exclude(:a_albums=>[@album, album]).all.must_equal [artist]
+    @Artist.exclude(:first_a_album=>[@album, album]).all.must_equal [artist]
     album.update(:name=>'Foo')
-    @Artist.exclude(:a_albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Artist.exclude(:first_a_album=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
+    @Artist.exclude(:a_albums=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Artist.exclude(:first_a_album=>[@album, album]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
 
-    @Album.exclude(:a_artist=>[@artist, artist]).all.should == []
+    @Album.exclude(:a_artist=>[@artist, artist]).all.must_equal []
     album.update(:artist => nil)
     @artist.update(:name=>'Foo')
-    @Album.exclude(:a_artist=>[@artist, artist]).all.should == [album]
+    @Album.exclude(:a_artist=>[@artist, artist]).all.must_equal [album]
     artist.update(:name=>'Foo')
-    @Album.exclude(:a_artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [@album, album]
+    @Album.exclude(:a_artist=>[@artist, artist]).all.sort_by{|x| x.pk}.must_equal [@album, album]
 
     @tag.add_album(album)
-    @Album.exclude(:t_tags=>[@tag, tag]).all.should == []
-    @Album.exclude(:alias_t_tags=>[@tag, tag]).all.should == []
+    @Album.exclude(:t_tags=>[@tag, tag]).all.must_equal []
+    @Album.exclude(:alias_t_tags=>[@tag, tag]).all.must_equal []
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>[@tag, tag]).all.should == []
-      @Album.exclude(:alias_t_tag=>[@tag, tag]).all.should == []
-      @Artist.exclude(:t_tags=>[@tag, tag]).all.should == [@artist]
-      @Artist.exclude(:t_tag=>[@tag, tag]).all.should == [@artist]
+      @Album.exclude(:t_tag=>[@tag, tag]).all.must_equal []
+      @Album.exclude(:alias_t_tag=>[@tag, tag]).all.must_equal []
+      @Artist.exclude(:t_tags=>[@tag, tag]).all.must_equal [@artist]
+      @Artist.exclude(:t_tag=>[@tag, tag]).all.must_equal [@artist]
     end
     @tag.update(:name=>'Foo')
-    @Album.exclude(:t_tags=>[@tag, tag]).all.should == [album]
-    @Album.exclude(:alias_t_tags=>[@tag, tag]).all.should == [album]
+    @Album.exclude(:t_tags=>[@tag, tag]).all.must_equal [album]
+    @Album.exclude(:alias_t_tags=>[@tag, tag]).all.must_equal [album]
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>[@tag, tag]).all.should == [album]
-      @Album.exclude(:alias_t_tag=>[@tag, tag]).all.should == [album]
-      @Artist.exclude(:t_tags=>[@tag, tag]).all.should == [@artist]
-      @Artist.exclude(:t_tag=>[@tag, tag]).all.should == [@artist]
+      @Album.exclude(:t_tag=>[@tag, tag]).all.must_equal [album]
+      @Album.exclude(:alias_t_tag=>[@tag, tag]).all.must_equal [album]
+      @Artist.exclude(:t_tags=>[@tag, tag]).all.must_equal [@artist]
+      @Artist.exclude(:t_tag=>[@tag, tag]).all.must_equal [@artist]
     end
     tag.update(:name=>'Foo')
-    @Album.exclude(:t_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:alias_t_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
+    @Album.exclude(:t_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:alias_t_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-      @Album.exclude(:alias_t_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
-      @Artist.exclude(:t_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@artist, artist]
-      @Artist.exclude(:t_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@artist, artist]
+      @Album.exclude(:t_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+      @Album.exclude(:alias_t_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@album, album]
+      @Artist.exclude(:t_tags=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+      @Artist.exclude(:t_tag=>[@tag, tag]).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
     end
   end
   
-  specify "should work correctly when excluding by associations in regards to NULL values" do
-    @Artist.exclude(:albums=>@album).all.should == [@artist]
-    @Artist.exclude(:first_album=>@album).all.should == [@artist]
-    @Album.exclude(:artist=>@artist).all.should == [@album]
-    @Album.exclude(:tags=>@tag).all.should == [@album]
-    @Album.exclude(:alias_tags=>@tag).all.should == [@album]
-    @Tag.exclude(:albums=>@album).all.should == [@tag]
-    @Album.exclude(:artist=>@artist, :tags=>@tag).all.should == [@album]
-
-    @Artist.exclude(:a_albums=>@album).all.should == [@artist]
-    @Artist.exclude(:first_a_album=>@album).all.should == [@artist]
-    @Album.exclude(:a_artist=>@artist).all.should == [@album]
-    @Album.exclude(:t_tags=>@tag).all.should == [@album]
-    @Album.exclude(:alias_t_tags=>@tag).all.should == [@album]
+  it "should work correctly when excluding by associations in regards to NULL values" do
+    @Artist.exclude(:albums=>@album).all.must_equal [@artist]
+    @Artist.exclude(:first_album=>@album).all.must_equal [@artist]
+    @Album.exclude(:artist=>@artist).all.must_equal [@album]
+    @Album.exclude(:tags=>@tag).all.must_equal [@album]
+    @Album.exclude(:alias_tags=>@tag).all.must_equal [@album]
+    @Tag.exclude(:albums=>@album).all.must_equal [@tag]
+    @Album.exclude(:artist=>@artist, :tags=>@tag).all.must_equal [@album]
+
+    @Artist.exclude(:a_albums=>@album).all.must_equal [@artist]
+    @Artist.exclude(:first_a_album=>@album).all.must_equal [@artist]
+    @Album.exclude(:a_artist=>@artist).all.must_equal [@album]
+    @Album.exclude(:t_tags=>@tag).all.must_equal [@album]
+    @Album.exclude(:alias_t_tags=>@tag).all.must_equal [@album]
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>@tag).all.should == [@album]
-      @Album.exclude(:alias_t_tag=>@tag).all.should == [@album]
-      @Artist.exclude(:t_tags=>@tag).all.should == [@artist]
-      @Artist.exclude(:t_tag=>@tag).all.should == [@artist]
+      @Album.exclude(:t_tag=>@tag).all.must_equal [@album]
+      @Album.exclude(:alias_t_tag=>@tag).all.must_equal [@album]
+      @Artist.exclude(:t_tags=>@tag).all.must_equal [@artist]
+      @Artist.exclude(:t_tag=>@tag).all.must_equal [@artist]
     end
 
     @album.update(:artist => @artist)
-    @artist.albums_dataset.exclude(:tags=>@tag).all.should == [@album]
+    @artist.albums_dataset.exclude(:tags=>@tag).all.must_equal [@album]
   end
 
-  specify "should handle NULL values in join table correctly when filtering/excluding many_to_many associations" do
+  it "should handle NULL values in join table correctly when filtering/excluding many_to_many associations" do
     @ins.call
-    @Album.exclude(:tags=>@tag).all.should == [@album]
-    @Album.exclude(:alias_tags=>@tag).all.should == [@album]
-    @Album.exclude(:t_tags=>@tag).all.should == [@album]
-    @Album.exclude(:alias_t_tags=>@tag).all.should == [@album]
+    @Album.exclude(:tags=>@tag).all.must_equal [@album]
+    @Album.exclude(:alias_tags=>@tag).all.must_equal [@album]
+    @Album.exclude(:t_tags=>@tag).all.must_equal [@album]
+    @Album.exclude(:alias_t_tags=>@tag).all.must_equal [@album]
     @album.add_tag(@tag)
-    @Album.filter(:tags=>@tag).all.should == [@album]
-    @Album.filter(:alias_tags=>@tag).all.should == [@album]
-    @Album.filter(:t_tags=>@tag).all.should == [@album]
-    @Album.filter(:alias_t_tags=>@tag).all.should == [@album]
+    @Album.filter(:tags=>@tag).all.must_equal [@album]
+    @Album.filter(:alias_tags=>@tag).all.must_equal [@album]
+    @Album.filter(:t_tags=>@tag).all.must_equal [@album]
+    @Album.filter(:alias_t_tags=>@tag).all.must_equal [@album]
     album, tag = @pr.call.values_at(0, 2)
-    @Album.exclude(:tags=>@tag).all.should == [album]
-    @Album.exclude(:alias_tags=>@tag).all.should == [album]
-    @Album.exclude(:t_tags=>@tag).all.should == [album]
-    @Album.exclude(:alias_t_tags=>@tag).all.should == [album]
-    @Album.exclude(:tags=>tag).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:alias_tags=>tag).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:t_tags=>tag).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:alias_t_tags=>tag).all.sort_by{|x| x.pk}.should == [@album, album]
+    @Album.exclude(:tags=>@tag).all.must_equal [album]
+    @Album.exclude(:alias_tags=>@tag).all.must_equal [album]
+    @Album.exclude(:t_tags=>@tag).all.must_equal [album]
+    @Album.exclude(:alias_t_tags=>@tag).all.must_equal [album]
+    @Album.exclude(:tags=>tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:alias_tags=>tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:t_tags=>tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:alias_t_tags=>tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
   end
 
-  specify "should work correctly when filtering by association datasets" do
+  it "should work correctly when filtering by association datasets" do
     album, artist, tag = @pr.call
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     album.add_tag(tag)
     album.update(:artist => artist)
 
-    @Artist.filter(:albums=>@Album).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Artist.filter(:albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [artist]
-    @Artist.filter(:albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Artist.filter(:first_album=>@Album).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Artist.filter(:first_album=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [artist]
-    @Artist.filter(:first_album=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Album.filter(:artist=>@Artist).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.filter(:artist=>@Artist.filter(Array(Artist.primary_key).map{|k| Sequel.qualify(Artist.table_name, k)}.zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.should == [album]
-    @Album.filter(:artist=>@Artist.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Album.filter(:tags=>@Tag).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.filter(:tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
-    @Album.filter(:tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Album.filter(:alias_tags=>@Tag).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.filter(:alias_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
-    @Album.filter(:alias_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Tag.filter(:albums=>@Album).all.sort_by{|x| x.pk}.should == [@tag, tag]
-    @Tag.filter(:albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [tag]
-    @Tag.filter(:albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+    @Artist.filter(:albums=>@Album).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Artist.filter(:albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [artist]
+    @Artist.filter(:albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Artist.filter(:first_album=>@Album).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Artist.filter(:first_album=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [artist]
+    @Artist.filter(:first_album=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Album.filter(:artist=>@Artist).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.filter(:artist=>@Artist.filter(Array(Artist.primary_key).map{|k| Sequel.qualify(Artist.table_name, k)}.zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.filter(:artist=>@Artist.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Album.filter(:tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.filter(:tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.filter(:tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Album.filter(:alias_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.filter(:alias_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.filter(:alias_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Tag.filter(:albums=>@Album).all.sort_by{|x| x.pk}.must_equal [@tag, tag]
+    @Tag.filter(:albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [tag]
+    @Tag.filter(:albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
 
     unless @no_many_through_many
-      @Artist.filter(:tags=>@Tag).all.sort_by{|x| x.pk}.should == [@artist, artist]
-      @Artist.filter(:tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [artist]
-      @Artist.filter(:tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-      @Artist.filter(:first_tag=>@Tag).all.sort_by{|x| x.pk}.should == [@artist, artist]
-      @Artist.filter(:first_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [artist]
-      @Artist.filter(:first_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+      @Artist.filter(:tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+      @Artist.filter(:tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [artist]
+      @Artist.filter(:tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+      @Artist.filter(:first_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+      @Artist.filter(:first_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [artist]
+      @Artist.filter(:first_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
     end
   end
 
-  specify "should work correctly when excluding by association datasets" do
+  it "should work correctly when excluding by association datasets" do
     album, artist, tag = @pr.call
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     album.add_tag(tag)
     album.update(:artist => artist)
 
-    @Artist.exclude(:albums=>@Album).all.sort_by{|x| x.pk}.should == []
-    @Artist.exclude(:albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
-    @Artist.exclude(:albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Artist.exclude(:first_album=>@Album).all.sort_by{|x| x.pk}.should == []
-    @Artist.exclude(:first_album=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
-    @Artist.exclude(:first_album=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Album.exclude(:artist=>@Artist).all.sort_by{|x| x.pk}.should == []
-    @Album.exclude(:artist=>@Artist.filter(Array(Artist.primary_key).map{|k| Sequel.qualify(Artist.table_name, k)}.zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.should == [@album]
-    @Album.exclude(:artist=>@Artist.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:tags=>@Tag).all.sort_by{|x| x.pk}.should == []
-    @Album.exclude(:tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@album]
-    @Album.exclude(:tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:alias_tags=>@Tag).all.sort_by{|x| x.pk}.should == []
-    @Album.exclude(:alias_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@album]
-    @Album.exclude(:alias_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Tag.exclude(:albums=>@Album).all.sort_by{|x| x.pk}.should == []
-    @Tag.exclude(:albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [@tag]
-    @Tag.exclude(:albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@tag, tag]
+    @Artist.exclude(:albums=>@Album).all.sort_by{|x| x.pk}.must_equal []
+    @Artist.exclude(:albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [@artist]
+    @Artist.exclude(:albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Artist.exclude(:first_album=>@Album).all.sort_by{|x| x.pk}.must_equal []
+    @Artist.exclude(:first_album=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [@artist]
+    @Artist.exclude(:first_album=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Album.exclude(:artist=>@Artist).all.sort_by{|x| x.pk}.must_equal []
+    @Album.exclude(:artist=>@Artist.filter(Array(Artist.primary_key).map{|k| Sequel.qualify(Artist.table_name, k)}.zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.must_equal [@album]
+    @Album.exclude(:artist=>@Artist.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:tags=>@Tag).all.sort_by{|x| x.pk}.must_equal []
+    @Album.exclude(:tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@album]
+    @Album.exclude(:tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:alias_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal []
+    @Album.exclude(:alias_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@album]
+    @Album.exclude(:alias_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Tag.exclude(:albums=>@Album).all.sort_by{|x| x.pk}.must_equal []
+    @Tag.exclude(:albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [@tag]
+    @Tag.exclude(:albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@tag, tag]
 
     unless @no_many_through_many
-      @Artist.exclude(:tags=>@Tag).all.sort_by{|x| x.pk}.should == []
-      @Artist.exclude(:tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
-      @Artist.exclude(:tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
-      @Artist.exclude(:first_tag=>@Tag).all.sort_by{|x| x.pk}.should == []
-      @Artist.exclude(:first_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
-      @Artist.exclude(:first_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
+      @Artist.exclude(:tags=>@Tag).all.sort_by{|x| x.pk}.must_equal []
+      @Artist.exclude(:tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@artist]
+      @Artist.exclude(:tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+      @Artist.exclude(:first_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal []
+      @Artist.exclude(:first_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@artist]
+      @Artist.exclude(:first_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
     end
   end
 
-  specify "should work correctly when filtering by association datasets with conditions" do
+  it "should work correctly when filtering by association datasets with conditions" do
     album, artist, tag = @pr.call
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     album.add_tag(tag)
     album.update(:artist => artist)
 
-    @Artist.filter(:a_albums=>@Album).all.sort_by{|x| x.pk}.should == [@artist]
-    @Artist.filter(:first_a_album=>@Album).all.sort_by{|x| x.pk}.should == [@artist]
-    @Album.filter(:a_artist=>@Artist).all.sort_by{|x| x.pk}.should == [@album]
-    @Album.filter(:t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [@album]
-    @Album.filter(:alias_t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [@album]
+    @Artist.filter(:a_albums=>@Album).all.sort_by{|x| x.pk}.must_equal [@artist]
+    @Artist.filter(:first_a_album=>@Album).all.sort_by{|x| x.pk}.must_equal [@artist]
+    @Album.filter(:a_artist=>@Artist).all.sort_by{|x| x.pk}.must_equal [@album]
+    @Album.filter(:t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album]
+    @Album.filter(:alias_t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album]
     unless @no_many_through_many
-      @Album.filter(:t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [@album]
-      @Album.filter(:alias_t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [@album]
-      @Artist.filter(:t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [@artist]
-      @Artist.filter(:t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [@artist]
+      @Album.filter(:t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album]
+      @Album.filter(:alias_t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album]
+      @Artist.filter(:t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@artist]
+      @Artist.filter(:t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [@artist]
     end
 
     artist.update(:name=>@artist.name)
     album.update(:name=>@album.name)
     tag.update(:name=>@tag.name)
 
-    @Artist.filter(:a_albums=>@Album).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Artist.filter(:first_a_album=>@Album).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Album.filter(:a_artist=>@Artist).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.filter(:t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.filter(:alias_t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [@album, album]
+    @Artist.filter(:a_albums=>@Album).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Artist.filter(:first_a_album=>@Album).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Album.filter(:a_artist=>@Artist).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.filter(:t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.filter(:alias_t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
     unless @no_many_through_many
-      @Album.filter(:t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [@album, album]
-      @Album.filter(:alias_t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [@album, album]
-      @Artist.filter(:t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [@artist, artist]
-      @Artist.filter(:t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [@artist, artist]
+      @Album.filter(:t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
+      @Album.filter(:alias_t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [@album, album]
+      @Artist.filter(:t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+      @Artist.filter(:t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
     end
 
-    @Artist.filter(:a_albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [artist]
-    @Artist.filter(:first_a_album=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [artist]
-    @Album.filter(:a_artist=>@Artist.filter(Array(Artist.primary_key).map{|k| Sequel.qualify(Artist.table_name, k)}.zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.should == [album]
-    @Album.filter(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
-    @Album.filter(:alias_t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
+    @Artist.filter(:a_albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [artist]
+    @Artist.filter(:first_a_album=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [artist]
+    @Album.filter(:a_artist=>@Artist.filter(Array(Artist.primary_key).map{|k| Sequel.qualify(Artist.table_name, k)}.zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.filter(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.filter(:alias_t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
     unless @no_many_through_many
-      @Album.filter(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
-      @Album.filter(:alias_t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
-      @Artist.filter(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [artist]
-      @Artist.filter(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [artist]
-    end
-
-    @Artist.filter(:a_albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Artist.filter(:first_a_album=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Album.filter(:a_artist=>@Artist.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Album.filter(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
-    @Album.filter(:t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-    @Album.filter(:alias_t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+      @Album.filter(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+      @Album.filter(:alias_t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+      @Artist.filter(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [artist]
+      @Artist.filter(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [artist]
+    end
+
+    @Artist.filter(:a_albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Artist.filter(:first_a_album=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Album.filter(:a_artist=>@Artist.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Album.filter(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.filter(:t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+    @Album.filter(:alias_t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
     unless @no_many_through_many
-      @Album.filter(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
-      @Album.filter(:t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-      @Album.filter(:alias_t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-      @Artist.filter(:t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
-      @Artist.filter(:t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+      @Album.filter(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [album]
+      @Album.filter(:t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+      @Album.filter(:alias_t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+      @Artist.filter(:t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
+      @Artist.filter(:t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal []
     end
   end
 
-  specify "should work correctly when excluding by association datasets with conditions" do
+  it "should work correctly when excluding by association datasets with conditions" do
     album, artist, tag = @pr.call
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     album.add_tag(tag)
     album.update(:artist => artist)
 
-    @Artist.exclude(:a_albums=>@Album).all.sort_by{|x| x.pk}.should == [artist]
-    @Artist.exclude(:first_a_album=>@Album).all.sort_by{|x| x.pk}.should == [artist]
-    @Album.exclude(:a_artist=>@Artist).all.sort_by{|x| x.pk}.should == [album]
-    @Album.exclude(:t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [album]
-    @Album.exclude(:alias_t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [album]
+    @Artist.exclude(:a_albums=>@Album).all.sort_by{|x| x.pk}.must_equal [artist]
+    @Artist.exclude(:first_a_album=>@Album).all.sort_by{|x| x.pk}.must_equal [artist]
+    @Album.exclude(:a_artist=>@Artist).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.exclude(:t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [album]
+    @Album.exclude(:alias_t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [album]
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [album]
-      @Album.exclude(:alias_t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [album]
-      @Artist.exclude(:t_tags=>@Tag).all.sort_by{|x| x.pk}.should == [artist]
-      @Artist.exclude(:t_tag=>@Tag).all.sort_by{|x| x.pk}.should == [artist]
+      @Album.exclude(:t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [album]
+      @Album.exclude(:alias_t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [album]
+      @Artist.exclude(:t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal [artist]
+      @Artist.exclude(:t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal [artist]
     end
 
     artist.update(:name=>@artist.name)
     album.update(:name=>@album.name)
     tag.update(:name=>@tag.name)
 
-    @Artist.exclude(:a_albums=>@Album).all.sort_by{|x| x.pk}.should == []
-    @Artist.exclude(:first_a_album=>@Album).all.sort_by{|x| x.pk}.should == []
-    @Album.exclude(:a_artist=>@Artist).all.sort_by{|x| x.pk}.should == []
-    @Album.exclude(:t_tags=>@Tag).all.sort_by{|x| x.pk}.should == []
-    @Album.exclude(:alias_t_tags=>@Tag).all.sort_by{|x| x.pk}.should == []
+    @Artist.exclude(:a_albums=>@Album).all.sort_by{|x| x.pk}.must_equal []
+    @Artist.exclude(:first_a_album=>@Album).all.sort_by{|x| x.pk}.must_equal []
+    @Album.exclude(:a_artist=>@Artist).all.sort_by{|x| x.pk}.must_equal []
+    @Album.exclude(:t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal []
+    @Album.exclude(:alias_t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal []
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>@Tag).all.sort_by{|x| x.pk}.should == []
-      @Album.exclude(:alias_t_tag=>@Tag).all.sort_by{|x| x.pk}.should == []
-      @Artist.exclude(:t_tags=>@Tag).all.sort_by{|x| x.pk}.should == []
-      @Artist.exclude(:t_tag=>@Tag).all.sort_by{|x| x.pk}.should == []
+      @Album.exclude(:t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal []
+      @Album.exclude(:alias_t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal []
+      @Artist.exclude(:t_tags=>@Tag).all.sort_by{|x| x.pk}.must_equal []
+      @Artist.exclude(:t_tag=>@Tag).all.sort_by{|x| x.pk}.must_equal []
     end
 
-    @Artist.exclude(:a_albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
-    @Artist.exclude(:first_a_album=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
-    @Album.exclude(:a_artist=>@Artist.filter(Array(Artist.primary_key).map{|k| Sequel.qualify(Artist.table_name, k)}.zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.should == [@album]
-    @Album.exclude(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@album]
-    @Album.exclude(:alias_t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@album]
+    @Artist.exclude(:a_albums=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [@artist]
+    @Artist.exclude(:first_a_album=>@Album.filter(Array(Album.primary_key).map{|k| Sequel.qualify(Album.table_name, k)}.zip(Array(album.pk)))).all.sort_by{|x| x.pk}.must_equal [@artist]
+    @Album.exclude(:a_artist=>@Artist.filter(Array(Artist.primary_key).map{|k| Sequel.qualify(Artist.table_name, k)}.zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.must_equal [@album]
+    @Album.exclude(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@album]
+    @Album.exclude(:alias_t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@album]
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@album]
-      @Album.exclude(:alias_t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@album]
-      @Artist.exclude(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
-      @Artist.exclude(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
+      @Album.exclude(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@album]
+      @Album.exclude(:alias_t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@album]
+      @Artist.exclude(:t_tags=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@artist]
+      @Artist.exclude(:t_tag=>@Tag.filter(Array(Tag.primary_key).map{|k| Sequel.qualify(Tag.table_name, k)}.zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.must_equal [@artist]
     end
 
-    @Artist.exclude(:a_albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Artist.exclude(:first_a_album=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
-    @Album.exclude(:a_artist=>@Artist.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
-    @Album.exclude(:alias_t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
+    @Artist.exclude(:a_albums=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Artist.exclude(:first_a_album=>@Album.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+    @Album.exclude(:a_artist=>@Artist.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@album, album]
+    @Album.exclude(:alias_t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@album, album]
     unless @no_many_through_many
-      @Album.exclude(:t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
-      @Album.exclude(:alias_t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
-      @Artist.exclude(:t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
-      @Artist.exclude(:t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
+      @Album.exclude(:t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@album, album]
+      @Album.exclude(:alias_t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@album, album]
+      @Artist.exclude(:t_tags=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
+      @Artist.exclude(:t_tag=>@Tag.filter(1=>0)).all.sort_by{|x| x.pk}.must_equal [@artist, artist]
     end
   end
 end
 
-shared_examples_for "filter by associations one_to_one limit strategies" do
-  specify "filter by associations with limited one_to_one associations should work correctly" do
+FilterByAssociationsOneToOneLimitStrategies = shared_description do
+  it "filter by associations with limited one_to_one associations should work correctly" do
     Artist.one_to_one :first_album, {:clone=>:first_album}.merge(@els)
     Artist.one_to_one :last_album, {:clone=>:last_album}.merge(@els)
     Artist.one_to_one :second_album, {:clone=>:second_album}.merge(@els)
@@ -1043,34 +1043,34 @@ shared_examples_for "filter by associations one_to_one limit strategies" do
     ar = @pr.call[1]
     ds = Artist.order(:name)
     
-    ds.where(:first_album=>@album).all.should == [@artist]
-    ds.where(:first_album=>diff_album).all.should == []
-    ds.exclude(:first_album=>@album).all.should == [ar]
-    ds.exclude(:first_album=>diff_album).all.should == [@artist, ar]
+    ds.where(:first_album=>@album).all.must_equal [@artist]
+    ds.where(:first_album=>diff_album).all.must_equal []
+    ds.exclude(:first_album=>@album).all.must_equal [ar]
+    ds.exclude(:first_album=>diff_album).all.must_equal [@artist, ar]
 
     if @els[:eager_limit_strategy] != :distinct_on && (@els[:eager_limit_strategy] != :correlated_subquery || Album.dataset.supports_offsets_in_correlated_subqueries?) 
-      ds.where(:second_album=>@album).all.should == []
-      ds.where(:second_album=>diff_album).all.should == [@artist]
-      ds.exclude(:second_album=>@album).all.should == [@artist, ar]
-      ds.exclude(:second_album=>diff_album).all.should == [ar]
+      ds.where(:second_album=>@album).all.must_equal []
+      ds.where(:second_album=>diff_album).all.must_equal [@artist]
+      ds.exclude(:second_album=>@album).all.must_equal [@artist, ar]
+      ds.exclude(:second_album=>diff_album).all.must_equal [ar]
     end
 
-    ds.where(:last_album=>@album).all.should == []
-    ds.where(:last_album=>diff_album).all.should == [@artist]
-    ds.exclude(:last_album=>@album).all.should == [@artist, ar]
-    ds.exclude(:last_album=>diff_album).all.should == [ar]
+    ds.where(:last_album=>@album).all.must_equal []
+    ds.where(:last_album=>diff_album).all.must_equal [@artist]
+    ds.exclude(:last_album=>@album).all.must_equal [@artist, ar]
+    ds.exclude(:last_album=>diff_album).all.must_equal [ar]
 
     Artist.one_to_one :first_album, :clone=>:first_album do |ads| ads.where(:albums__name=>diff_album.name) end
     ar.add_album(diff_album)
-    ds.where(:first_album=>[@album, diff_album]).all.should == [ar]
-    ds.exclude(:first_album=>[@album, diff_album]).all.should == [@artist]
+    ds.where(:first_album=>[@album, diff_album]).all.must_equal [ar]
+    ds.exclude(:first_album=>[@album, diff_album]).all.must_equal [@artist]
   end
 end
 
-shared_examples_for "filter by associations singular association limit strategies" do
-  it_should_behave_like "filter by associations one_to_one limit strategies"
+FilterByAssociationsSingularLimitStrategies = shared_description do
+  include FilterByAssociationsOneToOneLimitStrategies
 
-  specify "dataset associations with limited one_to_one associations should work correctly" do
+  it "dataset associations with limited one_to_one associations should work correctly" do
     Artist.one_to_one :first_album, {:clone=>:first_album}.merge(@els)
     Artist.one_to_one :last_album, {:clone=>:last_album}.merge(@els)
     Artist.one_to_one :second_album, {:clone=>:second_album}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
@@ -1079,20 +1079,20 @@ shared_examples_for "filter by associations singular association limit strategie
     ar = @pr.call[1]
     ds = Artist
     
-    ds.where(@artist.pk_hash).first_albums.all.should == [@album]
-    ds.where(@artist.pk_hash).second_albums.all.should == [diff_album]
-    ds.where(@artist.pk_hash).last_albums.all.should == [diff_album]
-    ds.where(ar.pk_hash).first_albums.all.should == []
-    ds.where(ar.pk_hash).second_albums.all.should == []
-    ds.where(ar.pk_hash).last_albums.all.should == []
+    ds.where(@artist.pk_hash).first_albums.all.must_equal [@album]
+    ds.where(@artist.pk_hash).second_albums.all.must_equal [diff_album]
+    ds.where(@artist.pk_hash).last_albums.all.must_equal [diff_album]
+    ds.where(ar.pk_hash).first_albums.all.must_equal []
+    ds.where(ar.pk_hash).second_albums.all.must_equal []
+    ds.where(ar.pk_hash).last_albums.all.must_equal []
 
     Artist.one_to_one :first_album, :clone=>:first_album do |ads| ads.where(:albums__name=>diff_album.name) end
     ar.add_album(diff_album)
-    ds.where(@artist.pk_hash).first_albums.all.should == []
-    ds.where(ar.pk_hash).first_albums.all.should == [diff_album]
+    ds.where(@artist.pk_hash).first_albums.all.must_equal []
+    ds.where(ar.pk_hash).first_albums.all.must_equal [diff_album]
   end
 
-  specify "filter by associations with limited one_through_one associations should work correctly" do
+  it "filter by associations with limited one_through_one associations should work correctly" do
     Album.one_through_one :first_tag, {:clone=>:first_tag}.merge(@els)
     Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     Album.one_through_one :last_tag, {:clone=>:last_tag}.merge(@els)
@@ -1101,39 +1101,39 @@ shared_examples_for "filter by associations singular association limit strategie
     ds = Album.order(:name)
     al.add_tag(tu)
     
-    ds.where(:first_tag=>@tag).all.should == [@album]
-    ds.where(:first_tag=>tu).all.should == [al]
-    ds.where(:first_tag=>tv).all.should == []
-    ds.exclude(:first_tag=>@tag).all.should == [al]
-    ds.exclude(:first_tag=>tu).all.should == [@album]
-    ds.exclude(:first_tag=>tv).all.should == [@album, al]
-
-    ds.where(:second_tag=>@tag).all.should == []
-    ds.where(:second_tag=>tu).all.should == [@album]
-    ds.where(:second_tag=>tv).all.should == []
-    ds.exclude(:second_tag=>@tag).all.should == [@album, al]
-    ds.exclude(:second_tag=>tu).all.should == [al]
-    ds.exclude(:second_tag=>tv).all.should == [@album, al]
-
-    ds.where(:last_tag=>@tag).all.should == []
-    ds.where(:last_tag=>tu).all.should == [al]
-    ds.where(:last_tag=>tv).all.should == [@album]
-    ds.exclude(:last_tag=>@tag).all.should == [@album, al]
-    ds.exclude(:last_tag=>tu).all.should == [@album]
-    ds.exclude(:last_tag=>tv).all.should == [al]
+    ds.where(:first_tag=>@tag).all.must_equal [@album]
+    ds.where(:first_tag=>tu).all.must_equal [al]
+    ds.where(:first_tag=>tv).all.must_equal []
+    ds.exclude(:first_tag=>@tag).all.must_equal [al]
+    ds.exclude(:first_tag=>tu).all.must_equal [@album]
+    ds.exclude(:first_tag=>tv).all.must_equal [@album, al]
+
+    ds.where(:second_tag=>@tag).all.must_equal []
+    ds.where(:second_tag=>tu).all.must_equal [@album]
+    ds.where(:second_tag=>tv).all.must_equal []
+    ds.exclude(:second_tag=>@tag).all.must_equal [@album, al]
+    ds.exclude(:second_tag=>tu).all.must_equal [al]
+    ds.exclude(:second_tag=>tv).all.must_equal [@album, al]
+
+    ds.where(:last_tag=>@tag).all.must_equal []
+    ds.where(:last_tag=>tu).all.must_equal [al]
+    ds.where(:last_tag=>tv).all.must_equal [@album]
+    ds.exclude(:last_tag=>@tag).all.must_equal [@album, al]
+    ds.exclude(:last_tag=>tu).all.must_equal [@album]
+    ds.exclude(:last_tag=>tv).all.must_equal [al]
 
     Album.one_through_one :first_tag, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
     Album.one_through_one :second_tag, :clone=>:second_tag do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
 
-    ds.where(:first_tag=>[@tag, tu]).all.should == [@album, al]
-    ds.exclude(:first_tag=>[@tag, tu]).all.should == []
+    ds.where(:first_tag=>[@tag, tu]).all.must_equal [@album, al]
+    ds.exclude(:first_tag=>[@tag, tu]).all.must_equal []
 
     al.add_tag(tv)
-    ds.where(:second_tag=>[tv, tu]).all.should == [@album, al]
-    ds.exclude(:second_tag=>[tv, tu]).all.should == []
+    ds.where(:second_tag=>[tv, tu]).all.must_equal [@album, al]
+    ds.exclude(:second_tag=>[tv, tu]).all.must_equal []
   end
 
-  specify "dataset associations with limited one_through_one associations should work correctly" do
+  it "dataset associations with limited one_through_one associations should work correctly" do
     Album.one_through_one :first_tag, {:clone=>:first_tag}.merge(@els)
     Album.one_through_one :second_tag, {:clone=>:second_tag}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     Album.one_through_one :last_tag, {:clone=>:last_tag}.merge(@els)
@@ -1142,29 +1142,29 @@ shared_examples_for "filter by associations singular association limit strategie
     ds = Album
     al.add_tag(tu)
     
-    ds.where(@album.pk_hash).first_tags.all.should == [@tag]
-    ds.where(@album.pk_hash).second_tags.all.should == [tu]
-    ds.where(@album.pk_hash).last_tags.all.should == [tv]
-    ds.where(al.pk_hash).first_tags.all.should == [tu]
-    ds.where(al.pk_hash).second_tags.all.should == []
-    ds.where(al.pk_hash).last_tags.all.should == [tu]
+    ds.where(@album.pk_hash).first_tags.all.must_equal [@tag]
+    ds.where(@album.pk_hash).second_tags.all.must_equal [tu]
+    ds.where(@album.pk_hash).last_tags.all.must_equal [tv]
+    ds.where(al.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(al.pk_hash).second_tags.all.must_equal []
+    ds.where(al.pk_hash).last_tags.all.must_equal [tu]
 
     Album.one_through_one :first_tag, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
     Album.one_through_one :second_tag, :clone=>:second_tag do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
 
-    ds.where(@album.pk_hash).first_tags.all.should == [tu]
-    ds.where(@album.pk_hash).second_tags.all.should == [tv]
-    ds.where(al.pk_hash).first_tags.all.should == [tu]
-    ds.where(al.pk_hash).second_tags.all.should == []
+    ds.where(@album.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(@album.pk_hash).second_tags.all.must_equal [tv]
+    ds.where(al.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(al.pk_hash).second_tags.all.must_equal []
 
     al.add_tag(tv)
-    ds.where(@album.pk_hash).first_tags.all.should == [tu]
-    ds.where(@album.pk_hash).second_tags.all.should == [tv]
-    ds.where(al.pk_hash).first_tags.all.should == [tu]
-    ds.where(al.pk_hash).second_tags.all.should == [tv]
+    ds.where(@album.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(@album.pk_hash).second_tags.all.must_equal [tv]
+    ds.where(al.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(al.pk_hash).second_tags.all.must_equal [tv]
   end
 
-  specify "filter by associations with limited one_through_many associations should work correctly" do
+  it "filter by associations with limited one_through_many associations should work correctly" do
     Artist.one_through_many :first_tag, {:clone=>:first_tag}.merge(@els)
     Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     Artist.one_through_many :last_tag, {:clone=>:last_tag}.merge(@els)
@@ -1175,39 +1175,39 @@ shared_examples_for "filter by associations singular association limit strategie
     al.add_tag(tu)
     ds = Artist.order(:name)
 
-    ds.where(:first_tag=>@tag).all.should == [@artist]
-    ds.where(:first_tag=>tu).all.should == [ar]
-    ds.where(:first_tag=>tv).all.should == []
-    ds.exclude(:first_tag=>@tag).all.should == [ar]
-    ds.exclude(:first_tag=>tu).all.should == [@artist]
-    ds.exclude(:first_tag=>tv).all.should == [@artist, ar]
-
-    ds.where(:second_tag=>@tag).all.should == []
-    ds.where(:second_tag=>tu).all.should == [@artist]
-    ds.where(:second_tag=>tv).all.should == []
-    ds.exclude(:second_tag=>@tag).all.should == [@artist, ar]
-    ds.exclude(:second_tag=>tu).all.should == [ar]
-    ds.exclude(:second_tag=>tv).all.should == [@artist, ar]
-
-    ds.where(:last_tag=>@tag).all.should == []
-    ds.where(:last_tag=>tu).all.should == [ar]
-    ds.where(:last_tag=>tv).all.should == [@artist]
-    ds.exclude(:last_tag=>@tag).all.should == [@artist, ar]
-    ds.exclude(:last_tag=>tu).all.should == [@artist]
-    ds.exclude(:last_tag=>tv).all.should == [ar]
+    ds.where(:first_tag=>@tag).all.must_equal [@artist]
+    ds.where(:first_tag=>tu).all.must_equal [ar]
+    ds.where(:first_tag=>tv).all.must_equal []
+    ds.exclude(:first_tag=>@tag).all.must_equal [ar]
+    ds.exclude(:first_tag=>tu).all.must_equal [@artist]
+    ds.exclude(:first_tag=>tv).all.must_equal [@artist, ar]
+
+    ds.where(:second_tag=>@tag).all.must_equal []
+    ds.where(:second_tag=>tu).all.must_equal [@artist]
+    ds.where(:second_tag=>tv).all.must_equal []
+    ds.exclude(:second_tag=>@tag).all.must_equal [@artist, ar]
+    ds.exclude(:second_tag=>tu).all.must_equal [ar]
+    ds.exclude(:second_tag=>tv).all.must_equal [@artist, ar]
+
+    ds.where(:last_tag=>@tag).all.must_equal []
+    ds.where(:last_tag=>tu).all.must_equal [ar]
+    ds.where(:last_tag=>tv).all.must_equal [@artist]
+    ds.exclude(:last_tag=>@tag).all.must_equal [@artist, ar]
+    ds.exclude(:last_tag=>tu).all.must_equal [@artist]
+    ds.exclude(:last_tag=>tv).all.must_equal [ar]
 
     Artist.one_through_many :first_tag, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
     Artist.one_through_many :second_tag, :clone=>:second_tag do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
 
-    ds.where(:first_tag=>[@tag, tu]).all.should == [@artist, ar]
-    ds.exclude(:first_tag=>[@tag, tu]).all.should == []
+    ds.where(:first_tag=>[@tag, tu]).all.must_equal [@artist, ar]
+    ds.exclude(:first_tag=>[@tag, tu]).all.must_equal []
 
     al.add_tag(tv)
-    ds.where(:second_tag=>[tv, tu]).all.should == [@artist, ar]
-    ds.exclude(:second_tag=>[tv, tu]).all.should == []
+    ds.where(:second_tag=>[tv, tu]).all.must_equal [@artist, ar]
+    ds.exclude(:second_tag=>[tv, tu]).all.must_equal []
   end
 
-  specify "dataset associations with limited one_through_many associations should work correctly" do
+  it "dataset associations with limited one_through_many associations should work correctly" do
     Artist.one_through_many :first_tag, {:clone=>:first_tag}.merge(@els)
     Artist.one_through_many :second_tag, {:clone=>:second_tag}.merge(@els) if @els[:eager_limit_strategy] != :distinct_on
     Artist.one_through_many :last_tag, {:clone=>:last_tag}.merge(@els)
@@ -1218,31 +1218,31 @@ shared_examples_for "filter by associations singular association limit strategie
     al.add_tag(tu)
     ds = Artist.order(:name)
 
-    ds.where(@artist.pk_hash).first_tags.all.should == [@tag]
-    ds.where(@artist.pk_hash).second_tags.all.should == [tu]
-    ds.where(@artist.pk_hash).last_tags.all.should == [tv]
-    ds.where(ar.pk_hash).first_tags.all.should == [tu]
-    ds.where(ar.pk_hash).second_tags.all.should == []
-    ds.where(ar.pk_hash).last_tags.all.should == [tu]
+    ds.where(@artist.pk_hash).first_tags.all.must_equal [@tag]
+    ds.where(@artist.pk_hash).second_tags.all.must_equal [tu]
+    ds.where(@artist.pk_hash).last_tags.all.must_equal [tv]
+    ds.where(ar.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(ar.pk_hash).second_tags.all.must_equal []
+    ds.where(ar.pk_hash).last_tags.all.must_equal [tu]
 
     Artist.one_through_many :first_tag, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
     Artist.one_through_many :second_tag, :clone=>:second_tag do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
 
-    ds.where(@artist.pk_hash).first_tags.all.should == [tu]
-    ds.where(@artist.pk_hash).second_tags.all.should == [tv]
-    ds.where(ar.pk_hash).first_tags.all.should == [tu]
-    ds.where(ar.pk_hash).second_tags.all.should == []
+    ds.where(@artist.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(@artist.pk_hash).second_tags.all.must_equal [tv]
+    ds.where(ar.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(ar.pk_hash).second_tags.all.must_equal []
 
     al.add_tag(tv)
-    ds.where(@artist.pk_hash).first_tags.all.should == [tu]
-    ds.where(@artist.pk_hash).second_tags.all.should == [tv]
-    ds.where(ar.pk_hash).first_tags.all.should == [tu]
-    ds.where(ar.pk_hash).second_tags.all.should == [tv]
+    ds.where(@artist.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(@artist.pk_hash).second_tags.all.must_equal [tv]
+    ds.where(ar.pk_hash).first_tags.all.must_equal [tu]
+    ds.where(ar.pk_hash).second_tags.all.must_equal [tv]
   end
 end
 
-shared_examples_for "filter by associations one_to_many limit strategies" do
-  specify "filter by associations with limited one_to_many associations should work correctly" do
+FilterByAssociationsOneToManyLimitStrategies = shared_description do
+  it "filter by associations with limited one_to_many associations should work correctly" do
     Artist.one_to_many :first_two_albums, {:clone=>:first_two_albums}.merge(@els)
     Artist.one_to_many :second_two_albums, {:clone=>:second_two_albums}.merge(@els)
     Artist.one_to_many :not_first_albums, {:clone=>:not_first_albums}.merge(@els)
@@ -1253,12 +1253,12 @@ shared_examples_for "filter by associations one_to_many limit strategies" do
     ar = @pr.call[1]
     ds = Artist.order(:name)
 
-    ds.where(:first_two_albums=>@album).all.should == [@artist]
-    ds.where(:first_two_albums=>middle_album).all.should == [@artist]
-    ds.where(:first_two_albums=>diff_album).all.should == []
-    ds.exclude(:first_two_albums=>@album).all.should == [ar]
-    ds.exclude(:first_two_albums=>middle_album).all.should == [ar]
-    ds.exclude(:first_two_albums=>diff_album).all.should == [@artist, ar]
+    ds.where(:first_two_albums=>@album).all.must_equal [@artist]
+    ds.where(:first_two_albums=>middle_album).all.must_equal [@artist]
+    ds.where(:first_two_albums=>diff_album).all.must_equal []
+    ds.exclude(:first_two_albums=>@album).all.must_equal [ar]
+    ds.exclude(:first_two_albums=>middle_album).all.must_equal [ar]
+    ds.exclude(:first_two_albums=>diff_album).all.must_equal [@artist, ar]
     
     assocs = if @els[:eager_limit_strategy] != :correlated_subquery || Album.dataset.supports_offsets_in_correlated_subqueries?
       [:second_two_albums, :not_first_albums, :last_two_albums]
@@ -1267,26 +1267,26 @@ shared_examples_for "filter by associations one_to_many limit strategies" do
     end
 
     assocs.each do |a|
-      ds.where(a=>@album).all.should == []
-      ds.where(a=>middle_album).all.should == [@artist]
-      ds.where(a=>diff_album).all.should == [@artist]
-      ds.exclude(a=>@album).all.should == [@artist, ar]
-      ds.exclude(a=>middle_album).all.should == [ar]
-      ds.exclude(a=>diff_album).all.should == [ar]
+      ds.where(a=>@album).all.must_equal []
+      ds.where(a=>middle_album).all.must_equal [@artist]
+      ds.where(a=>diff_album).all.must_equal [@artist]
+      ds.exclude(a=>@album).all.must_equal [@artist, ar]
+      ds.exclude(a=>middle_album).all.must_equal [ar]
+      ds.exclude(a=>diff_album).all.must_equal [ar]
     end
 
     Artist.one_to_one :first_two_albums, :clone=>:first_two_albums do |ads| ads.where(:albums__name=>diff_album.name) end
     ar.add_album(diff_album)
-    ds.where(:first_two_albums=>[@album, diff_album]).all.should == [ar]
-    ds.exclude(:first_two_albums=>[@album, diff_album]).all.should == [@artist]
+    ds.where(:first_two_albums=>[@album, diff_album]).all.must_equal [ar]
+    ds.exclude(:first_two_albums=>[@album, diff_album]).all.must_equal [@artist]
   end
 end
 
-shared_examples_for "filter by associations limit strategies" do
-  it_should_behave_like "filter by associations singular association limit strategies"
-  it_should_behave_like "filter by associations one_to_many limit strategies"
+FilterByAssociationsLimitStrategies = shared_description do
+  include FilterByAssociationsSingularLimitStrategies
+  include FilterByAssociationsOneToManyLimitStrategies
 
-  specify "dataset associations with limited one_to_many associations should work correctly" do
+  it "dataset associations with limited one_to_many associations should work correctly" do
     Artist.one_to_many :first_two_albums, {:clone=>:first_two_albums}.merge(@els)
     Artist.one_to_many :second_two_albums, {:clone=>:second_two_albums}.merge(@els)
     Artist.one_to_many :not_first_albums, {:clone=>:not_first_albums}.merge(@els)
@@ -1297,22 +1297,22 @@ shared_examples_for "filter by associations limit strategies" do
     ar = @pr.call[1]
     ds = Artist.order(:name)
 
-    ds.where(@artist.pk_hash).first_two_albums.all.should == [@album, middle_album]
-    ds.where(@artist.pk_hash).second_two_albums.all.should == [middle_album, diff_album]
-    ds.where(@artist.pk_hash).not_first_albums.all.should == [middle_album, diff_album]
-    ds.where(@artist.pk_hash).last_two_albums.all.should == [diff_album, middle_album]
-    ds.where(ar.pk_hash).first_two_albums.all.should == []
-    ds.where(ar.pk_hash).second_two_albums.all.should == []
-    ds.where(ar.pk_hash).not_first_albums.all.should == []
-    ds.where(ar.pk_hash).last_two_albums.all.should == []
+    ds.where(@artist.pk_hash).first_two_albums.all.must_equal [@album, middle_album]
+    ds.where(@artist.pk_hash).second_two_albums.all.must_equal [middle_album, diff_album]
+    ds.where(@artist.pk_hash).not_first_albums.all.must_equal [middle_album, diff_album]
+    ds.where(@artist.pk_hash).last_two_albums.all.must_equal [diff_album, middle_album]
+    ds.where(ar.pk_hash).first_two_albums.all.must_equal []
+    ds.where(ar.pk_hash).second_two_albums.all.must_equal []
+    ds.where(ar.pk_hash).not_first_albums.all.must_equal []
+    ds.where(ar.pk_hash).last_two_albums.all.must_equal []
 
     Artist.one_to_one :first_two_albums, :clone=>:first_two_albums do |ads| ads.where(:albums__name=>[diff_album.name, middle_album.name]) end
     ar.add_album(diff_album)
-    ds.where(@artist.pk_hash).first_two_albums.all.should == [middle_album]
-    ds.where(ar.pk_hash).first_two_albums.all.should == [diff_album]
+    ds.where(@artist.pk_hash).first_two_albums.all.must_equal [middle_album]
+    ds.where(ar.pk_hash).first_two_albums.all.must_equal [diff_album]
   end
 
-  specify "filter by associations with limited many_to_many associations should work correctly" do
+  it "filter by associations with limited many_to_many associations should work correctly" do
     Album.send :many_to_many, :first_two_tags, {:clone=>:first_two_tags}.merge(@els)
     Album.send :many_to_many, :second_two_tags, {:clone=>:second_two_tags}.merge(@els)
     Album.send :many_to_many, :not_first_tags, {:clone=>:not_first_tags}.merge(@els)
@@ -1322,46 +1322,46 @@ shared_examples_for "filter by associations limit strategies" do
     al.add_tag(tu)
     ds = Album.order(:name)
     
-    ds.where(:first_two_tags=>@tag).all.should == [@album]
-    ds.where(:first_two_tags=>tu).all.should == [@album, al]
-    ds.where(:first_two_tags=>tv).all.should == []
-    ds.exclude(:first_two_tags=>@tag).all.should == [al]
-    ds.exclude(:first_two_tags=>tu).all.should == []
-    ds.exclude(:first_two_tags=>tv).all.should == [@album, al]
-
-    ds.where(:second_two_tags=>@tag).all.should == []
-    ds.where(:second_two_tags=>tu).all.should == [@album]
-    ds.where(:second_two_tags=>tv).all.should == [@album]
-    ds.exclude(:second_two_tags=>@tag).all.should == [@album, al]
-    ds.exclude(:second_two_tags=>tu).all.should == [al]
-    ds.exclude(:second_two_tags=>tv).all.should == [al]
-
-    ds.where(:not_first_tags=>@tag).all.should == []
-    ds.where(:not_first_tags=>tu).all.should == [@album]
-    ds.where(:not_first_tags=>tv).all.should == [@album]
-    ds.exclude(:not_first_tags=>@tag).all.should == [@album, al]
-    ds.exclude(:not_first_tags=>tu).all.should == [al]
-    ds.exclude(:not_first_tags=>tv).all.should == [al]
-
-    ds.where(:last_two_tags=>@tag).all.should == []
-    ds.where(:last_two_tags=>tu).all.should == [@album, al]
-    ds.where(:last_two_tags=>tv).all.should == [@album]
-    ds.exclude(:last_two_tags=>@tag).all.should == [@album, al]
-    ds.exclude(:last_two_tags=>tu).all.should == []
-    ds.exclude(:last_two_tags=>tv).all.should == [al]
+    ds.where(:first_two_tags=>@tag).all.must_equal [@album]
+    ds.where(:first_two_tags=>tu).all.must_equal [@album, al]
+    ds.where(:first_two_tags=>tv).all.must_equal []
+    ds.exclude(:first_two_tags=>@tag).all.must_equal [al]
+    ds.exclude(:first_two_tags=>tu).all.must_equal []
+    ds.exclude(:first_two_tags=>tv).all.must_equal [@album, al]
+
+    ds.where(:second_two_tags=>@tag).all.must_equal []
+    ds.where(:second_two_tags=>tu).all.must_equal [@album]
+    ds.where(:second_two_tags=>tv).all.must_equal [@album]
+    ds.exclude(:second_two_tags=>@tag).all.must_equal [@album, al]
+    ds.exclude(:second_two_tags=>tu).all.must_equal [al]
+    ds.exclude(:second_two_tags=>tv).all.must_equal [al]
+
+    ds.where(:not_first_tags=>@tag).all.must_equal []
+    ds.where(:not_first_tags=>tu).all.must_equal [@album]
+    ds.where(:not_first_tags=>tv).all.must_equal [@album]
+    ds.exclude(:not_first_tags=>@tag).all.must_equal [@album, al]
+    ds.exclude(:not_first_tags=>tu).all.must_equal [al]
+    ds.exclude(:not_first_tags=>tv).all.must_equal [al]
+
+    ds.where(:last_two_tags=>@tag).all.must_equal []
+    ds.where(:last_two_tags=>tu).all.must_equal [@album, al]
+    ds.where(:last_two_tags=>tv).all.must_equal [@album]
+    ds.exclude(:last_two_tags=>@tag).all.must_equal [@album, al]
+    ds.exclude(:last_two_tags=>tu).all.must_equal []
+    ds.exclude(:last_two_tags=>tv).all.must_equal [al]
 
     Album.many_to_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(:tags__name=>tu.name) end
     Album.many_to_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
 
-    ds.where(:first_two_tags=>[@tag, tu]).all.should == [@album, al]
-    ds.exclude(:first_two_tags=>[@tag, tu]).all.should == []
+    ds.where(:first_two_tags=>[@tag, tu]).all.must_equal [@album, al]
+    ds.exclude(:first_two_tags=>[@tag, tu]).all.must_equal []
 
     al.add_tag(tv)
-    ds.where(:second_two_tags=>[tv, tu]).all.should == [@album, al]
-    ds.exclude(:second_two_tags=>[tv, tu]).all.should == []
+    ds.where(:second_two_tags=>[tv, tu]).all.must_equal [@album, al]
+    ds.exclude(:second_two_tags=>[tv, tu]).all.must_equal []
   end
 
-  specify "dataset associations with limited many_to_many associations should work correctly" do
+  it "dataset associations with limited many_to_many associations should work correctly" do
     Album.send :many_to_many, :first_two_tags, {:clone=>:first_two_tags}.merge(@els)
     Album.send :many_to_many, :second_two_tags, {:clone=>:second_two_tags}.merge(@els)
     Album.send :many_to_many, :not_first_tags, {:clone=>:not_first_tags}.merge(@els)
@@ -1371,31 +1371,31 @@ shared_examples_for "filter by associations limit strategies" do
     al.add_tag(tu)
     ds = Album.order(:name)
     
-    ds.where(@album.pk_hash).first_two_tags.all.should == [@tag, tu]
-    ds.where(@album.pk_hash).second_two_tags.all.should == [tu, tv]
-    ds.where(@album.pk_hash).not_first_tags.all.should == [tu, tv]
-    ds.where(@album.pk_hash).last_two_tags.all.should == [tv, tu]
-    ds.where(al.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(al.pk_hash).second_two_tags.all.should == []
-    ds.where(al.pk_hash).not_first_tags.all.should == []
-    ds.where(al.pk_hash).last_two_tags.all.should == [tu]
+    ds.where(@album.pk_hash).first_two_tags.all.must_equal [@tag, tu]
+    ds.where(@album.pk_hash).second_two_tags.all.must_equal [tu, tv]
+    ds.where(@album.pk_hash).not_first_tags.all.must_equal [tu, tv]
+    ds.where(@album.pk_hash).last_two_tags.all.must_equal [tv, tu]
+    ds.where(al.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(al.pk_hash).second_two_tags.all.must_equal []
+    ds.where(al.pk_hash).not_first_tags.all.must_equal []
+    ds.where(al.pk_hash).last_two_tags.all.must_equal [tu]
 
     Album.many_to_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(:tags__name=>tu.name) end
     Album.many_to_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
 
-    ds.where(@album.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(@album.pk_hash).second_two_tags.all.should == [tv]
-    ds.where(al.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(al.pk_hash).second_two_tags.all.should == []
+    ds.where(@album.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(@album.pk_hash).second_two_tags.all.must_equal [tv]
+    ds.where(al.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(al.pk_hash).second_two_tags.all.must_equal []
 
     al.add_tag(tv)
-    ds.where(@album.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(@album.pk_hash).second_two_tags.all.should == [tv]
-    ds.where(al.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(al.pk_hash).second_two_tags.all.should == [tv]
+    ds.where(@album.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(@album.pk_hash).second_two_tags.all.must_equal [tv]
+    ds.where(al.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(al.pk_hash).second_two_tags.all.must_equal [tv]
   end
 
-  specify "filter by associations with limited many_through_many associations should work correctly" do
+  it "filter by associations with limited many_through_many associations should work correctly" do
     Artist.many_through_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els)
     Artist.many_through_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els)
     Artist.many_through_many :not_first_tags, {:clone=>:not_first_tags}.merge(@els)
@@ -1407,46 +1407,46 @@ shared_examples_for "filter by associations limit strategies" do
     al.add_tag(tu)
     ds = Artist.order(:name)
     
-    ds.where(:first_two_tags=>@tag).all.should == [@artist]
-    ds.where(:first_two_tags=>tu).all.should == [@artist, ar]
-    ds.where(:first_two_tags=>tv).all.should == []
-    ds.exclude(:first_two_tags=>@tag).all.should == [ar]
-    ds.exclude(:first_two_tags=>tu).all.should == []
-    ds.exclude(:first_two_tags=>tv).all.should == [@artist, ar]
-
-    ds.where(:second_two_tags=>@tag).all.should == []
-    ds.where(:second_two_tags=>tu).all.should == [@artist]
-    ds.where(:second_two_tags=>tv).all.should == [@artist]
-    ds.exclude(:second_two_tags=>@tag).all.should == [@artist, ar]
-    ds.exclude(:second_two_tags=>tu).all.should == [ar]
-    ds.exclude(:second_two_tags=>tv).all.should == [ar]
-
-    ds.where(:not_first_tags=>@tag).all.should == []
-    ds.where(:not_first_tags=>tu).all.should == [@artist]
-    ds.where(:not_first_tags=>tv).all.should == [@artist]
-    ds.exclude(:not_first_tags=>@tag).all.should == [@artist, ar]
-    ds.exclude(:not_first_tags=>tu).all.should == [ar]
-    ds.exclude(:not_first_tags=>tv).all.should == [ar]
-
-    ds.where(:last_two_tags=>@tag).all.should == []
-    ds.where(:last_two_tags=>tu).all.should == [@artist, ar]
-    ds.where(:last_two_tags=>tv).all.should == [@artist]
-    ds.exclude(:last_two_tags=>@tag).all.should == [@artist, ar]
-    ds.exclude(:last_two_tags=>tu).all.should == []
-    ds.exclude(:last_two_tags=>tv).all.should == [ar]
+    ds.where(:first_two_tags=>@tag).all.must_equal [@artist]
+    ds.where(:first_two_tags=>tu).all.must_equal [@artist, ar]
+    ds.where(:first_two_tags=>tv).all.must_equal []
+    ds.exclude(:first_two_tags=>@tag).all.must_equal [ar]
+    ds.exclude(:first_two_tags=>tu).all.must_equal []
+    ds.exclude(:first_two_tags=>tv).all.must_equal [@artist, ar]
+
+    ds.where(:second_two_tags=>@tag).all.must_equal []
+    ds.where(:second_two_tags=>tu).all.must_equal [@artist]
+    ds.where(:second_two_tags=>tv).all.must_equal [@artist]
+    ds.exclude(:second_two_tags=>@tag).all.must_equal [@artist, ar]
+    ds.exclude(:second_two_tags=>tu).all.must_equal [ar]
+    ds.exclude(:second_two_tags=>tv).all.must_equal [ar]
+
+    ds.where(:not_first_tags=>@tag).all.must_equal []
+    ds.where(:not_first_tags=>tu).all.must_equal [@artist]
+    ds.where(:not_first_tags=>tv).all.must_equal [@artist]
+    ds.exclude(:not_first_tags=>@tag).all.must_equal [@artist, ar]
+    ds.exclude(:not_first_tags=>tu).all.must_equal [ar]
+    ds.exclude(:not_first_tags=>tv).all.must_equal [ar]
+
+    ds.where(:last_two_tags=>@tag).all.must_equal []
+    ds.where(:last_two_tags=>tu).all.must_equal [@artist, ar]
+    ds.where(:last_two_tags=>tv).all.must_equal [@artist]
+    ds.exclude(:last_two_tags=>@tag).all.must_equal [@artist, ar]
+    ds.exclude(:last_two_tags=>tu).all.must_equal []
+    ds.exclude(:last_two_tags=>tv).all.must_equal [ar]
 
     Artist.many_through_many :first_two_tags, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
     Artist.many_through_many :second_two_tags, :clone=>:first_tag do |ads| ads.where(:tags__name=>[tv.name, tu.name]) end
 
-    ds.where(:first_two_tags=>[@tag, tu]).all.should == [@artist, ar]
-    ds.exclude(:first_two_tags=>[@tag, tu]).all.should == []
+    ds.where(:first_two_tags=>[@tag, tu]).all.must_equal [@artist, ar]
+    ds.exclude(:first_two_tags=>[@tag, tu]).all.must_equal []
 
     al.add_tag(tv)
-    ds.where(:second_two_tags=>[tv, tu]).all.should == [@artist, ar]
-    ds.exclude(:second_two_tags=>[tv, tu]).all.should == []
+    ds.where(:second_two_tags=>[tv, tu]).all.must_equal [@artist, ar]
+    ds.exclude(:second_two_tags=>[tv, tu]).all.must_equal []
   end
 
-  specify "dataset associations with limited many_through_many associations should work correctly" do
+  it "dataset associations with limited many_through_many associations should work correctly" do
     Artist.many_through_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els)
     Artist.many_through_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els)
     Artist.many_through_many :not_first_tags, {:clone=>:not_first_tags}.merge(@els)
@@ -1458,42 +1458,52 @@ shared_examples_for "filter by associations limit strategies" do
     al.add_tag(tu)
     ds = Artist.order(:name)
     
-    ds.where(@artist.pk_hash).first_two_tags.all.should == [@tag, tu]
-    ds.where(@artist.pk_hash).second_two_tags.all.should == [tu, tv]
-    ds.where(@artist.pk_hash).not_first_tags.all.should == [tu, tv]
-    ds.where(@artist.pk_hash).last_two_tags.all.should == [tv, tu]
-    ds.where(ar.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(ar.pk_hash).second_two_tags.all.should == []
-    ds.where(ar.pk_hash).not_first_tags.all.should == []
-    ds.where(ar.pk_hash).last_two_tags.all.should == [tu]
+    ds.where(@artist.pk_hash).first_two_tags.all.must_equal [@tag, tu]
+    ds.where(@artist.pk_hash).second_two_tags.all.must_equal [tu, tv]
+    ds.where(@artist.pk_hash).not_first_tags.all.must_equal [tu, tv]
+    ds.where(@artist.pk_hash).last_two_tags.all.must_equal [tv, tu]
+    ds.where(ar.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(ar.pk_hash).second_two_tags.all.must_equal []
+    ds.where(ar.pk_hash).not_first_tags.all.must_equal []
+    ds.where(ar.pk_hash).last_two_tags.all.must_equal [tu]
 
     Artist.many_through_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(:tags__name=>tu.name) end
     Artist.many_through_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
 
-    ds.where(@artist.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(@artist.pk_hash).second_two_tags.all.should == [tv]
-    ds.where(ar.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(ar.pk_hash).second_two_tags.all.should == []
+    ds.where(@artist.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(@artist.pk_hash).second_two_tags.all.must_equal [tv]
+    ds.where(ar.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(ar.pk_hash).second_two_tags.all.must_equal []
 
     al.add_tag(tv)
-    ds.where(@artist.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(@artist.pk_hash).second_two_tags.all.should == [tv]
-    ds.where(ar.pk_hash).first_two_tags.all.should == [tu]
-    ds.where(ar.pk_hash).second_two_tags.all.should == [tv]
+    ds.where(@artist.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(@artist.pk_hash).second_two_tags.all.must_equal [tv]
+    ds.where(ar.pk_hash).first_two_tags.all.must_equal [tu]
+    ds.where(ar.pk_hash).second_two_tags.all.must_equal [tv]
   end
 end
 
-shared_examples_for "basic regular and composite key associations" do  
-  specify "should return no objects if none are associated" do
-    @album.artist.should == nil
-    @artist.first_album.should == nil
-    @artist.albums.should == []
-    @album.tags.should == []
-    @album.alias_tags.should == []
-    @tag.albums.should == []
+BasicRegularAndCompositeKeyAssociations = shared_description do
+  describe "when filtering/excluding by associations" do
+    before do
+      @Artist = Artist.dataset
+      @Album = Album.dataset
+      @Tag = Tag.dataset
+    end
+
+    include FilterByAssociations
+  end
+
+  it "should return no objects if none are associated" do
+    @album.artist.must_equal nil
+    @artist.first_album.must_equal nil
+    @artist.albums.must_equal []
+    @album.tags.must_equal []
+    @album.alias_tags.must_equal []
+    @tag.albums.must_equal []
   end
 
-  specify "should have add and set methods work any associated objects" do
+  it "should have add and set methods work any associated objects" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
@@ -1501,15 +1511,15 @@ shared_examples_for "basic regular and composite key associations" do
     @artist.reload
     @tag.reload
     
-    @album.artist.should == @artist
-    @artist.first_album.should == @album
-    @artist.albums.should == [@album]
-    @album.tags.should == [@tag]
-    @album.alias_tags.should == [@tag]
-    @tag.albums.should == [@album]
+    @album.artist.must_equal @artist
+    @artist.first_album.must_equal @album
+    @artist.albums.must_equal [@album]
+    @album.tags.must_equal [@tag]
+    @album.alias_tags.must_equal [@tag]
+    @tag.albums.must_equal [@album]
   end
   
-  specify "should work correctly with prepared_statements_association plugin" do
+  it "should work correctly with prepared_statements_association plugin" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
@@ -1518,78 +1528,78 @@ shared_examples_for "basic regular and composite key associations" do
     @tag.reload
     
     [Tag, Album, Artist].each{|x| x.plugin :prepared_statements_associations}
-    @album.artist.should == @artist
-    @artist.first_album.should == @album
-    @artist.albums.should == [@album]
-    @album.tags.should == [@tag]
-    @album.alias_tags.should == [@tag]
-    @tag.albums.should == [@album]
+    @album.artist.must_equal @artist
+    @artist.first_album.must_equal @album
+    @artist.albums.must_equal [@album]
+    @album.tags.must_equal [@tag]
+    @album.alias_tags.must_equal [@tag]
+    @tag.albums.must_equal [@album]
   end
 
-  specify "should have working dataset associations" do
+  it "should have working dataset associations" do
     album, artist, tag = @pr.call
 
-    Tag.albums.all.should == []
-    Album.artists.all.should == []
-    Album.tags.all.should == []
-    Album.alias_tags.all.should == []
-    Artist.albums.all.should == []
+    Tag.albums.all.must_equal []
+    Album.artists.all.must_equal []
+    Album.tags.all.must_equal []
+    Album.alias_tags.all.must_equal []
+    Artist.albums.all.must_equal []
     unless @no_many_through_many
-      Album.first_tags.all.should == []
-      Artist.tags.all.should == []
-      Artist.first_tags.all.should == []
+      Album.first_tags.all.must_equal []
+      Artist.tags.all.must_equal []
+      Artist.first_tags.all.must_equal []
     end
-    Artist.albums.tags.all.should == []
+    Artist.albums.tags.all.must_equal []
 
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
 
-    Tag.albums.all.should == [@album]
-    Album.artists.all.should == [@artist]
-    Album.tags.all.should == [@tag]
-    Album.alias_tags.all.should == [@tag]
-    Artist.albums.all.should == [@album]
+    Tag.albums.all.must_equal [@album]
+    Album.artists.all.must_equal [@artist]
+    Album.tags.all.must_equal [@tag]
+    Album.alias_tags.all.must_equal [@tag]
+    Artist.albums.all.must_equal [@album]
     unless @no_many_through_many
-      Album.first_tags.all.should == [@tag]
-      Artist.tags.all.should == [@tag]
-      Artist.first_tags.all.should == [@tag]
+      Album.first_tags.all.must_equal [@tag]
+      Artist.tags.all.must_equal [@tag]
+      Artist.first_tags.all.must_equal [@tag]
     end
-    Artist.albums.tags.all.should == [@tag]
+    Artist.albums.tags.all.must_equal [@tag]
 
     album.add_tag(tag)
     album.update(:artist => artist)
 
-    Tag.albums.order(:name).all.should == [@album, album]
-    Album.artists.order(:name).all.should == [@artist, artist]
-    Album.tags.order(:name).all.should == [@tag, tag]
-    Album.alias_tags.order(:name).all.should == [@tag, tag]
-    Artist.albums.order(:name).all.should == [@album, album]
+    Tag.albums.order(:name).all.must_equal [@album, album]
+    Album.artists.order(:name).all.must_equal [@artist, artist]
+    Album.tags.order(:name).all.must_equal [@tag, tag]
+    Album.alias_tags.order(:name).all.must_equal [@tag, tag]
+    Artist.albums.order(:name).all.must_equal [@album, album]
     unless @no_many_through_many
-      Album.first_tags.order(:name).all.should == [@tag, tag]
-      Artist.tags.order(:name).all.should == [@tag, tag]
-      Artist.first_tags.order(:name).all.should == [@tag, tag]
+      Album.first_tags.order(:name).all.must_equal [@tag, tag]
+      Artist.tags.order(:name).all.must_equal [@tag, tag]
+      Artist.first_tags.order(:name).all.must_equal [@tag, tag]
     end
-    Artist.albums.tags.order(:name).all.should == [@tag, tag]
+    Artist.albums.tags.order(:name).all.must_equal [@tag, tag]
 
-    Tag.filter(Tag.qualified_primary_key_hash(tag.pk)).albums.all.should == [album]
-    Album.filter(Album.qualified_primary_key_hash(album.pk)).artists.all.should == [artist]
-    Album.filter(Album.qualified_primary_key_hash(album.pk)).tags.all.should == [tag]
-    Album.filter(Album.qualified_primary_key_hash(album.pk)).alias_tags.all.should == [tag]
-    Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.all.should == [album]
+    Tag.filter(Tag.qualified_primary_key_hash(tag.pk)).albums.all.must_equal [album]
+    Album.filter(Album.qualified_primary_key_hash(album.pk)).artists.all.must_equal [artist]
+    Album.filter(Album.qualified_primary_key_hash(album.pk)).tags.all.must_equal [tag]
+    Album.filter(Album.qualified_primary_key_hash(album.pk)).alias_tags.all.must_equal [tag]
+    Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.all.must_equal [album]
     unless @no_many_through_many
-      Album.filter(Album.qualified_primary_key_hash(album.pk)).first_tags.all.should == [tag]
-      Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).tags.all.should == [tag]
-      Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).first_tags.all.should == [tag]
+      Album.filter(Album.qualified_primary_key_hash(album.pk)).first_tags.all.must_equal [tag]
+      Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).tags.all.must_equal [tag]
+      Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).first_tags.all.must_equal [tag]
     end
-    Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.tags.all.should == [tag]
+    Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.tags.all.must_equal [tag]
 
-    Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.filter(Album.qualified_primary_key_hash(album.pk)).tags.all.should == [tag]
-    Artist.filter(Artist.qualified_primary_key_hash(@artist.pk)).albums.filter(Album.qualified_primary_key_hash(@album.pk)).tags.all.should == [@tag]
-    Artist.filter(Artist.qualified_primary_key_hash(@artist.pk)).albums.filter(Album.qualified_primary_key_hash(album.pk)).tags.all.should == []
-    Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.filter(Album.qualified_primary_key_hash(@album.pk)).tags.all.should == []
+    Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.filter(Album.qualified_primary_key_hash(album.pk)).tags.all.must_equal [tag]
+    Artist.filter(Artist.qualified_primary_key_hash(@artist.pk)).albums.filter(Album.qualified_primary_key_hash(@album.pk)).tags.all.must_equal [@tag]
+    Artist.filter(Artist.qualified_primary_key_hash(@artist.pk)).albums.filter(Album.qualified_primary_key_hash(album.pk)).tags.all.must_equal []
+    Artist.filter(Artist.qualified_primary_key_hash(artist.pk)).albums.filter(Album.qualified_primary_key_hash(@album.pk)).tags.all.must_equal []
   end
 
-  specify "should have remove methods work" do
+  it "should have remove methods work" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
@@ -1603,19 +1613,19 @@ shared_examples_for "basic regular and composite key associations" do
     @artist.reload
     @tag.reload
     
-    @album.artist.should == nil
-    @artist.albums.should == []
-    @album.tags.should == []
-    @tag.albums.should == []
+    @album.artist.must_equal nil
+    @artist.albums.must_equal []
+    @album.tags.must_equal []
+    @tag.albums.must_equal []
 
     @album.add_alias_tag(@tag)
     @album.remove_alias_tag(@tag)
 
     @album.reload
-    @album.alias_tags.should == []
+    @album.alias_tags.must_equal []
   end
   
-  specify "should have remove_all methods work" do
+  it "should have remove_all methods work" do
     @artist.add_album(@album)
     @album.add_tag(@tag)
     
@@ -1626,65 +1636,55 @@ shared_examples_for "basic regular and composite key associations" do
     @artist.reload
     @tag.reload
     
-    @album.artist.should == nil
-    @artist.albums.should == []
-    @album.tags.should == []
-    @tag.albums.should == []
+    @album.artist.must_equal nil
+    @artist.albums.must_equal []
+    @album.tags.must_equal []
+    @tag.albums.must_equal []
 
     @album.add_alias_tag(@tag)
     @album.remove_all_alias_tags
 
     @album.reload
-    @album.alias_tags.should == []
+    @album.alias_tags.must_equal []
   end
   
-  specify "should eager load via eager correctly" do
+  it "should eager load via eager correctly" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
     a = Artist.eager(:albums=>[:tags, :alias_tags]).eager(:first_album).all
-    a.should == [@artist]
-    a.first.albums.should == [@album]
-    a.first.first_album.should == @album
-    a.first.albums.first.tags.should == [@tag]
-    a.first.albums.first.alias_tags.should == [@tag]
+    a.must_equal [@artist]
+    a.first.albums.must_equal [@album]
+    a.first.first_album.must_equal @album
+    a.first.albums.first.tags.must_equal [@tag]
+    a.first.albums.first.alias_tags.must_equal [@tag]
     
     a = Tag.eager(:albums=>:artist).all
-    a.should == [@tag]
-    a.first.albums.should == [@album]
-    a.first.albums.first.artist.should == @artist
+    a.must_equal [@tag]
+    a.first.albums.must_equal [@album]
+    a.first.albums.first.artist.must_equal @artist
   end
   
-  specify "should eager load via eager_graph correctly" do
+  it "should eager load via eager_graph correctly" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
     a = Artist.eager_graph(:albums=>[:tags, :alias_tags]).eager_graph(:first_album).all
-    a.should == [@artist]
-    a.first.albums.should == [@album]
-    a.first.first_album.should == @album
-    a.first.albums.first.tags.should == [@tag]
-    a.first.albums.first.alias_tags.should == [@tag]
+    a.must_equal [@artist]
+    a.first.albums.must_equal [@album]
+    a.first.first_album.must_equal @album
+    a.first.albums.first.tags.must_equal [@tag]
+    a.first.albums.first.alias_tags.must_equal [@tag]
     
     a = Tag.eager_graph(:albums=>:artist).all
-    a.should == [@tag]
-    a.first.albums.should == [@album]
-    a.first.albums.first.artist.should == @artist
-  end
-  
-  describe "when filtering/excluding by associations" do
-    before do
-      @Artist = Artist.dataset
-      @Album = Album.dataset
-      @Tag = Tag.dataset
-    end
-
-    it_should_behave_like "filtering/excluding by associations"
+    a.must_equal [@tag]
+    a.first.albums.must_equal [@album]
+    a.first.albums.first.artist.must_equal @artist
   end
 end
 
-shared_examples_for "regular and composite key associations" do  
-  it_should_behave_like "basic regular and composite key associations"
+RegularAndCompositeKeyAssociations = shared_description do
+  include BasicRegularAndCompositeKeyAssociations
 
   describe "when filtering/excluding by associations when joining" do
     def self_join(c)
@@ -1697,47 +1697,48 @@ shared_examples_for "regular and composite key associations" do
       @Tag = self_join(Tag)
     end
 
-    it_should_behave_like "filtering/excluding by associations"
+    include FilterByAssociations
   end
 
   describe "with default/union :eager_limit_strategy" do
     before do
       @els = {}
     end
-    it_should_behave_like "eager limit strategies"
+    include EagerLimitStrategies
   end
 
   describe "with :eager_limit_strategy=>:ruby" do
     before do
       @els = {:eager_limit_strategy=>:ruby}
     end
-    it_should_behave_like "eager limit strategies"
-    it_should_behave_like "eager_graph limit strategies"
+    include EagerLimitStrategies
+    include EagerGraphLimitStrategies
   end
 
   describe "with :eager_limit_strategy=>:distinct_on" do
     before do
       @els = {:eager_limit_strategy=>:distinct_on}
     end
-    it_should_behave_like "one_to_one eager limit strategies"
-    it_should_behave_like "one_through_one eager limit strategies"
-    it_should_behave_like "one_through_many eager limit strategies"
-    it_should_behave_like "one_to_one eager_graph limit strategies"
-    it_should_behave_like "one_through_one eager_graph limit strategies"
-    it_should_behave_like "one_through_many eager_graph limit strategies"
-    it_should_behave_like "filter by associations singular association limit strategies"
+
+    include OneToOneEagerLimitStrategies
+    include OneThroughOneEagerLimitStrategies
+    include OneThroughManyEagerLimitStrategies
+    include OneToOneEagerGraphLimitStrategies
+    include OneThroughOneEagerGraphLimitStrategies
+    include OneThroughManyEagerGraphLimitStrategies
+    include FilterByAssociationsSingularLimitStrategies
   end if DB.dataset.supports_ordered_distinct_on?
 
   describe "with :eager_limit_strategy=>:window_function" do
     before do
       @els = {:eager_limit_strategy=>:window_function}
     end
-    it_should_behave_like "eager limit strategies"
-    it_should_behave_like "eager_graph limit strategies"
-    it_should_behave_like "filter by associations limit strategies"
+    include EagerLimitStrategies
+    include EagerGraphLimitStrategies
+    include FilterByAssociationsLimitStrategies
   end if DB.dataset.supports_window_functions?
 
-  specify "should work with a many_through_many association" do
+  it "should work with a many_through_many association" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
 
@@ -1745,28 +1746,28 @@ shared_examples_for "regular and composite key associations" do
     @artist.reload
     @tag.reload
     
-    @album.tags.should == [@tag]
+    @album.tags.must_equal [@tag]
     
     a = Artist.eager(:tags).all
-    a.should == [@artist]
-    a.first.tags.should == [@tag]
+    a.must_equal [@artist]
+    a.first.tags.must_equal [@tag]
     
     a = Artist.eager_graph(:tags).all
-    a.should == [@artist]
-    a.first.tags.should == [@tag]
+    a.must_equal [@artist]
+    a.first.tags.must_equal [@tag]
     
     a = Album.eager(:artist=>:tags).all
-    a.should == [@album]
-    a.first.artist.should == @artist
-    a.first.artist.tags.should == [@tag]
+    a.must_equal [@album]
+    a.first.artist.must_equal @artist
+    a.first.artist.tags.must_equal [@tag]
     
     a = Album.eager_graph(:artist=>:tags).all
-    a.should == [@album]
-    a.first.artist.should == @artist
-    a.first.artist.tags.should == [@tag]
+    a.must_equal [@album]
+    a.first.artist.must_equal @artist
+    a.first.artist.tags.must_equal [@tag]
   end
 
-  specify "should work with a one_through_many association" do
+  it "should work with a one_through_many association" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
 
@@ -1774,25 +1775,25 @@ shared_examples_for "regular and composite key associations" do
     @artist.reload
     @tag.reload
     
-    @album.tags.should == [@tag]
+    @album.tags.must_equal [@tag]
     
     a = Artist.eager(:first_tag).all
-    a.should == [@artist]
-    a.first.first_tag.should == @tag
+    a.must_equal [@artist]
+    a.first.first_tag.must_equal @tag
     
     a = Artist.eager_graph(:first_tag).all
-    a.should == [@artist]
-    a.first.first_tag.should == @tag
+    a.must_equal [@artist]
+    a.first.first_tag.must_equal @tag
     
     a = Album.eager(:artist=>:first_tag).all
-    a.should == [@album]
-    a.first.artist.should == @artist
-    a.first.artist.first_tag.should == @tag
+    a.must_equal [@album]
+    a.first.artist.must_equal @artist
+    a.first.artist.first_tag.must_equal @tag
     
     a = Album.eager_graph(:artist=>:first_tag).all
-    a.should == [@album]
-    a.first.artist.should == @artist
-    a.first.artist.first_tag.should == @tag
+    a.must_equal [@album]
+    a.first.artist.must_equal @artist
+    a.first.artist.first_tag.must_equal @tag
   end
 end
 
@@ -1883,52 +1884,52 @@ describe "Sequel::Model Simple Associations" do
     @db.drop_table?(:albums_tags, :tags, :albums, :artists)
   end
   
-  it_should_behave_like "regular and composite key associations"
+  include RegularAndCompositeKeyAssociations
 
   describe "with :correlated_subquery limit strategy" do
     before do
       @els = {:eager_limit_strategy=>:correlated_subquery}
     end
 
-    it_should_behave_like "one_to_one eager_graph limit strategies"
-    it_should_behave_like "one_to_many eager_graph limit strategies"
-    it_should_behave_like "filter by associations one_to_one limit strategies"
-    it_should_behave_like "filter by associations one_to_many limit strategies"
+    include OneToOneEagerGraphLimitStrategies
+    include OneToManyEagerGraphLimitStrategies
+    include FilterByAssociationsOneToOneLimitStrategies
+    include FilterByAssociationsOneToManyLimitStrategies
   end if DB.dataset.supports_limits_in_correlated_subqueries?
 
-  specify "should handle eager loading limited associations for many objects" do
+  it "should handle eager loading limited associations for many objects" do
     @db[:artists].import([:name], (1..99).map{|i| [i.to_s]})
     artists = Artist.eager(:albums).all
-    artists.length.should == 100
-    artists.each{|a| a.albums.should == []}
+    artists.length.must_equal 100
+    artists.each{|a| a.albums.must_equal []}
     artists = Artist.eager(:first_two_albums).all
-    artists.length.should == 100
-    artists.each{|a| a.first_two_albums.should == []}
+    artists.length.must_equal 100
+    artists.each{|a| a.first_two_albums.must_equal []}
     @db[:albums].insert([:artist_id], @db[:artists].select(:id))
     artists = Artist.eager(:albums).all
-    artists.length.should == 100
-    artists.each{|a| a.albums.length.should == 1}
+    artists.length.must_equal 100
+    artists.each{|a| a.albums.length.must_equal 1}
     artists = Artist.eager(:first_two_albums).all
-    artists.length.should == 100
-    artists.each{|a| a.first_two_albums.length.should == 1}
+    artists.length.must_equal 100
+    artists.each{|a| a.first_two_albums.length.must_equal 1}
   end
 
-  specify "should handle many_to_one associations with same name as :key" do
+  it "should handle many_to_one associations with same name as :key" do
     Album.def_column_alias(:artist_id_id, :artist_id)
     Album.many_to_one :artist_id, :key_column =>:artist_id, :class=>Artist
     @album.update(:artist_id_id => @artist.id)
-    @album.artist_id.should == @artist
+    @album.artist_id.must_equal @artist
 
     as = Album.eager(:artist_id).all
-    as.should == [@album]
-    as.map{|a| a.artist_id}.should == [@artist]
+    as.must_equal [@album]
+    as.map{|a| a.artist_id}.must_equal [@artist]
 
     as = Album.eager_graph(:artist_id).all
-    as.should == [@album]
-    as.map{|a| a.artist_id}.should == [@artist]
+    as.must_equal [@album]
+    as.map{|a| a.artist_id}.must_equal [@artist]
   end
 
-  specify "should handle aliased tables when eager_graphing" do
+  it "should handle aliased tables when eager_graphing" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
@@ -1941,93 +1942,93 @@ describe "Sequel::Model Simple Associations" do
     Tag.many_to_many :balbums, :class=>Album, :join_table=>:albums_tags, :right_key=>:album_id
 
     a = Artist.eager_graph(:balbums=>:btags).all
-    a.should == [@artist]
-    a.first.balbums.should == [@album]
-    a.first.balbums.first.btags.should == [@tag]
+    a.must_equal [@artist]
+    a.first.balbums.must_equal [@album]
+    a.first.balbums.first.btags.must_equal [@tag]
     
     a = Tag.eager_graph(:balbums=>:bartist).all
-    a.should == [@tag]
-    a.first.balbums.should == [@album]
-    a.first.balbums.first.bartist.should == @artist
+    a.must_equal [@tag]
+    a.first.balbums.must_equal [@album]
+    a.first.balbums.first.bartist.must_equal @artist
   end
   
-  specify "should have add method accept hashes and create new records" do
+  it "should have add method accept hashes and create new records" do
     @artist.remove_all_albums
     Album.dataset.delete
     @album = @artist.add_album(:name=>'Al2')
-    Album.first[:name].should == 'Al2'
-    @artist.albums_dataset.first[:name].should == 'Al2'
+    Album.first[:name].must_equal 'Al2'
+    @artist.albums_dataset.first[:name].must_equal 'Al2'
     
     @album.remove_all_tags
     Tag.dataset.delete
     @album.add_tag(:name=>'T2')
-    Tag.first[:name].should == 'T2'
-    @album.tags_dataset.first[:name].should == 'T2'
+    Tag.first[:name].must_equal 'T2'
+    @album.tags_dataset.first[:name].must_equal 'T2'
   end
   
-  specify "should have add method accept primary key and add related records" do
+  it "should have add method accept primary key and add related records" do
     @artist.remove_all_albums
     @artist.add_album(@album.id)
-    @artist.albums_dataset.first[:id].should == @album.id
+    @artist.albums_dataset.first[:id].must_equal @album.id
 
     @album.remove_all_tags
     @album.add_tag(@tag.id)
-    @album.tags_dataset.first[:id].should == @tag.id
+    @album.tags_dataset.first[:id].must_equal @tag.id
   end
   
-  specify "should have remove method accept primary key and remove related album" do
+  it "should have remove method accept primary key and remove related album" do
     @artist.add_album(@album)
     @artist.reload.remove_album(@album.id)
-    @artist.reload.albums.should == []
+    @artist.reload.albums.must_equal []
     
     @album.add_tag(@tag)
     @album.reload.remove_tag(@tag.id)
-    @tag.reload.albums.should == []
+    @tag.reload.albums.must_equal []
   end
   
-  specify "should handle dynamic callbacks for regular loading" do
+  it "should handle dynamic callbacks for regular loading" do
     @artist.add_album(@album)
 
-    @artist.albums.should == [@album]
-    @artist.albums(proc{|ds| ds.exclude(:id=>@album.id)}).should == []
-    @artist.albums(proc{|ds| ds.filter(:id=>@album.id)}).should == [@album]
+    @artist.albums.must_equal [@album]
+    @artist.albums(proc{|ds| ds.exclude(:id=>@album.id)}).must_equal []
+    @artist.albums(proc{|ds| ds.filter(:id=>@album.id)}).must_equal [@album]
 
-    @album.artist.should == @artist
-    @album.artist(proc{|ds| ds.exclude(:id=>@artist.id)}).should == nil
-    @album.artist(proc{|ds| ds.filter(:id=>@artist.id)}).should == @artist
+    @album.artist.must_equal @artist
+    @album.artist(proc{|ds| ds.exclude(:id=>@artist.id)}).must_equal nil
+    @album.artist(proc{|ds| ds.filter(:id=>@artist.id)}).must_equal @artist
 
-    @artist.albums{|ds| ds.exclude(:id=>@album.id)}.should == []
-    @artist.albums{|ds| ds.filter(:id=>@album.id)}.should == [@album]
-    @album.artist{|ds| ds.exclude(:id=>@artist.id)}.should == nil
-    @album.artist{|ds| ds.filter(:id=>@artist.id)}.should == @artist
+    @artist.albums{|ds| ds.exclude(:id=>@album.id)}.must_equal []
+    @artist.albums{|ds| ds.filter(:id=>@album.id)}.must_equal [@album]
+    @album.artist{|ds| ds.exclude(:id=>@artist.id)}.must_equal nil
+    @album.artist{|ds| ds.filter(:id=>@artist.id)}.must_equal @artist
   end
   
-  specify "should handle dynamic callbacks for eager loading via eager and eager_graph" do
+  it "should handle dynamic callbacks for eager loading via eager and eager_graph" do
     @artist.add_album(@album)
     @album.add_tag(@tag)
     album2 = @artist.add_album(:name=>'Foo')
     tag2 = album2.add_tag(:name=>'T2')
 
     artist = Artist.eager(:albums=>:tags).all.first
-    artist.albums.should == [@album, album2]
-    artist.albums.map{|x| x.tags}.should == [[@tag], [tag2]]
+    artist.albums.must_equal [@album, album2]
+    artist.albums.map{|x| x.tags}.must_equal [[@tag], [tag2]]
 
     artist = Artist.eager_graph(:albums=>:tags).all.first
-    artist.albums.should == [@album, album2]
-    artist.albums.map{|x| x.tags}.should == [[@tag], [tag2]]
+    artist.albums.must_equal [@album, album2]
+    artist.albums.map{|x| x.tags}.must_equal [[@tag], [tag2]]
 
     artist = Artist.eager(:albums=>{proc{|ds| ds.where(:id=>album2.id)}=>:tags}).all.first
-    artist.albums.should == [album2]
-    artist.albums.first.tags.should == [tag2]
+    artist.albums.must_equal [album2]
+    artist.albums.first.tags.must_equal [tag2]
 
     artist = Artist.eager_graph(:albums=>{proc{|ds| ds.where(:id=>album2.id)}=>:tags}).all.first
-    artist.albums.should == [album2]
-    artist.albums.first.tags.should == [tag2]
+    artist.albums.must_equal [album2]
+    artist.albums.first.tags.must_equal [tag2]
   end
   
-  specify "should have remove method raise an error for one_to_many records if the object isn't already associated" do
-    proc{@artist.remove_album(@album.id)}.should raise_error(Sequel::Error)
-    proc{@artist.remove_album(@album)}.should raise_error(Sequel::Error)
+  it "should have remove method raise an error for one_to_many records if the object isn't already associated" do
+    proc{@artist.remove_album(@album.id)}.must_raise(Sequel::Error)
+    proc{@artist.remove_album(@album)}.must_raise(Sequel::Error)
   end
 end
 
@@ -2136,56 +2137,56 @@ describe "Sequel::Model Composite Key Associations" do
     @db.drop_table?(:albums_tags, :tags, :albums, :artists)
   end
 
-  it_should_behave_like "regular and composite key associations"
+  include RegularAndCompositeKeyAssociations
 
   describe "with :correlated_subquery limit strategy" do
     before do
       @els = {:eager_limit_strategy=>:correlated_subquery}
     end
 
-    it_should_behave_like "one_to_one eager_graph limit strategies"
-    it_should_behave_like "one_to_many eager_graph limit strategies"
-    it_should_behave_like "filter by associations one_to_one limit strategies"
-    it_should_behave_like "filter by associations one_to_many limit strategies"
+    include OneToOneEagerGraphLimitStrategies
+    include OneToManyEagerGraphLimitStrategies
+    include FilterByAssociationsOneToOneLimitStrategies
+    include FilterByAssociationsOneToManyLimitStrategies
   end if DB.dataset.supports_limits_in_correlated_subqueries? && DB.dataset.supports_multiple_column_in?
 
-  specify "should have add method accept hashes and create new records" do
+  it "should have add method accept hashes and create new records" do
     @artist.remove_all_albums
     Album.dataset.delete
     @artist.add_album(:id1=>1, :id2=>2, :name=>'Al2')
-    Album.first[:name].should == 'Al2'
-    @artist.albums_dataset.first[:name].should == 'Al2'
+    Album.first[:name].must_equal 'Al2'
+    @artist.albums_dataset.first[:name].must_equal 'Al2'
     
     @album.remove_all_tags
     Tag.dataset.delete
     @album.add_tag(:id1=>1, :id2=>2, :name=>'T2')
-    Tag.first[:name].should == 'T2'
-    @album.tags_dataset.first[:name].should == 'T2'
+    Tag.first[:name].must_equal 'T2'
+    @album.tags_dataset.first[:name].must_equal 'T2'
   end
   
-  specify "should have add method accept primary key and add related records" do
+  it "should have add method accept primary key and add related records" do
     @artist.remove_all_albums
     @artist.add_album([@album.id1, @album.id2])
-    @artist.albums_dataset.first.pk.should == [@album.id1, @album.id2]
+    @artist.albums_dataset.first.pk.must_equal [@album.id1, @album.id2]
     
     @album.remove_all_tags
     @album.add_tag([@tag.id1, @tag.id2])
-    @album.tags_dataset.first.pk.should == [@tag.id1, @tag.id2]
+    @album.tags_dataset.first.pk.must_equal [@tag.id1, @tag.id2]
   end
   
-  specify "should have remove method accept primary key and remove related album" do
+  it "should have remove method accept primary key and remove related album" do
     @artist.add_album(@album)
     @artist.reload.remove_album([@album.id1, @album.id2])
-    @artist.reload.albums.should == []
+    @artist.reload.albums.must_equal []
     
     @album.add_tag(@tag)
     @album.reload.remove_tag([@tag.id1, @tag.id2])
-    @tag.reload.albums.should == []
+    @tag.reload.albums.must_equal []
   end
   
-  specify "should have remove method raise an error for one_to_many records if the object isn't already associated" do
-    proc{@artist.remove_album([@album.id1, @album.id2])}.should raise_error(Sequel::Error)
-    proc{@artist.remove_album(@album)}.should raise_error(Sequel::Error)
+  it "should have remove method raise an error for one_to_many records if the object isn't already associated" do
+    proc{@artist.remove_album([@album.id1, @album.id2])}.must_raise(Sequel::Error)
+    proc{@artist.remove_album(@album)}.must_raise(Sequel::Error)
   end
 end
 
@@ -2256,10 +2257,10 @@ describe "Sequel::Model pg_array_to_many" do
   after(:all) do
     @db.drop_table?(:tags, :albums, :artists)
   end
-  
-  it_should_behave_like "basic regular and composite key associations"
-  it_should_behave_like "many_to_many eager limit strategies"
-  it_should_behave_like "many_to_many eager_graph limit strategies"
+
+  include BasicRegularAndCompositeKeyAssociations
+  include ManyToManyEagerLimitStrategies
+  include ManyToManyEagerGraphLimitStrategies
 
   it "should handle adding and removing entries in array" do
     a = Album.create
@@ -2338,9 +2339,9 @@ describe "Sequel::Model many_to_pg_array" do
     @db.drop_table?(:tags, :albums, :artists)
   end
   
-  it_should_behave_like "basic regular and composite key associations"
-  it_should_behave_like "many_to_many eager limit strategies"
-  it_should_behave_like "many_to_many eager_graph limit strategies"
+  include BasicRegularAndCompositeKeyAssociations
+  include ManyToManyEagerLimitStrategies
+  include ManyToManyEagerGraphLimitStrategies
 
   it "should handle adding and removing entries in array" do
     a = Album.create
@@ -2389,30 +2390,30 @@ describe "Sequel::Model Associations with clashing column names" do
   end
 
   it "should have working regular association methods" do
-    @Bar.first.foo.should == @foo
-    @Foo.first.bars.should == [@bar]
-    @Foo.first.bar.should == @bar
-    @Foo.first.mtmbars.should == [@bar]
-    @Foo.first.mtmbar.should == @bar
-    @Bar.first.mtmfoos.should == [@foo]
+    @Bar.first.foo.must_equal @foo
+    @Foo.first.bars.must_equal [@bar]
+    @Foo.first.bar.must_equal @bar
+    @Foo.first.mtmbars.must_equal [@bar]
+    @Foo.first.mtmbar.must_equal @bar
+    @Bar.first.mtmfoos.must_equal [@foo]
   end
 
   it "should have working eager loading methods" do
-    @Bar.eager(:foo).all.map{|o| [o, o.foo]}.should == [[@bar, @foo]]
-    @Foo.eager(:bars).all.map{|o| [o, o.bars]}.should == [[@foo, [@bar]]]
-    @Foo.eager(:bar).all.map{|o| [o, o.bar]}.should == [[@foo, @bar]]
-    @Foo.eager(:mtmbars).all.map{|o| [o, o.mtmbars]}.should == [[@foo, [@bar]]]
-    @Foo.eager(:mtmbar).all.map{|o| [o, o.mtmbar]}.should == [[@foo, @bar]]
-    @Bar.eager(:mtmfoos).all.map{|o| [o, o.mtmfoos]}.should == [[@bar, [@foo]]]
+    @Bar.eager(:foo).all.map{|o| [o, o.foo]}.must_equal [[@bar, @foo]]
+    @Foo.eager(:bars).all.map{|o| [o, o.bars]}.must_equal [[@foo, [@bar]]]
+    @Foo.eager(:bar).all.map{|o| [o, o.bar]}.must_equal [[@foo, @bar]]
+    @Foo.eager(:mtmbars).all.map{|o| [o, o.mtmbars]}.must_equal [[@foo, [@bar]]]
+    @Foo.eager(:mtmbar).all.map{|o| [o, o.mtmbar]}.must_equal [[@foo, @bar]]
+    @Bar.eager(:mtmfoos).all.map{|o| [o, o.mtmfoos]}.must_equal [[@bar, [@foo]]]
   end
 
   it "should have working eager graphing methods" do
-    @Bar.eager_graph(:foo).all.map{|o| [o, o.foo]}.should == [[@bar, @foo]]
-    @Foo.eager_graph(:bars).all.map{|o| [o, o.bars]}.should == [[@foo, [@bar]]]
-    @Foo.eager_graph(:bar).all.map{|o| [o, o.bar]}.should == [[@foo, @bar]]
-    @Foo.eager_graph(:mtmbars).all.map{|o| [o, o.mtmbars]}.should == [[@foo, [@bar]]]
-    @Foo.eager_graph(:mtmbar).all.map{|o| [o, o.mtmbar]}.should == [[@foo, @bar]]
-    @Bar.eager_graph(:mtmfoos).all.map{|o| [o, o.mtmfoos]}.should == [[@bar, [@foo]]]
+    @Bar.eager_graph(:foo).all.map{|o| [o, o.foo]}.must_equal [[@bar, @foo]]
+    @Foo.eager_graph(:bars).all.map{|o| [o, o.bars]}.must_equal [[@foo, [@bar]]]
+    @Foo.eager_graph(:bar).all.map{|o| [o, o.bar]}.must_equal [[@foo, @bar]]
+    @Foo.eager_graph(:mtmbars).all.map{|o| [o, o.mtmbars]}.must_equal [[@foo, [@bar]]]
+    @Foo.eager_graph(:mtmbar).all.map{|o| [o, o.mtmbar]}.must_equal [[@foo, @bar]]
+    @Bar.eager_graph(:mtmfoos).all.map{|o| [o, o.mtmfoos]}.must_equal [[@bar, [@foo]]]
   end
 
   it "should have working modification methods" do
@@ -2420,34 +2421,34 @@ describe "Sequel::Model Associations with clashing column names" do
     f = @Foo.create(:obj_id=>3)
 
     @bar.foo = f
-    @bar.obj_id.should == 3
+    @bar.obj_id.must_equal 3
     @foo.bar = @bar
-    @bar.obj_id.should == 2
+    @bar.obj_id.must_equal 2
 
     @foo.add_bar(b)
-    @foo.bars.sort_by{|x| x.id}.should == [@bar, b]
+    @foo.bars.sort_by{|x| x.id}.must_equal [@bar, b]
     @foo.remove_bar(b)
-    @foo.bars.should == [@bar]
+    @foo.bars.must_equal [@bar]
     @foo.remove_all_bars
-    @foo.bars.should == []
+    @foo.bars.must_equal []
 
     @bar.refresh.update(:obj_id=>2)
     b.refresh.update(:obj_id=>3)
-    @foo.mtmbars.should == [@bar]
+    @foo.mtmbars.must_equal [@bar]
     @foo.remove_all_mtmbars
-    @foo.mtmbars.should == []
+    @foo.mtmbars.must_equal []
     @foo.add_mtmbar(b)
-    @foo.mtmbars.should == [b]
+    @foo.mtmbars.must_equal [b]
     @foo.remove_mtmbar(b)
-    @foo.mtmbars.should == []
+    @foo.mtmbars.must_equal []
 
     @bar.add_mtmfoo(f)
-    @bar.mtmfoos.should == [f]
+    @bar.mtmfoos.must_equal [f]
     @bar.remove_all_mtmfoos
-    @bar.mtmfoos.should == []
+    @bar.mtmfoos.must_equal []
     @bar.add_mtmfoo(f)
-    @bar.mtmfoos.should == [f]
+    @bar.mtmfoos.must_equal [f]
     @bar.remove_mtmfoo(f)
-    @bar.mtmfoos.should == []
+    @bar.mtmfoos.must_equal []
   end
 end