sequel 5.28.0 → 5.33.0

data/spec/extensions/defaults_setter_spec.rb

@@ -1,150 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::DefaultsSetter" do
-  before do
-    @db = db = Sequel.mock
-    def db.supports_schema_parsing?() true end
-    def db.schema(*) [] end
-    @c = c = Class.new(Sequel::Model(db[:foo]))
-    @c.instance_variable_set(:@db_schema, {:a=>{}})
-    @c.plugin :defaults_setter
-    @c.columns :a
-    @pr = proc{|x| db.define_singleton_method(:schema){|*| [[:id, {:primary_key=>true}], [:a, {:ruby_default => x, :primary_key=>false}]]}; c.dataset = c.dataset; c}
-  end
-  after do
-    Sequel.datetime_class = Time
-  end
-
-  it "should set default value upon initialization" do
-    @pr.call(2).new.a.must_equal 2
-  end
-
-  it "should not mark the column as modified" do
-    @pr.call(2).new.changed_columns.must_equal []
-  end
-
-  it "should not set a default of nil" do
-    @pr.call(nil).new.class.default_values.must_equal({})
-  end
-
-  it "should set a default of false" do
-    @pr.call(false).new.a.must_equal false
-  end
-
-  it "should handle Sequel::CURRENT_DATE default by using the current Date" do
-    @pr.call(Sequel::CURRENT_DATE).new.a.must_equal Date.today
-  end
-
-  it "should handle Sequel::CURRENT_TIMESTAMP default by using the current Time" do
-    t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
-    t.must_be_kind_of(Time)
-    (t - Time.now).must_be :<,  1
-  end
-
-  it "should handle :callable_default values in schema in preference to :ruby_default" do
-    @db.define_singleton_method(:schema) do |*|
-      [[:id, {:primary_key=>true}],
-       [:a, {:ruby_default => Time.now, :callable_default=>lambda{Date.today}, :primary_key=>false}]]
-    end
-    @c.dataset = @c.dataset
-    @c.new.a.must_equal Date.today
-  end
-
-  it "should handle Sequel::CURRENT_TIMESTAMP default by using the current DateTime if Sequel.datetime_class is DateTime" do
-    Sequel.datetime_class = DateTime
-    t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
-    t.must_be_kind_of(DateTime)
-    (t - DateTime.now).must_be :<,  1/86400.0
-  end
-
-  it "should work correctly with the current_datetime_timestamp extension" do
-    @db.autoid = 1
-    @db.fetch = {:id=>1}
-    @c.dataset = @c.dataset.extension(:current_datetime_timestamp)
-    c = @pr.call(Sequel::CURRENT_TIMESTAMP)
-    @db.sqls
-    o = c.new
-    o.a = o.a
-    o.save
-    @db.sqls.must_equal ["INSERT INTO foo (a) VALUES (CURRENT_TIMESTAMP)", "SELECT * FROM foo WHERE id = 1"]
-  end
-
-  it "should cache default values if :cache plugin option is used" do
-    @c.plugin :defaults_setter, :cache => true
-    @c.default_values[:a] = 'a'
-    o = @c.new
-    o.a.must_equal 'a'
-    o.values[:a].must_equal 'a'
-    o.a.must_be_same_as(o.a)
-  end
-
-  it "should not cache default values if :cache plugin option is used and there is no default values" do
-    @c.plugin :defaults_setter, :cache => true
-    o = @c.new
-    o.a.must_be_nil
-    o.values.must_be_empty
-    o.a.must_be_nil
-    o.a.must_be_same_as(o.a)
-  end
-
-  it "should not override a given value" do
-    @pr.call(2)
-    @c.new('a'=>3).a.must_equal 3
-    @c.new('a'=>nil).a.must_be_nil
-  end
-
-  it "should work correctly when subclassing" do
-    Class.new(@pr.call(2)).new.a.must_equal 2
-  end
-
-  it "should contain the default values in default_values" do
-    @pr.call(2).default_values.must_equal(:a=>2)
-    @c.default_values.clear
-    @pr.call(nil).default_values.must_equal({})
-  end
-
-  it "should allow modifications of default values" do
-    @pr.call(2)
-    @c.default_values[:a] = 3
-    @c.new.a.must_equal 3
-  end
-
-  it "should allow proc default values" do
-    @pr.call(2)
-    @c.default_values[:a] = proc{3}
-    @c.new.a.must_equal 3
-  end
-
-  it "should have procs that set default values set them to nil" do
-    @pr.call(2)
-    @c.default_values[:a] = proc{nil}
-    @c.new.a.must_be_nil
-  end
-
-  it "should work in subclasses" do
-    @pr.call(2)
-    @c.default_values[:a] = proc{1}
-    c = Class.new(@c)
-
-    @c.new.a.must_equal 1
-    c.new.a.must_equal 1
-
-    c.default_values[:a] = proc{2}
-    @c.new.a.must_equal 1
-    c.new.a.must_equal 2
-  end
-
-  it "should work correctly on a model without a dataset" do
-    @pr.call(2)
-    c = Class.new(Sequel::Model(@db[:bar]))
-    c.plugin :defaults_setter
-    c.default_values.must_equal(:a=>2)
-  end
-
-  it "should freeze default values when freezing model class" do
-    c = Class.new(Sequel::Model(@db[:bar]))
-    c.plugin :defaults_setter
-    c.freeze
-    c.default_values.frozen?.must_equal true
-  end
-end

