viking-sequel 3.10.0

data/spec/extensions/identity_map_spec.rb

@@ -0,0 +1,202 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::IdentityMap" do
+  before do
+    class ::IdentityMapModel < Sequel::Model
+      plugin :identity_map
+      attr_accessor :foo
+      columns :id
+      ds = dataset
+      def ds.fetch_rows(sql)
+        c = @opts[:where].args.first
+        c = c.column if c.is_a?(Sequel::SQL::QualifiedIdentifier)
+        h = {c=>@opts[:where].args.last}
+        execute(sql)
+        yield h
+      end
+    end
+    class ::IdentityMapAlbum < ::IdentityMapModel
+      columns :id, :artist_id
+    end
+    class ::IdentityMapArtist < ::IdentityMapModel
+    end
+    @c = ::IdentityMapModel
+    @c1 = ::IdentityMapAlbum
+    @c2 = ::IdentityMapArtist
+    MODEL_DB.reset
+  end
+  after do
+    Object.send(:remove_const, :IdentityMapAlbum)
+    Object.send(:remove_const, :IdentityMapArtist)
+    Object.send(:remove_const, :IdentityMapModel)
+  end
+
+  it "#identity_map should return a hash if an identity map is currently being used" do
+    @c.with_identity_map{@c.identity_map.should == {}}
+  end
+
+  it "#identity_map should return nil if an identity map is not currently being used" do
+    @c.identity_map.should == nil
+  end
+
+  it "#identity_map_key should be the same for the same class and pk" do
+    @c.identity_map_key(1).should == @c.identity_map_key(1)
+  end
+
+  it "#identity_map_key should be different for a different class" do
+    @c1.identity_map_key(1).should_not == @c2.identity_map_key(1)
+  end
+
+  it "#identity_map_key should be different for different anonymous classes" do
+    Class.new(@c).identity_map_key(1).should_not == Class.new(@c).identity_map_key(1)
+  end
+
+  it "#identity_map_key should be different for a different pk" do
+    @c.identity_map_key(1).should_not == @c.identity_map_key(2)
+  end
+
+  it "#identity_map_key should be different if the pk is nil" do
+    @c.identity_map_key(nil).should_not == @c.identity_map_key(nil)
+  end
+
+  it "#load should return an object if there is no current identity map" do
+    o = @c.load(:id=>1)
+    o.should be_a_kind_of(@c)
+    o.values.should == {:id=>1}
+  end
+
+  it "#load should return an object if there is a current identity map" do
+    @c.with_identity_map do
+      o = @c.load(:id=>1)
+      o.should be_a_kind_of(@c)
+      o.values.should == {:id=>1}
+    end
+  end
+
+  it "#load should should store the object in the current identity map if it isn't already there" do
+    @c.with_identity_map do
+      @c.identity_map[@c.identity_map_key(1)].should == nil
+      o = @c.load(:id=>1)
+      @c.identity_map[@c.identity_map_key(1)].should == o
+    end
+  end
+
+  it "#load should update the record in the current identity map if new fields if it is already there" do
+    @c.with_identity_map do
+      o = @c.load(:id=>1, :a=>2)
+      o.values.should == {:id=>1, :a=>2}
+      o = @c.load(:id=>1, :b=>3)
+      o.values.should == {:id=>1, :a=>2, :b=>3}
+    end
+  end
+
+  it "#load should not update existing fields in the record if the record is in the current identity map" do
+    @c.with_identity_map do
+      o = @c.load(:id=>1, :a=>2)
+      o.values.should == {:id=>1, :a=>2}
+      o = @c.load(:id=>1, :a=>4)
+      o.values.should == {:id=>1, :a=>2}
+    end
+  end
+
+  it "should use the identity map as a lookup cache in Model.[] to save on database queries" do
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c[1]
+      MODEL_DB.sqls.length.should == 1
+      o.foo = 1
+      @c[1].foo.should == o.foo
+      MODEL_DB.sqls.length.should == 1
+      @c[2].foo.should_not == o.foo
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
+
+  it "should remove instances from the identity map if they are deleted or destroyed" do
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c[1]
+      MODEL_DB.sqls.length.should == 1
+      o.foo = 1
+      @c[1].should == o
+      MODEL_DB.sqls.length.should == 1
+      o.destroy
+      MODEL_DB.sqls.length.should == 2
+      @c[1].foo.should_not == o.foo
+      MODEL_DB.sqls.length.should == 3
+
+      MODEL_DB.reset
+      o = @c[2]
+      MODEL_DB.sqls.length.should == 1
+      o.foo = 1
+      @c[2].should == o
+      MODEL_DB.sqls.length.should == 1
+      o.delete
+      MODEL_DB.sqls.length.should == 2
+      @c[2].foo.should_not == o.foo
+      MODEL_DB.sqls.length.should == 3
+    end
+  end
+
+  it "should use the identity map as a lookup cache when retrieving many_to_one associated records" do
+    @c1.many_to_one :artist, :class=>@c2
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c1.load(:id=>1, :artist_id=>2)
+      a = o.artist
+      a.should be_a_kind_of(@c2)
+      MODEL_DB.sqls.length.should == 1
+      o = @c1.load(:id=>2, :artist_id=>2)
+      o.artist.should == a
+      MODEL_DB.sqls.length.should == 1
+      o = @c1.load(:id=>3, :artist_id=>3)
+      o.artist.should_not == a
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
+
+  it "should not use the identity map as a lookup cache for a one_to_one association" do
+    c = @c2
+    @c2.one_to_one :artist, :class=>@c1, :key=>:artist_id
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c2.load(:id=>2)
+      a = o.artist
+      a.should be_a_kind_of(@c1)
+      MODEL_DB.sqls.length.should == 1
+      o.reload
+      MODEL_DB.sqls.length.should == 2
+      o.artist.should == a
+      MODEL_DB.sqls.length.should == 3
+    end
+  end
+  
+  it "should not use the identity map as a lookup cache if the assocation has a nil :key option" do
+    c = @c2
+    @c1.many_to_one :artist, :class=>@c2, :key=>nil, :dataset=>proc{c.filter(:artist_id=>artist_id)}
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c1.load(:id=>1, :artist_id=>2)
+      a = o.artist
+      a.should be_a_kind_of(@c2)
+      MODEL_DB.sqls.length.should == 1
+      o = @c1.load(:id=>2, :artist_id=>2)
+      o.artist.should == a
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
+
+  it "should not use the identity map as a lookup cache if the assocation's :primary_key option doesn't match the primary key of the associated class" do
+    @c1.many_to_one :artist, :class=>@c2, :primary_key=>:artist_id
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c1.load(:id=>1, :artist_id=>2)
+      a = o.artist
+      a.should be_a_kind_of(@c2)
+      MODEL_DB.sqls.length.should == 1
+      o = @c1.load(:id=>2, :artist_id=>2)
+      o.artist.should == a
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
+end

