sequel 4.22.0 → 4.23.0

data/spec/extensions/null_dataset_spec.rb

@@ -8,78 +8,78 @@ describe "null_dataset extension" do
     @pr = proc{|*a| @i += 1}
   end
   after do
-    @db.sqls.should == [] unless @skip_check
+    @db.sqls.must_equal [] unless @skip_check
   end
 
   it "should make each be a noop" do
-    @ds.each(&@pr).should equal(@ds)
-    @i.should == 0
+    @ds.each(&@pr).must_be_same_as(@ds)
+    @i.must_equal 0
   end
 
   it "should make fetch_rows be a noop" do
-    @ds.fetch_rows("SELECT 1", &@pr).should == nil
-    @i.should == 0
+    @ds.fetch_rows("SELECT 1", &@pr).must_equal nil
+    @i.must_equal 0
   end
 
   it "should make insert be a noop" do
-    @ds.insert(1).should == nil
+    @ds.insert(1).must_equal nil
   end
 
   it "should make update be a noop" do
-    @ds.update(:a=>1).should == 0
+    @ds.update(:a=>1).must_equal 0
   end
 
   it "should make delete be a noop" do
-    @ds.delete.should == 0
+    @ds.delete.must_equal 0
   end
 
   it "should make truncate be a noop" do
-    @ds.truncate.should == nil
+    @ds.truncate.must_equal nil
   end
 
   it "should make execute_* be a noop" do
-    @ds.send(:execute_ddl,'FOO').should == nil
-    @ds.send(:execute_insert,'FOO').should == nil
-    @ds.send(:execute_dui,'FOO').should == nil
-    @ds.send(:execute,'FOO').should == nil
+    @ds.send(:execute_ddl,'FOO').must_equal nil
+    @ds.send(:execute_insert,'FOO').must_equal nil
+    @ds.send(:execute_dui,'FOO').must_equal nil
+    @ds.send(:execute,'FOO').must_equal nil
   end
 
   it "should have working columns" do
     @skip_check = true
-    @ds.columns.should == [:id]
-    @db.sqls.should == ['SELECT * FROM table LIMIT 1']
+    @ds.columns.must_equal [:id]
+    @db.sqls.must_equal ['SELECT * FROM table LIMIT 1']
   end
 
   it "should have count return 0" do
-    @ds.count.should == 0
+    @ds.count.must_equal 0
   end
 
   it "should have empty return true" do
-    @ds.empty?.should == true
+    @ds.empty?.must_equal true
   end
 
   it "should make import a noop" do
-    @ds.import([:id], [[1], [2], [3]]).should == nil
+    @ds.import([:id], [[1], [2], [3]]).must_equal nil
   end
 
   it "should have nullify method returned modified receiver" do
     @skip_check = true
     ds = @db[:table]
-    ds.nullify.should_not equal(ds)
+    ds.nullify.wont_be_same_as(ds)
     ds.each(&@pr)
-    @db.sqls.should == ['SELECT * FROM table']
-    @i.should == 1
+    @db.sqls.must_equal ['SELECT * FROM table']
+    @i.must_equal 1
   end
 
   it "should have nullify! method modify receiver" do
     ds = @db[:table]
-    ds.nullify!.should equal(ds)
+    ds.nullify!.must_be_same_as(ds)
     ds.each(&@pr)
-    @i.should == 0
+    @i.must_equal 0
   end
 
   it "should work with method chaining" do
     @ds.where(:a=>1).select(:b).each(&@pr)
-    @i.should == 0
+    @i.must_equal 0
   end
 end

data/spec/extensions/optimistic_locking_spec.rb

@@ -47,55 +47,55 @@ describe "optimistic_locking plugin" do
     @c.plugin :optimistic_locking
   end
 
-  specify "should raise an error when updating a stale record" do
+  it "should raise an error when updating a stale record" do
     p1 = @c[1]
     p2 = @c[1]
     p1.update(:name=>'Jim')
-    proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+    proc{p2.update(:name=>'Bob')}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
   end 
 
-  specify "should raise an error when destroying a stale record" do
+  it "should raise an error when destroying a stale record" do
     p1 = @c[1]
     p2 = @c[1]
     p1.update(:name=>'Jim')
-    proc{p2.destroy}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+    proc{p2.destroy}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
   end 
 
-  specify "should not raise an error when updating the same record twice" do
+  it "should not raise an error when updating the same record twice" do
     p1 = @c[1]
     p1.update(:name=>'Jim')
-    proc{p1.update(:name=>'Bob')}.should_not raise_error
+    p1.update(:name=>'Bob')
   end
 
-  specify "should allow changing the lock column via model.lock_column=" do
+  it "should allow changing the lock column via model.lock_column=" do
     @lv.replace('lv')
     @c.columns :id, :name, :lv
     @c.lock_column = :lv
     p1 = @c[1]
     p2 = @c[1]
     p1.update(:name=>'Jim')
-    proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+    proc{p2.update(:name=>'Bob')}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
   end
 
-  specify "should allow changing the lock column via plugin option" do
+  it "should allow changing the lock column via plugin option" do
     @lv.replace('lv')
     @c.columns :id, :name, :lv
     @c.plugin :optimistic_locking, :lock_column=>:lv
     p1 = @c[1]
     p2 = @c[1]
     p1.update(:name=>'Jim')
-    proc{p2.destroy}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+    proc{p2.destroy}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
   end
 
-  specify "should work when subclassing" do
+  it "should work when subclassing" do
     c = Class.new(@c)
     p1 = c[1]
     p2 = c[1]
     p1.update(:name=>'Jim')
-    proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
+    proc{p2.update(:name=>'Bob')}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
   end
 
-  specify "should work correctly if attempting to refresh and save again after a failed save" do
+  it "should work correctly if attempting to refresh and save again after a failed save" do
     p1 = @c[1]
     p2 = @c[1]
     p1.update(:name=>'Jim')
@@ -104,25 +104,25 @@ describe "optimistic_locking plugin" do
     rescue Sequel::Plugins::OptimisticLocking::Error
       p2.refresh
       @c.db.sqls
-      proc{p2.update(:name=>'Bob')}.should_not raise_error
+      p2.update(:name=>'Bob')
     end
-    @c.db.sqls.first.should =~ /UPDATE people SET (name = 'Bob', lock_version = 4|lock_version = 4, name = 'Bob') WHERE \(\(id = 1\) AND \(lock_version = 3\)\)/
+    @c.db.sqls.first.must_match(/UPDATE people SET (name = 'Bob', lock_version = 4|lock_version = 4, name = 'Bob') WHERE \(\(id = 1\) AND \(lock_version = 3\)\)/)
   end
 
-  specify "should increment the lock column when #modified! even if no columns are changed" do
+  it "should increment the lock column when #modified! even if no columns are changed" do
     p1 = @c[1]
     p1.modified!
     lv = p1.lock_version
     p1.save_changes
-    p1.lock_version.should == lv + 1
+    p1.lock_version.must_equal lv + 1
   end
 
-  specify "should not increment the lock column when the update fails" do
-    @c.instance_dataset.meta_def(:update) { raise Exception }
+  it "should not increment the lock column when the update fails" do
+    @c.instance_dataset.meta_def(:update) {|_| raise }
     p1 = @c[1]
     p1.modified!
     lv = p1.lock_version
-    proc{p1.save_changes}.should raise_error(Exception)
-    p1.lock_version.should == lv
+    proc{p1.save_changes}.must_raise(RuntimeError)
+    p1.lock_version.must_equal lv
   end
 end

data/spec/extensions/pagination_spec.rb

@@ -8,80 +8,80 @@ describe "A paginated dataset" do
     @paginated = @d.paginate(1, 20)
   end
   
-  specify "should raise an error if the dataset already has a limit" do
-    proc{@d.limit(10).paginate(1,10)}.should raise_error(Sequel::Error)
-    proc{@paginated.paginate(2,20)}.should raise_error(Sequel::Error)
-    proc{@d.limit(10).each_page(10){|ds|}}.should raise_error(Sequel::Error)
-    proc{@d.limit(10).each_page(10)}.should raise_error(Sequel::Error)
+  it "should raise an error if the dataset already has a limit" do
+    proc{@d.limit(10).paginate(1,10)}.must_raise(Sequel::Error)
+    proc{@paginated.paginate(2,20)}.must_raise(Sequel::Error)
+    proc{@d.limit(10).each_page(10){|ds|}}.must_raise(Sequel::Error)
+    proc{@d.limit(10).each_page(10)}.must_raise(Sequel::Error)
   end
   
-  specify "should set the limit and offset options correctly" do
-    @paginated.opts[:limit].should == 20
-    @paginated.opts[:offset].should == 0
+  it "should set the limit and offset options correctly" do
+    @paginated.opts[:limit].must_equal 20
+    @paginated.opts[:offset].must_equal 0
   end
   
-  specify "should set the page count correctly" do
-    @paginated.page_count.should == 8
-    @d.paginate(1, 50).page_count.should == 4
+  it "should set the page count correctly" do
+    @paginated.page_count.must_equal 8
+    @d.paginate(1, 50).page_count.must_equal 4
 
     @d.meta_def(:count) {0}
