sequel 5.29.0 → 5.34.0

data/spec/extensions/column_conflicts_spec.rb

@@ -1,75 +0,0 @@
-require_relative "spec_helper"
-
-describe "column_conflicts plugin" do
-  before do
-    @db = Sequel.mock
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @c.columns :model, :use_transactions, :foo
-    @c.plugin :column_conflicts
-    @o = @c.load(:model=>1, :use_transactions=>2, :foo=>4)
-  end
-
-  it "should have mass assignment work correctly" do
-    @o.set_fields({:use_transactions=>3}, [:use_transactions])
-    @o.get_column_value(:use_transactions).must_equal 3
-  end
-
-  it "should handle both symbols and strings" do
-    @o.get_column_value(:model).must_equal 1
-    @o.get_column_value("model").must_equal 1
-    @o.set_column_value(:use_transactions=, 3)
-    @o.get_column_value(:use_transactions).must_equal 3
-    @o.set_column_value(:use_transactions=, 4)
-    @o.get_column_value(:use_transactions).must_equal 4
-  end
-
-  it "should work correctly if there are no conflicts" do
-    @o.get_column_value(:foo).must_equal 4
-    @o.set_column_value(:model=, 2).must_equal 2
-  end
-
-  it "should allow manual setting of conflicted columns" do
-    @c.send(:define_method, :foo){raise}
-    @c.get_column_conflict!(:foo)
-    @o.get_column_value(:foo).must_equal 4
-
-    @c.send(:define_method, :model=){raise}
-    @c.set_column_conflict!(:model)
-    @o.set_column_value(:model=, 2).must_equal 2
-    @o.get_column_value(:model).must_equal 2
-  end
-
-  it "should not erase existing column conflicts when loading the plugin" do
-    @c.send(:define_method, :foo){raise}
-    @c.send(:define_method, :model=){raise}
-    @c.get_column_conflict!(:foo)
-    @c.set_column_conflict!(:model)
-    @c.plugin :column_conflicts
-    @o.get_column_value(:foo).must_equal 4
-    @o.set_column_value(:model=, 2).must_equal 2
-    @o.get_column_value(:model).must_equal 2
-  end
-
-  it "should work correctly in subclasses" do
-    @o = Class.new(@c).load(:model=>1, :use_transactions=>2)
-    @o.get_column_value(:model).must_equal 1
-    @o.get_column_value("model").must_equal 1
-    @o.set_column_value(:use_transactions=, 3)
-    @o.get_column_value(:use_transactions).must_equal 3
-    @o.set_column_value(:use_transactions=, 4)
-    @o.get_column_value(:use_transactions).must_equal 4
-  end
-
-  it "should work correctly for dataset changes" do
-    @c.dataset = @db[:test].with_extend{def columns; [:object_id] end}
-    o = @c.load(:object_id=>3)
-    o.get_column_value(:object_id).must_equal 3
-    o.object_id.wont_equal 3
-  end
-
-  it "should freeze column conflict information when freezing model class" do
-    @c.freeze
-    @c.get_column_conflicts.frozen?.must_equal true
-    @c.set_column_conflicts.frozen?.must_equal true
-  end
-end

data/spec/extensions/column_select_spec.rb

