modelish 0.1.0

data/lib/modelish/version.rb

@@ -0,0 +1,3 @@
+module Modelish
+  VERSION = "0.1.0"
+end

data/modelish.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "modelish/version"
+
+Gem::Specification.new do |s|
+  s.name        = "modelish"
+  s.version     = Modelish::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Maeve Revels"]
+  s.email       = ["maeve.revels@g5platform.com"]
+  s.homepage    = "http://github.com/maeve/#{s.name}"
+  s.summary     = %q{A lightweight pseudo-modeling not-quite-framework}
+  s.description = %q{Sometimes you need something just a little modelish.}
+
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('hashie', '~> 1.0')
+
+  s.add_development_dependency('rspec','~> 2.5')
+  s.add_development_dependency('yard', '~> 0.6')
+  s.add_development_dependency('bluecloth','~> 2.0.11')
+  s.add_development_dependency('autotest')
+
+  s.has_rdoc = true
+end

data/spec/modelish/base_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+
+describe Modelish::Base do
+  subject { model_class } 
+  let(:model_class) { Class.new(Modelish::Base) }
+
+  let(:model) { model_class.new(init_options) }
+  let(:init_options) { nil }
+  let(:default_value) { nil }
+
+  it { should respond_to(:property) }
+
+  context "with simple property" do
+    before { model_class.property(property_name) }
+
+    let(:property_name) { :simple_property }
+    let(:property_value) { 'simple string value' }
+
+    it_should_behave_like 'a modelish property'
+    it_should_behave_like 'a valid model'
+  end
+
+  context "with property default value" do
+    before { model_class.property(property_name, :default => default_value) }
+
+    let(:property_name) { :default_property }
+    let(:property_value) { 'non-default value' }
+    let(:default_value) { 42 }
+
+    it_should_behave_like 'a modelish property'
+    it_should_behave_like 'a valid model'
+  end
+
+  context "with translated property" do
+    before { model_class.property(property_name, :from => from_name) }
+
+    subject { model }
+
+    let(:property_name) { :translated_property }
+    let(:from_name) { 'OldPropertyNAME' }
+    let(:property_value) { 'new value' }
+
+    it_should_behave_like 'a modelish property'
+
+    it { should_not respond_to(from_name) }
+    it { should respond_to("#{from_name}=") }
+
+    describe "original setter" do
+      subject { model.send("#{from_name}=", property_value) }
+
+      it "should change the property value" do
+        expect { subject }.to change{model.send(property_name)}.from(nil).to(property_value)
+      end
+    end
+
+    it_should_behave_like 'a valid model'
+  end
+
+  context "with typed property" do
+    before { model_class.property(property_name, options) }
+
+    subject { model }
+
+    let(:property_name) { :my_int_property }
+    let(:property_type) { Integer }
+
+    let(:valid_string) { '42' }
+    let(:valid_typed_value) { 42 }
+    let(:invalid_value) { '42.0' }
+
+    context "without default value" do
+      let(:options) { {:type => property_type} }
+      let(:default_value) { nil }
+
+      context "without init options" do
+        it_should_behave_like 'a typed property', :my_int_property, Integer
+        it_should_behave_like 'a valid model'
+      end
+
+      context "with init options" do
+        let(:model) { model_class.new(property_name => valid_string) }
+
+        its(:my_int_property) { should == valid_typed_value }
+        its(:raw_my_int_property) { should == valid_string }
+
+        it_should_behave_like 'a valid model'
+      end
+    end
+
+    context "with default value" do
+      let(:options) { {:type => property_type, :default => default_value} }
+      let(:default_value) { 0 }
+
+      it_should_behave_like 'a typed property', :my_int_property, Integer
+
+      it_should_behave_like 'a valid model'
+    end
+  end
+
+  context "with required property" do
+    before { model_class.property(property_name, :required => true) }
+
+    let(:property_name) { :my_required_property }
+    let(:property_value) { 'a valid string' }
+
+    subject { model }
+
+    let(:init_options) { {property_name => property_value} }
+
+    it_should_behave_like 'a modelish property'
+
+    context "when property value is not nil" do
+      it_should_behave_like 'a valid model'
+    end
+
+    context "when property value is nil" do
+      let(:property_value) { nil }
+
+      it_should_behave_like 'a model with an invalid property' do
+        let(:error_count) { 1 }
+      end
+    end
+
+    context "when property value is an empty string" do
+      let(:property_value) { '          ' }
+
+      it_should_behave_like 'a model with an invalid property' do
+        let(:error_count) { 1 }
+      end
+    end
+  end
+
+  context "with length-restricted property" do
+    before { model_class.property(property_name, :required => false, :max_length => max_length) }
+
+    let(:property_name) { :my_required_property }
+    let(:property_value) { 'a' * (max_length - 1) }
+    let(:max_length) { 10 }
+
+    subject { model }
+
+    let(:init_options) { {property_name => property_value} }
+
+    it_should_behave_like 'a modelish property'
+
+    context "when property value is nil" do
+      let(:property_value) { nil }
+
+      it_should_behave_like 'a valid model'
+    end
+
+    context "when property value is a valid string" do
+      it_should_behave_like 'a valid model'
+    end
+
+    context "when property value is too long" do
+      let(:property_value) { 'a' * (max_length + 1) }
+
+      it_should_behave_like 'a model with an invalid property' do
+        let(:error_count) { 1 }
+      end
+    end
+  end
+
+  context "with property that has validator block" do
+    before { model_class.property(property_name, :validator => validator_block) }
+
+    let(:property_name) { :validated_property }
+    let(:validator_block) do
+      lambda { |val| "#{property_name} must support to_hash" unless val.respond_to?(:to_hash) }
+    end
+    let(:property_value) { Hash.new }
+
+    subject { model }
+
+    let(:init_options) { {property_name => property_value} }
+
+    it_should_behave_like 'a modelish property'
+
+    context "when value is valid" do
+      it_should_behave_like 'a valid model'
+    end
+
+    context "when value is invalid" do
+      let(:property_value) { Array.new }
+
+      it_should_behave_like 'a model with an invalid property' do
+        let(:error_count) { 1 }
+      end
+    end
+  end
+
+  context "with type-validated property" do
+    before { model_class.property(property_name, prop_options) }
+
+    let(:prop_options) { {:type => Integer, :validate_type => true} }
+    let(:property_name) { :strict_typed_property }
+    let(:property_value) { 42 }
+
+    subject { model }
+
+    let(:init_options) { {property_name => property_value} }
+
+    it_should_behave_like 'a modelish property'
+
+    context "when value is nil" do
+      let(:property_value) { nil }
+
+      it_should_behave_like 'a valid model'
+    end
+
+    context "when value is valid" do
+      let(:property_value) { '42' }
+
+      it_should_behave_like 'a valid model'
+    end
+
+    context "when value is invalid" do
+      let(:property_value) { 'forty-two' }
+
+      it_should_behave_like 'a model with an invalid property' do
+        let(:error_count) { 1 }
+      end
+    end
+
+    context "with no property type" do
+      let(:prop_options) { {:validate_type => true} }
+
+      context "when value is nil" do
+        let(:property_value) { nil }
+
+        it_should_behave_like 'a valid model'
+      end
+
+      context "when value is not nil" do
+        let(:property_value) { Object.new }
+
+        it_should_behave_like 'a valid model'
+      end
+    end
+  end
+
+  context "with multiple validations" do
+    before do 
+      model_class.property(property_name, :required => true, 
+                                          :max_length => 3, 
+                                          :type => Symbol, 
+                                          :validate_type => true)
+    end
+
+    let(:init_options) { {property_name => property_value} }
+
+    let(:property_name) { :prop_with_many_validations }
+
+    context "when value is valid" do
+      let(:property_value) { :foo }
+
+      it_should_behave_like 'a valid model'
+    end
+
+    context "when value is nil" do
+      let(:property_value) { nil }
+
+      it_should_behave_like 'a model with an invalid property' do
+        let(:error_count) { 1 }
+      end
+    end
+
+    context "when value is too long" do
+      let(:property_value) { :crazy_long_value }
+
+      it_should_behave_like 'a model with an invalid property' do
+        let(:error_count) { 1 }
+      end
+    end
+
+    context "when value is not a symbol" do
+      let(:property_value) { Object.new }
+
+      it_should_behave_like 'a model with an invalid property' do
+        let(:error_count) { 1 }
+      end
+    end
+  end
+end

