viking-sequel 3.10.0

data/spec/extensions/validation_helpers_spec.rb

@@ -0,0 +1,438 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::ValidationHelpers" do
+  before do
+    @c = Class.new(Sequel::Model) do
+      def self.set_validations(&block)
+        define_method(:validate, &block)
+      end
+      columns :value
+    end
+    @c.plugin :validation_helpers
+    @m = @c.new
+  end
+
+  specify "should take an :allow_blank option" do
+    @c.set_validations{validates_format(/.+_.+/, :value, :allow_blank=>true)}
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.value = '1_1'
+    @m.should be_valid
+    o = Object.new
+    @m.value = o
+    @m.should_not be_valid
+    def o.blank?
+      true
+    end
+    @m.should be_valid
+  end
+
+  specify "should take an :allow_missing option" do
+    @c.set_validations{validates_format(/.+_.+/, :value, :allow_missing=>true)}
+    @m.values.clear
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+    @m.value = '1_1'
+    @m.should be_valid
+  end
+
+  specify "should take an :allow_nil option" do
+    @c.set_validations{validates_format(/.+_.+/, :value, :allow_nil=>true)}
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.value = '1_1'
+    @m.should be_valid
+    @m.value = nil
+    @m.should be_valid
+  end
+
+  specify "should take a :message option" do
+    @c.set_validations{validates_format(/.+_.+/, :value, :message=>"is so blah")}
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.errors.full_messages.should == ['value is so blah']
+    @m.value = '1_1'
+    @m.should be_valid
+  end
+  
+  specify "should allow a proc for the :message option" do
+    @c.set_validations{validates_format(/.+_.+/, :value, :message=>proc{|f| "doesn't match #{f.inspect}"})}
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.errors.should == {:value=>["doesn't match /.+_.+/"]}
+  end
+
+  specify "should take multiple attributes in the same call" do
+    @c.columns :value, :value2
+    @c.set_validations{validates_presence([:value, :value2])}
+    @m.should_not be_valid
+    @m.value = 1
+    @m.should_not be_valid
+    @m.value2 = 1
+    @m.should be_valid
+  end
+  
+  specify "should support modifying default options for all models" do
+    @c.set_validations{validates_presence(:value)}
+    @m.should_not be_valid
+    @m.errors.should == {:value=>['is not present']}
+    o = Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS[:presence].dup
+    Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS[:presence][:message] = lambda{"was not entered"}
+    @m.should_not be_valid
+    @m.errors.should == {:value=>["was not entered"]}
+    @m.value = 1
+    @m.should be_valid
+    
+    @m.values.clear
+    Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS[:presence][:allow_missing] = true
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+    @m.errors.should == {:value=>["was not entered"]}
+
+    
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      plugin :validation_helpers
+      set_columns([:value])
+      def validate
+        validates_presence(:value)
+      end
+    end
+    m = c.new(:value=>nil)
+    m.should_not be_valid
+    m.errors.should == {:value=>["was not entered"]}
+    Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS[:presence] = o
+  end
+  
+  specify "should support modifying default validation options for a particular model" do
+    @c.set_validations{validates_presence(:value)}
+    @m.should_not be_valid
+    @m.errors.should == {:value=>['is not present']}
+    @c.class_eval do
+      def default_validation_helpers_options(type)
+        {:allow_missing=>true, :message=>proc{'was not entered'}}
+      end
+    end
+    @m.value = nil
+    @m.should_not be_valid
+    @m.errors.should == {:value=>["was not entered"]}
+    @m.value = 1
+    @m.should be_valid
+    
+    @m.values.clear
+    @m.should be_valid
+    
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      plugin :validation_helpers
+      attr_accessor :value
+      def validate
+        validates_presence(:value)
+      end
+    end
+    m = c.new
+    m.should_not be_valid
+    m.errors.should == {:value=>['is not present']}
+  end
+
+  specify "should support validates_exact_length" do
+    @c.set_validations{validates_exact_length(3, :value)}
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '12'
+    @m.should_not be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+  
+  specify "should support validate_format" do
+    @c.set_validations{validates_format(/.+_.+/, :value)}
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.value = 'abc_def'
+    @m.should be_valid
+  end
+  
+  specify "should support validates_includes with an array" do
+    @c.set_validations{validates_includes([1,2], :value)}
+    @m.should_not be_valid
+    @m.value = 1
+    @m.should be_valid
+    @m.value = 1.5
+    @m.should_not be_valid
+    @m.value = 2
+    @m.should be_valid    
+    @m.value = 3
+    @m.should_not be_valid 
+  end
+  
+  specify "should support validates_includes with a range" do
+    @c.set_validations{validates_includes(1..4, :value)}
+    @m.should_not be_valid
+    @m.value = 1
+    @m.should be_valid
+    @m.value = 1.5
+    @m.should be_valid
+    @m.value = 0
+    @m.should_not be_valid
+    @m.value = 5
+    @m.should_not be_valid    
+  end
+  
+  specify "should supports validates_integer" do
+    @c.set_validations{validates_integer(:value)}
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should_not be_valid
+  end
+  
+  specify "should support validates_length_range" do
+    @c.set_validations{validates_length_range(2..5, :value)}
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  specify "should support validates_max_length" do
+    @c.set_validations{validates_max_length(5, :value)}
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  specify "should support validates_min_length" do
+    @c.set_validations{validates_min_length(5, :value)}
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+
+  specify "should support validates_not_string" do
+    @c.set_validations{validates_not_string(:value)}
+    @m.value = 123
+    @m.should be_valid
+    @m.value = '123'
+    @m.should_not be_valid
+    @m.errors.full_messages.should == ['value is a string']
+    @m.meta_def(:db_schema){{:value=>{:type=>:integer}}}
+    @m.should_not be_valid
+    @m.errors.full_messages.should == ['value is not a valid integer']
+  end
+
+  specify "should support validates_numeric" do
+    @c.set_validations{validates_numeric(:value)}
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should be_valid
+    @m.value = '+1'
+    @m.should be_valid
+    @m.value = '-1'
+    @m.should be_valid
+    @m.value = '+1.123'
+    @m.should be_valid
+    @m.value = '-0.123'
+    @m.should be_valid
+    @m.value = '-0.123E10'
+    @m.should be_valid
+    @m.value = '32.123e10'
+    @m.should be_valid
+    @m.value = '+32.123E10'
+    @m.should be_valid
+    @m.should be_valid
+    @m.value = '.0123'
+  end
+  
+  specify "should support validates_type" do
+    @c.set_validations{validates_type(Integer, :value)}
+    @m.value = 123
+    @m.should be_valid
+    @m.value = '123'
+    @m.should_not be_valid
+    @m.errors.full_messages.should == ['value is not a Integer']
+    
+    @c.set_validations{validates_type(:String, :value)}
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = 123
+    @m.should_not be_valid
+    @m.errors.full_messages.should == ['value is not a String']
+    
+    @c.set_validations{validates_type('Integer', :value)}
+    @m.value = 123
+    @m.should be_valid
+    @m.value = 123.05
+    @m.should_not be_valid
+    @m.errors.full_messages.should == ['value is not a Integer']
+  end
+
+  specify "should support validates_presence" do
+    @c.set_validations{validates_presence(:value)}
+    @m.should_not be_valid
+    @m.value = ''
+    @m.should_not be_valid
+    @m.value = 1234
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+    @m.value = true
+    @m.should be_valid
+    @m.value = false
+    @m.should be_valid
+    @m.value = Time.now
+    @m.should be_valid
+  end
+  
+  it "should support validates_unique with a single attribute" 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
+      end
+    })
+    
+    @user = @c.new(:username => "0records", :password => "anothertest")
+    @user.should be_valid
+    @user = @c.load(:id=>3, :username => "0records", :password => "anothertest")
+    @user.should be_valid
+
+    @user = @c.new(:username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username is already taken']
+    @user = @c.load(:id=>4, :username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username is already taken']
+
+    ds1 = @c.dataset.filter([[:username, '0records']])
+    ds2 = ds1.exclude(:id=>1)
+    @c.dataset.should_receive(:filter).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")
+    @user.should be_valid
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (id != 1)) LIMIT 1"
+    @user = @c.new(:username => "0records", :password => "anothertest")
+    @user.should be_valid
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE (username = '0records') LIMIT 1"
+  end
+  
+  it "should support validates_unique with multiple attributes" 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
+      end
+    })
+    
+    @user = @c.new(:username => "0records", :password => "anothertest")
+    @user.should be_valid
+    @user = @c.load(:id=>3, :username => "0records", :password => "anothertest")
+    @user.should be_valid
+
+    @user = @c.new(:username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username and password is already taken']
+    @user = @c.load(:id=>4, :username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username and password is already taken']
+
+    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)
+    ds1.should_receive(:exclude).with(:id=>1).once.and_return(ds2)
+
+    @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
+    @user.should be_valid
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest') AND (id != 1)) LIMIT 1"
+    @user = @c.new(:username => "0records", :password => "anothertest")
+    @user.should be_valid
+    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
+  end
+
+  it "should support validates_unique with a block" 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
+    })
+    
+    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 ((username = '0records') AND active) LIMIT 1",
+                    "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active 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
+    })
+    
+    MODEL_DB.reset
+    @c.new(:username => "0records", :password => "anothertest").should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"]
+    MODEL_DB.reset
+    m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
+    m.should be_valid
+    MODEL_DB.sqls.should == []
+
+    m.username = '1'
+    m.should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '1') AND (password = 'anothertest') AND (id != 3)) LIMIT 1"]
+
+    m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
+    MODEL_DB.reset
+    m.password = '1'
+    m.should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = '1') AND (id != 3)) LIMIT 1"]
+    MODEL_DB.reset
+    m.username = '2'
+    m.should be_valid
+    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '2') AND (password = '1') AND (id != 3)) LIMIT 1"]
+  end
+end 