@@ -1,129 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::ColumnSelect" do
-  def set_cols(*cols)
-    @cols.replace(cols)
-  end
-
-  before do
-    cols = @cols = []
-    @db = Sequel.mock
-    @db.extend_datasets(Module.new{define_method(:columns){cols}})
-    set_cols :id, :a, :b, :c
-    @Album = Class.new(Sequel::Model(@db[:albums]))
-  end
-
-  it "should add a explicit column selections to existing dataset without explicit selection" do
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
-
-    @Album.dataset = :albs
-    @Album.dataset.sql.must_equal 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
-
-    @Album.dataset = Sequel.identifier(:albs)
-    @Album.dataset.sql.must_equal 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
-  end
-
-  with_symbol_splitting "should handle splittable symbols" do
-    @Album.dataset = :s__albums
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT s.albums.id, s.albums.a, s.albums.b, s.albums.c FROM s.albums'
-
-    @Album.dataset = :albums___a
-    @Album.dataset.sql.must_equal 'SELECT a.id, a.a, a.b, a.c FROM albums AS a'
-
-    @Album.dataset = :s__albums___a
-    @Album.dataset.sql.must_equal 'SELECT a.id, a.a, a.b, a.c FROM s.albums AS a'
-  end
-
-  it "should handle qualified tables" do
-    @Album.dataset = Sequel.qualify(:s2, :albums)
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT s2.albums.id, s2.albums.a, s2.albums.b, s2.albums.c FROM s2.albums'
-  end
-
-  it "should handle aliases" do
-    @Album.plugin :column_select
-    @Album.dataset = Sequel.as(:albums, :b)
-    @Album.dataset.sql.must_equal 'SELECT b.id, b.a, b.b, b.c FROM albums AS b'
-
-    @Album.dataset = @Album.db[:albums].from_self
-    @Album.dataset.sql.must_equal 'SELECT t1.id, t1.a, t1.b, t1.c FROM (SELECT * FROM albums) AS t1'
-
-    @Album.dataset = Sequel.as(@Album.db[:albums], :b)
-    @Album.dataset.sql.must_equal 'SELECT b.id, b.a, b.b, b.c FROM (SELECT * FROM albums) AS b'
-  end
-
-  it "should not add a explicit column selection selection on existing dataset with explicit selection" do
-    @Album.dataset = @Album.dataset.select(:name)
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT name FROM albums'
-
-    @Album.dataset = @Album.dataset.select(:name, :artist)
-    @Album.dataset.sql.must_equal 'SELECT name, artist FROM albums'
-  end
-
-  it "should work with implicit subqueries used for joined datasets" do
-    @Album.dataset = @Album.db.from(:a1, :a2)
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal "SELECT a1.id, a1.a, a1.b, a1.c FROM (SELECT * FROM a1, a2) AS a1"
-
-    @Album.dataset = @Album.db.from(:a1).cross_join(:a2)
-    @Album.dataset.sql.must_equal "SELECT a1.id, a1.a, a1.b, a1.c FROM (SELECT * FROM a1 CROSS JOIN a2) AS a1"
-  end
-
-  it "should add a explicit column selection on existing dataset with a subquery" do
-    @Album.dataset = @Album.db.from(:a1, :a2).from_self(:alias=>:foo)
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT foo.id, foo.a, foo.b, foo.c FROM (SELECT * FROM a1, a2) AS foo'
-
-    @Album.dataset = @Album.db.from(:a1).cross_join(:a2).from_self(:alias=>:foo)
-    @Album.dataset.sql.must_equal 'SELECT foo.id, foo.a, foo.b, foo.c FROM (SELECT * FROM a1 CROSS JOIN a2) AS foo'
-  end
-
-  it "should use explicit column selection for many_to_many associations" do
-    @Album.plugin :column_select
-    @Album.many_to_many :albums, :class=>@Album, :left_key=>:l, :right_key=>:r, :join_table=>:j
-    @Album.load(:id=>1).albums_dataset.sql.must_equal 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums INNER JOIN j ON (j.r = albums.id) WHERE (j.l = 1)'
-  end
-
-  it "should set not explicit column selection for many_to_many associations when overriding select" do
-    @Album.plugin :column_select
-    @Album.dataset = @Album.dataset.select(:a)
-    @Album.many_to_many :albums, :class=>@Album, :left_key=>:l, :right_key=>:r, :join_table=>:j
-    @Album.load(:id=>1).albums_dataset.sql.must_equal 'SELECT albums.* FROM albums INNER JOIN j ON (j.r = albums.id) WHERE (j.l = 1)'
-  end
-
-  it "should use the schema to get columns if available" do
-    def @db.supports_schema_parsing?() true end
-    def @db.schema(t, *)
-      [[:t, {}], [:d, {}]]
-    end
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT albums.t, albums.d FROM albums'
-  end
-
-  it "should handle case where schema parsing does not produce results" do
-    def @db.supports_schema_parsing?() true end
-    def @db.schema_parse_table(t, *) [] end
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
-  end
-
-  it "should handle case where schema parsing and columns does not produce results" do
-    def @db.supports_schema_parsing?() true end
-    def @db.schema_parse_table(t, *) [] end
-    @db.extend_datasets{def columns; raise Sequel::DatabaseError; end}
-    @Album.require_valid_table = false
-    @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT * FROM albums'
-  end
-
-  it "works correctly when loaded on model without a dataset" do
-    c = Class.new(Sequel::Model)
-    c.plugin :column_select
-    sc = Class.new(c)
-    sc.dataset = @db[:a]
-    sc.dataset.sql.must_equal "SELECT a.id, a.a, a.b, a.c FROM a"
-  end
-end