data/spec/extensions/inflector_spec.rb

@@ -0,0 +1,181 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe String do
+  it "#camelize and #camelcase should transform the word to CamelCase" do
+    "egg_and_hams".camelize.should == "EggAndHams"
+    "egg_and_hams".camelize(false).should == "eggAndHams"
+    "post".camelize.should == "Post"
+    "post".camelcase.should == "Post"
+  end
+
+  it "#constantize should eval the string to get a constant" do
+    "String".constantize.should == String
+    "String::Inflections".constantize.should == String::Inflections
+    proc{"BKSDDF".constantize}.should raise_error
+    proc{"++A++".constantize}.should raise_error
+  end
+  
+  it "#dasherize should transform underscores to dashes" do
+    "egg_and_hams".dasherize.should == "egg-and-hams"
+    "post".dasherize.should == "post"
+  end
+  
+  it "#demodulize should remove any preceding modules" do
+    "String::Inflections::Blah".demodulize.should == "Blah"
+    "String::Inflections".demodulize.should == "Inflections"
+    "String".demodulize.should == "String"
+  end
+  
+  it "#humanize should remove _i, transform underscore to spaces, and capitalize" do
+    "egg_and_hams".humanize.should == "Egg and hams"
+    "post".humanize.should == "Post"
+    "post_id".humanize.should == "Post"
+  end
+  
+  it "#titleize and #titlecase should underscore, humanize, and capitalize all words" do
+    "egg-and: hams".titleize.should == "Egg And: Hams"
+    "post".titleize.should == "Post"
+    "post".titlecase.should == "Post"
+  end
+  
+  it "#underscore should add underscores between CamelCased words, change :: to / and - to _, and downcase" do
+    "EggAndHams".underscore.should == "egg_and_hams"
+    "EGGAndHams".underscore.should == "egg_and_hams"
+    "Egg::And::Hams".underscore.should == "egg/and/hams"
+    "post".underscore.should == "post"
+    "post-id".underscore.should == "post_id"
+  end
+
+  it "#pluralize should transform words from singular to plural" do
+    "post".pluralize.should == "posts"
+    "octopus".pluralize.should =="octopuses"
+    "the blue mailman".pluralize.should == "the blue mailmen"
+    "CamelOctopus".pluralize.should == "CamelOctopuses"
+  end
+  
+  it "#singularize should transform words from plural to singular" do
+    "posts".singularize.should == "post"
+    "octopuses".singularize.should == "octopus"
+    "the blue mailmen".singularize.should == "the blue mailman"
+    "CamelOctopuses".singularize.should == "CamelOctopus"
+  end
+  
+  it "#tableize should transform class names to table names" do
+    "RawScaledScorer".tableize.should == "raw_scaled_scorers"
+    "egg_and_ham".tableize.should == "egg_and_hams"
+    "fancyCategory".tableize.should == "fancy_categories"
+  end
+  
+  it "#classify should tranform table names to class names" do
+    "egg_and_hams".classify.should == "EggAndHam"
+    "post".classify.should == "Post"
+  end
+  
+  it "#foreign_key should create a foreign key name from a class name" do
+    "Message".foreign_key.should == "message_id"
+    "Message".foreign_key(false).should == "messageid"
+    "Admin::Post".foreign_key.should == "post_id"
+  end
+end
+
+describe String::Inflections do
+  before do
+    @plurals, @singulars, @uncountables = String.inflections.plurals.dup, String.inflections.singulars.dup, String.inflections.uncountables.dup
+  end
+  after do
+    String.inflections.plurals.replace(@plurals)
+    String.inflections.singulars.replace(@singulars)
+    String.inflections.uncountables.replace(@uncountables)
+  end
+
+  it "should be possible to clear the list of singulars, plurals, and uncountables" do
+    String.inflections.clear(:plurals)
+    String.inflections.plurals.should == []
+    String.inflections.plural('blah', 'blahs')
+    String.inflections.clear
+    String.inflections.plurals.should == []
+    String.inflections.singulars.should == []
+    String.inflections.uncountables.should == []
+  end
+
+  it "should be able to specify new inflection rules" do
+    String.inflections do |i|
+      i.plural(/xx$/i, 'xxx')
+      i.singular(/ttt$/i, 'tt')
+      i.irregular('yy', 'yyy')
+      i.uncountable(%w'zz')
+    end
+    'roxx'.pluralize.should == 'roxxx'
+    'rottt'.singularize.should == 'rott'
+    'yy'.pluralize.should == 'yyy'
+    'yyy'.singularize.should == 'yy'
+    'zz'.pluralize.should == 'zz'
+    'zz'.singularize.should == 'zz'
+  end
+
+  it "should be yielded and returned by 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,
+      :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_filters_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "instance_filters plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:people)) do
+    end
+    @sql = sql = ''
+    @v = v = [1]
+    @c.dataset.quote_identifiers = false
+    @c.dataset.meta_def(:update) do |opts|
+      sql.replace(update_sql(opts))
+      return v.first
+    end
+    @c.dataset.meta_def(:delete) do
+      sql.replace(delete_sql)
+      return v.first
+    end
+    @c.columns :id, :name, :num
+    @c.plugin :instance_filters
+    @p = @c.load(:id=>1, :name=>'John', :num=>1)
+  end
+
+  specify "should raise an error when updating a stale record" do
+    @p.update(:name=>'Bob')
+    @sql.should == "UPDATE people SET name = 'Bob' WHERE (id = 1)"
+    @p.instance_filter(:name=>'Jim')
+    @v.replace([0])
+    proc{@p.update(:name=>'Joe')}.should raise_error(Sequel::Plugins::InstanceFilters::Error)
+    @sql.should == "UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"
+  end 
+
+  specify "should raise an error when destroying a stale record" do
+    @p.destroy
+    @sql.should == "DELETE FROM people WHERE (id = 1)"
+    @p.instance_filter(:name=>'Jim')
+    @v.replace([0])
+    proc{@p.destroy}.should raise_error(Sequel::Plugins::InstanceFilters::Error)
+    @sql.should == "DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"
+  end 
+  
+  specify "should apply all instance filters" do
+    @p.instance_filter(:name=>'Jim')
+    @p.instance_filter{num > 2}
+    @p.update(:name=>'Bob')
+    @sql.should == "UPDATE people SET name = 'Bob' WHERE ((id = 1) AND (name = 'Jim') AND (num > 2))"
+  end 
+
+  specify "should drop instance filters after updating" do
+    @p.instance_filter(:name=>'Joe')
+    @p.update(:name=>'Joe')
+    @sql.should == "UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Joe'))"
+    @p.update(:name=>'Bob')
+    @sql.should == "UPDATE people SET name = 'Bob' WHERE (id = 1)"
+  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