data/spec/extensions/delay_add_association_spec.rb

@@ -1,73 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::DelayAddAssociation" do
-  before do
-    @db = Sequel.mock(:autoid=>1, :numrows=>1, :fetch=>{:id=>1, :name=>'a', :c_id=>nil})
-    @c = Class.new(Sequel::Model(@db[:cs]))
-    @c.send(:define_method, :save){|*| super(:changed=>true)}
-    @c.plugin :delay_add_association
-    @c.columns :id, :name, :c_id
-    @c.one_to_many :cs, :class=>@c, :key=>:c_id
-    @db.sqls
-  end
-
-  it "should delay adding of the association until after creation" do
-    @o = @c.new(:name=>'a')
-    @o.add_c(@c.load(:id=>2, :name=>'b'))
-    @db.sqls.must_equal []
-    @o.save
-    @db.sqls.must_equal ["INSERT INTO cs (name) VALUES ('a')", "SELECT * FROM cs WHERE (id = 1) LIMIT 1", "UPDATE cs SET c_id = 1 WHERE (id = 2)"]
-  end
-
-  it "should immediately reflect changes in cached association" do
-    @o = @c.new(:name=>'a')
-    o = @c.load(:id=>2, :name=>'b')
-    @o.add_c(o)
-    @o.cs.must_equal [o]
-    @db.sqls.must_equal []
-  end
-
-  it "should not affect adding associations to existing rows" do
-    @o = @c.load(:id=>1, :name=>'a')
-    @o.add_c(@c.load(:id=>2, :name=>'b'))
-    @db.sqls.must_equal ["UPDATE cs SET c_id = 1 WHERE (id = 2)"]
-  end
-
-  it "should raise an error when saving if the associated object is invalid" do
-    @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
-    @o = @c.new(:name=>'a')
-    @o.add_c(@c.load(:id=>2, :name=>'b'))
-    proc{@o.save}.must_raise Sequel::ValidationFailed
-  end
-
-  it "should return nil when saving if the associated object is invalid when raise_on_save_failure is false" do
-    @c.raise_on_save_failure = false
-    @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
-    @o = @c.new(:name=>'a')
-    @o.add_c(@c.load(:id=>2, :name=>'b'))
-    @o.save.must_be_nil
-    @o.errors[:cs].must_equal ["name is b"]
-    @o.cs.first.errors[:name].must_equal ['is b']
-  end
-
-  it "should work when passing in hashes" do
-    @o = @c.new(:name=>'a')
-    @o.add_c(:name=>'b')
-    @db.sqls.must_equal []
-    @o.save
-    @db.sqls.must_equal [
-      "INSERT INTO cs (name) VALUES ('a')",
-      "SELECT * FROM cs WHERE (id = 1) LIMIT 1",
-      "INSERT INTO cs (name, c_id) VALUES ('b', 1)",
-      "SELECT * FROM cs WHERE (id = 2) LIMIT 1"]
-  end
-
-  it "should work when passing in primary keys" do
-    @db.fetch = [[{:id=>2, :name=>'b', :c_id=>nil}], [{:id=>1, :name=>'a', :c_id=>nil}]]
-    @o = @c.new(:name=>'a')
-    @o.add_c(2)
-    @db.sqls.must_equal ["SELECT * FROM cs WHERE (id = 2) LIMIT 1"]
-    @o.save
-    @db.sqls.must_equal ["INSERT INTO cs (name) VALUES ('a')", "SELECT * FROM cs WHERE (id = 1) LIMIT 1", "UPDATE cs SET c_id = 1 WHERE (id = 2)"]
-  end
-end

