sequel 4.22.0 → 4.23.0

data/spec/extensions/association_proxies_spec.rb

@@ -18,27 +18,27 @@ describe "Sequel::Plugins::AssociationProxies" do
   end
 
   it "should send method calls to the associated object array if sent an array method" do
-    @i.associations.has_key?(:tags).should == false
-    @t.select{|x| false}.should == []
-    @i.associations.has_key?(:tags).should == true
+    @i.associations.has_key?(:tags).must_equal false
+    @t.select{|x| false}.must_equal []
+    @i.associations.has_key?(:tags).must_equal true
   end
   
   it "should send method calls to the association dataset if sent a non-array method" do
-    @i.associations.has_key?(:tags).should == false
-    @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
-    @i.associations.has_key?(:tags).should == false
+    @i.associations.has_key?(:tags).must_equal false
+    @t.filter(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    @i.associations.has_key?(:tags).must_equal false
   end
   
   it "should accept block to plugin to specify which methods to proxy to dataset" do
     Item.plugin :association_proxies do |opts|
       opts[:method] == :where || opts[:arguments].length == 2 || opts[:block]
     end
-    @i.associations.has_key?(:tags).should == false
-    @t.where(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
-    @t.filter('a = ?', 1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
-    @t.filter{{:a=>1}}.sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    @i.associations.has_key?(:tags).must_equal false
+    @t.where(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    @t.filter('a = ?', 1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    @t.filter{{:a=>1}}.sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
 
-    @i.associations.has_key?(:tags).should == false
+    @i.associations.has_key?(:tags).must_equal false
     Item.plugin :association_proxies do |opts|
       proxy_arg = opts[:proxy_argument]
       proxy_block = opts[:proxy_block]
@@ -46,41 +46,41 @@ describe "Sequel::Plugins::AssociationProxies" do
       is_size = opts[:method] == :size
       is_size && !cached && !proxy_arg && !proxy_block
     end
-    @t.size.should == 1
-    Item.db.sqls.should == ["SELECT count(*) AS count FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1) LIMIT 1"]
-    @i.tags{|ds| ds}.size.should == 1
-    Item.db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1)"]
-    @i.tags(true).size.should == 1
-    Item.db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1)"]
-    @t.size.should == 1
-    Item.db.sqls.should == []
+    @t.size.must_equal 1
+    Item.db.sqls.must_equal ["SELECT count(*) AS count FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1) LIMIT 1"]
+    @i.tags{|ds| ds}.size.must_equal 1
+    Item.db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1)"]
+    @i.tags(true).size.must_equal 1
+    Item.db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE (items_tags.item_id = 1)"]
+    @t.size.must_equal 1
+    Item.db.sqls.must_equal []
   end
   
   it "should reload the cached association if sent an array method and the reload flag was given" do
-    @t.select{|x| false}.should == []
-    Item.db.sqls.length.should == 1
-    @t.select{|x| false}.should == []
-    Item.db.sqls.length.should == 0
-    @i.tags(true).select{|x| false}.should == []
-    Item.db.sqls.length.should == 1
-    @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
-    Item.db.sqls.length.should == 0
+    @t.select{|x| false}.must_equal []
+    Item.db.sqls.length.must_equal 1
+    @t.select{|x| false}.must_equal []
+    Item.db.sqls.length.must_equal 0
+    @i.tags(true).select{|x| false}.must_equal []
+    Item.db.sqls.length.must_equal 1
+    @t.filter(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    Item.db.sqls.length.must_equal 0
   end
   
   it "should not return a proxy object for associations that do not return an array" do
     Item.many_to_one :tag
-    proc{@i.tag.filter(:a=>1)}.should raise_error(NoMethodError)
+    proc{@i.tag.filter(:a=>1)}.must_raise(NoMethodError)
     
     Tag.one_to_one :item
-    proc{Tag.load(:id=>1, :item_id=>2).item.filter(:a=>1)}.should raise_error(NoMethodError)
+    proc{Tag.load(:id=>1, :item_id=>2).item.filter(:a=>1)}.must_raise(NoMethodError)
   end
 
   it "should work correctly in subclasses" do
     i = Class.new(Item).load(:id=>1)
-    i.associations.has_key?(:tags).should == false
-    i.tags.select{|x| false}.should == []
-    i.associations.has_key?(:tags).should == true
-    i.tags.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
+    i.associations.has_key?(:tags).must_equal false
+    i.tags.select{|x| false}.must_equal []
+    i.associations.has_key?(:tags).must_equal true
+    i.tags.filter(:a=>1).sql.must_equal "SELECT tags.* FROM tags INNER JOIN items_tags ON (items_tags.tag_id = tags.id) WHERE ((items_tags.item_id = 1) AND (a = 1))"
   end
   
 end

data/spec/extensions/auto_validations_spec.rb

@@ -28,131 +28,131 @@ describe "Sequel::Plugins::AutoValidations" do
   end
 
   it "should have automatically created validations" do
-    @m.valid?.should == false
-    @m.errors.should == {:d=>["is not present"], :name=>["is not present"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:d=>["is not present"], :name=>["is not present"])
 
     @m.name = ''
-    @m.valid?.should == false
-    @m.errors.should == {:d=>["is not present"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:d=>["is not present"])
 
     @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.should == false
-    @m.errors.should == {:d=>["is not a valid date"], :num=>["is not a valid integer"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
 
     @m.set(:d=>Date.today, :num=>1)
-    @m.valid?.should == false
-    @m.errors.should == {[:name, :num]=>["is already taken"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal([:name, :num]=>["is already taken"])
 
     @m.set(:name=>'a'*51)
-    @m.valid?.should == false
-    @m.errors.should == {:name=>["is longer than 50 characters"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:name=>["is longer than 50 characters"])
   end
 
   it "should handle databases that don't support index parsing" do
     def (@m.db).supports_index_parsing?() false end
     @m.model.send(:setup_auto_validations)
     @m.set(:d=>Date.today, :num=>1, :name=>'1')
-    @m.valid?.should == true
+    @m.valid?.must_equal true
   end
 
   it "should handle models that select from subqueries" do
     @c.set_dataset @c.dataset.from_self
-    proc{@c.send(:setup_auto_validations)}.should_not raise_error
+    @c.send(:setup_auto_validations)
   end
 
   it "should support :not_null=>:presence option" do
     @c.plugin :auto_validations, :not_null=>:presence
     @m.set(:d=>Date.today, :num=>'')
-    @m.valid?.should == false
-    @m.errors.should == {:name=>["is not present"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:name=>["is not present"])
   end
 
   it "should automatically validate explicit nil values for columns with not nil defaults" do
     @m.set(:d=>Date.today, :name=>1, :nnd=>nil)
     @m.id = nil
-    @m.valid?.should == false
-    @m.errors.should == {:id=>["is not present"], :nnd=>["is not present"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:id=>["is not present"], :nnd=>["is not present"])
   end
 
   it "should allow skipping validations by type" do
     @c = Class.new(@c)
     @m = @c.new
     @c.skip_auto_validations(:not_null)
-    @m.valid?.should == true
+    @m.valid?.must_equal true
 
     @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.should == false
-    @m.errors.should == {:d=>["is not a valid date"], :num=>["is not a valid integer"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
 
     @c.skip_auto_validations(:types)
-    @m.valid?.should == false
-    @m.errors.should == {[:name, :num]=>["is already taken"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal([:name, :num]=>["is already taken"])
 
     @c.skip_auto_validations(:unique)
-    @m.valid?.should == true
+    @m.valid?.must_equal true
 
     @m.set(:name=>'a'*51)
-    @m.valid?.should == false
-    @m.errors.should == {:name=>["is longer than 50 characters"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:name=>["is longer than 50 characters"])
 
     @c.skip_auto_validations(:max_length)
-    @m.valid?.should == true
+    @m.valid?.must_equal true
   end
 
   it "should allow skipping all auto validations" do
     @c = Class.new(@c)
     @m = @c.new
     @c.skip_auto_validations(:all)
-    @m.valid?.should == true
+    @m.valid?.must_equal true
     @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.should == true
+    @m.valid?.must_equal true
     @m.set(:name=>'a'*51)
-    @m.valid?.should == true
+    @m.valid?.must_equal true
   end
 
   it "should work correctly in subclasses" do
     @c = Class.new(@c)
     @m = @c.new
-    @m.valid?.should == false
-    @m.errors.should == {:d=>["is not present"], :name=>["is not present"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:d=>["is not present"], :name=>["is not present"])
 
     @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.should == false
-    @m.errors.should == {:d=>["is not a valid date"], :num=>["is not a valid integer"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
 
     @m.set(:d=>Date.today, :num=>1)
-    @m.valid?.should == false
-    @m.errors.should == {[:name, :num]=>["is already taken"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal([:name, :num]=>["is already taken"])
 
     @m.set(:name=>'a'*51)
-    @m.valid?.should == false
-    @m.errors.should == {:name=>["is longer than 50 characters"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:name=>["is longer than 50 characters"])
   end
 
   it "should work correctly in STI subclasses" do
     @c.plugin(:single_table_inheritance, :num, :model_map=>{1=>@c}, :key_map=>proc{[1, 2]})
     sc = Class.new(@c)
     @m = sc.new
-    @m.valid?.should == false
-    @m.errors.should == {:d=>["is not present"], :name=>["is not present"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:d=>["is not present"], :name=>["is not present"])
 
     @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.should == false
-    @m.errors.should == {:d=>["is not a valid date"], :num=>["is not a valid integer"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
 
     @m.db.sqls
     @m.set(:d=>Date.today, :num=>1)
-    @m.valid?.should == false
-    @m.errors.should == {[:name, :num]=>["is already taken"]}
-    @m.db.sqls.should == ["SELECT count(*) AS count FROM test WHERE ((name = '1') AND (num = 1)) LIMIT 1"]
+    @m.valid?.must_equal false
+    @m.errors.must_equal([:name, :num]=>["is already taken"])
+    @m.db.sqls.must_equal ["SELECT count(*) AS count FROM test WHERE ((name = '1') AND (num = 1)) LIMIT 1"]
 
     @m.set(:name=>'a'*51)
-    @m.valid?.should == false
-    @m.errors.should == {:name=>["is longer than 50 characters"]}
+    @m.valid?.must_equal false
+    @m.errors.must_equal(:name=>["is longer than 50 characters"])
   end
 
   it "should work correctly when changing the dataset" do
     @c.set_dataset(@c.db[:foo])
-    @c.new.valid?.should == true
+    @c.new.valid?.must_equal true
   end
 end

data/spec/extensions/blacklist_security_spec.rb

@@ -16,24 +16,24 @@ describe Sequel::Model, "#(set|update)_except" do
 
   it "should raise errors if not all hash fields can be set and strict_param_setting is true" do
     @c.strict_param_setting = true
-    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, :x, :y)}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3}, :x, :y)}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, :x, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3}, :x, :y)}.must_raise(Sequel::MassAssignmentRestriction)
     (o = @c.new).set_except({:z => 3}, :x, :y)
-    o.values.should == {:z=>3}
+    o.values.must_equal(:z=>3)
   end
 
   it "#set_except should not set given attributes or the primary key" do
     @o1.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, [:y, :z])
-    @o1.values.should == {:x => 1}
+    @o1.values.must_equal(:x => 1)
     @o1.set_except({:x => 4, :y => 2, :z=>3, :id=>4}, :y, :z)
-    @o1.values.should == {:x => 4}
+    @o1.values.must_equal(:x => 4)
   end
 
   it "#update_except should not update given attributes" do
     @o1.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, [:y, :z])
-    DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     @c.new.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, :y, :z)
-    DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 end
 
@@ -46,42 +46,43 @@ describe Sequel::Model, ".restricted_columns " do
     end
     @c.strict_param_setting = false
     @c.instance_variable_set(:@columns, [:x, :y, :z])
+    DB.sqls
   end
   
   it "should set the restricted columns correctly" do
-    @c.restricted_columns.should == nil
+    @c.restricted_columns.must_equal nil
     @c.set_restricted_columns :x
-    @c.restricted_columns.should == [:x]
+    @c.restricted_columns.must_equal [:x]
     @c.set_restricted_columns :x, :y
-    @c.restricted_columns.should == [:x, :y]
+    @c.restricted_columns.must_equal [:x, :y]
   end
 
   it "should not set restricted columns by default" do
     @c.set_restricted_columns :z
     i = @c.new(:x => 1, :y => 2, :z => 3)
-    i.values.should == {:x => 1, :y => 2}
+    i.values.must_equal(:x => 1, :y => 2)
     i.set(:x => 4, :y => 5, :z => 6)
-    i.values.should == {:x => 4, :y => 5}
+    i.values.must_equal(:x => 4, :y => 5)
 
     @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 7}
     i = @c.new
     i.update(:x => 7, :z => 9)
-    i.values.should == {:x => 7}
-    DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+    i.values.must_equal(:x => 7)
+    DB.sqls.must_equal ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 
   it "should have allowed take precedence over restricted" do
     @c.set_allowed_columns :x, :y
     @c.set_restricted_columns :y, :z
     i = @c.new(:x => 1, :y => 2, :z => 3)
-    i.values.should == {:x => 1, :y => 2}
+    i.values.must_equal(:x => 1, :y => 2)
     i.set(:x => 4, :y => 5, :z => 6)
-    i.values.should == {:x => 4, :y => 5}
+    i.values.must_equal(:x => 4, :y => 5)
 
     @c.instance_dataset._fetch = @c.dataset._fetch = {:y => 7}
     i = @c.new
     i.update(:y => 7, :z => 9)
-    i.values.should == {:y => 7}
-    DB.sqls.should == ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+    i.values.must_equal(:y => 7)
+    DB.sqls.must_equal ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 end

data/spec/extensions/blank_spec.rb

@@ -3,67 +3,67 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 Sequel.extension :blank
 
 describe "Object#blank?" do
-  specify "it should be true if the object responds true to empty?" do
-    [].blank?.should == true
-    {}.blank?.should == true
+  it "it should be true if the object responds true to empty?" do
+    [].blank?.must_equal true
+    {}.blank?.must_equal true
     o = Object.new
     def o.empty?; true; end
-    o.blank?.should == true
+    o.blank?.must_equal true
   end
 
-  specify "it should be false if the object doesn't respond true to empty?" do
-    [2].blank?.should == false
-    {1=>2}.blank?.should == false
-    Object.new.blank?.should == false
+  it "it should be false if the object doesn't respond true to empty?" do
+    [2].blank?.must_equal false
+    {1=>2}.blank?.must_equal false
+    Object.new.blank?.must_equal false
   end
 end
 
 describe "Numeric#blank?" do
-  specify "it should always be false" do
-    1.blank?.should == false
-    0.blank?.should == false
-    -1.blank?.should == false
-    1.0.blank?.should == false
-    0.0.blank?.should == false
-    -1.0.blank?.should == false
-    10000000000000000.blank?.should == false
-    -10000000000000000.blank?.should == false
-    10000000000000000.0.blank?.should == false
-    -10000000000000000.0.blank?.should == false
+  it "it should always be false" do
+    1.blank?.must_equal false
+    0.blank?.must_equal false
+    -1.blank?.must_equal false
+    1.0.blank?.must_equal false
+    0.0.blank?.must_equal false
+    -1.0.blank?.must_equal false
+    10000000000000000.blank?.must_equal false
+    -10000000000000000.blank?.must_equal false
+    10000000000000000.0.blank?.must_equal false
+    -10000000000000000.0.blank?.must_equal false
   end
 end
 
 describe "NilClass#blank?" do
-  specify "it should always be true" do
-    nil.blank?.should == true
+  it "it should always be true" do
+    nil.blank?.must_equal true
   end
 end
 
 describe "TrueClass#blank?" do
-  specify "it should always be false" do
-    true.blank?.should == false
+  it "it should always be false" do
+    true.blank?.must_equal false
   end
 end
 
 describe "FalseClass#blank?" do
-  specify "it should always be true" do
-    false.blank?.should == true
+  it "it should always be true" do
+    false.blank?.must_equal true
   end
 end
 
 describe "String#blank?" do
-  specify "it should be true if the string is empty" do
-    ''.blank?.should == true
+  it "it should be true if the string is empty" do
+    ''.blank?.must_equal true
   end
-  specify "it should be true if the string is composed of just whitespace" do
-    ' '.blank?.should == true
-    "\r\n\t".blank?.should == true
-    (' '*4000).blank?.should == true
-    ("\r\n\t"*4000).blank?.should == true
+  it "it should be true if the string is composed of just whitespace" do
+    ' '.blank?.must_equal true
+    "\r\n\t".blank?.must_equal true
+    (' '*4000).blank?.must_equal true
+    ("\r\n\t"*4000).blank?.must_equal true
   end
-  specify "it should be false if the string has any non whitespace characters" do
-    '1'.blank?.should == false
-    ("\r\n\t"*4000 + 'a').blank?.should == false
-    ("\r\na\t"*4000).blank?.should == false
+  it "it should be false if the string has any non whitespace characters" do
+    '1'.blank?.must_equal false
+    ("\r\n\t"*4000 + 'a').blank?.must_equal false
+    ("\r\na\t"*4000).blank?.must_equal false
   end
 end