sequel 3.28.0 → 3.29.0

data/spec/core/spec_helper.rb

@@ -10,93 +10,6 @@ if ENV['SEQUEL_COLUMNS_INTROSPECTION']
   Sequel::Dataset.introspect_all_columns
 end
 
-class MockDataset < Sequel::Dataset
-  def insert(*args)
-    @db.execute insert_sql(*args)
-  end
-  
-  def update(*args)
-    @db.execute update_sql(*args)
-  end
-  
-  def fetch_rows(sql)
-    @db.execute(sql)
-    yield({:id => 1, :x => 1})
-  end
-
-  def quoted_identifier(c)
-    "\"#{c}\""
-  end
-end
-
-class MockDatabase < Sequel::Database
-  set_adapter_scheme :mock
-  @@quote_identifiers = false
-  self.identifier_input_method = nil
-  self.identifier_output_method = nil
-  attr_reader :sqls
-  
-  def execute(sql, opts={})
-    @sqls ||= []
-    @sqls << sql
-  end
-
-  def reset
-    @sqls = []
-  end
-
-  def transaction(opts={}); yield; end
-  
-  def dataset; MockDataset.new(self); end
-end
-
-class SchemaDummyDatabase < Sequel::Database
-  attr_reader :sqls
-  self.identifier_input_method = nil
-  self.identifier_output_method = nil
-  
-  def execute(sql, opts={})
-    @sqls ||= []
-    @sqls << sql
-  end
-end
-
-class DummyDataset < Sequel::Dataset
-  def first
-    raise if @opts[:from] == [:a]
-    true
-  end
-end
-
-class DummyDatabase < Sequel::Database
-  attr_reader :sqls
-  
-  def execute(sql, opts={})
-    @sqls ||= []
-    @sqls << sql
-  end
-  
-  def transaction; yield; end
-
-  def dataset
-    DummyDataset.new(self)
-  end
-end
-
-class Dummy2Database < Sequel::Database
-  attr_reader :sql
-  def execute(sql); @sql = sql; end
-  def transaction; yield; end
-end
-
-class DummyDataset < Sequel::Dataset
-  VALUES = [
-    {:a => 1, :b => 2},
-    {:a => 3, :b => 4},
-    {:a => 5, :b => 6}
-  ]
-  def fetch_rows(sql, &block)
-    VALUES.each(&block)
-  end
-end
-
+Sequel.quote_identifiers = false
+Sequel.identifier_input_method = nil
+Sequel.identifier_output_method = nil

data/spec/extensions/class_table_inheritance_spec.rb

@@ -8,7 +8,7 @@ describe "class_table_inheritance plugin" do
        :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}]],
        :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
        :staff=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
-       }[table]
+       }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
      end
     def db.dataset(*args)
       ds = super(*args)

data/spec/extensions/dataset_associations_spec.rb

