sequel 5.28.0 → 5.33.0

data/spec/core_model_spec.rb

@@ -1,2 +0,0 @@
-require_relative 'core_spec'
-require_relative 'model_spec'

data/spec/core_spec.rb

@@ -1 +0,0 @@
-Dir['./spec/core/*_spec.rb'].each{|f| require f}

data/spec/deprecation_helper.rb

@@ -1,30 +0,0 @@
-Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
-
-class Minitest::HooksSpec
-  def self.deprecated(a, &block)
-    it("#{a} (deprecated)") do
-      deprecated{instance_exec(&block)}
-    end
-  end
-
-  def deprecated
-    output = Sequel::Deprecation.output
-    Sequel::Deprecation.output = nil
-    yield
-  ensure
-    Sequel::Deprecation.output = output
-  end
-
-  def self.with_symbol_splitting(a, &block)
-    it("#{a}, with symbol splitting enabled") do
-      with_symbol_splitting{instance_exec(&block)}
-    end
-  end
-
-  def with_symbol_splitting
-    Sequel.split_symbols = true
-    yield
-  ensure
-    Sequel.split_symbols = false
-  end
-end

data/spec/extensions/accessed_columns_spec.rb

@@ -1,51 +0,0 @@
-require_relative "spec_helper"
-
-describe "accessed_columns plugin" do
-  before do
-    @db = Sequel.mock(:fetch=>{:name=>'a', :b=>'c'}, :numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @c.columns :name, :b
-    @c.plugin :accessed_columns
-    @o = @c.new
-  end
-
-  it "should record columns accessed" do
-    @o.accessed_columns.must_equal []
-    @o.name
-    @o.accessed_columns.must_equal [:name]
-    @o.name
-    @o.accessed_columns.must_equal [:name]
-    @o.b
-    @o.accessed_columns.sort_by{|s| s.to_s}.must_equal [:b, :name]
-  end
-
-  it "should clear accessed columns when refreshing" do
-    @o.name
-    @o.refresh
-    @o.accessed_columns.must_equal []
-  end
-
-  it "should clear accessed columns when saving" do
-    @o.name
-    @o.save
-    @o.accessed_columns.must_equal []
-  end
-
-  it "should work when duping and cloning instances" do
-    @o.name
-    o = @o.dup
-    @o.accessed_columns.must_equal [:name]
-    @o.b
-    @o.accessed_columns.sort_by{|s| s.to_s}.must_equal [:b, :name]
-    o.accessed_columns.must_equal [:name]
-    o2 = o.clone
-    o2.refresh
-    o.accessed_columns.must_equal [:name]
-    o2.accessed_columns.must_equal []
-  end
-
-  it "should not raise exceptions when object is frozen" do
-    @o.freeze
-    @o.name
-  end
-end

data/spec/extensions/active_model_spec.rb

@@ -1,99 +0,0 @@
-require_relative "spec_helper"
-
-begin
-  require 'active_model'
-rescue LoadError
-  warn "Skipping test of active_model plugin: can't load active_model"
-else
-describe "ActiveModel plugin" do
-  before do
-    class ::AMLintTest < Sequel::Model
-      set_primary_key :id
-      columns :id, :id2
-      def delete; end
-    end
-    module ::Blog
-      class Post < Sequel::Model
-         plugin :active_model
-      end
-    end
-    @c = AMLintTest
-    @c.plugin :active_model
-    @c.freeze if @freeze_class
-    @m = @model = @c.new
-    @o = @c.load({})
-  end
-  after do
-    Object.send(:remove_const, :AMLintTest)
-    Object.send(:remove_const, :Blog)
-  end
-
-  it ".to_model should return self, not a proxy object" do
-    @m.object_id.must_equal @m.to_model.object_id
-  end
-  
-  it "#to_key should return a key array, or nil" do
-    @o.to_key.must_be_nil
-    @o.id = 1
-    @o.to_key.must_equal [1]
-    @o.id = nil
-    @o.to_key.must_be_nil
-
-    @c.set_primary_key [:id2, :id]
-    @c.freeze
-    @o.to_key.must_be_nil
-    @o.id = 1
-    @o.id2 = 2
-    @o.to_key.must_equal [2, 1]
-    @o.destroy
-    @o.to_key.must_equal [2, 1]
-    @o.id = nil
-    @o.to_key.must_be_nil
-  end
-  
-  it "#to_param should return a param string or nil" do
-    @o.to_param.must_be_nil
-    @o.id = 1
-    @o.to_param.must_equal '1'
-    @c.set_primary_key [:id2, :id]
-    @c.freeze
-    @o.id2 = 2
-    @o.to_param.must_equal '2-1'
-    def @o.to_param_joiner; '|' end
-    @o.to_param.must_equal '2|1'
-    @o.destroy
-    @o.to_param.must_be_nil
-  end
-
-  it "#persisted? should return true if the object exists and has not been destroyed" do
-    @m.persisted?.must_equal false
-    @o.persisted?.must_equal true
-    @m.destroy
-    @o.destroy
-    @m.persisted?.must_equal false
-    @o.persisted?.must_equal false
-  end
-
-  it "#persisted? should return false if the object is created and the transaction is rolled back" do
-    DB.transaction(:rollback=>:always){@m.save}
-    @m.persisted?.must_equal false
-  end
-
-  it "#to_partial_path should return a path string" do
-    @m.to_partial_path.must_equal 'am_lint_tests/am_lint_test'
-    Blog::Post.new.to_partial_path.must_equal 'blog/posts/post'
-  end
-
-  describe "with unfrozen model class" do
-    include ActiveModel::Lint::Tests
-  end
-
-  describe "with frozen model class" do
-    before do
-      @freeze_class = true
-    end
-
-    include ActiveModel::Lint::Tests
-  end
-end
-end 

data/spec/extensions/after_initialize_spec.rb

@@ -1,28 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::AfterInitialize" do
-  before do
-    @db = Sequel.mock(:host=>'mysql', :numrows=>1)
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @c.class_eval do
-      columns :id, :name
-      plugin :after_initialize
-      def after_initialize
-        self.name *= 2
-        self.id *= 3 if id
-      end
-    end
-  end
-
-  it "should have after_initialize hook be called for new objects" do
-    @c.new(:name=>'foo').values.must_equal(:name=>'foofoo')
-  end
-
-  it "should have after_initialize hook be called for objects loaded from the database" do
-    @c.call(:id=>1, :name=>'foo').values.must_equal(:id=>3, :name=>'foofoo')
-  end
-
-  it "should not allow .call to be called without arguments" do
-    proc{@c.call}.must_raise ArgumentError
-  end
-end

data/spec/extensions/any_not_empty_spec.rb

@@ -1,23 +0,0 @@
-require_relative "spec_helper"
-
-describe "any_not_empty extension" do
-  before do
-    @ds = Sequel.mock[:t].extension(:any_not_empty)
-  end
-
-  it "should use a limited query if no block is given" do
-    @ds.with_fetch(:one=>1).any?.must_equal true
-    @ds.db.sqls.must_equal ["SELECT 1 AS one FROM t LIMIT 1"]
-    @ds.with_fetch([]).any?.must_equal false
-    @ds.db.sqls.must_equal ["SELECT 1 AS one FROM t LIMIT 1"]
-  end
-
-  it "should use default behavior if block is given" do
-    @ds.with_fetch(:one=>1).any?{|x| x[:one] == 1}.must_equal true
-    @ds.db.sqls.must_equal ["SELECT * FROM t"]
-    @ds.with_fetch(:one=>1).any?{|x| x[:one] != 1}.must_equal false
-    @ds.db.sqls.must_equal ["SELECT * FROM t"]
-    @ds.with_fetch([]).any?{|x| x[:one] == 1}.must_equal false
-    @ds.db.sqls.must_equal ["SELECT * FROM t"]
-  end
-end

data/spec/extensions/arbitrary_servers_spec.rb

@@ -1,109 +0,0 @@
-require_relative "spec_helper"
-
-describe "arbtirary servers" do
-  before do
-    @db = Sequel.mock(:servers=>{})
-    @db.extension :arbitrary_servers
-  end
-
-  it "should allow arbitrary server options using a hash" do
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      c.opts[:host].must_equal 'host1'
-      c.opts[:database].must_equal 'db1'
-    end
-  end
-
-  it "should not cache connections to arbitrary servers" do
-    x = nil
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      x = c
-    end
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-      c2.wont_be_same_as(x)
-    end
-  end
-
-  it "should yield same connection correctly when nesting" do
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-        c2.must_be_same_as(c)
-      end
-    end
-  end
-
-  it "should disconnect when connection is finished" do
-    x, x1 = nil, nil
-    @db.define_singleton_method(:disconnect_connection){|c| x = c}
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      x1 = c
-      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-        c2.must_be_same_as(c)
-      end
-      x.must_be_same_as(nil)
-    end
-    x.must_be_same_as(x1)
-  end
-
-  it "should yield different connection correctly when nesting" do
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      c.opts[:host].must_equal 'host1'
-      @db.synchronize(:host=>'host2', :database=>'db1') do |c2|
-        c2.opts[:host].must_equal 'host2'
-        c2.wont_be_same_as(c)
-      end
-    end
-  end
-
-  it "should respect multithreaded access" do
-    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      Thread.new do
-        @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-          _(c2).wont_be_same_as(c)
-        end
-      end.join
-    end
-  end
-
-  it "should work correctly with server_block plugin" do
-    @db.extension :server_block
-    @db.with_server(:host=>'host1', :database=>'db1') do
-      @db.synchronize do |c|
-        c.opts[:host].must_equal 'host1'
-        c.opts[:database].must_equal 'db1'
-        @db.synchronize do |c2|
-          c2.must_be_same_as(c)
-        end
-      end
-    end
-  end
-
-  it "should respect multithreaded access with server block plugin" do
-    @db.extension :server_block
-    q, q1 = Queue.new, Queue.new
-    
-    t = nil
-    @db[:t].all
-    @db.with_server(:host=>'a') do
-      @db[:t].all
-      t = Thread.new do
-        @db[:t].all
-        @db.with_server(:host=>'c') do
-          @db[:t].all
-          @db.with_server(:host=>'d'){@db[:t].all}
-          q.push nil
-          q1.pop
-          @db[:t].all
-        end
-        @db[:t].all
-      end
-      q.pop
-      @db.with_server(:host=>'b'){@db[:t].all}
-      @db[:t].all
-    end
-    @db[:t].all
-    q1.push nil
-    t.join
-    @db.sqls.must_equal ['SELECT * FROM t', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t -- {:host=>"d"}',
-      'SELECT * FROM t -- {:host=>"b"}', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t']
-  end
-end

data/spec/extensions/association_dependencies_spec.rb

@@ -1,125 +0,0 @@
-require_relative "spec_helper"
-
-describe "AssociationDependencies plugin" do
-  before do
-    @mods = []
-    @c = Class.new(Sequel::Model)
-    @c.plugin :association_dependencies
-    @Artist = Class.new(@c).set_dataset(:artists)
-    @Artist.dataset = @Artist.dataset.with_fetch(:id=>2, :name=>'Ar')
-    @Album = Class.new(@c).set_dataset(:albums)
-    @Album.dataset = @Album.dataset.with_fetch(:id=>1, :name=>'Al', :artist_id=>2)
-    @Artist.columns :id, :name
-    @Album.columns :id, :name, :artist_id
-    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
-    @Artist.one_to_one :first_album, :class=>@Album, :key=>:artist_id, :conditions=>{:position=>1}
-    @Artist.many_to_many :other_artists, :class=>@Artist, :join_table=>:aoa, :left_key=>:l, :right_key=>:r
-    @Album.many_to_one :artist, :class=>@Artist
-    DB.reset
-  end
-
-  it "should allow destroying associated many_to_one associated object" do
-    @Album.add_association_dependencies :artist=>:destroy
-    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow deleting associated many_to_one associated object" do
-    @Album.add_association_dependencies :artist=>:delete
-    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE (artists.id = 2)']
-  end
-  
-  it "should allow destroying associated one_to_one associated object" do
-    @Artist.add_association_dependencies :first_album=>:destroy
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['SELECT * FROM albums WHERE ((position = 1) AND (albums.artist_id = 2)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow deleting associated one_to_one associated object" do
-    @Artist.add_association_dependencies :first_album=>:delete
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE ((position = 1) AND (albums.artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow destroying associated one_to_many objects" do
-    @Artist.add_association_dependencies :albums=>:destroy
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow deleting associated one_to_many objects" do
-    @Artist.add_association_dependencies :albums=>:delete
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
-  end
-  
-  it "should allow nullifying associated one_to_one objects" do
-    @Artist.add_association_dependencies :first_album=>:nullify
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['UPDATE albums SET artist_id = NULL WHERE ((position = 1) AND (artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow nullifying associated one_to_many objects" do
-    @Artist.add_association_dependencies :albums=>:nullify
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should allow nullifying associated many_to_many associations" do
-    @Artist.add_association_dependencies :other_artists=>:nullify
-    @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.must_equal ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should not allow modifications if class is frozen" do
-    @Artist.add_association_dependencies :other_artists=>:nullify
-    @Artist.freeze
-    proc{@Artist.add_association_dependencies :albums=>:nullify}.must_raise RuntimeError, TypeError
-    @Artist.association_dependencies.frozen?.must_equal true
-    @Artist.association_dependencies[:before_nullify].frozen?.must_equal true
-  end
-
-  it "should raise an error if attempting to nullify a many_to_one association" do
-    proc{@Album.add_association_dependencies :artist=>:nullify}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if using an unrecognized dependence action" do
-    proc{@Album.add_association_dependencies :artist=>:blah}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if a nonexistent association is used" do
-    proc{@Album.add_association_dependencies :blah=>:delete}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if a invalid association type is used" do
-    @Artist.plugin :many_through_many
-    @Artist.many_through_many :other_albums, [[:id, :id, :id]]
-    proc{@Artist.add_association_dependencies :other_albums=>:nullify}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if using a many_to_many association type without nullify" do
-    proc{@Artist.add_association_dependencies :other_artists=>:delete}.must_raise(Sequel::Error)
-  end
-
-  it "should allow specifying association dependencies in the plugin call" do
-    @Album.plugin :association_dependencies, :artist=>:destroy
-    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
-  end
-
-  it "should work with subclasses" do
-    c = Class.new(@Album)
-    c.add_association_dependencies :artist=>:destroy
-    c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
-
-    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1']
-
-    @Album.add_association_dependencies :artist=>:destroy
-    c2 = Class.new(@Album)
-    c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
-  end
-end