sequel 4.22.0 → 4.23.0

data/spec/extensions/tree_spec.rb

@@ -20,66 +20,66 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should define the correct associations" do
-    @c.associations.sort_by{|x| x.to_s}.should == [:children, :parent]
+    @c.associations.sort_by{|x| x.to_s}.must_equal [:children, :parent]
   end
   
   it "should define the correct reciprocals" do
-    @c.associations.sort_by{|x| x.to_s}.map{|x| @c.association_reflection(x).reciprocal}.should == [:parent, :children]
+    @c.associations.sort_by{|x| x.to_s}.map{|x| @c.association_reflection(x).reciprocal}.must_equal [:parent, :children]
   end
   
   it "should define the correct associations when giving options" do
-    klass(:children=>{:name=>:cs}, :parent=>{:name=>:p}).associations.sort_by{|x| x.to_s}.should == [:cs, :p]
+    klass(:children=>{:name=>:cs}, :parent=>{:name=>:p}).associations.sort_by{|x| x.to_s}.must_equal [:cs, :p]
   end
 
   it "should use the correct SQL for lazy associations" do
-    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
-    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
+    @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
+    @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
   end
   
   it "should use the correct SQL for lazy associations when giving options" do
     o = klass(:primary_key=>:i, :key=>:pi, :order=>:name, :children=>{:name=>:cs}, :parent=>{:name=>:p}).load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
-    o.p_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
-    o.cs_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
+    o.p_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
+    o.cs_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
   end
 
   it "should have parent_column give the symbol of the parent column" do
-    @c.parent_column.should == :parent_id
-    klass(:key=>:p_id).parent_column.should == :p_id
+    @c.parent_column.must_equal :parent_id
+    klass(:key=>:p_id).parent_column.must_equal :p_id
   end
 
   it "should have tree_order give the order of the association" do
-    @c.tree_order.should == nil
-    klass(:order=>:name).tree_order.should == :name
-    klass(:order=>[:parent_id, :name]).tree_order.should == [:parent_id, :name]
+    @c.tree_order.must_equal nil
+    klass(:order=>:name).tree_order.must_equal :name
+    klass(:order=>[:parent_id, :name]).tree_order.must_equal [:parent_id, :name]
   end
 
   it "should work correctly in subclasses" do
     o = Class.new(klass(:primary_key=>:i, :key=>:pi, :order=>:name, :children=>{:name=>:cs}, :parent=>{:name=>:p})).load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
-    o.p_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
-    o.cs_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
+    o.p_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'
+    o.cs_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.pi = 3) ORDER BY name'
   end
 
   it "should have roots return an array of the tree's roots" do
     @ds._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-    @c.roots.should == [@c.load(:id=>1, :parent_id=>nil, :name=>'r')]
-    @db.sqls.should == ["SELECT * FROM nodes WHERE (parent_id IS NULL)"]
+    @c.roots.must_equal [@c.load(:id=>1, :parent_id=>nil, :name=>'r')]
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id IS NULL)"]
   end
 
   it "should have roots_dataset be a dataset representing the tree's roots" do
-    @c.roots_dataset.sql.should == "SELECT * FROM nodes WHERE (parent_id IS NULL)"
+    @c.roots_dataset.sql.must_equal "SELECT * FROM nodes WHERE (parent_id IS NULL)"
   end
 
   it "should have ancestors return the ancestors of the current node" do
     @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
-    @o.ancestors.should == [@c.load(:id=>1, :parent_id=>5, :name=>'r'), @c.load(:id=>5, :parent_id=>nil, :name=>'r2')]
-    @db.sqls.should == ["SELECT * FROM nodes WHERE id = 1",
+    @o.ancestors.must_equal [@c.load(:id=>1, :parent_id=>5, :name=>'r'), @c.load(:id=>5, :parent_id=>nil, :name=>'r2')]
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE id = 1",
       "SELECT * FROM nodes WHERE id = 5"]
   end
 
   it "should have descendants return the descendants of the current node" do
     @ds._fetch = [[{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], []]
-    @o.descendants.should == [@c.load(:id=>3, :parent_id=>2, :name=>'r'), @c.load(:id=>4, :parent_id=>2, :name=>'r2'), @c.load(:id=>5, :parent_id=>4, :name=>'r3')] 
-    @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.parent_id = 2)",
+    @o.descendants.must_equal [@c.load(:id=>3, :parent_id=>2, :name=>'r'), @c.load(:id=>4, :parent_id=>2, :name=>'r2'), @c.load(:id=>5, :parent_id=>4, :name=>'r3')] 
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE (nodes.parent_id = 2)",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 3)",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 5)",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 4)"]
@@ -87,31 +87,31 @@ describe Sequel::Model, "tree plugin" do
 
   it "should have root return the root of the current node" do
     @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
