datamapper-shim 0.0.1

data/test/data_mapper/shim_test.rb

@@ -0,0 +1,1258 @@
+require "logger"
+require "minitest/autorun"
+require "minitest/pride"
+require "pry"
+
+require "data_mapper/shim"
+
+describe DataMapper::Shim do
+
+  # Hide deprecation notice, but figure out why first
+  I18n.enforce_available_locales = false
+
+  # Use in-memory database for easy setup
+  ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => ":memory:"
+
+  # Migrations
+  ActiveRecord::Migration.create_table :assets do |t|
+    t.references :owner
+  end
+
+  ActiveRecord::Migration.create_table :avatars do |t|
+    t.string :filename
+    t.references :user
+  end
+
+  ActiveRecord::Migration.create_table :callbackers do |t|
+  end
+
+  ActiveRecord::Migration.create_table :channels do |t|
+    t.string :name
+    t.integer :state
+  end
+
+  ActiveRecord::Migration.create_table :channels_users do |t|
+    t.references :user
+    t.references :channel
+  end
+
+  ActiveRecord::Migration.create_table :handles do |t|
+    t.string :type
+    t.string :value
+    t.references :user
+  end
+
+  ActiveRecord::Migration.create_table :messages do |t|
+    t.text :body
+    t.references :user
+    t.datetime :deleted_at
+    t.timestamps
+  end
+
+  ActiveRecord::Migration.create_table :users do |t|
+    t.string :alias
+    t.string :email
+    t.boolean :admin
+    t.timestamps
+  end
+
+  ActiveRecord::Migration.create_table :validators do |t|
+    t.string :value
+    t.string :value_confirmation
+    t.boolean :flag
+  end
+
+  ActiveRecord::Base.connection.execute("ALTER TABLE users ADD COLUMN active TINYINT(4)")
+
+  ActiveRecord::Migration.create_table :friendships do |t|
+    t.references :user
+    t.references :friend
+  end
+
+  ActiveRecord::Migration.create_table :typecasters do |t|
+    t.string :list
+    t.string :json
+    t.string :yaml
+    t.integer :enum
+    t.datetime :datetime
+  end
+
+  # DataMapper creates boolean fields with TINYINT(4) type
+  # instead of the more usual TINYINT(1)
+  ActiveRecord::Base.connection.execute("ALTER TABLE typecasters ADD COLUMN boolean TINYINT(4)")
+
+  # Enemies table
+  ActiveRecord::Migration.create_table :users_users do |t|
+    t.references :user
+    t.references :enemy
+  end
+
+  # Fixture classes
+  class Asset < ActiveRecord::Base
+    include DataMapper::Shim
+
+    belongs_to :user, :child_key => :owner_id
+
+    before_destroy do
+      raise ActiveRecord::DeleteRestrictionError.new(self.class.name)
+    end
+  end
+
+  class Avatar < ActiveRecord::Base
+    include DataMapper::Shim
+
+    belongs_to :user, :nullable => false, :autosave => true
+  end
+
+  class Channel < ActiveRecord::Base
+    include DataMapper::Shim
+
+    property :name, String, :format => /\A#.*\Z/, :key => true
+    property :state, Enum[:archived, :open], :default => :open, :nullable => false
+
+    has n, :users, :through => Resource
+    has n, :assets, :child_key => :owner_id, :constraint => :destroy!
+  end
+
+  class Friendship < ActiveRecord::Base
+    include DataMapper::Shim
+
+    property :user_id, Integer, :key => true
+    property :friend_id, Integer, :key => true
+
+    belongs_to :user
+    belongs_to :friend, :class_name => "User"
+
+    # Reciprocate friendship
+    after_create do
+      unless Friendship.where(:user_id => friend.id, :friend_id => user.id).first
+        Friendship.create(:user_id => friend.id, :friend_id => user.id)
+      end
+    end
+  end
+
+  class Message < ActiveRecord::Base
+    include DataMapper::Shim
+
+    property :deleted_at, ParanoidDateTime, :writer => :protected
+    property :body, Text
+
+    belongs_to :user
+  end
+
+  class Typecaster < ActiveRecord::Base
+    include DataMapper::Shim
+
+    property :list, List
+    property :json, Json
+    property :yaml, Yaml
+    property :boolean, Boolean
+    property :enum, Enum[:pending, :active]
+    property :datetime, DateTime
+  end
+
+  class Handle < ActiveRecord::Base
+    belongs_to :user, :inverse_of => :pseudonyms
+  end
+
+  class User < ActiveRecord::Base
+    include DataMapper::Shim
+
+    property :email, String, :length => 50, :unique => true, :format => :email_address
+    property :active, Boolean, :default => true, :nullable => false
+    property :alias, String, :reader => :private, :size => 10
+    property :admin, Boolean, :default => false, :writer => :private
+
+    # One-to-one relationships
+    has 1, :avatar, :constraint => :destroy
+
+    # One-to-many relationships
+    has n, :messages, :order => "body", :constraint => :set_nil
+    has n, :texts, :class_name => "Message"
+    has n, :assets, :child_key => :owner_id, :constraint => :protect
+    has n, :pseudonyms, :class_name => "Handle", :inverse_of => :user
+
+    # Many-to-many relationships
+    has n, :friendships, :constraint => :skip
+    has n, :friends, :through => :friendships, :mutable => true
+    has n, :enemies, :through => Resource, :class_name => "User", :association_foreign_key => :enemy_id, :constraint => :destroy
+    has n, :channels, :through => Resource
+  end
+
+  # Wrap tests in a transaction
+  def run
+    ActiveRecord::Base.transaction do
+      @result = super
+      raise ActiveRecord::Rollback
+    end
+    @result
+  end
+
+  # Fixtures
+  before do
+    @user = User.create :email => "steve@apple.com"
+    @avatar = Avatar.create :filename => "steve.png"
+
+    @message = Message.create :body => "Be hungry. Be foolish."
+    @asset = Asset.create
+    @friend = User.create :email => "woz@apple.com"
+    @enemy = User.create :email => "eric@google.com"
+    @channel = Channel.create :name => "#general"
+  end
+
+  describe "relationships" do
+
+    it "raises on leftover options" do
+      proc do
+        class User
+          has 1, :outfit, :turtleneck => true
+        end
+      end.must_raise NotImplementedError
+    end
+
+    it "can set up a one-to-one relationship" do
+      @user.avatar.must_be_nil
+
+      @user.avatar = @avatar
+      @user.save!
+
+      @avatar.user.must_equal @user
+    end
+
+    it "can set up a one-to-many relationship" do
+      @user.messages.must_be_empty
+
+      @user.messages = [@message]
+      @user.save!
+
+      @user.messages.must_equal [@message]
+      @message.user.must_equal @user
+    end
+
+    it "can set up a many-to-many relationship (with a join table model)" do
+      @user.friends.must_be_empty
+
+      @user.friends = [@friend]
+      @user.save!
+
+      @friend.friends.must_equal [@user]
+    end
+
+    it "can set up a many-to-many relationship (with no join table model)" do
+      @user.enemies.must_be_empty
+
+      @user.enemies = [@enemy]
+      @user.save!
+
+      result = User.connection.execute("SELECT enemy_id, user_id FROM users_users").first
+      result["user_id"].must_equal @user.id
+      result["enemy_id"].must_equal @enemy.id
+    end
+
+    it "can use a custom class name" do
+      @user.messages << @message
+
+      @user.texts.must_equal [@message]
+    end
+
+    it "can use a custom child key" do
+      @user.assets.must_be_empty
+
+      @user.assets = [@asset]
+      @user.save!
+
+      @user.assets.must_equal [@asset]
+      @asset.user.must_equal @user
+    end
+
+    it "can order relationships" do
+      %w(3 2 1).map do |n|
+        @user.messages << Message.create(:body => n)
+      end
+
+      messages = @user.messages
+      messages.must_equal Message.where(:user_id => @user.id).order(:body).to_a
+      messages.wont_equal Message.where(:user_id => @user.id).to_a
+    end
+
+    it "can require a parent object" do
+      @avatar.wont_be :valid?
+      @avatar.errors[:user].must_match /can't be blank/
+    end
+
+    it "can autosave a parent" do
+      @avatar.user = @user
+      @user.email = "zuck@facebook.com"
+
+      @avatar.save
+      @user.reload.email.must_equal "zuck@facebook.com"
+    end
+
+    it "avoids extra queries with :inverse_of" do
+      @user.pseudonyms << Handle.create(:type => "twitter", :value => "@n")
+      @user.save
+
+      @user.pseudonyms.first.user.object_id.must_equal @user.object_id
+    end
+
+  end
+
+  describe "restrictive relationships" do
+
+    it "stops a parent's deletion with :constraint => :protect" do
+      @user.assets << @asset
+      @user.destroy.must_equal false
+
+      @user.wont_be :destroyed?
+    end
+
+    it "destroys children with :constraint => :destroy" do
+      @user.avatar = @avatar
+      @user.destroy
+
+      @avatar.must_be :destroyed?
+    end
+
+    it "destroys children without instantiating them with :constraint => :destroy!" do
+      @channel.assets << @asset
+      @channel.destroy
+
+      @channel.must_be :destroyed?
+      proc { @asset.reload }.must_raise ActiveRecord::RecordNotFound
+    end
+
+    it "nils out children with :constraint => :set_nil" do
+      @user.messages << @message
+      @message.user.wont_be_nil
+
+      @user.destroy
+
+      @message.reload.user.must_be_nil
+    end
+
+    it "leaves the children alone with :constraint => :skip" do
+      @user.friends << @friend
+      friendships = @user.friendships
+      @user.destroy
+
+      @user.must_be :destroyed?
+      friendships.each { |friendship| friendship.wont_be :destroyed? }
+    end
+
+    it "warns that many-to-many relationships without a join table model can't stop a parent's deletion" do
+      proc do
+        class User
+          has n, :channels, :through => Resource, :constraint => :protect
+        end
+      end.must_output nil, /ActiveRecord's HABTM doesn't support :dependent => :restrict/
+    end
+
+    it "destroys children with :constraint => :destroy for many-to-many relationships without a join table model" do
+      @user.enemies << @enemy
+      @user.destroy
+
+      @user.must_be :destroyed?
+      @enemy.must_be :destroyed?
+    end
+
+  end
+
+  describe "finders" do
+
+    it "returns all rows for a query" do
+      User.all.must_equal [@user, @friend, @enemy]
+      User.all(:id => @user.id).must_equal [@user]
+    end
+
+    it "returns the first row for a query" do
+      User.first.must_equal @user
+      User.first(:id => @friend.id).must_equal @friend
+    end
+
+    it "returns gets a row by id" do
+      User.get(@user.id).must_equal @user
+      User.get(0).must_equal nil
+    end
+
+  end
+
+  describe "miscellaneous helpers" do
+
+    it "can set an attribute" do
+      email = "cook@apple.com"
+
+      @user.attribute_set(:email, email)
+      @user.email.must_equal email
+    end
+
+    it "can get an attribute" do
+      @user.attribute_get(:email).must_equal @user.email
+    end
+
+    it "can tell if an attribute has been modified" do
+      @user.email = nil
+      @user.attribute_dirty?(:email).must_equal true
+    end
+
+    it "can tell if an instance has been modified" do
+      @user.email = nil
+      @user.must_be :dirty?
+    end
+
+    it "can return original values for changed attributes" do
+      original_email = @user.email
+      @user.email = nil
+      @user.original_values[:email].must_equal original_email
+    end
+
+    it "can delete all instances in a relation" do
+      @user.friends << @friend
+      @user.friends.destroy!
+
+      proc { @friend.reload }.must_raise ActiveRecord::RecordNotFound
+    end
+
+    it "returns a list of all registered properties" do
+      properties = User.properties.map(&:name).map(&:to_s).sort
+      properties.must_equal %w(active admin alias email)
+    end
+
+    it "handles custom table names" do
+      class Person < ActiveRecord::Base
+        include DataMapper::Shim
+
+        storage_names[:default] = "users"
+      end
+
+      Person.table_name.must_equal "users"
+    end
+
+  end
+
+  describe "custom property types" do
+
+    before do
+      class Proprietor < ActiveRecord::Base
+        include DataMapper::Shim
+      end
+    end
+
+    it "can define a BigInt property" do
+      class Proprietor
+        property :value, BigInt
+      end
+    end
+
+    it "can define a Boolean property" do
+      class Proprietor
+        property :value, Boolean
+      end
+    end
+
+    it "can define a Serial property" do
+      class Proprietor
+        property :value, Serial
+      end
+    end
+
+    it "can define a ParanoidDatetime property" do
+      class Proprietor
+        property :value, ParanoidDateTime
+      end
+    end
+
+    it "can define a Resource property" do
+      class Proprietor
+        property :value, Resource
+      end
+    end
+
+    it "can define a Text property" do
+      class Proprietor
+        property :value, Text
+      end
+    end
+
+    it "can define a Discriminator property" do
+      class Proprietor
+        property :value, Discriminator
+      end
+    end
+
+    it "can define a Yaml property" do
+      class Proprietor
+        property :value, Yaml
+      end
+    end
+
+    it "can define a Json property" do
+      class Proprietor
+        property :value, Json
+      end
+    end
+
+
+  end
+
+  describe "typecasted properties" do
+
+    before do
+      @typecaster = Typecaster.new
+    end
+
+    it "can typecast to a list (CSV)" do
+      list = %w(something other)
+      @typecaster.list = list
+      @typecaster.save
+
+      Typecaster.connection.select_value("SELECT list FROM typecasters").must_equal list.join(",")
+      Typecaster.first.list.must_equal list
+    end
+
+    it "can typecast to YAML" do
+      object = {}
+      @typecaster.yaml = object
+      @typecaster.save
+
+      Typecaster.connection.select_value("SELECT yaml FROM typecasters").must_equal object.to_yaml
+      Typecaster.first.yaml.must_equal object
+    end
+
+    it "can typecast to JSON" do
+      object = {"hello" => "world"}
+      @typecaster.json = object
+      @typecaster.save
+
+      Typecaster.connection.select_value("SELECT json FROM typecasters").must_equal object.to_json
+      Typecaster.first.json.must_equal object
+    end
+
+    it "can typecast enums" do
+      @typecaster.enum = :pending
+      @typecaster.save
+
+      Typecaster.connection.select_value("SELECT enum FROM typecasters").must_equal 1
+
+      @typecaster.enum = :active
+      @typecaster.save
+
+      Typecaster.connection.select_value("SELECT enum FROM typecasters").must_equal 2
+
+      Typecaster.where(:enum => :active).first.must_equal @typecaster
+      Typecaster.first.enum.must_equal :active
+    end
+
+    it "can typecast booleans" do
+      @typecaster.boolean = 0
+      @typecaster.boolean.must_equal false
+
+      @typecaster.boolean = 1
+      @typecaster.boolean.must_equal true
+
+      @typecaster.save
+
+      Typecaster.connection.select_value("SELECT boolean FROM typecasters").must_equal 1
+      Typecaster.first.boolean.must_equal true
+    end
+
+    it "can typecast datetime fields" do
+      @typecaster.datetime = Time.now
+      @typecaster.save
+
+      Typecaster.first.datetime.must_be_instance_of DateTime
+    end
+
+    it "defaults text fields to nil" do
+      Message.new.body.must_be_nil
+    end
+
+  end
+
+  describe "paranoia" do
+
+    it "doesn't delete rows with ParanoidDateTime fields" do
+      @message.deleted_at.must_be_nil
+      @message.destroy
+
+      @message.wont_be :destroyed?
+      @message.deleted_at.wont_be_nil
+    end
+
+    it "doesn't include pseudo-deleted rows in queries by default" do
+      @message.destroy
+
+      Channel.all.wont_include @message
+    end
+
+    it "can include pseudo-deleted rows in queries" do
+      @message.destroy
+
+      Message.with_deleted { Message.all.must_include @message }
+    end
+
+  end
+
+  describe "accessor visibility" do
+
+    it "can mark a property's reader as private" do
+      alter_ego = "Superman"
+      user = User.create :alias => alter_ego
+
+      proc { user.alias }.must_raise NoMethodError
+      user.__send__(:alias).must_equal alter_ego
+    end
+
+    it "can mark a property's writer as protected" do
+      message = Message.new :deleted_at => Time.now
+      message.deleted_at.must_be_nil
+
+      begin
+        message.deleted_at = Time.now
+      rescue NoMethodError => e
+        e.message.must_match /protected/
+      end
+    end
+
+    it "can mark a property's writer as private" do
+      user = User.new :admin => true
+      user.admin.must_equal false
+
+      begin
+        user.admin = true
+      rescue NoMethodError => e
+        e.message.must_match /private/
+      end
+    end
+
+  end
+
+  describe "property options" do
+
+    it "raises on leftover options" do
+      proc do
+        class User
+          property :age, Integer, :only_if_older_than => 18
+        end
+      end.must_raise NotImplementedError
+    end
+
+    it "handles default values" do
+      Channel.new.state.must_equal :open
+    end
+
+    it "handles default boolean values" do
+      User.new.must_be :active?
+    end
+
+    it "ignores index options" do
+      class User
+        property :email, String, :index => true, :unique_index => true
+      end
+    end
+
+    it "ignores auto-validation options" do
+      class User
+        property :email, :auto_validation => false
+      end
+    end
+
+    it "ignores lazy options" do
+      class User
+        property :email, :lazy => true
+      end
+    end
+
+    it "ignores timestamp declarations" do
+      class User
+        timestamps :at
+      end
+    end
+
+  end
+
+  describe "primary keys" do
+
+    it "sets a property as a primary key" do
+      Channel.primary_key.must_equal "name"
+    end
+
+    it "handles composite primary keys" do
+      Friendship.primary_keys.must_equal ["user_id", "friend_id"]
+    end
+
+    it "validates the presence of primary keys" do
+      channel = Channel.new
+      channel.wont_be :valid?
+
+      channel.errors[:name].wont_be_empty
+      channel.errors[:name].must_match /can't be blank/
+    end
+
+  end
+
+  describe "property validations" do
+
+    it "validates length" do
+      user = User.new :email => "#{"a"*50}@web.com"
+      user.wont_be :valid?
+
+      user.errors[:email].wont_be_empty
+      user.errors[:email].must_match /is too long/
+    end
+
+    it "validates uniqueness" do
+      email_in_use = User.first.email
+      user = User.new :email => email_in_use
+
+      user.wont_be :valid?
+      user.errors[:email].wont_be_empty
+      user.errors[:email].must_match /has already been taken/
+    end
+
+    it "validates size (max length)" do
+      user = User.new :alias => "#{"a"*11}"
+      user.wont_be :valid?
+
+      user.errors[:alias].wont_be_empty
+      user.errors[:alias].must_match /is too long/
+    end
+
+    it "validates email format" do
+      user = User.new :email => "qwerty"
+      user.wont_be :valid?
+
+      user.errors[:email].wont_be_empty
+      user.errors[:email].must_match /is invalid/
+
+      user.email = "hpotter@hogwarts.edu"
+      user.must_be :valid?
+    end
+
+    it "validates any format" do
+      channel = Channel.new :name => "lunch"
+      channel.wont_be :valid?
+
+      channel.errors[:name].wont_be_empty
+      channel.errors[:name].must_match /is invalid/
+
+      channel.name = "#lunch"
+      channel.must_be :valid?
+    end
+
+    it "validates presence" do
+      channel = Channel.new
+      channel.state = nil
+      channel.wont_be :valid?
+
+      channel.errors.must_include :state
+      channel.errors[:state].must_match /can't be blank/
+    end
+
+    it "validates presence for booleans" do
+      user = User.new
+      user.active = nil
+      user.wont_be :valid?
+
+      user.errors.must_include :active
+      user.errors[:active].must_match /is not included in the list/
+    end
+  end
+
+
+  describe "validates" do
+
+    before do
+      Validator = Class.new(ActiveRecord::Base) do
+        self.table_name = "validators"
+        include DataMapper::Shim
+      end
+
+      @validator = Validator.new
+    end
+
+    describe "presence" do
+
+      it "checks an attribute is present" do
+        Validator.class_eval do
+          validates_present :value
+        end
+
+        @validator.valid?
+        @validator.errors[:value].must_match /can't be blank/
+      end
+
+      it "can validate only when conditions are met" do
+        Validator.class_eval do
+          validates_present :value, :if => proc { flag }
+        end
+
+        @validator.valid?
+        @validator.errors[:value].must_be_empty
+
+        @validator.flag = true
+        @validator.valid?
+        @validator.errors[:value].must_match /can't be blank/
+      end
+
+      it "can validate in a context" do
+        Validator.class_eval do
+          validates_present :value, :when => [:context]
+          end
+
+        @validator.valid?
+        @validator.errors[:value].must_be_empty
+
+        @validator.valid?(:context)
+        @validator.errors[:value].must_match /can't be blank/
+      end
+
+    end
+
+    describe "uniqueness" do
+
+      it "checks an attribute is unique" do
+        Validator.class_eval do
+          validates_is_unique :value
+        end
+
+        @validator.value = nil
+        @validator.save.must_equal true
+
+        dup = Validator.new :value => nil
+
+        dup.wont_be :valid?
+        dup.errors[:value].must_match /has already been taken/
+      end
+
+      it "can ignore nil values" do
+        Validator.class_eval do
+          validates_is_unique :value, :allow_nil => true
+        end
+
+        @validator.value = nil
+        @validator.save.must_equal true
+
+        dup = Validator.new :value => nil
+        dup.must_be :valid?
+      end
+
+      it "can check an attribute is unique within a scope" do
+        Validator.class_eval do
+          validates_is_unique :value, :scope => [:flag]
+        end
+
+        @validator.value = "value"
+        @validator.save.must_equal true
+
+        dup = Validator.new :value => "value"
+        dup.wont_be :valid?
+
+        dup.flag = true
+        dup.must_be :valid?
+      end
+
+      it "can conditionally check an attribute is unique" do
+        Validator.class_eval do
+          validates_is_unique :value, :if => proc { flag }
+        end
+
+        @validator.value = "value"
+        @validator.save.must_equal true
+
+        dup = Validator.new :value => "value"
+        dup.must_be :valid?
+
+        dup.flag = true
+        dup.wont_be :valid?
+      end
+
+    end
+
+    describe "length" do
+
+      it "checks an attribute's length" do
+        Validator.class_eval do
+          validates_length :value, :max => 10
+        end
+
+        @validator.value = "v" * 11
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /is too long \(maximum is 10 characters\)/
+      end
+
+      it "can use 'maximum' as an alias" do
+        Validator.class_eval do
+          validates_length :value, :maximum => 10
+        end
+
+        @validator.value = "v" * 11
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /is too long \(maximum is 10 characters\)/
+      end
+
+      it "can check a minimum length" do
+        Validator.class_eval do
+          validates_length :value, :min => 10
+        end
+
+        @validator.value = "v" * 9
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /is too short \(minimum is 10 characters\)/
+      end
+
+      it "can conditionally check an attribute's length" do
+        Validator.class_eval do
+          validates_length :value, :max => 10, :if => proc { flag }
+        end
+
+        @validator.value = "v" * 11
+        @validator.must_be :valid?
+
+        @validator.flag = true
+        @validator.wont_be :valid?
+      end
+
+      it "can display a custom message" do
+        Validator.class_eval do
+          validates_length :value, :max => 10, :message => "too much value"
+        end
+
+        @validator.value = "v" * 11
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /too much value/
+      end
+
+    end
+
+    describe "confirmation" do
+
+      it "checks an attribute's confirmation value" do
+        Validator.class_eval do
+          validates_is_confirmed :value
+        end
+
+        @validator.value = "value"
+        @validator.wont_be :valid?
+        @validator.errors[:value_confirmation].must_match /can't be blank/
+
+        @validator.value_confirmation = "valu"
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /doesn't match confirmation/
+
+        @validator.value_confirmation = "value"
+        @validator.must_be :valid?
+      end
+
+      it "can display a custom message" do
+        Validator.class_eval do
+          validates_is_confirmed :value, :message => "not alike enough"
+        end
+
+        @validator.value = "value"
+        @validator.value_confirmation = "valu"
+
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /not alike enough/
+      end
+
+      it "can conditionally check a confirmation value" do
+        Validator.class_eval do
+          validates_is_confirmed :value, :if => proc { flag }
+        end
+
+        @validator.value = "value"
+        @validator.must_be :valid?
+
+        @validator.flag = true
+        @validator.wont_be :valid?
+
+        @validator.value_confirmation = "value"
+        @validator.must_be :valid?
+      end
+
+    end
+
+    describe "with a block" do
+
+      it "checks an attribute against a block" do
+        Validator.class_eval do
+          validates_with_block :value do |value|
+            if value == "secret"
+              [true, nil]
+            else
+              [false, "try again"]
+            end
+          end
+        end
+
+        @validator.value = "public"
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /try again/
+
+        @validator.value = "secret"
+        @validator.must_be :valid?
+      end
+
+    end
+
+    describe "format" do
+
+      it "checks an attribute's format" do
+        Validator.class_eval do
+          validates_format :value, :with => /^#.*$/
+        end
+
+        @validator.value = "channel"
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /is invalid/
+
+        @validator.value = "#channel"
+        @validator.must_be :valid?
+      end
+
+    end
+
+    describe "inclusion" do
+
+      it "checks an attribute is part of a set" do
+        set = [0, 1]
+        Validator.class_eval do
+          validates_within :value, :set => set
+        end
+
+        @validator.value = -1
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /is not included in the list/
+
+        set.each do |n|
+          @validator.value = n
+          @validator.must_be :valid?
+        end
+
+        @validator.value = 2
+        @validator.wont_be :valid?
+      end
+
+    end
+
+    describe "with a method" do
+
+      it "checks an attribute against a method" do
+        Validator.class_eval do
+          validates_with_method :value, :method => :validate
+
+          def validate
+            if value == "secret"
+              true
+            else
+              [false, "try again"]
+            end
+          end
+        end
+
+        @validator.wont_be :valid?
+        @validator.errors[:value].must_match /try again/
+
+        @validator.value = "secret"
+        @validator.must_be :valid?
+      end
+
+      it "can check against a method within a scope" do
+        Validator.class_eval do
+          validates_with_method :value, :method => :validate, :when => :context
+          validates_with_method :value, :method => :validate, :when => [:context2]
+
+          def validate
+            [false, "try again"]
+          end
+        end
+
+        @validator.must_be :valid?
+
+        @validator.flag = true
+        @validator.valid?(:context).must_equal false
+        @validator.errors[:value].must_match /try again/
+
+        @validator.valid?(:context2).must_equal false
+        @validator.errors[:value].must_match /try again/
+      end
+
+    end
+
+  end
+
+  describe "callbacks" do
+
+    before do
+      Callbacker = Class.new(ActiveRecord::Base) do
+        include DataMapper::Shim
+
+        # Callback methods
+        [:create, :save, :destroy, :update, :valid?].each do |callback|
+          define_method "#{callback}_with_method" do
+            callbacks << "#{callback}_with_method"
+          end
+
+          define_method "before_#{callback}_with_method" do
+            callbacks << "before_#{callback}_with_method"
+          end
+        end
+
+        attr_accessor :callbacks
+        def callbacks
+          @callbacks ||= []
+        end
+      end
+
+      @callbacker = Callbacker.new
+    end
+
+    describe ":after callbacks" do
+
+      before do
+        Callbacker.class_eval do
+          after(:create)  { callbacks << "create" }
+          after(:save)    { callbacks << "save" }
+          after(:destroy) { callbacks << "destroy" }
+
+          after :create,  :create_with_method
+          after :save,    :save_with_method
+          after :destroy, :destroy_with_method
+        end
+      end
+
+      it "handles after :save" do
+        @callbacker.save
+        @callbacker.callbacks.must_include "save"
+        @callbacker.callbacks.must_include "save_with_method"
+
+        @callbacker.callbacks = []
+        @callbacker.save
+
+        @callbacker.callbacks.must_include "save"
+        @callbacker.callbacks.must_include "save_with_method"
+      end
+
+      it "handles after :create" do
+        @callbacker.save
+        @callbacker.callbacks.must_include "create"
+        @callbacker.callbacks.must_include "create_with_method"
+
+        @callbacker.callbacks = []
+        @callbacker.save
+
+        @callbacker.callbacks.wont_include "create"
+        @callbacker.callbacks.wont_include "create_with_method"
+      end
+
+      it "handles after :destroy" do
+        @callbacker.save
+        @callbacker.callbacks.wont_include "destroy"
+        @callbacker.callbacks.wont_include "destroy_with_method"
+
+        @callbacker.destroy
+        @callbacker.callbacks.must_include "destroy"
+        @callbacker.callbacks.must_include "destroy_with_method"
+      end
+
+    end
+
+    describe ":before callbacks" do
+
+      before do
+        Callbacker.class_eval do
+          before(:create)  { callbacks << "before_create" }
+          before(:save)    { callbacks << "before_save" }
+          before(:destroy) { callbacks << "before_destroy" }
+          before(:update)  { callbacks << "before_update" }
+          before(:valid?)  { callbacks << "before_valid?" }
+
+          before :create,  :before_create_with_method
+          before :save,    :before_save_with_method
+          before :destroy, :before_destroy_with_method
+          before :update,  :before_update_with_method
+          before :valid?,  :"#{"before_valid?_with_method"}"
+        end
+      end
+
+      it "handles before :save" do
+        @callbacker.save
+        @callbacker.callbacks.must_include "before_save"
+        @callbacker.callbacks.must_include "before_save_with_method"
+
+        @callbacker.callbacks = []
+        @callbacker.save
+
+        @callbacker.callbacks.must_include "before_save"
+        @callbacker.callbacks.must_include "before_save_with_method"
+      end
+
+      it "handles before :create" do
+        @callbacker.save
+        @callbacker.callbacks.must_include "before_create"
+        @callbacker.callbacks.must_include "before_create_with_method"
+
+        @callbacker.callbacks = []
+        @callbacker.save
+
+        @callbacker.callbacks.wont_include "before_create"
+        @callbacker.callbacks.wont_include "before_create_with_method"
+      end
+
+      it "handles before :destroy" do
+        @callbacker.save
+        @callbacker.callbacks.wont_include "before_destroy"
+        @callbacker.callbacks.wont_include "before_destroy_with_method"
+
+        @callbacker.destroy
+        @callbacker.callbacks.must_include "before_destroy"
+        @callbacker.callbacks.must_include "before_destroy_with_method"
+      end
+
+      it "handles before :update" do
+        @callbacker.save
+        @callbacker.callbacks.wont_include "before_update"
+        @callbacker.callbacks.wont_include "before_update_with_method"
+
+        @callbacker.save
+        @callbacker.callbacks.must_include "before_update"
+        @callbacker.callbacks.must_include "before_update_with_method"
+      end
+
+      it "handles before :valid?" do
+        @callbacker.save
+        @callbacker.callbacks.must_include "before_valid?"
+        @callbacker.callbacks.must_include "before_valid?_with_method"
+
+        @callbacker.callbacks = []
+        @callbacker.valid?
+        @callbacker.callbacks.must_include "before_valid?"
+        @callbacker.callbacks.must_include "before_valid?_with_method"
+      end
+
+      it "saves a record even if a before(:valid?) callback returns false" do
+        Callbacker.class_eval do
+          before(:valid?) { callbacks << "short_circuit"; false }
+        end
+
+        @callbacker.save.must_equal true
+        @callbacker.callbacks.must_include "short_circuit"
+      end
+
+    end
+
+  end
+
+  protected
+
+  class Object
+    def must_match(pattern)
+      if self.is_a?(Array)
+        self.any? { |element| element.match(pattern) }.must_equal true
+      else
+        super pattern
+      end
+    end
+  end
+
+end