sequel 3.3.0 → 3.4.0

data/spec/extensions/boolean_readers_spec.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "BooleanReaders plugin" do
+  before do
+    @db = Sequel::Database.new({})
+    def @db.schema(*args)
+      [[:id, {}], [:y, {:type=>:integer, :db_type=>'tinyint(1)'}], [:b, {:type=>:boolean, :db_type=>'boolean'}]]
+    end
+
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @p =lambda do
+      @columns = [:id, :b, :y]
+      def columns; @columns; end
+    end
+    @c.instance_eval(&@p)
+  end 
+
+  specify "should create attribute? readers for all boolean attributes" do
+    @c.plugin(:boolean_readers)
+    o = @c.new
+    o.b?.should == nil
+    o.b = '1'
+    o.b?.should == true
+    o.b = '0'
+    o.b?.should == false
+    o.b = ''
+    o.b?.should == nil
+  end
+
+  specify "should not create attribute? readers for non-boolean attributes" do
+    @c.plugin(:boolean_readers)
+    proc{@c.new.y?}.should raise_error(NoMethodError)
+    proc{@c.new.id?}.should raise_error(NoMethodError)
+  end
+
+  specify "should accept a block to determine if an attribute is boolean" do
+    @c.plugin(:boolean_readers){|c| db_schema[c][:db_type] == 'tinyint(1)'}
+    proc{@c.new.b?}.should raise_error(NoMethodError)
+    o = @c.new
+    o.y.should == nil
+    o.y?.should == nil
+    o.y = '1'
+    o.y.should == 1
+    o.y?.should == true
+    o.y = '0'
+    o.y.should == 0
+    o.y?.should == false
+    o.y = ''
+    o.y.should == nil
+    o.y?.should == nil
+  end
+
+  specify "should create boolean readers when set_dataset is defined" do
+    c = Class.new(Sequel::Model(@db))
+    c.instance_eval(&@p)
+    c.plugin(:boolean_readers)
+    c.set_dataset(@db[:a])
+    o = c.new
+    o.b?.should == nil
+    o.b = '1'
+    o.b?.should == true
+    o.b = '0'
+    o.b?.should == false
+    o.b = ''
+    o.b?.should == nil
+    proc{o.i?}.should raise_error(NoMethodError)
+
+    c = Class.new(Sequel::Model(@db))
+    c.instance_eval(&@p)
+    c.plugin(:boolean_readers){|x| db_schema[x][:db_type] == 'tinyint(1)'}
+    c.set_dataset(@db[:a])
+    o = c.new
+    o.y.should == nil
+    o.y?.should == nil
+    o.y = '1'
+    o.y.should == 1
+    o.y?.should == true
+    o.y = '0'
+    o.y.should == 0
+    o.y?.should == false
+    o.y = ''
+    o.y.should == nil
+    o.y?.should == nil
+    proc{o.b?}.should raise_error(NoMethodError)
+  end
+end

data/spec/extensions/inflector_spec.rb

@@ -48,16 +48,16 @@ describe String do
 
   it "#pluralize should transform words from singular to plural" do
     "post".pluralize.should == "posts"
-    "octopus".pluralize.should =="octopi"
+    "octopus".pluralize.should =="octopuses"
     "the blue mailman".pluralize.should == "the blue mailmen"
-    "CamelOctopus".pluralize.should == "CamelOctopi"
+    "CamelOctopus".pluralize.should == "CamelOctopuses"
   end
   
   it "#singularize should transform words from plural to singular" do
     "posts".singularize.should == "post"
-    "octopi".singularize.should == "octopus"
+    "octopuses".singularize.should == "octopus"
     "the blue mailmen".singularize.should == "the blue mailman"
-    "CamelOctopi".singularize.should == "CamelOctopus"
+    "CamelOctopuses".singularize.should == "CamelOctopus"
   end
   
   it "#tableize should transform class names to table names" do
@@ -117,3 +117,66 @@ describe String::Inflections do
     String.inflections{|i| i.should == String::Inflections}.should == String::Inflections
   end
 end