-    @o.root.should == @c.load(:id=>5, :parent_id=>nil, :name=>'r2')
-    @db.sqls.should == ["SELECT * FROM nodes WHERE id = 1",
+    @o.root.must_equal @c.load(:id=>5, :parent_id=>nil, :name=>'r2')
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE id = 1",
       "SELECT * FROM nodes WHERE id = 5"]
   end
 
   it "should have root? return true for a root node and false for a child node" do
-    @c.load(:parent_id => nil).root?.should == true
-    @c.load(:parent_id => 1).root?.should == false
+    @c.load(:parent_id => nil).root?.must_equal true
+    @c.load(:parent_id => 1).root?.must_equal false
   end
 
   it "should have root? return false for an new node" do
-    @c.new.root?.should == false
+    @c.new.root?.must_equal false
   end
 
   it "should have self_and_siblings return the children of the current node's parent" do
     @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
-    @o.self_and_siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2'), @o] 
-    @db.sqls.should == ["SELECT * FROM nodes WHERE id = 1",
+    @o.self_and_siblings.must_equal [@c.load(:id=>7, :parent_id=>1, :name=>'r2'), @o] 
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE id = 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
 
   it "should have siblings return the children of the current node's parent, except for the current node" do
     @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
-    @o.siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2')] 
-    @db.sqls.should == ["SELECT * FROM nodes WHERE id = 1",
+    @o.siblings.must_equal [@c.load(:id=>7, :parent_id=>1, :name=>'r2')] 
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE id = 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
 
@@ -122,23 +122,23 @@ describe Sequel::Model, "tree plugin" do
 
     it "should have root class method return the root" do
       @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-      @c.root.should == @c.load(:id=>1, :parent_id=>nil, :name=>'r')
+      @c.root.must_equal @c.load(:id=>1, :parent_id=>nil, :name=>'r')
     end
 
     it "prevents creating a second root" do
       @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-      lambda { @c.create }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      lambda { @c.create }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "errors when promoting an existing record to a second root" do
       @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       n = @c.load(:id => 2, :parent_id => 1)
-      lambda { n.update(:parent_id => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      lambda { n.update(:parent_id => nil) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "allows updating existing root" do
       @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
-      lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
+       @c.root.update(:name => 'fdsa') 
     end
   end
 end
@@ -165,37 +165,37 @@ describe Sequel::Model, "tree plugin with composite keys" do
 
   
   it "should use the correct SQL for lazy associations" do
-    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.id = 1) AND (nodes.id2 = 6)) LIMIT 1'
-    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))'
+    @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE ((nodes.id = 1) AND (nodes.id2 = 6)) LIMIT 1'
+    @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))'
   end
   
   it "should have parent_column give an array of symbols of the parent column" do
-    @c.parent_column.should == [:parent_id, :parent_id2]
+    @c.parent_column.must_equal [:parent_id, :parent_id2]
   end
 
   it "should have roots return an array of the tree's roots" do
     @ds._fetch = [{:id=>1, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
-    @c.roots.should == [@c.load(:id=>1, :parent_id=>nil, :parent_id2=>nil, :name=>'r')]
-    @db.sqls.should == ["SELECT * FROM nodes WHERE ((parent_id IS NULL) OR (parent_id2 IS NULL))"]
+    @c.roots.must_equal [@c.load(:id=>1, :parent_id=>nil, :parent_id2=>nil, :name=>'r')]
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE ((parent_id IS NULL) OR (parent_id2 IS NULL))"]
   end
 
   it "should have roots_dataset be a dataset representing the tree's roots" do
-    @c.roots_dataset.sql.should == "SELECT * FROM nodes WHERE ((parent_id IS NULL) OR (parent_id2 IS NULL))"
+    @c.roots_dataset.sql.must_equal "SELECT * FROM nodes WHERE ((parent_id IS NULL) OR (parent_id2 IS NULL))"
   end
 
   it "should have ancestors return the ancestors of the current node" do
     @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'}], [{:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2'}]]
