sequel 5.28.0 → 5.33.0

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -1,209 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_auto_constraint_validations plugin" do
-  def create_model(ds)
-    @ds = ds
-    @ds.send(:columns=, [:id, :i])
-    @db.fetch = @metadata_results.dup
-    c = Sequel::Model(@ds)
-    c.plugin :pg_auto_constraint_validations
-    c
-  end
-
-  before do
-    info = @info = {:schema=>'public', :table=>'items'}
-    @db = Sequel.mock(:host=>'postgres')
-    def @db.schema(*) [[:i, {}], [:id, {}]] end
-    @set_error = lambda{|ec, ei| @db.fetch = @db.autoid = @db.numrows = ec; info.merge!(ei)}
-    @db.define_singleton_method(:error_info){|e| info}
-    @metadata_results = [
-     [{:constraint=>'items_i_check', :column=>'i', :definition=>'CHECK i'}, {:constraint=>'items_i_id_check', :column=>'i', :definition=>'CHECK i + id < 20'}, {:constraint=>'items_i_id_check', :column=>'id', :definition=>'CHECK i + id < 20'}],
-     [{:name=>'items_i_uidx', :unique=>true, :column=>'i', :deferrable=>false}, {:name=>'items_i2_idx', :unique=>false, :column=>'i', :deferrable=>false}],
-     [{:name=>'items_i_fk', :column=>'i', :on_update=>'a', :on_delete=>'a', :table=>'items2', :refcolumn=>'id', :schema=>'public'}],
-     [{:name=>'items2_i_fk', :column=>'id', :on_update=>'a', :on_delete=>'a', :table=>'items2', :refcolumn=>'i', :schema=>'public'}],
-     [{:nspname=>'public', :relname=>'items'}]
-    ]
-    @c = create_model(@db[:items])
-  end
-
-  it "should handle check constraint failures as validation errors when creating" do
-    o = @c.new(:i=>12)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle check constraint failures as validation errors when updating" do
-    o = @c.load(:i=>3)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-    proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle unique constraint failures as validation errors when creating" do
-    o = @c.new(:i=>2)
-    @set_error[Sequel::UniqueConstraintViolation, :constraint=>'items_i_uidx']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is already taken'])
-  end
-
-  it "should handle unique constraint failures as validation errors when updating" do
-    o = @c.load(:id=>5, :i=>3)
-    @set_error[Sequel::UniqueConstraintViolation, :constraint=>'items_i_uidx']
-    proc{o.update(:i=>2)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is already taken'])
-  end
-
-  it "should handle not null constraint failures as validation errors when creating" do
-    o = @c.new(:i=>5)
-    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is not present'])
-  end
-
-  it "should handle not null constraint failures as validation errors when updating" do
-    o = @c.load(:i=>3)
-    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
-    proc{o.update(:i=>nil)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is not present'])
-  end
-
-  it "should handle foreign key constraint failures as validation errors when creating" do
-    o = @c.new(:i=>3)
-    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items_i_fk', :message_primary=>'insert or']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle foreign key constraint failures as validation errors when updating" do
-    o = @c.load(:i=>1)
-    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items_i_fk', :message_primary=>'insert or']
-    proc{o.update(:i=>3)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle foreign key constraint failures in other tables as validation errors when updating" do
-    o = @c.load(:i=>1)
-    @set_error[Sequel::ForeignKeyConstraintViolation, :constraint=>'items2_i_fk', :message_primary=>'update or', :schema=>'public', :table=>'items2']
-    proc{o.update(:i=>3)}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['cannot be changed currently'])
-  end
-
-  it "should handle symbol, string, and identifier table names" do
-    [@db[:items], @db.from('items'), @db.from{items}, @db.from{public[:items]}].each do |ds|
-      c = create_model(ds)
-      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-      o = c.new(:i=>3)
-      proc{o.save}.must_raise Sequel::ValidationFailed
-      o.errors.must_equal(:i=>['is invalid'])
-    end
-  end
-
-  it "should skip handling of other table types such as subqueries and functions" do
-    [@db.from{foo(:bar)}, @db[:a, :b]].each do |ds|
-      @db.fetch = @metadata_results.dup
-      @c.dataset = ds
-      o = @c.new(:i=>3)
-      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-      proc{o.save}.must_raise Sequel::CheckConstraintViolation
-    end
-  end
-
-  it "should skip handling if the error_info method is not supported" do
-    @db.singleton_class.send(:remove_method, :error_info)
-    c = create_model(@db[:items])
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-    o = c.new(:i=>3)
-    proc{o.save}.must_raise Sequel::CheckConstraintViolation
-  end
-
-  it "should not handle constraint failures if they can't be converted" do
-    o = @c.new(:i=>12)
-    @set_error[Sequel::NotNullConstraintViolation, {}]
-    proc{o.save}.must_raise Sequel::NotNullConstraintViolation
-  end
-
-  it "should reraise original exception if there is an error" do
-    o = @c.new(:i=>12)
-    def o.add_pg_constraint_validation_error; end
-    @set_error[Sequel::NotNullConstraintViolation, :column=>'i']
-    proc{o.save}.must_raise Sequel::NotNullConstraintViolation
-  end
-
-  it "should not handle constraint failures if schema or table do not match" do
-    o = @c.new(:i=>12)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check', :schema=>'x']
-    proc{o.save}.must_raise Sequel::CheckConstraintViolation
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check', :schema=>'public', :table=>'x']
-    proc{o.save}.must_raise Sequel::CheckConstraintViolation
-  end
-
-  it "should handle constraint failures when disabling insert returning" do
-    c = create_model(@db[:items].disable_insert_returning)
-    o = c.new(:i=>12)
-    o.id = 1
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_check']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'])
-  end
-
-  it "should handle multi-column constraint failures as validation errors" do
-    o = @c.new(:i=>12)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal([:i, :id]=>['is invalid'])
-  end
-
-  it "should handle multi-column constraint failures as validation errors when using the error_splitter plugin" do
-    @c.plugin :error_splitter
-    o = @c.new(:i=>12)
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
-    proc{o.save}.must_raise Sequel::ValidationFailed
-    o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
-  end
-
-  it "should handle overridden constraint failures as validation errors when updating" do
-    o = @c.load(:i=>3)
-    @c.pg_auto_constraint_validation_override(:items_i_ocheck, :i, "foo bar")
-    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_ocheck']
-    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_enum_spec.rb

