sequel 4.49.0 → 5.3.0

data/spec/model/base_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe "Model attribute setters" do
   before do
@@ -118,72 +118,6 @@ describe Sequel::Model, "implicit table names" do
   end
 end
 
-describe Sequel::Model, ".def_dataset_method" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-  end
-  
-  deprecated "should add a method to the dataset and model if called with a block argument" do
-    @c.def_dataset_method(:return_3){3}
-    @c.return_3.must_equal 3
-    @c.dataset.return_3.must_equal 3
-  end
-
-  deprecated "should handle weird method names" do
-    @c.def_dataset_method(:"return 3"){3}
-    @c.send(:"return 3").must_equal 3
-    @c.dataset.send(:"return 3").must_equal 3
-  end
-
-  deprecated "should not add a model method if the model already responds to the method" do
-    @c.instance_eval do
-      def foo
-        1
-      end
-
-      private
-
-      def bar
-        2
-      end
-
-      def_dataset_method(:foo){3}
-      def_dataset_method(:bar){4}
-    end
-    @c.foo.must_equal 1
-    @c.dataset.foo.must_equal 3
-    @c.send(:bar).must_equal 2
-    @c.dataset.bar.must_equal 4
-  end
-
-  deprecated "should add all passed methods to the model if called without a block argument" do
-    @c.def_dataset_method(:return_3, :return_4)
-    proc{@c.return_3}.must_raise(NoMethodError)
-    proc{@c.return_4}.must_raise(NoMethodError)
-    @c.dataset = @c.dataset.with_extend do
-      def return_3; 3; end
-      def return_4; 4; end
-    end
-    @c.return_3.must_equal 3
-    @c.return_4.must_equal 4
-  end
-
-  deprecated "should cache calls and readd methods if set_dataset is used" do
-    @c.def_dataset_method(:return_3){3}
-    @c.set_dataset :items
-    @c.return_3.must_equal 3
-    @c.dataset.return_3.must_equal 3
-  end
-
-  deprecated "should readd methods to subclasses, if set_dataset is used in a subclass" do
-    @c.def_dataset_method(:return_3){3}
-    c = Class.new(@c)
-    c.set_dataset :items
-    c.return_3.must_equal 3
-    c.dataset.return_3.must_equal 3
-  end
-end
-
 describe Sequel::Model, ".dataset_module" do
   before do
     @c = Class.new(Sequel::Model(:items))
@@ -209,6 +143,11 @@ describe Sequel::Model, ".dataset_module" do
     @c.return_3.must_equal 3
   end
 
+  it "should add methods that can't be called with normal method syntax as class methods" do
+    @c.dataset_module.module_eval{define_method(:'return 3'){3}}
+    @c.send(:'return 3').must_equal 3
+  end
+
   it "should not add private or protected methods defined in the module to the class" do
     @c.dataset_module{private; def return_3() 3 end}
     @c.dataset_module{protected; def return_4() 4 end}
@@ -377,6 +316,12 @@ describe Sequel::Model, ".dataset_module" do
     @c.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY baz, bar'
   end
 
+  it "should have dataset_module support a reverse method" do
+    @c.dataset_module{reverse(:foo){:baz}}
+    @c.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz DESC'
+    @c.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar ORDER BY baz DESC'
+  end
+
   it "should have dataset_module support a select method" do
     @c.dataset_module{select :foo, :baz}
     @c.foo.sql.must_equal 'SELECT baz FROM items'
@@ -442,6 +387,25 @@ describe "A model inheriting from a model" do
   end
 end
 
+describe "A model inheriting from a custom base that sets @dataset" do
+  before do
+    ::Feline = Class.new(Sequel::Model)
+    def Feline.inherited(subclass)
+      subclass.instance_variable_set(:@dataset, nil)
+      superclass.inherited(subclass)
+    end
+    class ::Leopard < Feline; end
+  end
+  after do
+    Object.send(:remove_const, :Leopard)
+    Object.send(:remove_const, :Feline)
+  end
+
+  it "should not infer the dataset of the subclass" do
+    proc{Leopard.dataset}.must_raise(Sequel::Error)
+  end
+end
+
 describe "Model.primary_key" do
   before do
     @c = Class.new(Sequel::Model)
