viking-sequel 3.10.0

data/spec/extensions/serialization_spec.rb

@@ -0,0 +1,209 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require 'yaml'
+require 'json'
+
+describe "Serialization plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:items)) do
+      include(Module.new do
+        def before_save
+        end
+      end)
+      no_primary_key
+      columns :id, :abc, :def, :ghi
+    end
+    MODEL_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)
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 2|2, '--- 1\n')\)/
+
+    @c.plugin :serialization, :marshal, :def
+    @c.create(:abc => 1, :def=> 1)
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n')\)/
+    
+    @c.plugin :serialization, :json, :ghi
+    @c.create(:ghi => [123])
+    MODEL_DB.sqls.last.should =~ /INSERT INTO items \((ghi)\) VALUES \('\[123\]'\)/
+  end
+
+  it "should allow serializing attributes to yaml" do
+    @c.plugin :serialization, :yaml, :abc
+    @c.create(:abc => 1)
+    @c.create(:abc => "hello")
+
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
+      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
+    ]
+  end
+
+  it "serialization_format should be the serialization format used" do
+    @c.plugin :serialization, :yaml, :abc
+    @c.serialization_format.should == :yaml
+  end
+
+  it "serialized_columns should be the columns serialized" do
+    @c.plugin :serialization, :yaml, :abc
+    @c.serialized_columns.should == [: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')
+
+    MODEL_DB.sqls.should == [ \
+      "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 = JSON.generate ["hello"]
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (ghi) VALUES ('[1]')", \
+      "INSERT INTO items (ghi) VALUES ('#{x}')", \
+    ]
+  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
+    vals = nil
+
+    ds = @c.dataset
+    def ds.fetch_rows(sql, &block)
+      block.call(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
+    end
+
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
+    o.def.should == "hello"
+
+    o.update(:abc => 23)
+    @c.create(:abc => [1, 2, 3])
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '--- 23\n' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
+  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
+
+    ds = @c.dataset
+    def ds.fetch_rows(sql, &block)
+      block.call(:id => 1, :abc =>[Marshal.dump(1)].pack('m'), :def =>[Marshal.dump('hello')].pack('m'))
+    end
+
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
+    o.def.should == "hello"
+
+    o.update(:abc => 23)
+    @c.create(:abc => [1, 2, 3])
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')"]
+  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
+    
+    ds = @c.dataset
+    def ds.fetch_rows(sql, &block)
+      block.call(:id => 1, :abc => JSON.generate([1]), :def => JSON.generate(["hello"]))
+    end
+    
+    o = @c.first
+    o.id.should == 1
+    o.abc.should == [1]
+    o.abc.should == [1]
+    o.def.should == ["hello"]
+    o.def.should == ["hello"]
+    
+    o.update(:abc => [23])
+    @c.create(:abc => [1,2,3])
+    
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{JSON.generate([23])}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{JSON.generate([1,2,3])}')"]
+  end
+
+  it "should copy serialization formats and columns to subclasses" do
+    @c.set_primary_key :id
+    @c.plugin :serialization, :yaml, :abc, :def
+
+    ds = @c.dataset
+    def ds.fetch_rows(sql, &block)
+      block.call(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
+    end
+
+    o = Class.new(@c).first
+    o.id.should == 1
+    o.abc.should == 1
+    o.abc.should == 1
+    o.def.should == "hello"
+    o.def.should == "hello"
+
+    o.update(:abc => 23)
+    Class.new(@c).create(:abc => [1, 2, 3])
+    MODEL_DB.sqls.should == ["UPDATE items SET abc = '--- 23\n' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
+  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.should == 1
+    o.abc.should == 23
+    o.refresh
+    o.deserialized_values.length.should == 0
+  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)}.should raise_error(Sequel::Error)
+    lambda{o.send(:deserialize_value, :abc, "--- hello\n")}.should raise_error(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.should == "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.should == 9
+  end
+end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "#sti_key" do
+  before do
+    class ::StiTest < Sequel::Model
+      def kind; self[:kind]; end 
+      def kind=(x); self[:kind] = x; end 
+      def _refresh(x); end 
+      plugin :single_table_inheritance, :kind
+    end 
+    class ::StiTestSub1 < StiTest
+    end 
+    class ::StiTestSub2 < StiTest
+    end 
+    @ds = StiTest.dataset
+    MODEL_DB.reset
+  end
+  after do
+    Object.send(:remove_const, :StiTestSub1)
+    Object.send(:remove_const, :StiTestSub2)
+    Object.send(:remove_const, :StiTest)
+  end
+
+  specify "should have simple_table = nil" do
+    StiTest.simple_table.should == nil
+    StiTestSub1.simple_table.should == nil
+  end
+  
+  it "should allow changing the inheritance column via a plugin :single_table_inheritance call" do
+    StiTest.plugin :single_table_inheritance, :blah
+    Object.send(:remove_const, :StiTestSub1)
+    Object.send(:remove_const, :StiTestSub2)
+    class ::StiTestSub1 < StiTest
+    end 
+    class ::StiTestSub2 < StiTest
+    end 
+    def @ds.fetch_rows(sql)
+      yield({:blah=>'StiTest'})
+      yield({:blah=>'StiTestSub1'})
+      yield({:blah=>'StiTestSub2'})
+    end 
+    StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
+    StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.blah = 'StiTestSub1')"
+    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.blah = 'StiTestSub2')"
+  end 
+  
+  it "should return rows with the correct class based on the polymorphic_key value" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'StiTest'})
+      yield({:kind=>'StiTestSub1'})
+      yield({:kind=>'StiTestSub2'})
+    end 
+    StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
+  end 
+
+  it "should fallback to the main class if the given class does not exist" do
+    def @ds.fetch_rows(sql)
+      yield({:kind=>'StiTestSub3'})
+    end
+    StiTest.all.collect{|x| x.class}.should == [StiTest]
+  end
+
+  it "should fallback to the main class if the sti_key field is empty or nil without calling constantize" do
+    called = false
+    StiTest.meta_def(:constantize) do |s|
+      called = true
+      Object
+    end
+    StiTest.plugin :single_table_inheritance, :kind
+    def @ds.fetch_rows(sql)
+      yield({:kind=>''})
+      yield({:kind=>nil})
+    end
+    StiTest.all.collect{|x| x.class}.should == [StiTest, StiTest]
+    called.should == false
+  end
+
+  it "should add a before_create hook that sets the model class name for the key" do
+    StiTest.new.save
+    StiTestSub1.new.save
+    StiTestSub2.new.save
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')"]
+  end
+
+  it "should have the before_create hook not override an existing value" do
+    StiTest.create(:kind=>'StiTestSub1')
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')"]
+  end
+
+  it "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
+    StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
+    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind = 'StiTestSub1')"
+    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (sti_tests.kind = 'StiTestSub2')"
+  end
+end

