sequel 3.21.0 → 3.41.0

data/spec/extensions/tree_spec.rb

@@ -7,26 +7,11 @@ describe Sequel::Model, "tree plugin" do
     c.class_eval do
       def self.name; 'Node'; end
       columns :id, :name, :parent_id, :i, :pi
+      plugin :tree, opts
     end
-    ds = c.dataset
-    class << ds
-      attr_accessor :row_sets
-      def fetch_rows(sql)
-        @db << sql
-        if rs = row_sets.shift
-          rs.each{|row| yield row}
-        end
-      end
-    end
-    c.plugin :tree, opts
     c
   end
 
-  def y(c, *hs)
-    ds = c.dataset
-    ds.row_sets = hs
-  end
-
   before do
     @c = klass
     @ds = @c.dataset
@@ -71,7 +56,7 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have roots return an array of the tree's roots" do
-    y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+    @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)"]
   end
@@ -81,14 +66,14 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have ancestors return the ancestors of the current node" do
-    y(@c, [{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}])
+    @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 (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
   end
 
   it "should have descendants return the descendants of the current node" do
-    y(@c, [{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], [])
+    @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)",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 3)",
@@ -97,7 +82,7 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have root return the root of the current node" do
-    y(@c, [{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}])
+    @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 (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
@@ -113,14 +98,14 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have self_and_siblings return the children of the current node's parent" do
-    y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
+    @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 (nodes.id = 1) LIMIT 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
-    y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
+    @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 (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
@@ -132,23 +117,23 @@ describe Sequel::Model, "tree plugin" do
     end
 
     it "should have root class method return the root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       @c.root.should == @c.load(:id=>1, :parent_id=>nil, :name=>'r')
     end
 
     it "prevents creating a second root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       lambda { @c.create }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "errors when promoting an existing record to a second root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @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)
     end
 
     it "allows updating existing root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
     end
   end

data/spec/extensions/typecast_on_load_spec.rb

@@ -2,22 +2,17 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "TypecastOnLoad plugin" do
   before do
-    @db = Sequel::Database.new({})
+    @db = Sequel.mock(:fetch=>{:id=>1, :b=>"1", :y=>"0"}, :columns=>[:id, :b, :y], :numrows=>1)
     def @db.schema(*args)
       [[:id, {}], [:y, {:type=>:boolean, :db_type=>'tinyint(1)'}], [:b, {:type=>:integer, :db_type=>'integer'}]]
     end
     @c = Class.new(Sequel::Model(@db[:items])) do
-      include(Module.new{def _refresh(ds); values[:b] = b.to_s; self; end})
       attr_accessor :bset
       def b=(x)
         self.bset = true
         super
       end
     end
-    @c.instance_eval do
-      @columns = [:id, :b, :y]
-      def columns; @columns; end
-    end
   end 
 
   specify "should call setter method with value when loading the object, for all given columns" do
@@ -35,6 +30,14 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
     o.bset.should == true
   end
 
+  specify "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({:id=>1, :b=>"1", :y=>"0"}, true)
+    o.save.values.should == {:id=>1, :b=>1, :y=>"0"}
+    o.bset.should == true
+  end
+
   specify "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"}

data/spec/extensions/update_primary_key_spec.rb

@@ -9,57 +9,63 @@ describe "Sequel::Plugins::UpdatePrimaryKey" do
     @c.unrestrict_primary_key
     @o = @c.new
     @ds = @c.dataset
-    @ds.extend(Module.new do
-      attr_accessor :a
-      def fetch_rows(sql)
-        yield(a.dup)
-      end
-
-      def update(h)
-        if literal(opts[:where]) =~ /a = (\d)/ and $1.to_i == a[:a]
-          a.update(h)
-        end
-        super
-      end
-    end)
-    @ds.a = {:a=>1, :b=>3}
-    @ds2 = @ds.naked 
     MODEL_DB.reset
   end
 
   specify "should handle regular updates" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>1, :b=>4}], [{:a=>1, :b=>4}], [{:a=>1, :b=>5}], [{:a=>1, :b=>5}], [{:a=>1, :b=>6}], [{:a=>1, :b=>6}]]
     @c.first.update(:b=>4)
