sequel 4.43.0 → 4.44.0

data/spec/core/dataset_spec.rb

@@ -2057,6 +2057,11 @@ describe "Dataset#from_self" do
     @ds.from_self.sql.must_equal 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS t1'
   end
   
+  it "should keep any existing columns" do
+    @ds.columns(:id, :a)
+    @ds.from_self.columns.must_equal [:id, :a]
+  end
+  
   it "should modify only the new dataset" do
     @ds.from_self.select(:bogus).sql.must_equal 'SELECT bogus FROM (SELECT name FROM test LIMIT 1) AS t1'
   end

data/spec/core/expression_filters_spec.rb

@@ -248,6 +248,10 @@ describe "Blockless Ruby Filters" do
     @d.l(~((((Sequel.lit('x') - :y)/(Sequel.expr(:x) + :y))*:z) <= 100)).must_equal '((((x - y) / (x + y)) * z) > 100)'
   end
 
+  it "should have LiteralString#inspect show it is a literal string" do
+    Sequel.lit('x').inspect.must_equal "#<Sequel::LiteralString \"x\">"
+  end
+
   it "should support hashes by ANDing the conditions" do
     @d.l(:x => 100, :y => 'a')[1...-1].split(' AND ').sort.must_equal ['(x = 100)', '(y = \'a\')']
     @d.l(:x => true, :y => false)[1...-1].split(' AND ').sort.must_equal ['(x IS TRUE)', '(y IS FALSE)']
@@ -270,6 +274,10 @@ describe "Blockless Ruby Filters" do
     @d.l([:x, :y]=>Sequel.value_list([[1,2], [3,4]])).must_equal '(((x = 1) AND (y = 2)) OR ((x = 3) AND (y = 4)))'
     @d.l([:x, :y, :z]=>[[1,2,5], [3,4,6]]).must_equal '(((x = 1) AND (y = 2) AND (z = 5)) OR ((x = 3) AND (y = 4) AND (z = 6)))'
   end
+
+  it "should have SQL::ValueList#inspect show it is a value list" do
+    Sequel.value_list([[1,2], [3,4]]).inspect.must_equal "#<Sequel::SQL::ValueList [[1, 2], [3, 4]]>"
+  end
   
   it "should support StringExpression#+ for concatenation of SQL strings" do
     @d.lit(Sequel.expr(:x).sql_string + :y).must_equal '(x || y)'
@@ -952,6 +960,21 @@ describe "Sequel core extension replacements" do
     Sequel.blob(o).must_be_same_as(o)
   end
 
+  it "Sequel.blob#inspect output should indicate it is a blob and the size" do
+    o = Sequel.blob('a')
+    o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=1 content=\"a\">"
+    o = Sequel.blob(('a'..'z').to_a.join)
+    o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=26 start=\"abcdefghij\" end=\"qrstuvwxyz\">"
+    o = Sequel.blob(255.chr)
+    o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=1 content=\"#{RUBY_VERSION >= '1.9' ? "\\xFF" : "\\377"}\">"
+    o = Sequel.blob((230..255).map(&:chr).join)
+    if RUBY_VERSION >= '1.9'
+      o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=26 start=\"\\xE6\\xE7\\xE8\\xE9\\xEA\\xEB\\xEC\\xED\\xEE\\xEF\" end=\"\\xF6\\xF7\\xF8\\xF9\\xFA\\xFB\\xFC\\xFD\\xFE\\xFF\">"
+    else
+      o.inspect.must_equal "#<Sequel::SQL::Blob:0x#{'%x' % o.object_id} bytes=26 start=\"\\346\\347\\350\\351\\352\\353\\354\\355\\356\\357\" end=\"\\366\\367\\370\\371\\372\\373\\374\\375\\376\\377\">"
+    end
+  end
+
   it "Sequel.deep_qualify should do a deep qualification into nested structors" do
     l(Sequel.deep_qualify(:t, Sequel.+(:c, 1)), "(t.c + 1)")
   end