+
+describe 'Default inflections' do
+  it "should support the default inflection rules" do
+    {
+      :test=>:tests,
+      :ax=>:axes,
+      :testis=>:testes,
+      :octopus=>:octopuses,
+      :virus=>:viruses,
+      :alias=>:aliases,
+      :status=>:statuses,
+      :bus=>:buses,
+      :buffalo=>:buffaloes,
+      :tomato=>:tomatoes,
+      :datum=>:data,
+      :bacterium=>:bacteria,
+      :analysis=>:analyses,
+      :basis=>:bases,
+      :diagnosis=>:diagnoses,
+      :parenthesis=>:parentheses,
+      :prognosis=>:prognoses,
+      :synopsis=>:synopses,
+      :thesis=>:theses,
+      :wife=>:wives,
+      :giraffe=>:giraffes,
+      :self=>:selves,
+      :dwarf=>:dwarves,
+      :hive=>:hives,
+      :fly=>:flies,
+      :buy=>:buys,
+      :soliloquy=>:soliloquies,
+      :day=>:days,
+      :attorney=>:attorneys,
+      :boy=>:boys,
+      :hoax=>:hoaxes,
+      :lunch=>:lunches,
+      :princess=>:princesses,
+      :matrix=>:matrices,
+      :vertex=>:vertices,
+      :index=>:indices,
+      :mouse=>:mice,
+      :louse=>:lice,
+      :ox=>:oxen,
+      :quiz=>:quizzes,
+      :motive=>:motives,
+      :movie=>:movies,
+      :series=>:series,
+      :crisis=>:crises,
+      :person=>:people,
+      :man=>:men,
+      :woman=>:women,
+      :child=>:children,
+      :sex=>:sexes,
+      :move=>:moves
+    }.each do |k, v|
+      k.to_s.pluralize.should == v.to_s
+      v.to_s.singularize.should == k.to_s
+    end
+    [:equipment, :information, :rice, :money, :species, :series, :fish, :sheep, :news].each do |a|
+      a.to_s.pluralize.should == a.to_s.singularize
+    end
+  end
+end

data/spec/extensions/instance_hooks_spec.rb