-    @d.paginate(1, 50).page_count.should == 1
+    @d.paginate(1, 50).page_count.must_equal 1
   end
   
-  specify "should set the current page number correctly" do
-    @paginated.current_page.should == 1
-    @d.paginate(3, 50).current_page.should == 3
+  it "should set the current page number correctly" do
+    @paginated.current_page.must_equal 1
+    @d.paginate(3, 50).current_page.must_equal 3
   end
   
-  specify "should return the next page number or nil if we're on the last" do
-    @paginated.next_page.should == 2
-    @d.paginate(4, 50).next_page.should be_nil
+  it "should return the next page number or nil if we're on the last" do
+    @paginated.next_page.must_equal 2
+    @d.paginate(4, 50).next_page.must_equal nil
   end
   
-  specify "should return the previous page number or nil if we're on the first" do
-    @paginated.prev_page.should be_nil
-    @d.paginate(4, 50).prev_page.should == 3
+  it "should return the previous page number or nil if we're on the first" do
+    @paginated.prev_page.must_equal nil
+    @d.paginate(4, 50).prev_page.must_equal 3
   end
   
-  specify "should return the page range" do
-    @paginated.page_range.should == (1..8)
-    @d.paginate(4, 50).page_range.should == (1..4)
+  it "should return the page range" do
+    @paginated.page_range.must_equal(1..8)
+    @d.paginate(4, 50).page_range.must_equal(1..4)
   end
   
-  specify "should return the record range for the current page" do
-    @paginated.current_page_record_range.should == (1..20)
-    @d.paginate(4, 50).current_page_record_range.should == (151..153)
-    @d.paginate(5, 50).current_page_record_range.should == (0..0)
+  it "should return the record range for the current page" do
+    @paginated.current_page_record_range.must_equal(1..20)
+    @d.paginate(4, 50).current_page_record_range.must_equal(151..153)
+    @d.paginate(5, 50).current_page_record_range.must_equal(0..0)
   end
 
-  specify "should return the record count for the current page" do
-    @paginated.current_page_record_count.should == 20
-    @d.paginate(3, 50).current_page_record_count.should == 50
-    @d.paginate(4, 50).current_page_record_count.should == 3
-    @d.paginate(5, 50).current_page_record_count.should == 0
+  it "should return the record count for the current page" do
+    @paginated.current_page_record_count.must_equal 20
+    @d.paginate(3, 50).current_page_record_count.must_equal 50
+    @d.paginate(4, 50).current_page_record_count.must_equal 3
+    @d.paginate(5, 50).current_page_record_count.must_equal 0
   end
 
-  specify "should know if current page is last page" do
-    @paginated.last_page?.should == false
-    @d.paginate(2, 20).last_page?.should == false
-    @d.paginate(5, 30).last_page?.should == false
-    @d.paginate(6, 30).last_page?.should == true
+  it "should know if current page is last page" do
+    @paginated.last_page?.must_equal false
+    @d.paginate(2, 20).last_page?.must_equal false
+    @d.paginate(5, 30).last_page?.must_equal false
+    @d.paginate(6, 30).last_page?.must_equal true
 
     @d.meta_def(:count) {0}
-    @d.paginate(1, 30).last_page?.should == true
-    @d.paginate(2, 30).last_page?.should == false
+    @d.paginate(1, 30).last_page?.must_equal true
+    @d.paginate(2, 30).last_page?.must_equal false
   end
 
-  specify "should know if current page is first page" do
-    @paginated.first_page?.should == true
-    @d.paginate(1, 20).first_page?.should == true
-    @d.paginate(2, 20).first_page?.should == false
+  it "should know if current page is first page" do
+    @paginated.first_page?.must_equal true
+    @d.paginate(1, 20).first_page?.must_equal true
+    @d.paginate(2, 20).first_page?.must_equal false
   end
 
-  specify "should work with fixed sql" do
+  it "should work with fixed sql" do
     ds = @d.clone(:sql => 'select * from blah')
     ds.meta_def(:count) {150}
-    ds.paginate(2, 50).sql.should == 'SELECT * FROM (select * from blah) AS t1 LIMIT 50 OFFSET 50'
+    ds.paginate(2, 50).sql.must_equal 'SELECT * FROM (select * from blah) AS t1 LIMIT 50 OFFSET 50'
   end
 end
 
@@ -91,14 +91,14 @@ describe "Dataset#each_page" do
     @d.meta_def(:count) {153}
   end
   
-  specify "should raise an error if the dataset already has a limit" do
-    proc{@d.limit(10).each_page(10){}}.should raise_error(Sequel::Error)
+  it "should raise an error if the dataset already has a limit" do
+    proc{@d.limit(10).each_page(10){}}.must_raise(Sequel::Error)
   end
   
-  specify "should iterate over each page in the resultset as a paginated dataset" do
+  it "should iterate over each page in the resultset as a paginated dataset" do
     a = []
     @d.each_page(50) {|p| a << p}
-    a.map {|p| p.sql}.should == [
+    a.map {|p| p.sql}.must_equal [
       'SELECT * FROM items LIMIT 50 OFFSET 0',
       'SELECT * FROM items LIMIT 50 OFFSET 50',
       'SELECT * FROM items LIMIT 50 OFFSET 100',
@@ -106,9 +106,9 @@ describe "Dataset#each_page" do
     ]
   end
 
-  specify "should return an enumerator if no block is given" do
+  it "should return an enumerator if no block is given" do
     enum = @d.each_page(50)
-    enum.map {|p| p.sql}.should == [
+    enum.map {|p| p.sql}.must_equal [
       'SELECT * FROM items LIMIT 50 OFFSET 0',
       'SELECT * FROM items LIMIT 50 OFFSET 50',
       'SELECT * FROM items LIMIT 50 OFFSET 100',

data/spec/extensions/pg_array_associations_spec.rb

@@ -41,100 +41,100 @@ describe Sequel::Model, "pg_array_associations" do
     @c2.many_to_pg_array :artists, :clone=>:artists, :eager_loader=>pr
     @c1.eager(:tags).all
     @c2.eager(:artists).all
-    khs.should == [[{}, nil], [{:id=>{2=>[Tag.load(:id=>2)]}}, {2=>[Tag.load(:id=>2)]}]]
+    khs.must_equal [[{}, nil], [{:id=>{2=>[Tag.load(:id=>2)]}}, {2=>[Tag.load(:id=>2)]}]]
   end
 
   it "should not issue queries if the object cannot have associated objects" do
-    @n1.tags.should == []
-    @c1.load(:tag_ids=>[]).tags.should == []
-    @n2.artists.should == []
-    @db.sqls.should == []
+    @n1.tags.must_equal []
+    @c1.load(:tag_ids=>[]).tags.must_equal []
+    @n2.artists.must_equal []
+    @db.sqls.must_equal []
   end
 
   it "should use correct SQL when loading associations lazily" do
-    @o1.tags.should == [@o2]
-    @o2.artists.should == [@o1]
-    @db.sqls.should == ["SELECT * FROM tags WHERE (tags.id IN (1, 2, 3))", "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[])"]
+    @o1.tags.must_equal [@o2]
+    @o2.artists.must_equal [@o1]
+    @db.sqls.must_equal ["SELECT * FROM tags WHERE (tags.id IN (1, 2, 3))", "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[])"]
   end
 
   it "should accept :primary_key option for primary keys to use in current and associated table" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :primary_key=>Sequel./(:id, 3)
     @c2.many_to_pg_array :artists, :clone=>:artists, :primary_key=>:id3
-    @o1.tags_dataset.sql.should == "SELECT * FROM tags WHERE ((tags.id / 3) IN (1, 2, 3))"
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[6]::integer[])"
+    @o1.tags_dataset.sql.must_equal "SELECT * FROM tags WHERE ((tags.id / 3) IN (1, 2, 3))"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[6]::integer[])"
   end
   
   it "should allowing filtering by associations" do
-    @c1.filter(:tags=>@o2).sql.should == "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[])"
-    @c2.filter(:artists=>@o1).sql.should == "SELECT * FROM tags WHERE (tags.id IN (1, 2, 3))"
+    @c1.filter(:tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[])"
+    @c2.filter(:artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (1, 2, 3))"
   end
 
   it "should allowing filtering by associations with :conditions" do
-    @c1.filter(:a_tags=>@o2).sql.should == "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id = 2)))), 'f')"
-    @c2.filter(:a_artists=>@o1).sql.should == "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id = 1))))"
+    @c1.filter(:a_tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id = 2)))), 'f')"
+    @c2.filter(:a_artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id = 1))))"
   end
 
   it "should allowing excluding by associations" do
