viking-sequel 3.10.0

data/spec/integration/spec_helper.rb

@@ -0,0 +1,73 @@
+require 'rubygems'
+require 'logger'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel'
+end
+begin
+  require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb') unless defined?(INTEGRATION_DB)
+rescue LoadError
+end
+
+Sequel::Model.use_transactions = false
+
+$sqls = []
+def clear_sqls
+  $sqls.clear
+end 
+
+class Spec::Example::ExampleGroup
+  def log
+    begin
+      INTEGRATION_DB.loggers << Logger.new(STDOUT)
+      yield
+    ensure
+     INTEGRATION_DB.loggers.pop
+    end
+  end
+  
+  def self.log_specify(message, &block)
+    specify(message){log{instance_eval(&block)}}
+  end
+
+  def self.cspecify(message, *checked, &block)
+    pending = false
+    checked.each do |c|
+      case c
+      when INTEGRATION_DB.database_type
+        pending = c
+      when Array
+        case c.length
+        when 1
+          pending = c if c.first == INTEGRATION_DB.class.adapter_scheme
+        when 2
+          if c.first.is_a?(Proc)
+            pending = c if c.first.call(INTEGRATION_DB) && c.last == INTEGRATION_DB.database_type
+          elsif c.last.is_a?(Proc)
+            pending = c if c.first == INTEGRATION_DB.class.adapter_scheme && c.last.call(INTEGRATION_DB)
+          else
+            pending = c if c.first == INTEGRATION_DB.class.adapter_scheme && c.last == INTEGRATION_DB.database_type
+          end
+        when 3
+          pending = c if c[0] == INTEGRATION_DB.class.adapter_scheme && c[1] == INTEGRATION_DB.database_type && c[2].call(INTEGRATION_DB)
+        end          
+      end
+      break if pending
+    end
+    if pending
+      specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
+    else
+      specify(message, &block)
+    end
+  end
+end
+
+if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRATION_URL']
+  unless defined?(INTEGRATION_DB)
+    url = defined?(INTEGRATION_URL) ? INTEGRATION_URL : ENV['SEQUEL_INTEGRATION_URL']
+    INTEGRATION_DB = Sequel.connect(url)
+    #INTEGRATION_DB.instance_variable_set(:@server_version, 80100)
+  end
+else
+  INTEGRATION_DB = Sequel.sqlite('', :quote_identifiers=>false)
+end

data/spec/integration/timezone_test.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Sequel timezone support" do
+  def test_timezone
+    t = Time.now
+    @db[:t].insert(t)
+    t2 = @db[:t].single_value
+    t2 = Sequel.database_to_application_timestamp(t2.to_s) unless t2.is_a?(Time)
+    (t2 - t).should be_close(0, 2)
+    t2.utc_offset.should == 0 if Sequel.application_timezone == :utc
+    t2.utc_offset.should == t.getlocal.utc_offset if Sequel.application_timezone == :local
+    @db[:t].delete
+    
+    dt = DateTime.now
+    Sequel.datetime_class = DateTime
+    @db[:t].insert(dt)
+    dt2 = @db[:t].single_value
+    dt2 = Sequel.database_to_application_timestamp(dt2.to_s) unless dt2.is_a?(DateTime)
+    (dt2 - dt).should be_close(0, 0.00002)
+    dt2.offset.should == 0 if Sequel.application_timezone == :utc
+    dt2.offset.should == dt.offset if Sequel.application_timezone == :local
+  end
+  
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:t){DateTime :t}
+  end
+  after do
+    @db.drop_table(:t)
+    Sequel.default_timezone = nil
+    Sequel.datetime_class = Time
+  end
+
+  cspecify "should support using UTC for database storage and local time for the application", [:do, proc{|db| db.database_type != :sqlite}] do
+    Sequel.database_timezone = :utc
+    Sequel.application_timezone = :local
+    test_timezone
+  end
+  
+  cspecify "should support using local time for database storage and UTC for the application", [:do, proc{|db| db.database_type != :sqlite}] do
+    Sequel.database_timezone = :local
+    Sequel.application_timezone = :utc
+    test_timezone
+  end
+  
+  cspecify "should support using UTC for both database storage and for application", [:do, proc{|db| db.database_type != :sqlite}] do
+    Sequel.default_timezone = :utc
+    test_timezone
+  end
+  
+  specify "should support using local time for both database storage and for application" do
+    Sequel.default_timezone = :local
+    test_timezone
+  end
+end