data/spec/modelish/property_types_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Modelish::PropertyTypes do
+  let(:model_class) { Class.new { include Modelish::PropertyTypes } }
+  let(:model) { model_class.new }
+
+  let(:property_name) { :my_property }
+
+  subject { model_class }
+
+  context "when included" do
+    it { should respond_to(:add_property_type) }
+    it { should respond_to(:property_types) }
+
+    describe "property_types" do
+      subject { model_class.property_types }
+
+      it { should be_a Hash }
+      it { should be_empty }
+    end
+  end
+
+  describe "#add_property_type" do
+    before { model_class.add_property_type(property_name, property_type) }
+
+    let(:default_value) { nil }
+
+    context "when property_type is Integer" do
+      let(:property_type) { Integer }
+
+      it_should_behave_like 'a typed property', :my_property, Integer do
+        let(:valid_string) { '42' }
+        let(:valid_typed_value) { 42 }
+        let(:invalid_value) { 'forty-two' }
+      end
+    end
+
+    context "when property_type is Float" do
+      let(:property_type) { Float }
+
+      it_should_behave_like 'a typed property', :my_property, Float do
+        let(:valid_string) { '42.5' }
+        let(:valid_typed_value) { 42.5 }
+        let(:invalid_value) { 'forty-two point five' }
+      end
+    end
+
+    context "when property_type is Date" do
+      let(:property_type) { Date }
+
+      it_should_behave_like 'a typed property', :my_property, Date do
+        let(:valid_string) { '2011-03-10' }
+        let(:valid_typed_value) { Date.civil(2011, 03, 10) }
+        let(:invalid_value) { 'foo' }
+      end
+    end
+
+    context "when property_type is String" do
+      let(:property_type) { String }
+
+      it_should_behave_like 'a typed property', :my_property, String do
+        let(:valid_string) { "\tmy_string  \n" }
+        let(:valid_typed_value) { "my_string" }
+      end 
+    end
+
+    context "when property_type is Symbol" do
+      let(:property_type) { Symbol }
+
+      it_should_behave_like 'a typed property', :my_property, Symbol do
+        let(:valid_string) { 'MyCrazy    String' }
+        let(:valid_typed_value) { :my_crazy_string }
+      end
+    end
+
+    context "when property_type is Array" do
+      let(:property_type) { Array }
+
+      it_should_behave_like 'a typed property', :my_property, Array do
+        let(:valid_string) { 'my valid string' }
+        let(:valid_typed_value) { ['my valid string'] }
+      end
+    end
+
+    context "when type is an arbitrary class" do
+      class CustomType
+        attr_accessor :foo
+
+        def initialize(raw_val)
+          if raw_val.respond_to?(:foo)
+            self.foo = raw_val.foo
+          elsif raw_val.is_a?(String)
+            self.foo = raw_val
+          else
+            raise TypeError.new
+          end
+        end
+
+        def ==(other)
+          other.respond_to?(:foo) && other.foo == self.foo
+        end
+      end
+
+      let(:property_type) { CustomType }
+
+      it_should_behave_like 'a typed property', :my_property, CustomType do
+        let(:valid_string) { 'bar' }
+        let(:valid_typed_value) { CustomType.new(valid_string) }
+        let(:invalid_value) { Object.new }
+      end
+    end
+
+    context "when type is a closure" do
+      let(:property_type) do
+        lambda do |val|
+          value = val.respond_to?(:split) ? val.split(',') : val
+          value.collect { |n| n.to_i }
+        end
+      end
+
+      it_should_behave_like 'a typed property', :my_property do
+        let(:valid_string) { '1,2,3' }
+        let(:valid_typed_value) { [1,2,3] }
+        let(:invalid_value) { Object.new }
+      end
+    end
+  end
+end