-    @c1.exclude(:tags=>@o2).sql.should == "SELECT * FROM artists WHERE (NOT (artists.tag_ids @> ARRAY[2]::integer[]) OR (artists.tag_ids IS NULL))"
-    @c2.exclude(:artists=>@o1).sql.should == "SELECT * FROM tags WHERE ((tags.id NOT IN (1, 2, 3)) OR (tags.id IS NULL))"
+    @c1.exclude(:tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE (NOT (artists.tag_ids @> ARRAY[2]::integer[]) OR (artists.tag_ids IS NULL))"
+    @c2.exclude(:artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (1, 2, 3)) OR (tags.id IS NULL))"
   end
 
   it "should allowing excluding by associations with :conditions" do
-    @c1.exclude(:a_tags=>@o2).sql.should == "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id = 2)))), 'f') OR (artists.tag_ids IS NULL))"
-    @c2.exclude(:a_artists=>@o1).sql.should == "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id = 1)))) OR (tags.id IS NULL))"
+    @c1.exclude(:a_tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id = 2)))), 'f') OR (artists.tag_ids IS NULL))"
+    @c2.exclude(:a_artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id = 1)))) OR (tags.id IS NULL))"
   end
 
   it "should allowing filtering by multiple associations" do
-    @c1.filter(:tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.should == "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[1,2]::integer[])"
-    @c2.filter(:artists=>[@c1.load(:tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:tag_ids=>Sequel.pg_array([4, 5]))]).sql.should == "SELECT * FROM tags WHERE (tags.id IN (3, 4, 5))"
+    @c1.filter(:tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[1,2]::integer[])"
+    @c2.filter(:artists=>[@c1.load(:tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:tag_ids=>Sequel.pg_array([4, 5]))]).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (3, 4, 5))"
   end
 
   it "should allowing filtering by multiple associations with :conditions" do
-    @c1.filter(:a_tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.should == "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (1, 2))))), 'f')"
-    @c2.filter(:a_artists=>[@c1.load(:id=>7, :tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:id=>8, :tag_ids=>Sequel.pg_array([4, 5]))]).sql.should == "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (7, 8)))))"
+    @c1.filter(:a_tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (1, 2))))), 'f')"
+    @c2.filter(:a_artists=>[@c1.load(:id=>7, :tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:id=>8, :tag_ids=>Sequel.pg_array([4, 5]))]).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (7, 8)))))"
   end
 
   it "should allowing excluding by multiple associations" do
-    @c1.exclude(:tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.should == "SELECT * FROM artists WHERE (NOT (artists.tag_ids && ARRAY[1,2]::integer[]) OR (artists.tag_ids IS NULL))"
-    @c2.exclude(:artists=>[@c1.load(:tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:tag_ids=>Sequel.pg_array([4, 5]))]).sql.should == "SELECT * FROM tags WHERE ((tags.id NOT IN (3, 4, 5)) OR (tags.id IS NULL))"
+    @c1.exclude(:tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE (NOT (artists.tag_ids && ARRAY[1,2]::integer[]) OR (artists.tag_ids IS NULL))"
+    @c2.exclude(:artists=>[@c1.load(:tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:tag_ids=>Sequel.pg_array([4, 5]))]).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (3, 4, 5)) OR (tags.id IS NULL))"
   end
 
   it "should allowing excluding by multiple associations with :conditions" do
-    @c1.exclude(:a_tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.should == "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (1, 2))))), 'f') OR (artists.tag_ids IS NULL))"
-    @c2.exclude(:a_artists=>[@c1.load(:id=>7, :tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:id=>8, :tag_ids=>Sequel.pg_array([4, 5]))]).sql.should == "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (7, 8))))) OR (tags.id IS NULL))"
+    @c1.exclude(:a_tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (1, 2))))), 'f') OR (artists.tag_ids IS NULL))"
+    @c2.exclude(:a_artists=>[@c1.load(:id=>7, :tag_ids=>Sequel.pg_array([3, 4])), @c1.load(:id=>8, :tag_ids=>Sequel.pg_array([4, 5]))]).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (7, 8))))) OR (tags.id IS NULL))"
   end
 
   it "should allowing filtering/excluding associations with NULL or empty values" do
-    @c1.filter(:tags=>@c2.new).sql.should == 'SELECT * FROM artists WHERE \'f\''
-    @c1.exclude(:tags=>@c2.new).sql.should == 'SELECT * FROM artists WHERE \'t\''
-    @c2.filter(:artists=>@c1.new).sql.should == 'SELECT * FROM tags WHERE \'f\''
-    @c2.exclude(:artists=>@c1.new).sql.should == 'SELECT * FROM tags WHERE \'t\''
+    @c1.filter(:tags=>@c2.new).sql.must_equal 'SELECT * FROM artists WHERE \'f\''
+    @c1.exclude(:tags=>@c2.new).sql.must_equal 'SELECT * FROM artists WHERE \'t\''
+    @c2.filter(:artists=>@c1.new).sql.must_equal 'SELECT * FROM tags WHERE \'f\''
+    @c2.exclude(:artists=>@c1.new).sql.must_equal 'SELECT * FROM tags WHERE \'t\''
 
-    @c2.filter(:artists=>@c1.load(:tag_ids=>[])).sql.should == 'SELECT * FROM tags WHERE \'f\''
-    @c2.exclude(:artists=>@c1.load(:tag_ids=>[])).sql.should == 'SELECT * FROM tags WHERE \'t\''
+    @c2.filter(:artists=>@c1.load(:tag_ids=>[])).sql.must_equal 'SELECT * FROM tags WHERE \'f\''
+    @c2.exclude(:artists=>@c1.load(:tag_ids=>[])).sql.must_equal 'SELECT * FROM tags WHERE \'t\''
 
-    @c1.filter(:tags=>[@c2.new, @c2.load(:id=>2)]).sql.should == "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"
-    @c2.filter(:artists=>[@c1.load(:tag_ids=>Sequel.pg_array([3, 4])), @c1.new]).sql.should == "SELECT * FROM tags WHERE (tags.id IN (3, 4))"
+    @c1.filter(:tags=>[@c2.new, @c2.load(:id=>2)]).sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"
+    @c2.filter(:artists=>[@c1.load(:tag_ids=>Sequel.pg_array([3, 4])), @c1.new]).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (3, 4))"
   end
 
   it "should allowing filtering by association datasets" do
-    @c1.filter(:tags=>@c2.where(:id=>1)).sql.should == "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE (id = 1))), 'f')"
-    @c2.filter(:artists=>@c1.where(:id=>1)).sql.should == "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE (id = 1)))"
+    @c1.filter(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE (id = 1))), 'f')"
+    @c2.filter(:artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE (id = 1)))"
   end
 
   it "should allowing filtering by association datasets with :conditions" do
-    @c1.filter(:a_tags=>@c2.where(:id=>1)).sql.should == "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (SELECT tags.id FROM tags WHERE (id = 1)))))), 'f')"
-    @c2.filter(:a_artists=>@c1.where(:id=>1)).sql.should == "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (SELECT artists.id FROM artists WHERE (id = 1))))))"
+    @c1.filter(:a_tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (SELECT tags.id FROM tags WHERE (id = 1)))))), 'f')"
+    @c2.filter(:a_artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (SELECT artists.id FROM artists WHERE (id = 1))))))"
   end
 
   it "should allowing excluding by association datasets" do
-    @c1.exclude(:tags=>@c2.where(:id=>1)).sql.should == "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE (id = 1))), 'f') OR (artists.tag_ids IS NULL))"
-    @c2.exclude(:artists=>@c1.where(:id=>1)).sql.should == "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE (id = 1))) OR (tags.id IS NULL))"
+    @c1.exclude(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE (id = 1))), 'f') OR (artists.tag_ids IS NULL))"
+    @c2.exclude(:artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE (id = 1))) OR (tags.id IS NULL))"
   end
 
   it "should allowing excluding by association datasets with :conditions" do
