sequel 4.22.0 → 4.23.0

data/spec/extensions/server_block_spec.rb

@@ -1,26 +1,26 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-shared_examples_for "Database#with_server" do  
-  specify "should set the default server to use in the block" do
+with_server_specs = shared_description do
+  it "should set the default server to use in the block" do
     @db.with_server(:a){@db[:t].all}
-    @db.sqls.should == ["SELECT * FROM t -- a"]
+    @db.sqls.must_equal ["SELECT * FROM t -- a"]
     @db.with_server(:b){@db[:t].all}
-    @db.sqls.should == ["SELECT * FROM t -- b"]
+    @db.sqls.must_equal ["SELECT * FROM t -- b"]
   end
 
-  specify "should have no affect after the block" do
+  it "should have no affect after the block" do
     @db.with_server(:a){@db[:t].all}
-    @db.sqls.should == ["SELECT * FROM t -- a"]
+    @db.sqls.must_equal ["SELECT * FROM t -- a"]
     @db[:t].all
-    @db.sqls.should == ["SELECT * FROM t"]
+    @db.sqls.must_equal ["SELECT * FROM t"]
   end
 
-  specify "should not override specific server inside the block" do
+  it "should not override specific server inside the block" do
     @db.with_server(:a){@db[:t].server(:b).all}
-    @db.sqls.should == ["SELECT * FROM t -- b"]
+    @db.sqls.must_equal ["SELECT * FROM t -- b"]
   end
 
-  specify "should work correctly when blocks are nested" do
+  it "should work correctly when blocks are nested" do
     @db[:t].all
     @db.with_server(:a) do
       @db[:t].all
@@ -28,16 +28,16 @@ shared_examples_for "Database#with_server" do
       @db[:t].all
     end
     @db[:t].all
-    @db.sqls.should == ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t"]
+    @db.sqls.must_equal ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t"]
   end
 
-  specify "should work correctly for inserts/updates/deletes" do
+  it "should work correctly for inserts/updates/deletes" do
     @db.with_server(:a) do
       @db[:t].insert
       @db[:t].update(:a=>1)
       @db[:t].delete
     end
-    @db.sqls.should == ["INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
+    @db.sqls.must_equal ["INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
   end
 end
 
@@ -47,7 +47,7 @@ describe "Database#with_server single threaded" do
     @db.extension :server_block
   end
 
-  it_should_behave_like "Database#with_server"
+  include with_server_specs
 end
 
 describe "Database#with_server multi threaded" do
@@ -56,9 +56,9 @@ describe "Database#with_server multi threaded" do
     @db.extension :server_block
   end
 
-  it_should_behave_like "Database#with_server"
+  include with_server_specs
 
-  specify "should respect multithreaded access" do
+  it "should respect multithreaded access" do
     q, q1 = Queue.new, Queue.new
     
     t = nil
@@ -83,7 +83,7 @@ describe "Database#with_server multi threaded" do
     @db[:t].all
     q1.push nil
     t.join
-    @db.sqls.should == ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t -- d",
+    @db.sqls.must_equal ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t -- d",
       "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t"]
   end
 end

data/spec/extensions/set_overrides_spec.rb

@@ -5,30 +5,30 @@ describe "Sequel::Dataset #set_defaults" do
     @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_defaults(:x=>1)
   end
 
-  specify "should set the default values for inserts" do
-    @ds.insert_sql.should == "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:x=>2).should == "INSERT INTO items (x) VALUES (2)"
-    @ds.insert_sql(:y=>2).should =~ /INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/
-    @ds.set_defaults(:y=>2).insert_sql.should =~ /INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/
-    @ds.set_defaults(:x=>2).insert_sql.should == "INSERT INTO items (x) VALUES (2)"
+  it "should set the default values for inserts" do
+    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
+    @ds.insert_sql(:x=>2).must_equal "INSERT INTO items (x) VALUES (2)"
+    @ds.insert_sql(:y=>2).must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
+    @ds.set_defaults(:y=>2).insert_sql.must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
+    @ds.set_defaults(:x=>2).insert_sql.must_equal "INSERT INTO items (x) VALUES (2)"
   end
 
-  specify "should set the default values for updates" do
-    @ds.update_sql.should == "UPDATE items SET x = 1"
-    @ds.update_sql(:x=>2).should == "UPDATE items SET x = 2"
-    @ds.update_sql(:y=>2).should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
-    @ds.set_defaults(:y=>2).update_sql.should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
-    @ds.set_defaults(:x=>2).update_sql.should == "UPDATE items SET x = 2"
+  it "should set the default values for updates" do
+    @ds.update_sql.must_equal "UPDATE items SET x = 1"
+    @ds.update_sql(:x=>2).must_equal "UPDATE items SET x = 2"
+    @ds.update_sql(:y=>2).must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
+    @ds.set_defaults(:y=>2).update_sql.must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
+    @ds.set_defaults(:x=>2).update_sql.must_equal "UPDATE items SET x = 2"
   end
 
-  specify "should not affect String update arguments" do
-    @ds.update_sql('y = 2').should == "UPDATE items SET y = 2"
+  it "should not affect String update arguments" do
+    @ds.update_sql('y = 2').must_equal "UPDATE items SET y = 2"
   end
 
-  specify "should have working mutation method" do
+  it "should have working mutation method" do
     @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides)
     @ds.set_defaults!(:x=>1)