@@ -565,59 +529,21 @@ describe "Model.db=" do
   before do
     @db1 = Sequel.mock
     @db2 = Sequel.mock
-    
-    @m = Class.new(Sequel::Model(@db1[:blue].filter(:x=>1)))
+    @m = Class.new(Sequel::Model(@db1))
   end
   
-  deprecated "should affect the underlying dataset" do
+  it "should change database for model" do
     @m.db = @db2
-    
-    @m.dataset.db.must_equal @db2
-    @m.dataset.db.wont_equal @db1
+    @m.db.must_equal @db2
   end
 
-  deprecated "should keep the same dataset options" do
-    @m.db = @db2
-    @m.dataset.sql.must_equal 'SELECT * FROM blue WHERE (x = 1)'
+  it "should raise Error for model with existing dataset" do
+    @m.dataset = :table
+    proc{@m.db = @db2}.must_raise Sequel::Error
   end
 
   it "should use the database for subclasses" do
-    @m = Class.new(Sequel::Model)
-    @m.db = @db2
-    Class.new(@m).db.must_equal @db2
-  end
-end
-
-describe Sequel::Model, ".allowed_columns " do
-  before do
-    @c = Class.new(Sequel::Model(:blahblah)) do
-      columns :x, :y, :z
-    end
-    @c.strict_param_setting = false
-    @c.instance_variable_set(:@columns, [:x, :y, :z])
-    DB.reset
-  end
-  
-  deprecated "should set the allowed columns correctly" do
-    @c.allowed_columns.must_be_nil
-    @c.set_allowed_columns :x
-    @c.allowed_columns.must_equal [:x]
-    @c.set_allowed_columns :x, :y
-    @c.allowed_columns.must_equal [:x, :y]
-  end
-
-  deprecated "should only set allowed columns by default" do
-    @c.set_allowed_columns :x, :y
-    i = @c.new(:x => 1, :y => 2, :z => 3)
-    i.values.must_equal(:x => 1, :y => 2)
-    i.set(:x => 4, :y => 5, :z => 6)
-    i.values.must_equal(:x => 4, :y => 5)
-
-    @c.dataset = @c.dataset.with_fetch(:x => 7)
-    i = @c.new
-    i.update(:x => 7, :z => 9)
-    i.values.must_equal(:x => 7)
-    DB.sqls.must_equal ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE id = 10"]
+    Class.new(@m).db.must_equal @db1
   end
 end
 
@@ -676,13 +602,6 @@ describe Sequel::Model, ".strict_param_setting" do
     c = @c.new
     proc{c.set(:a=>1)}.must_raise(Sequel::MassAssignmentRestriction)
     proc{c.update(:a=>1)}.must_raise(Sequel::MassAssignmentRestriction)