@@ -1138,6 +1161,11 @@ describe "Sequel::SQLTime" do
     Sequel::SQLTime.create(1, 2, 3).strftime('%Y-%m-%d').must_equal Date.new(2000).strftime('%Y-%m-%d')
   end
 
+  it "#inspect should show class and time by default" do
+    Sequel::SQLTime.create(1, 2, 3).inspect.must_equal "#<Sequel::SQLTime 01:02:03>"
+    Sequel::SQLTime.create(13, 24, 35).inspect.must_equal "#<Sequel::SQLTime 13:24:35>"
+  end
+
   it "#to_s should include hour, minute, and second by default" do
     Sequel::SQLTime.create(1, 2, 3).to_s.must_equal "01:02:03"
     Sequel::SQLTime.create(1, 2, 3, 500000).to_s.must_equal "01:02:03"
@@ -1225,6 +1253,11 @@ describe "Sequel.recursive_map" do
     Sequel.recursive_map([nil], proc{|s| s.to_i}).must_equal [nil]
     Sequel.recursive_map([[nil]], proc{|s| s.to_i}).must_equal [[nil]]
   end
+  
+  it "should call callable for falsey value" do 
+    Sequel.recursive_map([false], proc{|s| s.to_s}).must_equal ['false']  
+    Sequel.recursive_map([[false]], proc{|s| s.to_s}).must_equal [['false']]  
+  end
 end
 
 describe "Sequel.delay" do

data/spec/extensions/active_model_spec.rb

@@ -19,6 +19,7 @@ describe "ActiveModel plugin" do
     end
     @c = AMLintTest
     @c.plugin :active_model
+    @c.freeze if @freeze_class
     @m = @model = @c.new
     @o = @c.load({})
   end
@@ -26,7 +27,6 @@ describe "ActiveModel plugin" do
     Object.send(:remove_const, :AMLintTest)
     Object.send(:remove_const, :Blog)
   end
-  include ActiveModel::Lint::Tests
 
   it ".to_model should return self, not a proxy object" do
     @m.object_id.must_equal @m.to_model.object_id
@@ -40,6 +40,7 @@ describe "ActiveModel plugin" do
     @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
@@ -55,6 +56,7 @@ describe "ActiveModel plugin" do
     @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'
     @o.meta_def(:to_param_joiner){'|'}
@@ -81,5 +83,17 @@ describe "ActiveModel plugin" 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/association_dependencies_spec.rb

@@ -72,6 +72,14 @@ describe "AssociationDependencies plugin" do
     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

data/spec/extensions/auto_validations_spec.rb

@@ -189,4 +189,12 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.valid?.must_equal false
     @m.errors.must_equal([:name, :num]=>["u_message"])
   end
+
+  it "should not allow modifying auto validation information for frozen model classes" do
+    @c.freeze
+    @c.auto_validate_not_null_columns.frozen?.must_equal true
+    @c.auto_validate_explicit_not_null_columns.frozen?.must_equal true
+    @c.auto_validate_max_length_columns.frozen?.must_equal true
+    @c.auto_validate_unique_columns.frozen?.must_equal true
+  end
 end

data/spec/extensions/blacklist_security_spec.rb

@@ -85,4 +85,10 @@ describe Sequel::Model, ".restricted_columns " do
     i.values.must_equal(:y => 7)
     DB.sqls.must_equal ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE id = 10"]
   end
+
+  it "should freeze restricted_columns when freezing class" do
+    @c.set_restricted_columns :z
+    @c.freeze
+    @c.restricted_columns.frozen?.must_equal true
+  end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -51,6 +51,15 @@ describe "class_table_inheritance plugin" do
     Object.send(:remove_const, :Employee)
   end
 
