viking-sequel 3.10.0

data/spec/extensions/migration_spec.rb

@@ -0,0 +1,332 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Migration classes" do
+  before do
+    Sequel::Migration.descendants.clear
+  end
+
+  specify "should be registred in Migration.descendants" do
+    @class = Class.new(Sequel::Migration)
+    
+    Sequel::Migration.descendants.should == [@class]
+  end
+  
+  specify "should be registered in the right order" do
+    @c1 = Class.new(Sequel::Migration)
+    @c2 = Class.new(Sequel::Migration)
+    @c3 = Class.new(Sequel::Migration)
+    
+    Sequel::Migration.descendants.should == [@c1, @c2, @c3]
+  end
+end
+
+context "Migration#apply" do
+  before do
+    @c = Class.new do
+      define_method(:one) {|x| [1111, x]}
+      define_method(:two) {|x| [2222, x]}
+    end
+    @db = @c.new
+    
+    @migration = Class.new(Sequel::Migration) do
+      define_method(:up) {one(3333)}
+      define_method(:down) {two(4444)}
+    end
+  end
+  
+  specify "should raise for an invalid direction" do
+    proc {@migration.apply(@db, :hahaha)}.should raise_error(ArgumentError)
+  end
+  
+  specify "should apply the up direction correctly" do
+    @migration.apply(@db, :up).should == [1111, 3333]
+  end
+
+  specify "should apply the down direction correctly" do
+    @migration.apply(@db, :down).should == [2222, 4444]
+  end
+end
+
+MIGRATION_001 = %[
+  class CreateSessions < Sequel::Migration
+    def up
+      create(1111)
+    end
+    
+    def down
+      drop(1111)
+    end
+  end
+]
+
+MIGRATION_002 = %[
+  class CreateNodes < Sequel::Migration
+    def up
+      create(2222)
+    end
+    
+    def down
+      drop(2222)
+    end
+  end
+]
+
+MIGRATION_003 = %[
+  class CreateUsers < Sequel::Migration
+    def up
+      create(3333)
+    end
+    
+    def down
+      drop(3333)
+    end
+  end
+]
+
+MIGRATION_005 = %[
+  class CreateAttributes < Sequel::Migration
+    def up
+      create(5555)
+    end
+    
+    def down
+      drop(5555)
+    end
+  end
+]
+
+ALT_MIGRATION_001 = %[
+  class CreateAltBasic < Sequel::Migration
+    def up
+      create(11111)
+    end
+    
+    def down
+      drop(11111)
+    end
+  end
+]
+
+ALT_MIGRATION_003 = %[
+  class CreateAltAdvanced < Sequel::Migration
+    def up
+      create(33333)
+    end
+    
+    def down
+      drop(33333)
+    end
+  end
+]
+
+context "Sequel::Migrator" do
+  before do
+    dbc = Class.new(MockDatabase) do
+      attr_reader :creates, :drops, :tables_created, :columns_created, :versions
+      def initialize(*args)
+        super
+        @creates = []
+        @drops = []
+        @tables_created = []
+        @columns_created = []
+        @versions = {}
+      end
+  
+      def create(x); @creates << x; end
+      def drop(x); @drops << x; end
+
+      def create_table(name, opts={}, &block)
+        super
+        @columns_created << / \(?(\w+) integer\)?\z/.match(sqls.last)[1].to_sym
+        @tables_created << name
+      end
+      
+      def dataset(opts={})
+        ds = super
+        ds.extend(Module.new do
+          def columns; db.columns_created end
+          def insert(h); db.versions.merge!(h); super(h) end
+          def update(h); db.versions.merge!(h); super(h) end
+          def fetch_rows(sql); db.execute(sql); yield(db.versions) unless db.versions.empty? end
+        end)
+        ds
+      end
+
+      def table_exists?(name)
+        @tables_created.include?(name)
+      end
+    end
+    @db = dbc.new
+    
+    @dirname = "migrate_#{$$}"
+    Dir.mkdir(@dirname)
+    File.open("#{@dirname}/001_create_sessions.rb", 'w') {|f| f << MIGRATION_001}
+    File.open("#{@dirname}/002_create_nodes.rb", 'w') {|f| f << MIGRATION_002}
+    File.open("#{@dirname}/003_create_users.rb", 'w') {|f| f << MIGRATION_003}
+    File.open("#{@dirname}/005_5_create_attributes.rb", 'w') {|f| f << MIGRATION_005}
+    
+    @alt_dirname = "migrate_alt_#{$$}"
+    Dir.mkdir(@alt_dirname)
+    File.open("#{@alt_dirname}/001_create_alt_basic.rb", 'w') {|f| f << ALT_MIGRATION_001}
+    File.open("#{@alt_dirname}/003_create_alt_advanced.rb", 'w') {|f| f << ALT_MIGRATION_003}
+  end
+  
+  after do
+    Object.send(:remove_const, "CreateSessions") if Object.const_defined?("CreateSessions")
+    Object.send(:remove_const, "CreateNodes") if Object.const_defined?("CreateNodes")
+    Object.send(:remove_const, "CreateUsers") if Object.const_defined?("CreateUsers")
+    Object.send(:remove_const, "CreateAttributes") if Object.const_defined?("CreateAttributes")
+    Object.send(:remove_const, "CreateAltBasic") if Object.const_defined?("CreateAltBasic")
+    Object.send(:remove_const, "CreateAltAdvanced") if Object.const_defined?("CreateAltAdvanced")
+
+    File.delete("#{@dirname}/001_create_sessions.rb")
+    File.delete("#{@dirname}/002_create_nodes.rb")
+    File.delete("#{@dirname}/003_create_users.rb")
+    File.delete("#{@dirname}/005_5_create_attributes.rb")
+    Dir.rmdir(@dirname)
+    File.delete("#{@alt_dirname}/001_create_alt_basic.rb")
+    File.delete("#{@alt_dirname}/003_create_alt_advanced.rb")
+    Dir.rmdir(@alt_dirname)
+  end
+  
+  specify "#migration_files should return the list of files for a specified version range" do
+    Sequel::Migrator.migration_files(@dirname, 1..1).map{|f| File.basename(f)}.should == ['001_create_sessions.rb']
+    Sequel::Migrator.migration_files(@dirname, 1..3).map{|f| File.basename(f)}.should == ['001_create_sessions.rb', '002_create_nodes.rb', '003_create_users.rb']
+    Sequel::Migrator.migration_files(@dirname, 3..6).map{|f| File.basename(f)}.should == ['003_create_users.rb', '005_5_create_attributes.rb']
+    Sequel::Migrator.migration_files(@dirname, 7..8).map{|f| File.basename(f)}.should == []
+    Sequel::Migrator.migration_files(@alt_dirname, 1..1).map{|f| File.basename(f)}.should == ['001_create_alt_basic.rb']
+    Sequel::Migrator.migration_files(@alt_dirname, 1..3).map{|f| File.basename(f)}.should == ['001_create_alt_basic.rb','003_create_alt_advanced.rb']
+  end
+  
+  specify "#latest_migration_version should return the latest version available" do
+    Sequel::Migrator.latest_migration_version(@dirname).should == 5
+    Sequel::Migrator.latest_migration_version(@alt_dirname).should == 3
+  end
+  
+  specify "#migration_classes should load the migration classes for the specified range for the up direction" do
+    Sequel::Migrator.migration_classes(@dirname, 3, 0, :up).should == [CreateSessions, CreateNodes, CreateUsers]
+    Sequel::Migrator.migration_classes(@alt_dirname, 3, 0, :up).should == [CreateAltBasic, CreateAltAdvanced]
+  end
+  
+  specify "#migration_classes should load the migration classes for the specified range for the down direction" do
+    Sequel::Migrator.migration_classes(@dirname, 0, 5, :down).should == [CreateAttributes, CreateUsers, CreateNodes, CreateSessions]
+    Sequel::Migrator.migration_classes(@alt_dirname, 0, 3, :down).should == [CreateAltAdvanced, CreateAltBasic]
+  end
+  
+  specify "#migration_classes should start from current + 1 for the up direction" do
+    Sequel::Migrator.migration_classes(@dirname, 3, 1, :up).should == [CreateNodes, CreateUsers]
+    Sequel::Migrator.migration_classes(@alt_dirname, 3, 2, :up).should == [CreateAltAdvanced]
+  end
+  
+  specify "#migration_classes should end on current + 1 for the down direction" do
+    Sequel::Migrator.migration_classes(@dirname, 2, 5, :down).should == [CreateAttributes, CreateUsers]
+    Sequel::Migrator.migration_classes(@alt_dirname, 2, 4, :down).should == [CreateAltAdvanced]
+  end
+  
+  specify "#schema_info_dataset should automatically create the schema_info table" do
+    @db.table_exists?(:schema_info).should be_false
+    Sequel::Migrator.schema_info_dataset(@db)
+    @db.table_exists?(:schema_info).should be_true
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)"]
+  end
+
+  specify "should automatically create new APP_version column in schema_info" do
+    @db.table_exists?(:schema_info).should be_false
+    Sequel::Migrator.schema_info_dataset(@db, :column => :alt_version)
+    @db.table_exists?(:schema_info).should be_true
+    @db.sqls.should == ["CREATE TABLE schema_info (alt_version integer)"]
+  end
+  
+  specify "should automatically create new APP_version column in schema_info" do
+    @db.table_exists?(:alt_table).should be_false
+    Sequel::Migrator.schema_info_dataset(@db, :table => :alt_table)
+    @db.table_exists?(:alt_table).should be_true
+    Sequel::Migrator.schema_info_dataset(@db, :table => :alt_table, :column=>:alt_version)
+    @db.sqls.should == ["CREATE TABLE alt_table (version integer)",
+      "ALTER TABLE alt_table ADD COLUMN alt_version integer"]
+  end
+  
+  specify "should return a dataset for the correct table" do
+    Sequel::Migrator.schema_info_dataset(@db).first_source_alias.should == :schema_info
+    Sequel::Migrator.schema_info_dataset(@db, :table=>:blah).first_source_alias.should == :blah
+  end
+  
+  specify "should assume a migration version of 0 if no migration information exists in the database" do
+    Sequel::Migrator.get_current_migration_version(@db).should == 0
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)", "SELECT * FROM schema_info LIMIT 1"]
+  end
+  specify "should use the migration version stored in the database" do
+    Sequel::Migrator.schema_info_dataset(@db).insert(:version => 4321)
+    Sequel::Migrator.get_current_migration_version(@db).should == 4321
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)", "INSERT INTO schema_info (version) VALUES (4321)", "SELECT * FROM schema_info LIMIT 1"]
+  end
+  
+  specify "should set the migration version stored in the database" do
+    Sequel::Migrator.set_current_migration_version(@db, 6666)
+    Sequel::Migrator.get_current_migration_version(@db).should == 6666
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (6666)",
+      "SELECT * FROM schema_info LIMIT 1"]
+  end
+  
+  specify "should apply migrations correctly in the up direction" do
+    Sequel::Migrator.apply(@db, @dirname, 3, 2)
+    @db.creates.should == [3333]
+    
+    Sequel::Migrator.get_current_migration_version(@db).should == 3
+
+    Sequel::Migrator.apply(@db, @dirname, 5)
+    @db.creates.should == [3333, 5555]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 5
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (3)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "SELECT * FROM schema_info LIMIT 1",
+      "SELECT * FROM schema_info LIMIT 1",
+      "UPDATE schema_info SET version = 5",
+      "SELECT * FROM schema_info LIMIT 1"]
+  end
+  
+  specify "should apply migrations correctly in the down direction" do
+    Sequel::Migrator.apply(@db, @dirname, 1, 5)
+    @db.drops.should == [5555, 3333, 2222]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 1
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (1)",
+      "SELECT * FROM schema_info LIMIT 1"]
+  end
+
+  specify "should apply migrations up to the latest version if no target is given" do
+    Sequel::Migrator.apply(@db, @dirname)
+    @db.creates.should == [1111, 2222, 3333, 5555]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 5
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (5)",
+      "SELECT * FROM schema_info LIMIT 1"]
+  end
+
+  specify "should apply migrations down to 0 version correctly" do
+    Sequel::Migrator.apply(@db, @dirname, 0, 5)
+    @db.drops.should == [5555, 3333, 2222, 1111]
+
+    Sequel::Migrator.get_current_migration_version(@db).should == 0
+    @db.sqls.should == ["CREATE TABLE schema_info (version integer)",
+      "SELECT * FROM schema_info LIMIT 1",
+      "INSERT INTO schema_info (version) VALUES (0)",
+      "SELECT * FROM schema_info LIMIT 1"]
+  end
+  
+  specify "should return the target version" do
+    Sequel::Migrator.apply(@db, @dirname, 3, 2).should == 3
+    Sequel::Migrator.apply(@db, @dirname, 0).should == 0
+    Sequel::Migrator.apply(@db, @dirname).should == 5
+  end
+end

