sequel 5.8.0 → 5.38.0

data/spec/extensions/eager_each_spec.rb

@@ -1,62 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::EagerEach" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.columns :id, :parent_id
-    @c.plugin :eager_each
-    @c.one_to_many :children, :class=>@c, :key=>:parent_id
-    @c.db.sqls
-  end
-
-  it "should make #each on an eager dataset do eager loading" do
-    a = []
-    ds = @c.eager(:children).with_fetch([{:id=>1, :parent_id=>nil}, {:id=>2, :parent_id=>nil}])
-    @c.dataset = @c.dataset.with_fetch([{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>2}, {:id=>6, :parent_id=>2}])
-    ds.each{|c| a << c}
-    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
-    a.map{|c| c.associations[:children]}.must_equal [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
-    sqls = @c.db.sqls
-    sqls.shift.must_equal 'SELECT * FROM items'
-    ['SELECT * FROM items WHERE (items.parent_id IN (1, 2))', 
-     'SELECT * FROM items WHERE (items.parent_id IN (2, 1))'].must_include(sqls.pop)
-  end
-
-  it "should make #each on an eager_graph dataset do eager loading" do
-    a = []
-    ds = @c.eager_graph(:children).with_fetch([{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}])
-    ds.each{|c| a << c}
-    a.must_equal [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
-    a.map{|c| c.associations[:children]}.must_equal [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
-    @c.db.sqls.must_equal ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
-  end
-
-  it "should make #first on an eager dataset do eager loading" do
-    ds = @c.eager(:children).with_fetch([{:id=>1, :parent_id=>nil}])
-    @c.dataset = @c.dataset.with_fetch([{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}])
-    a = ds.first
-    a.values.must_equal(:id=>1, :parent_id=>nil)
-    a.associations[:children].must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)]
-    @c.db.sqls.must_equal ['SELECT * FROM items LIMIT 1','SELECT * FROM items WHERE (items.parent_id IN (1))'] 
-  end
-
-  it "should make #first on an eager_graph dataset do eager loading" do
-    a = @c.eager_graph(:children).with_fetch([[{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}], [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}]]).first
-    a.values.must_equal(:id=>1, :parent_id=>nil)
-    a.associations[:children].must_equal [@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)]
-    @c.db.sqls.must_equal ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) LIMIT 1',
-      'SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id) WHERE (items.id = 1)']
-  end
-
-  it "should make #first on a non-eager dataset work correctly" do
-    @c.dataset.with_fetch([{:id=>1, :parent_id=>nil}]).first.must_equal @c.load(:id=>1, :parent_id=>nil)
-  end
-
-  it "should get columns normally columns" do
-    @c.dataset.columns!.must_equal [:id, :parent_id]
-  end
-
-  it "should not attempt to eager load when getting the columns" do
-    @c.eager(:children).with_extend{def all; raise; end}.columns!.must_equal [:id, :parent_id]
-  end
-end

data/spec/extensions/empty_array_consider_nulls_spec.rb