@@ -0,0 +1,133 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "InstanceHooks plugin" do
+  def r(x)
+    @r << x
+    x
+  end
+  
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.plugin :instance_hooks
+    @c.raise_on_save_failure = false
+    @o = @c.new
+    @x = @c.load({:id=>1})
+    @r = []
+  end
+  
+  it "should support before_create_hook and after_create_hook" do
+    @o.after_create_hook{r 1}
+    @o.before_create_hook{r 2}
+    @o.after_create_hook{r 3}
+    @o.before_create_hook{r 4}
+    @o.save.should_not == nil
+    @r.should == [4, 2, 1, 3]
+  end
+
+  it "should cancel the save if before_create_hook block returns false" do
+    @o.after_create_hook{r 1}
+    @o.before_create_hook{r false}
+    @o.before_create_hook{r 4}
+    @o.save.should == nil
+    @r.should == [4, false]
+    @r.clear
+    @o.save.should == nil
+    @r.should == [4, false]
+  end
+
+  it "should support before_update_hook and after_update_hook" do
+    @x.after_update_hook{r 1}
+    @x.before_update_hook{r 2}
+    @x.after_update_hook{r 3}
+    @x.before_update_hook{r 4}
+    @x.save.should_not == nil
+    @r.should == [4, 2, 1, 3]
+    @x.save.should_not == nil
+    @r.should == [4, 2, 1, 3]
+  end
+
+  it "should cancel the save if before_update_hook block returns false" do
+    @x.after_update_hook{r 1}
+    @x.before_update_hook{r false}
+    @x.before_update_hook{r 4}
+    @x.save.should == nil
+    @r.should == [4, false]
+    @r.clear
+    @x.save.should == nil
+    @r.should == [4, false]
+  end
+
+  it "should support before_save_hook and after_save_hook" do
+    @o.after_save_hook{r 1}
+    @o.before_save_hook{r 2}
+    @o.after_save_hook{r 3}
+    @o.before_save_hook{r 4}
+    @o.save.should_not == nil
+    @r.should == [4, 2, 1, 3]
+    @r.clear
+    
+    @x.after_save_hook{r 1}
+    @x.before_save_hook{r 2}
+    @x.after_save_hook{r 3}
+    @x.before_save_hook{r 4}
+    @x.save.should_not == nil
+    @r.should == [4, 2, 1, 3]
+    @x.save.should_not == nil
+    @r.should == [4, 2, 1, 3]
+  end
+
+  it "should cancel the save if before_save_hook block returns false" do
+    @x.after_save_hook{r 1}
+    @x.before_save_hook{r false}
+    @x.before_save_hook{r 4}
+    @x.save.should == nil
+    @r.should == [4, false]
+    @r.clear
+    
+    @x.after_save_hook{r 1}
+    @x.before_save_hook{r false}
+    @x.before_save_hook{r 4}
+    @x.save.should == nil
+    @r.should == [4, false]
+    @r.clear
+    @x.save.should == nil
+    @r.should == [4, false]
+  end
+
+  it "should support before_destroy_hook and after_destroy_hook" do
+    @x.after_destroy_hook{r 1}
+    @x.before_destroy_hook{r 2}
+    @x.after_destroy_hook{r 3}
+    @x.before_destroy_hook{r 4}
+    @x.destroy.should_not == nil
+    @r.should == [4, 2, 1, 3]
+  end
+
+  it "should cancel the destroy if before_destroy_hook block returns false" do
+    @x.after_destroy_hook{r 1}
+    @x.before_destroy_hook{r false}
+    @x.before_destroy_hook{r 4}
+    @x.destroy.should == nil
+    @r.should == [4, false]
+  end
+
+  it "should support before_validation_hook and after_validation_hook" do
+    @o.after_validation_hook{r 1}
+    @o.before_validation_hook{r 2}
+    @o.after_validation_hook{r 3}
+    @o.before_validation_hook{r 4}
+    @o.valid?.should == true
+    @r.should == [4, 2, 1, 3]
+  end
+
+  it "should cancel the save if before_validation_hook block returns false" do
+    @o.after_validation_hook{r 1}
+    @o.before_validation_hook{r false}
+    @o.before_validation_hook{r 4}
+    @o.valid?.should == false
+    @r.should == [4, false]
+    @r.clear
+    @o.valid?.should == false
+    @r.should == [4, false]
+  end
+end

data/spec/extensions/lazy_attributes_spec.rb

@@ -4,7 +4,7 @@ describe "Sequel::Plugins::LazyAttributes" do
   before do
     class ::LazyAttributesModel < Sequel::Model(:la)
       plugin :lazy_attributes
-      columns :id, :name
+      set_columns([:id, :name])
       meta_def(:columns){[:id, :name]}
       lazy_attributes :name
       meta_def(:columns){[:id]}
@@ -13,10 +13,11 @@ describe "Sequel::Plugins::LazyAttributes" do
         execute(sql)
         select = @opts[:select]
         where = @opts[:where]
+        block = @mod_block || proc{|s| s}
         if !where
           if select.include?(:name)
-            yield(:id=>1, :name=>'1')
-            yield(:id=>2, :name=>'2')
+            yield(block[:id=>1, :name=>'1'])
+            yield(block[:id=>2, :name=>'2'])
           else
             yield(:id=>1)
             yield(:id=>2)
@@ -26,9 +27,9 @@ describe "Sequel::Plugins::LazyAttributes" do
           i = i.instance_variable_get(:@array) if i.is_a?(Sequel::SQL::SQLArray)
           Array(i).each do |x|
             if sql =~ /SELECT name FROM/
-              yield(:name=>x.to_s)
+              yield(block[:name=>x.to_s])
             else
-              yield(:id=>x, :name=>x.to_s)
+              yield(block[:id=>x, :name=>x.to_s])
             end
           end
         end
@@ -110,4 +111,43 @@ describe "Sequel::Plugins::LazyAttributes" do
       MODEL_DB.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
     end
   end