-    @ds2.all.should == [{:a=>1, :b=>4}]
+    @c.all.should == [@c.load(:a=>1, :b=>4)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 4 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>5).save
-    @ds2.all.should == [{:a=>1, :b=>5}]
+    @c.all.should == [@c.load(:a=>1, :b=>5)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 5 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>6).save(:b)
-    @ds2.all.should == [{:a=>1, :b=>6}]
+    @c.all.should == [@c.load(:a=>1, :b=>6)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
   end
 
   specify "should handle updating the primary key field with another field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     @c.first.update(:a=>2, :b=>4)
-    @ds2.all.should == [{:a=>2, :b=>4}]
+    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle updating just the primary key field when saving changes" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}], [{:a=>2, :b=>3}], [{:a=>3, :b=>3}]]
     @c.first.update(:a=>2)
-    @ds2.all.should == [{:a=>2, :b=>3}]
+    @c.all.should == [@c.load(:a=>2, :b=>3)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:a=>3).save(:a)
-    @ds2.all.should == [{:a=>3, :b=>3}]
+    @c.all.should == [@c.load(:a=>3, :b=>3)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
   end
 
   specify "should handle saving after modifying the primary key field with another field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     @c.first.set(:a=>2, :b=>4).save
-    @ds2.all.should == [{:a=>2, :b=>4}]
+    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle saving after modifying just the primary key field" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}]]
     @c.first.set(:a=>2).save
-    @ds2.all.should == [{:a=>2, :b=>3}]
+    @c.all.should == [@c.load(:a=>2, :b=>3)]
+    sqls = MODEL_DB.sqls
+    ["UPDATE a SET a = 2, b = 3 WHERE (a = 1)", "UPDATE a SET b = 3, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
+    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
   specify "should handle saving after updating the primary key" do
+    @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>5}]]
     @c.first.update(:a=>2).update(:b=>4).set(:b=>5).save
-    @ds2.all.should == [{:a=>2, :b=>5}]
+    @c.all.should == [@c.load(:a=>2, :b=>5)]
+    MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "UPDATE a SET b = 4 WHERE (a = 2)", "UPDATE a SET b = 5 WHERE (a = 2)", "SELECT * FROM a"]
   end
 end

data/spec/extensions/validation_class_methods_spec.rb

@@ -1,8 +1,15 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+model_class = proc do |klass, &block|
+  c = Class.new(klass)
+  c.plugin :validation_class_methods
+  c.class_eval(&block) if block
+  c
+end
+
 describe Sequel::Model do
   before do
-    @c = Class.new(Sequel::Model) do
+    @c = model_class.call Sequel::Model do
       def self.validates_coolness_of(attr)
         validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool}
       end
@@ -135,8 +142,7 @@ end
 
 describe Sequel::Model do
   before do
-    @c = Class.new(Sequel::Model)
-    @c.class_eval do
+    @c = model_class.call Sequel::Model do
       columns :score
       validates_each :score do |o, a, v|
         o.errors[a] << 'too low' if v < 87
@@ -165,11 +171,11 @@ describe Sequel::Model do
   end
 end
 
-describe Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator do
+describe "Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator" do
   before do
     $testit = nil
     
-    @c = Class.new(Sequel::Model) do
+    @c = model_class.call Sequel::Model do
       def self.validates_blah
         $testit = 1324
       end
@@ -186,7 +192,7 @@ end
 
 describe Sequel::Model do
   before do
-    @c = Class.new(Sequel::Model) do
+    @c = model_class.call Sequel::Model do
       columns :value
       
       def self.filter(*args)
@@ -527,13 +533,8 @@ describe Sequel::Model do
   end
   
   specify "should raise an error if inclusion_of doesn't receive a valid :in option" do
-    lambda {
-      @c.validates_inclusion_of :value
-    }.should raise_error(ArgumentError)
-    
-    lambda {
-      @c.validates_inclusion_of :value, :in => 1
-    }.should raise_error(ArgumentError)
+    lambda{@c.validates_inclusion_of :value}.should raise_error(ArgumentError)
+    lambda{@c.validates_inclusion_of :value, :in => 1}.should raise_error(ArgumentError)
   end
   
   specify "should raise an error if inclusion_of handles :allow_nil too" do
@@ -570,7 +571,6 @@ describe Sequel::Model do
 
   specify "should validate uniqueness_of with if => false" do
     @c.validates_uniqueness_of :value, :if => :skip
-
     @m.value = 'a'
     @m.should be_valid
   end
@@ -578,15 +578,14 @@ describe Sequel::Model do
   specify "should validate uniqueness_of with allow_missing => true" do
     @c.validates_uniqueness_of :value, :allow_missing => true
     @m.should be_valid
-    @m.value = nil
+    @m.value = 1
     @m.should_not be_valid
   end
 end
 
 describe "Superclass validations" do
   before do
-    @c1 = Class.new(Sequel::Model)
-    @c1.class_eval do
+    @c1 = model_class.call Sequel::Model do
       columns :value
       validates_length_of :value, :minimum => 5
     end
@@ -602,16 +601,11 @@ describe "Superclass validations" do
     o = @c2.new
     o.value = 'ab'
     o.valid?.should == false
-    o.errors.full_messages.should == [
-      'value is too short'
-    ]
+    o.errors.full_messages.should == ['value is too short']
 
     o.value = '12'
     o.valid?.should == false
-    o.errors.full_messages.should == [
-      'value is too short',
-      'value is invalid'
-    ]
+    o.errors.full_messages.should == ['value is too short', 'value is invalid']
 
     o.value = 'abcde'
     o.valid?.should be_true
@@ -626,9 +620,7 @@ describe "Superclass validations" do
 
     o.value = '12'
     o.valid?.should == false
-    o.errors.full_messages.should == [
-      'value is invalid'
-    ]
+    o.errors.full_messages.should == ['value is invalid']
 
     o.value = 'abcde'
     o.valid?.should be_true
