sequel 5.2.0 → 5.3.0

data/spec/extensions/serialization_spec.rb

@@ -15,15 +15,15 @@ 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)
-    DB.sqls.last.must_match(/INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 2|2, '--- 1\n(\.\.\.\n)?')\)/)
+    DB.sqls.map{|s| s.sub("1\n...", '1')}.must_equal ["INSERT INTO items (def, abc) VALUES (2, '--- 1\n')"]
 
     @c.plugin :serialization, :marshal, :def
     @c.create(:abc => 1, :def=> 1)
-    DB.sqls.last.must_match(/INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n(\.\.\.\n)?')\)/)
+    DB.sqls.map{|s| s.sub("1\n...", '1')}.must_equal ["INSERT INTO items (abc, def) VALUES ('--- 1\n', 'BAhpBg==\n')"]
     
     @c.plugin :serialization, :json, :ghi
     @c.create(:ghi => [123])
-    DB.sqls.last.must_match(/INSERT INTO items \((ghi)\) VALUES \('\[123\]'\)/)
+    DB.sqls.must_equal ["INSERT INTO items (ghi) VALUES ('[123]')"]
   end
 
   it "should handle validations of underlying column" do

data/spec/extensions/synchronize_sql_spec.rb

@@ -0,0 +1,124 @@
+require_relative 'spec_helper'
+
+describe "synchronize_sql extension" do
+  module Sync
+    def literal_string_append(sql, v)
+      db.synchronize{super}
+    end
+  end
+
+  before do
+    @db = Sequel.mock
+    @db.pool.extend(Module.new do
+      def assign_connection(*args)
+        r = super
+        @times_connection_acquired ||= 0
+        @times_connection_acquired += 1 if r
+        return r
+      end
+
+      def times_connection_acquired
+        v = @times_connection_acquired
+        @times_connection_acquired = 0
+        v || 0
+      end
+    end)
+    @db.extend_datasets(Sync)
+    @ds = @db[:tab1]
+  end
+
+  it 'does not checkout a connection if SQL is given as a string' do
+    extds = @ds.extension(:synchronize_sql).with_sql('SELECT 1').sql
+    @db.pool.times_connection_acquired.must_equal 0
+  end
+
+  it 'checks out an extra connection on insert_sql if there are no strings' do
+    @ds.insert_sql(:numeric_foo => 8)
+    @db.pool.times_connection_acquired.must_equal 0
+
+    extds = @ds.extension(:synchronize_sql)
+    extds.insert_sql(:numeric_foo => 8)
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'checks out just one connection on insert_sql if there are multiple strings' do
+    @ds.insert_sql(:string_foo1 => 'eight', :string_foo2 => 'nine', :string_foo3 => 'ten')
+    @db.pool.times_connection_acquired.must_equal 3
+
+    extds = @ds.extension(:synchronize_sql)
+    extds.insert_sql(:string_foo1 => 'eight', :string_foo2 => 'nine', :string_foo3 => 'ten')
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'cheks out an extra connectrion on update_sql if there are no strings' do
+    @ds.where(:numeric_foo => [1, 2, 3, 4, 5]).update_sql(:numeric_foo => 99)
+    @db.pool.times_connection_acquired.must_equal 0
+
+    extds = @ds.extension(:synchronize_sql)
+    extds.where(:numeric_foo => [1, 2, 3, 4, 5]).update_sql(:numeric_foo => 99)
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'checks out just one connection on update_sql if there are multiple strings' do
+    @ds.where(:numeric_foo => [1, 2, 3, 4, 5]).update_sql(:string_foo1 => 'eight', :string_foo2 => 'nine', :string_foo3 => 'ten')
+    @db.pool.times_connection_acquired.must_equal 3
+
+    extds = @ds.extension(:synchronize_sql)
+    extds.where(:numeric_foo => [1, 2, 3, 4, 5]).update_sql(:string_foo1 => 'eight', :string_foo2 => 'nine', :string_foo3 => 'ten')
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'checks out an extra connection on delete_sql if there are no strings' do
+    @ds.where(:numeric_foo => [1, 2, 3]).delete_sql
+    @db.pool.times_connection_acquired.must_equal 0
+
+    extds = @ds.extension(:synchronize_sql)
+    extds.where(:numeric_foo => [1, 2, 3]).delete_sql
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'checks out just one connection on delete_sql if there are multiple strings' do
+    @ds.where(:string_foo => ['one', 'two', 'three', 'four']).delete_sql
+    @db.pool.times_connection_acquired.must_equal 4
+
+    extds = @ds.extension(:synchronize_sql)
+    extds.where(:string_foo => ['one', 'two', 'three', 'four']).delete_sql
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'checks out an extra connection on select_sql if there are no strings' do
+    @ds.where(:numeric_foo => [1, 2, 3]).select_sql
+    @db.pool.times_connection_acquired.must_equal 0
+
+    extds = @ds.extension(:synchronize_sql)
+    extds.where(:numeric_foo => [1, 2, 3]).select_sql
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'checks out just one connection on select_sql if there are multiple strings' do
+    @ds.where(:string_foo => ['one', 'two', 'three', 'four']).select_sql
+    @db.pool.times_connection_acquired.must_equal 4
+
+    extds = @ds.extension(:synchronize_sql)
+    extds.where(:string_foo => ['one', 'two', 'three', 'four']).select_sql
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'checks out an extra connection on fetch if there are no strings' do
+    @db.fetch('SELECT * FROM tab1 WHERE numeric_foo IN (?, ?, ?, ?)', 1, 2, 3, 4).select_sql
+    @db.pool.times_connection_acquired.must_equal 0
+
+    @db.extension(:synchronize_sql)
+    @db.fetch('SELECT * FROM tab1 WHERE numeric_foo IN (?, ?, ?, ?)', 1, 2, 3, 4).select_sql
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+
+  it 'checks out just one connection on fetch if there are multiple strings' do
+    @db.fetch('SELECT * FROM tab1 WHERE string_foo IN (?, ?, ?, ?)', 'one', 'two', 'three', 'four').select_sql
+    @db.pool.times_connection_acquired.must_equal 4
+
+    @db.extension(:synchronize_sql)
+    @db.fetch('SELECT * FROM tab1 WHERE string_foo IN (?, ?, ?, ?)', 'one', 'two', 'three', 'four').select_sql
+    @db.pool.times_connection_acquired.must_equal 1
+  end
+end

data/spec/extensions/timestamps_spec.rb

@@ -76,9 +76,7 @@ describe "Sequel::Plugins::Timestamps" do
   it "should use the same value for the creation and update timestamps when creating if the :update_on_create option is given" do
     @c.plugin :timestamps, :update_on_create=>true
     o = @c.create
-    sqls = @c.db.sqls
-    sqls.shift.must_match(/INSERT INTO t \((creat|updat)ed_at, (creat|updat)ed_at\) VALUES \('2009-08-01', '2009-08-01'\)/)
-    sqls.must_equal []
+    @c.db.sqls.must_equal ["INSERT INTO t (created_at, updated_at) VALUES ('2009-08-01', '2009-08-01')"]
     o.created_at.must_be :===, o.updated_at
   end
 
@@ -201,7 +199,7 @@ describe "Sequel::Plugins::Timestamps" do
     o = c2.create
     o.c.must_equal '2009-08-01'
     o.u.must_be :===, o.c 
-    c2.db.sqls.first.must_match(/INSERT INTO t \([cu], [cu]\) VALUES \('2009-08-01', '2009-08-01'\)/)
+    c2.db.sqls.must_equal ["INSERT INTO t (c, u) VALUES ('2009-08-01', '2009-08-01')"]
     c2.db.reset
     o = c2.load(:id=>1).save
     o.u.must_equal '2009-08-01'

data/spec/extensions/update_or_create_spec.rb

@@ -20,32 +20,28 @@ describe "Sequel::Plugins::UpdateOrCreate" do
 
     @db.fetch = [[{:id=>1, :a=>2, :b=>3}]]
     @c.update_or_create({:a=>2}, :a=>3){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>3, :b=>4)
-    sqls = @db.sqls
-    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 2) LIMIT 1"
-    sqls.shift.must_match(/UPDATE test SET [ab] = [34], [ab] = [34] WHERE \(id = 1\)/)
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 2) LIMIT 1",
+      'UPDATE test SET a = 3, b = 4 WHERE (id = 1)']
   end
 
   it ".update_or_create should create a record if an existing record does not exist" do
     @db.fetch = [[], [{:id=>1, :a=>1, :b=>4}]]
     @c.update_or_create(:a=>1){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>1, :b=>4)
