sequel 3.21.0 → 3.39.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
@@ -585,8 +585,7 @@ 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
@@ -869,26 +867,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
@@ -962,8 +956,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 +967,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|

data/spec/extensions/validation_helpers_spec.rb

@@ -317,18 +317,14 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
     @c.set_validations{validates_unique(:username)}
-    @c.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        
-        case sql
-        when /COUNT.*username = '0records'/
-          yield({:v => 0})
-        when /COUNT.*username = '1record'/
-          yield({:v => 1})
-        end
+    @c.dataset._fetch = proc do |sql|
+      case sql
+      when /COUNT.*username = '0records'/
+        {:v => 0}
+      when /COUNT.*username = '1record'/
+        {:v => 1}
       end
-    })
+    end
     
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
@@ -344,7 +340,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     ds1 = @c.dataset.filter([[:username, '0records']])
     ds2 = ds1.exclude(:id=>1)
-    @c.dataset.should_receive(:filter).with([[:username, '0records']]).twice.and_return(ds1)
+    @c.dataset.should_receive(:where).with([[:username, '0records']]).twice.and_return(ds1)
     ds1.should_receive(:exclude).with(:id=>1).once.and_return(ds2)
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
@@ -359,18 +355,14 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
     @c.set_validations{validates_unique([:username, :password])}
-    @c.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        
-        case sql
-        when /COUNT.*username = '0records'/
-          yield({:v => 0})
-        when /COUNT.*username = '1record'/
-          yield({:v => 1})
-        end
+    @c.dataset._fetch = proc do |sql|
+      case sql
+      when /COUNT.*username = '0records'/
+        {:v => 0}
+      when /COUNT.*username = '1record'/
+        {:v => 1}
       end
-    })
+    end
     
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
@@ -386,7 +378,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     ds1 = @c.dataset.filter([[:username, '0records'], [:password, 'anothertest']])
     ds2 = ds1.exclude(:id=>1)
-    @c.dataset.should_receive(:filter).with([[:username, '0records'], [:password, 'anothertest']]).twice.and_return(ds1)
+    @c.dataset.should_receive(:where).with([[:username, '0records'], [:password, 'anothertest']]).twice.and_return(ds1)
     ds1.should_receive(:exclude).with(:id=>1).once.and_return(ds2)
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
@@ -401,12 +393,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
     @c.set_validations{validates_unique(:username){|ds| ds.filter(:active)}}
-    @c.dataset.extend(Module.new {
-      def fetch_rows (sql)
-        @db << sql
-        yield({:v => 0})
-      end
-    })
+    @c.dataset._fetch = {:v=>0}
     
     MODEL_DB.reset
     @c.new(:username => "0records", :password => "anothertest").should be_valid
@@ -415,17 +402,24 @@ describe "Sequel::Plugins::ValidationHelpers" do
                     "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active AND (id != 3)) LIMIT 1"]
   end
 
+  it "should support validates_unique with a custom filter" do
+    @c.columns(:id, :username, :password)
+    @c.set_dataset MODEL_DB[:items]
+    @c.set_validations{validates_unique(:username, :where=>proc{|ds, obj, cols| ds.where(cols.map{|c| [Sequel.function(:lower, c), obj.send(c).downcase]})})}
+    @c.dataset._fetch = {:v=>0}
+    
+    MODEL_DB.reset
+    @c.new(:username => "0RECORDS", :password => "anothertest").should be_valid
+    @c.load(:id=>3, :username => "0RECORDS", :password => "anothertest").should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (lower(username) = '0records') LIMIT 1",
+                    "SELECT COUNT(*) AS count FROM items WHERE ((lower(username) = '0records') AND (id != 3)) LIMIT 1"]
+  end
+
   it "should support :only_if_modified option for validates_unique, and not check uniqueness for existing records if values haven't changed" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
     @c.set_validations{validates_unique([:username, :password], :only_if_modified=>true)}
-    
-    @c.dataset.extend(Module.new {
-      def fetch_rows (sql)
-        @db << sql
-        yield({:v => 0})
-      end
-    })
+    @c.dataset._fetch = {:v=>0}
     
     MODEL_DB.reset
     @c.new(:username => "0records", :password => "anothertest").should be_valid

data/spec/extensions/xml_serializer_spec.rb

@@ -36,6 +36,18 @@ describe "Sequel::Plugins::XmlSerializer" do
     Album.from_xml(@album.to_xml).should == @album
   end
 
+  it "should round trip successfully for namespaced models" do
+    module XmlSerializerTest
+      class Artist < Sequel::Model
+      plugin :xml_serializer
+      columns :id, :name
+      @db_schema = {:id=>{:type=>:integer}, :name=>{:type=>:string}}
+      end 
+    end
+    artist = XmlSerializerTest::Artist.load(:id=>2, :name=>'YJM')
+    XmlSerializerTest::Artist.from_xml(artist.to_xml).should == artist
+  end
+
   it "should round trip successfully with empty strings" do
     artist = Artist.load(:id=>2, :name=>'')
     Artist.from_xml(artist.to_xml).should == artist
@@ -106,13 +118,13 @@ describe "Sequel::Plugins::XmlSerializer" do
   end
 
   it "should support an :encoding option when serializing" do
-    ["<?xml version=\"1.0\" encoding=\"utf-8\"?><artist><id>2</id><name>YJM</name></artist>",
-     "<?xml version=\"1.0\" encoding=\"utf-8\"?><artist><name>YJM</name><id>2</id></artist>"].should include(@artist.to_xml(:encoding=>'utf-8').gsub(/\n */m, ''))
+    ["<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><id>2</id><name>YJM</name></artist>",
+     "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><name>YJM</name><id>2</id></artist>"].should include(@artist.to_xml(:encoding=>'UTF-8').gsub(/\n */m, ''))
   end
 
   it "should support a :builder_opts option when serializing" do
-    ["<?xml version=\"1.0\" encoding=\"utf-8\"?><artist><id>2</id><name>YJM</name></artist>",
-     "<?xml version=\"1.0\" encoding=\"utf-8\"?><artist><name>YJM</name><id>2</id></artist>"].should include(@artist.to_xml(:builder_opts=>{:encoding=>'utf-8'}).gsub(/\n */m, ''))
+    ["<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><id>2</id><name>YJM</name></artist>",
+     "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><name>YJM</name><id>2</id></artist>"].should include(@artist.to_xml(:builder_opts=>{:encoding=>'UTF-8'}).gsub(/\n */m, ''))
   end
 
   it "should support an :types option when serializing" do
@@ -145,6 +157,19 @@ describe "Sequel::Plugins::XmlSerializer" do
     Album.array_from_xml(Album.dataset.to_xml(:only=>:name)).should == [Album.load(:name=>@album.name)]
   end
 
+  it "should have to_xml dataset method respect an :array option" do
+    a = Album.load(:id=>1, :name=>'RF', :artist_id=>3)
+    Album.array_from_xml(Album.to_xml(:array=>[a])).should == [a]
+
+    a.associations[:artist] = artist = Artist.load(:id=>3, :name=>'YJM')
+    Album.array_from_xml(Album.to_xml(:array=>[a], :include=>:artist)).first.artist.should == artist
+
+    artist.associations[:albums] = [a]
+    x = Artist.array_from_xml(Artist.to_xml(:array=>[artist], :include=>:albums))
+    x.should == [artist]
+    x.first.albums.should == [a]
+  end
+
   it "should raise an error if the dataset does not have a row_proc" do
     proc{Album.dataset.naked.to_xml}.should raise_error(Sequel::Error)
   end