@@ -637,8 +629,7 @@ end
 
 describe ".validates with block" do
   specify "should support calling .each" do
-    @c = Class.new(Sequel::Model)
-    @c.class_eval do
+    @c = model_class.call Sequel::Model do
       columns :vvv
       validates do
         each :vvv do |o, a, v|
@@ -659,24 +650,36 @@ describe Sequel::Model, "Validations" do
 
   before(:all) do
     class ::Person < Sequel::Model
+      plugin :validation_class_methods
       columns :id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms
     end
 
     class ::Smurf < Person
     end
+
+    class ::Can < Sequel::Model
+      plugin :validation_class_methods
+      columns :id, :name
+    end
     
     class ::Cow < Sequel::Model
+      plugin :validation_class_methods
       columns :id, :name, :got_milk
     end
 
     class ::User < Sequel::Model
+      plugin :validation_class_methods
       columns :id, :username, :password
     end
     
     class ::Address < Sequel::Model
+      plugin :validation_class_methods
       columns :id, :zip_code
     end
   end
+  after(:all) do
+    [:Person, :Smurf, :Cow, :User, :Address].each{|c| Object.send(:remove_const, c)}
+  end
   
   it "should validate the acceptance of a column" do
     class ::Cow < Sequel::Model
@@ -754,8 +757,7 @@ describe Sequel::Model, "Validations" do
   end
   
   it "should validate that a column doesn't have a string value" do
-    p = Class.new(Sequel::Model)
-    p.class_eval do
+    p = model_class.call Sequel::Model do
       columns :age, :price, :confirmed
       self.raise_on_typecast_failure = false
       validates_not_string :age
@@ -824,22 +826,18 @@ describe Sequel::Model, "Validations" do
         uniqueness_of :username
       end
     end
-    User.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        
-        case sql
-        when /COUNT.*username = '0records'/
-          yield({:v => 0})
-        when /COUNT.*username = '2records'/
-          yield({:v => 2})
-        when /COUNT.*username = '1record'/
-          yield({:v => 1})
-        when /username = '1record'/
-          yield({:id => 3, :username => "1record", :password => "test"})
-        end
+    User.dataset._fetch = proc do |sql|
+      case sql
+      when /COUNT.*username = '0records'/
+        {:v => 0}
+      when /COUNT.*username = '2records'/
+        {:v => 2}
+      when /COUNT.*username = '1record'/
+        {:v => 1}
+      when /username = '1record'/
+        {:id => 3, :username => "1record", :password => "test"}
       end
-    })
+    end
     
     @user = User.new(:username => "2records", :password => "anothertest")
     @user.should_not be_valid
@@ -860,6 +858,12 @@ describe Sequel::Model, "Validations" do
     @user = User.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
     @user.errors.full_messages.should == []
+
+    User.db.sqls
+    @user = User.new(:password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    User.db.sqls.should == []
   end
   
   it "should validate the uniqueness of multiple columns" do
@@ -869,26 +873,22 @@ describe Sequel::Model, "Validations" do
         uniqueness_of [:username, :password]
       end
     end
-    User.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        
-        case sql
-        when /COUNT.*username = '0records'/
-          yield({:v => 0})
-        when /COUNT.*username = '2records'/
-          yield({:v => 2})
-        when /COUNT.*username = '1record'/
-          yield({:v => 1})
-        when /username = '1record'/
-          if sql =~ /password = 'anothertest'/
-            yield({:id => 3, :username => "1record", :password => "anothertest"})
-          else
-            yield({:id => 4, :username => "1record", :password => "test"})
-          end
+    User.dataset._fetch = proc do |sql|
+      case sql
+      when /COUNT.*username = '0records'/
+        {:v => 0}
+      when /COUNT.*username = '2records'/
+        {:v => 2}
+      when /COUNT.*username = '1record'/
+        {:v => 1}
+      when /username = '1record'/
+        if sql =~ /password = 'anothertest'/
+          {:id => 3, :username => "1record", :password => "anothertest"}
+        else
+          {:id => 4, :username => "1record", :password => "test"}
         end
       end
-    })
+    end
     
     @user = User.new(:username => "2records", :password => "anothertest")
     @user.should_not be_valid
@@ -913,6 +913,18 @@ describe Sequel::Model, "Validations" do
     @user = User.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
     @user.errors.full_messages.should == []
+
+    User.db.sqls
+    @user = User.new(:password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    @user = User.new(:username => "0records")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    @user = User.new
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+    User.db.sqls.should == []
   end
   
   it "should have a validates block that contains multiple validations" do
@@ -962,8 +974,6 @@ describe Sequel::Model, "Validations" do
 
   it "should validate correctly instances initialized with string keys" do
     class ::Can < Sequel::Model
-      columns :id, :name
-      
       validates_length_of :name, :minimum => 4
     end
     
@@ -975,8 +985,7 @@ end
 
 describe "Model#save" do
   before do
-    @c = Class.new(Sequel::Model(:people))
-    @c.class_eval do
+    @c = model_class.call Sequel::Model(:people) do
       columns :id, :x
 
       validates_each :x do |o, a, v|