-    sqls = @db.sqls
-    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([14], [14]\)/)
-    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1",
+      "INSERT INTO test (a, b) VALUES (1, 4)",
+      "SELECT * FROM test WHERE (id = 1) LIMIT 1"]
 
     @db.fetch = [[], [{:id=>1, :a=>1, :b=>4}]]
     @c.update_or_create({:a=>1}, :b=>4).must_equal @c.load(:id=>1, :a=>1, :b=>4)
-    sqls = @db.sqls
-    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([14], [14]\)/)
-    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1",
+      "INSERT INTO test (a, b) VALUES (1, 4)",
+      "SELECT * FROM test WHERE (id = 1) LIMIT 1"]
 
     @db.fetch = [[], [{:id=>1, :a=>3, :b=>4}]]
     @c.update_or_create({:a=>1}, :a=>3){|t| t.b = 4}.must_equal @c.load(:id=>1, :a=>3, :b=>4)
-    sqls = @db.sqls
-    sqls.shift.must_equal "SELECT * FROM test WHERE (a = 1) LIMIT 1"
-    sqls.shift.must_match(/INSERT INTO test \([ab], [ab]\) VALUES \([34], [34]\)/)
-    sqls.shift.must_equal "SELECT * FROM test WHERE (id = 1) LIMIT 1"
+    @db.sqls.must_equal ["SELECT * FROM test WHERE (a = 1) LIMIT 1",
+      "INSERT INTO test (a, b) VALUES (3, 4)",
+      "SELECT * FROM test WHERE (id = 1) LIMIT 1"]
   end
 
   it ".update_or_create should return an existing record even if no changes necessary" do

