sequel 5.29.0 → 5.30.0

data/spec/extensions/integer64_spec.rb

@@ -1,22 +0,0 @@
-require_relative "spec_helper"
-
-describe "integer64 extension" do
-  before do
-    @db = Sequel.mock.extension(:integer64)
-  end
-
-  it "should use bigint as default integer type" do
-    @db.create_table(:t){Integer :a; column :b, Integer}
-    @db.sqls.must_equal ['CREATE TABLE t (a bigint, b bigint)']
-  end
-
-  it "should use bigint as default type for primary_key and foreign_key" do
-    @db.create_table(:t){primary_key :id; foreign_key :t_id, :t}
-    @db.sqls.must_equal ['CREATE TABLE t (id bigint PRIMARY KEY AUTOINCREMENT, t_id bigint REFERENCES t)']
-  end
-
-  it "should use bigint when casting" do
-    @db.get(Sequel.cast('a', Integer))
-    @db.sqls.must_equal ["SELECT CAST('a' AS bigint) AS v LIMIT 1"]
-  end
-end

data/spec/extensions/inverted_subsets_spec.rb

@@ -1,33 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::InvertedSubsets" do
-  it "should add an inverted subset method which inverts the condition" do
-    c = Class.new(Sequel::Model(:a))
-    c.plugin :inverted_subsets
-    c.dataset_module{subset(:published, :published => true)}
-    c.not_published.sql.must_equal 'SELECT * FROM a WHERE (published IS NOT TRUE)'
-  end
-
-  it "should support a configuration block to customise the inverted method name" do
-    c = Class.new(Sequel::Model(:a))
-    c.plugin(:inverted_subsets){|name| "exclude_#{name}"}
-    c.dataset_module{where(:published, :published => true)}
-    c.exclude_published.sql.must_equal 'SELECT * FROM a WHERE (published IS NOT TRUE)'
-  end
-
-  it "should chain to existing dataset" do
-    c = Class.new(Sequel::Model(:a))
-    c.plugin :inverted_subsets
-    c.dataset_module{where(:published, :published => true)}
-    c.where(1=>0).not_published.sql.must_equal 'SELECT * FROM a WHERE ((1 = 0) AND (published IS NOT TRUE))'
-  end
-
-  it "should work in subclasses" do
-    c = Class.new(Sequel::Model)
-    c.plugin(:inverted_subsets){|name| "exclude_#{name}"}
-    c = Class.new(c)
-    c.dataset = :a
-    c.dataset_module{subset(:published, :published => true)}
-    c.exclude_published.sql.must_equal 'SELECT * FROM a WHERE (published IS NOT TRUE)'
-  end
-end

data/spec/extensions/json_serializer_spec.rb