-    @o.ancestors.should == [@c.load(:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'), @c.load(:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2')]
+    @o.ancestors.must_equal [@c.load(:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'), @c.load(:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2')]
     sqls = @db.sqls
-    sqls.length.should == 2
-    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].should include(sqls[0])
-    ["SELECT * FROM nodes WHERE ((id = 5) AND (id2 = 7)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 7) AND (id = 5)) LIMIT 1"].should include(sqls[1])
+    sqls.length.must_equal 2
+    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].must_include(sqls[0])
+    ["SELECT * FROM nodes WHERE ((id = 5) AND (id2 = 7)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 7) AND (id = 5)) LIMIT 1"].must_include(sqls[1])
   end
 
   it "should have descendants return the descendants of the current node" do
     @ds._fetch = [[{:id=>3, :id2=>7, :parent_id=>2, :parent_id2=>5, :name=>'r'}, {:id=>4, :id2=>8, :parent_id=>2, :parent_id2=>5, :name=>'r2'}], [{:id=>5, :id2=>9, :parent_id=>4, :parent_id2=>8, :name=>'r3'}], []]
-    @o.descendants.should == [@c.load(:id=>3, :id2=>7, :parent_id=>2, :parent_id2=>5, :name=>'r'), @c.load(:id=>4, :id2=>8, :parent_id=>2, :parent_id2=>5, :name=>'r2'), @c.load(:id=>5, :id2=>9, :parent_id=>4, :parent_id2=>8, :name=>'r3')] 
-    @db.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))",
+    @o.descendants.must_equal [@c.load(:id=>3, :id2=>7, :parent_id=>2, :parent_id2=>5, :name=>'r'), @c.load(:id=>4, :id2=>8, :parent_id=>2, :parent_id2=>5, :name=>'r2'), @c.load(:id=>5, :id2=>9, :parent_id=>4, :parent_id2=>8, :name=>'r3')] 
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE ((nodes.parent_id = 2) AND (nodes.parent_id2 = 5))",
       "SELECT * FROM nodes WHERE ((nodes.parent_id = 3) AND (nodes.parent_id2 = 7))",
       "SELECT * FROM nodes WHERE ((nodes.parent_id = 5) AND (nodes.parent_id2 = 9))",
       "SELECT * FROM nodes WHERE ((nodes.parent_id = 4) AND (nodes.parent_id2 = 8))"]