data/spec/extensions/named_timezones_spec.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+if (begin
+  require 'tzinfo'
+  true
+  rescue LoadError
+  end) 
+
+Sequel.extension :named_timezones
+Sequel.datetime_class = Time
+
+describe "Sequel named_timezones extension" do
+  before do
+    @tz_in = TZInfo::Timezone.get('America/Los_Angeles')
+    @tz_out = TZInfo::Timezone.get('America/New_York')
+    @db = MockDatabase.new
+    @dt = DateTime.civil(2009,6,1,10,20,30,0)
+    Sequel.application_timezone = 'America/Los_Angeles'
+    Sequel.database_timezone = 'America/New_York'
+    Sequel.datetime_class = DateTime
+  end
+  after do
+    Sequel.default_timezone = nil
+    Sequel.datetime_class = Time
+  end
+  
+  it "should convert string arguments to *_timezone= to TZInfo::Timezone instances" do
+    Sequel.application_timezone.should == @tz_in
+    Sequel.database_timezone.should == @tz_out
+  end
+    
+  it "should accept TZInfo::Timezone instances in *_timezone=" do
+    Sequel.application_timezone = @tz_in
+    Sequel.database_timezone = @tz_out
+    Sequel.application_timezone.should == @tz_in
+    Sequel.database_timezone.should == @tz_out
+  end
+    
+  it "should convert datetimes going into the database to named database_timezone" do
+    ds = @db[:a]
+    def ds.supports_timestamp_timezones?; true; end
+    def ds.supports_timestamp_usecs?; false; end
+    ds.insert([@dt, DateTime.civil(2009,6,1,3,20,30,Rational(-7, 24)), DateTime.civil(2009,6,1,6,20,30,Rational(-1, 6))])
+    @db.sqls.should == ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
+  end
+  
+  it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
+    dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30-0400')
+    dt.should == @dt
+    dt.offset.should == Rational(-7, 24)
+    
+    dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30+0000')
+    dt.should == @dt
+    dt.offset.should == Rational(-7, 24)
+  end
+    
+  it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
+    dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30')
+    dt.should == @dt
+    dt.offset.should == Rational(-7, 24)
+    
+    dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30')
+    dt.should == @dt + Rational(1, 6)
+    dt.offset.should == Rational(-7, 24)
+  end
+  
+  it "should work with the thread_local_timezones extension" do
+    [Thread.new{Sequel.thread_application_timezone = 'America/New_York'; sleep 0.03; Sequel.application_timezone.should == @tz_out},
+     Thread.new{sleep 0.01; Sequel.thread_application_timezone = 'America/Los_Angeles'; sleep 0.01; Sequel.application_timezone.should == @tz_in}].each{|x| x.join}
+  end
+end
+end