@@ -0,0 +1,199 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DatasetAssociations" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.columns :id, :name
+    @Album.columns :id, :name, :artist_id
+    @Tag.columns :id, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album
+    @Artist.one_to_one :first_album, :class=>@Album
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag
+    @Tag.many_to_many :albums, :class=>@Album
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    ds = @Album.artists
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    ds = @Artist.albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    ds = @Artist.first_albums
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Album
+    ds.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    ds = @Album.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should work for many_through_many associations" do
+    ds = @Artist.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
+  end
+
+  it "should have an associated method that takes an association symbol" do
+    ds = @Album.associated(:artist)
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
+  end
+
+  it "should raise an Error if an invalid association is given to associated" do
+    proc{@Album.associated(:foo)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an Error if an unrecognized association type is used" do
+    @Album.association_reflection(:artist)[:type] = :foo
+    proc{@Album.artists}.should raise_error(Sequel::Error)
+  end
+
+  it "should work correctly when chaining" do
+    ds = @Artist.albums.tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM albums INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
+  end
+
+  it "should deal correctly with filters before the association method" do
+    @Artist.filter(:id=>1).albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists WHERE (id = 1)))"
+  end
+
+  it "should deal correctly with filters after the association method" do
+    @Artist.albums.filter(:id=>1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with block on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums do |ds| ds.filter(:id=>1..100) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :conditions option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :conditions=>{:id=>1..100}
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :distinct option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :distinct=>true
+    @Artist.albums.sql.should == "SELECT DISTINCT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+
+  it "should deal correctly with :eager option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager=>:tags
+    @Artist.albums.opts[:eager].should == {:tags=>nil}
+  end
+
+  it "should deal correctly with :eager_block option on the association, ignoring the association block" do
+    @Artist.one_to_many :albums, :clone=>:albums, :eager_block=>proc{|ds| ds.filter(:id=>1..100)} do |ds| ds.filter(:id=>2..200) end
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
+  end
+
+  it "should deal correctly with :extend option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :extend=>Module.new{def foo(x) filter(:id=>x) end}
+    @Artist.albums.foo(1).sql.should == "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
+  end
+
+  it "should deal correctly with :order option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :order=>:name
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists)) ORDER BY name"
+  end
+
+  it "should deal correctly with :select option on the association" do
+    @Artist.one_to_many :albums, :clone=>:albums, :select=>[:id, :name]
+    @Artist.albums.sql.should == "SELECT id, name FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
+  end
+end
+
+describe "Sequel::Plugins::DatasetAssociations with composite keys" do
+  before do
+    @db = Sequel::Database.new
+    @Base = Class.new(Sequel::Model)
+    @Base.plugin :dataset_associations
+
+    @Artist = Class.new(@Base)
+    @Album = Class.new(@Base)
+    @Tag = Class.new(@Base)
+
+    @Artist.meta_def(:name){'Artist'}
+    @Album.meta_def(:name){'Album'}
+    @Tag.meta_def(:name){'Tag'}
+
+    @Artist.dataset = @db[:artists]
+    @Album.dataset = @db[:albums]
+    @Tag.dataset = @db[:tags]
+
+    @Artist.set_primary_key([:id1, :id2])
+    @Album.set_primary_key([:id1, :id2])
+    @Tag.set_primary_key([:id1, :id2])
+
+    @Artist.columns :id1, :id2, :name
+    @Album.columns :id1, :id2, :name, :artist_id1, :artist_id2
+    @Tag.columns :id1, :id2, :name
+
+    @Artist.plugin :many_through_many
+    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Artist.one_to_one :first_album, :class=>@Album, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id1, :artist_id2]
+    @Album.many_to_many :tags, :class=>@Tag, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
+    @Tag.many_to_many :albums, :class=>@Album, :right_key=>[:album_id1, :album_id2], :left_key=>[:tag_id1, :tag_id2]
+    @Artist.many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :class=>@Tag
+  end
+
+  it "should work for many_to_one associations" do
+    @Album.artists.sql.should == "SELECT * FROM artists WHERE ((artists.id1, artists.id2) IN (SELECT albums.artist_id1, albums.artist_id2 FROM albums))"
+  end
+
+  it "should work for one_to_many associations" do
+    @Artist.albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for one_to_one associations" do
+    @Artist.first_albums.sql.should == "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
+  end
+
+  it "should work for many_to_many associations" do
+    @Album.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work for many_through_many associations" do
+    @Artist.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2))))"
+  end
+
+  it "should work correctly when chaining" do
+    @Artist.albums.tags.sql.should == "SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM albums INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))"
+  end
+end

data/spec/extensions/instance_hooks_spec.rb

@@ -177,3 +177,74 @@ describe "InstanceHooks plugin" do
     @r.should == [2, 1, 4, 3]
   end
 end
+
+describe "InstanceHooks plugin with transactions" do
+  before do
+    @logger = Object.new
+    def @logger.method_missing(meth, sql)
+      (@sqls ||= []) << sql
+    end
+    def @logger.sqls
+      @sqls
+    end
+    @db = Class.new(Sequel::Database) do
+      def connect(*)
+        Object.new
+      end
+      def log_connection_execute(conn, sql)
+        execute(sql)
+      end
+      def execute(sql, opts={})
+        @loggers.each{|l| l.info(sql)}
+      end
+    end.new(:loggers=>[@logger])
+    pr = proc{|x| r(x)}
+    @c = Class.new(Sequel::Model(@db[:items])) do
+      attr_accessor :rb
+      def _delete
+      end
+      def after_save
+        db.execute('as')
+        raise Sequel::Rollback if rb
+      end
+      def after_destroy
+        db.execute('ad')
+        raise Sequel::Rollback if rb
+      end
+    end
+    @c.use_transactions = true
+    @c.plugin :instance_hooks
+    @o = @c.load({:id=>1})
+    @or = @c.load({:id=>1})
+    @or.rb = true
+    @r = []
+  end
+  
+  it "should support after_commit_hook" do
+    @o.after_commit_hook{@db.execute('ac1')}
+    @o.after_commit_hook{@db.execute('ac2')}
+    @o.save.should_not be_nil
+    @logger.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac1', 'ac2']
+  end
+  
+  it "should support after_rollback_hook" do
+    @or.after_rollback_hook{@db.execute('ar1')}
+    @or.after_rollback_hook{@db.execute('ar2')}
+    @or.save.should be_nil
+    @logger.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar1', 'ar2']
+  end
+  
+  it "should support after_commit_hook" do
+    @o.after_destroy_commit_hook{@db.execute('adc1')}
+    @o.after_destroy_commit_hook{@db.execute('adc2')}
+    @o.destroy.should_not be_nil
+    @logger.sqls.should == ['BEGIN', 'ad', 'COMMIT', 'adc1', 'adc2']
+  end
+  
+  it "should support after_rollback_hook" do
+    @or.after_destroy_rollback_hook{@db.execute('adr1')}
+    @or.after_destroy_rollback_hook{@db.execute('adr2')}
+    @or.destroy.should be_nil
+    @logger.sqls.should == ['BEGIN', 'ad', 'ROLLBACK', 'adr1', 'adr2']
+  end
+end