@@ -1,118 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :migration
-
-describe "pg_enum extension" do
-  before do
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    @db.extend(Module.new do
-      def schema_parse_table(*)
-        [[:a, {:oid=>1}]]
-      end
-      def _metadata_dataset
-        super.with_fetch([[{:v=>1, :enumlabel=>'a'}, {:v=>1, :enumlabel=>'b'}, {:v=>1, :enumlabel=>'c'}], [{:typname=>'enum1', :v=>212389}]])
-      end
-    end)
-    @db.extension(:pg_array, :pg_enum)
-    @db.sqls
-  end
-
-  it "should include enum information in the schema entry" do
-    @db.schema(:a).must_equal [[:a, {:oid=>1, :ruby_default=>nil, :type=>:enum, :enum_values=>%w'a b c'}]]
-  end
-
-  it "should typecast objects to string" do
-    @db.typecast_value(:enum, :a).must_equal 'a'
-  end
-
-  it "should add array parsers for enum values" do
-    @db.conversion_procs[212389].call('{a,b,c}').must_equal %w'a b c'
-  end
-
-  it "should support #create_enum method for adding a new enum" do
-    @db.create_enum(:foo, [:a, :b, :c])
-    @db.sqls.first.must_equal "CREATE TYPE foo AS ENUM ('a', 'b', 'c')"
-    @db.create_enum(Sequel[:sch][:foo], %w'a b c')
-    @db.sqls.first.must_equal "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
-  end
-
-  with_symbol_splitting "should support #create_enum method for adding a new enum with qualified symbol" do
-    @db.create_enum(:sch__foo, %w'a b c')
-    @db.sqls.first.must_equal "CREATE TYPE sch.foo AS ENUM ('a', 'b', 'c')"
-  end
-
-  it "should support #rename_enum method for renameing an enum" do
-    @db.rename_enum(:foo, :bar)
-    @db.sqls.first.must_equal "ALTER TYPE foo RENAME TO bar"
-    @db.rename_enum(Sequel[:sch][:foo], Sequel[:sch][:bar])
-    @db.sqls.first.must_equal "ALTER TYPE sch.foo RENAME TO sch.bar"
-  end
-
-  it "should support #rename_enum_value method for renameing an enum value" do
-    @db.rename_enum_value(:foo, :b, :x)
-    @db.sqls.first.must_equal "ALTER TYPE foo RENAME VALUE 'b' TO 'x'"
-  end
-
-  it "should support #drop_enum method for dropping an enum" do
-    @db.drop_enum(:foo)
-    @db.sqls.first.must_equal "DROP TYPE foo"
-    @db.drop_enum(Sequel[:sch][:foo], :if_exists=>true)
-    @db.sqls.first.must_equal "DROP TYPE IF EXISTS sch.foo"
-    @db.drop_enum('foo', :cascade=>true)
-    @db.sqls.first.must_equal "DROP TYPE foo CASCADE"
-  end
-
-  with_symbol_splitting "should support #drop_enum method for dropping an enum with a splittable symbol" do
-    @db.drop_enum(:sch__foo, :if_exists=>true)
-    @db.sqls.first.must_equal "DROP TYPE IF EXISTS sch.foo"
-  end
-
-  it "should support #add_enum_value method for adding value to an existing enum" do
-    @db.add_enum_value(:foo, :a)
-    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE 'a'"
-  end
-
-  it "should support :before option for #add_enum_value method for adding value before an existing enum value" do
-    @db.add_enum_value('foo', :a, :before=>:b)
-    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE 'a' BEFORE 'b'"
-  end
-
-  it "should support :after option for #add_enum_value method for adding value after an existing enum value" do
-    @db.add_enum_value(Sequel[:sch][:foo], :a, :after=>:b)
-    @db.sqls.first.must_equal "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
-  end
-
-  with_symbol_splitting "should support :after option for #add_enum_value method for adding value after an existing enum value with splittable symbol" do
-    @db.add_enum_value(:sch__foo, :a, :after=>:b)
-    @db.sqls.first.must_equal "ALTER TYPE sch.foo ADD VALUE 'a' AFTER 'b'"
-  end
-
-  it "should support :if_not_exists option for #add_enum_value method for not adding the value if it exists" do
-    @db.add_enum_value(:foo, :a, :if_not_exists=>true)
-    @db.sqls.first.must_equal "ALTER TYPE foo ADD VALUE IF NOT EXISTS 'a'"
-  end
-
-  it "should reverse a create_enum directive in a migration" do
-    m = Sequel.migration{change{create_enum(:type_name, %w'value1 value2 value3')}}
-    m.apply(@db, :up)
-    @db.sqls.must_equal ["CREATE TYPE type_name AS ENUM ('value1', 'value2', 'value3')",
-      "SELECT CAST(enumtypid AS integer) AS v, enumlabel FROM pg_enum ORDER BY enumtypid, enumsortorder",
-      "SELECT typname, CAST(typarray AS integer) AS v FROM pg_type WHERE ((1 = 0) AND (typarray != 0))"]
-    m.apply(@db, :down)
-    @db.sqls.must_equal ["DROP TYPE type_name", "SELECT CAST(enumtypid AS integer) AS v, enumlabel FROM pg_enum ORDER BY enumtypid, enumsortorder",
-      "SELECT typname, CAST(typarray AS integer) AS v FROM pg_type WHERE ((1 = 0) AND (typarray != 0))"]
-  end
-
-  it "should reverse a rename_enum directive in a migration" do
-    m = Sequel.migration{change{rename_enum(:old_type_name, :new_type_name)}}
-    m.apply(@db, :up)
-    @db.sqls.must_equal ["ALTER TYPE old_type_name RENAME TO new_type_name",
-      "SELECT CAST(enumtypid AS integer) AS v, enumlabel FROM pg_enum ORDER BY enumtypid, enumsortorder",
-      "SELECT typname, CAST(typarray AS integer) AS v FROM pg_type WHERE ((1 = 0) AND (typarray != 0))"]
-    m.apply(@db, :down)
-    @db.sqls.must_equal ["ALTER TYPE new_type_name RENAME TO old_type_name",
-      "SELECT CAST(enumtypid AS integer) AS v, enumlabel FROM pg_enum ORDER BY enumtypid, enumsortorder",
-      "SELECT typname, CAST(typarray AS integer) AS v FROM pg_type WHERE ((1 = 0) AND (typarray != 0))"]
-  end
-end