-    @ds.insert_sql.should == "INSERT INTO items (x) VALUES (1)"
+    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
   end
 end
 
@@ -37,25 +37,25 @@ describe "Sequel::Dataset #set_overrides" do
     @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_overrides(:x=>1)
   end
 
-  specify "should override the given values for inserts" do
-    @ds.insert_sql.should == "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:x=>2).should == "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:y=>2).should =~ /INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/
-    @ds.set_overrides(:y=>2).insert_sql.should =~ /INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/
-    @ds.set_overrides(:x=>2).insert_sql.should == "INSERT INTO items (x) VALUES (1)"
+  it "should override the given values for inserts" do
+    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
+    @ds.insert_sql(:x=>2).must_equal "INSERT INTO items (x) VALUES (1)"
+    @ds.insert_sql(:y=>2).must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
+    @ds.set_overrides(:y=>2).insert_sql.must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
+    @ds.set_overrides(:x=>2).insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
   end
 
-  specify "should override the given values for updates" do
-    @ds.update_sql.should == "UPDATE items SET x = 1"
-    @ds.update_sql(:x=>2).should == "UPDATE items SET x = 1"
-    @ds.update_sql(:y=>2).should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
-    @ds.set_overrides(:y=>2).update_sql.should =~ /UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/
-    @ds.set_overrides(:x=>2).update_sql.should == "UPDATE items SET x = 1"
+  it "should override the given values for updates" do
+    @ds.update_sql.must_equal "UPDATE items SET x = 1"
+    @ds.update_sql(:x=>2).must_equal "UPDATE items SET x = 1"
+    @ds.update_sql(:y=>2).must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
+    @ds.set_overrides(:y=>2).update_sql.must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
+    @ds.set_overrides(:x=>2).update_sql.must_equal "UPDATE items SET x = 1"
   end
 
-  specify "should have working mutation method" do
+  it "should have working mutation method" do
     @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides)
     @ds.set_overrides!(:x=>1)
-    @ds.insert_sql.should == "INSERT INTO items (x) VALUES (1)"
+    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
   end
 end

data/spec/extensions/sharding_spec.rb

@@ -27,172 +27,172 @@ describe "sharding plugin" do
     @db.sqls
   end 
 
-  specify "should allow you to instantiate a new object for a specified shard" do
+  it "should allow you to instantiate a new object for a specified shard" do
     @Album.new_using_server(:s1, :name=>'RF').save
-    @db.sqls.should == ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
+    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
     
     @Album.new_using_server(:s2){|o| o.name = 'MO'}.save
-    @db.sqls.should == ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
+    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
   end 
 
-  specify "should allow you to create and save a new object for a specified shard" do
+  it "should allow you to create and save a new object for a specified shard" do
     @Album.create_using_server(:s1, :name=>'RF')
-    @db.sqls.should == ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
+    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
 
     @Album.create_using_server(:s2){|o| o.name = 'MO'}
-    @db.sqls.should == ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
+    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
   end 
 