data/spec/extensions/uuid_spec.rb

@@ -45,8 +45,7 @@ describe "Sequel::Plugins::Uuid" do
       def _save_refresh(*) end
     end
     o = c.create
-    c.db.sqls.first.must_match(/INSERT INTO t \(u\) VALUES \('[-0-9a-f]+'\)/)
-    o.u.must_match(/[-0-9a-f]+/)
+    c.db.sqls.must_equal ["INSERT INTO t (u) VALUES ('#{o.u}')"]
   end
 
   it "should not raise an error if the model doesn't have the uuid column" do
@@ -97,6 +96,6 @@ describe "Sequel::Plugins::Uuid" do
     c2.db.reset
     o = c2.create
     o.u.must_equal @uuid
-    c2.db.sqls.first.must_match(/INSERT INTO t \([u]\) VALUES \('#{@uuid}'\)/)
+    c2.db.sqls.must_equal ["INSERT INTO t (u) VALUES ('#{@uuid}')"]
   end
 end

data/spec/extensions/xml_serializer_spec.rb

@@ -125,30 +125,25 @@ describe "Sequel::Plugins::XmlSerializer" do
   end
 
   it "should support an :encoding option when serializing" do
-    ["<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><id>2</id><name>YJM</name></artist>",
-     "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><name>YJM</name><id>2</id></artist>"].must_include(@artist.to_xml(:encoding=>'UTF-8').gsub(/\n */m, ''))
+     @artist.to_xml(:encoding=>'UTF-8').gsub(/\n */m, '').must_equal "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><id>2</id><name>YJM</name></artist>"
   end
 
   it "should support a :builder_opts option when serializing" do
-    ["<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><id>2</id><name>YJM</name></artist>",
-     "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><name>YJM</name><id>2</id></artist>"].must_include(@artist.to_xml(:builder_opts=>{:encoding=>'UTF-8'}).gsub(/\n */m, ''))
+    @artist.to_xml(:builder_opts=>{:encoding=>'UTF-8'}).gsub(/\n */m, '').must_equal "<?xml version=\"1.0\" encoding=\"UTF-8\"?><artist><id>2</id><name>YJM</name></artist>"
   end
 
   it "should support an :types option when serializing" do
