sequel 3.5.0 → 3.6.0

data/spec/extensions/caching_spec.rb

@@ -12,6 +12,14 @@ describe Sequel::Model, "caching" do
     cache = @cache_class.new
     @cache = cache
     
+    @memcached_class = Class.new(Hash) do
+      attr_accessor :ttl
+      def set(k, v, ttl); self[k] = v; @ttl = ttl; end
+      def get(k); if self[k] then return self[k]; else raise ArgumentError; end end
+    end
+    cache2 = @memcached_class.new
+    @memcached = cache2
+    
     @c = Class.new(Sequel::Model(:items))
     @c.class_eval do
       plugin :caching, cache
@@ -19,9 +27,26 @@ describe Sequel::Model, "caching" do
       
       columns :name, :id
     end
-    
+  
+    @c3 = Class.new(Sequel::Model(:items))
+    @c3.class_eval do
+      plugin :caching, cache2
+      def self.name; 'Item' end
+      
+      columns :name, :id
+    end
+
+    @c4 = Class.new(Sequel::Model(:items))
+    @c4.class_eval do
+      plugin :caching, cache2, :ignore_exceptions => true
+      def self.name; 'Item' end
+      
+      columns :name, :id
+    end
+   
+
     $cache_dataset_row = {:name => 'sharon', :id => 1}
-    @dataset = @c.dataset
+    @dataset = @c.dataset = @c3.dataset = @c4.dataset
     $sqls = []
     @dataset.extend(Module.new {
       def fetch_rows(sql)
@@ -38,9 +63,10 @@ describe Sequel::Model, "caching" do
         $sqls << delete_sql
       end
     })
+    
     @c2 = Class.new(@c) do
       def self.name; 'SubItem' end
-    end
+    end    
   end
   
   it "should set the model's cache store" do
@@ -205,4 +231,18 @@ describe Sequel::Model, "caching" do
       "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
       "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
   end
+  
+  it "should support ignore_exception option" do
+    c = Class.new(Sequel::Model(:items))
+    c.plugin :caching, @cache, :ignore_exceptions => true
+    Class.new(c).cache_ignore_exceptions.should == true
+  end
+  
+  it "should raise an exception if cache_store is memcached and ignore_exception is not enabled" do
+    proc{@c3[1]}.should raise_error
+  end
+  
+  it "should rescue an exception if cache_store is memcached and ignore_exception is enabled" do
+    @c4[1].values.should == $cache_dataset_row
+  end
 end

data/spec/extensions/force_encoding_spec.rb

@@ -71,5 +71,47 @@ describe "force_encoding plugin" do
     o.x.should == ''
     o.x.encoding.should == Encoding.find('UTF-16LE')
   end
+  
+  specify "should work when saving new model instances" do
+    o = @c.new
+    @c.dataset = ds = MODEL_DB[:a]
+    def ds.first
+      s = 'blah'
+      s.force_encoding('US-ASCII')
+      {:id=>1, :x=>s}
+    end
+    o.save
+    o.x.should == 'blah'
+    o.x.encoding.should == @e1
+  end
+  
+  specify "should work when refreshing model instances" do
+    o = @c.load(:id=>1, :x=>'as')
+    @c.dataset = ds = MODEL_DB[:a]
+    def ds.first
+      s = 'blah'
+      s.force_encoding('US-ASCII')
+      {:id=>1, :x=>s}
+    end
+    o.refresh
+    o.x.should == 'blah'
+    o.x.encoding.should == @e1
+  end
+  
+  specify "should work when used with the identity_map plugin if the identity_map plugin is setup first" do
+    @c = Class.new(Sequel::Model) do
+    end
+    @c.columns :id, :x
+    @c.plugin :identity_map
+    @c.plugin :force_encoding, 'UTF-8'
+    @c.with_identity_map do
+      o = @c.load(:id=>1)
+      s = 'blah'
+      s.force_encoding('US-ASCII')
+      @c.load(:id=>1, :x=>s)
+      o.x.should == 'blah'
+      o.x.encoding.should == @e1
+    end
+  end
 end 
-end
+end

data/spec/extensions/nested_attributes_spec.rb

@@ -7,6 +7,7 @@ describe "NestedAttributes plugin" do
     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]
@@ -71,6 +72,12 @@ describe "NestedAttributes plugin" do
     @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')
@@ -294,7 +301,53 @@ describe "NestedAttributes plugin" do
     @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
-    
+  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

data/spec/extensions/validation_helpers_spec.rb

@@ -55,6 +55,13 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @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
@@ -65,6 +72,70 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @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)}

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