sequel 5.8.0 → 5.38.0

data/spec/extensions/select_remove_spec.rb

@@ -1,38 +0,0 @@
-require_relative "spec_helper"
-
-describe "Dataset#select_remove" do
-  before do
-    @d = Sequel.mock.from(:test).extension(:select_remove)
-    @d.columns :a, :b, :c
-  end
-  
-  it "should remove columns from the selected columns" do
-    @d.sql.must_equal 'SELECT * FROM test'
-    @d.select_remove(:a).sql.must_equal 'SELECT b, c FROM test'
-    @d.select_remove(:b).sql.must_equal 'SELECT a, c FROM test'
-    @d.select_remove(:c).sql.must_equal 'SELECT a, b FROM test'
-  end
-
-  it "should work correctly if there are already columns selected" do
-    d = @d.select(:a, :b, :c)
-    d.columns :a, :b, :c
-    d.select_remove(:c).sql.must_equal 'SELECT a, b FROM test'
-  end
-
-  it "should have no effect if the columns given are not currently selected" do
-    @d.select_remove(:d).sql.must_equal 'SELECT a, b, c FROM test'
-  end
-
-  it "should handle expressions where Sequel can't determine the alias by itself" do
-    d = @d.select(:a, Sequel.function(:b), Sequel.as(:c, :b))
-    d.columns :a, :"b()", :b
-    d.select_remove(:"b()").sql.must_equal 'SELECT a, c AS b FROM test'
-  end
-
-  it "should remove expressions if given exact expressions" do
-    d = @d.select(:a, Sequel.function(:b), Sequel.as(:c, :b))
-    d.columns :a, :"b()", :b
-    d.select_remove(Sequel.function(:b)).sql.must_equal 'SELECT a, c AS b FROM test'
-    d.select_remove(Sequel.as(:c, :b)).sql.must_equal 'SELECT a, b() FROM test'
-  end
-end

data/spec/extensions/sequel_4_dataset_methods_spec.rb