-  specify "should have objects retrieved from a specific shard update that shard" do
+  it "should have objects retrieved from a specific shard update that shard" do
     @Album.server(:s1).first.update(:name=>'MO')
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s1"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s1"]
   end 
 
-  specify "should have objects retrieved from a specific shard delete from that shard" do
+  it "should have objects retrieved from a specific shard delete from that shard" do
     @Album.server(:s1).first.delete
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "DELETE FROM albums WHERE (id = 1) -- s1"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "DELETE FROM albums WHERE (id = 1) -- s1"]
   end 
 
-  specify "should have objects retrieved from a specific shard reload from that shard" do
+  it "should have objects retrieved from a specific shard reload from that shard" do
     @Album.server(:s1).first.reload
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
   end 
 
-  specify "should use current dataset's shard when eager loading if eagerly loaded dataset doesn't have its own shard" do
+  it "should use current dataset's shard when eager loading if eagerly loaded dataset doesn't have its own shard" do
     albums = @Album.server(:s1).eager(:artist).all
-    @db.sqls.should == ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s1"]
-    albums.length.should == 1
+    @db.sqls.must_equal ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s1"]
+    albums.length.must_equal 1
     albums.first.artist.save
-    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
   end 
 
-  specify "should not use current dataset's shard when eager loading if eagerly loaded dataset has its own shard" do
+  it "should not use current dataset's shard when eager loading if eagerly loaded dataset has its own shard" do
     @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
     albums = @Album.server(:s1).eager(:artist).all
-    @db.sqls.should == ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s2"]
-    albums.length.should == 1
+    @db.sqls.must_equal ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s2"]
+    albums.length.must_equal 1
     albums.first.artist.save
-    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
   end 
 
-  specify "should use current dataset's shard when eager graphing if eagerly graphed dataset doesn't have its own shard" do
+  it "should use current dataset's shard when eager graphing if eagerly graphed dataset doesn't have its own shard" do
     ds = @Album.server(:s1).eager_graph(:artist)
     ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
     albums = ds.all
-    @db.sqls.should == ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
-    albums.length.should == 1
+    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
+    albums.length.must_equal 1
     albums.first.artist.save
-    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
   end 
 
-  specify "should not use current dataset's shard when eager graphing if eagerly graphed dataset has its own shard" do
+  it "should not use current dataset's shard when eager graphing if eagerly graphed dataset has its own shard" do
     @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
     ds = @Album.server(:s1).eager_graph(:artist)
     ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
     albums = ds.all
-    @db.sqls.should == ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
-    albums.length.should == 1
+    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
+    albums.length.must_equal 1
     albums.first.artist.save
-    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
   end 
 
-  specify "should use eagerly graphed dataset shard for eagerly graphed objects even if current dataset does not have a shard" do
+  it "should use eagerly graphed dataset shard for eagerly graphed objects even if current dataset does not have a shard" do
     @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
     ds = @Album.eager_graph(:artist)
     ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
     albums = ds.all
-    @db.sqls.should == ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id)"]
-    albums.length.should == 1
+    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id)"]
+    albums.length.must_equal 1
     albums.first.artist.save
-    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
   end 
 
-  specify "should have objects retrieved from a specific shard use associated objects from that shard, with modifications to the associated objects using that shard" do
+  it "should have objects retrieved from a specific shard use associated objects from that shard, with modifications to the associated objects using that shard" do
     album = @Album.server(:s1).first
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1"]
     album.artist.update(:name=>'AS')
-    @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- s1", "UPDATE artists SET name = 'AS' WHERE (id = 2) -- s1"]
+    @db.sqls.must_equal ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- s1", "UPDATE artists SET name = 'AS' WHERE (id = 2) -- s1"]
     album.tags.map{|a| a.update(:name=>'SR')}
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) -- s1", "UPDATE tags SET name = 'SR' WHERE (id = 3) -- s1"]
+    @db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) -- s1", "UPDATE tags SET name = 'SR' WHERE (id = 3) -- s1"]
     @Artist.server(:s2).first.albums.map{|a| a.update(:name=>'MO')}