data/spec/integration/transaction_test.rb

@@ -0,0 +1,122 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Database transactions" do
+  before do
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+    INTEGRATION_DB.create_table(:items, :engine=>'InnoDB'){String :name; Integer :value}
+    @d = INTEGRATION_DB[:items]
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+  end
+
+  specify "should support transactions" do
+    INTEGRATION_DB.transaction do
+      @d << {:name => 'abc', :value => 1}
+    end
+
+    @d.count.should == 1
+  end
+
+  specify "should have #transaction yield the connection" do
+    INTEGRATION_DB.transaction do |conn|
+      conn.should_not == nil
+    end
+  end
+
+  specify "should correctly rollback transactions" do
+    proc do
+      INTEGRATION_DB.transaction do
+        @d << {:name => 'abc', :value => 1}
+        raise Interrupt, 'asdf'
+      end
+    end.should raise_error(Interrupt)
+
+    proc do
+      INTEGRATION_DB.transaction do
+        @d << {:name => 'abc', :value => 1}
+        raise Sequel::Rollback
+      end
+    end.should_not raise_error
+
+    @d.count.should == 0
+  end
+
+  specify "should support nested transactions" do
+    @db = INTEGRATION_DB
+    @db.transaction do
+      @db.transaction do
+        @d << {:name => 'abc', :value => 1}
+      end 
+    end 
+    @d.count.should == 1
+
+    @d.delete
+    proc {@db.transaction do
+      @d << {:name => 'abc', :value => 1}
+      @db.transaction do
+        raise Sequel::Rollback
+      end 
+    end}.should_not raise_error
+    @d.count.should == 0
+
+    proc {@db.transaction do
+      @d << {:name => 'abc', :value => 1}
+      @db.transaction do
+        raise Interrupt, 'asdf'
+      end 
+    end}.should raise_error(Interrupt)
+    @d.count.should == 0
+  end 
+  
+  if INTEGRATION_DB.supports_savepoints?
+    cspecify "should support nested transactions through savepoints using the savepoint option", [:jdbc, :sqlite] do
+      @db = INTEGRATION_DB
+      @db.transaction do
+        @d << {:name => '1'}
+        @db.transaction(:savepoint=>true) do
+          @d << {:name => '2'}
+          @db.transaction do
+            @d << {:name => '3'}
+            raise Sequel::Rollback
+          end
+        end
+        @d << {:name => '4'}
+        @db.transaction do
+          @d << {:name => '6'}
+          @db.transaction(:savepoint=>true) do
+            @d << {:name => '7'}
+            raise Sequel::Rollback
+          end
+        end
+        @d << {:name => '5'}
+      end
+
+      @d.order(:name).map(:name).should == %w{1 4 5 6}
+    end
+  end
+
+  specify "should handle returning inside of the block by committing" do
+    def INTEGRATION_DB.ret_commit
+      transaction do
+        self[:items] << {:name => 'abc'}
+        return
+        self[:items] << {:name => 'd'}
+      end
+    end
+
+    @d.count.should == 0
+    INTEGRATION_DB.ret_commit
+    @d.count.should == 1
+    INTEGRATION_DB.ret_commit
+    @d.count.should == 2
+    proc do
+      INTEGRATION_DB.transaction do
+        raise Interrupt, 'asdf'
+      end
+    end.should raise_error(Interrupt)
+
+    @d.count.should == 2
+  end
+end