-    @c1.exclude(:a_tags=>@c2.where(:id=>1)).sql.should == "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (SELECT tags.id FROM tags WHERE (id = 1)))))), 'f') OR (artists.tag_ids IS NULL))"
-    @c2.exclude(:a_artists=>@c1.where(:id=>1)).sql.should == "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (SELECT artists.id FROM artists WHERE (id = 1)))))) OR (tags.id IS NULL))"
+    @c1.exclude(:a_tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE (NOT coalesce((artists.tag_ids && (SELECT array_agg(tags.id) FROM tags WHERE ((name = 'A') AND (tags.id IS NOT NULL) AND (tags.id IN (SELECT tags.id FROM tags WHERE (id = 1)))))), 'f') OR (artists.tag_ids IS NULL))"
+    @c2.exclude(:a_artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE ((tags.id NOT IN (SELECT unnest(artists.tag_ids) FROM artists WHERE ((name = 'A') AND (artists.tag_ids IS NOT NULL) AND (artists.id IN (SELECT artists.id FROM artists WHERE (id = 1)))))) OR (tags.id IS NULL))"
   end
 
   it "filter by associations should respect key options" do 
@@ -142,82 +142,82 @@ describe Sequel::Model, "pg_array_associations" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :primary_key=>Sequel.*(:id, 3), :primary_key_method=>:id3, :key=>:tag3_ids, :key_column=>Sequel.pg_array(:tag_ids)[1..2]
     @c2.many_to_pg_array :artists, :clone=>:artists, :primary_key=>Sequel.*(:id, 3), :primary_key_method=>:id3, :key=>:tag3_ids, :key_column=>Sequel.pg_array(:tag_ids)[1..2]
 
-    @c1.filter(:tags=>@o2).sql.should == "SELECT * FROM artists WHERE (artists.tag_ids[1:2] @> ARRAY[6]::integer[])"
-    @c2.filter(:artists=>@o1).sql.should == "SELECT * FROM tags WHERE ((tags.id * 3) IN (3, 6, 9))"
-    @c1.filter(:tags=>@c2.where(:id=>1)).sql.should == "SELECT * FROM artists WHERE coalesce((artists.tag_ids[1:2] && (SELECT array_agg((tags.id * 3)) FROM tags WHERE (id = 1))), 'f')"
-    @c2.filter(:artists=>@c1.where(:id=>1)).sql.should == "SELECT * FROM tags WHERE ((tags.id * 3) IN (SELECT unnest(artists.tag_ids[1:2]) FROM artists WHERE (id = 1)))"
+    @c1.filter(:tags=>@o2).sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids[1:2] @> ARRAY[6]::integer[])"
+    @c2.filter(:artists=>@o1).sql.must_equal "SELECT * FROM tags WHERE ((tags.id * 3) IN (3, 6, 9))"
+    @c1.filter(:tags=>@c2.where(:id=>1)).sql.must_equal "SELECT * FROM artists WHERE coalesce((artists.tag_ids[1:2] && (SELECT array_agg((tags.id * 3)) FROM tags WHERE (id = 1))), 'f')"
+    @c2.filter(:artists=>@c1.where(:id=>1)).sql.must_equal "SELECT * FROM tags WHERE ((tags.id * 3) IN (SELECT unnest(artists.tag_ids[1:2]) FROM artists WHERE (id = 1)))"
   end
   
   it "should raise an error if associated model does not have a primary key, and :primary_key is not specified" do
     @c1.no_primary_key
     @c2.no_primary_key
     @c1.pg_array_to_many :tags, :clone=>:tags
-    proc{@o1.tags}.should raise_error(Sequel::Error)
-    proc{@c2.many_to_pg_array :artists, :clone=>:artists}.should raise_error(Sequel::Error)
-    @db.sqls.should == []
+    proc{@o1.tags}.must_raise(Sequel::Error)
+    proc{@c2.many_to_pg_array :artists, :clone=>:artists}.must_raise(Sequel::Error)
+    @db.sqls.must_equal []
   end
   
   it "should support a :key option" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :key=>:tag2_ids
     @c2.many_to_pg_array :artists, :clone=>:artists, :key=>:tag2_ids
     @c1.class_eval{def tag2_ids; tag_ids.map{|x| x * 2} end}
-    @o1.tags_dataset.sql.should == "SELECT * FROM tags WHERE (tags.id IN (2, 4, 6))"
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE (artists.tag2_ids @> ARRAY[2]::integer[])"
+    @o1.tags_dataset.sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (2, 4, 6))"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (artists.tag2_ids @> ARRAY[2]::integer[])"
   end
   
   it "should support a :key_column option" do
     @c2.many_to_pg_array :artists, :clone=>:artists, :key_column=>Sequel.pg_array(:tag_ids)[1..2], :key=>:tag2_ids
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE (artists.tag_ids[1:2] @> ARRAY[2]::integer[])"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids[1:2] @> ARRAY[2]::integer[])"
   end
   
   it "should support a :primary_key option" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :primary_key=>:id2
     @c2.many_to_pg_array :artists, :clone=>:artists, :primary_key=>:id2
-    @o1.tags_dataset.sql.should == "SELECT * FROM tags WHERE (tags.id2 IN (1, 2, 3))"
+    @o1.tags_dataset.sql.must_equal "SELECT * FROM tags WHERE (tags.id2 IN (1, 2, 3))"
     @c2.class_eval{def id2; id*2 end}
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[4]::integer[])"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[4]::integer[])"
   end
   
   it "should support a :conditions option" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :conditions=>{:a=>1}
     @c2.many_to_pg_array :artists, :clone=>:artists, :conditions=>{:a=>1}
-    @o1.tags_dataset.sql.should == "SELECT * FROM tags WHERE ((a = 1) AND (tags.id IN (1, 2, 3)))"
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE ((a = 1) AND (artists.tag_ids @> ARRAY[2]::integer[]))"
+    @o1.tags_dataset.sql.must_equal "SELECT * FROM tags WHERE ((a = 1) AND (tags.id IN (1, 2, 3)))"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE ((a = 1) AND (artists.tag_ids @> ARRAY[2]::integer[]))"
   end
   
   it "should support an :order option" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :order=>[:a, :b]
     @c2.many_to_pg_array :artists, :clone=>:artists, :order=>[:a, :b]
-    @o1.tags_dataset.sql.should == "SELECT * FROM tags WHERE (tags.id IN (1, 2, 3)) ORDER BY a, b"
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[]) ORDER BY a, b"
+    @o1.tags_dataset.sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (1, 2, 3)) ORDER BY a, b"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[]) ORDER BY a, b"
   end
   
   it "should support a select option" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :select=>[:a, :b]
     @c2.many_to_pg_array :artists, :clone=>:artists, :select=>[:a, :b]
-    @c1.load(:tag_ids=>Sequel.pg_array([1,2,3])).tags_dataset.sql.should == "SELECT a, b FROM tags WHERE (tags.id IN (1, 2, 3))"
-    @c2.load(:id=>1).artists_dataset.sql.should == "SELECT a, b FROM artists WHERE (artists.tag_ids @> ARRAY[1]::integer[])"
+    @c1.load(:tag_ids=>Sequel.pg_array([1,2,3])).tags_dataset.sql.must_equal "SELECT a, b FROM tags WHERE (tags.id IN (1, 2, 3))"
+    @c2.load(:id=>1).artists_dataset.sql.must_equal "SELECT a, b FROM artists WHERE (artists.tag_ids @> ARRAY[1]::integer[])"
   end
   
   it "should accept a block" do
     @c1.pg_array_to_many :tags, :clone=>:tags do |ds| ds.filter(:yyy=>@yyy) end
     @c2.many_to_pg_array :artists, :clone=>:artists do |ds| ds.filter(:a=>1) end
-    @c1.new(:yyy=>6, :tag_ids=>Sequel.pg_array([1,2,3])).tags_dataset.sql.should == "SELECT * FROM tags WHERE ((tags.id IN (1, 2, 3)) AND (yyy = 6))"
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE ((artists.tag_ids @> ARRAY[2]::integer[]) AND (a = 1))"
+    @c1.new(:yyy=>6, :tag_ids=>Sequel.pg_array([1,2,3])).tags_dataset.sql.must_equal "SELECT * FROM tags WHERE ((tags.id IN (1, 2, 3)) AND (yyy = 6))"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE ((artists.tag_ids @> ARRAY[2]::integer[]) AND (a = 1))"
   end
 
   it "should support a :dataset option that is used instead of the default" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :dataset=>proc{Tag.where(:id=>tag_ids.map{|x| x*2})}
     @c2.many_to_pg_array :artists, :clone=>:artists, :dataset=>proc{Artist.where(Sequel.pg_array(Sequel.pg_array(:tag_ids)[1..2]).contains([id]))}
-    @o1.tags_dataset.sql.should == "SELECT * FROM tags WHERE (id IN (2, 4, 6))"
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE (tag_ids[1:2] @> ARRAY[2])"
+    @o1.tags_dataset.sql.must_equal "SELECT * FROM tags WHERE (id IN (2, 4, 6))"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (tag_ids[1:2] @> ARRAY[2])"
   end
 
   it "should support a :limit option" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :limit=>[2, 3]
     @c2.many_to_pg_array :artists, :clone=>:artists, :limit=>[3, 2]
-    @o1.tags_dataset.sql.should == "SELECT * FROM tags WHERE (tags.id IN (1, 2, 3)) LIMIT 2 OFFSET 3"
-    @o2.artists_dataset.sql.should == "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[]) LIMIT 3 OFFSET 2"
+    @o1.tags_dataset.sql.must_equal "SELECT * FROM tags WHERE (tags.id IN (1, 2, 3)) LIMIT 2 OFFSET 3"
+    @o2.artists_dataset.sql.must_equal "SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[]) LIMIT 3 OFFSET 2"
   end
 
   it "should support a :uniq option that removes duplicates from the association" do
@@ -225,39 +225,39 @@ describe Sequel::Model, "pg_array_associations" do
     @c2.many_to_pg_array :artists, :clone=>:artists, :uniq=>true
     @c1.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]
     @c2.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]
-    @o1.tags.should == [@c2.load(:id=>20), @c2.load(:id=>30)]
-    @o2.artists.should == [@c1.load(:id=>20), @c1.load(:id=>30)]
+    @o1.tags.must_equal [@c2.load(:id=>20), @c2.load(:id=>30)]
+    @o2.artists.must_equal [@c1.load(:id=>20), @c1.load(:id=>30)]
   end
 
   it "reflection associated_object_keys should return correct values" do
