viking-sequel 3.10.0

data/spec/core/spec_helper.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel/core'
+end
+
+class MockDataset < Sequel::Dataset
+  def insert(*args)
+    @db.execute insert_sql(*args)
+  end
+  
+  def update(*args)
+    @db.execute update_sql(*args)
+  end
+  
+  def fetch_rows(sql)
+    @db.execute(sql)
+    yield({:id => 1, :x => 1})
+  end
+
+  def quoted_identifier(c)
+    "\"#{c}\""
+  end
+end
+
+class MockDatabase < Sequel::Database
+  set_adapter_scheme :mock
+  @@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 reset
+    @sqls = []
+  end
+
+  def transaction(opts={}); yield; end
+  
+  def dataset; MockDataset.new(self); end
+end
+
+class SchemaDummyDatabase < Sequel::Database
+  attr_reader :sqls
+  self.identifier_input_method = nil
+  self.identifier_output_method = nil
+  
+  def execute(sql, opts={})
+    @sqls ||= []
+    @sqls << sql
+  end
+end

data/spec/core/version_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Sequel.version" do
+  specify "should be in the form X.Y.Z with all being numbers" do
+    Sequel.version.should =~ /\A\d+\.\d+\.\d+\z/
+  end
+end

data/spec/extensions/active_model_spec.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+if RUBY_PLATFORM !~ /(win|w)32|java$/
+describe "ActiveModel plugin" do
+  specify "should be compliant to the ActiveModel spec" do
+    s = ''
+    IO.popen('-') do |f|
+      if f
+        s = f.read
+      else
+        begin
+          require 'rubygems'
+          require 'active_model'
+        rescue LoadError
+          puts "0 failures, 0 errors, skipping tests"
+        else
+          require 'test/unit'
+          require "test/unit/ui/console/testrunner"
+          class AMLintTest < Test::Unit::TestCase
+            def setup
+              @c = Class.new(Sequel::Model) do
+                set_primary_key :id
+                columns :id, :id2
+                def delete; end
+              end
+              @c.plugin :active_model
+              @m = @model = @c.new
+              @o = @c.load({})
+            end
+            include ActiveModel::Lint::Tests
+
+            # Should return self, not a proxy object
+            def test__to_model
+              assert_equal @m.to_model.object_id.should, @m.object_id
+            end
+            
+            def test__to_key
+              assert_equal nil, @m.to_key
+              @o.id = 1
+              assert_equal [1], @o.to_key
+              @c.set_primary_key [:id2, :id]
+              @o.id2 = 2
+              assert_equal [2, 1], @o.to_key
+              @o.destroy
+              assert_equal nil, @o.to_key
+            end
+            
+            def test__to_param
+              assert_equal nil, @m.to_param
+              @o.id = 1
+              assert_equal '1', @o.to_param
+              @c.set_primary_key [:id2, :id]
+              @o.id2 = 2
+              assert_equal '2-1', @o.to_param
+              @o.meta_def(:to_param_joiner){'|'}
+              assert_equal '2|1', @o.to_param
+              @o.destroy
+              assert_equal nil, @o.to_param
+            end
+
+            def test__persisted?
+              assert_equal false, @m.persisted?
+              assert_equal true, @o.persisted?
+              @m.destroy
+              @o.destroy
+              assert_equal false, @m.persisted?
+              assert_equal false, @o.persisted?
+            end
+          end
+          Test::Unit::UI::Console::TestRunner.run(AMLintTest)
+        end
+      end
+    end
+    s.should =~ /0 failures, 0 errors/
+  end
+end 
+end

data/spec/extensions/association_dependencies_spec.rb

