sequel 4.36.0 → 5.61.0

data/spec/extensions/hook_class_methods_spec.rb

@@ -1,429 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-model_class = proc do |klass, &block|
-  c = Class.new(klass)
-  c.plugin :hook_class_methods
-  c.class_eval(&block) if block
-  c
-end
-
-describe Sequel::Model, "hook_class_methods plugin" do
-  before do
-    DB.reset
-  end
-  
-  it "should be definable using a block" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      before_save{adds << 'hi'}
-    end
-    
-    c.new.before_save
-    adds.must_equal ['hi']
-  end
-  
-  it "should be definable using a method name" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-    end
-    
-    c.new.before_save
-    adds.must_equal ['bye']
-  end
-
-  it "should be additive" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      after_save{adds << 'hyiyie'}
-      after_save{adds << 'byiyie'}
-    end
-
-    c.new.after_save
-    adds.must_equal ['hyiyie', 'byiyie']
-  end
-  
-  it "before hooks should run in reverse order" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      before_save{adds << 'hyiyie'}
-      before_save{adds << 'byiyie'}
-    end
-    
-    c.new.before_save
-    adds.must_equal ['byiyie', 'hyiyie']
-  end
-
-  it "should not be additive if the method or tag already exists" do
-    adds = []
-    c = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-      before_save :bye
-    end
-    
-    c.new.before_save
-    adds.must_equal ['bye']
-
-    adds = []
-    d = model_class.call Sequel::Model do
-      before_save(:bye){adds << 'hyiyie'}
-      before_save(:bye){adds << 'byiyie'}
-    end
-    
-    d.new.before_save
-    adds.must_equal ['byiyie']
-
-    adds = []
-    e = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save :bye
-      before_save(:bye){adds << 'byiyie'}
-    end
-    
-    e.new.before_save
-    adds.must_equal ['byiyie']
-
-    adds = []
-    e = model_class.call Sequel::Model do
-      define_method(:bye){adds << 'bye'}
-      before_save(:bye){adds << 'byiyie'}
-      before_save :bye
-    end
-    
-    e.new.before_save
-    adds.must_equal ['bye']
-  end
-  
-  it "should be inheritable" do
-    adds = []
-    a = model_class.call Sequel::Model do
-      after_save{adds << '123'}
-    end
-    
-    b = Class.new(a)
-    b.class_eval do
-      after_save{adds << '456'}
-      after_save{adds << '789'}
-    end
-    
-    b.new.after_save
-    adds.must_equal ['123', '456', '789']
-  end
-  
-  it "should be overridable in descendant classes" do
-    adds = []
-    a = model_class.call Sequel::Model do
-      before_save{adds << '123'}
-    end
-    
-    b = Class.new(a)
-    b.class_eval do
-      define_method(:before_save){adds << '456'}
-    end
-    
-    a.new.before_save
-    adds.must_equal ['123']
-    adds = []
-    b.new.before_save
-    adds.must_equal ['456']
-  end
-  
-  it "should stop processing if a before hook returns false" do
-    flag = true
-    adds = []
-    
-    a = model_class.call Sequel::Model do
-      before_save{adds << 'cruel'; flag}
-      before_save{adds << 'blah'; flag}
-    end
-    
-    a.new.before_save
-    adds.must_equal ['blah', 'cruel']
-
-    # chain should not break on nil
-    adds = []
-    flag = nil
-    a.new.before_save
-    adds.must_equal ['blah', 'cruel']
-    
-    adds = []
-    flag = false
-    a.new.before_save
-    adds.must_equal ['blah']
-    
-    b = Class.new(a)
-    b.class_eval do
-      before_save{adds << 'mau'}
-    end
-    
-    adds = []
-    b.new.before_save
-    adds.must_equal ['mau', 'blah']
-  end
-end
-
-describe "Model#before_create && Model#after_create" do
-  before do
-    DB.reset
-
-    @c = model_class.call Sequel::Model(:items)  do
-      columns :x
-      no_primary_key
-      
-      after_create {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around new record creation" do
-    @c.before_create {DB << "BLAH before"}
-    @c.create(:x => 2)
-    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
-  end
-
-  it ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
-    @c.before_create{false}
-    proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it ".create should cancel the save and raise an error if before_create calls cancel_action and raise_on_save_failure is true" do
-    @c.before_create{cancel_action}
-    proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
-    @c.before_create{false}
-    @c.raise_on_save_failure = false
-    @c.create(:x => 2).must_equal nil
-    DB.sqls.must_equal []
-  end
-
-  it ".create should cancel the save and return nil if before_create calls cancel_action and raise_on_save_failure is false" do
-    @c.before_create{cancel_action}
-    @c.raise_on_save_failure = false
-    @c.create(:x => 2).must_equal nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_update && Model#after_update" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      after_update {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record update" do
-    @c.before_update {DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save
-    DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
-  end
-
-  it "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
-    @c.before_update{false}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it "#save should cancel the save and return nil if before_update returns false and raise_on_save_failure is false" do
-    @c.before_update{false}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_equal nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_save && Model#after_save" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      columns :x
-      after_save {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record update" do
-    @c.before_save {DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save
-    DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
-  end
-  
-  it "should be called around record creation" do
-    @c.before_save {DB << "BLAH before"}
-    @c.no_primary_key
-    @c.create(:x => 2)
-    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
-  end
-
-  it "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
-    @c.before_save{false}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it "#save should cancel the save and return nil if before_save returns false and raise_on_save_failure is false" do
-    @c.before_save{false}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_equal nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_destroy && Model#after_destroy" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      after_destroy {DB << "BLAH after"}
-    end
-  end
-  
-  it "should be called around record destruction" do
-    @c.before_destroy {DB << "BLAH before"}
-    m = @c.load(:id => 2233)
-    m.destroy
-    DB.sqls.must_equal ['BLAH before', "DELETE FROM items WHERE id = 2233", 'BLAH after']
-  end
-
-  it "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
-    @c.before_destroy{false}
-    proc{@c.load(:id => 2233).destroy}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it "#destroy should cancel the destroy and return nil if before_destroy returns false and raise_on_save_failure is false" do
-    @c.before_destroy{false}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).destroy.must_equal nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model#before_validation && Model#after_validation" do
-  before do
-    DB.reset
-
-    @c = model_class.call(Sequel::Model(:items)) do
-      plugin :validation_class_methods
-      after_validation{DB << "BLAH after"}
-
-      def self.validate(o)
-        o.errors.add(:id, 'not valid') unless o[:id] == 2233
-      end
-      columns :id
-    end
-  end
-  
-  it "should be called around validation" do
-    @c.before_validation{DB << "BLAH before"}
-    m = @c.load(:id => 2233)
-    m.must_be :valid?
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-
-    DB.sqls.clear
-    m = @c.load(:id => 22)
-    m.wont_be :valid?
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-  end
-
-  it "should be called when calling save" do
-    @c.before_validation{DB << "BLAH before"}
-    m = @c.load(:id => 2233, :x=>123)
-    m.save.must_equal m
-    DB.sqls.must_equal ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
-
-    DB.sqls.clear
-    m = @c.load(:id => 22)
-    m.raise_on_save_failure = false
-    m.save.must_equal nil
-    DB.sqls.must_equal ['BLAH before', 'BLAH after']
-  end
-
-  it "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
-    @c.before_validation{false}
-    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
-    DB.sqls.must_equal []
-  end
-
-  it "#save should cancel the save and return nil if before_validation returns false and raise_on_save_failure is false" do
-    @c.before_validation{false}
-    @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.must_equal nil
-    DB.sqls.must_equal []
-  end
-end
-
-describe "Model.has_hooks?" do
-  before do
-    @c = model_class.call(Sequel::Model(:items))
-  end
-  
-  it "should return false if no hooks are defined" do
-    @c.has_hooks?(:before_save).must_equal false
-  end
-  
-  it "should return true if hooks are defined" do
-    @c.before_save {'blah'}
-    @c.has_hooks?(:before_save).must_equal true
-  end
-  
-  it "should return true if hooks are inherited" do
-    @d = Class.new(@c)
-    @d.has_hooks?(:before_save).must_equal false
-  end
-end
-
-describe "Model#add_hook_type" do
-  before do
-    class ::Foo < Sequel::Model(:items)
-      plugin :hook_class_methods
-      add_hook_type :before_bar, :after_bar
-
-      def bar
-        return :b if before_bar == false
-        return :a if after_bar == false
-        true
-      end
-    end
-    @f = Class.new(Foo)
-  end
-  after do
-    Object.send(:remove_const, :Foo)
-  end
-
-  it "should have before_bar and after_bar class methods" do
-    @f.must_respond_to(:before_bar)
-    @f.must_respond_to(:before_bar)
-  end
-
-  it "should have before_bar and after_bar instance methods" do
-    @f.new.must_respond_to(:before_bar)
-    @f.new.must_respond_to(:before_bar)
-  end
-
-  it "it should return true for bar when before_bar and after_bar hooks are returing true" do
-    a = 1
-    @f.before_bar { a += 1}
-    @f.new.bar.must_equal true
-    a.must_equal 2
-    @f.after_bar { a *= 2}
-    @f.new.bar.must_equal true
-    a.must_equal 6
-  end
-
-  it "it should return nil for bar when before_bar and after_bar hooks are returing false" do
-    @f.new.bar.must_equal true
-    @f.after_bar { false }
-    @f.new.bar.must_equal :a
-    @f.before_bar { false }
-    @f.new.bar.must_equal :b
-  end
-end

data/spec/extensions/identifier_columns_spec.rb

@@ -1,17 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "identifier_columns plugin" do
-  before do
-    @db = Sequel.mock(:numrows=>1, :fetch=>{:id=>1, :a__b=>2}, :autoid=>1)
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @ds = @c.dataset
-    @c.columns :id, :a__b
-    @c.plugin :identifier_columns
-    @db.sqls
-  end
-
-  it "should not use qualification when updating or inserting values" do
-    @c.create(:a__b=>2).save
-    @db.sqls.must_equal ["INSERT INTO test (a__b) VALUES (2)", "SELECT * FROM test WHERE (id = 1) LIMIT 1", "UPDATE test SET a__b = 2 WHERE (id = 1)"]
-  end
-end

data/spec/extensions/inflector_spec.rb

@@ -1,183 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-Sequel.extension :inflector
-
-describe String do
-  it "#camelize and #camelcase should transform the word to CamelCase" do
-    "egg_and_hams".camelize.must_equal "EggAndHams"
-    "egg_and_hams".camelize(false).must_equal "eggAndHams"
-    "post".camelize.must_equal "Post"
-    "post".camelcase.must_equal "Post"
-  end
-
-  it "#constantize should eval the string to get a constant" do
-    "String".constantize.must_equal String
-    "String::Inflections".constantize.must_equal String::Inflections
-    proc{"BKSDDF".constantize}.must_raise NameError
-    proc{"++A++".constantize}.must_raise NameError
-  end
-  
-  it "#dasherize should transform underscores to dashes" do
-    "egg_and_hams".dasherize.must_equal "egg-and-hams"
-    "post".dasherize.must_equal "post"
-  end
-  
-  it "#demodulize should remove any preceding modules" do
-    "String::Inflections::Blah".demodulize.must_equal "Blah"
-    "String::Inflections".demodulize.must_equal "Inflections"
-    "String".demodulize.must_equal "String"
-  end
-  
-  it "#humanize should remove _i, transform underscore to spaces, and capitalize" do
-    "egg_and_hams".humanize.must_equal "Egg and hams"
-    "post".humanize.must_equal "Post"
-    "post_id".humanize.must_equal "Post"
-  end
-  
-  it "#titleize and #titlecase should underscore, humanize, and capitalize all words" do
-    "egg-and: hams".titleize.must_equal "Egg And: Hams"
-    "post".titleize.must_equal "Post"
-    "post".titlecase.must_equal "Post"
-  end
-  
-  it "#underscore should add underscores between CamelCased words, change :: to / and - to _, and downcase" do
-    "EggAndHams".underscore.must_equal "egg_and_hams"
-    "EGGAndHams".underscore.must_equal "egg_and_hams"
-    "Egg::And::Hams".underscore.must_equal "egg/and/hams"
-    "post".underscore.must_equal "post"
-    "post-id".underscore.must_equal "post_id"
-  end
-
-  it "#pluralize should transform words from singular to plural" do
-    "post".pluralize.must_equal "posts"
-    "octopus".pluralize.must_equal"octopuses"
-    "the blue mailman".pluralize.must_equal "the blue mailmen"
-    "CamelOctopus".pluralize.must_equal "CamelOctopuses"
-  end
-  
-  it "#singularize should transform words from plural to singular" do
-    "posts".singularize.must_equal "post"
-    "octopuses".singularize.must_equal "octopus"
-    "the blue mailmen".singularize.must_equal "the blue mailman"
-    "CamelOctopuses".singularize.must_equal "CamelOctopus"
-  end
-  
-  it "#tableize should transform class names to table names" do
-    "RawScaledScorer".tableize.must_equal "raw_scaled_scorers"
-    "egg_and_ham".tableize.must_equal "egg_and_hams"
-    "fancyCategory".tableize.must_equal "fancy_categories"
-  end
-  
-  it "#classify should tranform table names to class names" do
-    "egg_and_hams".classify.must_equal "EggAndHam"
-    "post".classify.must_equal "Post"
-  end
-  
-  it "#foreign_key should create a foreign key name from a class name" do
-    "Message".foreign_key.must_equal "message_id"
-    "Message".foreign_key(false).must_equal "messageid"
-    "Admin::Post".foreign_key.must_equal "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.must_equal []
-    String.inflections.plural('blah', 'blahs')
-    String.inflections.clear
-    String.inflections.plurals.must_equal []
-    String.inflections.singulars.must_equal []
-    String.inflections.uncountables.must_equal []
-  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.must_equal 'roxxx'
-    'rottt'.singularize.must_equal 'rott'
-    'yy'.pluralize.must_equal 'yyy'
-    'yyy'.singularize.must_equal 'yy'
-    'zz'.pluralize.must_equal 'zz'
-    'zz'.singularize.must_equal 'zz'
-  end
-
-  it "should be yielded and returned by String.inflections" do
-    String.inflections{|i| i.must_equal String::Inflections}.must_equal 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.must_equal v.to_s
-      v.to_s.singularize.must_equal k.to_s
-    end
-    [:equipment, :information, :rice, :money, :species, :series, :fish, :sheep, :news].each do |a|
-      a.to_s.pluralize.must_equal a.to_s.singularize
-    end
-  end
-end

data/spec/extensions/input_transformer_spec.rb

@@ -1,54 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::InputTransformer" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.columns :name, :b
-    @c.plugin(:input_transformer, :reverser){|v| v.is_a?(String) ? v.reverse : v}
-    @o = @c.new
-  end
-
-  it "should apply transformation to input" do
-    @o.name = ' name '
-    @o.name.must_equal ' eman '
-    @o.name = [1, 2, 3]
-    @o.name.must_equal [1, 2, 3]
-  end
-
-  it "should not apply any transformers by default" do
-    c = Class.new(Sequel::Model)
-    c.columns :name, :b
-    c.plugin :input_transformer
-    c.new(:name => ' name ').name.must_equal ' name '
-  end
-
-  it "should allow skipping of columns using .skip_input_transformer" do
-    @c.skip_input_transformer :reverser, :name
-    v = ' name '
-    @o.name = v
-    @o.name.must_be_same_as(v)
-  end
-
-  it "should work correctly in subclasses" do
-    o = Class.new(@c).new
-    o.name = ' name '
-    o.name.must_equal ' eman '
-  end
-
-  it "should raise an error if adding input filter without name" do
-    proc{@c.add_input_transformer(nil){}}.must_raise(Sequel::Error)
-    proc{@c.plugin(:input_transformer){}}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if adding input filter without block" do
-    proc{@c.add_input_transformer(:foo)}.must_raise(Sequel::Error)
-    proc{@c.plugin(:input_transformer, :foo)}.must_raise(Sequel::Error)
-  end
-
-  it "should apply multiple input transformers in reverse order of their call" do
-    @c.add_input_transformer(:add_bar){|v| v << 'bar'}
-    @c.add_input_transformer(:add_foo){|v| v << 'foo'}
-    @o.name = ' name '.dup
-    @o.name.must_equal 'raboof eman '
-  end
-end