data/spec/extensions/columns_introspection_spec.rb

@@ -1,90 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :columns_introspection
-
-describe "columns_introspection extension" do
-  before do
-    @db = Sequel.mock.extension(:columns_introspection)
-    @ds = @db[:a]
-    @db.sqls
-  end
-
-  it "should not issue a database query if the columns are already loaded" do
-    @ds.send(:columns=, [:x])
-    @ds.columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-  
-  it "should handle plain symbols without a database query" do
-    @ds.select(:x).columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  with_symbol_splitting "should handle qualified symbols without a database query" do
-    @ds.select(:t__x).columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  with_symbol_splitting "should handle aliased symbols without a database query" do
-    @ds.select(:x___a).columns.must_equal [:a]
-    @db.sqls.length.must_equal 0
-  end
-
-  with_symbol_splitting "should handle qualified and aliased symbols without a database query" do
-    @ds.select(:t__x___a).columns.must_equal [:a]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle SQL::Identifiers " do
-    @ds.select(Sequel.identifier(:x)).columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle SQL::QualifiedIdentifiers" do
-    @ds.select(Sequel.qualify(:t, :x)).columns.must_equal [:x]
-    @ds.select(Sequel.identifier(:x).qualify(:t)).columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle SQL::AliasedExpressions" do
-    @ds.select(Sequel.as(:x, :a)).columns.must_equal [:a]
-    @ds.select(Sequel.as(:x, Sequel.identifier(:a))).columns.must_equal [:a]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle selecting * from a single subselect with no joins without a database query if the subselect's columns can be handled" do
-    @ds.select(:x).from_self.columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-    @ds.select(:x).from_self.from_self.columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle selecting * from a single table with no joins without a database query if the database has cached schema columns for the table" do
-    @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
-    @ds.columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should issue a database query for multiple subselects or joins" do
-    @ds.from(@ds.select(:x), @ds.select(:y)).columns
-    @db.sqls.length.must_equal 1
-    @ds.select(:x).from_self.natural_join(:a).columns
-    @db.sqls.length.must_equal 1
-  end
-
-  it "should issue a database query when common table expressions are used" do
-    @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
-    @ds.with_extend{def supports_cte?(*) true end}.with(:a, @ds).columns
-    @db.sqls.length.must_equal 1
-  end
-
-  it "should issue a database query if the wildcard is selected" do
-    @ds.columns
-    @db.sqls.length.must_equal 1
-  end
-
-  it "should issue a database query if an unsupported type is used" do
-    @ds.select(1).columns
-    @db.sqls.length.must_equal 1
-  end
-end

data/spec/extensions/columns_updated_spec.rb

@@ -1,35 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::ColumnsUpdated" do
-  before do
-    @c = Class.new(Sequel::Model(DB[:items].with_autoid(13)))
-    @c.columns :id, :x, :y
-    @c.plugin :columns_updated
-  end
-  
-  it "should make hash used for updating available in columns_updated until after hooks finish running" do
-    res = nil
-    @c.send(:define_method, :after_save){res = columns_updated}
-    o = @c.new(:x => 1, :y => nil)
-    o[:x] = 2
-    o.save
-    res.must_be_nil
-    o.after_save
-    res.must_be_nil
-
-    o = @c.load(:id => 23,:x => 1, :y => nil)
-    o[:x] = 2
-    o.save
-    res.must_equal(:x=>2, :y=>nil)
-    o.after_save
-    res.must_be_nil
-
-    o = @c.load(:id => 23,:x => 2, :y => nil)
-    o[:x] = 2
-    o[:y] = 22
-    o.save(:columns=>:x)
-    res.must_equal(:x=>2)
-    o.after_save
-    res.must_be_nil
-  end
-end