-    @db.sqls.should == ["SELECT * FROM artists LIMIT 1 -- s2", "SELECT * FROM albums WHERE (albums.artist_id = 2) -- s2", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s2"]
+    @db.sqls.must_equal ["SELECT * FROM artists LIMIT 1 -- s2", "SELECT * FROM albums WHERE (albums.artist_id = 2) -- s2", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s2"]
   end 
 
-  specify "should have objects retrieved from a specific shard add associated objects to that shard" do
+  it "should have objects retrieved from a specific shard add associated objects to that shard" do
     album = @Album.server(:s1).first
     artist = @Artist.server(:s2).first
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
 
     artist.add_album(:name=>'MO')
     sqls = @db.sqls
-    ["INSERT INTO albums (artist_id, name) VALUES (2, 'MO') -- s2", "INSERT INTO albums (name, artist_id) VALUES ('MO', 2) -- s2"].should include(sqls.shift)
-    sqls.should == ["SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
+    ["INSERT INTO albums (artist_id, name) VALUES (2, 'MO') -- s2", "INSERT INTO albums (name, artist_id) VALUES ('MO', 2) -- s2"].must_include(sqls.shift)
+    sqls.must_equal ["SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
     
     album.add_tag(:name=>'SR')
     sqls = @db.sqls
-    ["INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3) -- s1", "INSERT INTO albums_tags (tag_id, album_id) VALUES (3, 1) -- s1"].should include(sqls.pop)
-    sqls.should == ["INSERT INTO tags (name) VALUES ('SR') -- s1", "SELECT * FROM tags WHERE (id = 1) LIMIT 1 -- s1", ]
+    ["INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3) -- s1", "INSERT INTO albums_tags (tag_id, album_id) VALUES (3, 1) -- s1"].must_include(sqls.pop)
+    sqls.must_equal ["INSERT INTO tags (name) VALUES ('SR') -- s1", "SELECT * FROM tags WHERE (id = 1) LIMIT 1 -- s1", ]
   end 
 
-  specify "should have objects retrieved from a specific shard remove associated objects from that shard" do
+  it "should have objects retrieved from a specific shard remove associated objects from that shard" do
     album = @Album.server(:s1).first
     artist = @Artist.server(:s2).first
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
 
     artist.remove_album(1)
     sqls = @db.sqls
-    ["UPDATE albums SET artist_id = NULL, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = NULL WHERE (id = 1) -- s2"].should include(sqls.pop)
-    sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (albums.id = 1)) LIMIT 1 -- s2"]
+    ["UPDATE albums SET artist_id = NULL, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = NULL WHERE (id = 1) -- s2"].must_include(sqls.pop)
+    sqls.must_equal ["SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (albums.id = 1)) LIMIT 1 -- s2"]
     
     album.remove_tag(3)
-    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id = 1) AND (tags.id = 3)) LIMIT 1 -- s1", "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id = 3)) -- s1"]
+    @db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id = 1) AND (tags.id = 3)) LIMIT 1 -- s1", "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id = 3)) -- s1"]
   end 
 
-  specify "should have objects retrieved from a specific shard remove all associated objects from that shard" do
+  it "should have objects retrieved from a specific shard remove all associated objects from that shard" do
     album = @Album.server(:s1).first
     artist = @Artist.server(:s2).first
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
 
     artist.remove_all_albums
-    @db.sqls.should == ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 2) -- s2"]
+    @db.sqls.must_equal ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 2) -- s2"]
     
     album.remove_all_tags
-    @db.sqls.should == ["DELETE FROM albums_tags WHERE (album_id = 1) -- s1"]
+    @db.sqls.must_equal ["DELETE FROM albums_tags WHERE (album_id = 1) -- s1"]
   end 
 
-  specify "should not override a server already set on an associated object" do
+  it "should not override a server already set on an associated object" do
     @Album.server(:s1).first
     artist = @Artist.server(:s2).first
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
 
     artist.add_album(@Album.load(:id=>4, :name=>'MO').set_server(:s3))
-    ["UPDATE albums SET artist_id = 2, name = 'MO' WHERE (id = 4) -- s3", "UPDATE albums SET name = 'MO', artist_id = 2 WHERE (id = 4) -- s3"].should include(@db.sqls.pop)
+    ["UPDATE albums SET artist_id = 2, name = 'MO' WHERE (id = 4) -- s3", "UPDATE albums SET name = 'MO', artist_id = 2 WHERE (id = 4) -- s3"].must_include(@db.sqls.pop)
 
     artist.remove_album(@Album.load(:id=>5, :name=>'T', :artist_id=>2).set_server(:s4))
     # Should select from current object's shard to check existing association, but update associated object's shard
     sqls = @db.sqls
