sequel 4.36.0 → 5.61.0

data/spec/extensions/serialization_spec.rb

@@ -1,362 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "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.last.must_match(/INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 2|2, '--- 1\n(\.\.\.\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)?')\)/)
-    
-    @c.plugin :serialization, :json, :ghi
-    @c.create(:ghi => [123])
-    DB.sqls.last.must_match(/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 "serialized_columns should be the columns serialized" do
-    @c.plugin :serialization, :yaml, :abc
-    @c.serialized_columns.must_equal [:abc]
-  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._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) LIMIT 1"]
-  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._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) LIMIT 1"]
-  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._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._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._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) LIMIT 1"]
-  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._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) LIMIT 1"]
-  end
-
-  it "should handle registration of custom serializer/deserializer pairs" do
-    @c.set_primary_key :id
-    require '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._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) LIMIT 1"]
-  end
-
-  it "should copy serialization formats and columns to subclasses" do
-    @c.set_primary_key :id
-    @c.plugin :serialization, :yaml, :abc, :def
-    @c.dataset._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) LIMIT 1"]
-  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
-    def (@c.instance_dataset).supports_insert_select?() true end
-    def (@c.instance_dataset).insert_select(*) {:id=>1} 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._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._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._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
-
-end

data/spec/extensions/server_block_spec.rb

@@ -1,90 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-with_server_specs = shared_description do
-  it "should set the default server to use in the block" do
-    @db.with_server(:a){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- a"]
-    @db.with_server(:b){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- b"]
-  end
-
-  it "should have no affect after the block" do
-    @db.with_server(:a){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- a"]
-    @db[:t].all
-    @db.sqls.must_equal ["SELECT * FROM t"]
-  end
-
-  it "should not override specific server inside the block" do
-    @db.with_server(:a){@db[:t].server(:b).all}
-    @db.sqls.must_equal ["SELECT * FROM t -- b"]
-  end
-
-  it "should work correctly when blocks are nested" do
-    @db[:t].all
-    @db.with_server(:a) do
-      @db[:t].all
-      @db.with_server(:b){@db[:t].all}
-      @db[:t].all
-    end
-    @db[:t].all
-    @db.sqls.must_equal ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t"]
-  end
-
-  it "should work correctly for inserts/updates/deletes" do
-    @db.with_server(:a) do
-      @db[:t].insert
-      @db[:t].update(:a=>1)
-      @db[:t].delete
-    end
-    @db.sqls.must_equal ["INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
-  end
-end
-
-describe "Database#with_server single threaded" do
-  before do
-    @db = Sequel.mock(:single_threaded=>true, :servers=>{:a=>{}, :b=>{}})
-    @db.extension :server_block
-  end
-
-  include with_server_specs
-end
-
-describe "Database#with_server multi threaded" do
-  before do
-    @db = Sequel.mock(:servers=>{:a=>{}, :b=>{}, :c=>{}, :d=>{}})
-    @db.extension :server_block
-  end
-
-  include with_server_specs
-
-  it "should respect multithreaded access" do
-    q, q1 = Queue.new, Queue.new
-    
-    t = nil
-    @db[:t].all
-    @db.with_server(:a) do
-      @db[:t].all
-      t = Thread.new do
-        @db[:t].all
-        @db.with_server(:c) do
-          @db[:t].all
-          @db.with_server(:d){@db[:t].all}
-          q.push nil
-          q1.pop
-          @db[:t].all
-        end
-        @db[:t].all
-      end
-      q.pop
-      @db.with_server(:b){@db[:t].all}
-      @db[:t].all
-    end
-    @db[:t].all
-    q1.push nil
-    t.join
-    @db.sqls.must_equal ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t -- d",
-      "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t"]
-  end
-end
-

data/spec/extensions/server_logging_spec.rb

@@ -1,45 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "server_logging extension" do
-  before do
-    @o = Object.new
-    def @o.logs; @logs || []; end
-    def @o.log; logs.length.must_equal 1; logs.first.length.must_equal 1; logs.shift.first; end
-    def @o.to_ary; [self]; end
-    def @o.method_missing(m, *args); (@logs ||= []) << args; end
-    @db = Sequel::mock(:servers=>{:read_only=>{}, :b=>{}}, :logger=>@o).extension(:server_logging)
-  end
-
-  it "should include shard when logging" do
-    @db[:a].all
-    @o.log.must_include "server: read_only) SELECT * FROM a"
-    @db[:a].insert
-    @o.log.must_include "server: default) INSERT INTO a DEFAULT VALUES"
-    @db[:a].server(:b).all
-    @o.log.must_include "server: b) SELECT * FROM a"
-  end
-
-  it "should not include shard when not logging connection info" do
-    @db.log_connection_info = false
-    @db[:a].all
-    log = @o.log
-    log.wont_include "server: read_only) SELECT * FROM a"
-    log.must_include "SELECT * FROM a"
-  end
-
-  it "should not turn on logging connction info if it was turned off" do
-    @db.log_connection_info = false
-    @db.extension :server_logging
-    @db[:a].all
-    log = @o.log
-    log.wont_include "server: read_only) SELECT * FROM a"
-    log.must_include "SELECT * FROM a"
-  end
-
-  it "should remove mapping when disconnecting" do
-    c = @db.synchronize{|c1| c1}
-    @db.disconnect
-    @db.send(:log_connection_execute, c, "SELECT * FROM a")
-    @o.log.must_include "server: ) SELECT * FROM a"
-  end
-end

data/spec/extensions/set_overrides_spec.rb

@@ -1,61 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Dataset #set_defaults" do
-  before do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_defaults(:x=>1)
-  end
-
-  it "should set the default values for inserts" do
-    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:x=>2).must_equal "INSERT INTO items (x) VALUES (2)"
-    @ds.insert_sql(:y=>2).must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
-    @ds.set_defaults(:y=>2).insert_sql.must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
-    @ds.set_defaults(:x=>2).insert_sql.must_equal "INSERT INTO items (x) VALUES (2)"
-  end
-
-  it "should set the default values for updates" do
-    @ds.update_sql.must_equal "UPDATE items SET x = 1"
-    @ds.update_sql(:x=>2).must_equal "UPDATE items SET x = 2"
-    @ds.update_sql(:y=>2).must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
-    @ds.set_defaults(:y=>2).update_sql.must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
-    @ds.set_defaults(:x=>2).update_sql.must_equal "UPDATE items SET x = 2"
-  end
-
-  it "should not affect String update arguments" do
-    @ds.update_sql('y = 2').must_equal "UPDATE items SET y = 2"
-  end
-
-  it "should have working mutation method" do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides)
-    @ds.set_defaults!(:x=>1)
-    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-  end
-end
-
-describe "Sequel::Dataset #set_overrides" do
-  before do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_overrides(:x=>1)
-  end
-
-  it "should override the given values for inserts" do
-    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:x=>2).must_equal "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:y=>2).must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
-    @ds.set_overrides(:y=>2).insert_sql.must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
-    @ds.set_overrides(:x=>2).insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-  end
-
-  it "should override the given values for updates" do
-    @ds.update_sql.must_equal "UPDATE items SET x = 1"
-    @ds.update_sql(:x=>2).must_equal "UPDATE items SET x = 1"
-    @ds.update_sql(:y=>2).must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
-    @ds.set_overrides(:y=>2).update_sql.must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
-    @ds.set_overrides(:x=>2).update_sql.must_equal "UPDATE items SET x = 1"
-  end
-
-  it "should have working mutation method" do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides)
-    @ds.set_overrides!(:x=>1)
-    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-  end
-end