+
+  it "should add the accessors to a module included in the class, so they can be easily overridden" do
+    @c.class_eval do
+      def name
+        "#{super}-blah"
+      end
+    end
+    @c.with_identity_map do
+      ms = @c.all
+      ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
+      ms.map{|m| m.name}.should == %w'1-blah 2-blah'
+      ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
+      MODEL_DB.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
+    end
+  end
+
+  it "should work with the serialization plugin" do
+    @c.plugin :serialization, :yaml, :name
+    @ds.instance_variable_set(:@mod_block, proc{|s| s.merge(:name=>"--- #{s[:name].to_i*3}\n")})
+    @c.with_identity_map do
+      ms = @ds.all
+      ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
+      ms.map{|m| m.name}.should == [3,6]
+      ms.map{|m| m.values}.should == [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}]
+      ms.map{|m| m.deserialized_values}.should == [{:name=>3}, {:name=>6}]
+      ms.map{|m| m.name}.should == [3,6]
+      MODEL_DB.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
+    end
+    MODEL_DB.reset
+    @c.with_identity_map do
+      m = @ds.first
+      m.values.should == {:id=>1}
+      m.name.should == 3
+      m.values.should == {:id=>1, :name=>"--- 3\n"}
+      m.deserialized_values.should == {:name=>3}
+      m.name.should == 3
+      MODEL_DB.sqls.should == ["SELECT id FROM la LIMIT 1", "SELECT name FROM la WHERE (id = 1) LIMIT 1"]
+    end
+  end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -0,0 +1,272 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "NestedAttributes plugin" do
+  before do
+    mods = @mods = []
+    i = 0
+    gi = lambda{i}
+    ii = lambda{i+=1}
+    ds_mod = Module.new do
+      define_method(:insert) do |h|
+        x = ii.call
+        mods << [:i, first_source, h, x]
+        x
+      end
+      define_method(:insert_select) do |h|
+        x = ii.call
+        mods << [:is, first_source, h, x]
+        h.merge(:id=>x)
+      end
+      define_method(:update) do |h|
+        mods << [:u, first_source, h, literal(opts[:where])]
+        1
+      end
+      define_method(:delete) do
+        mods << [:d, first_source, literal(opts[:where])]
+        1
+      end
+    end
+    db = Sequel::Database.new({})
+    db.meta_def(:dataset) do |*a|
+      x = super(*a)
+      x.extend(ds_mod)
+      x
+    end
+    @c = Class.new(Sequel::Model(db))
+    @c.plugin :nested_attributes
+    @Artist = Class.new(@c).set_dataset(:artists)
+    @Album = Class.new(@c).set_dataset(:albums)
+    @Tag = Class.new(@c).set_dataset(:tags)
+    [@Artist, @Album, @Tag].each do |m|
+      m.dataset.extend(ds_mod)
+    end
+    @Artist.columns :id, :name
+    @Album.columns :id, :name, :artist_id
+    @Tag.columns :id, :name
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
+    @Artist.nested_attributes :albums, :destroy=>true, :remove=>true
+    @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
+  end
+  
+  it "should support creating new many_to_one objects" do
+    a = @Album.new({:name=>'Al', :artist_attributes=>{:name=>'Ar'}})
+    @mods.should == []
+    a.save
+    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+  end
+  
+  it "should support creating new one_to_many objects" do
+    a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:name=>'Al'}]})
+    @mods.should == []
+    a.save
+    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+  end
+  
+  it "should support creating new many_to_many objects" do
+    a = @Album.new({:name=>'Al', :tags_attributes=>[{:name=>'T'}]})
+    @mods.should == []
+    a.save
+    @mods.should == [[:is, :albums, {:name=>"Al"}, 1], [:is, :tags, {:name=>"T"}, 2], [:i, :at, {:album_id=>1, :tag_id=>2}, 3]]
+  end
+  
+  it "should support updating many_to_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    al.associations[:artist] = ar
+    al.set(:artist_attributes=>{:id=>'20', :name=>'Ar2'})
+    @mods.should == []
+    al.save
+    @mods.should == [[:u, :albums, {:name=>"Al"}, '(id = 10)'], [:u, :artists, {:name=>"Ar2"}, '(id = 20)']]
+  end
+  
+  it "should support updating one_to_many objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :name=>'Al2'}])
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)'], [:u, :albums, {:name=>"Al2"}, '(id = 10)']]
+  end
+  
+  it "should support updating many_to_many objects" do
+    a = @Album.load(:id=>10, :name=>'Al')
+    t = @Tag.load(:id=>20, :name=>'T')
+    a.associations[:tags] = [t]
+    a.set(:tags_attributes=>[{:id=>20, :name=>'T2'}])
+    @mods.should == []
+    a.save
+    @mods.should == [[:u, :albums, {:name=>"Al"}, '(id = 10)'], [:u, :tags, {:name=>"T2"}, '(id = 20)']]
+  end
+  
+  it "should support removing many_to_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    al.associations[:artist] = ar
+    al.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})
+    @mods.should == []
+    al.save
+    @mods.should == [[:u, :albums, {:artist_id=>nil, :name=>'Al'}, '(id = 10)']]
+  end
+  
+  it "should support removing one_to_many objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :_remove=>'t'}])
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :albums, {:name=>"Al", :artist_id=>nil}, '(id = 10)'], [:u, :artists, {:name=>"Ar"}, '(id = 20)']]
+  end
+  
+  it "should support removing many_to_many objects" do
+    a = @Album.load(:id=>10, :name=>'Al')
+    t = @Tag.load(:id=>20, :name=>'T')
+    a.associations[:tags] = [t]
+    a.set(:tags_attributes=>[{:id=>20, :_remove=>true}])
+    @mods.should == []
+    a.save
+    @mods.should == [[:d, :at, '((album_id = 10) AND (tag_id = 20))'], [:u, :albums, {:name=>"Al"}, '(id = 10)']]
+  end
+  
+  it "should support destroying many_to_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    al.associations[:artist] = ar
+    al.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})
+    @mods.should == []
+    al.save
+    @mods.should == [[:u, :albums, {:artist_id=>nil, :name=>'Al'}, '(id = 10)'], [:d, :artists, '(id = 20)']]
+  end
+  
+  it "should support destroying one_to_many objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :albums, {:name=>"Al", :artist_id=>nil}, '(id = 10)'], [:u, :artists, {:name=>"Ar"}, '(id = 20)'], [:d, :albums, '(id = 10)']]
+  end
+  
+  it "should support destroying many_to_many objects" do
+    a = @Album.load(:id=>10, :name=>'Al')
+    t = @Tag.load(:id=>20, :name=>'T')
+    a.associations[:tags] = [t]
+    a.set(:tags_attributes=>[{:id=>20, :_delete=>true}])
+    @mods.should == []
+    a.save
+    @mods.should == [[:d, :at, '((album_id = 10) AND (tag_id = 20))'], [:u, :albums, {:name=>"Al"}, '(id = 10)'], [:d, :tags, '(id = 20)']]
+  end
+  
+  it "should support both string and symbol keys in nested attribute hashes" do
+    a = @Album.load(:id=>10, :name=>'Al')
+    t = @Tag.load(:id=>20, :name=>'T')
+    a.associations[:tags] = [t]
+    a.set('tags_attributes'=>[{'id'=>20, '_delete'=>true}])
+    @mods.should == []
+    a.save
+    @mods.should == [[:d, :at, '((album_id = 10) AND (tag_id = 20))'], [:u, :albums, {:name=>"Al"}, '(id = 10)'], [:d, :tags, '(id = 20)']]
+  end
+  
+  it "should support using a hash instead of an array for to_many nested attributes" do
+    a = @Album.load(:id=>10, :name=>'Al')
+    t = @Tag.load(:id=>20, :name=>'T')
+    a.associations[:tags] = [t]
+    a.set('tags_attributes'=>{'1'=>{'id'=>20, '_delete'=>true}})
+    @mods.should == []
+    a.save
+    @mods.should == [[:d, :at, '((album_id = 10) AND (tag_id = 20))'], [:u, :albums, {:name=>"Al"}, '(id = 10)'], [:d, :tags, '(id = 20)']]
+  end
+  
+  it "should only allow destroying associated objects if :destroy option is used in the nested_attributes call" do
+    a = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    a.associations[:artist] = ar
+    @Album.nested_attributes :artist
+    proc{a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})}.should raise_error(Sequel::Error)
+    @Album.nested_attributes :artist, :destroy=>true
+    proc{a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})}.should_not raise_error(Sequel::Error)
+  end
+  
+  it "should only allow removing associated objects if :remove option is used in the nested_attributes call" do
+    a = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    a.associations[:artist] = ar
+    @Album.nested_attributes :artist
+    proc{a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})}.should raise_error(Sequel::Error)
+    @Album.nested_attributes :artist, :remove=>true
+    proc{a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})}.should_not raise_error(Sequel::Error)
+  end
+  
+  it "should raise an Error if a primary key is given in a nested attribute hash, but no matching associated object exists" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    proc{ar.set(:albums_attributes=>[{:id=>30, :_delete=>'t'}])}.should raise_error(Sequel::Error)
+    proc{ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])}.should_not raise_error(Sequel::Error)
+  end
+  
+  it "should not raise an Error if an unmatched primary key is given, if the :strict=>false option is used" do
+    @Artist.nested_attributes :albums, :strict=>false
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>30, :_delete=>'t'}])
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)']]
+  end
+  
+  it "should not save if nested attribute is not validate and should include nested attribute validation errors in the main object's validation errors" do
+    @Artist.class_eval do
+      def validate
+        super
+        errors.add(:name, 'cannot be Ar') if name == 'Ar'
+      end
+    end
+    a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
+    @mods.should == []
+    proc{a.save}.should raise_error(Sequel::ValidationFailed)
+    a.errors.full_messages.should == ['artist name cannot be Ar']
+    @mods.should == []
+  end
+  
+  it "should not accept nested attributes unless explicitly specified" do
+    @Artist.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
+    proc{@Artist.create({:name=>'Ar', :tags_attributes=>[{:name=>'T'}]})}.should raise_error(Sequel::Error)
+    @mods.should == []
+  end
+  
+  it "should save when save_changes or update is called if nested attribute associated objects changed but there are no changes to the main object" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    al.associations[:artist] = ar
+    al.update(:artist_attributes=>{:id=>'20', :name=>'Ar2'})
+    @mods.should == [[:u, :artists, {:name=>"Ar2"}, '(id = 20)']]
+  end
+  
+  it "should have a :limit option limiting the amount of entries" do
+    @Album.nested_attributes :tags, :limit=>2
+    arr = [{:name=>'T'}]
+    proc{@Album.new({:name=>'Al', :tags_attributes=>arr*3})}.should raise_error(Sequel::Error)
+    a = @Album.new({:name=>'Al', :tags_attributes=>arr*2})
+    @mods.should == []
+    a.save
+    @mods.should == [[:is, :albums, {:name=>"Al"}, 1], [:is, :tags, {:name=>"T"}, 2], [:i, :at, {:album_id=>1, :tag_id=>2}, 3], [:is, :tags, {:name=>"T"}, 4], [:i, :at, {:album_id=>1, :tag_id=>4}, 5]]
+  end
+  
+  it "should accept a block that each hash gets passed to determine if it should be processed" do
+    @Album.nested_attributes(:tags){|h| h[:name].empty?}
+    a = @Album.new({:name=>'Al', :tags_attributes=>[{:name=>'T'}, {:name=>''}, {:name=>'T2'}]})
+    @mods.should == []
+    a.save
+    @mods.should == [[:is, :albums, {:name=>"Al"}, 1], [:is, :tags, {:name=>"T"}, 2], [:i, :at, {:album_id=>1, :tag_id=>2}, 3], [:is, :tags, {:name=>"T2"}, 4], [:i, :at, {:album_id=>1, :tag_id=>4}, 5]]
+  end
+  
+  it "should deal properly with accessing the same nested attribute associated object with conflicting actions" do
+    
+  end
+end