data/spec/extensions/pg_extended_date_support_spec.rb

@@ -1,126 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_extended_date_support extension" do
-  before do
-    @db = Sequel.mock(:host=>'postgres', :fetch=>{:v=>1}).extension(:pg_extended_date_support)
-    @db.extend_datasets{def quote_identifiers?; false end}
-  end
-  after do
-    Sequel.datetime_class = Time
-    Sequel.default_timezone = nil
-  end
-
-  it "should convert infinite timestamps and dates as configured" do
-    cp = @db.conversion_procs
-    d = lambda{|v| cp[1082].call(v)}
-    t = lambda{|v| cp[1114].call(v)}
-    pi = 'infinity'
-    ni = '-infinity'
-    today = Date.today
-    now = Time.now
-
-    d.(today.to_s).must_equal today
-    t.(now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
-    proc{@db.typecast_value(:date, pi)}.must_raise Sequel::InvalidValue
-    proc{@db.typecast_value(:datetime, pi)}.must_raise Sequel::InvalidValue
-
-    [:nil, 'nil'].each do |v|
-      @db.convert_infinite_timestamps = v
-      d.(pi).must_be_nil
-      t.(pi).must_be_nil
-      d.(ni).must_be_nil
-      t.(ni).must_be_nil
-      @db.typecast_value(:date, pi).must_equal pi
-      @db.typecast_value(:datetime, pi).must_equal pi
-      @db.typecast_value(:date, ni).must_equal ni
-      @db.typecast_value(:datetime, ni).must_equal ni
-    end
-
-    d.(today.to_s).must_equal today
-    t.(now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
-    @db.typecast_value(:date, today.to_s).must_equal today
-    @db.typecast_value(:datetime, now.strftime("%Y-%m-%d %H:%M:%S.%N")).must_equal now
-
-    [:string, 'string'].each do |v|
-      @db.convert_infinite_timestamps = v
-      d.(pi).must_equal pi
-      t.(pi).must_equal pi
-      d.(ni).must_equal ni
-      t.(ni).must_equal ni
-    end
-
-    [:date, 'date'].each do |v|
-      @db.convert_infinite_timestamps = v
-      d.(pi).must_equal Date::Infinity.new
-      t.(pi).must_equal Date::Infinity.new
-      d.(ni).must_equal(-Date::Infinity.new)
-      t.(ni).must_equal(-Date::Infinity.new)
-    end
-
-    [:float, 'float', 't', true].each do |v|
-      @db.convert_infinite_timestamps = v
-      d.(pi).must_equal 1.0/0.0
-      t.(pi).must_equal 1.0/0.0
-      d.(ni).must_equal(-1.0/0.0)
-      t.(ni).must_equal(-1.0/0.0)
-    end
-
-    ['f', false].each do |v|
-      @db.convert_infinite_timestamps = v
-      proc{d.(pi)}.must_raise ArgumentError, Sequel::InvalidValue
-      proc{t.(pi)}.must_raise ArgumentError, Sequel::InvalidValue
-      proc{d.(ni)}.must_raise ArgumentError, Sequel::InvalidValue
-      proc{t.(ni)}.must_raise ArgumentError, Sequel::InvalidValue
-    end
-  end
-
-  it "should handle parsing BC dates" do
-    @db.conversion_procs[1082].call("1092-10-20 BC").must_equal Date.new(-1091, 10, 20)
-  end
-
-  it "should handle parsing BC timestamps as Time values" do
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00 BC").must_equal Time.at(-100000000000).utc
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00 BC").must_equal Time.at(-100000000000).utc
-    Sequel.default_timezone = :utc
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20 BC").must_equal Time.at(-100000000000).utc
-    Sequel.default_timezone = nil
-  end
-
-  it "should handle parsing BC timestamps as DateTime values" do
-    Sequel.datetime_class = DateTime
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
-    Sequel.default_timezone = :utc
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20 BC").must_equal DateTime.new(-1199, 2, 15, 14, 13, 20)
-  end
-
-  it "should handle parsing AD timestamps with offset seconds" do
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00").must_equal DateTime.new(1200, 2, 15, 14, 13, 20).to_time
-    Sequel.datetime_class = DateTime
-    @db.conversion_procs[1114].call("1200-02-15 14:13:20-00:00:00").must_equal DateTime.new(1200, 2, 15, 14, 13, 20)
-  end
-
-  it "should format Date::Infinity values" do
-    @db.literal(Date::Infinity.new).must_equal "'infinity'"
-    @db.literal(-Date::Infinity.new).must_equal "'-infinity'"
-  end
-
-  it "should raise errors for literalizing random Objects" do
-    proc{@db.literal(Object.new)}.must_raise Sequel::Error
-  end
-
-  it "should format BC dates" do
-    @db.literal(Date.new(-1091, 10, 20)).must_equal "'1092-10-20 BC'"
-    @db.literal(Date.new(1092, 10, 20)).must_equal "'1092-10-20'"
-  end
-
-  it "should format BC datetimes" do
-    @db.literal(DateTime.new(-1199, 2, 15, 14, 13, 20)).must_equal "'1200-02-15 14:13:20.000000000+0000 BC'"
-    @db.literal(DateTime.new(1200, 2, 15, 14, 13, 20)).must_equal "'1200-02-15 14:13:20.000000+0000'"
-  end
-
-  it "should format BC times" do
-    @db.literal(Time.at(-100000000000).utc).must_equal "'1200-02-15 14:13:20.000000000+0000 BC'"
-    @db.literal(Time.at(100000000000).utc).must_equal "'5138-11-16 09:46:40.000000+0000'"
-  end
-end