@@ -1,346 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::JsonSerializer" do
-  before do
-    class ::Artist < Sequel::Model
-      unrestrict_primary_key
-      plugin :json_serializer, :naked=>true
-      columns :id, :name
-      def_column_accessor :id, :name
-      @db_schema = {:id=>{:type=>:integer}}
-      one_to_many :albums
-    end
-    class ::Album < Sequel::Model
-      unrestrict_primary_key
-      attr_accessor :blah
-      plugin :json_serializer, :naked=>true
-      columns :id, :name, :artist_id
-      def_column_accessor :id, :name, :artist_id
-      many_to_one :artist
-    end
-    @artist = Artist.load(:id=>2, :name=>'YJM')
-    @artist.associations[:albums] = []
-    @album = Album.load(:id=>1, :name=>'RF')
-    @album.artist = @artist
-    @album.blah = 'Blah'
-  end
-  after do
-    Object.send(:remove_const, :Artist)
-    Object.send(:remove_const, :Album)
-  end
-
-  it "should round trip successfully" do
-    Artist.from_json(@artist.to_json).must_equal @artist
-    Album.from_json(@album.to_json).must_equal @album
-  end
-
-  it "should handle ruby objects in values" do
-    class ::Artist
-      def name=(v)
-        super(Date.parse(v))
-      end
-    end
-    Artist.from_json(Artist.load(:name=>Date.today).to_json).must_equal Artist.load(:name=>Date.today)
-  end
-
-  it "should support setting json_serializer_opts on models" do
-    @artist.json_serializer_opts(:only=>:name)
-    Sequel.parse_json([@artist].to_json).must_equal [{'name'=>@artist.name}]
-    @artist.json_serializer_opts(:include=>{:albums=>{:only=>:name}})
-    Sequel.parse_json([@artist].to_json).must_equal [{'name'=>@artist.name, 'albums'=>[{'name'=>@album.name}]}]
-  end
-
-  it "should handle the :only option" do
-    Artist.from_json(@artist.to_json(:only=>:name)).must_equal Artist.load(:name=>@artist.name)
-    Album.from_json(@album.to_json(:only=>[:id, :name])).must_equal Album.load(:id=>@album.id, :name=>@album.name)
-  end
-
-  it "should handle the :except option" do
-    Artist.from_json(@artist.to_json(:except=>:id)).must_equal Artist.load(:name=>@artist.name)
-    Album.from_json(@album.to_json(:except=>[:id, :artist_id])).must_equal Album.load(:name=>@album.name)
-  end
-
-  it "should handle the :include option for associations" do
-    Artist.from_json(@artist.to_json(:include=>:albums), :associations=>:albums).albums.must_equal [@album]
-    Album.from_json(@album.to_json(:include=>:artist), :associations=>:artist).artist.must_equal @artist
-  end
-
-  it "should have #to_json support blocks for transformations" do
-    values = {}
-    @artist.values.each{|k,v| values[k.to_s] = v}
-    Sequel.parse_json(@artist.to_json{|h| {'data'=>h}}).must_equal({'data'=>values})
-  end
-
-  it "should raise an error if attempting to parse json when providing array to non-array association or vice-versa" do
-    proc{Artist.from_json('{"albums":{"id":1,"name":"RF","artist_id":2},"id":2,"name":"YJM"}', :associations=>:albums)}.must_raise(Sequel::Error)
-    proc{Album.from_json('{"artist":[{"id":2,"name":"YJM"}],"id":1,"name":"RF","artist_id":2}', :associations=>:artist)}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if attempting to parse an array containing non-hashes" do
-    proc{Artist.from_json('[{"id":2,"name":"YJM"}, 2]')}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if attempting to parse invalid JSON" do
-    begin
-      Sequel.instance_eval do
-        alias pj parse_json
-        def parse_json(v)
-          v
-        end
-      end
-      proc{Album.from_json('1')}.must_raise(Sequel::Error)
-    ensure
-      Sequel.instance_eval do
-        alias parse_json pj
-      end
-    end
-  end
-
-  it "should handle case where Sequel.parse_json already returns an instance" do
-    begin
-      Sequel.instance_eval do
-        alias pj parse_json
-        def parse_json(v)
-          Album.load(:id=>3)
-        end
-      end
-      ::Album.from_json('1').must_equal Album.load(:id=>3)
-    ensure
-      Sequel.instance_eval do
-        alias parse_json pj
-      end
-    end
-  end
-
-  it "should handle the :include option for arbitrary attributes" do
-    Album.from_json(@album.to_json(:include=>:blah)).blah.must_equal @album.blah
-  end
-
-  it "should handle multiple inclusions using an array for the :include option" do
-    a = Album.from_json(@album.to_json(:include=>[:blah, :artist]), :associations=>:artist)
-    a.blah.must_equal @album.blah
-    a.artist.must_equal @artist
-  end
-
-  it "should handle cascading using a hash for the :include option" do
-    Artist.from_json(@artist.to_json(:include=>{:albums=>{:include=>:artist}}), :associations=>{:albums=>{:associations=>:artist}}).albums.map{|a| a.artist}.must_equal [@artist]
-    Album.from_json(@album.to_json(:include=>{:artist=>{:include=>:albums}}), :associations=>{:artist=>{:associations=>:albums}}).artist.albums.must_equal [@album]
-
-    Artist.from_json(@artist.to_json(:include=>{:albums=>{:only=>:name}}), :associations=>[:albums]).albums.must_equal [Album.load(:name=>@album.name)]
-    Album.from_json(@album.to_json(:include=>{:artist=>{:except=>:name}}), :associations=>[:artist]).artist.must_equal Artist.load(:id=>@artist.id)
-
-    Artist.from_json(@artist.to_json(:include=>{:albums=>{:include=>{:artist=>{:include=>:albums}}}}), :associations=>{:albums=>{:associations=>{:artist=>{:associations=>:albums}}}}).albums.map{|a| a.artist.albums}.must_equal [[@album]]
-    Album.from_json(@album.to_json(:include=>{:artist=>{:include=>{:albums=>{:only=>:name}}}}), :associations=>{:artist=>{:associations=>:albums}}).artist.albums.must_equal [Album.load(:name=>@album.name)]
-  end
-
-  it "should handle usage of association_proxies when cascading using the :include option" do
-    Artist.plugin :association_proxies
-    Artist.one_to_many :albums, :clone=>:albums
-    Artist.from_json(@artist.to_json(:include=>{:albums=>{:include=>:artist}}), :associations=>{:albums=>{:associations=>:artist}}).albums.map{|a| a.artist}.must_equal [@artist]
-  end
-
-  it "should handle the :include option cascading with an empty hash" do
-    Album.from_json(@album.to_json(:include=>{:artist=>{}}), :associations=>:artist).artist.must_equal @artist
-    Album.from_json(@album.to_json(:include=>{:blah=>{}})).blah.must_equal @album.blah
-  end
-
-  it "should accept a :naked option to not include the JSON.create_id, so parsing yields a plain hash" do
-    Sequel.parse_json(@album.to_json(:naked=>true)).must_equal @album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}
-  end
-
-  it "should support #from_json to set column values" do
-    @artist.from_json('{"name": "AS"}')
-    @artist.name.must_equal 'AS'
-    @artist.id.must_equal 2
-  end
-
-  it "should support #from_json to support specific :fields" do
-    @album.from_json('{"name": "AS", "artist_id": 3}', :fields=>['name'])
-    @album.name.must_equal 'AS'
-    @album.artist_id.must_equal 2
-  end
-
-  it "should support #from_json to support :missing=>:skip option" do
-    @album.from_json('{"artist_id": 3}', :fields=>['name'], :missing=>:skip)
-    @album.name.must_equal 'RF'
-    @album.artist_id.must_equal 2
-  end
-
-  it "should support #from_json to support :missing=>:raise option" do
-    proc{@album.from_json('{"artist_id": 3}', :fields=>['name'], :missing=>:raise)}.must_raise(Sequel::Error)
-  end
-
-  it "should have #from_json raise an error if parsed json isn't a hash" do
-    proc{@artist.from_json('[]')}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an exception for json keys that aren't associations, columns, or setter methods" do
-    Album.send(:undef_method, :blah=)
-    proc{Album.from_json(@album.to_json(:include=>:blah))}.must_raise(Sequel::MassAssignmentRestriction)
-  end
-
-  it "should support a to_json class and dataset method" do
-    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
-    Artist.dataset = Artist.dataset.with_fetch(:id=>2, :name=>'YJM')
-    Album.array_from_json(Album.to_json).must_equal [@album]
-    Album.array_from_json(Album.to_json(:include=>:artist), :associations=>:artist).map{|x| x.artist}.must_equal [@artist]
-    Album.array_from_json(Album.dataset.to_json(:only=>:name)).must_equal [Album.load(:name=>@album.name)]
-  end
-
-  it "should support setting json_serializer_opts for datasets" do
-    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
-    Album.array_from_json(Album.dataset.json_serializer_opts(:only=>:name).to_json).must_equal [Album.load(:name=>@album.name)]
-    Album.plugin :json_serializer, :only=>:id
-    Album.array_from_json(Album.dataset.json_serializer_opts(:only=>:name).to_json).must_equal [Album.load(:name=>@album.name)]
-    Album.array_from_json(Album.dataset.json_serializer_opts(:only=>:name).to_json(:only=>:artist_id)).must_equal [Album.load(:artist_id=>2)]
-    json = Album.dataset.json_serializer_opts(:only=>:name, :root=>true).to_json(:only=>:artist_id)
-    Album.array_from_json(JSON.parse(json)['albums'].to_json).must_equal [Album.load(:artist_id=>2)]
-  end
-
-  it "should have dataset to_json method work with eager_graph datasets" do
-    ds = Album.dataset.eager_graph(:artist).with_fetch(:id=>1, :name=>'RF', :artist_id=>2, :artist_id_0=>2, :artist_name=>'YM')
-    Sequel.parse_json(ds.to_json(:only=>:name, :include=>{:artist=>{:only=>:name}})).must_equal [{"name"=>"RF", "artist"=>{"name"=>"YM"}}]
-  end
-
-  it "should have dataset to_json method work with naked datasets" do
-    ds = Album.dataset.naked.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
-    Sequel.parse_json(ds.to_json).must_equal [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
-  end
-
-  it "should have class and dataset to_json method accept blocks for transformations" do
-    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
-    Sequel.parse_json(Album.to_json{|h| {'data'=>h}}).must_equal('data'=>[@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}])
-    Sequel.parse_json(Album.dataset.to_json{|h| {'data'=>h}}).must_equal('data'=>[@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}])
-  end
-
-  it "should have class and dataset to_json method support :instance_block option for instance_transformations" do
-    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
-    Sequel.parse_json(Album.to_json(:instance_block=>lambda{|h| {'data'=>h}})).must_equal [{'data'=>@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}}]
-    Sequel.parse_json(Album.dataset.to_json(:instance_block=>lambda{|h| {'data'=>h}})).must_equal [{'data'=>@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}}]
-  end
-
-  it "should have dataset to_json method respect :array option for the array to use" do
-    a = Album.new(:name=>'RF', :artist_id=>3)
-    Album.array_from_json(Album.to_json(:array=>[a])).must_equal [a]
-
-    a.associations[:artist] = artist = Artist.load(:id=>3, :name=>'YJM')
-    Album.array_from_json(Album.to_json(:array=>[a], :include=>:artist), :associations=>:artist).first.artist.must_equal artist
-
-    artist.associations[:albums] = [a]
-    x = Artist.array_from_json(Artist.to_json(:array=>[artist], :include=>:albums), :associations=>[:albums])
-    x.must_equal [artist]
-    x.first.albums.must_equal [a]
-  end
-
-  it "should propagate class default options to instance to_json output" do
-    class ::Album2 < Sequel::Model
-      attr_accessor :blah
-      plugin :json_serializer, :naked => true, :except => :id
-      columns :id, :name, :artist_id
-      many_to_one :artist
-    end
-    @album2 = Album2.load(:id=>2, :name=>'JK')
-    @album2.artist = @artist
-    @album2.blah = 'Gak'
-    JSON.parse(@album2.to_json).must_equal @album2.values.reject{|k,v| k.to_s == 'id'}.inject({}){|h, (k, v)| h[k.to_s] = v; h}
-    JSON.parse(@album2.to_json(:only => :name)).must_equal @album2.values.reject{|k,v| k.to_s != 'name'}.inject({}){|h, (k, v)| h[k.to_s] = v; h}
-    JSON.parse(@album2.to_json(:except => :artist_id)).must_equal @album2.values.reject{|k,v| k.to_s == 'artist_id'}.inject({}){|h, (k, v)| h[k.to_s] = v; h}
-  end
-  
-  it "should handle the :root option to qualify single records" do
-    @album.to_json(:root=>true, :except => [:name, :artist_id]).to_s.must_equal '{"album":{"id":1}}'
-    @album.to_json(:root=>true, :only => :name).to_s.must_equal '{"album":{"name":"RF"}}'
-  end
-
-  it "should handle the :root option to qualify single records of namespaced models" do
-    module ::Namespace
-      class Album < Sequel::Model
-        plugin :json_serializer, :naked=>true
-      end
-    end
-    Namespace::Album.new({}).to_json(:root=>true).to_s.must_equal '{"album":{}}'
-    Namespace::Album.dataset = Namespace::Album.dataset.with_fetch([{}])
-    Namespace::Album.dataset.to_json(:root=>:collection).to_s.must_equal '{"albums":[{}]}'
-    Namespace::Album.dataset.to_json(:root=>:both).to_s.must_equal '{"albums":[{"album":{}}]}'
-    Object.send(:remove_const, :Namespace)
-  end
-  
-  it "should handle the :root option with a string to qualify single records using the string as the key" do
-    @album.to_json(:root=>"foo", :except => [:name, :artist_id]).to_s.must_equal '{"foo":{"id":1}}'
-    @album.to_json(:root=>"bar", :only => :name).to_s.must_equal '{"bar":{"name":"RF"}}'
-  end
-  
-  it "should handle the :root=>:both option to qualify a dataset of records" do
-    Album.dataset.with_fetch([{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]).to_json(:root=>:both, :only => :id).to_s.must_equal '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
-  end
-
-  it "should handle the :root=>:collection option to qualify just the collection" do
-    ds = Album.dataset.with_fetch([{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}])
-    ds.to_json(:root=>:collection, :only => :id).to_s.must_equal '{"albums":[{"id":1},{"id":1}]}'
-    ds.to_json(:root=>true, :only => :id).to_s.must_equal '{"albums":[{"id":1},{"id":1}]}'
-  end
-
-  it "should handle the :root=>:instance option to qualify just the instances" do
-    Album.dataset.with_fetch([{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]).to_json(:root=>:instance, :only => :id).to_s.must_equal '[{"album":{"id":1}},{"album":{"id":1}}]'
-  end
-
-  it "should handle the :root=>string option to qualify just the collection using the string as the key" do
-    ds = Album.dataset.with_fetch([{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}])
-    ds.to_json(:root=>"foos", :only => :id).to_s.must_equal '{"foos":[{"id":1},{"id":1}]}'
-    ds.to_json(:root=>"bars", :only => :id).to_s.must_equal '{"bars":[{"id":1},{"id":1}]}'
-  end
-
-  it "should use an alias for an included asscociation to qualify an association" do
-    JSON.parse(@album.to_json(:include=>Sequel.as(:artist, :singer)).to_s).must_equal JSON.parse('{"id":1,"name":"RF","artist_id":2,"singer":{"id":2,"name":"YJM"}}')
-    JSON.parse(@album.to_json(:include=>{Sequel.as(:artist, :singer)=>{:only=>:name}}).to_s).must_equal JSON.parse('{"id":1,"name":"RF","artist_id":2,"singer":{"name":"YJM"}}')
-  end
-
-  it "should store the default options in json_serializer_opts" do
-    Album.json_serializer_opts.must_equal(:naked=>true)
-    c = Class.new(Album)
-    c.plugin :json_serializer, :naked=>false
-    c.json_serializer_opts.must_equal(:naked=>false)
-  end
-
-  it "should work correctly when subclassing" do
-    class ::Artist2 < Artist
-      plugin :json_serializer, :only=>:name
-    end
-    Artist2.from_json(Artist2.load(:id=>2, :name=>'YYY').to_json).must_equal Artist2.load(:name=>'YYY')
-    class ::Artist3 < Artist2
-      plugin :json_serializer, :naked=>:true
-    end
-    Sequel.parse_json(Artist3.load(:id=>2, :name=>'YYY').to_json).must_equal("name"=>'YYY')
-    Object.send(:remove_const, :Artist2)
-    Object.send(:remove_const, :Artist3)
-  end
-
-  it "should raise an error if attempting to set a restricted column and :all_columns is not used" do
-    Artist.restrict_primary_key
-    proc{Artist.from_json(@artist.to_json)}.must_raise(Sequel::MassAssignmentRestriction)
-  end
-
-  it "should raise an error if an unsupported association is passed in the :associations option" do
-    Artist.association_reflections.delete(:albums)
-    proc{Artist.from_json(@artist.to_json(:include=>:albums), :associations=>:albums)}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if using from_json and JSON parsing returns an array" do
-    proc{Artist.from_json([@artist].to_json)}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if using array_from_json and JSON parsing does not return an array" do
-    proc{Artist.array_from_json(@artist.to_json)}.must_raise(Sequel::Error)
-  end
-
-  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

@@ -1,183 +0,0 @@
-require_relative "spec_helper"
-require 'yaml'
-
-describe "Sequel::Plugins::LazyAttributes" do
-  before do
-    @db = Sequel.mock
-    def @db.supports_schema_parsing?() true end
-    def @db.schema(*a) [[:id, {:type=>:integer}], [:name,{:type=>:string}]] end
-    class ::LazyAttributesModel < Sequel::Model(@db[:la])
-      plugin :lazy_attributes
-      set_columns([:id, :name])
-      def self.columns; [:id, :name] end
-      lazy_attributes :name
-      def self.columns; [:id] end
-      set_dataset dataset.with_fetch(proc do |sql|
-        if sql !~ /WHERE/
-          if sql =~ /name/
-            [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
-          else
-            [{:id=>1}, {:id=>2}]
-          end
-        else
-          if sql =~ /id IN \(([\d, ]+)\)/
-            $1.split(', ')
-          elsif sql =~ /id = (\d)/
-            [$1]
-          end.map do |x|
-            if sql =~ /SELECT (la.)?name FROM/
-              {:name=>x.to_s}
-            else
-              {:id=>x.to_i, :name=>x.to_s}
-            end
-          end
-        end
-      end)
-    end
-    @c = ::LazyAttributesModel
-    @ds = LazyAttributesModel.dataset
-    @db.sqls
-  end
-  after do
-    Object.send(:remove_const, :LazyAttributesModel)
-  end
-  
-  it "should allowing adding additional lazy attributes via plugin :lazy_attributes" do
-    @c.set_dataset(@ds.select(:id, :blah))
-    @c.dataset.sql.must_equal 'SELECT id, blah FROM la'
-    @c.plugin :lazy_attributes, :blah
-    @c.dataset.sql.must_equal 'SELECT id FROM la'
-  end
-  
-  it "should allowing adding additional lazy attributes via lazy_attributes" do
-    @c.set_dataset(@ds.select(:id, :blah))
-    @c.dataset.sql.must_equal 'SELECT id, blah FROM la'
-    @c.lazy_attributes :blah
-    @c.dataset.sql.must_equal 'SELECT id FROM la'
-  end
-
-  it "should handle lazy attributes that are qualified in the selection" do
-    @c.set_dataset(@ds.select(Sequel[:la][:id], Sequel[:la][:blah]))
-    @c.dataset.sql.must_equal 'SELECT la.id, la.blah FROM la'
-    @c.plugin :lazy_attributes, :blah
-    @c.dataset.sql.must_equal 'SELECT la.id FROM la'
-  end
-  
-  with_symbol_splitting "should handle lazy attributes that are qualified in the selection using symbol splitting" do
-    @c.set_dataset(@ds.select(:la__id, :la__blah))
-    @c.dataset.sql.must_equal 'SELECT la.id, la.blah FROM la'
-    @c.plugin :lazy_attributes, :blah
-    @c.dataset.sql.must_equal 'SELECT la.id FROM la'
-  end
-  
-  it "should remove the attributes given from the SELECT columns of the model's dataset" do
-    @ds.sql.must_equal 'SELECT la.id FROM la'
-  end
-
-  it "should still typecast correctly in lazy loaded column setters" do
-    m = @c.new
-    m.name = 1
-    m.name.must_equal '1'
-  end
-
-  it "should raise error if the model has no primary key" do
-    m = @c.first
-    @c.no_primary_key
-    proc{m.name}.must_raise(Sequel::Error)
-  end
-
-  it "should lazily load the attribute for a single model object" do
-    m = @c.first
-    m.values.must_equal(:id=>1)
-    m.name.must_equal '1'
-    m.values.must_equal(:id=>1, :name=>'1')
-    @db.sqls.must_equal ['SELECT la.id FROM la LIMIT 1', 'SELECT la.name FROM la WHERE (id = 1) LIMIT 1']
-  end
-
-  it "should lazily load the attribute for a frozen model object" do
-    m = @c.first
-    m.freeze
-    m.name.must_equal '1'
-    @db.sqls.must_equal ['SELECT la.id FROM la LIMIT 1', 'SELECT la.name FROM la WHERE (id = 1) LIMIT 1']
-    m.name.must_equal '1'
-    @db.sqls.must_equal ['SELECT la.name FROM la WHERE (id = 1) LIMIT 1']
-  end
-
-  it "should not lazily load the attribute for a single model object if the value already exists" do
-    m = @c.first
-    m.values.must_equal(:id=>1)
-    m[:name] = '1'
-    m.name.must_equal '1'
-    m.values.must_equal(:id=>1, :name=>'1')
-    @db.sqls.must_equal ['SELECT la.id FROM la LIMIT 1']
-  end
-
-  it "should not lazily load the attribute for a single model object if it is a new record" do
-    m = @c.new
-    m.values.must_equal({})
-    m.name.must_be_nil
-    @db.sqls.must_equal []
-  end
-
-  it "should eagerly load the attribute for all model objects reteived with it" do
-    ms = @c.all
-    ms.map{|m| m.values}.must_equal [{:id=>1}, {:id=>2}]
-    ms.map{|m| m.name}.must_equal %w'1 2'
-    ms.map{|m| m.values}.must_equal [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
-    sqls = @db.sqls
-    ['SELECT la.id, la.name FROM la WHERE (la.id IN (1, 2))',
-     'SELECT la.id, la.name FROM la WHERE (la.id IN (2, 1))'].must_include(sqls.pop)
-    sqls.must_equal ['SELECT la.id FROM la']
-  end
-
-  it "should not eagerly load the attribute if model instance is frozen, and deal with other frozen instances if not frozen" do
-    ms = @c.all
-    ms.first.freeze
-    ms.map{|m| m.name}.must_equal %w'1 2'
-    @db.sqls.must_equal ['SELECT la.id FROM la', 'SELECT la.name FROM la WHERE (id = 1) LIMIT 1', 'SELECT la.id, la.name FROM la WHERE (la.id IN (2))']
-  end
-
-  it "should add the accessors to a module included in the class, so they can be easily overridden" do
-    @c.class_eval do
-      def name
-        "#{super}-blah"
-      end
-    end
-    ms = @c.all
-    ms.map{|m| m.values}.must_equal [{:id=>1}, {:id=>2}]
-    ms.map{|m| m.name}.must_equal %w'1-blah 2-blah'
-    ms.map{|m| m.values}.must_equal [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
-    sqls = @db.sqls
-    ['SELECT la.id, la.name FROM la WHERE (la.id IN (1, 2))',
-     'SELECT la.id, la.name FROM la WHERE (la.id IN (2, 1))'].must_include(sqls.pop)
-    sqls.must_equal ['SELECT la.id FROM la']
-  end
-
-  it "should work with the serialization plugin" do
-    @c.plugin :serialization, :yaml, :name
-    @ds = @c.dataset = @ds.with_fetch([[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]])
-    ms = @ds.all
-    ms.map{|m| m.values}.must_equal [{:id=>1}, {:id=>2}]
-    ms.map{|m| m.name}.must_equal [3,6]
-    ms.map{|m| m.values}.must_equal [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}]
-    ms.map{|m| m.deserialized_values}.must_equal [{:name=>3}, {:name=>6}]
-    ms.map{|m| m.name}.must_equal [3,6]
-    sqls = @db.sqls
-    ['SELECT la.id, la.name FROM la WHERE (la.id IN (1, 2))',
-     'SELECT la.id, la.name FROM la WHERE (la.id IN (2, 1))'].must_include(sqls.pop)
-    sqls.must_equal ['SELECT la.id FROM la']
-    m = @ds.first
-    m.values.must_equal(:id=>1)
-    m.name.must_equal 3
-    m.values.must_equal(:id=>1, :name=>"--- 3\n")
-    m.deserialized_values.must_equal(:name=>3)
-    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 not allow additional lazy attributes after freezing" do
-    @c.plugin :lazy_attributes, :blah
-    @c.freeze
-    proc{@c.lazy_attributes :name}.must_raise RuntimeError, TypeError
-  end
-end