data/spec/integration/type_test.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Supported types" do
+  def create_items_table_with_column(name, type, opts={})
+    INTEGRATION_DB.create_table!(:items){column name, type, opts}
+    INTEGRATION_DB[:items]
+  end
+
+  cspecify "should support casting correctly", [:sqlite, :sqlite] do
+    ds = create_items_table_with_column(:number, Integer)
+    ds.insert(:number => 1)
+    ds.select(:number.cast_string.as(:n)).map(:n).should == %w'1'
+    ds = create_items_table_with_column(:name, String)
+    ds.insert(:name=> '1')
+    ds.select(:name.cast_numeric.as(:n)).map(:n).should == [1]
+  end
+
+  specify "should support NULL correctly" do
+    ds = create_items_table_with_column(:number, Integer)
+    ds.insert(:number => nil)
+    ds.all.should == [{:number=>nil}]
+  end
+
+  specify "should support generic integer type" do
+    ds = create_items_table_with_column(:number, Integer)
+    ds.insert(:number => 2)
+    ds.all.should == [{:number=>2}]
+  end
+  
+  specify "should support generic fixnum type" do
+    ds = create_items_table_with_column(:number, Fixnum)
+    ds.insert(:number => 2)
+    ds.all.should == [{:number=>2}]
+  end
+  
+  specify "should support generic bignum type" do
+    ds = create_items_table_with_column(:number, Bignum)
+    ds.insert(:number => 2**34)
+    ds.all.should == [{:number=>2**34}]
+  end
+  
+  specify "should support generic float type" do
+    ds = create_items_table_with_column(:number, Float)
+    ds.insert(:number => 2.1)
+    ds.all.should == [{:number=>2.1}]
+  end
+  
+  cspecify "should support generic numeric type", [:odbc, :mssql] do
+    ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
+    ds.insert(:number => BigDecimal.new('2.123456789'))
+    ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
+    ds = create_items_table_with_column(:number, BigDecimal, :size=>[15, 10])
+    ds.insert(:number => BigDecimal.new('2.123456789'))
+    ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
+  end
+
+  specify "should support generic string type" do
+    ds = create_items_table_with_column(:name, String)
+    ds.insert(:name => 'Test User')
+    ds.all.should == [{:name=>'Test User'}]
+  end
+  
+  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], :mssql do
+    ds = create_items_table_with_column(:dat, Date)
+    d = Date.today
+    ds.insert(:dat => d)
+    ds.first[:dat].should == d
+  end
+  
+  cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
+    ds = create_items_table_with_column(:tim, DateTime)
+    t = DateTime.now
+    ds.insert(:tim => t)
+    ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
+    ds = create_items_table_with_column(:tim, Time)
+    t = Time.now
+    ds.insert(:tim => t)
+    ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
+  end
+  
+  cspecify "should support generic file type", [:do], [:odbc, :mssql] do
+    ds = create_items_table_with_column(:name, File)
+    ds.insert(:name => ("a\0"*300).to_sequel_blob)
+    ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]
+    ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
+  end
+  
+  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:odbc, :mssql] do
+    ds = create_items_table_with_column(:number, TrueClass)
+    ds.insert(:number => true)
+    ds.all.should == [{:number=>true}]
+    ds = create_items_table_with_column(:number, FalseClass)
+    ds.insert(:number => true)
+    ds.all.should == [{:number=>true}]
+  end
+end

data/spec/model/association_reflection_spec.rb