@@ -203,40 +203,40 @@ describe Sequel::Model, "tree plugin with composite keys" do
 
   it "should have root return the root of the current node" do
     @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>5, :parent_id2=>7, :name=>'r'}], [{:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2'}]]
-    @o.root.should == @c.load(:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2')
+    @o.root.must_equal @c.load(:id=>5, :id2=>7, :parent_id=>nil, :parent_id2=>nil, :name=>'r2')
     sqls = @db.sqls
-    sqls.length.should == 2
-    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].should include(sqls[0])
-    ["SELECT * FROM nodes WHERE ((id = 5) AND (id2 = 7)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 7) AND (id = 5)) LIMIT 1"].should include(sqls[1])
+    sqls.length.must_equal 2
+    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].must_include(sqls[0])
+    ["SELECT * FROM nodes WHERE ((id = 5) AND (id2 = 7)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 7) AND (id = 5)) LIMIT 1"].must_include(sqls[1])
   end
 
   it "should have root? return true for a root node and false for a child node" do
-    @c.load(:parent_id => nil, :parent_id2=>nil).root?.should == true
-    @c.load(:parent_id => 1, :parent_id2=>nil).root?.should == true
-    @c.load(:parent_id => nil, :parent_id2=>2).root?.should == true
-    @c.load(:parent_id => 1, :parent_id2=>2).root?.should == false
+    @c.load(:parent_id => nil, :parent_id2=>nil).root?.must_equal true
+    @c.load(:parent_id => 1, :parent_id2=>nil).root?.must_equal true
+    @c.load(:parent_id => nil, :parent_id2=>2).root?.must_equal true
+    @c.load(:parent_id => 1, :parent_id2=>2).root?.must_equal false
   end
 
   it "should have root? return false for an new node" do
-    @c.new.root?.should == false
+    @c.new.root?.must_equal false
   end
 
   it "should have self_and_siblings return the children of the current node's parent" do
     @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>3, :parent_id2=>7, :name=>'r'}], [{:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'}, @o.values.dup]]
-    @o.self_and_siblings.should == [@c.load(:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'), @o] 
+    @o.self_and_siblings.must_equal [@c.load(:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'), @o] 
     sqls = @db.sqls
-    sqls.length.should == 2
-    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].should include(sqls[0])
-    sqls[1].should == "SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.parent_id2 = 6))"
+    sqls.length.must_equal 2
+    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].must_include(sqls[0])
+    sqls[1].must_equal "SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.parent_id2 = 6))"
   end
 
   it "should have siblings return the children of the current node's parent, except for the current node" do
     @ds._fetch = [[{:id=>1, :id2=>6, :parent_id=>3, :parent_id2=>7, :name=>'r'}], [{:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2'}, @o.values.dup]]
-    @o.siblings.should == [@c.load(:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2')] 
+    @o.siblings.must_equal [@c.load(:id=>7, :id2=>9, :parent_id=>1, :parent_id2=>6, :name=>'r2')] 
     sqls = @db.sqls
-    sqls.length.should == 2
-    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].should include(sqls[0])
-    sqls[1].should == "SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.parent_id2 = 6))"
+    sqls.length.must_equal 2
+    ["SELECT * FROM nodes WHERE ((id = 1) AND (id2 = 6)) LIMIT 1", "SELECT * FROM nodes WHERE ((id2 = 6) AND (id = 1)) LIMIT 1"].must_include(sqls[0])
+    sqls[1].must_equal "SELECT * FROM nodes WHERE ((nodes.parent_id = 1) AND (nodes.parent_id2 = 6))"
   end
 
   describe ":single_root option" do
@@ -246,29 +246,29 @@ describe Sequel::Model, "tree plugin with composite keys" do
 
     it "prevents creating a second root" do
       @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
-      lambda { @c.create }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      lambda { @c.create }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
       @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}]
-      lambda { @c.create(:parent_id2=>1) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      lambda { @c.create(:parent_id2=>1) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
       @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}]
-      lambda { @c.create(:parent_id=>2) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      lambda { @c.create(:parent_id=>2) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "errors when promoting an existing record to a second root" do
       @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}]
-      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id => nil, :parent_id2=>nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id => nil, :parent_id2=>nil) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
       @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}]
-      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id => nil) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
       @c.dataset._fetch = [{:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}]
-      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id2 => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
+      lambda { @c.load(:id => 2, :id2=>7, :parent_id => 1, :parent_id2=>2).update(:parent_id2 => nil) }.must_raise(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "allows updating existing root" do
       @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>nil, :name=>'r'}
-      lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
+       @c.root.update(:name => 'fdsa') 
       @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>1, :parent_id2=>nil, :name=>'r'}
-      lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
+       @c.root.update(:name => 'fdsa') 
       @c.dataset._fetch = {:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r'}
-      lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
+       @c.root.update(:name => 'fdsa') 
     end
   end
 end

data/spec/extensions/typecast_on_load_spec.rb

@@ -16,65 +16,65 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
     end
   end 
 
-  specify "should call setter method with value when loading the object, for all given columns" do
+  it "should call setter method with value when loading the object, for all given columns" do
     @c.plugin :typecast_on_load, :b
     o = @c.load(:id=>1, :b=>"1", :y=>"0")
-    o.values.should == {:id=>1, :b=>1, :y=>"0"}
-    o.bset.should == true
+    o.values.must_equal(:id=>1, :b=>1, :y=>"0")
+    o.bset.must_equal true
   end
 
-  specify "should call setter method with value when reloading the object, for all given columns" do
+  it "should call setter method with value when reloading the object, for all given columns" do
     @c.plugin :typecast_on_load, :b
     o = @c.load(:id=>1, :b=>"1", :y=>"0")
     o.refresh
-    o.values.should == {:id=>1, :b=>1, :y=>"0"}
-    o.bset.should == true
+    o.values.must_equal(:id=>1, :b=>1, :y=>"0")
+    o.bset.must_equal true
   end
 
-  specify "should call setter method with value when automatically reloading the object on creation" do
+  it "should call setter method with value when automatically reloading the object on creation" do
     @c.plugin :typecast_on_load, :b
     o = @c.new(:b=>"1", :y=>"0")
-    o.save.values.should == {:id=>1, :b=>1, :y=>"0"}
-    o.bset.should == true
+    o.save.values.must_equal(:id=>1, :b=>1, :y=>"0")
+    o.bset.must_equal true
   end
 
-  specify "should call setter method with value when automatically reloading the object on creation via insert_select" do
+  it "should call setter method with value when automatically reloading the object on creation via insert_select" do
     @c.plugin :typecast_on_load, :b
     @c.dataset.meta_def(:insert_select){|h| insert(h); first}
     o = @c.new(:b=>"1", :y=>"0")
-    o.save.values.should == {:id=>1, :b=>1, :y=>"0"}
-    o.bset.should == true
+    o.save.values.must_equal(:id=>1, :b=>1, :y=>"0")
+    o.bset.must_equal true
   end
 
-  specify "should allowing setting columns separately via add_typecast_on_load_columns" do
+  it "should allowing setting columns separately via add_typecast_on_load_columns" do
     @c.plugin :typecast_on_load
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>"1", :y=>"0")
     @c.add_typecast_on_load_columns :b
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>"0"}
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>"0")
     @c.add_typecast_on_load_columns :y
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>false}
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>false)
   end
 