-    ["UPDATE albums SET artist_id = NULL, name = 'T' WHERE (id = 5) -- s4", "UPDATE albums SET name = 'T', artist_id = NULL WHERE (id = 5) -- s4"].should include(sqls.pop)
-    sqls.should == ["SELECT 1 AS one FROM albums WHERE ((albums.artist_id = 2) AND (id = 5)) LIMIT 1 -- s2"]
+    ["UPDATE albums SET artist_id = NULL, name = 'T' WHERE (id = 5) -- s4", "UPDATE albums SET name = 'T', artist_id = NULL WHERE (id = 5) -- s4"].must_include(sqls.pop)
+    sqls.must_equal ["SELECT 1 AS one FROM albums WHERE ((albums.artist_id = 2) AND (id = 5)) LIMIT 1 -- s2"]
   end 
 
-  specify "should be able to set a shard to use for any object using set_server" do
+  it "should be able to set a shard to use for any object using set_server" do
     @Album.server(:s1).first.set_server(:s2).reload
-    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
+    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
   end 
 
-  specify "should use transactions on the correct shard" do
+  it "should use transactions on the correct shard" do
     @Album.use_transactions = true
     @Album.server(:s2).first.save
     sqls = @db.sqls
-    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s2"].should include(sqls.slice!(2))
-    sqls.should == ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s2", "COMMIT -- s2"]
+    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s2"].must_include(sqls.slice!(2))
+    sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s2", "COMMIT -- s2"]
   end 
 
-  specify "should use override current shard when saving with given :server option" do
+  it "should use override current shard when saving with given :server option" do
     @Album.use_transactions = true
     @Album.server(:s2).first.save(:server=>:s1)
     sqls = @db.sqls
-    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s1", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s1"].should include(sqls.slice!(2))
-    sqls.should == ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s1", "COMMIT -- s1"]
+    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s1", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s1"].must_include(sqls.slice!(2))
+    sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s1", "COMMIT -- s1"]
   end 
 end

data/spec/extensions/shared_caching_spec.rb

@@ -21,75 +21,75 @@ describe "Shared caching behavior" do
     Object.send(:remove_const, :LookupModel)
   end
 
-  shared_examples_for "many_to_one_pk_lookup with composite keys" do
+  many_to_one_cpk_specs = shared_description do
     it "should use a simple primary key lookup when retrieving many_to_one associated records with a composite key" do
-      @db.sqls.should == []
-      @c.load(:id=>3, :caching_model_id=>1, :caching_model_id2=>2).caching_model2.should equal(@cm12)
-      @c.load(:id=>3, :caching_model_id=>2, :caching_model_id2=>1).caching_model2.should equal(@cm21)
-      @db.sqls.should == []
+      @db.sqls.must_equal []
+      @c.load(:id=>3, :caching_model_id=>1, :caching_model_id2=>2).caching_model2.must_be_same_as(@cm12)
+      @c.load(:id=>3, :caching_model_id=>2, :caching_model_id2=>1).caching_model2.must_be_same_as(@cm21)
+      @db.sqls.must_equal []
       @db.fetch = []
-      @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2.should == nil
+      @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2.must_equal nil
     end
   end
 
-  shared_examples_for "many_to_one_pk_lookup" do
+  many_to_one_pk_specs = shared_description do
     it "should use a simple primary key lookup when retrieving many_to_one associated records" do
       @cc.set_primary_key([:id, :id2])
-      @db.sqls.should == []
-      @c.load(:id=>3, :caching_model_id=>1).caching_model.should equal(@cm1)
-      @c.load(:id=>4, :caching_model_id=>2).caching_model.should equal(@cm2)
-      @db.sqls.should == []
+      @db.sqls.must_equal []
+      @c.load(:id=>3, :caching_model_id=>1).caching_model.must_be_same_as(@cm1)
+      @c.load(:id=>4, :caching_model_id=>2).caching_model.must_be_same_as(@cm2)
+      @db.sqls.must_equal []
       @db.fetch = []