data/spec/extensions/spec_helper.rb

@@ -0,0 +1,91 @@
+require 'rubygems'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel/core'
+end
+unless Sequel.const_defined?('Model')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel/model'
+end
+
+Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones')
+{:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}.each{|p, opts| Sequel::Model.plugin(p, *opts)}
+
+class MockDataset < Sequel::Dataset
+  def insert(*args)
+    @db.execute insert_sql(*args)
+  end
+  
+  def update(*args)
+    @db.execute update_sql(*args)
+    1
+  end
+  
+  def delete(*args)
+    @db.execute delete_sql(*args)
+    1
+  end
+  
+  def fetch_rows(sql)
+    return if sql =~ /information_schema/
+    @db.execute(sql)
+    yield({:id => 1, :x => 1})
+  end
+
+  def quoted_identifier(c)
+    "\"#{c}\""
+  end
+end
+
+class MockDatabase < Sequel::Database
+  @@quote_identifiers = false
+  self.identifier_input_method = nil
+  self.identifier_output_method = nil
+  attr_reader :sqls
+  
+  def execute(sql, opts={})
+    @sqls ||= []
+    @sqls << sql
+  end
+  
+  def new_sqls
+    s = sqls
+    reset
+    s
+  end
+
+  def reset
+    @sqls = []
+  end
+
+  def schema(table_name, opts)
+    if table_name
+      [[:id, {:primary_key=>true}]]
+    else
+      {table_name=>[[:id, {:primary_key=>true}]]}
+    end
+  end
+
+  def transaction(opts={}); yield; end
+  
+  def dataset(opts=nil); MockDataset.new(self, opts); end
+end
+
+class << Sequel::Model
+  alias orig_columns columns
+  def columns(*cols)
+    return if cols.empty?
+    define_method(:columns){cols}
+    @dataset.instance_variable_set(:@columns, cols) if @dataset
+    def_column_accessor(*cols)
+    @columns = cols
+    @db_schema = {}
+    cols.each{|c| @db_schema[c] = {}}
+  end
+  def simple_table
+    nil
+  end
+end
+
+Sequel::Model.db = MODEL_DB = MockDatabase.new
+Sequel::Model.use_transactions = false