data/spec/extensions/dirty_spec.rb

@@ -1,222 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::Dirty" do
-  before do
-    @db = Sequel.mock(:fetch=>{:initial=>'i'.dup, :initial_changed=>'ic'.dup}, :numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:c]))
-    @c.plugin :dirty
-    @c.columns :initial, :initial_changed, :missing, :missing_changed
-  end
-
-  dirty_plugin_specs = shared_description do
-    it "initial_value should be the current value if value has not changed" do
-      @o.initial_value(:initial).must_equal 'i'
-      @o.initial_value(:missing).must_be_nil
-    end
-
-    it "initial_value should be the intial value if value has changed" do
-      @o.initial_value(:initial_changed).must_equal 'ic'
-      @o.initial_value(:missing_changed).must_be_nil
-    end
-
-    it "initial_value should handle case where initial value is reassigned later" do
-      @o.initial_changed = 'ic'
-      @o.initial_value(:initial_changed).must_equal 'ic'
-      @o.missing_changed = nil
-      @o.initial_value(:missing_changed).must_be_nil
-    end
-
-    it "changed_columns should handle case where initial value is reassigned later" do
-      @o.changed_columns.must_equal [:initial_changed, :missing_changed]
-      @o.initial_changed = 'ic'
-      @o.changed_columns.must_equal [:missing_changed]
-      @o.missing_changed = nil
-      @o.changed_columns.must_equal [:missing_changed]
-    end
-
-    it "column_change should give initial and current values if there has been a change made" do
-      @o.column_change(:initial_changed).must_equal ['ic', 'ic2']
-      @o.column_change(:missing_changed).must_equal [nil, 'mc2']
-    end
-
-    it "column_change should be nil if no change has been made" do
-      @o.column_change(:initial).must_be_nil
-      @o.column_change(:missing).must_be_nil
-    end
-
-    it "column_changed? should return whether the column has changed" do
-      @o.column_changed?(:initial).must_equal false
-      @o.column_changed?(:initial_changed).must_equal true
-      @o.column_changed?(:missing).must_equal false
-      @o.column_changed?(:missing_changed).must_equal true
-    end
-
-    it "column_changed? should handle case where initial value is reassigned later" do
-      @o.initial_changed = 'ic'
-      @o.column_changed?(:initial_changed).must_equal false
-      @o.missing_changed = nil
-      @o.column_changed?(:missing_changed).must_equal false
-    end
-
-    it "changed_columns should handle case where initial value is reassigned later" do
-      @o.changed_columns.must_equal [:initial_changed, :missing_changed]
-      @o.initial_changed = 'ic'
-      @o.changed_columns.must_equal [:missing_changed]
-      @o.missing_changed = nil
-      @o.changed_columns.must_equal [:missing_changed]
-    end
-
-    it "column_changes should give initial and current values" do
-      @o.column_changes.must_equal(:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2'])
-    end
-
-    it "reset_column should reset the column to its initial value" do
-      @o.reset_column(:initial)
-      @o.initial.must_equal 'i'
-      @o.reset_column(:initial_changed)
-      @o.initial_changed.must_equal 'ic'
-      @o.reset_column(:missing)
-      @o.missing.must_be_nil
-      @o.reset_column(:missing_changed)
-      @o.missing_changed.must_be_nil
-    end
-
-    it "reset_column should remove missing values from the values" do
-      @o.reset_column(:missing)
-      @o.values.has_key?(:missing).must_equal false
-      @o.reset_column(:missing_changed)
-      @o.values.has_key?(:missing_changed).must_equal false
-    end
-    
-    it "refresh should clear the cached initial values" do
-      @o.refresh
-      @o.column_changes.must_equal({})
-    end
-    
-    it "will_change_column should be used to signal in-place modification to column" do
-      @o.will_change_column(:initial)
-      @o.initial << 'b'
-      @o.column_change(:initial).must_equal ['i', 'ib']
-      @o.will_change_column(:initial_changed)
-      @o.initial_changed << 'b'
-      @o.column_change(:initial_changed).must_equal ['ic', 'ic2b']
-      @o.will_change_column(:missing)
-      @o.values[:missing] = 'b'
-      @o.column_change(:missing).must_equal [nil, 'b']
-      @o.will_change_column(:missing_changed)
-      @o.missing_changed << 'b'
-      @o.column_change(:missing_changed).must_equal [nil, 'mc2b']
-    end
-
-    it "will_change_column should different types of existing objects" do
-      [nil, true, false, Class.new{undef_method :clone}.new, Class.new{def clone; raise TypeError; end}.new].each do |v|
-        o = @c.new(:initial=>v)
-        o.will_change_column(:initial)
-        o.initial = 'a'
-        o.column_change(:initial).must_equal [v, 'a']
-      end
-    end
-
-    it "should work when freezing objects" do
-      @o.freeze
-      @o.initial_value(:initial).must_equal 'i'
-      proc{@o.initial = 'b'}.must_raise
-    end
-
-    it "should have #dup duplicate structures" do
-      was_new = @o.new?
-      @o.update(:missing=>'m2')
-      @o.dup.initial_values.must_equal @o.initial_values
-      @o.dup.initial_values.wont_be_same_as(@o.initial_values)
-      @o.dup.instance_variable_get(:@missing_initial_values).must_equal @o.instance_variable_get(:@missing_initial_values)
-      @o.dup.instance_variable_get(:@missing_initial_values).wont_be_same_as(@o.instance_variable_get(:@missing_initial_values))
-      if was_new
-        @o.previous_changes.must_be_nil
-        @o.dup.previous_changes.must_be_nil
-      else
-        @o.dup.previous_changes.must_equal @o.previous_changes
-      end
-      @o.dup.previous_changes.wont_be_same_as(@o.previous_changes) if @o.previous_changes
-    end
-  end
-
-  describe "with new instance" do
-    before do
-      @o = @c.new(:initial=>'i'.dup, :initial_changed=>'ic'.dup)
-      @o.initial_changed = 'ic2'.dup
-      @o.missing_changed = 'mc2'.dup
-    end
-
-    include dirty_plugin_specs
-
-    it "save should clear the cached initial values" do
-      @o.save
-      @o.column_changes.must_equal({})
-    end
-
-    it "save_changes should clear the cached initial values" do
-      @c.dataset = @c.dataset.with_extend do
-        def supports_insert_select?; true end
-        def insert_select(*) {:id=>1} end
-      end
-      @o.save
-      @o.column_changes.must_equal({})
-    end
-
-    it "should work with the typecast_on_load plugin" do
-      @c.instance_variable_set(:@db_schema, :initial=>{:type=>:integer})
-      @c.plugin :typecast_on_load, :initial
-      
-      @o = @c.call(:initial=>'1')
-      @o.column_changes.must_equal({})
-      @o.save
-      @o.previous_changes.must_equal({})
-    end
-
-    it "should have column_changes work with the typecast_on_load in after hooks" do
-      @c.instance_variable_set(:@db_schema, :initial=>{:type=>:integer})
-      @c.plugin :typecast_on_load, :initial
-      
-      @o = @c.new
-      @o.initial = 1
-      @o.column_changes.must_equal({:initial=>[nil, 1]})
-      column_changes_in_after_save = nil
-      @o.define_singleton_method(:after_save) do
-        column_changes_in_after_save = column_changes
-        super()
-      end
-      @db.fetch = {:initial=>1}
-      @o.save
-      column_changes_in_after_save.must_equal({:initial=>[nil, 1]})
-
-      @o.initial = 2
-      @o.column_changes.must_equal({:initial=>[1, 2]})
-      @o.save
-      column_changes_in_after_save.must_equal({:initial=>[1, 2]})
-      @o.previous_changes.must_equal({:initial=>[1, 2]})
-    end
-  end
-
-  describe "with existing instance" do
-    before do
-      @o = @c[1]
-      @o.initial_changed = 'ic2'.dup
-      @o.missing_changed = 'mc2'.dup
-    end
-
-    include dirty_plugin_specs
-
-    it "previous_changes should be the previous changes after saving" do
-      @o.save
-      @o.previous_changes.must_equal(:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2'])
-    end
-
-    it "should work when freezing objects after saving" do
-      @o.initial = 'a'
-      @o.save
-      @o.freeze
-      @o.previous_changes[:initial].must_equal ['i', 'a']
-      proc{@o.initial = 'b'}.must_raise
-    end
-  end
-end

data/spec/extensions/duplicate_columns_handler_spec.rb

@@ -1,104 +0,0 @@
-require_relative "spec_helper"
-
-mod = shared_description do
-  it "should take action depending on :on_duplicate_columns if 2 or more columns have the same name" do
-    check(nil, @cols)
-    @warned.must_be_nil
-
-    check(:ignore, @cols)
-    @warned.must_be_nil
-
-    check(:warn, @cols)
-    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
-
-    proc{check(:raise, @cols)}.must_raise(Sequel::DuplicateColumnError)
-
-    cols = nil
-    check(proc{|cs| cols = cs; nil}, @cols)
-    @warned.must_be_nil
-    cols.must_equal @cols
-
-    cols = nil
-    check(proc{|cs| cols = cs; :ignore}, @cols)
-    @warned.must_be_nil
-    cols.must_equal @cols
-
-    cols = nil
-    proc{check(proc{|cs| cols = cs; :raise}, @cols)}.must_raise(Sequel::DuplicateColumnError)
-    cols.must_equal @cols
-
-    cols = nil
-    check(proc{|cs| cols = cs; :warn}, @cols)
-    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
-    cols.must_equal @cols
-
-    check(:raise, nil)
-    @warned.must_be_nil
-  end
-
-  it "should not raise error or warning if no columns have the same name" do
-    [nil, :ignore, :raise, :warn, proc{|cs| :raise}].each do |handler|
-      check(handler, @cols.uniq)
-      @warned.must_be_nil
-    end
-  end
-end
-
-describe "Sequel::DuplicateColumnsHandler Database configuration" do
-  before do
-    @db = Sequel.mock
-    @db.extension(:duplicate_columns_handler)
-    @cols = [:id, :name, :id]
-    @warned = nil
-    set_warned = @set_warned = proc{|m| @warned = m}
-    @ds = @db[:things].with_extend{define_method(:warn){|message| set_warned.call(message)}}
-  end
-
-  def check(handler, cols)
-    @db.opts[:on_duplicate_columns] = handler
-    @set_warned.call(nil)
-    @ds.send(:columns=, cols)
-  end
-
-  include mod
-end
-
-describe "Sequel::DuplicateColumnsHandler Dataset configuration" do
-  before do
-    @cols = [:id, :name, :id]
-    @warned = nil
-    set_warned = @set_warned = proc{|m| @warned = m}
-    @ds = Sequel.mock[:things].extension(:duplicate_columns_handler).with_extend{define_method(:warn){|message| set_warned.call(message)}}
-  end
-
-  def check(handler, cols)
-    @set_warned.call(nil)
-    @ds.on_duplicate_columns(handler).send(:columns=, cols)
-  end
-
-  include mod
-
-  it "should use handlers passed as blocks to on_duplicate_columns" do
-    proc{@ds.on_duplicate_columns{:raise}.send(:columns=, @cols)}.must_raise(Sequel::DuplicateColumnError)
-  end
-
-  it "should raise an error if not providing either an argument or block to on_duplicate_columns" do
-    proc{@ds.on_duplicate_columns}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if providing both an argument and block to on_duplicate_columns" do
-    proc{@ds.on_duplicate_columns(:raise){:raise}}.must_raise(Sequel::Error)
-  end
-
-  it "should warn by defaul if there is no database or dataset handler" do
-    @ds.send(:columns=, @cols)
-    @warned.must_include("One or more duplicate columns present in #{@cols.inspect}")
-  end
-
-  it "should fallback to database setting if there is no dataset-level handler" do
-    @ds.db.opts[:on_duplicate_columns] = :raise
-    proc{@ds.send(:columns=, @cols)}.must_raise(Sequel::DuplicateColumnError)
-    check(:ignore, @cols)
-    @warned.must_be_nil
-  end
-end