-    ["<?xml version=\"1.0\"?><artist><id type=\"integer\">2</id><name type=\"string\">YJM</name></artist>",
-     "<?xml version=\"1.0\"?><artist><name type=\"string\">YJM</name><id type=\"integer\">2</id></artist>"].must_include(@artist.to_xml(:types=>true).gsub(/\n */m, ''))
+    @artist.to_xml(:types=>true).gsub(/\n */m, '').must_equal "<?xml version=\"1.0\"?><artist><id type=\"integer\">2</id><name type=\"string\">YJM</name></artist>"
   end
 
   it "should support an :root_name option when serializing" do
-    ["<?xml version=\"1.0\"?><ar><id>2</id><name>YJM</name></ar>",
-     "<?xml version=\"1.0\"?><ar><name>YJM</name><id>2</id></ar>"].must_include(@artist.to_xml(:root_name=>'ar').gsub(/\n */m, ''))
+    @artist.to_xml(:root_name=>'ar').gsub(/\n */m, '').must_equal "<?xml version=\"1.0\"?><ar><id>2</id><name>YJM</name></ar>"
   end
 
   it "should support an :array_root_name option when serializing arrays" do
     artist = @artist
     Artist.dataset = Artist.dataset.with_extend{define_method(:all){[artist]}}
-    ["<?xml version=\"1.0\"?><ars><ar><id>2</id><name>YJM</name></ar></ars>",
-     "<?xml version=\"1.0\"?><ars><ar><name>YJM</name><id>2</id></ar></ars>"].must_include(Artist.to_xml(:array_root_name=>'ars', :root_name=>'ar').gsub(/\n */m, ''))
+    Artist.to_xml(:array_root_name=>'ars', :root_name=>'ar').gsub(/\n */m, '').must_equal "<?xml version=\"1.0\"?><ars><ar><id>2</id><name>YJM</name></ar></ars>"
   end
 
   it "should raise an exception for xml tags that aren't associations, columns, or setter methods" do

data/spec/integration/database_test.rb

@@ -53,7 +53,7 @@ describe Sequel::Database do
       proc{@db[:test].update(:a=>'1', :b=>'2')}.must_raise(Sequel::UniqueConstraintViolation)
     end
 
-    cspecify "should raise Sequel::CheckConstraintViolation when a check constraint is violated", :mysql, [proc{|db| db.sqlite_version < 30802}, :sqlite] do
+    cspecify "should raise Sequel::CheckConstraintViolation when a check constraint is violated", [proc{|db| !db.mariadb? || db.server_version <= 100200}, :mysql], [proc{|db| db.sqlite_version < 30802}, :sqlite] do
       @db.create_table!(:test){String :a; check Sequel.~(:a=>'1')}
       proc{@db[:test].insert('1')}.must_raise(Sequel::CheckConstraintViolation)
       @db[:test].insert('2')

data/spec/integration/dataset_test.rb

@@ -771,6 +771,13 @@ if DB.dataset.supports_cte?(:update) # Assume INSERT and DELETE support as well
       @ds2.filter(:id=>@db[:t].select{max(id)}).delete
       @ds.select_order_map(:id).must_equal [1, 1]
     end
+
+    it "should support a subselect in an subquery used for INSERT" do
+      @db.transaction(:rollback=>:always) do
+        @ds.insert([:id], @db[:foo].with(:foo, @ds.select{(id + 10).as(:id)}))
+        @ds.select_order_map(:id).must_equal [1,2,11,12]
+      end
+    end
   end
 end
 

data/spec/integration/plugin_test.rb

@@ -2043,7 +2043,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
   end
 
   ConstraintValidationsSpecs = shared_description do
-    cspecify "should set up constraints that work even outside the model", :mysql do 
+    cspecify "should set up constraints that work even outside the model", [proc{|db| !db.mariadb? || db.server_version <= 100200}, :mysql] do 
       @ds.insert(@valid_row)
 
       # Test for unique constraint

data/spec/integration/schema_test.rb

@@ -129,7 +129,7 @@ describe "Database schema parser" do
     DB.schema(:items).first.last[:ruby_default].must_equal Sequel::CURRENT_TIMESTAMP
   end
 