-    deprecated do
-      @c.set_allowed_columns :x, :y
-      proc{c.set_all(:use_after_commit_rollback => false)}.must_raise(Sequel::MassAssignmentRestriction)
-      proc{c.set_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
-      proc{c.update_all(:use_after_commit_rollback=>false)}.must_raise(Sequel::MassAssignmentRestriction)
-      proc{c.update_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
-    end
   end
 
   it "should be disabled by strict_param_setting = false" do
@@ -835,16 +754,10 @@ describe "Model datasets #with_pk with #with_pk!" do
   it "should handle an array for composite primary keys" do
     @c.set_primary_key [:id1, :id2]
     @ds.with_pk([1, 2])
-    sqls = DB.sqls
-    ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
-    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
-    sqls.must_equal []
+    DB.sqls.must_equal ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1"]
 
     @ds.with_pk!([1, 2])
-    sqls = DB.sqls
-    ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
-    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
-    sqls.must_equal []
+    DB.sqls.must_equal ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1"]
   end
 
   it "should work with composite primary keys when called repeatedly on a frozen dataset with" do
@@ -852,10 +765,7 @@ describe "Model datasets #with_pk with #with_pk!" do
     @ds.freeze
     5.times do
       @ds.with_pk([1,2])
-      sqls = DB.sqls
-      ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
-      "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
-      sqls.must_equal []
+      DB.sqls.must_equal ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1"]
     end
   end
 
@@ -880,11 +790,6 @@ describe "Model datasets #with_pk with #with_pk!" do
     DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
-  deprecated "should not have #[] consider a string as a primary key lookup" do
-    @ds['foo'].must_equal @c.load(:id=>1)
-    DB.sqls.must_equal ["SELECT * FROM a WHERE (foo) LIMIT 1"]
-  end
-
   it "should not have #[] consider a literal string as a primary key lookup" do
     @ds[Sequel.lit('foo')].must_equal @c.load(:id=>1)
     DB.sqls.must_equal ["SELECT * FROM a WHERE (foo) LIMIT 1"]
@@ -906,6 +811,7 @@ describe "Model::include" do
     including_class = Class.new(Sequel::Model(:items)) do
       include(mod1, mod2)
     end
-    including_class.included_modules.must_include(mod1, mod2)
+    including_class.included_modules.must_include(mod1)
+    including_class.included_modules.must_include(mod2)
   end
 end

data/spec/model/class_dataset_methods_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model, "class dataset methods"  do
   before do
@@ -9,10 +9,6 @@ describe Sequel::Model, "class dataset methods"  do
   end
 
   it "should call the dataset method of the same name with the same args" do
-    deprecated do
-      @c.<<({}).must_equal @d
-    end
-    @db.sqls.must_equal ["INSERT INTO items DEFAULT VALUES"]
     @c.all.must_equal [@c.load(:id=>1)]
     @db.sqls.must_equal ["SELECT * FROM items"]
     @c.avg(:id).must_equal 1
@@ -29,9 +25,6 @@ describe Sequel::Model, "class dataset methods"  do
     @c.except(@d, :from_self=>false).sql.must_equal "SELECT * FROM items EXCEPT SELECT * FROM items"
     @c.exclude(:a).sql.must_equal "SELECT * FROM items WHERE NOT a"
     @c.exclude_having(:a).sql.must_equal "SELECT * FROM items HAVING NOT a"
-    deprecated do
-      @c.exclude_where(:a).sql.must_equal "SELECT * FROM items WHERE NOT a"
-    end
     @c.fetch_rows("S"){|r| r.must_equal(:id=>1)}
     @db.sqls.must_equal ["S"]
     @c.filter(:a).sql.must_equal "SELECT * FROM items WHERE a"
@@ -57,13 +50,9 @@ describe Sequel::Model, "class dataset methods"  do
     @c.import([:id], [[1]])
     @db.sqls.must_equal ["BEGIN", "INSERT INTO items (id) VALUES (1)", "COMMIT"]
     @c.inner_join(@c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
-    @c.insert.must_equal 2
+    @c.insert.must_equal 1
     @db.sqls.must_equal ["INSERT INTO items DEFAULT VALUES"]
     @c.intersect(@d, :from_self=>false).sql.must_equal "SELECT * FROM items INTERSECT SELECT * FROM items"
-    deprecated do
-      @c.interval(:id).must_equal 1
-    end
-    @db.sqls.must_equal ["SELECT (max(id) - min(id)) AS interval FROM items LIMIT 1"]
     @c.join(@c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
     @c.join_table(:inner, @c.table_name).sql.must_equal "SELECT * FROM items INNER JOIN items"
     @c.last.must_equal @c.load(:id=>1)
@@ -109,9 +98,6 @@ describe Sequel::Model, "class dataset methods"  do
     @c.select_order_map(:id).must_equal [1]
     @db.sqls.must_equal ["SELECT id FROM items ORDER BY id"]
     @c.server(:a).opts[:server].must_equal :a
-    deprecated do
-      @c.set_graph_aliases(:a=>:b).opts[:graph_aliases].must_equal(:a=>[:b, :a])
-    end
     @c.single_record.must_equal @c.load(:id=>1)
     @db.sqls.must_equal ["SELECT * FROM items LIMIT 1"]
     @c.single_record!.must_equal @c.load(:id=>1)
@@ -148,10 +134,6 @@ describe Sequel::Model, "class dataset methods"  do
     sc.invert.sql.must_equal 'SELECT a FROM items WHERE NOT a GROUP BY a ORDER BY a LIMIT 2'
     sc.dataset = sc.dataset.with_fetch(:v1=>1, :v2=>2)
     @db.sqls
-    deprecated do
-      sc.range(:a).must_equal(1..2)
-    end
-    @db.sqls.must_equal ["SELECT min(a) AS v1, max(a) AS v2 FROM (SELECT a FROM items WHERE a GROUP BY a ORDER BY a LIMIT 2) AS t1 LIMIT 1"]
     sc.reverse.sql.must_equal 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a DESC LIMIT 2'
     sc.reverse_order.sql.must_equal 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a DESC LIMIT 2'
     sc.select_more(:a).sql.must_equal 'SELECT a, a FROM items WHERE a GROUP BY a ORDER BY a LIMIT 2'

data/spec/model/dataset_methods_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model::DatasetMethods, "#destroy"  do
   before do
@@ -86,24 +86,6 @@ describe Sequel::Model::DatasetMethods  do
     @c.db.reset
   end
 
-  deprecated "#join_table should allow use to use a model class when joining" do
-    @c.join(Class.new(Sequel::Model(:categories)), :item_id => :id).sql.must_equal 'SELECT * FROM items INNER JOIN categories ON (categories.item_id = items.id)'
-  end
-
-  deprecated "#join_table should handle model classes that aren't simple selects using a subselect" do
-    @c.join(Class.new(Sequel::Model(DB[:categories].where(:foo=>1))), :item_id => :id).sql.must_equal 'SELECT * FROM items INNER JOIN (SELECT * FROM categories WHERE (foo = 1)) AS t1 ON (t1.item_id = items.id)'
-  end
-
-  deprecated "#graph should allow use to use a model class when joining" do
-    c = Class.new(Sequel::Model(:categories))
-    c.columns :id
-    @c.graph(c, :item_id => :id).sql.must_equal 'SELECT items.id, categories.id AS categories_id FROM items LEFT OUTER JOIN categories ON (categories.item_id = items.id)'
-  end
-
-  deprecated "#insert_sql should handle a single model instance as an argument" do
-    @c.dataset.insert_sql(@c.load(:id=>1)).must_equal 'INSERT INTO items (id) VALUES (1)'
-  end
-
   it "#first should handle no primary key" do
     @c.no_primary_key
     @c.first.must_be_kind_of(@c)
@@ -209,7 +191,6 @@ describe Sequel::Model::DatasetMethods, "#where_single_value"  do
 
   it "should return single value" do
     5.times do
-      a = []
       @c.only_id.where_single_value(:id=>1).must_equal 1
       @c.db.sqls.must_equal ['SELECT id FROM items WHERE (id = 1) LIMIT 1']
     end

data/spec/model/eager_loading_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model, "#eager" do
   before do
@@ -222,6 +222,31 @@ describe Sequel::Model, "#eager" do
     DB.sqls.must_equal []
   end
   
+  it "should eagerly load a single one_to_one association using the :window_function strategy on MySQL" do
+    odb = DB
+    db = Class.new do
+      def database_type; :mysql; end
+      define_method(:method_missing) do |*args, &block|
+        odb.send(*args, &block)
+      end
+    end.new
+
+    begin
+      EagerTrack.dataset = EagerTrack.dataset.with_extend do
+        def supports_window_functions?; true end
+        define_method(:db){db}
+      end
+      EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :order=>:name, :eager_limit_strategy=>:window_function
+      a = EagerAlbum.eager(:track).all
+      a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
+      DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY name) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x = 1) ORDER BY x_sequel_row_number_x']
+      a.first.track.must_equal EagerTrack.load(:id => 3, :album_id=>1)
+      DB.sqls.must_equal []
+    ensure
+      db = DB
+    end
+  end
+  
   it "should automatically use an eager limit stategy if the association has an offset" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :limit=>[1,1]
     EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:id => 4, :album_id=>1}])