data/spec/extensions/nested_attributes_spec.rb

@@ -0,0 +1,396 @@
+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
+      def empty?; false; end
+      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
+    @Artist.one_to_one :first_album, :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, :first_album, :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_one objects" do
+    a = @Artist.new(:name=>'Ar')
+    a.id = 1
+    a.first_album_attributes = {:name=>'Al'}
+    @mods.should == []
+    a.save
+    @mods.should == [[:is, :artists, {:name=>"Ar", :id=>1}, 1], [:is, :albums, {:name=>"Al"}, 2], [:u, :albums, {:artist_id=>nil}, "((artist_id = 1) AND (id != 2))"], [:u, :albums, {:name=>"Al", :artist_id=>1}, "(id = 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 add new objects to the cached association array as soon as the *_attributes= method is called" do
+    a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:name=>'Al', :tags_attributes=>[{:name=>'T'}]}]})
+    a.albums.should == [@Album.new(:name=>'Al')]
+    a.albums.first.tags.should == [@Tag.new(:name=>'T')]
+  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_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:first_album] = al
+    ar.set(:first_album_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 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_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:first_album] = al
+    ar.set(:first_album_attributes=>{:id=>10, :_remove=>'t'})
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :albums, {:artist_id=>nil}, "(artist_id = 20)"], [:u, :artists, {:name=>"Ar"}, "(id = 20)"]]
+    
+  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_one objects" do
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:first_album] = al
+    ar.set(:first_album_attributes=>{:id=>10, :_delete=>'t'})
+    @mods.should == []
+    ar.save
+    @mods.should == [[:u, :albums, {:artist_id=>nil}, "(artist_id = 20)"], [:u, :artists, {:name=>"Ar"}, "(id = 20)"], [:d, :albums, "(id = 10)"]]
+  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 valid 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 == []
+    # Should preserve attributes
+    a.artist.name.should == 'Ar'
+  end
+  
+  it "should not attempt to validate nested attributes if the :validate=>false association option is used" do
+    @Album.many_to_one :artist, :class=>@Artist, :validate=>false
+    @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
+    @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 == []
+    a.save
+    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+  end
+  
+  it "should not attempt to validate nested attributes if the :validate=>false option is passed to save" 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 == []
+    a.save(:validate=>false)
+    @mods.should == [[:is, :artists, {:name=>"Ar"}, 1], [:is, :albums, {:name=>"Al", :artist_id=>1}, 2]]
+  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 return objects created/modified in the internal methods" do
+    @Album.nested_attributes :tags, :remove=>true, :strict=>false
+    objs = []
+    @Album.class_eval do
+      define_method(:nested_attributes_create){|*a| objs << [super(*a), :create]}
+      define_method(:nested_attributes_remove){|*a| objs << [super(*a), :remove]}
+      define_method(:nested_attributes_update){|*a| objs << [super(*a), :update]}
+    end
+    a = @Album.new(:name=>'Al')
+    a.associations[:tags] = [@Tag.load(:id=>6, :name=>'A'), @Tag.load(:id=>7, :name=>'A2')] 
+    a.tags_attributes = [{:id=>6, :name=>'T'}, {:id=>7, :name=>'T2', :_remove=>true}, {:name=>'T3'}, {:id=>8, :name=>'T4'}, {:id=>9, :name=>'T5', :_remove=>true}]
+    objs.should == [[@Tag.load(:id=>6, :name=>'T'), :update], [@Tag.load(:id=>7, :name=>'A2'), :remove], [@Tag.new(:name=>'T3'), :create], [nil, :update], [nil, :remove]]
+  end
+
+  it "should raise an error if updating modifies the associated objects keys" do
+    @Artist.columns :id, :name, :artist_id
+    @Album.columns :id, :name, :artist_id
+    @Tag.columns :id, :name, :tag_id
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :primary_key=>:artist_id
+    @Album.many_to_one :artist, :class=>@Artist, :primary_key=>:artist_id
+    @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at, :right_primary_key=>:tag_id
+    @Artist.nested_attributes :albums, :destroy=>true, :remove=>true
+    @Album.nested_attributes :artist, :tags, :destroy=>true, :remove=>true
+
+    al = @Album.load(:id=>10, :name=>'Al', :artist_id=>25)
+    ar = @Artist.load(:id=>20, :name=>'Ar', :artist_id=>25)
+    t = @Tag.load(:id=>30, :name=>'T', :tag_id=>15)
+    al.associations[:artist] = ar
+    al.associations[:tags] = [t]
+    ar.associations[:albums] = [al]
+    proc{ar.set(:albums_attributes=>[{:id=>10, :name=>'Al2', :artist_id=>'3'}])}.should raise_error(Sequel::Error)
+    proc{al.set(:artist_attributes=>{:id=>20, :name=>'Ar2', :artist_id=>'3'})}.should raise_error(Sequel::Error)
+    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :tag_id=>'3'}])}.should raise_error(Sequel::Error)
+  end
+
+  it "should accept a :fields option and only allow modification of those fields" do
+    @Tag.columns :id, :name, :number
+    @Album.nested_attributes :tags, :destroy=>true, :remove=>true, :fields=>[:name]
+
+    al = @Album.load(:id=>10, :name=>'Al')
+    t = @Tag.load(:id=>30, :name=>'T', :number=>10)
+    al.associations[:tags] = [t]
+    al.set(:tags_attributes=>[{:id=>30, :name=>'T2'}, {:name=>'T3'}])
+    @mods.should == []
+    al.save
+    @mods.should == [[:u, :albums, {:name=>'Al'}, '(id = 10)'], [:u, :tags, {:name=>'T2'}, '(id = 30)'], [:is, :tags, {:name=>"T3"}, 1], [:i, :at, {:album_id=>10, :tag_id=>1}, 2]]
+    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
+    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
+  end
+end