+  it "should freeze CTI information when freezing model class" do
+    Employee.freeze
+    Employee.cti_models.frozen?.must_equal true
+    Employee.cti_tables.frozen?.must_equal true
+    Employee.cti_instance_dataset.frozen?.must_equal true
+    Employee.cti_table_columns.frozen?.must_equal true
+    Employee.cti_table_map.frozen?.must_equal true
+  end
+
   it "should not attempt to use prepared statements" do
     Manager.plugin :prepared_statements
     Manager[1]

data/spec/extensions/column_conflicts_spec.rb

@@ -55,4 +55,10 @@ describe "column_conflicts plugin" do
     o.get_column_value(:object_id).must_equal 3
     o.object_id.wont_equal 3
   end
+
+  it "should freeze column conflict information when freezing model class" do
+    @c.freeze
+    @c.get_column_conflicts.frozen?.must_equal true
+    @c.set_column_conflicts.frozen?.must_equal true
+  end
 end

data/spec/extensions/composition_spec.rb

@@ -241,4 +241,12 @@ describe "Composition plugin" do
     sql.must_include("month = 2")
     sql.must_include("day = 3")
   end
+
+  it "should freeze composition metadata when freezing model class" do
+    @c.composition :date, :mapping=>[:year, :month, :day]
+    @c.freeze
+    @c.compositions.frozen?.must_equal true
+    @c.compositions[:date].frozen?.must_equal true
+    @c.composition_module.frozen?.must_equal true
+  end
 end

data/spec/extensions/constraint_validations_plugin_spec.rb

@@ -285,4 +285,16 @@ describe "Sequel::Plugins::ConstraintValidations" do
     c.constraint_validations.must_equal [[:validates_presence, :name]]
     c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
+
+  it "should freeze constraint validations data when freezing model class" do
+    @c = model_class
+    @c.freeze
+    @c.constraint_validations.frozen?.must_equal true
+    @c.constraint_validations.all?(&:frozen?).must_equal true
+    @c.constraint_validation_reflections.frozen?.must_equal true
+    @c.constraint_validation_reflections.values.all?(&:frozen?).must_equal true
+    @c.constraint_validation_reflections.values.all?{|r| r.all?(&:frozen?)}.must_equal true
+    @c.instance_variable_get(:@constraint_validation_options).frozen?.must_equal true
+    @c.instance_variable_get(:@constraint_validation_options).values.all?(&:frozen?).must_equal true
+  end
 end

data/spec/extensions/csv_serializer_spec.rb

@@ -177,5 +177,12 @@ describe "Sequel::Plugins::CsvSerializer" do
     @album.to_csv(:only=>:name).must_equal "RF\n"
     @album.to_csv(:except=>[:id, :artist_id]).must_equal "RF\n"
   end
+
+  it "should freeze csv serializier opts when model class is frozen" do
+    @Album.csv_serializer_opts[:only] = [:id]
+    @Album.freeze
+    @Album.csv_serializer_opts.frozen?.must_equal true
+    @Album.csv_serializer_opts[:only].frozen?.must_equal true
+  end
 end
 end

data/spec/extensions/defaults_setter_spec.rb

@@ -99,4 +99,11 @@ describe "Sequel::Plugins::DefaultsSetter" do
     c.plugin :defaults_setter
     c.default_values.must_equal(:a=>2)
   end
+
+  it "should freeze default values when freezing model class" do
+    c = Class.new(Sequel::Model(@db[:bar]))
+    c.plugin :defaults_setter
+    c.freeze
+    c.default_values.frozen?.must_equal true
+  end
 end

data/spec/extensions/force_encoding_spec.rb

@@ -24,6 +24,20 @@ describe "force_encoding plugin" do
     o.x.encoding.must_equal @e1
   end
   
+  it "should not force encoding of blobs to given encoding on load" do
+    s = Sequel.blob('blah'.dup.force_encoding('BINARY'))
+    o = @c.load(:id=>1, :x=>s)
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal Encoding.find('BINARY')
+  end
+  
+  it "should not force encoding of blobs to given encoding when setting column values" do
+    s = Sequel.blob('blah'.dup.force_encoding('BINARY'))
+    o = @c.new(:x=>s)
+    o.x.must_equal 'blah'
+    o.x.encoding.must_equal Encoding.find('BINARY')
+  end
+  
   it "should work correctly when given a frozen string" do
     s = 'blah'.dup
     s.force_encoding('US-ASCII')