@@ -675,9 +700,9 @@ describe Sequel::Model, "#eager" do
   it "should cache the negative lookup when eagerly loading a *_to_many associations" do
     a = EagerBand.eager(:albums).where{id > 100}.all
     a.must_equal [EagerBand.load(:id => 101), EagerBand.load(:id =>102)]
-    sqls = DB.sqls
-    ['SELECT * FROM albums WHERE (albums.band_id IN (101, 102))', 'SELECT * FROM albums WHERE (albums.band_id IN (102, 101))'].must_include(sqls.delete_at(1))
-    sqls.must_equal ['SELECT * FROM bands WHERE (id > 100)', "SELECT * FROM tracks WHERE (tracks.album_id IN (101))"]
+    DB.sqls.must_equal ['SELECT * FROM bands WHERE (id > 100)',
+      'SELECT * FROM albums WHERE (albums.band_id IN (101, 102))',
+      "SELECT * FROM tracks WHERE (tracks.album_id IN (101))"]
     a.map{|b| b.associations[:albums]}.must_equal [[EagerAlbum.load({:band_id=>101, :id=>101})], []]
     DB.sqls.must_equal []
   end
@@ -1100,9 +1125,9 @@ describe Sequel::Model, "#eager" do
     EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:id=>3, :album_id=>1}])
     a = EagerBand.eager(:top_10_albums=>{proc{|ds| ds.select(:id, :name)}=>:tracks}).all
     a.must_equal [EagerBand.load(:id => 2)]