@@ -1,121 +0,0 @@
-require_relative "spec_helper"
-
-describe "Dataset#and" do
-  before do
-    @dataset = Sequel.mock.dataset.from(:test).extension(:sequel_4_dataset_methods)
-    @d1 = @dataset.where(:x => 1)
-  end
-  
-  it "should add a WHERE filter if none exists" do
-    @dataset.and(:a => 1).sql.must_equal 'SELECT * FROM test WHERE (a = 1)'
-  end
-  
-  it "should add an expression to the where clause" do
-    @d1.and(:y => 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y = 2))'
-  end
-  
-  it "should accept placeholder literal string filters" do
-    @d1.and(Sequel.lit('y > ?', 2)).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
-  end
-
-  it "should accept expression filters" do
-    @d1.and(Sequel.expr(:yy) > 3).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
-  end
-      
-  it "should accept string filters with placeholders" do
-    @d1.extension(:auto_literal_strings).and('y > ?', 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
-  end
-
-  it "should accept blocks passed to filter" do
-    @d1.and{yy > 3}.sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
-  end
-  
-  it "should correctly add parens to give predictable results" do
-    @d1.or(:y => 2).and(:z => 3).sql.must_equal 'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
-    @d1.and(:y => 2).or(:z => 3).sql.must_equal 'SELECT * FROM test WHERE (((x = 1) AND (y = 2)) OR (z = 3))'
-  end
-end
-
-describe "Dataset#exclude_where" do
-  before do
-    @dataset = Sequel.mock.dataset.from(:test).extension(:sequel_4_dataset_methods)
-  end
-
-  it "should correctly negate the expression and add it to the where clause" do
-    @dataset.exclude_where(:region=>'Asia').sql.must_equal "SELECT * FROM test WHERE (region != 'Asia')"
-    @dataset.exclude_where(:region=>'Asia').exclude_where(:region=>'NA').sql.must_equal "SELECT * FROM test WHERE ((region != 'Asia') AND (region != 'NA'))"
-  end
-
-  it "should affect the where clause even if having clause is already used" do
-    @dataset.group_and_count(:name).having{count > 2}.exclude_where(:region=>'Asia').sql.
-      must_equal "SELECT name, count(*) AS count FROM test WHERE (region != 'Asia') GROUP BY name HAVING (count > 2)"
-  end
-end
-
-describe "Dataset#interval" do
-  before do
-    @db = Sequel.mock(:fetch=>{:v => 1234}).extension(:sequel_4_dataset_methods)
-    @ds = @db[:test].freeze
-  end
-  
-  it "should generate the correct SQL statement" do
-    5.times do
-      @ds.interval(:stamp)
-      @db.sqls.must_equal ["SELECT (max(stamp) - min(stamp)) AS interval FROM test LIMIT 1"]
-    end
-
-    @ds.filter(Sequel.expr(:price) > 100).interval(:stamp)
-    @db.sqls.must_equal ["SELECT (max(stamp) - min(stamp)) AS interval FROM test WHERE (price > 100) LIMIT 1"]
-  end
-  
-  it "should use a subselect for the same conditions as count" do
-    ds = @ds.order(:stamp).limit(5)
-    5.times do
-      ds.interval(:stamp).must_equal 1234
-      @db.sqls.must_equal ['SELECT (max(stamp) - min(stamp)) AS interval FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
-    end
-  end
-
-  it "should accept virtual row blocks" do
-    5.times do
-      @ds.interval{a(b)}
-      @db.sqls.must_equal ["SELECT (max(a(b)) - min(a(b))) AS interval FROM test LIMIT 1"]
-    end
-  end
-end
-
-describe "Dataset#range" do
-  before do
-    @db = Sequel.mock(:fetch=>{:v1 => 1, :v2 => 10}).extension(:sequel_4_dataset_methods)
-    @ds = @db[:test].freeze
-  end
-  
-  it "should generate a correct SQL statement" do
-    5.times do
-      @ds.range(:stamp)
-      @db.sqls.must_equal ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"]
-    end
-
-    @ds.filter(Sequel.expr(:price) > 100).range(:stamp)
-    @db.sqls.must_equal ["SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test WHERE (price > 100) LIMIT 1"]
-  end
-  
-  it "should return a range object" do
-    5.times do
-      @ds.range(:tryme).must_equal(1..10)
-    end
-  end
-  
-  it "should use a subselect for the same conditions as count" do
-    @ds.order(:stamp).limit(5).range(:stamp).must_equal(1..10)
-    @db.sqls.must_equal ['SELECT min(stamp) AS v1, max(stamp) AS v2 FROM (SELECT * FROM test ORDER BY stamp LIMIT 5) AS t1 LIMIT 1']
-  end
-  
-  it "should accept virtual row blocks" do
-    5.times do
-      @ds.range{a(b)}
-      @db.sqls.must_equal ["SELECT min(a(b)) AS v1, max(a(b)) AS v2 FROM test LIMIT 1"]
-    end
-  end
-end
-

data/spec/extensions/serialization_modification_detection_spec.rb

@@ -1,98 +0,0 @@
-require_relative "spec_helper"
-require 'yaml'
-
-describe "serialization_modification_detection plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
-      columns :id, :h
-      plugin :serialization, :yaml, :h
-      plugin :serialization_modification_detection
-    end
-    @o1 = @c.new(:h=>{})
-    @o2 = @c.load(:id=>1, :h=>"--- {}\n\n")
-    @o3 = @c.new
-    @o4 = @c.load(:id=>1, :h=>nil)
-    DB.reset
-  end
-  
-  it "should not detect columns that haven't been changed" do
-    @o1.changed_columns.must_equal []
-    @o1.h.must_equal({})
-    @o1.h[1] = 2
-    @o1.h.clear
-    @o1.changed_columns.must_equal []
-
-    @o2.changed_columns.must_equal []
-    @o2.h.must_equal({})
-    @o2.h[1] = 2
-    @o2.h.clear
-    @o2.changed_columns.must_equal []
-  end
-  
-  it "should detect columns that have been changed" do
-    @o1.changed_columns.must_equal []
-    @o1.h.must_equal({})
-    @o1.h[1] = 2
-    @o1.changed_columns.must_equal [:h]
-
-    @o2.changed_columns.must_equal []
-    @o2.h.must_equal({})
-    @o2.h[1] = 2
-    @o2.changed_columns.must_equal [:h]
-
-    @o3.changed_columns.must_equal []
-    @o3.h.must_be_nil
-    @o3.h = {}
-    @o3.changed_columns.must_equal [:h]
-
-    @o4.changed_columns.must_equal []
-    @o4.h.must_be_nil
-    @o4.h = {}
-    @o4.changed_columns.must_equal [:h]
-  end
-  
-  it "should report correct changed_columns after saving" do
-    @o1.h[1] = 2
-    @o1.save
-    @o1.changed_columns.must_equal []
-
-    @o2.h[1] = 2
-    @o2.save_changes
-    @o2.changed_columns.must_equal []
-
-    @o3.h = {1=>2}
-    @o3.save
-    @o3.changed_columns.must_equal []
-
-    @o4.h = {1=>2}
-    @o4.save
-    @o4.changed_columns.must_equal []
-  end
-
-  it "should work with frozen objects" do
-    @o1.changed_columns.must_equal []
-    @o1.h.must_equal({})
-    @o1.freeze
-    @o1.h[1] = 2
-    @o1.changed_columns.must_equal [:h]
-  end
-
-  it "should work with duplicating objects" do
-    @o2.changed_columns.must_equal []
-    o = @o2.dup
-    @o2.h.must_equal({})
-    @o2.h[1] = 2
-    @o2.changed_columns.must_equal [:h]
-    o.changed_columns.must_equal []
-  end
-
-  it "should work with duplicating objects after modifying them" do
-    @o2.changed_columns.must_equal []
-    @o2.h.must_equal({})
-    @o2.h[1] = 2
-    @o2.changed_columns.must_equal [:h]
-    o = @o2.dup
-    o.changed_columns.must_equal [:h]
-  end
-end

data/spec/extensions/serialization_spec.rb

@@ -1,365 +0,0 @@
-require_relative "spec_helper"
-
-require 'yaml'
-require 'json'
-
-describe "Serialization plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-      columns :id, :abc, :def, :ghi
-    end
-    DB.reset
-  end
-  
-  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.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.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.must_equal ["INSERT INTO items (ghi) VALUES ('[123]')"]
-  end
-
-  it "should handle validations of underlying column" do
-    @c.plugin :serialization, :yaml, :abc
-    o = @c.new
-    def o.validate
-      errors.add(:abc, "not present") unless self[:abc]
-    end
-    o.valid?.must_equal false
-    o.abc = {}
-    o.valid?.must_equal true
-  end
-
-  it "should set column values even when not validating" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :yaml, :abc
-    @c.load({:id=>1}).set(:abc=>{}).save(:validate=>false)
-    DB.sqls.last.gsub("\n", '').must_equal "UPDATE items SET abc = '--- {}' WHERE (id = 1)"
-  end
-
-  it "should allow serializing attributes to yaml" do
-    @c.plugin :serialization, :yaml, :abc
-    @c.create(:abc => 1)
-    @c.create(:abc => "hello")
-
-    DB.sqls.map{|s| s.sub("...\n", '')}.must_equal ["INSERT INTO items (abc) VALUES ('--- 1\n')", "INSERT INTO items (abc) VALUES ('--- hello\n')"]
-  end
-
-  it "should allow serializing attributes to marshal" do
-    @c.plugin :serialization, :marshal, :abc
-    @c.create(:abc => 1)
-    @c.create(:abc => "hello")
-    x = [Marshal.dump("hello")].pack('m')
-
-    DB.sqls.must_equal [ \
-      "INSERT INTO items (abc) VALUES ('BAhpBg==\n')", \
-      "INSERT INTO items (abc) VALUES ('#{x}')", \
-    ]
-  end
-  
-  it "should allow serializing attributes to json" do
-    @c.plugin :serialization, :json, :ghi
-    @c.create(:ghi => [1])
-    @c.create(:ghi => ["hello"])
-    
-    x = ["hello"].to_json
-    DB.sqls.must_equal [ \
-      "INSERT INTO items (ghi) VALUES ('[1]')", \
-      "INSERT INTO items (ghi) VALUES ('#{x}')", \
-    ]
-  end
-
-  it "should allow serializing attributes using arbitrary callable" do
-    @c.plugin :serialization, [proc{|s| s.reverse}, proc{}], :abc
-    @c.create(:abc => "hello")
-    DB.sqls.must_equal ["INSERT INTO items (abc) VALUES ('olleh')"]
-  end
-  
-  it "should raise an error if specificing serializer as an unregistered symbol" do
-    proc{@c.plugin :serialization, :foo, :abc}.must_raise(Sequel::Error)
-  end
-  
-  it "should translate values to and from yaml serialization format using accessor methods" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :yaml, :abc, :def
-    @c.dataset = @c.dataset.with_fetch(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-
-    o = @c.first
-    o.id.must_equal 1
-    o.abc.must_equal 1
-    o.abc.must_equal 1
-    o.def.must_equal "hello"
-    o.def.must_equal "hello"
-
-    o.update(:abc => 23)
-    @c.create(:abc => [1, 2, 3])
-    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
-      "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
-      "SELECT * FROM items WHERE id = 10"]
-  end
-
-  it "should translate values to and from marshal serialization format using accessor methods" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :marshal, :abc, :def
-    @c.dataset = @c.dataset.with_fetch([:id => 1, :abc =>[Marshal.dump(1)].pack('m'), :def =>[Marshal.dump('hello')].pack('m')])
-
-    o = @c.first
-    o.id.must_equal 1
-    o.abc.must_equal 1
-    o.abc.must_equal 1
-    o.def.must_equal "hello"
-    o.def.must_equal "hello"
-
-    o.update(:abc => 23)
-    @c.create(:abc => [1, 2, 3])
-    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
-      "UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')",
-      "SELECT * FROM items WHERE id = 10"]
-  end
-  
-  it "should handle old non-base-64 encoded marshal serialization format" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :marshal, :abc, :def
-    @c.dataset = @c.dataset.with_fetch([:id => 1, :abc =>Marshal.dump(1), :def =>Marshal.dump('hello')])
-
-    o = @c.first
-    o.abc.must_equal 1
-    o.def.must_equal "hello"
-  end
-
-  it "should raise exception for bad marshal data" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :marshal, :abc, :def
-    @c.dataset = @c.dataset.with_fetch([:id => 1, :abc =>'foo', :def =>'bar'])
-
-    o = @c.first
-    proc{o.abc}.must_raise TypeError, ArgumentError
-    proc{o.def}.must_raise TypeError, ArgumentError
-  end
-  
-  it "should translate values to and from json serialization format using accessor methods" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :json, :abc, :def
-    @c.dataset = @c.dataset.with_fetch(:id => 1, :abc => [1].to_json, :def => ["hello"].to_json)
-    
-    o = @c.first
-    o.id.must_equal 1
-    o.abc.must_equal [1]
-    o.abc.must_equal [1]
-    o.def.must_equal ["hello"]
-    o.def.must_equal ["hello"]
-    
-    o.update(:abc => [23])
-    @c.create(:abc => [1,2,3])
-    
-    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
-      "UPDATE items SET abc = '#{[23].to_json}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1,2,3].to_json}')",
-      "SELECT * FROM items WHERE id = 10"]
-  end
-
-  it "should translate values to and from arbitrary callables using accessor methods" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, [proc{|s| s.reverse}, proc{|s| s.reverse}], :abc, :def
-    @c.dataset = @c.dataset.with_fetch(:id => 1, :abc => 'cba', :def => 'olleh')
-    
-    o = @c.first
-    o.id.must_equal 1
-    o.abc.must_equal 'abc'
-    o.abc.must_equal 'abc'
-    o.def.must_equal "hello"
-    o.def.must_equal "hello"
-    
-    o.update(:abc => 'foo')
-    @c.create(:abc => 'bar')
-    
-    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
-      "UPDATE items SET abc = 'oof' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('rab')",
-      "SELECT * FROM items WHERE id = 10"]
-  end
-
-  it "should handle registration of custom serializer/deserializer pairs" do
-    @c.set_primary_key :id
-    require_relative '../../lib/sequel/plugins/serialization'
-    Sequel::Plugins::Serialization.register_format(:reverse, proc{|s| s.reverse}, proc{|s| s.reverse})
-    @c.plugin :serialization, :reverse, :abc, :def
-    @c.dataset = @c.dataset.with_fetch(:id => 1, :abc => 'cba', :def => 'olleh')
-    
-    o = @c.first
-    o.id.must_equal 1
-    o.abc.must_equal 'abc'
-    o.abc.must_equal 'abc'
-    o.def.must_equal "hello"
-    o.def.must_equal "hello"
-    
-    o.update(:abc => 'foo')
-    @c.create(:abc => 'bar')
-    
-    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
-      "UPDATE items SET abc = 'oof' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('rab')",
-      "SELECT * FROM items WHERE id = 10"]
-  end
-
-  it "should copy serialization formats and columns to subclasses" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :yaml, :abc, :def
-    @c.dataset = @c.dataset.with_fetch(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-
-    o = Class.new(@c).first
-    o.id.must_equal 1
-    o.abc.must_equal 1
-    o.abc.must_equal 1
-    o.def.must_equal "hello"
-    o.def.must_equal "hello"
-
-    o.update(:abc => 23)
-    Class.new(@c).create(:abc => [1, 2, 3])
-    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
-      "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
-      "SELECT * FROM items WHERE id = 10"]
-  end
-
-  it "should clear the deserialized columns when refreshing" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :yaml, :abc, :def
-    o = @c.load(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    o.abc = 23
-    o.deserialized_values.length.must_equal 1
-    o.abc.must_equal 23
-    o.refresh
-    o.deserialized_values.length.must_equal 0
-  end
-  
-  it "should not clear the deserialized columns when refreshing after saving a new object" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :yaml, :abc, :def
-    o = @c.new(:abc => "--- 1\n", :def => "--- hello\n")
-    o.deserialized_values.length.must_equal 2
-    o.save
-    o.deserialized_values.length.must_equal 2
-  end
-  
-  it "should not clear the deserialized columns when refreshing after saving a new object with insert_select" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :yaml, :abc, :def
-    @c.dataset = @c.dataset.with_extend do
-      def supports_insert_select?; true end
-      def insert_select(*) {:id=>1} end
-    end
-    o = @c.new(:abc => "--- 1\n", :def => "--- hello\n")
-    o.deserialized_values.length.must_equal 2
-    o.save
-    o.deserialized_values.length.must_equal 2
-  end
-  
-  it "should raise an error if calling internal serialization methods with bad columns" do
-    @c.set_primary_key :id
-    @c.plugin :serialization
-    o = @c.load(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    lambda{o.send(:serialize_value, :abc, 1)}.must_raise(Sequel::Error)
-    lambda{o.send(:deserialize_value, :abc, "--- hello\n")}.must_raise(Sequel::Error)
-  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 abc
-        "#{super}-blah"
-      end
-    end
-    @c.plugin :serialization, :yaml, :abc
-    o = @c.load(:abc => "--- 1\n")
-    o.abc.must_equal "1-blah"
-  end
-
-  it "should call super to get the deserialized value from a previous accessor" do
-    m = Module.new do
-      def abc
-        "--- #{@values[:abc]*3}\n"
-      end
-    end
-    @c.send(:include, m)
-    @c.plugin :serialization, :yaml, :abc
-    o = @c.load(:abc => 3)
-    o.abc.must_equal 9
-  end
-
-  it "should work correctly with frozen instances" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :yaml, :abc, :def
-    @c.dataset = @c.dataset.with_fetch(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-
-    o = @c.first
-    o.freeze
-    o.abc.must_equal 1
-    o.abc.must_equal 1
-    o.def.must_equal "hello"
-    o.def.must_equal "hello"
-    proc{o.abc = 2}.must_raise
-    proc{o.def = 'h'}.must_raise
-  end
-
-  it "should have dup duplicate internal structures" do
-    @c.plugin :serialization, :yaml, :abc, :def
-    o = @c.new
-    o.dup.deserialized_values.must_equal o.deserialized_values
-    o.dup.deserialized_values.wont_be_same_as(o.deserialized_values)
-  end
-
-  it "should have changed_columns include serialized columns if those columns have changed" do
-    @c.plugin :serialization, :yaml, :abc, :def
-    @c.dataset = @c.dataset.with_fetch(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    o = @c.first
-    o.changed_columns.must_equal []
-    o.abc = 1
-    o.changed_columns.must_equal []
-    o.abc = 1
-    o.changed_columns.must_equal []
-    o.abc = 2
-    o.changed_columns.must_equal [:abc]
-    o.def = 'hello'
-    o.changed_columns.must_equal [:abc]
-    o.def = 'hello'
-    o.changed_columns.must_equal [:abc]
-    o.def = 'hello2'
-    o.changed_columns.must_equal [:abc, :def]
-  end
-
-  it "should update column_changes if the dirty plugin is used" do
-    @c.plugin :serialization, :yaml, :abc, :def
-    @c.plugin :dirty
-    @c.dataset = @c.dataset.with_fetch(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    o = @c.first
-    o.column_changes.must_equal({})
-    o.abc = 1
-    o.column_changes.must_equal({})
-    o.abc = 1
-    o.column_changes.must_equal({})
-    o.abc = 2
-    o.column_changes.must_equal(:abc=>[1, 2])
-    o.def = 'hello'
-    o.column_changes.must_equal(:abc=>[1, 2])
-    o.def = 'hello'
-    o.column_changes.must_equal(:abc=>[1, 2])
-    o.def = 'hello2'
-    o.column_changes.must_equal(:abc=>[1, 2], :def=>["hello", "hello2"])
-  end
-
-  it "should freeze serialization metadata when freezing model class" do
-    @c.plugin :serialization, :yaml, :abc, :def
-    @c.freeze
-    @c.serialization_map.frozen?.must_equal true
-    @c.deserialization_map.frozen?.must_equal true
-  end
-end