-  specify "should work with subclasses" do
+  it "should work with subclasses" do
     @c.plugin :typecast_on_load
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>"1", :y=>"0")
 
     c1 = Class.new(@c)
     @c.add_typecast_on_load_columns :b
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>"0"}
-    c1.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>"0")
+    c1.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>"1", :y=>"0")
 
     c2 = Class.new(@c)
     @c.add_typecast_on_load_columns :y
-    @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>false}
-    c2.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>1, :y=>"0"}
+    @c.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>false)
+    c2.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>1, :y=>"0")
     
     c1.add_typecast_on_load_columns :y
-    c1.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>false}
+    c1.load(:id=>1, :b=>"1", :y=>"0").values.must_equal(:id=>1, :b=>"1", :y=>false)
   end
 
-  specify "should not mark the object as modified" do
+  it "should not mark the object as modified" do
     @c.plugin :typecast_on_load, :b
-    @c.load(:id=>1, :b=>"1", :y=>"0").modified?.should == false
+    @c.load(:id=>1, :b=>"1", :y=>"0").modified?.must_equal false
   end
 end

data/spec/extensions/unlimited_update_spec.rb

@@ -11,10 +11,10 @@ describe "Sequel::Plugins::UnlimitedUpdate" do
 
   it "should remove limit from update dataset" do
     @o.save
-    @db.sqls.should == ["UPDATE test SET name = 'a' WHERE (id = 1) LIMIT 1"]
+    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1) LIMIT 1"]
 
     @c.plugin :unlimited_update
     @o.save
-    @db.sqls.should == ["UPDATE test SET name = 'a' WHERE (id = 1)"]
+    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1)"]
   end
 end

data/spec/extensions/update_or_create_spec.rb

@@ -11,77 +11,77 @@ describe "Sequel::Plugins::UpdateOrCreate" do
 
   it ".update_or_create should update an existing record if one exists" do
     @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.update_or_create(:a=>2){|t| t.b = 4}.should == @c.load(:id=>1, :a=>2, :b=>4)
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 2) LIMIT 1", "UPDATE test SET b = 4 WHERE (id = 1)"]
+    @c.update_or_create(:a=>2){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>2, :b=>4)
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1", "UPDATE test SET b = 4 WHERE (id = 1)"]
 
     @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.update_or_create({:a=>2}, :b=>4).should == @c.load(:id=>1, :a=>2, :b=>4)
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 2) LIMIT 1", "UPDATE test SET b = 4 WHERE (id = 1)"]
+    @c.update_or_create({:a=>2}, :b=>4).must_equal @c.load(:id=>1, :a=>2, :b=>4)
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1", "UPDATE test SET b = 4 WHERE (id = 1)"]
 
     @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.update_or_create({:a=>2}, :a=>3){|t| t.b = 4}.should == @c.load(:id=>1, :a=>3, :b=>4)
+    @c.update_or_create({:a=>2}, :a=>3){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>3, :b=>4)
     sqls = @db.sqls