-    @c1.association_reflection(:tags).associated_object_keys.should == [:id]
-    @c2.association_reflection(:artists).associated_object_keys.should == [:tag_ids]
+    @c1.association_reflection(:tags).associated_object_keys.must_equal [:id]
+    @c2.association_reflection(:artists).associated_object_keys.must_equal [:tag_ids]
   end
   
   it "reflection remove_before_destroy? should return correct values" do
-    @c1.association_reflection(:tags).remove_before_destroy?.should == true
-    @c2.association_reflection(:artists).remove_before_destroy?.should == false
+    @c1.association_reflection(:tags).remove_before_destroy?.must_equal true
+    @c2.association_reflection(:artists).remove_before_destroy?.must_equal false
   end
   
   it "reflection reciprocal should be correct" do
-    @c1.association_reflection(:tags).reciprocal.should == :artists
-    @c2.association_reflection(:artists).reciprocal.should == :tags
+    @c1.association_reflection(:tags).reciprocal.must_equal :artists
+    @c2.association_reflection(:artists).reciprocal.must_equal :tags
   end
 
   it "should eagerly load correctly" do
     a = @c1.eager(:tags).all
-    a.should == [@o1]
+    a.must_equal [@o1]
     sqls = @db.sqls
-    sqls.pop.should =~ /SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/ 
-    sqls.should == ["SELECT * FROM artists"]
-    a.first.tags.should == [@o2]
-    @db.sqls.should == []
+    sqls.pop.must_match(/SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
+    sqls.must_equal ["SELECT * FROM artists"]
+    a.first.tags.must_equal [@o2]
+    @db.sqls.must_equal []
 
     a = @c2.eager(:artists).all
-    a.should == [@o2]
-    @db.sqls.should == ['SELECT * FROM tags', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
-    a.first.artists.should == [@o1]
-    @db.sqls.should == []
+    a.must_equal [@o2]
+    @db.sqls.must_equal ['SELECT * FROM tags', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
+    a.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
   end
   
   it "should support using custom key options when eager loading associations" do
@@ -266,46 +266,46 @@ describe Sequel::Model, "pg_array_associations" do
     @c2.many_to_pg_array :artists, :clone=>:artists, :primary_key=>:id3, :key=>:tag3_ids, :key_column=>Sequel.pg_array(:tag_ids)[1..2]
 
     a = @c1.eager(:tags).all
-    a.should == [@o1]
+    a.must_equal [@o1]
     sqls = @db.sqls
-    sqls.pop.should =~ /SELECT \* FROM tags WHERE \(\(tags\.id \* 3\) IN \([369], [369], [369]\)\)/ 
-    sqls.should == ["SELECT * FROM artists"]
-    a.first.tags.should == [@o2]
-    @db.sqls.should == []
+    sqls.pop.must_match(/SELECT \* FROM tags WHERE \(\(tags\.id \* 3\) IN \([369], [369], [369]\)\)/)
+    sqls.must_equal ["SELECT * FROM artists"]
+    a.first.tags.must_equal [@o2]
+    @db.sqls.must_equal []
 
     a = @c2.eager(:artists).all
-    a.should == [@o2]
-    @db.sqls.should == ["SELECT * FROM tags", "SELECT * FROM artists WHERE (artists.tag_ids[1:2] && ARRAY[6]::integer[])"]
-    a.first.artists.should == [@o1]
-    @db.sqls.should == []
+    a.must_equal [@o2]
+    @db.sqls.must_equal ["SELECT * FROM tags", "SELECT * FROM artists WHERE (artists.tag_ids[1:2] && ARRAY[6]::integer[])"]
+    a.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
   end
 
   it "should allow cascading of eager loading for associations of associated models" do
     a = @c1.eager(:tags=>:artists).all
-    a.should == [@o1]
+    a.must_equal [@o1]
     sqls = @db.sqls
-    sqls.slice!(1).should =~ /SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/ 
-    sqls.should == ['SELECT * FROM artists', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
-    a.first.tags.should == [@o2]
-    a.first.tags.first.artists.should == [@o1]
-    @db.sqls.should == []
+    sqls.slice!(1).must_match(/SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
+    sqls.must_equal ['SELECT * FROM artists', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
+    a.first.tags.must_equal [@o2]
+    a.first.tags.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
   end
   
   it "should respect :eager when lazily loading an association" do
     @c1.pg_array_to_many :tags2, :clone=>:tags, :eager=>:artists, :key=>:tag_ids
     @c2.many_to_pg_array :artists2, :clone=>:artists, :eager=>:tags
 
-    @o1.tags2.should == [@o2]
-    @db.sqls.should == ["SELECT * FROM tags WHERE (tags.id IN (1, 2, 3))", "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
-    @o1.tags2.first.artists.should == [@o1]
-    @db.sqls.should == []
+    @o1.tags2.must_equal [@o2]
+    @db.sqls.must_equal ["SELECT * FROM tags WHERE (tags.id IN (1, 2, 3))", "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
+    @o1.tags2.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
 
-    @o2.artists2.should == [@o1]
+    @o2.artists2.must_equal [@o1]
     sqls = @db.sqls
-    sqls.pop.should =~ /SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/ 
-    sqls.should == ["SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[])"]
-    @o2.artists2.first.tags.should == [@o2]
-    @db.sqls.should == []
+    sqls.pop.must_match(/SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
+    sqls.must_equal ["SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[2]::integer[])"]
+    @o2.artists2.first.tags.must_equal [@o2]
+    @db.sqls.must_equal []
   end
   
   it "should cascade eagerly loading when the :eager_graph association option is used" do
@@ -315,37 +315,37 @@ describe Sequel::Model, "pg_array_associations" do
     @c2.dataset._fetch = {:id=>2, :artists_id=>1, :tag_ids=>Sequel.pg_array([1,2,3])}
     @c1.dataset._fetch = {:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3])}
 
-    @o1.tags2.should == [@o2]
-    @db.sqls.first.should =~ /SELECT tags\.id, artists\.id AS artists_id, artists\.tag_ids FROM tags LEFT OUTER JOIN artists ON \(artists.tag_ids @> ARRAY\[tags.id\]\) WHERE \(tags\.id IN \([123], [123], [123]\)\)/ 
-    @o1.tags2.first.artists.should == [@o1]
-    @db.sqls.should == []
+    @o1.tags2.must_equal [@o2]
+    @db.sqls.first.must_match(/SELECT tags\.id, artists\.id AS artists_id, artists\.tag_ids FROM tags LEFT OUTER JOIN artists ON \(artists.tag_ids @> ARRAY\[tags.id\]\) WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
+    @o1.tags2.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
 
-    @o2.artists2.should == [@o1]
-    @db.sqls.should == ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id]) WHERE (artists.tag_ids @> ARRAY[2]::integer[])"]
-    @o2.artists2.first.tags.should == [@o2]
-    @db.sqls.should == []
+    @o2.artists2.must_equal [@o1]
+    @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id]) WHERE (artists.tag_ids @> ARRAY[2]::integer[])"]
+    @o2.artists2.first.tags.must_equal [@o2]
+    @db.sqls.must_equal []
 
     @c2.dataset._fetch = {:id=>2, :artists_id=>1, :tag_ids=>Sequel.pg_array([1,2,3])}
     @c1.dataset._fetch = {:id=>1, :tag_ids=>Sequel.pg_array([1,2,3])}
 
     a = @c1.eager(:tags2).all
     sqls = @db.sqls
-    sqls.pop.should =~ /SELECT tags\.id, artists\.id AS artists_id, artists\.tag_ids FROM tags LEFT OUTER JOIN artists ON \(artists.tag_ids @> ARRAY\[tags.id\]\) WHERE \(tags\.id IN \([123], [123], [123]\)\)/ 
-    sqls.should == ["SELECT * FROM artists"]
-    a.should == [@o1]
-    a.first.tags2.should == [@o2]
-    a.first.tags2.first.artists.should == [@o1]
-    @db.sqls.should == []
+    sqls.pop.must_match(/SELECT tags\.id, artists\.id AS artists_id, artists\.tag_ids FROM tags LEFT OUTER JOIN artists ON \(artists.tag_ids @> ARRAY\[tags.id\]\) WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
+    sqls.must_equal ["SELECT * FROM artists"]
+    a.must_equal [@o1]
+    a.first.tags2.must_equal [@o2]
+    a.first.tags2.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
 
     @c2.dataset._fetch = {:id=>2}
     @c1.dataset._fetch = {:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3])}
 
     a = @c2.eager(:artists2).all
-    @db.sqls.should == ["SELECT * FROM tags", "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id]) WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
-    a.should == [@o2]
-    a.first.artists2.should == [@o1]
-    a.first.artists2.first.tags.should == [@o2]
-    @db.sqls.should == []
+    @db.sqls.must_equal ["SELECT * FROM tags", "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id]) WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
+    a.must_equal [@o2]
+    a.first.artists2.must_equal [@o1]
+    a.first.artists2.first.tags.must_equal [@o2]
+    @db.sqls.must_equal []
   end
   
   it "should respect the :limit option when eager loading" do
@@ -353,64 +353,64 @@ describe Sequel::Model, "pg_array_associations" do
 
     @c1.pg_array_to_many :tags, :clone=>:tags, :limit=>2
     a = @c1.eager(:tags).all
-    a.should == [@o1]
+    a.must_equal [@o1]
     sqls = @db.sqls
-    sqls.pop.should =~ /SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/ 
-    sqls.should == ["SELECT * FROM artists"]
-    a.first.tags.should == [@c2.load(:id=>1), @c2.load(:id=>2)]
-    @db.sqls.should == []
+    sqls.pop.must_match(/SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
+    sqls.must_equal ["SELECT * FROM artists"]
+    a.first.tags.must_equal [@c2.load(:id=>1), @c2.load(:id=>2)]
+    @db.sqls.must_equal []
 
     @c1.pg_array_to_many :tags, :clone=>:tags, :limit=>[1, 1]
     a = @c1.eager(:tags).all
-    a.should == [@o1]
+    a.must_equal [@o1]
     sqls = @db.sqls
-    sqls.pop.should =~ /SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/ 
-    sqls.should == ["SELECT * FROM artists"]
-    a.first.tags.should == [@c2.load(:id=>2)]
-    @db.sqls.should == []
+    sqls.pop.must_match(/SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
+    sqls.must_equal ["SELECT * FROM artists"]
+    a.first.tags.must_equal [@c2.load(:id=>2)]
+    @db.sqls.must_equal []
 
     @c1.pg_array_to_many :tags, :clone=>:tags, :limit=>[nil, 1]
     a = @c1.eager(:tags).all
-    a.should == [@o1]
+    a.must_equal [@o1]
     sqls = @db.sqls
-    sqls.pop.should =~ /SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/ 
-    sqls.should == ["SELECT * FROM artists"]
-    a.first.tags.should == [@c2.load(:id=>2), @c2.load(:id=>3)]
-    @db.sqls.length.should == 0
+    sqls.pop.must_match(/SELECT \* FROM tags WHERE \(tags\.id IN \([123], [123], [123]\)\)/)
+    sqls.must_equal ["SELECT * FROM artists"]
+    a.first.tags.must_equal [@c2.load(:id=>2), @c2.load(:id=>3)]
+    @db.sqls.length.must_equal 0
 
     @c2.dataset._fetch = [{:id=>2}]
     @c1.dataset._fetch = [{:id=>5, :tag_ids=>Sequel.pg_array([1,2,3])},{:id=>6, :tag_ids=>Sequel.pg_array([2,3])}, {:id=>7, :tag_ids=>Sequel.pg_array([1,2])}]
 
     @c2.many_to_pg_array :artists, :clone=>:artists, :limit=>2
     a = @c2.eager(:artists).all
-    a.should == [@o2]
-    @db.sqls.should == ['SELECT * FROM tags', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
-    a.first.artists.should == [@c1.load(:id=>5, :tag_ids=>Sequel.pg_array([1,2,3])), @c1.load(:id=>6, :tag_ids=>Sequel.pg_array([2,3]))]
-    @db.sqls.should == []
+    a.must_equal [@o2]
+    @db.sqls.must_equal ['SELECT * FROM tags', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
+    a.first.artists.must_equal [@c1.load(:id=>5, :tag_ids=>Sequel.pg_array([1,2,3])), @c1.load(:id=>6, :tag_ids=>Sequel.pg_array([2,3]))]
+    @db.sqls.must_equal []
 
     @c2.many_to_pg_array :artists, :clone=>:artists, :limit=>[1, 1]
     a = @c2.eager(:artists).all
-    a.should == [@o2]
-    @db.sqls.should == ['SELECT * FROM tags', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
-    a.first.artists.should == [@c1.load(:id=>6, :tag_ids=>Sequel.pg_array([2,3]))]
-    @db.sqls.should == []
+    a.must_equal [@o2]
+    @db.sqls.must_equal ['SELECT * FROM tags', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
+    a.first.artists.must_equal [@c1.load(:id=>6, :tag_ids=>Sequel.pg_array([2,3]))]
+    @db.sqls.must_equal []
 
     @c2.many_to_pg_array :artists, :clone=>:artists, :limit=>[nil, 1]
     a = @c2.eager(:artists).all
-    a.should == [@o2]
-    @db.sqls.should == ['SELECT * FROM tags', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
-    a.first.artists.should == [@c1.load(:id=>6, :tag_ids=>Sequel.pg_array([2,3])), @c1.load(:id=>7, :tag_ids=>Sequel.pg_array([1,2]))]
-    @db.sqls.should == []
+    a.must_equal [@o2]
+    @db.sqls.must_equal ['SELECT * FROM tags', "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::integer[])"]
+    a.first.artists.must_equal [@c1.load(:id=>6, :tag_ids=>Sequel.pg_array([2,3])), @c1.load(:id=>7, :tag_ids=>Sequel.pg_array([1,2]))]
+    @db.sqls.must_equal []
   end
 
   it "should support association_join" do
-    @c1.association_join(:tags).sql.should == "SELECT * FROM artists INNER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"
-    @c2.association_join(:artists).sql.should == "SELECT * FROM tags INNER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"
+    @c1.association_join(:tags).sql.must_equal "SELECT * FROM artists INNER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"
+    @c2.association_join(:artists).sql.must_equal "SELECT * FROM tags INNER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"
   end
 
   it "should support custom selects when using association_join" do
-    @c1.select{a(b)}.association_join(:tags).sql.should == "SELECT a(b) FROM artists INNER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"
-    @c2.select{a(b)}.association_join(:artists).sql.should == "SELECT a(b) FROM tags INNER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"
+    @c1.select{a(b)}.association_join(:tags).sql.must_equal "SELECT a(b) FROM artists INNER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"
+    @c2.select{a(b)}.association_join(:artists).sql.must_equal "SELECT a(b) FROM tags INNER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"
   end
 
   it "should eagerly graph associations" do
@@ -418,16 +418,16 @@ describe Sequel::Model, "pg_array_associations" do
     @c1.dataset._fetch = {:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3])}
 
     a = @c1.eager_graph(:tags).all
-    @db.sqls.should == ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"]
-    a.should == [@o1]
-    a.first.tags.should == [@o2]
-    @db.sqls.should == []
+    @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"]
+    a.must_equal [@o1]
+    a.first.tags.must_equal [@o2]
+    @db.sqls.must_equal []
 
     a = @c2.eager_graph(:artists).all
-    @db.sqls.should == ["SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"]
-    a.should == [@o2]
-    a.first.artists.should == [@o1]
-    @db.sqls.should == []
+    @db.sqls.must_equal ["SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"]
+    a.must_equal [@o2]
+    a.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
   end
 
   it "should allow cascading of eager graphing for associations of associated models" do
@@ -435,18 +435,18 @@ describe Sequel::Model, "pg_array_associations" do
     @c1.dataset._fetch = {:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3]), :artists_0_id=>1, :artists_0_tag_ids=>Sequel.pg_array([1,2,3])}
 
     a = @c1.eager_graph(:tags=>:artists).all
-    @db.sqls.should == ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id, artists_0.id AS artists_0_id, artists_0.tag_ids AS artists_0_tag_ids FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id]) LEFT OUTER JOIN artists AS artists_0 ON (artists_0.tag_ids @> ARRAY[tags.id])"]
-    a.should == [@o1]
-    a.first.tags.should == [@o2]
-    a.first.tags.first.artists.should == [@o1]
-    @db.sqls.should == []
+    @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id, artists_0.id AS artists_0_id, artists_0.tag_ids AS artists_0_tag_ids FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id]) LEFT OUTER JOIN artists AS artists_0 ON (artists_0.tag_ids @> ARRAY[tags.id])"]
+    a.must_equal [@o1]
+    a.first.tags.must_equal [@o2]
+    a.first.tags.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
 
     a = @c2.eager_graph(:artists=>:tags).all
-    @db.sqls.should == ["SELECT tags.id, artists.id AS artists_id, artists.tag_ids, tags_0.id AS tags_0_id FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id]) LEFT OUTER JOIN tags AS tags_0 ON (artists.tag_ids @> ARRAY[tags_0.id])"]
-    a.should == [@o2]
-    a.first.artists.should == [@o1]
-    a.first.artists.first.tags.should == [@o2]
-    @db.sqls.should == []
+    @db.sqls.must_equal ["SELECT tags.id, artists.id AS artists_id, artists.tag_ids, tags_0.id AS tags_0_id FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id]) LEFT OUTER JOIN tags AS tags_0 ON (artists.tag_ids @> ARRAY[tags_0.id])"]
+    a.must_equal [@o2]
+    a.first.artists.must_equal [@o1]
+    a.first.artists.first.tags.must_equal [@o2]
+    @db.sqls.must_equal []
   end
   
   it "eager graphing should respect key options" do 
@@ -458,16 +458,16 @@ describe Sequel::Model, "pg_array_associations" do
     @c1.dataset._fetch = {:id=>1, :tags_id=>2, :tag_ids=>Sequel.pg_array([1,2,3]), :artists_0_id=>1, :artists_0_tag_ids=>Sequel.pg_array([1,2,3])}
 
     a = @c1.eager_graph(:tags).all
-    a.should == [@o1]
-    @db.sqls.should == ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids[1:2] @> ARRAY[(tags.id * 3)])"]
-    a.first.tags.should == [@o2]
-    @db.sqls.should == []
+    a.must_equal [@o1]
+    @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids[1:2] @> ARRAY[(tags.id * 3)])"]
+    a.first.tags.must_equal [@o2]
+    @db.sqls.must_equal []
 
     a = @c2.eager_graph(:artists).all
-    a.should == [@o2]
-    @db.sqls.should == ["SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids[1:2] @> ARRAY[tags.id3])"]
-    a.first.artists.should == [@o1]
-    @db.sqls.should == []
+    a.must_equal [@o2]
+    @db.sqls.must_equal ["SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids[1:2] @> ARRAY[tags.id3])"]
+    a.first.artists.must_equal [@o1]
+    @db.sqls.must_equal []
   end
   
   it "should respect the association's :graph_select option" do 
@@ -478,177 +478,177 @@ describe Sequel::Model, "pg_array_associations" do
     @c1.dataset._fetch = {:id=>1, :id2=>2, :tag_ids=>Sequel.pg_array([1,2,3])}
 
     a = @c1.eager_graph(:tags).all
-    @db.sqls.should == ["SELECT artists.id, artists.tag_ids, tags.id2 FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"]
-    a.should == [@o1]
-    a.first.tags.should == [@c2.load(:id2=>2)]
-    @db.sqls.should == []
+    @db.sqls.must_equal ["SELECT artists.id, artists.tag_ids, tags.id2 FROM artists LEFT OUTER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"]
+    a.must_equal [@o1]
+    a.first.tags.must_equal [@c2.load(:id2=>2)]
+    @db.sqls.must_equal []
 
     a = @c2.eager_graph(:artists).all
-    @db.sqls.should == ["SELECT tags.id, artists.id AS artists_id FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"]
-    a.should == [@o2]
-    a.first.artists.should == [@c1.load(:id=>1)]
-    @db.sqls.should == []
+    @db.sqls.must_equal ["SELECT tags.id, artists.id AS artists_id FROM tags LEFT OUTER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"]
+    a.must_equal [@o2]
+    a.first.artists.must_equal [@c1.load(:id=>1)]
+    @db.sqls.must_equal []
   end
 
   it "should respect the association's :graph_join_type option" do 
     @c1.pg_array_to_many :tags, :clone=>:tags, :graph_join_type=>:inner
     @c2.many_to_pg_array :artists, :clone=>:artists, :graph_join_type=>:inner
-    @c1.eager_graph(:tags).sql.should == "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists INNER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"
-    @c2.eager_graph(:artists).sql.should == "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags INNER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"
+    @c1.eager_graph(:tags).sql.must_equal "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists INNER JOIN tags ON (artists.tag_ids @> ARRAY[tags.id])"
+    @c2.eager_graph(:artists).sql.must_equal "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags INNER JOIN artists ON (artists.tag_ids @> ARRAY[tags.id])"
   end
 
   it "should respect the association's :conditions option" do 
     @c1.pg_array_to_many :tags, :clone=>:tags, :conditions=>{:a=>1}
     @c2.many_to_pg_array :artists, :clone=>:artists, :conditions=>{:a=>1}
-    @c1.eager_graph(:tags).sql.should == "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((tags.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
-    @c2.eager_graph(:artists).sql.should == "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
+    @c1.eager_graph(:tags).sql.must_equal "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((tags.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
+    @c2.eager_graph(:artists).sql.must_equal "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
   end
 
   it "should respect the association's :graph_conditions option" do 
     @c1.pg_array_to_many :tags, :clone=>:tags, :graph_conditions=>{:a=>1}
     @c2.many_to_pg_array :artists, :clone=>:artists, :graph_conditions=>{:a=>1}
-    @c1.eager_graph(:tags).sql.should == "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((tags.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
-    @c2.eager_graph(:artists).sql.should == "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
+    @c1.eager_graph(:tags).sql.must_equal "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((tags.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
+    @c2.eager_graph(:artists).sql.must_equal "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
   end
 
   it "should respect the association's :graph_block option" do 
     @c1.pg_array_to_many :tags, :clone=>:tags, :graph_block=>proc{|ja,lja,js| {Sequel.qualify(ja, :a)=>1}}
     @c2.many_to_pg_array :artists, :clone=>:artists, :graph_block=>proc{|ja,lja,js| {Sequel.qualify(ja, :a)=>1}}
-    @c1.eager_graph(:tags).sql.should == "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((tags.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
-    @c2.eager_graph(:artists).sql.should == "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
+    @c1.eager_graph(:tags).sql.must_equal "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((tags.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
+    @c2.eager_graph(:artists).sql.must_equal "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.a = 1) AND (artists.tag_ids @> ARRAY[tags.id]))"
   end
 
   it "should respect the association's :graph_only_conditions option" do 
     @c1.pg_array_to_many :tags, :clone=>:tags, :graph_only_conditions=>{:a=>1}
     @c2.many_to_pg_array :artists, :clone=>:artists, :graph_only_conditions=>{:a=>1}
-    @c1.eager_graph(:tags).sql.should == "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (tags.a = 1)"
-    @c2.eager_graph(:artists).sql.should == "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON (artists.a = 1)"
+    @c1.eager_graph(:tags).sql.must_equal "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON (tags.a = 1)"
+    @c2.eager_graph(:artists).sql.must_equal "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON (artists.a = 1)"
   end
 
   it "should respect the association's :graph_only_conditions with :graph_block option" do 
     @c1.pg_array_to_many :tags, :clone=>:tags, :graph_only_conditions=>{:a=>1}, :graph_block=>proc{|ja,lja,js| {Sequel.qualify(lja, :b)=>1}}
     @c2.many_to_pg_array :artists, :clone=>:artists, :graph_only_conditions=>{:a=>1}, :graph_block=>proc{|ja,lja,js| {Sequel.qualify(lja, :b)=>1}}
-    @c1.eager_graph(:tags).sql.should == "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((tags.a = 1) AND (artists.b = 1))"
-    @c2.eager_graph(:artists).sql.should == "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.a = 1) AND (tags.b = 1))"
+    @c1.eager_graph(:tags).sql.must_equal "SELECT artists.id, artists.tag_ids, tags.id AS tags_id FROM artists LEFT OUTER JOIN tags ON ((tags.a = 1) AND (artists.b = 1))"
+    @c2.eager_graph(:artists).sql.must_equal "SELECT tags.id, artists.id AS artists_id, artists.tag_ids FROM tags LEFT OUTER JOIN artists ON ((artists.a = 1) AND (tags.b = 1))"
   end
 
   it "should define an add_ method for adding associated objects" do
     @o1.add_tag(@c2.load(:id=>4))
-    @o1.tag_ids.should == [1,2,3,4]
-    @db.sqls.should == []
+    @o1.tag_ids.must_equal [1,2,3,4]
+    @db.sqls.must_equal []
     @o1.save_changes
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[1,2,3,4] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[1,2,3,4] WHERE (id = 1)"]
 
     @o2.add_artist(@c1.load(:id=>1, :tag_ids=>Sequel.pg_array([4])))
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[4,2] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[4,2] WHERE (id = 1)"]
   end
 
   it "should define a remove_ method for removing associated objects" do
     @o1.remove_tag(@o2)
-    @o1.tag_ids.should == [1,3]
-    @db.sqls.should == []
+    @o1.tag_ids.must_equal [1,3]
+    @db.sqls.must_equal []
     @o1.save_changes
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[1,3] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[1,3] WHERE (id = 1)"]
 
     @o2.remove_artist(@c1.load(:id=>1, :tag_ids=>Sequel.pg_array([1,2,3,4])))
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[1,3,4] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[1,3,4] WHERE (id = 1)"]
   end
 
   it "should define a remove_all_ method for removing all associated objects" do
     @o1.remove_all_tags
-    @o1.tag_ids.should == []
-    @db.sqls.should == []
+    @o1.tag_ids.must_equal []
+    @db.sqls.must_equal []
     @o1.save_changes
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[] WHERE (id = 1)"]
 
     @o2.remove_all_artists
-    @db.sqls.should == ["UPDATE artists SET tag_ids = array_remove(tag_ids, 2) WHERE (tag_ids @> ARRAY[2])"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = array_remove(tag_ids, 2) WHERE (tag_ids @> ARRAY[2])"]
   end
 
   it "should allow calling add_ and remove_ methods on new objects for pg_array_to_many associations" do
     a = Artist.new
     a.add_tag(@c2.load(:id=>4))
-    a.tag_ids.should == [4]
+    a.tag_ids.must_equal [4]
     a.remove_tag(@c2.load(:id=>4))
-    a.tag_ids.should == []
+    a.tag_ids.must_equal []
     a.add_tag(@c2.load(:id=>4))
-    a.tag_ids.should == [4]
+    a.tag_ids.must_equal [4]
     a.remove_all_tags
-    a.tag_ids.should == []
+    a.tag_ids.must_equal []
   end
 
   it "should have pg_array_to_many association modification methods save if :save_after_modify option is used" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :save_after_modify=>true
 
     @o1.add_tag(@c2.load(:id=>4))
-    @o1.tag_ids.should == [1,2,3,4]
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[1,2,3,4] WHERE (id = 1)"]
+    @o1.tag_ids.must_equal [1,2,3,4]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[1,2,3,4] WHERE (id = 1)"]
 
     @o1.remove_tag(@o2)
-    @o1.tag_ids.should == [1,3,4]
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[1,3,4] WHERE (id = 1)"]
+    @o1.tag_ids.must_equal [1,3,4]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[1,3,4] WHERE (id = 1)"]
 
     @o1.remove_all_tags
-    @o1.tag_ids.should == []
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[] WHERE (id = 1)"]
+    @o1.tag_ids.must_equal []
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[] WHERE (id = 1)"]
   end
 
   it "should have association modification methods deal with nil values" do
     v = @c1.load(:id=>1)
     v.add_tag(@c2.load(:id=>4))
-    v.tag_ids.should == [4]
-    @db.sqls.should == []
+    v.tag_ids.must_equal [4]
+    @db.sqls.must_equal []
     v.save_changes
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[4]::integer[] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[4]::integer[] WHERE (id = 1)"]
 
     @o2.add_artist(@c1.load(:id=>1))
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[2]::integer[] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[2]::integer[] WHERE (id = 1)"]
 
     v = @c1.load(:id=>1)
     v.remove_tag(@c2.load(:id=>4))
-    v.tag_ids.should == nil
-    @db.sqls.should == []
+    v.tag_ids.must_equal nil
+    @db.sqls.must_equal []
     v.save_changes
-    @db.sqls.should == []
+    @db.sqls.must_equal []
 
     @o2.remove_artist(@c1.load(:id=>1))
-    @db.sqls.should == []
+    @db.sqls.must_equal []
 
     v = @c1.load(:id=>1)
     v.remove_all_tags
-    v.tag_ids.should == nil
-    @db.sqls.should == []
+    v.tag_ids.must_equal nil
+    @db.sqls.must_equal []
     v.save_changes
-    @db.sqls.should == []
+    @db.sqls.must_equal []
   end
 
   it "should have association modification methods deal with empty arrays values" do
     v = @c1.load(:id=>1, :tag_ids=>Sequel.pg_array([]))
     v.add_tag(@c2.load(:id=>4))
-    v.tag_ids.should == [4]
-    @db.sqls.should == []
+    v.tag_ids.must_equal [4]
+    @db.sqls.must_equal []
     v.save_changes
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[4] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[4] WHERE (id = 1)"]
 
     @o2.add_artist(@c1.load(:id=>1, :tag_ids=>Sequel.pg_array([])))
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[2] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[2] WHERE (id = 1)"]
 
     v = @c1.load(:id=>1, :tag_ids=>Sequel.pg_array([]))
     v.remove_tag(@c2.load(:id=>4))
-    v.tag_ids.should == []
-    @db.sqls.should == []
+    v.tag_ids.must_equal []
+    @db.sqls.must_equal []
     v.save_changes
-    @db.sqls.should == []
+    @db.sqls.must_equal []
 
     @o2.remove_artist(@c1.load(:id=>1, :tag_ids=>Sequel.pg_array([])))
-    @db.sqls.should == []
+    @db.sqls.must_equal []
 
     v = @c1.load(:id=>1, :tag_ids=>Sequel.pg_array([]))
     v.remove_all_tags
-    v.tag_ids.should == []
-    @db.sqls.should == []
+    v.tag_ids.must_equal []
+    @db.sqls.must_equal []
     v.save_changes
-    @db.sqls.should == []
+    @db.sqls.must_equal []
   end
 
   it "should respect the :array_type option when manually creating arrays" do
@@ -656,39 +656,39 @@ describe Sequel::Model, "pg_array_associations" do
     @c2.many_to_pg_array :artists, :clone=>:artists, :array_type=>:int8
     v = @c1.load(:id=>1)
     v.add_tag(@c2.load(:id=>4))
-    v.tag_ids.should == [4]
-    @db.sqls.should == []
+    v.tag_ids.must_equal [4]
+    @db.sqls.must_equal []
     v.save_changes
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[4]::int8[] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[4]::int8[] WHERE (id = 1)"]
 
     @o2.add_artist(@c1.load(:id=>1))
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[2]::int8[] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[2]::int8[] WHERE (id = 1)"]
   end
 
   it "should respect the :array_type option in the associations dataset" do
     @c2.many_to_pg_array :artists, :clone=>:artists, :array_type=>:int8
-    @c2.load(:id=>1).artists_dataset.sql.should == 'SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[1]::int8[])'
+    @c2.load(:id=>1).artists_dataset.sql.must_equal 'SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[1]::int8[])'
   end
 
   it "should respect the :array_type option when eager loading" do
     @c2.many_to_pg_array :artists, :clone=>:artists, :array_type=>:int8
     @c2.eager(:artists).all
-    @db.sqls.should == ["SELECT * FROM tags", "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::int8[])"]
+    @db.sqls.must_equal ["SELECT * FROM tags", "SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[2]::int8[])"]
   end
 
   it "should respect the :array_type option when filtering by associations" do
     @c1.pg_array_to_many :tags, :clone=>:tags, :array_type=>:int8
-    @c1.where(:tags=>@c2.load(:id=>1)).sql.should == 'SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[1]::int8[])'
-    @c1.where(:tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.should == 'SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[1,2]::int8[])'
+    @c1.where(:tags=>@c2.load(:id=>1)).sql.must_equal 'SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[1]::int8[])'
+    @c1.where(:tags=>[@c2.load(:id=>1), @c2.load(:id=>2)]).sql.must_equal 'SELECT * FROM artists WHERE (artists.tag_ids && ARRAY[1,2]::int8[])'
   end
 
   it "should automatically determine the array type by looking at the schema" do
     @c1.db_schema[:tag_ids][:db_type] = 'int8'
     @c2.many_to_pg_array :artists, :clone=>:artists
     @c1.pg_array_to_many :tags, :clone=>:tags, :save_after_modify=>true
-    @c2.load(:id=>1).artists_dataset.sql.should == 'SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[1]::int8[])'
+    @c2.load(:id=>1).artists_dataset.sql.must_equal 'SELECT * FROM artists WHERE (artists.tag_ids @> ARRAY[1]::int8[])'
     @c1.load(:id=>1).add_tag(@c2.load(:id=>1))
-    @db.sqls.should == ["UPDATE artists SET tag_ids = ARRAY[1]::int8[] WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE artists SET tag_ids = ARRAY[1]::int8[] WHERE (id = 1)"]
   end
 
   it "should automatically determine the array type by looking at the schema" do
@@ -701,16 +701,16 @@ describe Sequel::Model, "pg_array_associations" do
     t = @c2.load(:id=>2)
     def a.validate() errors.add(:id, 'foo') end
     a.associations[:tags] = []
-    a.add_tag(t).should == t
-    a.tags.should == [t]
-    a.remove_tag(t).should == t
-    a.tags.should == []
+    a.add_tag(t).must_equal t
+    a.tags.must_equal [t]
+    a.remove_tag(t).must_equal t
+    a.tags.must_equal []
 
     t.associations[:artists] = []
-    t.add_artist(a).should == a
-    t.artists.should == [a]
-    t.remove_artist(a).should == a
-    t.artists.should == []
+    t.add_artist(a).must_equal a
+    t.artists.must_equal [a]
+    t.remove_artist(a).must_equal a
+    t.artists.must_equal []
   end
 
   it "should not raise exception in add_ and remove_ if the :raise_on_save_failure=>false option is used" do
@@ -720,17 +720,17 @@ describe Sequel::Model, "pg_array_associations" do
     t = @c2.load(:id=>2)
     def a.validate() errors.add(:id, 'foo') end
     a.associations[:tags] = []
-    a.add_tag(t).should == nil
-    a.tags.should == []
+    a.add_tag(t).must_equal nil
+    a.tags.must_equal []
     a.associations[:tags] = [t]
-    a.remove_tag(t).should == nil
-    a.tags.should == [t]
+    a.remove_tag(t).must_equal nil
+    a.tags.must_equal [t]
 
     t.associations[:artists] = []
-    t.add_artist(a).should == nil
-    t.artists.should == []
+    t.add_artist(a).must_equal nil
+    t.artists.must_equal []
     t.associations[:artists] = [a]
-    t.remove_artist(a).should == nil
-    t.artists.should == [a]
+    t.remove_artist(a).must_equal nil
+    t.artists.must_equal [a]
   end
 end