sequel 5.22.0 → 5.26.0

data/spec/extensions/dirty_spec.rb

@@ -162,6 +162,39 @@ describe "Sequel::Plugins::Dirty" do
       @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

data/spec/extensions/insert_conflict_spec.rb

@@ -0,0 +1,103 @@
+require_relative "spec_helper"
+
+describe "insert_conflict plugin" do
+  def model_class(adapter)
+    db = Sequel.mock(:host=>adapter, :fetch=>{:id=>1, :s=>2}, :autoid=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s, :o
+    model.plugin :insert_conflict
+    db.sqls
+    model
+  end
+
+  def model_class_plugin_first(adapter)
+    model = Class.new(Sequel::Model)
+    model.plugin :insert_conflict
+    model = Class.new(model)
+    db = Sequel.mock(:host=>adapter, :fetch=>{:id=>1, :s=>2}, :autoid=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model.dataset = db[:t]
+    model.columns :id, :s, :o
+    db.sqls
+    model
+  end
+
+  it "should use INSERT ON CONFLICT when inserting on PostgreSQL" do
+    model = model_class(:postgres)
+    model.new(:s=>'A', :o=>1).insert_conflict.save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING RETURNING *"]
+
+    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o RETURNING *"]
+  end
+
+  it "should use INSERT ON CONFLICT when inserting on SQLITE" do
+    model = model_class(:sqlite)
+    model.new(:s=>'A', :o=>1).insert_conflict.save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING",
+      "SELECT * FROM t WHERE (id = 1) LIMIT 1"]
+
+    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o",
+      "SELECT * FROM t WHERE (id = 2) LIMIT 1"]
+  end
+
+  it "should raise Error if calling insert_conflict on a model instance that isn't new" do
+    m = model_class(:postgres).load(:s=>'A', :o=>1)
+    proc{m.insert_conflict}.must_raise Sequel::Error
+  end
+
+  it "should raise if loading plugin into a model class with a dataset that doesn't support insert_conflict" do
+    model = Class.new(Sequel::Model)
+    model.dataset = Sequel.mock[:t]
+    proc{model.plugin :insert_conflict}.must_raise Sequel::Error
+  end
+
+  it "should work if loading into a model class without a dataset on PostgreSQL" do
+    model = model_class_plugin_first(:postgres)
+    model.new(:s=>'A', :o=>1).insert_conflict.save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING RETURNING *"]
+
+    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o RETURNING *"]
+  end
+
+  it "should work if loading into a model class without a dataset on SQLITE" do
+    model = model_class_plugin_first(:sqlite)
+    model.new(:s=>'A', :o=>1).insert_conflict.save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT DO NOTHING",
+      "SELECT * FROM t WHERE (id = 1) LIMIT 1"]
+
+    model.new(:s=>'A', :o=>1).insert_conflict(:target=>:s, :update => {:o => Sequel[:excluded][:o]}).save
+    model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o",
+      "SELECT * FROM t WHERE (id = 2) LIMIT 1"]
+  end
+
+  it "should work if the prepared_statements plugin is loaded before" do
+    db = Sequel.mock(:host=>'sqlite', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s
+    model.plugin :prepared_statements
+    model.plugin :insert_conflict
+    db.sqls
+    model.create(:s=>'a').update(:s=>'b')
+    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a')", "SELECT * FROM t WHERE (id = 1) LIMIT 1", "UPDATE t SET s = 'b' WHERE (id = 1)"]
+  end
+
+  it "should work if the prepared_statements plugin is loaded after" do
+    db = Sequel.mock(:host=>'postgres', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s
+    model.plugin :insert_conflict
+    model.plugin :prepared_statements
+    db.sqls
+    model.create(:s=>'a').update(:s=>'b')
+    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a') RETURNING *", "UPDATE t SET s = 'b' WHERE (id = 1)"]
+  end
+end

data/spec/extensions/named_timezones_spec.rb

@@ -9,7 +9,7 @@ Sequel.extension :thread_local_timezones
 Sequel.extension :named_timezones
 Sequel.datetime_class = Time
 
-describe "Sequel named_timezones extension" do
+describe "Sequel named_timezones extension with DateTime class" do
   before do
     @tz_in = TZInfo::Timezone.get('America/Los_Angeles')
     @tz_out = TZInfo::Timezone.get('America/New_York')
@@ -54,10 +54,12 @@ describe "Sequel named_timezones extension" do
   
   it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
     dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30-0400')
+    dt.must_be_instance_of DateTime
     dt.must_equal @dt
     dt.offset.must_equal(-7/24.0)
     
     dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30+0000')
+    dt.must_be_instance_of DateTime
     dt.must_equal @dt
     dt.offset.must_equal(-7/24.0)
   end
@@ -68,7 +70,9 @@ describe "Sequel named_timezones extension" do
 
   it "should support tzinfo_disambiguator= to handle ambiguous timezones automatically" do
     Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
-    Sequel.database_to_application_timestamp('2004-10-31T01:30:00').must_equal DateTime.parse('2004-10-30T22:30:00-07:00')
+    dt = Sequel.database_to_application_timestamp('2004-10-31T01:30:00')
+    dt.must_equal DateTime.parse('2004-10-30T22:30:00-07:00')
+    dt.offset.must_equal(-7/24.0)
   end
 
   it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
@@ -108,4 +112,107 @@ describe "Sequel named_timezones extension" do
     tz2.must_equal @tz_in
   end
 end
+
+describe "Sequel named_timezones extension with Time class" do
+  before do
+    @tz_in = TZInfo::Timezone.get('America/Los_Angeles')
+    @tz_out = TZInfo::Timezone.get('America/New_York')
+    @db = Sequel.mock
+    Sequel.application_timezone = 'America/Los_Angeles'
+    Sequel.database_timezone = 'America/New_York'
+  end
+  after do
+    Sequel.tzinfo_disambiguator = nil
+    Sequel.default_timezone = nil
+    Sequel.datetime_class = Time
+  end
+  
+  it "should convert string arguments to *_timezone= to TZInfo::Timezone instances" do
+    Sequel.application_timezone.must_equal @tz_in
+    Sequel.database_timezone.must_equal @tz_out
+  end
+    
+  it "should convert string arguments for Database#timezone= to TZInfo::Timezone instances for database-specific timezones" do
+    @db.extension :named_timezones
+    @db.timezone = 'America/Los_Angeles'
+    @db.timezone.must_equal @tz_in
+  end
+    
+  it "should accept TZInfo::Timezone instances in *_timezone=" do
+    Sequel.application_timezone = @tz_in
+    Sequel.database_timezone = @tz_out
+    Sequel.application_timezone.must_equal @tz_in
+    Sequel.database_timezone.must_equal @tz_out
+  end
+    
+  it "should convert datetimes going into the database to named database_timezone" do
+    ds = @db[:a].with_extend do
+      def supports_timestamp_timezones?; true; end
+      def supports_timestamp_usecs?; false; end
+    end
+    ds.insert([Time.new(2009,6,1,3,20,30, RUBY_VERSION >= '2.6' ? @tz_in : -25200), Time.new(2009,6,1,3,20,30,-25200), Time.new(2009,6,1,6,20,30,-14400)])
+    @db.sqls.must_equal ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
+  end
+  
+  it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
+    dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30-0400')
+    dt.must_be_instance_of Time
+    dt.must_equal Time.new(2009,6,1,3,20,30,-25200)
+    dt.utc_offset.must_equal -25200
+    
+    dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30+0000')
+    dt.must_be_instance_of Time
+    dt.must_equal Time.new(2009,6,1,3,20,30,-25200)
+    dt.utc_offset.must_equal -25200
+  end
+    
+  it "should raise an error for ambiguous timezones by default" do
+    proc{Sequel.database_to_application_timestamp('2004-10-31T01:30:00')}.must_raise(Sequel::InvalidValue)
+  end
+
+  it "should support tzinfo_disambiguator= to handle ambiguous timezones automatically" do
+    Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
+    Sequel.database_to_application_timestamp('2004-10-31T01:30:00').must_equal Time.new(2004, 10, 30, 22, 30, 0, -25200)
+    dt = Sequel.database_to_application_timestamp('2004-10-31T01:30:00')
+    dt.must_equal Time.new(2004, 10, 30, 22, 30, 0, -25200)
+    dt.utc_offset.must_equal -25200
+  end
+
+  it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
+    dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30')
+    dt.must_be_instance_of Time
+    dt.must_equal Time.new(2009,6,1,3,20,30, -25200)
+    dt.utc_offset.must_equal -25200
+    
+    dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30')
+    dt.must_be_instance_of Time
+    dt.must_equal Time.new(2009,6,1,7,20,30, -25200)
+    dt.utc_offset.must_equal -25200
+  end
+  
+  it "should work with the thread_local_timezones extension" do
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
+    tz1, tz2 = nil, nil
+    t1 = Thread.new do
+      Sequel.thread_application_timezone = 'America/New_York'
+      q2.push nil
+      q.pop
+      tz1 = Sequel.application_timezone
+    end
+    t2 = Thread.new do
+      Sequel.thread_application_timezone = 'America/Los_Angeles'
+      q2.push nil
+      q1.pop
+      tz2 = Sequel.application_timezone
+    end
+    q2.pop
+    q2.pop
+    q.push nil
+    q1.push nil
+    t1.join
+    t2.join
+    tz1.must_equal @tz_out
+    tz2.must_equal @tz_in
+  end
+end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -492,6 +492,54 @@ describe "NestedAttributes plugin" do
     @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
   end
 
+  it "should raise a NoExistingObject error if object to be updated no longer exists, if the :require_modification=>true option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>true, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :name=>'L'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    proc{ar.save}.must_raise Sequel::NoExistingObject
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'L' WHERE (id = 10)"]
+  end
+
+  it "should not raise an Error if object to be updated no longer exists, if the :require_modification=>false option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>false, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :name=>'L'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    ar.save
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'L' WHERE (id = 10)"]
+  end
+
+  it "should raise a NoExistingObject error if object to be deleted no longer exists, if the :require_modification=>true option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>true, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    proc{ar.save}.must_raise Sequel::NoExistingObject
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
+  end
+
+  it "should not raise an Error if object to be deleted no longer exists, if the :require_modification=>false option is used" do
+    @Artist.nested_attributes :albums, :require_modification=>false, :destroy=>true
+    al = @Album.load(:id=>10, :name=>'Al')
+    ar = @Artist.load(:id=>20, :name=>'Ar')
+    ar.associations[:albums] = [al]
+    ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
+    @db.sqls.must_equal []
+    @db.numrows = [1, 0]
+    ar.save
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
+  end
+
   it "should not attempt to validate nested attributes twice for one_to_many associations when creating them" do
     @Artist.nested_attributes :albums
     validated = []

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -169,4 +169,41 @@ describe "pg_auto_constraint_validations plugin" do
     proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
     o.errors.must_equal(:i=>['foo bar'])
   end
+
+  it "should handle dumping cached metadata and loading metadata from cache" do
+    cache_file = "spec/files/pgacv-spec-#{$$}.cache"
+    begin
+      @ds = @db[:items]
+      @ds.send(:columns=, [:id, :i])
+      @db.fetch = @metadata_results.dup
+      c = Sequel::Model(@ds)
+      def c.name; 'Foo' end
+      @db.sqls
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      @db.sqls.length.must_equal 5
+
+      o = c.new(:i=>12)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+      proc{o.save}.must_raise Sequel::ValidationFailed
+
+      c.dump_pg_auto_constraint_validations_cache
+
+      @db.fetch = []
+      c = Sequel::Model(@ds)
+      def c.name; 'Foo' end
+      @db.sqls
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      @db.sqls.must_be_empty
+
+      o = c.new(:i=>12)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+      proc{o.save}.must_raise Sequel::ValidationFailed
+    ensure
+      File.delete(cache_file) if File.file?(cache_file)
+    end
+  end
+
+  it "should raise error if attempting to dump cached metadata when not using caching" do
+    proc{@c.dump_pg_auto_constraint_validations_cache}.must_raise Sequel::Error
+  end
 end

data/spec/extensions/pg_json_ops_spec.rb

@@ -286,4 +286,71 @@ describe "Sequel::Postgres::JSONOp" do
   it "should allow transforming JSONBHash instances into ArrayOp instances" do
     @db.literal(Sequel.pg_jsonb('a'=>1).op['a']).must_equal "('{\"a\":1}'::jsonb -> 'a')"
   end
+
+  it "#path_exists should use the @? operator" do
+    @l[@jb.path_exists('$')].must_equal "(j @? '$')"
+  end
+
+  it "#path_exists result should be a boolean expression" do
+    @jb.path_exists('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_match should use the @@ operator" do
+    @l[@jb.path_match('$')].must_equal "(j @@ '$')"
+  end
+
+  it "#path_match result should be a boolean expression" do
+    @jb.path_match('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_exists! should use the jsonb_path_exists function" do
+    @l[@jb.path_exists!('$')].must_equal "jsonb_path_exists(j, '$')"
+    @l[@jb.path_exists!('$', '{"x":2}')].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}')"
+    @l[@jb.path_exists!('$', x: 2)].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}')"
+    @l[@jb.path_exists!('$', {x: 2}, true)].must_equal "jsonb_path_exists(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_exists! result should be a boolean expression" do
+    @jb.path_exists!('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_match! should use the jsonb_path_match function" do
+    @l[@jb.path_match!('$')].must_equal "jsonb_path_match(j, '$')"
+    @l[@jb.path_match!('$', '{"x":2}')].must_equal "jsonb_path_match(j, '$', '{\"x\":2}')"
+    @l[@jb.path_match!('$', x: 2)].must_equal "jsonb_path_match(j, '$', '{\"x\":2}')"
+    @l[@jb.path_match!('$', {x: 2}, true)].must_equal "jsonb_path_match(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_match! result should be a boolean expression" do
+    @jb.path_match!('$').must_be_kind_of Sequel::SQL::BooleanExpression
+  end
+
+  it "#path_query should use the jsonb_path_query function" do
+    @l[@jb.path_query('$')].must_equal "jsonb_path_query(j, '$')"
+    @l[@jb.path_query('$', '{"x":2}')].must_equal "jsonb_path_query(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query('$', x: 2)].must_equal "jsonb_path_query(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query('$', {x: 2}, true)].must_equal "jsonb_path_query(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_array should use the jsonb_path_query_array function" do
+    @l[@jb.path_query_array('$')].must_equal "jsonb_path_query_array(j, '$')"
+    @l[@jb.path_query_array('$', '{"x":2}')].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_array('$', x: 2)].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_array('$', {x: 2}, true)].must_equal "jsonb_path_query_array(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_array result should be a JSONBOp" do
+    @l[@jb.path_query_array('$').path_query_array('$')].must_equal "jsonb_path_query_array(jsonb_path_query_array(j, '$'), '$')"
+  end
+
+  it "#path_query_first should use the jsonb_path_query_first function" do
+    @l[@jb.path_query_first('$')].must_equal "jsonb_path_query_first(j, '$')"
+    @l[@jb.path_query_first('$', '{"x":2}')].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_first('$', x: 2)].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}')"
+    @l[@jb.path_query_first('$', {x: 2}, true)].must_equal "jsonb_path_query_first(j, '$', '{\"x\":2}', true)"
+  end
+
+  it "#path_query_first result should be a JSONBOp" do
+    @l[@jb.path_query_first('$').path_query_first('$')].must_equal "jsonb_path_query_first(jsonb_path_query_first(j, '$'), '$')"
+  end
 end