@@ -1,24 +0,0 @@
-require_relative "spec_helper"
-
-describe "filter_having extension" do
-  before do
-    @dataset = Sequel.mock[:test].extension(:empty_array_consider_nulls)
-  end
-
-  it "should handle all types of IN/NOT IN queries with empty arrays" do
-    @dataset.filter(:id => []).sql.must_equal "SELECT * FROM test WHERE (id != id)"
-    @dataset.filter([:id1, :id2] => []).sql.must_equal "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
-    @dataset.exclude(:id => []).sql.must_equal "SELECT * FROM test WHERE (id = id)"
-    @dataset.exclude([:id1, :id2] => []).sql.must_equal "SELECT * FROM test WHERE ((id1 = id1) AND (id2 = id2))"
-  end
-
-  it "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
-    db = Sequel.mock
-    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia').columns(:id1, :id2)
-    @dataset = @dataset.with_extend{def supports_multiple_column_in?; false end}
-    @dataset.filter([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
-    db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
-    @dataset.exclude([:id1, :id2] => d1).sql.must_equal "SELECT * FROM test WHERE ((id1 = id1) AND (id2 = id2))"
-    db.sqls.must_equal ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
-  end
-end

data/spec/extensions/error_splitter_spec.rb

@@ -1,18 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::ErrorSplitter" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.plugin :error_splitter
-    @m = @c.new
-    def @m.validate
-      errors.add([:a, :b], 'is bad')
-    end
-  end
-
-  it "should split errors for multiple columns and assign them to each column" do
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:a=>['is bad'], :b=>['is bad'])
-  end
-end
-

data/spec/extensions/error_sql_spec.rb

@@ -1,20 +0,0 @@
-require_relative "spec_helper"
-
-describe "error_sql extension" do
-  before do
-    @db = Sequel.mock(:fetch=>proc{|sql| @db.log_connection_yield(sql, nil){raise StandardError}}).extension(:error_sql)
-  end
-
-  it "should have Sequel::DatabaseError#sql give the SQL causing the error" do
-    @db["SELECT"].all rescue (e = $!)
-    e.sql.must_equal "SELECT"
-  end
-
-  it "should have Sequel::DatabaseError#sql give the SQL causing the error when using a logger" do
-    l = Object.new
-    def l.method_missing(*) end
-    @db.loggers = [l]
-    @db["SELECT"].all rescue (e = $!)
-    e.sql.must_equal "SELECT"
-  end
-end

data/spec/extensions/eval_inspect_spec.rb

@@ -1,74 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :eval_inspect
-
-describe "eval_inspect extension" do
-  before do
-    @ds = Sequel.mock.dataset.with_extend do
-      def supports_window_functions?; true end
-      def literal_blob_append(sql, s) sql << "X'#{s}'" end
-    end
-  end
-
-  it "should make eval(obj.inspect) == obj for all Sequel::SQL::Expression subclasses" do
-    [
-      # Objects with components where eval(inspect) == self
-      Sequel::SQL::AliasedExpression.new(:b, :a),
-      Sequel::SQL::AliasedExpression.new(:b, :a, [:c, :d]),
-      Sequel::SQL::CaseExpression.new({:b=>:a}, :c),
-      Sequel::SQL::CaseExpression.new({:b=>:a}, :c, :d),
-      Sequel::SQL::Cast.new(:a, :b),
-      Sequel::SQL::ColumnAll.new(:a),
-      Sequel::SQL::ComplexExpression.new(:'=', :b, :a),
-      Sequel::SQL::Constant.new(:a),
-      Sequel::CURRENT_DATE,
-      Sequel::CURRENT_TIMESTAMP,
-      Sequel::CURRENT_TIME,
-      Sequel::SQLTRUE,
-      Sequel::SQLFALSE,
-      Sequel::NULL,
-      Sequel::NOTNULL,
-      Sequel::SQL::Function.new(:a, :b, :c),
-      Sequel::SQL::Identifier.new(:a),
-      Sequel::SQL::JoinClause.new(:inner, :b),
-      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, :b),
-      Sequel::SQL::JoinUsingClause.new([:a], :inner, :b),
-      Sequel::SQL::JoinClause.new(:inner, Sequel.as(:b, :c, [:d, :e])),
-      Sequel::SQL::JoinOnClause.new({:d=>:a}, :inner, Sequel.as(:b, :c, [:d, :e])),
-      Sequel::SQL::JoinUsingClause.new([:a], :inner, Sequel.as(:b, :c, [:d, :e])),
-      Sequel::SQL::PlaceholderLiteralString.new('? = ?', [:a, :b]),
-      Sequel::SQL::PlaceholderLiteralString.new(':a = :b', [{:a=>:b, :b=>42}]),
-      Sequel::SQL::OrderedExpression.new(:a),
-      Sequel::SQL::OrderedExpression.new(:a, false),
-      Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:first),
-      Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:last),
-      Sequel::SQL::QualifiedIdentifier.new(:b, :a),
-      Sequel::SQL::Subscript.new(:a, [1, 2]),
-      Sequel::SQL::Window.new(:order=>:a, :partition=>:b),
-      Sequel::SQL::Function.new(:a, :b, :c).over(:order=>:a, :partition=>:b),
-      Sequel::SQL::Wrapper.new(:a),
-      
-      # Objects with components where eval(inspect) != self
-      Sequel::SQL::AliasedExpression.new(Sequel::SQL::Blob.new('s'), :a),
-      Sequel::SQL::AliasedExpression.new(Sequel::LiteralString.new('s'), :a),
-      Sequel::SQL::PlaceholderLiteralString.new('(a, b) IN ?', [Sequel::SQL::ValueList.new([[1, 2]])]),
-      Sequel::SQL::CaseExpression.new({{:d=>Sequel::LiteralString.new('e')}=>:a}, :c, :d),
-      Sequel::SQL::AliasedExpression.new(Date.new(2011, 10, 11), :a),
-      Sequel::SQL::AliasedExpression.new(Sequel::SQLTime.create(10, 20, 30, 500000.125), :a),
-      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30), :a),
-      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30, 0.25), :a),
-      Sequel::SQL::AliasedExpression.new(DateTime.new(2011, 9, 11, 10, 20, 30, -0.25), :a),
-      Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30), :a),
-      Sequel::SQL::AliasedExpression.new(Time.local(2011, 9, 11, 10, 20, 30, 500000.125), :a),
-      Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30), :a),
-      Sequel::SQL::AliasedExpression.new(Time.utc(2011, 9, 11, 10, 20, 30, 500000.125), :a),
-      Sequel::SQL::AliasedExpression.new(BigDecimal.new('1.000000000000000000000000000000000000000000000001'), :a),
-      Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_DATE, :a),
-      Sequel::SQL::AliasedExpression.new(Sequel::CURRENT_TIMESTAMP, :a),
-    ].each do |o|
-      v = eval(o.inspect)
-      v.must_equal o
-      @ds.literal(v).must_equal @ds.literal(o)
-    end
-  end
-end