-    sqls.shift.should == "SELECT * FROM test WHERE (a = 2) LIMIT 1"
-    sqls.shift.should =~ /UPDATE test SET [ab] = [34], [ab] = [34] WHERE \(id = 1\)/
+    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 2) LIMIT 1"
+    sqls.shift.must_match(/UPDATE test SET [ab] = [34], [ab] = [34] WHERE \(id = 1\)/)
   end
 
   it ".update_or_create should create a record if an existing record does not exist" do
     @db.fetch = [[], [{:id=>1, :a=>1, :b=>4}]]
-    @c.update_or_create(:a=>1){|t| t.b = 4}.should == @c.load(:id=>1, :a=>1, :b=>4)
+    @c.update_or_create(:a=>1){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>1, :b=>4)
     sqls = @db.sqls
-    sqls.shift.should == "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.should =~ /INSERT INTO test \([ab], [ab]\) VALUES \([14], [14]\)/
-    sqls.shift.should == "SELECT * FROM test WHERE (id = 1) LIMIT 1"
+    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
+    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([14], [14]\)/)
+    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
 
     @db.fetch = [[], [{:id=>1, :a=>1, :b=>4}]]
-    @c.update_or_create({:a=>1}, :b=>4).should == @c.load(:id=>1, :a=>1, :b=>4)
+    @c.update_or_create({:a=>1}, :b=>4).must_equal @c.load(:id=>1, :a=>1, :b=>4)
     sqls = @db.sqls
-    sqls.shift.should == "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.should =~ /INSERT INTO test \([ab], [ab]\) VALUES \([14], [14]\)/
-    sqls.shift.should == "SELECT * FROM test WHERE (id = 1) LIMIT 1"
+    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
+    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([14], [14]\)/)
+    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
 
     @db.fetch = [[], [{:id=>1, :a=>3, :b=>4}]]
-    @c.update_or_create({:a=>1}, :a=>3){|t| t.b = 4}.should == @c.load(:id=>1, :a=>3, :b=>4)
+    @c.update_or_create({:a=>1}, :a=>3){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>3, :b=>4)
     sqls = @db.sqls
-    sqls.shift.should == "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.should =~ /INSERT INTO test \([ab], [ab]\) VALUES \([34], [34]\)/
-    sqls.shift.should == "SELECT * FROM test WHERE (id = 1) LIMIT 1"
+    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
+    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([34], [34]\)/)
+    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
   end
 
   it ".update_or_create should return an existing record even if no changes necessary" do
     @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.update_or_create(:a=>2){|t| t.b = 3}.should == @c.load(:id=>1, :a=>2, :b=>3)
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
+    @c.update_or_create(:a=>2){|t| t.b = 3}.must_equal @c.load(:id=>1, :a=>2, :b=>3)
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
   end
 
   it ".find_or_new should return an existing record" do
     @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.find_or_new(:a=>2){|t| t.b = 4}.should == @c.load(:id=>1, :a=>2, :b=>4)
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
+    @c.find_or_new(:a=>2){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>2, :b=>4)
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
 
     @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.find_or_new({:a=>2}, :b=>4).should == @c.load(:id=>1, :a=>2, :b=>4)
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
+    @c.find_or_new({:a=>2}, :b=>4).must_equal @c.load(:id=>1, :a=>2, :b=>4)
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
 
     @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
-    @c.find_or_new({:a=>2}, :a=>3){|t| t.b = 4}.should == @c.load(:id=>1, :a=>3, :b=>4)
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
+    @c.find_or_new({:a=>2}, :a=>3){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>3, :b=>4)
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1"]
   end
 
   it ".find_or_new should return a new record if no record exists" do
     o = @c.find_or_new(:a=>1){|t| t.b = 4}
-    o.should == @c.load(:a=>1, :b=>4)
-    o.new?.should == true
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
+    o.must_equal @c.load(:a=>1, :b=>4)
+    o.new?.must_equal true
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
 
     o = @c.find_or_new({:a=>1}, :b=>4)
-    o.should == @c.load(:a=>1, :b=>4)
-    o.new?.should == true
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
+    o.must_equal @c.load(:a=>1, :b=>4)
+    o.new?.must_equal true
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
 
     o = @c.find_or_new({:a=>1}, :a=>3){|t| t.b = 4}
-    o.should == @c.load(:a=>3, :b=>4)
-    o.new?.should == true
-    @db.sqls.should == ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
+    o.must_equal @c.load(:a=>3, :b=>4)
+    o.new?.must_equal true
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1"]
   end
 end