epugh-sequel 0.0.0

data/spec/core/spec_helper.rb

@@ -0,0 +1,82 @@
+require 'rubygems'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel/core'
+end
+
+Sequel.virtual_row_instance_eval = true
+
+module Spec::Example::ExampleMethods
+  def deprec
+    output = Sequel::Deprecation.output = nil 
+    begin
+      yield
+    ensure
+      Sequel::Deprecation.output = output
+    end 
+  end 
+end
+
+module Spec::Example::ExampleGroupMethods
+  def deprec_specify(*args, &block)
+    specify(*args) do
+      output = Sequel::Deprecation.output
+      Sequel::Deprecation.output = nil
+      begin
+        instance_eval(&block)
+      ensure
+        Sequel::Deprecation.output = output
+      end
+    end
+  end
+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
+  @@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/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/caching_spec.rb

@@ -0,0 +1,201 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "caching" do
+  before do
+    MODEL_DB.reset
+    
+    @cache_class = Class.new(Hash) do
+      attr_accessor :ttl
+      def set(k, v, ttl); self[k] = v; @ttl = ttl; end
+      def get(k); self[k]; end
+    end
+    cache = @cache_class.new
+    @cache = cache
+    
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      plugin :caching, cache
+      def self.name; 'Item' end
+      
+      columns :name, :id
+    end
+    
+    $cache_dataset_row = {:name => 'sharon', :id => 1}
+    @dataset = @c.dataset
+    $sqls = []
+    @dataset.extend(Module.new {
+      def fetch_rows(sql)
+        $sqls << sql
+        yield $cache_dataset_row
+      end
+      
+      def update(values)
+        $sqls << update_sql(values)
+        $cache_dataset_row.merge!(values)
+      end
+      
+      def delete
+        $sqls << delete_sql
+      end
+    })
+    @c2 = Class.new(@c) do
+      def self.name; 'SubItem' end
+    end
+  end
+  
+  it "should set the model's cache store" do
+    @c.cache_store.should be(@cache)
+    @c2.cache_store.should be(@cache)
+  end
+  
+  it "should have a default ttl of 3600" do
+    @c.cache_ttl.should == 3600
+    @c2.cache_ttl.should == 3600
+  end
+  
+  it "should take a ttl option" do
+    @c.plugin :caching, @cache, :ttl => 1234
+    @c.cache_ttl.should == 1234
+    Class.new(@c).cache_ttl.should == 1234
+  end
+  
+  it "should offer a set_cache_ttl method for setting the ttl" do
+    @c.cache_ttl.should == 3600
+    @c.set_cache_ttl 1234
+    @c.cache_ttl.should == 1234
+    Class.new(@c).cache_ttl.should == 1234
+  end
+  
+  it "should generate a cache key appropriate to the class" do
+    m = @c.new
+    m.values[:id] = 1
+    m.cache_key.should == "#{m.class}:1"
+    m = @c2.new
+    m.values[:id] = 1
+    m.cache_key.should == "#{m.class}:1"
+    
+    # custom primary key
+    @c.set_primary_key :ttt
+    m = @c.new
+    m.values[:ttt] = 333
+    m.cache_key.should == "#{m.class}:333"
+    c = Class.new(@c)
+    m = c.new
+    m.values[:ttt] = 333
+    m.cache_key.should == "#{m.class}:333"
+    
+    # composite primary key
+    @c.set_primary_key [:a, :b, :c]
+    m = @c.new
+    m.values[:a] = 123
+    m.values[:c] = 456
+    m.values[:b] = 789
+    m.cache_key.should == "#{m.class}:123,789,456"
+    c = Class.new(@c)
+    m = c.new
+    m.values[:a] = 123
+    m.values[:c] = 456
+    m.values[:b] = 789
+    m.cache_key.should == "#{m.class}:123,789,456"
+  end
+  
+  it "should raise error if attempting to generate cache_key and primary key value is null" do
+    m = @c.new
+    proc {m.cache_key}.should raise_error(Sequel::Error)
+    m.values[:id] = 1
+    proc {m.cache_key}.should_not raise_error(Sequel::Error)
+
+    m = @c2.new
+    proc {m.cache_key}.should raise_error(Sequel::Error)
+    m.values[:id] = 1
+    proc {m.cache_key}.should_not raise_error(Sequel::Error)
+  end
+  
+  it "should not raise error if trying to save a new record" do
+    proc {@c.new(:name=>'blah').save}.should_not raise_error
+    proc {@c.create(:name=>'blah')}.should_not raise_error
+    proc {@c2.new(:name=>'blah').save}.should_not raise_error
+    proc {@c2.create(:name=>'blah')}.should_not raise_error
+  end
+  
+  it "should set the cache when reading from the database" do
+    $sqls.should == []
+    @cache.should be_empty
+    
+    m = @c[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m.values.should == $cache_dataset_row
+    @cache[m.cache_key].should == m
+    m2 = @c[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m2.should == m
+    m2.values.should == $cache_dataset_row
+
+    $sqls.clear
+    m = @c2[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m.values.should == $cache_dataset_row
+    @cache[m.cache_key].should == m
+    m2 = @c2[1]
+    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    m2.should == m
+    m2.values.should == $cache_dataset_row
+  end
+  
+  it "should delete the cache when writing to the database" do
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    m.name = 'hey'
+    m.save
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    m.name = 'hey'
+    m.save
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
+  end
+
+  it "should delete the cache when deleting the record" do
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    m.delete
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    m.delete
+    @cache.has_key?(m.cache_key).should be_false
+    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+  end
+  
+  it "should support #[] as a shortcut to #find with hash" do
+    m = @c[:id => 3]
+    @cache[m.cache_key].should be_nil
+    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    m = @c[1]
+    @cache[m.cache_key].should == m
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c[:id => 4]
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+
+    $sqls.clear
+    m = @c2[:id => 3]
+    @cache[m.cache_key].should be_nil
+    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    m = @c2[1]
+    @cache[m.cache_key].should == m
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c2[:id => 4]
+    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
+      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+  end
+end

data/spec/extensions/hook_class_methods_spec.rb

@@ -0,0 +1,470 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Model hooks" do
+  before do
+    MODEL_DB.reset
+  end
+  
+  specify "should be definable using a block" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      before_save {$adds << 'hi'}
+    end
+    
+    c.new.before_save
+    $adds.should == ['hi']
+  end
+  
+  specify "should be definable using a method name" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      def bye; $adds << 'bye'; end
+      before_save :bye
+    end
+    
+    c.new.before_save
+    $adds.should == ['bye']
+  end
+
+  specify "should be additive" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      after_save {$adds << 'hyiyie'}
+      after_save {$adds << 'byiyie'}
+    end
+
+    c.new.after_save
+    $adds.should == ['hyiyie', 'byiyie']
+  end
+  
+  specify "before hooks should run in reverse order" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      before_save {$adds << 'hyiyie'}
+      before_save {$adds << 'byiyie'}
+    end
+    
+    c.new.before_save
+    $adds.should == ['byiyie', 'hyiyie']
+  end
+
+  specify "should not be additive if the method or tag already exists" do
+    $adds = []
+    c = Class.new(Sequel::Model)
+    c.class_eval do
+      def bye; $adds << 'bye'; end
+      before_save :bye
+      before_save :bye
+    end
+    
+    c.new.before_save
+    $adds.should == ['bye']
+
+    $adds = []
+    d = Class.new(Sequel::Model)
+    d.class_eval do
+      before_save(:bye){$adds << 'hyiyie'}
+      before_save(:bye){$adds << 'byiyie'}
+    end
+    
+    d.new.before_save
+    $adds.should == ['byiyie']
+
+    $adds = []
+    e = Class.new(Sequel::Model)
+    e.class_eval do
+      def bye; $adds << 'bye'; end
+      before_save :bye
+      before_save(:bye){$adds << 'byiyie'}
+    end
+    
+    e.new.before_save
+    $adds.should == ['byiyie']
+
+    $adds = []
+    e = Class.new(Sequel::Model)
+    e.class_eval do
+      def bye; $adds << 'bye'; end
+      before_save(:bye){$adds << 'byiyie'}
+      before_save :bye
+    end
+    
+    e.new.before_save
+    $adds.should == ['bye']
+  end
+  
+  specify "should be inheritable" do
+    # pending
+    
+    $adds = []
+    a = Class.new(Sequel::Model)
+    a.class_eval do
+      after_save {$adds << '123'}
+    end
+    
+    b = Class.new(a)
+    b.class_eval do
+      after_save {$adds << '456'}
+      after_save {$adds << '789'}
+    end
+    
+    b.new.after_save
+    $adds.should == ['123', '456', '789']
+  end
+  
+  specify "should be overridable in descendant classes" do
+    $adds = []
+    a = Class.new(Sequel::Model)
+    a.class_eval do
+      before_save {$adds << '123'}
+    end
+    
+    b = Class.new(a)
+    b.class_eval do
+      def before_save; $adds << '456'; end
+    end
+    
+    a.new.before_save
+    $adds.should == ['123']
+    $adds = []
+    b.new.before_save
+    $adds.should == ['456']
+  end
+  
+  specify "should stop processing if a hook returns false" do
+    $flag = true
+    $adds = []
+    
+    a = Class.new(Sequel::Model)
+    a.class_eval do
+      after_save {$adds << 'blah'; $flag}
+      after_save {$adds << 'cruel'}
+    end
+    
+    a.new.after_save
+    $adds.should == ['blah', 'cruel']
+
+    # chain should not break on nil
+    $adds = []
+    $flag = nil
+    a.new.after_save
+    $adds.should == ['blah', 'cruel']
+    
+    $adds = []
+    $flag = false
+    a.new.after_save
+    $adds.should == ['blah']
+    
+    b = Class.new(a)
+    b.class_eval do
+      after_save {$adds << 'mau'}
+    end
+    
+    $adds = []
+    b.new.after_save
+    $adds.should == ['blah']
+  end
+end
+
+describe "Model#after_initialize" do
+  specify "should be called after initialization" do
+    $values1 = nil
+    $reached_after_initialized = false
+    
+    a = Class.new(Sequel::Model)
+    a.class_eval do
+      columns :x, :y
+      after_initialize do
+        $values1 = @values.clone
+        $reached_after_initialized = true
+      end
+    end
+    
+    a.new(:x => 1, :y => 2)
+    $values1.should == {:x => 1, :y => 2}
+    $reached_after_initialized.should == true
+  end
+end
+
+describe "Model#before_create && Model#after_create" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :x
+      no_primary_key
+      
+      after_create {MODEL_DB << "BLAH after"}
+    end
+  end
+  
+  specify "should be called around new record creation" do
+    @c.before_create {MODEL_DB << "BLAH before"}
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'INSERT INTO items (x) VALUES (2)',
+      'BLAH after'
+    ]
+  end
+
+  specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
+    @c.before_create{false}
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
+    @c.before_create{false}
+    @c.raise_on_save_failure = false
+    @c.create(:x => 2).should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_update && Model#after_update" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      after_update {MODEL_DB << "BLAH after"}
+    end
+  end
+  
+  specify "should be called around record update" do
+    @c.before_update {MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.save
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'BLAH after'
+    ]
+  end
+
+  specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
+    @c.before_update{false}
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify "#save should cancel the save and return nil if before_update returns false and raise_on_save_failure is false" do
+    @c.before_update{false}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_save && Model#after_save" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :x
+      after_save {MODEL_DB << "BLAH after"}
+    end
+  end
+  
+  specify "should be called around record update" do
+    @c.before_save {MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.save
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'BLAH after'
+    ]
+  end
+  
+  specify "should be called around record creation" do
+    @c.before_save {MODEL_DB << "BLAH before"}
+    @c.no_primary_key
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'INSERT INTO items (x) VALUES (2)',
+      'BLAH after'
+    ]
+  end
+
+  specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
+    @c.before_save{false}
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify "#save should cancel the save and return nil if before_save returns false and raise_on_save_failure is false" do
+    @c.before_save{false}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_destroy && Model#after_destroy" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      after_destroy {MODEL_DB << "BLAH after"}
+      
+      def delete
+        MODEL_DB << "DELETE BLAH"
+      end
+    end
+  end
+  
+  specify "should be called around record destruction" do
+    @c.before_destroy {MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.destroy
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'DELETE BLAH',
+      'BLAH after'
+    ]
+  end
+
+  specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
+    @c.before_destroy{false}
+    proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify "#destroy should cancel the destroy and return nil if before_destroy returns false and raise_on_save_failure is false" do
+    @c.before_destroy{false}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).destroy.should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model#before_validation && Model#after_validation" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      after_validation{MODEL_DB << "BLAH after"}
+
+      def self.validate(o)
+        o.errors[:id] << 'not valid' unless o[:id] == 2233
+      end
+      columns :id
+    end
+  end
+  
+  specify "should be called around validation" do
+    @c.before_validation{MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.should be_valid
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+
+    MODEL_DB.sqls.clear
+    m = @c.load(:id => 22)
+    m.should_not be_valid
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+  end
+
+  specify "should be called when calling save" do
+    @c.before_validation{MODEL_DB << "BLAH before"}
+    m = @c.load(:id => 2233)
+    m.save.should == m
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after', 'UPDATE items SET id = 2233 WHERE (id = 2233)']
+
+    MODEL_DB.sqls.clear
+    m = @c.load(:id => 22)
+    m.raise_on_save_failure = false
+    m.save.should == nil
+    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+  end
+
+  specify "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
+    @c.before_validation{false}
+    proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    MODEL_DB.sqls.should == []
+  end
+
+  specify "#save should cancel the save and return nil if before_validation returns false and raise_on_save_failure is false" do
+    @c.before_validation{false}
+    @c.raise_on_save_failure = false
+    @c.load(:id => 2233).save.should == nil
+    MODEL_DB.sqls.should == []
+  end
+end
+
+describe "Model.has_hooks?" do
+  setup do
+    @c = Class.new(Sequel::Model(:items))
+  end
+  
+  specify "should return false if no hooks are defined" do
+    @c.has_hooks?(:before_save).should be_false
+  end
+  
+  specify "should return true if hooks are defined" do
+    @c.before_save {'blah'}
+    @c.has_hooks?(:before_save).should be_true
+  end
+  
+  specify "should return true if hooks are inherited" do
+    @d = Class.new(@c)
+    @d.has_hooks?(:before_save).should be_false
+  end
+end
+
+describe "Model#add_hook_type" do
+  setup do
+    class Foo < Sequel::Model(:items)
+      add_hook_type :before_bar, :after_bar
+
+      def bar
+        return :b if before_bar == false
+        return :a if after_bar == false
+        true
+      end
+    end
+    @f = Class.new(Foo)
+  end
+
+  specify "should have before_bar and after_bar class methods" do
+    @f.should respond_to(:before_bar)
+    @f.should respond_to(:before_bar)
+  end
+
+  specify "should have before_bar and after_bar instance methods" do
+    @f.new.should respond_to(:before_bar)
+    @f.new.should respond_to(:before_bar)
+  end
+
+  specify "it should return true for bar when before_bar and after_bar hooks are returing true" do
+    a = 1
+    @f.before_bar { a += 1}
+    @f.new.bar.should be_true
+    a.should == 2
+    @f.after_bar { a *= 2}
+    @f.new.bar.should be_true
+    a.should == 6
+  end
+
+  specify "it should return nil for bar when before_bar and after_bar hooks are returing false" do
+    @f.new.bar.should be_true
+    @f.after_bar { false }
+    @f.new.bar.should == :a
+    @f.before_bar { false }
+    @f.new.bar.should == :b
+  end
+end