@@ -0,0 +1,175 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model::Associations::AssociationReflection, "#associated_class" do
+  before do
+    @c = Class.new(Sequel::Model)
+    class ::ParParent < Sequel::Model; end
+  end
+
+  it "should use the :class value if present" do
+    @c.many_to_one :c, :class=>ParParent
+    @c.association_reflection(:c).keys.should include(:class)
+    @c.association_reflection(:c).associated_class.should == ParParent
+  end
+  it "should figure out the class if the :class value is not present" do
+    @c.many_to_one :c, :class=>'ParParent'
+    @c.association_reflection(:c).keys.should_not include(:class)
+    @c.association_reflection(:c).associated_class.should == ParParent
+  end
+end
+
+describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do
+  before do
+    @c = Class.new(Sequel::Model)
+    class ::ParParent < Sequel::Model; end
+  end
+
+  it "should use the :primary_key value if present" do
+    @c.many_to_one :c, :class=>ParParent, :primary_key=>:blah__blah
+    @c.association_reflection(:c).keys.should include(:primary_key)
+    @c.association_reflection(:c).primary_key.should == :blah__blah
+  end
+  it "should use the associated table's primary key if :primary_key is not present" do
+    @c.many_to_one :c, :class=>'ParParent'
+    @c.association_reflection(:c).keys.should_not include(:primary_key)
+    @c.association_reflection(:c).primary_key.should == :id
+  end
+end
+
+describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
+  before do
+    class ::ParParent < Sequel::Model; end
+    class ::ParParentTwo < Sequel::Model; end
+    class ::ParParentThree < Sequel::Model; end
+  end
+  after do
+    Object.send(:remove_const, :ParParent)
+    Object.send(:remove_const, :ParParentTwo)
+    Object.send(:remove_const, :ParParentThree)
+  end
+
+  it "should use the :reciprocal value if present" do
+    @c = Class.new(Sequel::Model)
+    @d = Class.new(Sequel::Model)
+    @c.many_to_one :c, :class=>@d, :reciprocal=>:xx
+    @c.association_reflection(:c).keys.should include(:reciprocal)
+    @c.association_reflection(:c).reciprocal.should == :xx
+  end
+
+  it "should require the associated class is the current class to be a reciprocal" do
+    ParParent.many_to_one :par_parent_two, :key=>:blah
+    ParParent.many_to_one :par_parent_three, :key=>:blah
+    ParParentTwo.one_to_many :par_parents, :key=>:blah
+    ParParentThree.one_to_many :par_parents, :key=>:blah
+
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_three
+
+    ParParent.many_to_many :par_parent_twos, :left_key=>:l, :right_key=>:r, :join_table=>:jt
+    ParParent.many_to_many :par_parent_threes, :left_key=>:l, :right_key=>:r, :join_table=>:jt
+    ParParentTwo.many_to_many :par_parents, :right_key=>:l, :left_key=>:r, :join_table=>:jt
+    ParParentThree.many_to_many :par_parents, :right_key=>:l, :left_key=>:r, :join_table=>:jt
+
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_twos
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+  end
+  
+  it "should handle composite keys" do
+    ParParent.many_to_one :par_parent_two, :key=>[:a, :b], :primary_key=>[:c, :b]
+    ParParent.many_to_one :par_parent_three, :key=>[:d, :e], :primary_key=>[:c, :b]
+    ParParentTwo.one_to_many :par_parents, :primary_key=>[:c, :b], :key=>[:a, :b]
+    ParParentThree.one_to_many :par_parents, :primary_key=>[:c, :b], :key=>[:d, :e]
+
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_three
+
+    ParParent.many_to_many :par_parent_twos, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:pl1, :pl2], :right_primary_key=>[:pr1, :pr2], :join_table=>:jt
+    ParParent.many_to_many :par_parent_threes, :right_key=>[:l1, :l2], :left_key=>[:r1, :r2], :left_primary_key=>[:pl1, :pl2], :right_primary_key=>[:pr1, :pr2], :join_table=>:jt
+    ParParentTwo.many_to_many :par_parents, :right_key=>[:l1, :l2], :left_key=>[:r1, :r2], :right_primary_key=>[:pl1, :pl2], :left_primary_key=>[:pr1, :pr2], :join_table=>:jt
+    ParParentThree.many_to_many :par_parents, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :right_primary_key=>[:pl1, :pl2], :left_primary_key=>[:pr1, :pr2], :join_table=>:jt
+
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_twos
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+  end
+
+  it "should figure out the reciprocal if the :reciprocal value is not present" do
+    ParParent.many_to_one :par_parent_two
+    ParParentTwo.one_to_many :par_parents
+    ParParent.many_to_many :par_parent_threes
+    ParParentThree.many_to_many :par_parents
+
+    ParParent.association_reflection(:par_parent_two).keys.should_not include(:reciprocal)
+    ParParent.association_reflection(:par_parent_two).reciprocal.should == :par_parents
+    ParParentTwo.association_reflection(:par_parents).keys.should_not include(:reciprocal)
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
+    ParParent.association_reflection(:par_parent_threes).keys.should_not include(:reciprocal)
+    ParParent.association_reflection(:par_parent_threes).reciprocal.should == :par_parents
+    ParParentThree.association_reflection(:par_parents).keys.should_not include(:reciprocal)
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+  end
+end
+
+describe Sequel::Model::Associations::AssociationReflection, "#select" do
+  before do
+    @c = Class.new(Sequel::Model)
+    class ::ParParent < Sequel::Model; end
+  end
+
+  it "should use the :select value if present" do
+    @c.many_to_one :c, :class=>ParParent, :select=>[:par_parents__id]
+    @c.association_reflection(:c).keys.should include(:select)
+    @c.association_reflection(:c).select.should == [:par_parents__id]
+  end
+  it "should be the associated_table.* if :select is not present for a many_to_many associaiton" do
+    @c.many_to_many :cs, :class=>'ParParent'
+    @c.association_reflection(:cs).keys.should_not include(:select)
+    @c.association_reflection(:cs).select.should == :par_parents.*
+  end
+  it "should be if :select is not present for a many_to_one and one_to_many associaiton" do
+    @c.one_to_many :cs, :class=>'ParParent'
+    @c.association_reflection(:cs).keys.should_not include(:select)
+    @c.association_reflection(:cs).select.should == nil
+    @c.many_to_one :c, :class=>'ParParent'
+    @c.association_reflection(:c).keys.should_not include(:select)
+    @c.association_reflection(:c).select.should == nil
+  end
+end
+
+describe Sequel::Model::Associations::AssociationReflection, "#can_have_associated_objects?" do
+  it "should be true for any given object (for backward compatibility)" do
+    Sequel::Model::Associations::AssociationReflection.new.can_have_associated_objects?(Object.new).should == true
+  end
+end
+
+describe Sequel::Model::Associations::AssociationReflection, "#associated_object_keys" do
+  before do
+    @c = Class.new(Sequel::Model)
+    class ::ParParent < Sequel::Model; end
+  end
+
+  it "should use the primary keys for a many_to_one association" do
+    @c.many_to_one :c, :class=>ParParent
+    @c.association_reflection(:c).associated_object_keys.should == [:id]
+    @c.many_to_one :c, :class=>ParParent, :primary_key=>:d_id
+    @c.association_reflection(:c).associated_object_keys.should == [:d_id]
+    @c.many_to_one :c, :class=>ParParent, :key=>[:c_id1, :c_id2], :primary_key=>[:id1, :id2]
+    @c.association_reflection(:c).associated_object_keys.should == [:id1, :id2]
+  end
+  it "should use the keys for a one_to_many association" do
+    ParParent.one_to_many :cs, :class=>ParParent
+    ParParent.association_reflection(:cs).associated_object_keys.should == [:par_parent_id]
+    @c.one_to_many :cs, :class=>ParParent, :key=>:d_id
+    @c.association_reflection(:cs).associated_object_keys.should == [:d_id]
+    @c.one_to_many :cs, :class=>ParParent, :key=>[:c_id1, :c_id2], :primary_key=>[:id1, :id2]
+    @c.association_reflection(:cs).associated_object_keys.should == [:c_id1, :c_id2]
+  end
+  it "should use the right primary keys for a many_to_many association" do
+    @c.many_to_many :cs, :class=>ParParent
+    @c.association_reflection(:cs).associated_object_keys.should == [:id]
+    @c.many_to_many :cs, :class=>ParParent, :right_primary_key=>:d_id
+    @c.association_reflection(:cs).associated_object_keys.should == [:d_id]
+    @c.many_to_many :cs, :class=>ParParent, :right_key=>[:c_id1, :c_id2], :right_primary_key=>[:id1, :id2]
+    @c.association_reflection(:cs).associated_object_keys.should == [:id1, :id2]
+  end
+end
+