-    sqls = DB.sqls
-    sqls.pop.must_match(/SELECT \* FROM tracks WHERE \(tracks.album_id IN \((\d+, ){10}\d+\)\)/)
-    sqls.must_equal ['SELECT * FROM bands', 'SELECT id, name FROM albums WHERE (albums.band_id IN (2))']
+    DB.sqls.must_equal ['SELECT * FROM bands',
+      'SELECT id, name FROM albums WHERE (albums.band_id IN (2))',
+      'SELECT * FROM tracks WHERE (tracks.album_id IN (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))']
     a = a.first
     a.top_10_albums.must_equal((1..10).map{|i| EagerAlbum.load(:band_id=>2, :id=>i)})
     a.top_10_albums.map{|x| x.tracks}.must_equal [[EagerTrack.load(:id => 3, :album_id=>1)]] + ([[]] * 9)
@@ -1483,20 +1508,26 @@ describe Sequel::Model, "#eager_graph" do
     a.first.lgenre.must_equal sub.load(:id => 4)
   end
   
-  it "should correctly handle an aliased join table in many_to_many and one_through_one with conditions" do
+  it "should correctly handle an aliased join table in many_to_many and one_through_one with graph_conditions or graph_block" do
     c = Class.new(GraphAlbum)
-    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :conditions=>'true', :ignore_conditions_warning=> true
-    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
-    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :conditions=>'true', :graph_block => proc{true}
-    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND \'t\')'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :graph_conditions=>{:a=>:b}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND (genres.a = ga.b))'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :graph_block => proc{true}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND (genres.a = ga.b) AND \'t\')'
   end
 
-  with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many and one_through_one with conditions" do
+  with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many and one_through_one with graph_conditions or graph_block" do
     c = Class.new(GraphAlbum)
-    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :conditions=>'true', :ignore_conditions_warning=> true
-    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
-    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :conditions=>'true', :graph_block => proc{true}
-    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND \'t\')'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :graph_conditions=>{:a=>:b}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND (genres.a = ga.b))'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :graph_block => proc{true}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND (genres.a = ga.b) AND \'t\')'
+  end
+
+  it "should raise Error when using eager_graph with :conditions option that isn't a conditions specifier" do
+    c = Class.new(GraphAlbum)
+    c.many_to_many :genres, :clone=>:genres, :join_table=>Sequel[:ag].as(:ga), :conditions=>'true'
+    proc{c.eager_graph(:genres)}.must_raise Sequel::Error
   end
 
   with_symbol_splitting "should correctly handle an aliased join table symbol in many_to_many and one_through_one" do