data/spec/modelish/validations_spec.rb

@@ -0,0 +1,695 @@
+require 'spec_helper'
+
+describe Modelish::Validations do
+  let(:model_class) { Class.new { include Modelish::Validations } }
+
+  let(:property_name) { :validated_property }
+
+  let(:model) { model_class.new }
+
+  subject { model_class }
+
+  it { should respond_to(:validate_required?) }
+
+  describe ".validate_required?" do
+    subject { model_class.validate_required?(property_name => value) }
+
+    context "when value is nil" do
+      let(:value) { nil }
+
+      it { should be_false }
+    end
+
+    context "when value is blank" do
+      let(:value) { '    ' }
+
+      it { should be_false }
+    end
+
+    context "when value is not blank" do
+      let(:value) { Object.new }
+
+      it { should be_true }
+    end
+  end
+
+  it { should respond_to(:validate_required) }
+
+  describe ".validate_required" do
+    subject { errors }
+    let(:errors) { model_class.validate_required(property_name => value) }
+
+    context "when value is nil" do
+      let(:value) { nil }
+
+      it { should_not be_empty }
+
+      describe "first error" do
+        subject { errors.first }
+
+        it { should be_an ArgumentError }
+        its(:message) { should match(/#{property_name}/i) }
+      end
+    end
+
+    context "when value is blank" do
+      let(:value) { '        ' }
+
+      it { should_not be_empty }
+
+      describe "first error" do
+        subject { errors.first }
+
+        it { should be_an ArgumentError }
+        its(:message) { should match(/#{property_name}/i) }
+      end
+    end
+
+    context "when value is not blank" do
+      let(:value) { Object.new }
+
+      it { should be_empty }
+    end
+  end
+
+  it { should respond_to(:validate_required!) }
+
+  describe ".validate_required!" do  
+    subject { model_class.validate_required!(property_name => value) }
+
+    context "when value is nil" do
+      let(:value) { nil }
+
+      it "should raise an ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+
+      it "should include the name in the error message" do
+        expect { subject }.to raise_error { |e| e.message.should match(/#{property_name}/i) }
+      end
+    end
+
+    context "when value is blank" do
+      let(:value) { '           ' }
+
+      it "should raise an ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+
+      it "should include the name in the error message" do
+        expect { subject }.to raise_error { |e| e.message.should match(/#{property_name}/i) }
+      end
+    end
+
+    context "when value is not blank" do
+      let(:value) { 'valid value' }
+
+      it "should not raise any errors" do
+        expect { subject }.to_not raise_error
+      end
+    end
+  end
+
+  it { should respond_to(:validate_length) }
+
+  describe ".validate_length" do
+    subject { model_class.validate_length(property_name, value, max_length) }
+    let(:max_length) { 10 }
+
+    context "when value is longer than max_length" do
+      let(:value) { 'a' * (max_length + 1) }
+
+      it { should be_an ArgumentError }
+      its(:message) { should match(/#{property_name}/i) }
+      its(:message) { should match(/#{max_length}/) }
+    end
+
+    context "when value is shorter than max_length" do
+      let(:value) { 'a' * (max_length - 1) }
+
+      it { should be_nil }
+    end
+
+    context "when value is the same length as max_length" do
+      let(:value) { 'a' * max_length }
+
+      it { should be_nil }
+    end
+
+    context "when value is nil" do
+      let(:value) { nil }
+
+      it { should be_nil }
+    end
+
+    context "when max_length is nil" do
+      let(:value) { mock(:length => 50) }
+      let(:max_length) { nil }
+
+      it { should be_nil }
+    end
+  end
+
+  it { should respond_to(:validate_length?) }
+
+  describe ".validate_length?" do
+    subject { model_class.validate_length?(property_name, value, max_length) }
+    let(:max_length) { 16 }
+
+    context "when value is longer than max_length" do
+      let(:value) { 'a' * (max_length + 1) }
+
+      it { should be_false }
+    end
+
+    context "when value is shorter than max_length" do
+      let(:value) { 'a' * (max_length - 1) }
+
+      it { should be_true }
+    end
+
+    context "when value is the same length as max_length" do
+      let(:value) { 'a' * max_length }
+
+      it { should be_true }
+    end
+
+    context "when value is nil" do
+      let(:value) { nil }
+
+      it { should be_true }
+    end
+
+    context "when max_length is nil" do
+      let(:value) { Object.new }
+      let(:max_length) { nil }
+
+      it { should be_true }
+    end
+  end
+
+  it { should respond_to(:validate_length!) }
+
+  describe ".validate_length!" do
+    subject { model_class.validate_length!(property_name, value, max_length) }
+    let(:max_length) { 8 }
+
+    context "when value is longer than max_length" do
+      let(:value) { 'a' * (max_length + 1) }
+
+      it "should raise an ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+
+      it "should include the name in the error message" do
+        expect { subject }.to raise_error { |e| e.message.should match(/#{property_name}/i) }
+      end
+
+      it "should include the max length in the error message" do
+        expect { subject }.to raise_error { |e| e.message.should match(/#{max_length}/) }
+      end
+    end
+
+    context "when value is shorter than max_length" do
+      let(:value) { 'a' * (max_length - 1) }
+
+      it "should not raise an error" do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context "when value is nil" do
+      let(:value) { nil }
+
+      it "should not raise an error" do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context "when max_length is nil" do
+      let(:max_length) { nil }
+      let(:value) { 'aaaaaaaaaaa' }
+
+      it "should not raise an error" do
+        expect { subject }.to_not raise_error
+      end
+    end
+  end
+
+  it { should respond_to(:validate_type) }
+
+  describe ".validate_type" do
+    subject { model_class.validate_type(property_name, property_value, property_type) }
+
+    context "for type Integer" do
+      let(:property_type) { Integer }
+
+      context "with nil value" do
+        let(:property_value) { nil }
+
+        it { should be_nil }
+      end
+
+      context "with valid int" do
+        let(:property_value) { 42 }
+
+        it { should be_nil }
+      end
+
+      context "with valid string" do
+        let(:property_value) { '42' }
+
+        it { should be_nil }
+      end
+
+      context "with invalid value" do
+        let(:property_value) { 42.99 }
+
+        it { should be_an ArgumentError }
+        its(:message) { should match(/#{property_name}/i) }
+        its(:message) { should match(/#{property_value.inspect}/i) }
+        its(:message) { should match(/#{property_type}/i) }
+      end
+    end
+
+    context "for type Float" do
+      let(:property_type) { Float }
+
+      context "with nil value" do
+        let(:property_value) { nil }
+
+        it { should be_nil }
+      end
+
+      context "with valid float value" do
+        let(:property_value) { 42.5 }
+
+        it { should be_nil }
+      end
+
+      context "with valid string" do
+        let(:property_value) { '42.5' }
+
+        it { should be_nil }
+      end
+
+      context "with valid type that can be upcast" do
+        let(:property_value) { 42 }
+
+        it { should be_nil }
+      end
+
+      context "with invalid value" do
+        let(:property_value) { 'forty-two' }
+
+        it { should be_an ArgumentError }
+        its(:message) { should match(/#{property_name}/i) }
+        its(:message) { should match(/#{property_value.inspect}/i) }
+        its(:message) { should match(/#{property_type}/i) }
+      end
+    end
+
+    context "for type Array" do
+      let(:property_type) { Array }
+
+      context "with nil" do
+        let(:property_value) { nil }
+
+        it { should be_nil }
+      end
+      context "with a valid array" do
+        let(:property_value) { [1,2,3] }
+
+        it { should be_nil }
+      end
+
+      context "with an invalid value" do
+        let(:property_value) { {1 => 2, 3 => 4} }
+
+        it { should be_an ArgumentError }
+        its(:message) { should match(/#{property_name}/i) }
+        its(:message) { should match(/#{property_value.inspect.gsub('{', '\{').gsub('}', '\}')}/i) }
+        its(:message) { should match(/#{property_type}/i) }
+      end
+    end
+
+    context "for an arbitrary class" do
+      let(:property_type) { Hash }
+
+      context "with nil value" do
+        let(:property_value) { nil }
+
+        it { should be_nil }
+      end
+
+      context "with valid hash value" do
+        let(:property_value) { {1 => 2} }
+
+        it { should be_nil }
+      end
+
+      context "with invalid value" do
+        let(:property_value) { [1,2] }
+
+        it { should be_an ArgumentError }
+        its(:message) { should match(/#{property_name}/i) }
+        its(:message) { should match(/#{property_value.inspect}/i) }
+        its(:message) { should match(/#{property_type}/i) }
+      end
+    end
+
+    context "for type Date" do
+      let(:property_type) { Date }
+
+      context "with nil value" do
+        let(:property_value) { nil }
+
+        it { should be_nil }
+      end
+
+      context "with valid string" do
+        let(:property_value) { '2011-03-10' }
+
+        it { should be_nil }
+      end
+
+      context "with valid Date" do
+        let(:property_value) { Date.civil(2011, 3, 10) }
+
+        it { should be_nil }
+      end
+
+      context "with invalid value" do
+        let(:property_value) { 'this is not a date' }
+
+        it { should be_an ArgumentError }
+        its(:message) { should match(/#{property_name}/i) }
+        its(:message) { should match(/#{property_value.inspect}/i) }
+        its(:message) { should match(/#{property_type}/i) }
+      end
+    end
+
+    context "for a Symbol type" do
+      let(:property_type) { Symbol }
+
+      context "with nil value" do
+        let(:property_value) { nil }
+
+        it { should be_nil }
+      end
+
+      context "with a valid string" do
+        let(:property_value) { 'my string' }
+
+        it { should be_nil }
+      end
+
+      context "with a valid symbol" do
+        let(:property_value) { :my_symbol }
+
+        it { should be_nil }
+      end
+
+      context "with an invalid value" do
+        let(:property_value) { Object.new }
+
+        it { should be_an ArgumentError }
+        its(:message) { should match(/#{property_name}/i) }
+        its(:message) { should match(/#{property_value.inspect}/i) }
+        its(:message) { should match(/#{property_type}/i) }
+      end
+    end
+
+    context "when type is nil" do
+      let(:property_type) { nil }
+
+      context "with any value" do
+        let(:property_value) { 'foo' } 
+
+        it { should be_nil }
+      end
+    end
+  end
+
+  it { should respond_to(:validate_type!) }
+
+  describe ".validate_type!" do
+    subject { model_class.validate_type!(property_name, property_value, property_type) }
+
+    context "for type Integer" do
+      let(:property_type) { Integer }
+
+      context "with nil value" do
+        let(:property_value) { nil }
+
+        it "should not raise any errors" do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      context "with valid int" do
+        let(:property_value) { 42 }
+
+        it "should not raise any errors" do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      context "with valid string" do
+        let(:property_value) { '42' }
+
+        it "should not raise any errors" do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      context "with invalid value" do
+        let(:property_value) { 42.99 }
+
+        it "should raise an ArgumentError" do
+          expect { subject }.to raise_error(ArgumentError)
+        end
+
+        it "should reference the property name in the error message" do
+          expect { subject }.to raise_error { |e| e.message.should match(/#{property_name}/i) }
+        end
+      end
+    end
+  end
+
+  it { should respond_to(:validate_type?) }
+
+  describe ".validate_type?" do
+    subject { model_class.validate_type?(property_name, property_value, property_type) }
+
+    context "for type Integer" do
+      let(:property_type) { Integer }
+
+      context "with nil value" do
+        let(:property_value) { nil }
+
+        it { should be_true }
+      end
+
+      context "with valid int" do
+        let(:property_value) { 42 }
+
+        it { should be_true }
+      end
+
+      context "with valid string" do
+        let(:property_value) { '42' }
+
+        it { should be_true }
+      end
+
+      context "with invalid value" do
+        let(:property_value) { 42.99 }
+
+        it { should be_false }
+      end
+    end
+  end
+
+  it { should respond_to(:add_validator) }
+
+  context "with simple validated property" do
+    before do 
+      model_class.add_validator(property_name, &validator_block)
+      model.send("#{property_name}=", property_value)
+    end
+
+    subject { model }
+
+    let(:property_value) { '42' }
+
+    let(:message_validator) { lambda { |val| val.to_i != 42 ? "#{property_name} must be 42" : nil } }
+    let(:error_validator) { lambda { |val| val.to_i != 42 ? ArgumentError.new("#{property_name} must be 42") : nil } }
+
+    describe ".validators" do
+      let(:validator_block) { message_validator }
+
+      subject { validators }
+      let(:validators) { model_class.validators }
+
+      it { should have(1).property }
+
+      describe "[property_name]" do
+        subject { prop_validators }
+        let(:prop_validators) { validators[property_name] }
+
+        it { should have(1).validator }
+
+        describe "#first" do
+          subject { prop_validators.first }
+
+          it { should respond_to(:call) }
+          it { should == validator_block }
+        end
+      end
+    end
+
+    context "with valid value" do
+      context "with validator that returns an error message" do
+        let(:validator_block) { message_validator }
+
+        it_should_behave_like 'a valid model'
+      end
+
+      context "with validator that returns an error" do
+        let(:validator_block) { error_validator }
+
+        it_should_behave_like 'a valid model'
+      end
+    end
+
+    context "with invalid value" do
+      let(:property_value) { 'not valid' }
+
+      context "with validator that returns an error message" do
+        let(:validator_block) { message_validator }
+
+        it_should_behave_like 'a model with an invalid property' do
+          let(:error_count) { 1 }
+        end
+      end
+
+      context "with validator that returns an error" do
+        let(:validator_block) { error_validator }
+
+         it_should_behave_like 'a model with an invalid property' do
+          let(:error_count) { 1 }
+        end
+      end
+    end
+  end
+
+  context "with property that has multiple validations" do
+    before do
+      model_class.add_validator(property_name, &nil_validator)
+      model_class.add_validator(property_name, &int_validator)
+      model.send("#{property_name}=", property_value)
+    end
+
+    subject { model }
+
+    let(:nil_validator) { lambda { |val| val.nil? ? "#{property_name} should not be nil" : nil } }
+    let(:int_validator) { lambda { |val| "#{property_name} must represent the integer 42" unless val.to_i == 42 } }
+
+    let(:property_value) { '42' }
+
+    describe ".validators" do
+      subject { validators }
+      let(:validators) { model_class.validators }
+
+      it { should have(1).property }
+
+      describe "[property_name]" do
+        subject { prop_validators }
+        let(:prop_validators) { validators[property_name] }
+
+        it { should have(2).validators }
+
+        describe "#first" do
+          subject { prop_validators.first }
+          it { should respond_to(:call) }
+          it { should == nil_validator }
+        end
+
+        describe "#last" do
+          subject { prop_validators.last }
+          it { should respond_to(:call) }
+          it { should == int_validator }
+        end
+      end
+    end
+
+    context "with valid value" do
+      it { should be_valid }
+
+      describe "#validate" do
+        subject { model.validate }
+
+        it { should be_empty }
+      end
+
+      describe "#validate!" do
+        subject { model.validate! }
+
+        it "should not raise any errors" do
+          expect { subject }.to_not raise_error
+        end
+      end
+    end
+
+    context "with nil value" do
+      let(:property_value) { nil }
+
+      it { should_not be_valid }
+
+      describe "#validate" do
+        subject { errors }
+        let(:errors) { model.validate }
+
+        it { should have(1).property }
+
+        it { should have_key(property_name) }
+
+        describe "[property_name]" do
+          subject { prop_errors }
+          let(:prop_errors) { errors[property_name] }
+
+          it { should have(2).errors }
+
+          describe "#first" do
+            subject { prop_errors.first }
+
+            it { should be_a ArgumentError }
+            its(:message) { should match(/#{property_name}/i) }
+            its(:message) { should match(/nil/i) }
+          end
+
+          describe "#last" do
+            subject { prop_errors.last }
+
+            it { should be_a ArgumentError }
+            its(:message) { should match(/#{property_name}/i) }
+            its(:message) { should match(/integer/i) }
+          end
+        end
+      end
+
+      describe "#validate!" do
+        subject { model.validate! }
+
+        it "should raise an ArgumentError" do
+          expect { subject }.to raise_error(ArgumentError)
+        end
+
+        it "should reference the property name in the error message" do
+          expect { subject }.to raise_error { |e| e.message.should match(/#{property_name}/i) }
+        end
+      end
+    end
+  end
+end