data/spec/integration/associations_test.rb

@@ -0,0 +1,281 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+shared_examples_for "regular and composite key associations" do  
+  specify "should return no objects if none are associated" do
+    @album.artist.should == nil
+    @artist.albums.should == []
+    @album.tags.should == []
+    @tag.albums.should == []
+  end
+
+  specify "should have add and set methods work any associated objects" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
+    @album.reload
+    @artist.reload
+    @tag.reload
+    
+    @album.artist.should == @artist
+    @artist.albums.should == [@album]
+    @album.tags.should == [@tag]
+    @tag.albums.should == [@album]
+  end
+  
+  specify "should have remove methods work" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
+    @album.update(:artist => nil)
+    @album.remove_tag(@tag)
+    
+    @album.reload
+    @artist.reload
+    @tag.reload
+    
+    @album.artist.should == nil
+    @artist.albums.should == []
+    @album.tags.should == []
+    @tag.albums.should == []
+  end
+  
+  specify "should have remove_all methods work" do
+    @artist.add_album(@album)
+    @album.add_tag(@tag)
+    
+    @artist.remove_all_albums
+    @album.remove_all_tags
+    
+    @album.reload
+    @artist.reload
+    @tag.reload
+    
+    @album.artist.should == nil
+    @artist.albums.should == []
+    @album.tags.should == []
+    @tag.albums.should == []
+  end
+  
+  specify "should eager load via eager correctly" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
+    a = Artist.eager(:albums=>:tags).all
+    a.should == [@artist]
+    a.first.albums.should == [@album]
+    a.first.albums.first.tags.should == [@tag]
+    
+    a = Tag.eager(:albums=>:artist).all
+    a.should == [@tag]
+    a.first.albums.should == [@album]
+    a.first.albums.first.artist.should == @artist
+  end
+  
+  specify "should eager load via eager_graph correctly" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
+    a = Artist.eager_graph(:albums=>:tags).all
+    a.should == [@artist]
+    a.first.albums.should == [@album]
+    a.first.albums.first.tags.should == [@tag]
+    
+    a = Tag.eager_graph(:albums=>:artist).all
+    a.should == [@tag]
+    a.first.albums.should == [@album]
+    a.first.albums.first.artist.should == @artist
+  end
+  
+  specify "should work with a many_through_many association" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+
+    @album.reload
+    @artist.reload
+    @tag.reload
+    
+    @album.tags.should == [@tag]
+    
+    a = Artist.eager(:tags).all
+    a.should == [@artist]
+    a.first.tags.should == [@tag]
+    
+    a = Artist.eager_graph(:tags).all
+    a.should == [@artist]
+    a.first.tags.should == [@tag]
+    
+    a = Album.eager(:artist=>:tags).all
+    a.should == [@album]
+    a.first.artist.should == @artist
+    a.first.artist.tags.should == [@tag]
+    
+    a = Album.eager_graph(:artist=>:tags).all
+    a.should == [@album]
+    a.first.artist.should == @artist
+    a.first.artist.tags.should == [@tag]
+  end
+end
+
+describe "Sequel::Model Simple Associations" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:artists) do
+      primary_key :id
+      String :name
+    end
+    @db.create_table!(:albums) do
+      primary_key :id
+      String :name
+      foreign_key :artist_id, :artists
+    end
+    @db.create_table!(:tags) do
+      primary_key :id
+      String :name
+    end
+    @db.create_table!(:albums_tags) do
+      foreign_key :album_id, :albums
+      foreign_key :tag_id, :tags
+    end
+    class ::Artist < Sequel::Model(@db)
+      one_to_many :albums
+      plugin :many_through_many
+      Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]]
+    end
+    class ::Album < Sequel::Model(@db)
+      many_to_one :artist
+      many_to_many :tags
+    end
+    class ::Tag < Sequel::Model(@db)
+      many_to_many :albums
+    end
+    @album = Album.create(:name=>'Al')
+    @artist = Artist.create(:name=>'Ar')
+    @tag = Tag.create(:name=>'T')
+  end
+  after do
+    @db.drop_table(:albums_tags, :tags, :albums, :artists)
+    [:Tag, :Album, :Artist].each{|x| Object.send(:remove_const, x)}
+  end
+  
+  it_should_behave_like "regular and composite key associations"
+
+  specify "should have add method accept hashes and create new records" do
+    @artist.remove_all_albums
+    Album.delete
+    @album = @artist.add_album(:name=>'Al2')
+    Album.first[:name].should == 'Al2'
+    @artist.albums_dataset.first[:name].should == 'Al2'
+    
+    @album.remove_all_tags
+    Tag.delete
+    @album.add_tag(:name=>'T2')
+    Tag.first[:name].should == 'T2'
+    @album.tags_dataset.first[:name].should == 'T2'
+  end
+  
+  specify "should have remove method accept primary key and remove related album" do
+    @artist.add_album(@album)
+    @artist.reload.remove_album(@album.id)
+    @artist.reload.albums.should == []
+    
+    @album.add_tag(@tag)
+    @album.reload.remove_tag(@tag.id)
+    @tag.reload.albums.should == []
+  end
+  
+  specify "should have remove method raise an error for one_to_many records if the object isn't already associated" do
+    proc{@artist.remove_album(@album.id)}.should raise_error(Sequel::Error)
+    proc{@artist.remove_album(@album)}.should raise_error(Sequel::Error)
+  end
+end
+
+describe "Sequel::Model Composite Key Associations" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:artists) do
+      Integer :id1
+      Integer :id2
+      String :name
+      primary_key [:id1, :id2]
+    end
+    @db.create_table!(:albums) do
+      Integer :id1
+      Integer :id2
+      String :name
+      Integer :artist_id1
+      Integer :artist_id2
+      foreign_key [:artist_id1, :artist_id2], :artists
+      primary_key [:id1, :id2]
+    end
+    @db.create_table!(:tags) do
+      Integer :id1
+      Integer :id2
+      String :name
+      primary_key [:id1, :id2]
+    end
+    @db.create_table!(:albums_tags) do
+      Integer :album_id1
+      Integer :album_id2
+      Integer :tag_id1
+      Integer :tag_id2
+      foreign_key [:album_id1, :album_id2], :albums
+      foreign_key [:tag_id1, :tag_id2], :tags
+    end
+    class ::Artist < Sequel::Model(@db)
+      set_primary_key :id1, :id2
+      unrestrict_primary_key
+      one_to_many :albums, :key=>[:artist_id1, :artist_id2]
+      plugin :many_through_many
+      Artist.many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]]
+    end
+    class ::Album < Sequel::Model(@db)
+      set_primary_key :id1, :id2
+      unrestrict_primary_key
+      many_to_one :artist, :key=>[:artist_id1, :artist_id2]
+      many_to_many :tags, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
+    end
+    class ::Tag < Sequel::Model(@db)
+      set_primary_key :id1, :id2
+      unrestrict_primary_key
+      many_to_many :albums, :right_key=>[:album_id1, :album_id2], :left_key=>[:tag_id1, :tag_id2]
+    end
+    @album = Album.create(:name=>'Al', :id1=>1, :id2=>2)
+    @artist = Artist.create(:name=>'Ar', :id1=>3, :id2=>4)
+    @tag = Tag.create(:name=>'T', :id1=>5, :id2=>6)
+  end
+  after do
+    @db.drop_table(:albums_tags, :tags, :albums, :artists)
+    [:Tag, :Album, :Artist].each{|x| Object.send(:remove_const, x)}
+  end
+
+  it_should_behave_like "regular and composite key associations"
+
+  specify "should have add method accept hashes and create new records" do
+    @artist.remove_all_albums
+    Album.delete
+    @artist.add_album(:id1=>1, :id2=>2, :name=>'Al2')
+    Album.first[:name].should == 'Al2'
+    @artist.albums_dataset.first[:name].should == 'Al2'
+    
+    @album.remove_all_tags
+    Tag.delete
+    @album.add_tag(:id1=>1, :id2=>2, :name=>'T2')
+    Tag.first[:name].should == 'T2'
+    @album.tags_dataset.first[:name].should == 'T2'
+  end
+  
+  specify "should have remove method accept primary key and remove related album" do
+    @artist.add_album(@album)
+    @artist.reload.remove_album([@album.id1, @album.id2])
+    @artist.reload.albums.should == []
+    
+    @album.add_tag(@tag)
+    @album.reload.remove_tag([@tag.id1, @tag.id2])
+    @tag.reload.albums.should == []
+  end
+  
+  specify "should have remove method raise an error for one_to_many records if the object isn't already associated" do
+    proc{@artist.remove_album([@album.id1, @album.id2])}.should raise_error(Sequel::Error)
+    proc{@artist.remove_album(@album)}.should raise_error(Sequel::Error)
+  end
+end