-  cspecify "should parse current date defaults from the schema properly", :mysql, :oracle do
+  cspecify "should parse current date defaults from the schema properly", [proc{|db| !db.mariadb? || db.server_version <= 100200}, :mysql], :oracle do
     DB.create_table!(:items){Date :a, :default=>Sequel::CURRENT_DATE}
     DB.schema(:items).first.last[:ruby_default].must_equal Sequel::CURRENT_DATE
   end
@@ -765,14 +765,14 @@ describe "Database schema modifiers" do
       primary_key :id
       String :name2
       String :number2
-      constraint :bar, Sequel.~(:id=>nil)
+      constraint :bar, Sequel.~(:number2=>nil, :name2=>nil)
     end
     @ds.insert(:name2=>'A12')
     @db.alter_table(:items) do
       add_column :number, Integer
+      drop_constraint :bar
       drop_column :number2
       rename_column :name2, :name
-      drop_constraint :bar
       set_column_not_null :name
       set_column_default :name, 'A13'
       add_constraint :foo, Sequel.like(:name, 'A%')

data/spec/integration/spec_helper.rb

@@ -42,6 +42,10 @@ if ENV['SEQUEL_ERROR_SQL']
   DB.extension :error_sql
 end
 
+if ENV['SEQUEL_SYNCHRONIZE_SQL']
+  DB.extension :synchronize_sql
+end
+
 if ENV['SEQUEL_CONNECTION_VALIDATOR']
   ENV['SEQUEL_NO_CHECK_SQLS'] = '1'
   DB.extension(:connection_validator)

data/spec/model/base_spec.rb

@@ -316,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'

data/spec/model/eager_loading_spec.rb

@@ -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)

data/spec/model/model_spec.rb

@@ -231,10 +231,8 @@ end
 
 describe Sequel::Model do
   it "should have class method aliased as model" do
-    Sequel::Model.instance_methods.collect{|x| x.to_s}.must_include("model")
-
     model_a = Class.new(Sequel::Model(:items))
-    model_a.new.model.wont_be_nil
+    model_a.new.model.must_be_same_as model_a
   end
 
   it "should be associated with a dataset" do
@@ -626,10 +624,9 @@ describe Sequel::Model, ".find_or_create" do
     @db.fetch = [[], {:x=>1, :id=>1}]
     @db.autoid = 1
     @c.find_or_create(:x => 1){|x| x[:y] = 2}.must_equal @c.load(:x=>1, :id=>1)
-    sqls = @db.sqls
-    sqls.first.must_equal "SELECT * FROM items WHERE (x = 1) LIMIT 1"
-    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].must_include(sqls[1])
-    sqls.last.must_equal "SELECT * FROM items WHERE id = 1"
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (x = 1) LIMIT 1",
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "SELECT * FROM items WHERE id = 1"]
   end
 end
 
@@ -687,17 +684,12 @@ describe Sequel::Model, "attribute accessors" do
   end
 
   it "should be created on set_dataset" do
-    %w'x z x= z='.each do |x|
-      @c.instance_methods.collect{|z| z.to_s}.wont_include(x)
-    end
+    a = [:x, :z, :x= ,:z=]
+    (a - @c.instance_methods).must_equal a
     @c.set_dataset(@dataset)
-    %w'x z x= z='.each do |x|
-      @c.instance_methods.collect{|z| z.to_s}.must_include(x)
-    end
+    (a - @c.instance_methods).must_equal []
     o = @c.new
-    %w'x z x= z='.each do |x|
-      o.methods.collect{|z| z.to_s}.must_include(x)
-    end
+    (a - o.methods).must_equal []
 
     o.x.must_be_nil
     o.x = 34
@@ -769,9 +761,7 @@ describe Sequel::Model, ".[]" do
   it "should work correctly for composite primary key specified as array" do
     @c.set_primary_key [:node_id, :kind]
     @c[3921, 201].must_be_kind_of(@c)
-    sqls = DB.sqls
-    sqls.length.must_equal 1
-    sqls.first.must_match(/^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/)
+    DB.sqls.must_equal ['SELECT * FROM items WHERE ((node_id = 3921) AND (kind = 201)) LIMIT 1']
   end
 end