sequel 4.36.0 → 5.61.0

data/spec/extensions/no_auto_literal_strings_spec.rb

@@ -1,65 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "no_auto_literal_strings extension" do
-  before do
-    @ds = Sequel.mock[:t].extension(:no_auto_literal_strings)
-  end
-
-  it "should raise exception for plain strings in filter methods" do
-    proc{@ds.where("a")}.must_raise Sequel::Error
-    proc{@ds.having("a")}.must_raise Sequel::Error
-    proc{@ds.filter("a")}.must_raise Sequel::Error
-    proc{@ds.exclude_where("a")}.must_raise Sequel::Error
-    proc{@ds.exclude_having("a")}.must_raise Sequel::Error
-    proc{@ds.and("a")}.must_raise Sequel::Error
-    proc{@ds.where(:a).or("a")}.must_raise Sequel::Error
-    proc{@ds.first("a")}.must_raise Sequel::Error
-    proc{@ds.order(:a).last("a")}.must_raise Sequel::Error
-    proc{@ds["a"]}.must_raise Sequel::Error
-  end
-  
-  it "should raise exception for plain strings arrays in filter methods" do
-    proc{@ds.where(["a"])}.must_raise Sequel::Error
-  end
-
-  it "should handle explicit literal strings in filter methods" do
-    @ds.where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
-    @ds.having(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t HAVING (a)'
-    @ds.filter(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
-    @ds.exclude_where(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE NOT (a)'
-    @ds.exclude_having(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t HAVING NOT (a)'
-    @ds.and(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a)'
-    @ds.where(:a).or(Sequel.lit("a")).sql.must_equal 'SELECT * FROM t WHERE (a OR (a))'
-    @ds.first(Sequel.lit("a"))
-    @ds.order(:a).last(Sequel.lit("a"))
-    @ds[Sequel.lit("a")]
-    @ds.db.sqls.must_equal ["SELECT * FROM t WHERE (a) LIMIT 1",
-                            "SELECT * FROM t WHERE (a) ORDER BY a DESC LIMIT 1",
-                            "SELECT * FROM t WHERE (a) LIMIT 1"]
-  end
-  
-  it "should handle literal strings in arrays in filter methods" do
-    @ds.where([Sequel.lit("a")]).sql.must_equal 'SELECT * FROM t WHERE (a)'
-  end
-
-  it "should handle other objects in filter methods" do
-    @ds.where(:a).sql.must_equal 'SELECT * FROM t WHERE a'
-  end
-  
-  it "should raise exception for plain strings in update methods" do
-    proc{@ds.update("a = a + 1")}.must_raise Sequel::Error
-    proc{@ds.update_sql("a = a + 1")}.must_raise Sequel::Error
-  end
-  
-  it "should handle explicit literal strings in update methods" do
-    @ds.update_sql(Sequel.lit("a = a + 1")).must_equal "UPDATE t SET a = a + 1"
-    @ds.update(Sequel.lit("a = a + 1"))
-    @ds.db.sqls.must_equal ["UPDATE t SET a = a + 1"]
-  end
-  
-  it "should handle other objects in update methods" do
-    @ds.update_sql(:a=>:a).must_equal "UPDATE t SET a = a"
-    @ds.update(:a=>:a)
-    @ds.db.sqls.must_equal ["UPDATE t SET a = a"]
-  end
-end

data/spec/extensions/null_dataset_spec.rb

@@ -1,85 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "null_dataset extension" do
-  before do
-    @db = Sequel::mock(:fetch=>{:id=>1}, :autoid=>1, :numrows=>1, :columns=>[:id]).extension(:null_dataset)
-    @ds = @db[:table].nullify
-    @i = 0
-    @pr = proc{|*a| @i += 1}
-  end
-  after do
-    @db.sqls.must_equal [] unless @skip_check
-  end
-
-  it "should make each be a noop" do
-    @ds.each(&@pr).must_be_same_as(@ds)
-    @i.must_equal 0
-  end
-
-  it "should make fetch_rows be a noop" do
-    @ds.fetch_rows("SELECT 1", &@pr).must_equal nil
-    @i.must_equal 0
-  end
-
-  it "should make insert be a noop" do
-    @ds.insert(1).must_equal nil
-  end
-
-  it "should make update be a noop" do
-    @ds.update(:a=>1).must_equal 0
-  end
-
-  it "should make delete be a noop" do
-    @ds.delete.must_equal 0
-  end
-
-  it "should make truncate be a noop" do
-    @ds.truncate.must_equal nil
-  end
-
-  it "should make execute_* be a noop" do
-    @ds.send(:execute_ddl,'FOO').must_equal nil
-    @ds.send(:execute_insert,'FOO').must_equal nil
-    @ds.send(:execute_dui,'FOO').must_equal nil
-    @ds.send(:execute,'FOO').must_equal nil
-  end
-
-  it "should have working columns" do
-    @skip_check = true
-    @ds.columns.must_equal [:id]
-    @db.sqls.must_equal ['SELECT * FROM table LIMIT 1']
-  end
-
-  it "should have count return 0" do
-    @ds.count.must_equal 0
-  end
-
-  it "should have empty return true" do
-    @ds.empty?.must_equal true
-  end
-
-  it "should make import a noop" do
-    @ds.import([:id], [[1], [2], [3]]).must_equal nil
-  end
-
-  it "should have nullify method returned modified receiver" do
-    @skip_check = true
-    ds = @db[:table]
-    ds.nullify.wont_be_same_as(ds)
-    ds.each(&@pr)
-    @db.sqls.must_equal ['SELECT * FROM table']
-    @i.must_equal 1
-  end
-
-  it "should have nullify! method modify receiver" do
-    ds = @db[:table]
-    ds.nullify!.must_be_same_as(ds)
-    ds.each(&@pr)
-    @i.must_equal 0
-  end
-
-  it "should work with method chaining" do
-    @ds.where(:a=>1).select(:b).each(&@pr)
-    @i.must_equal 0
-  end
-end

data/spec/extensions/optimistic_locking_spec.rb

@@ -1,128 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "optimistic_locking plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:people)) do
-    end
-    h = {1=>{:id=>1, :name=>'John', :lock_version=>2}}
-    lv = @lv = "lock_version".dup
-    @c.instance_dataset.numrows = @c.dataset.numrows = proc do |sql|
-      case sql
-      when /UPDATE people SET (name|#{lv}) = ('Jim'|'Bob'|\d+), (?:name|#{lv}) = ('Jim'|'Bob'|\d+) WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
-        name, nlv = $1 == 'name' ? [$2, $3] : [$3, $2]
-        m = h[$4.to_i]
-        if m && m[:lock_version] == $5.to_i
-          m.merge!(:name=>name.gsub("'", ''), :lock_version=>nlv.to_i)
-          1
-        else
-          0
-        end
-      when /UPDATE people SET #{lv} = (\d+) WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
-        m = h[$2.to_i]
-        if m && m[:lock_version] == $3.to_i
-          m.merge!(:lock_version=>$1.to_i)
-          1
-        else
-          0
-        end
-      when /DELETE FROM people WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
-        m = h[$1.to_i]
-        if m && m[lv.to_sym] == $2.to_i
-          h.delete[$1.to_i]
-          1
-        else
-          0
-        end
-      else
-        puts sql
-      end
-    end
-    @c.instance_dataset._fetch = @c.dataset._fetch = proc do |sql|
-      m = h[1].dup
-      v = m.delete(:lock_version)
-      m[lv.to_sym] = v
-      m
-    end
-    @c.columns :id, :name, :lock_version
-    @c.plugin :optimistic_locking
-  end
-
-  it "should raise an error when updating a stale record" do
-    p1 = @c[1]
-    p2 = @c[1]
-    p1.update(:name=>'Jim')
-    proc{p2.update(:name=>'Bob')}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
-  end 
-
-  it "should raise an error when destroying a stale record" do
-    p1 = @c[1]
-    p2 = @c[1]
-    p1.update(:name=>'Jim')
-    proc{p2.destroy}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
-  end 
-
-  it "should not raise an error when updating the same record twice" do
-    p1 = @c[1]
-    p1.update(:name=>'Jim')
-    p1.update(:name=>'Bob')
-  end
-
-  it "should allow changing the lock column via model.lock_column=" do
-    @lv.replace('lv')
-    @c.columns :id, :name, :lv
-    @c.lock_column = :lv
-    p1 = @c[1]
-    p2 = @c[1]
-    p1.update(:name=>'Jim')
-    proc{p2.update(:name=>'Bob')}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
-  end
-
-  it "should allow changing the lock column via plugin option" do
-    @lv.replace('lv')
-    @c.columns :id, :name, :lv
-    @c.plugin :optimistic_locking, :lock_column=>:lv
-    p1 = @c[1]
-    p2 = @c[1]
-    p1.update(:name=>'Jim')
-    proc{p2.destroy}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
-  end
-
-  it "should work when subclassing" do
-    c = Class.new(@c)
-    p1 = c[1]
-    p2 = c[1]
-    p1.update(:name=>'Jim')
-    proc{p2.update(:name=>'Bob')}.must_raise(Sequel::Plugins::OptimisticLocking::Error)
-  end
-
-  it "should work correctly if attempting to refresh and save again after a failed save" do
-    p1 = @c[1]
-    p2 = @c[1]
-    p1.update(:name=>'Jim')
-    begin
-      p2.update(:name=>'Bob')
-    rescue Sequel::Plugins::OptimisticLocking::Error
-      p2.refresh
-      @c.db.sqls
-      p2.update(:name=>'Bob')
-    end
-    @c.db.sqls.first.must_match(/UPDATE people SET (name = 'Bob', lock_version = 4|lock_version = 4, name = 'Bob') WHERE \(\(id = 1\) AND \(lock_version = 3\)\)/)
-  end
-
-  it "should increment the lock column when #modified! even if no columns are changed" do
-    p1 = @c[1]
-    p1.modified!
-    lv = p1.lock_version
-    p1.save_changes
-    p1.lock_version.must_equal lv + 1
-  end
-
-  it "should not increment the lock column when the update fails" do
-    @c.instance_dataset.meta_def(:update) {|_| raise }
-    p1 = @c[1]
-    p1.modified!
-    lv = p1.lock_version
-    proc{p1.save_changes}.must_raise(RuntimeError)
-    p1.lock_version.must_equal lv
-  end
-end

data/spec/extensions/pagination_spec.rb

@@ -1,118 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "A paginated dataset" do
-  before do
-    @d = Sequel.mock.dataset.extension(:pagination)
-    @d.meta_def(:count) {153}
-    
-    @paginated = @d.paginate(1, 20)
-  end
-  
-  it "should raise an error if the dataset already has a limit" do
-    proc{@d.limit(10).paginate(1,10)}.must_raise(Sequel::Error)
-    proc{@paginated.paginate(2,20)}.must_raise(Sequel::Error)
-    proc{@d.limit(10).each_page(10){|ds|}}.must_raise(Sequel::Error)
-    proc{@d.limit(10).each_page(10)}.must_raise(Sequel::Error)
-  end
-  
-  it "should set the limit and offset options correctly" do
-    @paginated.opts[:limit].must_equal 20
-    @paginated.opts[:offset].must_equal 0
-  end
-  
-  it "should set the page count correctly" do
-    @paginated.page_count.must_equal 8
-    @d.paginate(1, 50).page_count.must_equal 4
-
-    @d.meta_def(:count) {0}
-    @d.paginate(1, 50).page_count.must_equal 1
-  end
-  
-  it "should set the current page number correctly" do
-    @paginated.current_page.must_equal 1
-    @d.paginate(3, 50).current_page.must_equal 3
-  end
-  
-  it "should return the next page number or nil if we're on the last" do
-    @paginated.next_page.must_equal 2
-    @d.paginate(4, 50).next_page.must_equal nil
-  end
-  
-  it "should return the previous page number or nil if we're on the first" do
-    @paginated.prev_page.must_equal nil
-    @d.paginate(4, 50).prev_page.must_equal 3
-  end
-  
-  it "should return the page range" do
-    @paginated.page_range.must_equal(1..8)
-    @d.paginate(4, 50).page_range.must_equal(1..4)
-  end
-  
-  it "should return the record range for the current page" do
-    @paginated.current_page_record_range.must_equal(1..20)
-    @d.paginate(4, 50).current_page_record_range.must_equal(151..153)
-    @d.paginate(5, 50).current_page_record_range.must_equal(0..0)
-  end
-
-  it "should return the record count for the current page" do
-    @paginated.current_page_record_count.must_equal 20
-    @d.paginate(3, 50).current_page_record_count.must_equal 50
-    @d.paginate(4, 50).current_page_record_count.must_equal 3
-    @d.paginate(5, 50).current_page_record_count.must_equal 0
-  end
-
-  it "should know if current page is last page" do
-    @paginated.last_page?.must_equal false
-    @d.paginate(2, 20).last_page?.must_equal false
-    @d.paginate(5, 30).last_page?.must_equal false
-    @d.paginate(6, 30).last_page?.must_equal true
-
-    @d.meta_def(:count) {0}
-    @d.paginate(1, 30).last_page?.must_equal true
-    @d.paginate(2, 30).last_page?.must_equal false
-  end
-
-  it "should know if current page is first page" do
-    @paginated.first_page?.must_equal true
-    @d.paginate(1, 20).first_page?.must_equal true
-    @d.paginate(2, 20).first_page?.must_equal false
-  end
-
-  it "should work with fixed sql" do
-    ds = @d.clone(:sql => 'select * from blah')
-    ds.meta_def(:count) {150}
-    ds.paginate(2, 50).sql.must_equal 'SELECT * FROM (select * from blah) AS t1 LIMIT 50 OFFSET 50'
-  end
-end
-
-describe "Dataset#each_page" do
-  before do
-    @d = Sequel.mock.dataset.from(:items).extension(:pagination)
-    @d.meta_def(:count) {153}
-  end
-  
-  it "should raise an error if the dataset already has a limit" do
-    proc{@d.limit(10).each_page(10){}}.must_raise(Sequel::Error)
-  end
-  
-  it "should iterate over each page in the resultset as a paginated dataset" do
-    a = []
-    @d.each_page(50) {|p| a << p}
-    a.map {|p| p.sql}.must_equal [
-      'SELECT * FROM items LIMIT 50 OFFSET 0',
-      'SELECT * FROM items LIMIT 50 OFFSET 50',
-      'SELECT * FROM items LIMIT 50 OFFSET 100',
-      'SELECT * FROM items LIMIT 50 OFFSET 150',
-    ]
-  end
-
-  it "should return an enumerator if no block is given" do
-    enum = @d.each_page(50)
-    enum.map {|p| p.sql}.must_equal [
-      'SELECT * FROM items LIMIT 50 OFFSET 0',
-      'SELECT * FROM items LIMIT 50 OFFSET 50',
-      'SELECT * FROM items LIMIT 50 OFFSET 100',
-      'SELECT * FROM items LIMIT 50 OFFSET 150',
-    ]
-  end
-end