@@ -0,0 +1,127 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "AssociationDependencies plugin" do
+  before do
+    mods = @mods = []
+    @c = Class.new(Sequel::Model)
+    @c.plugin :association_dependencies
+    @Artist = Class.new(@c).set_dataset(:artists)
+    ds1 = @Artist.dataset
+    def ds1.fetch_rows(s)
+      (MODEL_DB.sqls ||= []) << s
+      yield({:id=>2, :name=>'Ar'})
+    end
+    @Album = Class.new(@c).set_dataset(:albums)
+    ds1 = @Album.dataset
+    def ds1.fetch_rows(s)
+      (MODEL_DB.sqls ||= []) << s
+      yield({:id=>1, :name=>'Al', :artist_id=>2})
+    end
+    @Artist.columns :id, :name
+    @Album.columns :id, :name, :artist_id
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Artist.one_to_one :first_album, :class=>@Album, :key=>:artist_id, :conditions=>{:position=>1}
+    @Artist.many_to_many :other_artists, :class=>@Artist, :join_table=>:aoa, :left_key=>:l, :right_key=>:r
+    @Album.many_to_one :artist, :class=>@Artist
+    MODEL_DB.reset
+  end
+
+  specify "should allow destroying associated many_to_one associated object" do
+    @Album.add_association_dependencies :artist=>:destroy
+    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow deleting associated many_to_one associated object" do
+    @Album.add_association_dependencies :artist=>:delete
+    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (artists.id = 2)']
+  end
+  
+  specify "should allow destroying associated one_to_one associated object" do
+    @Artist.add_association_dependencies :first_album=>:destroy
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (position = 1)) LIMIT 1', 'DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow deleting associated one_to_one associated object" do
+    @Artist.add_association_dependencies :first_album=>:delete
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE ((albums.artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow destroying associated one_to_many objects" do
+    @Artist.add_association_dependencies :albums=>:destroy
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow deleting associated one_to_many objects" do
+    @Artist.add_association_dependencies :albums=>:delete
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+  
+  specify "should allow nullifying associated one_to_one objects" do
+    @Artist.add_association_dependencies :first_album=>:nullify
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow nullifying associated one_to_many objects" do
+    @Artist.add_association_dependencies :albums=>:nullify
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should allow nullifying associated many_to_many associations" do
+    @Artist.add_association_dependencies :other_artists=>:nullify
+    @Artist.load(:id=>2, :name=>'Ar').destroy
+    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should raise an error if attempting to nullify a many_to_one association" do
+    proc{@Album.add_association_dependencies :artist=>:nullify}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if using an unrecognized dependence action" do
+    proc{@Album.add_association_dependencies :artist=>:blah}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if a nonexistent association is used" do
+    proc{@Album.add_association_dependencies :blah=>:delete}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if a invalid association type is used" do
+    @Artist.plugin :many_through_many
+    @Artist.many_through_many :other_albums, [[:id, :id, :id]]
+    proc{@Artist.add_association_dependencies :other_albums=>:nullify}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if using a many_to_many association type without nullify" do
+    proc{@Artist.add_association_dependencies :other_artists=>:delete}.should raise_error(Sequel::Error)
+  end
+
+  specify "should allow specifying association dependencies in the plugin call" do
+    @Album.plugin :association_dependencies, :artist=>:destroy
+    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+  end
+
+  specify "should work with subclasses" do
+    c = Class.new(@Album)
+    c.add_association_dependencies :artist=>:destroy
+    c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.reset
+
+    @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)']
+    MODEL_DB.reset
+
+    @Album.add_association_dependencies :artist=>:destroy
+    c2 = Class.new(@Album)
+    c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+  end
+end

data/spec/extensions/association_proxies_spec.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel::Plugins::AssociationProxies" do
+  before do
+    class ::Tag < Sequel::Model
+    end
+    class ::Item < Sequel::Model
+      plugin :association_proxies
+      many_to_many :tags
+    end
+    @i = Item.load(:id=>1)
+    @t = @i.tags
+    Item.db.reset
+  end 
+  after do
+    Object.send(:remove_const, :Tag)
+    Object.send(:remove_const, :Item)
+  end
+
+  it "should send method calls to the associated object array if sent an array method" do
+    @i.associations.has_key?(:tags).should == false
+    @t.select{|x| false}.should == []
+    @i.associations.has_key?(:tags).should == true
+  end
+  
+  it "should send method calls to the association dataset sent another method" do
+    @i.associations.has_key?(:tags).should == false
+    @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
+    @i.associations.has_key?(:tags).should == false
+  end
+  
+  it "should reload the cached association if sent an array method and the reload flag was given" do
+    @t.select{|x| false}.should == []
+    Item.db.sqls.length == 1
+    @t.select{|x| false}.should == []
+    Item.db.sqls.length == 1
+    @i.tags(true).select{|x| false}.should == []
+    Item.db.sqls.length == 2
+    @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
+    Item.db.sqls.length == 2
+  end
+  
+  it "should not return a proxy object for associations that do not return an array" do
+    Item.many_to_one :tag
+    proc{@i.tag.filter(:a=>1)}.should raise_error(NoMethodError)
+    
+    Tag.one_to_one :item
+    proc{Tag.load(:id=>1, :item_id=>2).item.filter(:a=>1)}.should raise_error(NoMethodError)
+  end
+end

data/spec/extensions/blank_spec.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Object#blank?" do
+  specify "it should be true if the object responds true to empty?" do
+    [].blank?.should == true
+    {}.blank?.should == true
+    o = Object.new
+    def o.empty?; true; end
+    o.blank?.should == true
+  end
+
+  specify "it should be false if the object doesn't respond true to empty?" do
+    [2].blank?.should == false
+    {1=>2}.blank?.should == false
+    Object.new.blank?.should == false
+  end
+end
+
+context "Numeric#blank?" do
+  specify "it should always be false" do
+    1.blank?.should == false
+    0.blank?.should == false
+    -1.blank?.should == false
+    1.0.blank?.should == false
+    0.0.blank?.should == false
+    -1.0.blank?.should == false
+    10000000000000000.blank?.should == false
+    -10000000000000000.blank?.should == false
+    10000000000000000.0.blank?.should == false
+    -10000000000000000.0.blank?.should == false
+  end
+end
+
+context "NilClass#blank?" do
+  specify "it should always be true" do
+    nil.blank?.should == true
+  end
+end
+
+context "TrueClass#blank?" do
+  specify "it should always be false" do
+    true.blank?.should == false
+  end
+end
+
+context "FalseClass#blank?" do
+  specify "it should always be true" do
+    false.blank?.should == true
+  end
+end
+
+context "String#blank?" do
+  specify "it should be true if the string is empty" do
+    ''.blank?.should == true
+  end
+  specify "it should be true if the string is composed of just whitespace" do
+    ' '.blank?.should == true
+    "\r\n\t".blank?.should == true
+    (' '*4000).blank?.should == true
+    ("\r\n\t"*4000).blank?.should == true
+  end
+  specify "it should be false if the string has any non whitespace characters" do
+    '1'.blank?.should == false
+    ("\r\n\t"*4000 + 'a').blank?.should == false
+    ("\r\na\t"*4000).blank?.should == false
+  end
+end

data/spec/extensions/boolean_readers_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "BooleanReaders plugin" do
+  before do
+    @db = Sequel::Database.new({})
+    def @db.schema(*args)
+      [[:id, {}], [:y, {:type=>:integer, :db_type=>'tinyint(1)'}], [:b, {:type=>:boolean, :db_type=>'boolean'}]]
+    end
+
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @p = proc do
+      @columns = [:id, :b, :y]
+      def columns; @columns; end
+    end
+    @c.instance_eval(&@p)
+  end 
+
+  specify "should create attribute? readers for all boolean attributes" do
+    @c.plugin(:boolean_readers)
+    o = @c.new
+    o.b?.should == nil
+    o.b = '1'
+    o.b?.should == true
+    o.b = '0'
+    o.b?.should == false
+    o.b = ''
+    o.b?.should == nil
+  end
+
+  specify "should not create attribute? readers for non-boolean attributes" do
+    @c.plugin(:boolean_readers)
+    proc{@c.new.y?}.should raise_error(NoMethodError)
+    proc{@c.new.id?}.should raise_error(NoMethodError)
+  end
+
+  specify "should accept a block to determine if an attribute is boolean" do
+    @c.plugin(:boolean_readers){|c| db_schema[c][:db_type] == 'tinyint(1)'}
+    proc{@c.new.b?}.should raise_error(NoMethodError)
+    o = @c.new
+    o.y.should == nil
+    o.y?.should == nil
+    o.y = '1'
+    o.y.should == 1
+    o.y?.should == true
+    o.y = '0'
+    o.y.should == 0
+    o.y?.should == false
+    o.y = ''
+    o.y.should == nil
+    o.y?.should == nil
+  end
+
+  specify "should create boolean readers when set_dataset is defined" do
+    c = Class.new(Sequel::Model(@db))
+    c.instance_eval(&@p)
+    c.plugin(:boolean_readers)
+    c.set_dataset(@db[:a])
+    o = c.new
+    o.b?.should == nil
+    o.b = '1'
+    o.b?.should == true
+    o.b = '0'
+    o.b?.should == false
+    o.b = ''
+    o.b?.should == nil
+    proc{o.i?}.should raise_error(NoMethodError)
+
+    c = Class.new(Sequel::Model(@db))
+    c.instance_eval(&@p)
+    c.plugin(:boolean_readers){|x| db_schema[x][:db_type] == 'tinyint(1)'}
+    c.set_dataset(@db[:a])
+    o = c.new
+    o.y.should == nil
+    o.y?.should == nil
+    o.y = '1'
+    o.y.should == 1
+    o.y?.should == true
+    o.y = '0'
+    o.y.should == 0
+    o.y?.should == false
+    o.y = ''
+    o.y.should == nil
+    o.y?.should == nil
+    proc{o.b?}.should raise_error(NoMethodError)
+  end
+
+  specify "should handle cases where getting the columns raises an error" do
+    @c.meta_def(:columns){raise Sequel::Error}
+    proc{@c.plugin(:boolean_readers)}.should_not raise_error
+    proc{@c.new.b?}.should raise_error(NoMethodError)
+  end
+end