data/spec/extensions/sql_expr_spec.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Sequel sql_expr extension" do
+  specify "Object#sql_expr should wrap the object in a GenericComplexExpression" do
+    o = Object.new
+    s = o.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::GenericComplexExpression)
+    s.op.should == :NOOP
+    s.args.should == [o]
+    (s+1).should be_a_kind_of(Sequel::SQL::NumericExpression)
+    (s & true).should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    (s < 1).should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    s.sql_subscript(1).should be_a_kind_of(Sequel::SQL::Subscript)
+    s.like('a').should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    s.as(:a).should be_a_kind_of(Sequel::SQL::AliasedExpression)
+    s.cast(Integer).should be_a_kind_of(Sequel::SQL::Cast)
+    s.desc.should be_a_kind_of(Sequel::SQL::OrderedExpression)
+    s.sql_string.should be_a_kind_of(Sequel::SQL::StringExpression)
+  end
+
+  specify "Numeric#sql_expr should wrap the object in a NumericExpression" do
+    [1, 2.0, 2^40, BigDecimal.new('1.0')].each do |o|
+      s = o.sql_expr
+      s.should be_a_kind_of(Sequel::SQL::NumericExpression)
+      s.op.should == :NOOP
+      s.args.should == [o]
+    end
+  end
+
+  specify "String#sql_expr should wrap the object in a StringExpression" do
+    o = ""
+    s = o.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::StringExpression)
+    s.op.should == :NOOP
+    s.args.should == [o]
+  end
+
+  specify "NilClass, TrueClass, and FalseClass#sql_expr should wrap the object in a BooleanExpression" do
+    [nil, true, false].each do |o|
+      s = o.sql_expr
+      s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
+      s.op.should == :NOOP
+      s.args.should == [o]
+    end
+  end
+
+  specify "Proc#sql_expr should should treat the object as a virtual row block" do
+    s = proc{a}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.value.should == :a
+
+    s = proc{a__b}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::QualifiedIdentifier)
+    s.table.should == "a"
+    s.column.should == "b"
+
+    s = proc{a(b)}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::Function)
+    s.f.should == :a
+    s.args.length.should == 1
+    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.first.value.should == :b
+  end
+
+  specify "Proc#sql_expr should should wrap the object in a GenericComplexExpression if the object is not already an expression" do
+    s = proc{1}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::GenericComplexExpression)
+    s.op.should == :NOOP
+    s.args.should == [1]
+  end
+
+  specify "Proc#sql_expr should should convert a hash or array of two element arrays to a BooleanExpression" do
+    s = proc{{a=>b}}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    s.op.should == :"="
+    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.first.value.should == :a
+    s.args.last.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.last.value.should == :b
+
+    s = proc{[[a,b]]}.sql_expr
+    s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
+    s.op.should == :"="
+    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.first.value.should == :a
+    s.args.last.should be_a_kind_of(Sequel::SQL::Identifier)
+    s.args.last.value.should == :b
+  end
+end