sequel 5.20.0 → 5.49.0

data/spec/extensions/null_dataset_spec.rb

@@ -1,85 +0,0 @@
-require_relative "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_be_nil
-    @i.must_equal 0
-  end
-
-  it "nullify should be a cached dataset" do
-    ds = @db[:table]
-    ds.nullify.object_id.must_equal(ds.nullify.object_id)
-  end
-
-  it "should make insert be a noop" do
-    @ds.insert(1).must_be_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_be_nil
-  end
-
-  it "should make execute_* be a noop" do
-    @ds.send(:execute_ddl,'FOO').must_be_nil
-    @ds.send(:execute_insert,'FOO').must_be_nil
-    @ds.send(:execute_dui,'FOO').must_be_nil
-    @ds.send(:execute,'FOO').must_be_nil
-  end
-
-  it "should have working columns" do
-    @skip_check = true
-    2.times do
-      @ds.columns.must_equal [:id]
-    end
-    @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_be_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 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,127 +0,0 @@
-require_relative "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.dataset = @c.dataset.with_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).with_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.must_equal ["UPDATE people SET name = 'Bob', lock_version = 4 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.dataset = @c.dataset.with_extend{def update(_) raise end}
-    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,116 +0,0 @@
-require_relative "spec_helper"
-
-describe "A paginated dataset" do
-  before do
-    count = @count = [153]
-    @d = Sequel.mock.dataset.extension(:pagination).with_extend{define_method(:count){count.first}}
-    @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
-
-    @count[0] = 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_be_nil
-  end
-  
-  it "should return the previous page number or nil if we're on the first" do
-    @paginated.prev_page.must_be_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
-
-    @count[0] = 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')
-    @count[0] = 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[:items].extension(:pagination).with_extend{def count; 153 end}
-  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