-      @c.load(:id=>4, :caching_model_id=>3).caching_model.should == nil
+      @c.load(:id=>4, :caching_model_id=>3).caching_model.must_equal nil
     end
 
     it "should not use a simple primary key lookup if the assocation has a nil :key option" do
       @c.many_to_one :caching_model, :key=>nil, :dataset=>proc{CachingModel.filter(:caching_model_id=>caching_model_id)}
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should_not == []
+      @db.sqls.wont_equal []
     end
 
     it "should not use a simple primary key lookup if the assocation has a nil :key option" do
       @c.many_to_one :caching_model, :many_to_one_pk_lookup=>false
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should_not == []
+      @db.sqls.wont_equal []
     end
 
     it "should not use a simple primary key lookup if the assocation's :primary_key option doesn't match the primary key of the associated class" do
       @c.many_to_one :caching_model, :primary_key=>:id2
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should_not == []
+      @db.sqls.wont_equal []
     end
 
     it "should not use a simple primary key lookup if the assocation has :conditions" do
       @c.many_to_one :caching_model, :conditions=>{:a=>1}
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should_not == []
+      @db.sqls.wont_equal []
     end
 
     it "should not use a simple primary key lookup if the assocation has :select" do
       @c.many_to_one :caching_model, :select=>[:a, :b]
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should_not == []
+      @db.sqls.wont_equal []
     end
 
     it "should not use a simple primary key lookup if the assocation has a block" do
       @c.many_to_one(:caching_model){|ds| ds.where{a > 1}}
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should_not == []
+      @db.sqls.wont_equal []
     end
 
     it "should not use a simple primary key lookup if the assocation has a non-default :dataset option" do
       cc = @cc
       @c.many_to_one :caching_model, :dataset=>proc{cc.where(:id=>caching_model_id)}
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should_not == []
+      @db.sqls.wont_equal []
     end
 
     it "should use a simple primary key lookup if explicitly set" do
       @c.many_to_one :caching_model, :select=>[:a, :b], :many_to_one_pk_lookup=>true
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should == []
+      @db.sqls.must_equal []
     end
 
     it "should not use a simple primary key lookup if the prepared_statements_associations method is being used" do
@@ -101,8 +101,8 @@ describe "Shared caching behavior" do
         columns :id, :caching_model_id
         many_to_one :caching_model, :class=>c2
       end
-      c.load(:id=>3, :caching_model_id=>1).caching_model.should == c2.load(:id=>1)
-      @db.sqls.should_not == []
+      c.load(:id=>3, :caching_model_id=>1).caching_model.must_equal c2.load(:id=>1)
+      @db.sqls.wont_equal []
     end
 
     it "should use a simple primary key lookup if the prepared_statements_associations method is being used but associated model also uses caching" do
@@ -112,8 +112,8 @@ describe "Shared caching behavior" do
         columns :id, :caching_model_id
         many_to_one :caching_model
       end
-      c.load(:id=>3, :caching_model_id=>1).caching_model.should equal(@cm1)
-      @db.sqls.should == []
+      c.load(:id=>3, :caching_model_id=>1).caching_model.must_be_same_as(@cm1)
+      @db.sqls.must_equal []
     end
   end
 
@@ -137,8 +137,8 @@ describe "Shared caching behavior" do
       @db.sqls
     end
 
-    it_should_behave_like "many_to_one_pk_lookup"
-    it_should_behave_like "many_to_one_pk_lookup with composite keys"
+    include many_to_one_cpk_specs
+    include many_to_one_pk_specs
   end
 
   describe "With static_cache plugin with single key" do
@@ -150,13 +150,13 @@ describe "Shared caching behavior" do
       @db.sqls
     end
 
-    it_should_behave_like "many_to_one_pk_lookup"
+    include many_to_one_pk_specs
 
     it "should not issue regular query if primary key lookup returns no rows" do
       def @cc.primary_key_lookup(pk); end
       @c.many_to_one :caching_model
       @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.should == []
+      @db.sqls.must_equal []
     end
   end
 
@@ -170,6 +170,6 @@ describe "Shared caching behavior" do
       @db.sqls
     end
 
-    it_should_behave_like "many_to_one_pk_lookup with composite keys"
+    include many_to_one_cpk_specs
   end
 end