sequel 3.21.0 → 3.28.0

data/spec/model/hooks_spec.rb

@@ -268,4 +268,165 @@ describe "Model#before_validation && Model#after_validation" do
     @c.load(:id => 2233).save.should == nil
     MODEL_DB.sqls.should == []
   end
+  
+  specify "#valid? should return false if before_validation returns false" do
+    @c.send(:define_method, :before_validation){false}
+    @c.load(:id => 2233).valid?.should == false
+  end
+end
+
+describe "Model around filters" do
+  before do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :id, :x
+      def _save_refresh(*a) end
+    end
+  end
+  
+  specify "around_create should be called around new record creation" do
+    @c.class_eval do
+      def around_create
+        MODEL_DB << 'ac_before'
+        super
+        MODEL_DB << 'ac_after'
+      end
+    end
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [ 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after' ]
+  end
+
+  specify "around_delete should be called around record destruction" do
+    @c.class_eval do
+      def around_destroy
+        MODEL_DB << 'ad_before'
+        super
+        MODEL_DB << 'ad_after'
+      end
+    end
+    @c.load(:id=>1, :x => 2).destroy
+    MODEL_DB.sqls.should == [ 'ad_before', 'DELETE FROM items WHERE (id = 1)', 'ad_after' ]
+  end
+  
+  specify "around_update should be called around updating existing records" do
+    @c.class_eval do
+      def around_update
+        MODEL_DB << 'au_before'
+        super
+        MODEL_DB << 'au_after'
+      end
+    end
+    @c.load(:id=>1, :x => 2).save
+    MODEL_DB.sqls.should == [ 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after' ]
+  end
+
+  specify "around_update should be called around saving both new and existing records, around either after_create and after_update" do
+    @c.class_eval do
+      def around_update
+        MODEL_DB << 'au_before'
+        super
+        MODEL_DB << 'au_after'
+      end
+      def around_create
+        MODEL_DB << 'ac_before'
+        super
+        MODEL_DB << 'ac_after'
+      end
+      def around_save
+        MODEL_DB << 'as_before'
+        super
+        MODEL_DB << 'as_after'
+      end
+    end
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [ 'as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after' ]
+    MODEL_DB.sqls.clear
+    @c.load(:id=>1, :x => 2).save
+    MODEL_DB.sqls.should == [ 'as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after' ]
+  end
+
+  specify "around_validation should be called around validating records" do
+    @c.class_eval do
+      def around_validation
+        MODEL_DB << 'av_before'
+        super
+        MODEL_DB << 'av_after'
+      end
+      def validate
+        MODEL_DB << 'validate'
+      end
+    end
+    @c.new(:x => 2).valid?.should == true
+    MODEL_DB.sqls.should == [ 'av_before', 'validate', 'av_after' ]
+  end
+
+  specify "around_validation should be able to catch validation errors and modify them" do
+    @c.class_eval do
+      def validate
+        errors.add(:x, 'foo')
+      end
+    end
+    @c.new(:x => 2).valid?.should == false
+    @c.class_eval do
+      def around_validation
+        super
+        errors.clear
+      end
+    end
+    @c.new(:x => 2).valid?.should == true
+  end
+
+  specify "around_create that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_create){}
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
+  end
+  
+  specify "around_update that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_update){}
+    proc{@c.load(:x => 2).save}.should raise_error(Sequel::HookFailed)
+  end
+  
+  specify "around_save that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_save){}
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
+    proc{@c.load(:x => 2).save}.should raise_error(Sequel::HookFailed)
+  end
+  
+  specify "around_destroy that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_destroy){}
+    proc{@c.load(:x => 2).destroy}.should raise_error(Sequel::HookFailed)
+  end
+  
+  specify "around_validation that doesn't call super should raise a HookFailed" do
+    @c.send(:define_method, :around_validation){}
+    proc{@c.new.save}.should raise_error(Sequel::HookFailed)
+  end
+
+  specify "around_validation that doesn't call super should have valid? return false" do
+    @c.send(:define_method, :around_validation){}
+    @c.new.valid?.should == false
+  end
+
+  specify "around_* that doesn't call super should return nil if raise_on_save_failure is false" do
+    @c.raise_on_save_failure = false
+
+    o = @c.load(:id => 1)
+    o.meta_def(:around_save){}
+    o.save.should == nil
+
+    o = @c.load(:id => 1)
+    o.meta_def(:around_update){}
+    o.save.should == nil
+
+    o = @c.new
+    o.meta_def(:around_create){}
+    o.save.should == nil
+
+    o = @c.new
+    o.meta_def(:around_validation){}
+    o.save.should == nil
+  end
+
 end

data/spec/model/model_spec.rb

@@ -12,13 +12,48 @@ describe "Sequel::Model()" do
     c.dataset.should == ds
   end
 
-  it "should return a model subclass with a dataset with the default database and given table name if given a symbol" do
+  it "should return a model subclass with a dataset with the default database and given table name if given a Symbol" do
     c = Sequel::Model(:blah)
     c.superclass.should == Sequel::Model
     c.db.should == @db
     c.table_name.should == :blah
   end
 
+  it "should return a model subclass with a dataset with the default database and given table name if given a LiteralString" do
+    c = Sequel::Model('blah'.lit)
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == 'blah'.lit
+  end
+
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::Identifier" do
+    c = Sequel::Model(:blah.identifier)
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == :blah.identifier
+  end
+
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::QualifiedIdentifier" do
+    c = Sequel::Model(:blah.qualify(:boo))
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == :blah.qualify(:boo)
+  end
+
+  it "should return a model subclass with a dataset with the default database and given table name if given an SQL::AliasedExpression" do
+    c = Sequel::Model(:blah.as(:boo))
+    c.superclass.should == Sequel::Model
+    c.db.should == @db
+    c.table_name.should == :boo
+  end
+
+  it "should return a model subclass with the given dataset if given a dataset using an SQL::Identifier" do
+    ds = @db[:blah.identifier]
+    c = Sequel::Model(ds)
+    c.superclass.should == Sequel::Model
+    c.dataset.should == ds
+  end
+
   it "should return a model subclass associated to the given database if given a database" do
     db = Sequel::Database.new
     c = Sequel::Model(db)
@@ -43,6 +78,27 @@ describe "Sequel::Model()" do
       end.should_not raise_error
     end
 
+    it "should work without raising an exception with an SQL::Identifier " do
+      proc do
+        class ::Album < Sequel::Model(:table.identifier); end
+        class ::Album < Sequel::Model(:table.identifier); end
+      end.should_not raise_error
+    end
+
+    it "should work without raising an exception with an SQL::QualifiedIdentifier " do
+      proc do
+        class ::Album < Sequel::Model(:table.qualify(:schema)); end
+        class ::Album < Sequel::Model(:table.qualify(:schema)); end
+      end.should_not raise_error
+    end
+
+    it "should work without raising an exception with an SQL::AliasedExpression" do
+      proc do
+        class ::Album < Sequel::Model(:table.as(:alias)); end
+        class ::Album < Sequel::Model(:table.as(:alias)); end
+      end.should_not raise_error
+    end
+
     it "should work without raising an exception with a database" do
       proc do
         class ::Album < Sequel::Model(@db); end
@@ -56,6 +112,13 @@ describe "Sequel::Model()" do
         class ::Album < Sequel::Model(@db[:table]); end
       end.should_not raise_error
     end
+
+    it "should work without raising an exception with a dataset with an SQL::Identifier" do
+      proc do
+        class ::Album < Sequel::Model(@db[:table.identifier]); end
+        class ::Album < Sequel::Model(@db[:table.identifier]); end
+      end.should_not raise_error
+    end
   end
 end
 
@@ -106,12 +169,36 @@ describe Sequel::Model, "dataset & schema" do
     @model.table_name.should == :foo
   end
 
-  it "set_dataset should take a symbol" do
+  it "set_dataset should take a Symbol" do
     @model.db = MODEL_DB
     @model.set_dataset(:foo)
     @model.table_name.should == :foo
   end
 
+  it "set_dataset should take a LiteralString" do
+    @model.db = MODEL_DB
+    @model.set_dataset('foo'.lit)
+    @model.table_name.should == 'foo'.lit
+  end
+
+  it "set_dataset should take an SQL::Identifier" do
+    @model.db = MODEL_DB
+    @model.set_dataset(:foo.identifier)
+    @model.table_name.should == :foo.identifier
+  end
+
+  it "set_dataset should take an SQL::QualifiedIdentifier" do
+    @model.db = MODEL_DB
+    @model.set_dataset(:foo.qualify(:bar))
+    @model.table_name.should == :foo.qualify(:bar)
+  end
+
+  it "set_dataset should take an SQL::AliasedExpression" do
+    @model.db = MODEL_DB
+    @model.set_dataset(:foo.as(:bar))
+    @model.table_name.should == :bar
+  end
+
   it "table_name should respect table aliases" do
     @model.set_dataset(:foo___x)
     @model.table_name.should == :x

data/spec/model/plugins_spec.rb

@@ -233,4 +233,21 @@ describe Sequel::Model, ".plugin" do
     end
     lambda{@c.plugin m}.should_not raise_error
   end
+
+  it "should not raise an error if plugin submodule names exist higher up in the namespace hierarchy" do
+    class ::ClassMethods; end
+    @c.plugin(m = Module.new)
+    Object.send(:remove_const, :ClassMethods)
+    @c.plugins.should include(m)
+
+    class ::InstanceMethods; end
+    @c.plugin(m = Module.new)
+    Object.send(:remove_const, :InstanceMethods)
+    @c.plugins.should include(m)
+
+    class ::DatasetMethods; end
+    @c.plugin(m = Module.new)
+    Object.send(:remove_const, :DatasetMethods)
+    @c.plugins.should include(m)
+  end
 end

data/spec/model/record_spec.rb

@@ -52,6 +52,7 @@ describe "Model#save" do
 
   it "should use dataset's insert_select method if present" do
     ds = @c.dataset = @c.dataset.clone
+    def ds.supports_insert_select?() true end
     def ds.insert_select(hash)
       execute("INSERT INTO items (y) VALUES (2)")
       {:y=>2}
@@ -63,6 +64,12 @@ describe "Model#save" do
     MODEL_DB.sqls.should == ["INSERT INTO items (y) VALUES (2)"]
   end
 
+  it "should not use dataset's insert_select method if specific columns are selected" do
+    ds = @c.dataset = @c.dataset.select(:y)
+    ds.should_not_receive(:insert_select)
+    @c.new(:x => 1).save
+  end
+
   it "should use value returned by insert as the primary key and refresh the object" do
     @c.dataset.meta_def(:insert){|h| super(h); 13}
     o = @c.new(:x => 11)
@@ -623,6 +630,40 @@ describe "Model#pk" do
   end
 end
 
+describe "Model#pk_or_nil" do
+  before(:each) do
+    @m = Class.new(Sequel::Model)
+    @m.columns :id, :x, :y
+  end
+  
+  it "should be default return the value of the :id column" do
+    m = @m.load(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should == 111
+  end
+
+  it "should be return the primary key value for custom primary key" do
+    @m.set_primary_key :x
+    m = @m.load(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should == 2
+  end
+
+  it "should be return the primary key value for composite primary key" do
+    @m.set_primary_key [:y, :x]
+    m = @m.load(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should == [3, 2]
+  end
+
+  it "should raise if no primary key" do
+    @m.set_primary_key nil
+    m = @m.new(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should be_nil
+
+    @m.no_primary_key
+    m = @m.new(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should be_nil
+  end
+end
+
 describe "Model#pk_hash" do
   before(:each) do
     @m = Class.new(Sequel::Model)
@@ -716,6 +757,29 @@ describe Sequel::Model, "#set" do
     MODEL_DB.sqls.should == []
   end
 
+  it "should raise error if strict_param_setting is true and method does not exist" do
+    @o1.strict_param_setting = true
+    proc{@o1.set('foo' => 1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise error if strict_param_setting is true and column is a primary key" do
+    @o1.strict_param_setting = true
+    proc{@o1.set('id' => 1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise error if strict_param_setting is true and column is restricted" do
+    @o1.strict_param_setting = true
+    @c.set_restricted_columns :x
+    proc{@o1.set('x' => 1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should not create a symbol if strict_param_setting is true and string is given" do
+    @o1.strict_param_setting = true
+    l = Symbol.all_symbols.length
+    proc{@o1.set('sadojafdso' => 1)}.should raise_error(Sequel::Error)
+    Symbol.all_symbols.length.should == l
+  end
+
   it "#set should correctly handle cases where an instance method is added to the class" do
     @o1.set(:x => 1)
     @o1.values.should == {:x => 1}
@@ -739,6 +803,32 @@ describe Sequel::Model, "#set" do
     @o1.set(:x => 2, :z => 3)
     @o1.values.should == {:x => 2, :z=>3}
   end
+
+  it "#set should correctly handle cases where a module with a setter method is included in the class" do
+    @o1.set(:x => 1)
+    @o1.values.should == {:x => 1}
+
+    @c.send(:include, Module.new do
+      def z=(v)
+        self[:z] = v
+      end
+    end)
+    @o1.set(:x => 2, :z => 3)
+    @o1.values.should == {:x => 2, :z=>3}
+  end
+
+  it "#set should correctly handle cases where the object extends a module with a setter method " do
+    @o1.set(:x => 1)
+    @o1.values.should == {:x => 1}
+
+    @o1.extend(Module.new do
+      def z=(v)
+        self[:z] = v
+      end
+    end)
+    @o1.set(:x => 2, :z => 3)
+    @o1.values.should == {:x => 2, :z=>3}
+  end
 end
 
 describe Sequel::Model, "#update" do
@@ -997,6 +1087,11 @@ describe Sequel::Model, "#exists?" do
     @model.load(:id=>2).exists?.should be_false
     MODEL_DB.sqls.should == ['SELECT 1 FROM items WHERE (id = 2) LIMIT 1']
   end
+
+  it "should return false without issuing a query if the model object is new" do
+    @model.new.exists?.should be_false
+    MODEL_DB.sqls.should == []
+  end
 end
 
 describe Sequel::Model, "#each" do
@@ -1094,13 +1189,10 @@ describe Sequel::Model, "#hash" do
     y = Class.new(Sequel::Model)
     y.columns :id, :x
     a = z.load(:id => 1, :x => 3)
-    b = z.load(:id => 1, :x => 4)
-    c = z.load(:id => 2, :x => 3)
-    d = y.load(:id => 1, :x => 3)
     
-    a.hash.should == b.hash
-    a.hash.should_not == c.hash
-    a.hash.should_not == d.hash
+    a.hash.should == z.load(:id => 1, :x => 4).hash
+    a.hash.should_not == z.load(:id => 2, :x => 3).hash
+    a.hash.should_not == y.load(:id => 1, :x => 3).hash
   end
 
   specify "should be the same only for objects with the same class and values if the pk is nil" do
@@ -1109,14 +1201,71 @@ describe Sequel::Model, "#hash" do
     y = Class.new(Sequel::Model)
     y.columns :id, :x
     a = z.new(:x => 3)
-    b = z.new(:x => 4)
-    c = z.new(:x => 3)
-    d = y.new(:x => 3)
     
-    a.hash.should_not == b.hash
-    a.hash.should == c.hash
-    a.hash.should_not == d.hash
+    a.hash.should_not == z.new(:x => 4).hash
+    a.hash.should == z.new(:x => 3).hash
+    a.hash.should_not == y.new(:x => 3).hash
+  end
+
+  specify "should be the same only for objects with the same class and pk if pk is composite and all values are non-NULL" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :id2, :x
+    z.set_primary_key(:id, :id2)
+    y = Class.new(Sequel::Model)
+    y.columns :id, :id2, :x
+    y.set_primary_key(:id, :id2)
+    a = z.load(:id => 1, :id2=>2, :x => 3)
+    
+    a.hash.should == z.load(:id => 1, :id2=>2, :x => 4).hash
+    a.hash.should_not == z.load(:id => 2, :id2=>1, :x => 3).hash
+    a.hash.should_not == y.load(:id => 1, :id2=>1, :x => 3).hash
+  end
+
+  specify "should be the same only for objects with the same class and value if pk is composite and one values is NULL" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :id2, :x
+    z.set_primary_key(:id, :id2)
+    y = Class.new(Sequel::Model)
+    y.columns :id, :id2, :x
+    y.set_primary_key(:id, :id2)
+
+    a = z.load(:id => 1, :id2 => nil, :x => 3)
+    a.hash.should == z.load(:id => 1, :id2=>nil, :x => 3).hash
+    a.hash.should_not == z.load(:id => 1, :id2=>nil, :x => 4).hash
+    a.hash.should_not == y.load(:id => 1, :id2=>nil, :x => 3).hash
+
+    a = z.load(:id =>nil, :id2 => nil, :x => 3)
+    a.hash.should == z.load(:id => nil, :id2=>nil, :x => 3).hash
+    a.hash.should_not == z.load(:id => nil, :id2=>nil, :x => 4).hash
+    a.hash.should_not == y.load(:id => nil, :id2=>nil, :x => 3).hash
+
+    a = z.load(:id => 1, :x => 3)
+    a.hash.should == z.load(:id => 1, :x => 3).hash
+    a.hash.should_not == z.load(:id => 1, :id2=>nil, :x => 3).hash
+    a.hash.should_not == z.load(:id => 1, :x => 4).hash
+    a.hash.should_not == y.load(:id => 1, :x => 3).hash
+
+    a = z.load(:x => 3)
+    a.hash.should == z.load(:x => 3).hash
+    a.hash.should_not == z.load(:id => nil, :id2=>nil, :x => 3).hash
+    a.hash.should_not == z.load(:x => 4).hash
+    a.hash.should_not == y.load(:x => 3).hash
+  end
+
+  specify "should be the same only for objects with the same class and values if the no primary key" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :x
+    z.no_primary_key
+    y = Class.new(Sequel::Model)
+    y.columns :id, :x
+    y.no_primary_key
+    a = z.new(:x => 3)
+    
+    a.hash.should_not == z.new(:x => 4).hash
+    a.hash.should == z.new(:x => 3).hash
+    a.hash.should_not == y.new(:x => 3).hash
   end
+
 end
 
 describe Sequel::Model, "#initialize" do
@@ -1161,6 +1310,29 @@ describe Sequel::Model, "#initialize" do
     m.values.should == {:x => 2}
   end
 end
+  
+describe Sequel::Model, "#initialize_set" do
+  before do
+    @c = Class.new(Sequel::Model){columns :id, :x, :y}
+  end
+
+  specify "should be called by initialize to set the column values" do
+    @c.send(:define_method, :initialize_set){|h| set(:y => 3)}
+    @c.new(:x => 2).values.should == {:y => 3}
+  end
+
+  specify "should be called with the hash given to initialize " do
+    x = nil
+    @c.send(:define_method, :initialize_set){|y| x = y}
+    @c.new(:x => 2)
+    x.should == {:x => 2}
+  end
+
+  specify "should not cause columns modified by the method to be considered as changed" do
+    @c.send(:define_method, :initialize_set){|h| set(:y => 3)}
+    @c.new(:x => 2).changed_columns.should == []
+  end
+end
 
 describe Sequel::Model, ".create" do
 

data/spec/model/spec_helper.rb

@@ -8,6 +8,11 @@ unless Sequel.const_defined?('Model')
   require 'sequel/model'
 end
 
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
 class MockDataset < Sequel::Dataset
   def insert(*args)
     @db.execute insert_sql(*args)

data/spec/model/validations_spec.rb

@@ -61,6 +61,17 @@ describe Sequel::Model::Errors do
     msgs.should include('blow blieuh', 'blow blich', 'blay bliu')
   end
 
+  specify "should not add column names for LiteralStrings" do
+    @errors.full_messages.should == []
+    
+    @errors[:blow] << 'blieuh'
+    @errors[:blow] << 'blich'.lit
+    @errors[:blay] << 'bliu'
+    msgs = @errors.full_messages
+    msgs.size.should == 3
+    msgs.should include('blow blieuh', 'blich', 'blay bliu')
+  end
+
   specify "should return the number of error messages using #count" do
     @errors.count.should == 0
     @errors.add(:a, 'b')