data/spec/extensions/named_timezones_spec.rb

@@ -66,8 +66,28 @@ describe "Sequel named_timezones extension" do
   end
   
   it "should work with the thread_local_timezones extension" do
-    [Thread.new{Sequel.thread_application_timezone = 'America/New_York'; sleep 0.03; Sequel.application_timezone.should == @tz_out},
-     Thread.new{sleep 0.01; Sequel.thread_application_timezone = 'America/Los_Angeles'; sleep 0.01; Sequel.application_timezone.should == @tz_in}].each{|x| x.join}
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
+    tz1, tz2 = nil, nil
+    t1 = Thread.new do
+      Sequel.thread_application_timezone = 'America/New_York'
+      q2.push nil
+      q.pop
+      tz1 = Sequel.application_timezone
+    end
+    t2 = Thread.new do
+      Sequel.thread_application_timezone = 'America/Los_Angeles'
+      q2.push nil
+      q1.pop
+      tz2 = Sequel.application_timezone
+    end
+    q2.pop
+    q2.pop
+    q.push nil
+    q1.push nil
+    t1.join
+    t2.join
+    tz1.should == @tz_out
+    tz2.should == @tz_in
   end
 end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -29,6 +29,9 @@ describe "NestedAttributes plugin" do
       end
     end
     db = Sequel::Database.new({})
+    def db.connect(opts)
+      Object.new
+    end
     db.meta_def(:dataset) do |*a|
       x = super(*a)
       x.extend(ds_mod)

data/spec/extensions/schema_spec.rb

@@ -57,7 +57,7 @@ describe Sequel::Model, "create_table and schema" do
 
   it "should reload the schema from the database" do
     schem = {:name=>{:type=>:string}, :price=>{:type=>:float}}
-    @model.db.should_receive(:schema).with(:items, :reload=>true).and_return(schem.to_a.sort_by{|x| x[0].to_s})
+    @model.db.should_receive(:schema).with(@model.dataset, :reload=>true).and_return(schem.to_a.sort_by{|x| x[0].to_s})
     @model.create_table
     @model.db_schema.should == schem
     @model.instance_variable_get(:@columns).should == [:name, :price]

data/spec/extensions/serialization_modification_detection_spec.rb

@@ -1,4 +1,5 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require 'yaml'
 
 describe "serialization_modification_detection plugin" do
   before do

data/spec/extensions/serialization_spec.rb

@@ -22,11 +22,11 @@ describe "Serialization plugin" do
   it "should allow setting additional serializable attributes via plugin :serialization call" do
     @c.plugin :serialization, :yaml, :abc
     @c.create(:abc => 1, :def=> 2)
-    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 2|2, '--- 1\n')\)/
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 2|2, '--- 1\n(\.\.\.\n)?')\)/
 
     @c.plugin :serialization, :marshal, :def
     @c.create(:abc => 1, :def=> 1)
-    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n')\)/
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n(\.\.\.\n)?')\)/
     
     @c.plugin :serialization, :json, :ghi
     @c.create(:ghi => [123])
@@ -38,10 +38,7 @@ describe "Serialization plugin" do
     @c.create(:abc => 1)
     @c.create(:abc => "hello")
 
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
-      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
-    ]
+    MODEL_DB.sqls.map{|s| s.sub("...\n", '')}.should == ["INSERT INTO items (abc) VALUES ('--- 1\n')", "INSERT INTO items (abc) VALUES ('--- hello\n')"]
   end
 
   it "serialization_format should be the serialization format used" do
@@ -97,7 +94,7 @@ describe "Serialization plugin" do
 
     o.update(:abc => 23)
     @c.create(:abc => [1, 2, 3])
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '--- 23\n' WHERE (id = 1)",
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
   end
 
@@ -164,7 +161,7 @@ describe "Serialization plugin" do
 
     o.update(:abc => 23)
     Class.new(@c).create(:abc => [1, 2, 3])
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '--- 23\n' WHERE (id = 1)",
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
   end