data/spec/extensions/hook_class_methods_spec.rb

@@ -12,6 +12,16 @@ describe Sequel::Model, "hook_class_methods plugin" do
     DB.reset
   end
   
+  it "should freeze hooks when freezing model class" do
+    c = model_class.call Sequel::Model do
+      before_save{adds << 'hi'}
+    end
+    c.freeze
+    hooks = c.instance_variable_get(:@hooks)
+    hooks.frozen?.must_equal true
+    hooks.values.all?(&:frozen?).must_equal true
+  end
+
   it "should be definable using a block" do
     adds = []
     c = model_class.call Sequel::Model do

data/spec/extensions/implicit_subquery_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Dataset::ImplicitSubquery" do
+  it "should implicitly use a subquery for most dataset query methods" do
+    db = Sequel.mock
+    db.extend_datasets{def supports_cte?; true end}
+    ds = db["SELECT * FROM table"].extension(:implicit_subquery)
+    ds.columns(:id, :a)
+    ods = db[:c]
+    ods.columns(:id, :b)
+
+    ds.and(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
+    ds.cross_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 CROSS JOIN c"
+    ds.distinct.sql.must_equal "SELECT DISTINCT * FROM (SELECT * FROM table) AS t1"
+    ds.except(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 EXCEPT SELECT * FROM c) AS t1"
+    ds.exclude(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
+    ds.exclude_having(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 HAVING NOT c"
+    ds.exclude_where(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE NOT c"
+    ds.filter(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
+    ds.for_update.sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FOR UPDATE"
+    ds.full_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FULL JOIN c"
+    ds.full_outer_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FULL OUTER JOIN c"
+    ds.graph(ods).sql.must_equal "SELECT t1.id, t1.a, c.id AS c_id, c.b FROM (SELECT * FROM table) AS t1 LEFT OUTER JOIN c"
+    ds.grep(:c, 'a').sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE ((c LIKE 'a' ESCAPE '\\'))"
+    ds.group(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
+    ds.group_append(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
+    ds.group_and_count(:c).sql.must_equal "SELECT c, count(*) AS count FROM (SELECT * FROM table) AS t1 GROUP BY c"
+    ds.group_by(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 GROUP BY c"
+    ds.having(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 HAVING c"
+    ds.inner_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
+    ds.intersect(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 INTERSECT SELECT * FROM c) AS t1"
+    ds.invert.sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE 'f'"
+    ds.join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
+    ds.join_table(:inner, :c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 INNER JOIN c USING (d)"
+    ds.left_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LEFT JOIN c USING (d)"
+    ds.left_outer_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LEFT OUTER JOIN c USING (d)"
+    ds.limit(1).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 LIMIT 1"
+    ds.lock_style('FOR UPDATE').sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 FOR UPDATE"
+    ds.natural_full_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL FULL JOIN c"
+    ds.natural_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL JOIN c"
+    ds.natural_left_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL LEFT JOIN c"
+    ds.natural_right_join(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 NATURAL RIGHT JOIN c"
+    ds.offset(1).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 OFFSET 1"
+    ds.order(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
+    ds.order_append(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
+    ds.order_by(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
+    ds.order_more(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
+    ds.order_prepend(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 ORDER BY c"
+    ds.right_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 RIGHT JOIN c USING (d)"
+    ds.right_outer_join(:c, [:d]).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 RIGHT OUTER JOIN c USING (d)"
+    ds.select(:c).sql.must_equal "SELECT c FROM (SELECT * FROM table) AS t1"
+    ds.select_append(:c).sql.must_equal "SELECT *, c FROM (SELECT * FROM table) AS t1"
+    ds.select_group(:c).sql.must_equal "SELECT c FROM (SELECT * FROM table) AS t1 GROUP BY c"
+    ds.select_more(:c).sql.must_equal "SELECT *, c FROM (SELECT * FROM table) AS t1"
+    ds.union(ods).sql.must_equal "SELECT * FROM (SELECT * FROM (SELECT * FROM table) AS t1 UNION SELECT * FROM c) AS t1"
+    ds.where(:c).sql.must_equal "SELECT * FROM (SELECT * FROM table) AS t1 WHERE c"
+    ds.with(:d, ods).sql.must_equal "WITH d AS (SELECT * FROM c) SELECT * FROM (SELECT * FROM table) AS t1"
+    ds.with_recursive(:d, ods, ods).sql.must_equal "WITH d AS (SELECT * FROM c UNION ALL SELECT * FROM c) SELECT * FROM (SELECT * FROM table) AS t1"
+  end
+end

data/spec/extensions/input_transformer_spec.rb

@@ -51,4 +51,14 @@ describe "Sequel::Plugins::InputTransformer" do
     @o.name = ' name '.dup
     @o.name.must_equal 'raboof eman '
   end
+
+  it "should freeze input transformers when freezing model class" do
+    @c.skip_input_transformer :reverser, :name
+    @c.freeze
+    @c.input_transformers.frozen?.must_equal true
+    @c.input_transformer_order.frozen?.must_equal true
+    skip = @c.instance_variable_get(:@skip_input_transformer_columns)
+    skip.frozen?.must_equal true
+    skip.values.all?(&:frozen?).must_equal true
+  end
 end

data/spec/extensions/insert_returning_select_spec.rb

@@ -63,4 +63,10 @@ describe "Sequel::Plugins::InsertReturningSelect" do
     b.create(:x=>2).must_equal b.load(:id=>1, :x=>2)
     @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2) RETURNING id, x']
   end
+
+  it "should freeze instance_insert_dataset when freezing model class" do
+    @Album.plugin :insert_returning_select
+    @Album.freeze
+    @Album.instance_insert_dataset.frozen?.must_equal true
+  end
 end

data/spec/extensions/json_serializer_spec.rb

@@ -303,4 +303,11 @@ describe "Sequel::Plugins::JsonSerializer" do
   it "should raise an error if using an unsupported :associations option" do
     proc{Artist.from_json(@artist.to_json, :associations=>'')}.must_raise(Sequel::Error)
   end
+
+  it "should freeze json serializier opts when model class is frozen" do
+    Album.json_serializer_opts[:only] = [:id]
+    Album.freeze
+    Album.json_serializer_opts.frozen?.must_equal true
+    Album.json_serializer_opts[:only].frozen?.must_equal true
+  end
 end

data/spec/extensions/lazy_attributes_spec.rb

@@ -167,4 +167,10 @@ describe "Sequel::Plugins::LazyAttributes" do
     m.name.must_equal 3
     @db.sqls.must_equal ["SELECT la.id FROM la LIMIT 1", "SELECT la.name FROM la WHERE (id = 1) LIMIT 1"]
   end
+
+  it "should freeze lazy_attributes_module when freezing model class" do
+    @c.plugin :lazy_attributes, :blah
+    @c.freeze
+    @c.lazy_attributes_module.frozen?.must_equal true
+  end
 end

data/spec/extensions/many_through_many_spec.rb

@@ -2115,3 +2115,47 @@ describe "one_through_many eager loading methods" do
     @c1.order(:artists__blah2, :artists__blah3).eager_graph(:tag).sql.must_equal 'SELECT artists.id, tag.id AS tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tag.blah__id, tag.blah__id DESC, blah.id DESC, blah.id, tag.album_id, tag.album_id DESC, 1, RANDOM(), b.a'
   end
 end
+
+describe "Sequel::Model.finalize_associations" do
+  before do
+    class ::Item < Sequel::Model
+      plugin :many_through_many
+      many_through_many :items, [[:foos, :item1_id, :foo1_id], [:bars, :foo2_id, :item2_id]]
+      one_through_many :item, [[:foos, :item1_id, :foo1_id], [:bars, :foo2_id, :item2_id]]
+      finalize_associations
+    end
+  end
+  after do
+    Object.send(:remove_const, :Item)
+  end
+
+  it "should finalize one_through_many associations" do
+    r = Item.association_reflection(:item)
+    r[:class].must_equal Item
+    r[:_dataset].sql.must_equal "SELECT items.* FROM items INNER JOIN bars ON (bars.item2_id = items.id) INNER JOIN foos ON (foos.foo1_id = bars.foo2_id) LIMIT 1"
+    r[:associated_eager_dataset].sql.must_equal "SELECT items.* FROM items INNER JOIN bars ON (bars.item2_id = items.id) INNER JOIN foos ON (foos.foo1_id = bars.foo2_id)"
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT foos.item1_id FROM items INNER JOIN bars ON (bars.item2_id = items.id) INNER JOIN foos ON (foos.foo1_id = bars.foo2_id) WHERE (foos.item1_id IS NOT NULL)"
+    r[:placeholder_loader].wont_be_nil
+    r[:predicate_key].must_equal Sequel.qualify(:foos, :item1_id)
+    r[:associated_key_table].must_equal :foos
+    r[:edges].must_equal [{:table=>:foos, :left=>:id, :right=>:item1_id, :conditions=>[], :join_type=>:left_outer, :block=>nil}, {:table=>:bars, :left=>:foo1_id, :right=>:foo2_id, :conditions=>[], :join_type=>:left_outer, :block=>nil}]
+    r[:final_edge].must_equal(:table=>:items, :left=>:item2_id, :right=>:id, :conditions=>nil, :join_type=>nil, :block=>nil)
+    r[:final_reverse_edge].must_equal(:table=>:foos, :left=>:foo1_id, :right=>:foo2_id, :alias=>:foos)
+    r[:reverse_edges].must_equal [{:table=>:bars, :left=>:item2_id, :right=>:id, :alias=>:bars}]
+  end
+
+  it "should finalize many_through_many associations" do
+    r = Item.association_reflection(:items)
+    r[:class].must_equal Item
+    r[:_dataset].sql.must_equal "SELECT items.* FROM items INNER JOIN bars ON (bars.item2_id = items.id) INNER JOIN foos ON (foos.foo1_id = bars.foo2_id)"
+    r[:associated_eager_dataset].sql.must_equal "SELECT items.* FROM items INNER JOIN bars ON (bars.item2_id = items.id) INNER JOIN foos ON (foos.foo1_id = bars.foo2_id)"
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT foos.item1_id FROM items INNER JOIN bars ON (bars.item2_id = items.id) INNER JOIN foos ON (foos.foo1_id = bars.foo2_id) WHERE (foos.item1_id IS NOT NULL)"
+    r[:placeholder_loader].wont_be_nil
+    r[:predicate_key].must_equal Sequel.qualify(:foos, :item1_id)
+    r[:associated_key_table].must_equal :foos
+    r[:edges].must_equal [{:table=>:foos, :left=>:id, :right=>:item1_id, :conditions=>[], :join_type=>:left_outer, :block=>nil}, {:table=>:bars, :left=>:foo1_id, :right=>:foo2_id, :conditions=>[], :join_type=>:left_outer, :block=>nil}]
+    r[:final_edge].must_equal(:table=>:items, :left=>:item2_id, :right=>:id, :conditions=>nil, :join_type=>nil, :block=>nil)
+    r[:final_reverse_edge].must_equal(:table=>:foos, :left=>:foo1_id, :right=>:foo2_id, :alias=>:foos)
+    r[:reverse_edges].must_equal [{:table=>:bars, :left=>:item2_id, :right=>:id, :alias=>:bars}]
+  end
+end