data/spec/extensions/composition_spec.rb

@@ -1,248 +0,0 @@
-require_relative "spec_helper"
-
-describe "Composition plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.plugin :composition
-    @c.columns :id, :year, :month, :day
-    @o = @c.load(:id=>1, :year=>1, :month=>2, :day=>3)
-    DB.reset
-  end
-  
-  it ".composition should add compositions" do
-    @o.wont_respond_to(:date)
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date.must_equal Date.new(1, 2, 3)
-  end
-
-  it "loading the plugin twice should not remove existing compositions" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.plugin :composition
-    @c.compositions.keys.must_equal [:date]
-  end
-
-  it ".composition should raise an error if :composer and :decomposer options are not present and :mapping option is not provided" do
-    proc{@c.composition :date}.must_raise(Sequel::Error)
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.composition :date, :mapping=>[]
-  end
-
-  it "should handle validations of underlying columns" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    o = @c.new
-    def o.validate
-      [:year, :month, :day].each{|c| errors.add(c, "not present") unless send(c)}
-    end
-    o.valid?.must_equal false
-    o.date = Date.new(1, 2, 3)
-    o.valid?.must_equal true
-  end
-
-  it "should have decomposer work with column_conflicts plugin" do
-    @c.plugin :column_conflicts
-    @c.set_column_conflict! :year
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    o = @c.new
-    def o.validate
-      [:year, :month, :day].each{|c| errors.add(c, "not present") unless send(c)}
-    end
-    o.valid?.must_equal false
-    o.date = Date.new(1, 2, 3)
-    o.valid?.must_equal true
-  end
-
-  it "should set column values even when not validating" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.load(id: 1).set(:date=>Date.new(4, 8, 12)).save(:validate=>false)
-    DB.sqls.must_equal ['UPDATE items SET year = 4, month = 8, day = 12 WHERE (id = 1)']
-  end
-
-  it ".compositions should return the reflection hash of compositions" do
-    @c.compositions.must_equal({})
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.compositions.keys.must_equal [:date]
-    r = @c.compositions.values.first
-    r[:mapping].must_equal [:year, :month, :day]
-    r[:composer].must_be_kind_of Proc
-    r[:decomposer].must_be_kind_of Proc
-  end
-
-  it "#compositions should be a hash of cached values of compositions" do
-    @o.compositions.must_equal({})
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date
-    @o.compositions.must_equal(:date=>Date.new(1, 2, 3))
-  end
-
-  it "should work with custom :composer and :decomposer options" do
-    @c.composition :date, :composer=>proc{Date.new(year+1, month+2, day+3)}, :decomposer=>proc{[:year, :month, :day].each{|s| self.send("#{s}=", date.send(s) * 2)}}
-    @o.date.must_equal Date.new(2, 4, 6)
-    @o.save
-    DB.sqls.must_equal ['UPDATE items SET year = 4, month = 8, day = 12 WHERE (id = 1)']
-  end
-
-  it "should allow call super in composition getter and setter method definition in class" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.class_eval do
-      def date
-        super + 1
-      end
-      def date=(v)
-        super(v - 3)
-      end
-    end
-    @o.date.must_equal Date.new(1, 2, 4)
-    @o.compositions[:date].must_equal Date.new(1, 2, 3)
-    @o.date = Date.new(1, 3, 5)
-    @o.compositions[:date].must_equal Date.new(1, 3, 2)
-    @o.date.must_equal Date.new(1, 3, 3)
-  end
-
-  it "should mark the object as modified whenever the composition is set" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.modified?.must_equal false
-    @o.date = Date.new(3, 4, 5)
-    @o.modified?.must_equal true
-  end
-
-  it "should only decompose existing compositions" do
-    called = false
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
-    called.must_equal false
-    @o.save
-    called.must_equal false
-    @o.date = Date.new(1,2,3)
-    called.must_equal false
-    @o.save_changes
-    called.must_equal true
-  end
-
-  it "should clear compositions cache when refreshing" do
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @o.date = Date.new(3, 4, 5)
-    @o.refresh
-    @o.compositions.must_equal({})
-  end
-
-  it "should not clear compositions cache when refreshing after save" do
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.create(:date=>Date.new(3, 4, 5)).compositions.must_equal(:date=>Date.new(3, 4, 5))
-  end
-
-  it "should not clear compositions cache when saving with insert_select" do
-    @c.dataset = @c.dataset.with_extend do
-      def supports_insert_select?; true end
-      def insert_select(*) {:id=>1} end
-    end
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.create(:date=>Date.new(3, 4, 5)).compositions.must_equal(:date=>Date.new(3, 4, 5))
-  end
-
-  it "should instantiate compositions lazily" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.compositions.must_equal({})
-    @o.date
-    @o.compositions.must_equal(:date=>Date.new(1,2,3))
-  end
-
-  it "should cache value of composition" do
-    times = 0
-    @c.composition :date, :composer=>proc{times+=1}, :decomposer=>proc{}
-    times.must_equal 0
-    @o.date
-    times.must_equal 1
-    @o.date
-    times.must_equal 1
-  end
-
-  it ":class option should take an string, symbol, or class" do
-    @c.composition :date1, :class=>'Date', :mapping=>[:year, :month, :day]
-    @c.composition :date2, :class=>:Date, :mapping=>[:year, :month, :day]
-    @c.composition :date3, :class=>Date, :mapping=>[:year, :month, :day]
-    @o.date1.must_equal Date.new(1, 2, 3)
-    @o.date2.must_equal Date.new(1, 2, 3)
-    @o.date3.must_equal Date.new(1, 2, 3)
-  end
-
-  it ":mapping option should work with a single array of symbols" do
-    c = Class.new do
-      def initialize(y, m)
-        @y, @m = y, m
-      end
-      def year
-        @y * 2
-      end
-      def month
-        @m * 3
-      end
-    end
-    @c.composition :date, :class=>c, :mapping=>[:year, :month]
-    @o.date.year.must_equal 2
-    @o.date.month.must_equal 6
-    @o.date = c.new(3, 4)
-    @o.save
-    DB.sqls.must_equal ['UPDATE items SET year = 6, month = 12, day = 3 WHERE (id = 1)']
-  end
-
-  it ":mapping option should work with an array of two pairs of symbols" do
-    c = Class.new do
-      def initialize(y, m)
-        @y, @m = y, m
-      end
-      def y
-        @y * 2
-      end
-      def m
-        @m * 3
-      end
-    end
-    @c.composition :date, :class=>c, :mapping=>[[:year, :y], [:month, :m]]
-    @o.date.y.must_equal 2
-    @o.date.m.must_equal 6
-    @o.date = c.new(3, 4)
-    @o.save
-    DB.sqls.must_equal ['UPDATE items SET year = 6, month = 12, day = 3 WHERE (id = 1)']
-  end
-
-  it ":mapping option :composer should return nil if all values are nil" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.new.date.must_be_nil
-  end
-
-  it ":mapping option :decomposer should set all related fields to nil if nil" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date = nil
-    @o.save
-    DB.sqls.must_equal ['UPDATE items SET year = NULL, month = NULL, day = NULL WHERE (id = 1)']
-  end
-
-  it "should work with frozen instances" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.freeze
-    @o.date.must_equal Date.new(1, 2, 3)
-    proc{@o.date = Date.today}.must_raise
-  end
-
-  it "should have #dup duplicate compositions" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date.must_equal Date.new(1, 2, 3)
-    @o.dup.compositions.must_equal @o.compositions
-    @o.dup.compositions.wont_be_same_as(@o.compositions)
-  end
-
-  it "should work correctly with subclasses" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    c = Class.new(@c)
-    o = c.load(:id=>1, :year=>1, :month=>2, :day=>3)
-    o.date.must_equal Date.new(1, 2, 3)
-    o.save
-    DB.sqls.must_equal ['UPDATE items SET year = 1, month = 2, day = 3 WHERE (id = 1)']
-  end
-
-  it "should freeze composition metadata when freezing model class" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.freeze
-    @c.compositions.frozen?.must_equal true
-    @c.compositions[:date].frozen?.must_equal true
-  end
-end