data/spec/extensions/finder_spec.rb

@@ -1,260 +0,0 @@
-require_relative "spec_helper"
-
-describe Sequel::Model, ".finder" do
-  before do
-    @h = {:id=>1}
-    @db = Sequel.mock(:fetch=>@h)
-    @c = Class.new(Sequel::Model(@db[:items]))
-    @c.instance_eval do
-      def foo(a, b)
-        where(:bar=>a).order(b)
-      end
-    end
-    @c.plugin :finder
-    @o = @c.load(@h)
-    @db.sqls
-  end
-
-  it "should create a method that calls the method given and returns the first instance" do
-    @c.finder :foo
-    @c.first_foo(1, 2).must_equal @o
-    @c.first_foo(3, 4).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
-  end
-
-  it "should work correctly when subclassing" do
-    @c.finder(:foo)
-    @sc = Class.new(@c)
-    @sc.set_dataset :foos
-    @db.sqls
-    @sc.first_foo(1, 2).must_equal @sc.load(@h)
-    @sc.first_foo(3, 4).must_equal @sc.load(@h)
-    @db.sqls.must_equal ["SELECT * FROM foos WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
-  end
-
-  it "should work correctly when dataset is modified" do
-    @c.finder(:foo)
-    @c.first_foo(1, 2).must_equal @o
-    @c.set_dataset :foos
-    @c.first_foo(3, 4).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM foos LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
-  end
-
-  it "should create a method based on the given block if no method symbol provided" do
-    @c.finder(:name=>:first_foo){|pl, ds| ds.where(pl.arg).limit(1)}
-    @c.first_foo(:id=>1).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1) LIMIT 1"]
-  end
-
-  it "should raise an error if both a block and method symbol given" do
-    proc{@c.finder(:foo, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if two option hashes are provided" do
-    proc{@c.finder({:name2=>:foo}, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
-  end
-
-  it "should support :type option" do
-    @c.finder :foo, :type=>:all
-    @c.finder :foo, :type=>:each
-    @c.finder :foo, :type=>:get
-
-    a = []
-    @c.all_foo(1, 2){|r| a << r}.must_equal [@o]
-    a.must_equal [@o]
-   
-    a = []
-    @c.each_foo(3, 4){|r| a << r}
-    a.must_equal [@o]
-
-    @c.get_foo(5, 6).must_equal 1
-
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4", "SELECT * FROM items WHERE (bar = 5) ORDER BY 6 LIMIT 1"]
-  end
-
-  it "should support :name option" do
-    @c.finder :foo, :name=>:find_foo
-    @c.find_foo(1, 2).must_equal @o
-    @c.find_foo(3, 4).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
-  end
-
-  it "should support :arity option" do
-    def @c.foobar(*b)
-      ds = dataset
-      b.each_with_index do |a, i|
-        ds = ds.where(i=>a)
-      end
-      ds
-    end
-    @c.finder :foobar, :arity=>1, :name=>:find_foobar_1
-    @c.finder :foobar, :arity=>2, :name=>:find_foobar_2
-    @c.find_foobar_1(:a)
-    @c.find_foobar_2(:a, :b)
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (0 = a) LIMIT 1", "SELECT * FROM items WHERE ((0 = a) AND (1 = b)) LIMIT 1"]
-  end
-
-  it "should support :mod option" do
-    m = Module.new
-    @c.finder :foo, :mod=>m
-    proc{@c.first_foo}.must_raise NoMethodError
-    @c.extend m
-    @c.first_foo(1, 2).must_equal @o
-    @c.first_foo(3, 4).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
-  end
-
-  it "should raise error when calling with the wrong arity" do
-    @c.finder :foo
-    proc{@c.first_foo(1)}.must_raise Sequel::Error
-    proc{@c.first_foo(1,2,3)}.must_raise Sequel::Error
-  end
-end
-
-describe Sequel::Model, ".prepared_finder" do
-  before do
-    @h = {:id=>1}
-    @db = Sequel.mock(:fetch=>@h)
-    @db.extend_datasets do
-      def select_sql
-        sql = super
-        sql << ' -- prepared' if is_a?(Sequel::Dataset::PreparedStatementMethods)
-        sql
-      end
-    end
-    @c = Class.new(Sequel::Model(@db[:items]))
-    @c.instance_eval do
-      def foo(a, b)
-        where(:bar=>a).order(b)
-      end
-    end
-    @c.plugin :finder
-    @o = @c.load(@h)
-    @db.sqls
-  end
-
-  it "should create a method that calls the method given and returns the first instance" do
-    @c.prepared_finder :foo
-    @c.first_foo(1, 2).must_equal @o
-    @c.first_foo(3, 4).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
-  end
-
-  it "should work correctly when subclassing" do
-    @c.prepared_finder(:foo)
-    @sc = Class.new(@c)
-    @sc.set_dataset :foos
-    @db.sqls
-    @sc.first_foo(1, 2).must_equal @sc.load(@h)
-    @sc.first_foo(3, 4).must_equal @sc.load(@h)
-    @db.sqls.must_equal ["SELECT * FROM foos WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
-  end
-
-  it "should work correctly when dataset is modified" do
-    @c.prepared_finder(:foo)
-    @c.first_foo(1, 2).must_equal @o
-    @c.set_dataset :foos
-    @c.first_foo(3, 4).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM foos LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
-  end
-
-  it "should create a method based on the given block if no method symbol provided" do
-    @c.prepared_finder(:name=>:first_foo){|a1| where(:id=>a1).limit(1)}
-    @c.first_foo(1).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1) LIMIT 1 -- prepared"]
-  end
-
-  it "should raise an error if both a block and method symbol given" do
-    proc{@c.prepared_finder(:foo, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if two option hashes are provided" do
-    proc{@c.prepared_finder({:name2=>:foo}, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
-  end
-
-  it "should support :type option" do
-    @c.prepared_finder :foo, :type=>:all
-    @c.prepared_finder :foo, :type=>:each
-
-    a = []
-    @c.all_foo(1, 2){|r| a << r}.must_equal [@o]
-    a.must_equal [@o]
-   
-    a = []
-    @c.each_foo(3, 4){|r| a << r}
-    a.must_equal [@o]
-
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 -- prepared"]
-  end
-
-  it "should support :name option" do
-    @c.prepared_finder :foo, :name=>:find_foo
-    @c.find_foo(1, 2).must_equal @o
-    @c.find_foo(3, 4).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
-  end
-
-  it "should support :arity option" do
-    def @c.foobar(*b)
-      ds = dataset
-      b.each_with_index do |a, i|
-        ds = ds.where(i=>a)
-      end
-      ds
-    end
-    @c.prepared_finder :foobar, :arity=>1, :name=>:find_foobar_1
-    @c.prepared_finder :foobar, :arity=>2, :name=>:find_foobar_2
-    @c.find_foobar_1(:a)
-    @c.find_foobar_2(:a, :b)
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (0 = a) LIMIT 1 -- prepared", "SELECT * FROM items WHERE ((0 = a) AND (1 = b)) LIMIT 1 -- prepared"]
-  end
-
-  it "should support :mod option" do
-    m = Module.new
-    @c.prepared_finder :foo, :mod=>m
-    proc{@c.first_foo}.must_raise NoMethodError
-    @c.extend m
-    @c.first_foo(1, 2).must_equal @o
-    @c.first_foo(3, 4).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
-  end
-
-  it "should handle models with names" do
-    def @c.name; 'foobar' end
-    @c.prepared_finder :foo
-    @c.first_foo(1, 2).must_equal @o
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared"]
-  end
-end
-
-describe "Sequel::Model.freeze" do
-  it "should freeze the model class and not allow any changes" do
-    model = Class.new(Sequel::Model(:items))
-    model.plugin :finder
-    model.finder(:name=>:f_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
-    model.freeze
-    model.f_by_name('a').must_equal model.call(:id=>1, :x=>1)
-    proc{model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}}.must_raise RuntimeError, TypeError
-  end
-
-  it "should freeze a model class without a dataset without breaking" do
-    model = Class.new(Sequel::Model)
-    model.plugin :finder
-    model.freeze
-    proc{model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}}.must_raise RuntimeError, TypeError
-  end
-
-  it "should allow subclasses of frozen model classes to work correctly" do
-    model = Class.new(Sequel::Model(:items))
-    model.plugin :finder
-    model.freeze
-    model = Class.new(model)
-    model.dataset = :items2
-
-    model.dataset_module{}
-    model.plugin Module.new
-    model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
-    model.first_by_name('a').values.must_equal(:id=>1, :x=>1)
-  end
-end
-