remarkable_mongo 0.1.2

data/locales/en.yml

@@ -0,0 +1,135 @@
+en:
+  remarkable:
+    mongo_mapper:
+      describe:
+        each: "{{key}} is {{value}}"
+        prepend: "when "
+        connector: " and "
+      expectations:
+        allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
+        allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+      optionals:
+        allow_nil:
+          positive: "allowing nil values"
+          negative: "not allowing nil values"
+        allow_blank:
+          positive: "allowing blank values"
+          negative: "not allowing blank values"
+      
+      allow_values_for:
+        description: "allow {{in}} as values for {{attributes}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          
+      association:
+        many: have many
+        belongs_to: belong to
+        description: "{{type}} {{associations}}"
+        expectations:
+          association_exists: "{{subject_name}} records {{type}} {{association}}, but the association does not exist"
+          type_matches: "{{subject_name}} records {{type}} {{association}}, got {{subject_name}} records {{actual_type}} {{association}}"
+          klass_exists: "{{subject_name}} records {{type}} {{association}}, but the association class does not exist"
+          options_match: "{{subject_name}} records {{type}} {{association}} with options {{options}}, got {{actual}}"
+          
+      have_key:
+        description: "have key(s) {{attributes}} with type {{type}}"
+        expectations:
+          has_key: "{{subject_name}} to have key named {{attribute}} with type {{type}}"
+          
+      validate_acceptance_of:
+        description: "require {{attributes}} to be accepted"
+        expectations:
+          requires_acceptance: "{{subject_name}} to be invalid if {{attribute}} is not accepted"
+          accept_is_valid: "{{subject_name}} to be valid when {{attribute}} is accepted with value {{accept}}"
+        optionals:
+          accept:
+            positive: "with value {{inspect}}"
+
+      validate_associated:
+        description: "require associated {{associations}} to be valid"
+        expectations:
+          is_valid: "{{subject_name}} to be invalid when {{association}} is invalid"
+          
+      validate_confirmation_of:
+        description: "require {{attributes}} to be confirmed"
+        expectations:
+          responds_to_confirmation: "{{subject_name}} instance responds to {{attribute}}_confirmation"
+          confirms: "{{subject_name}} to be valid only when {{attribute}} is confirmed"
+          
+      validate_exclusion_of:
+        description: "ensure exclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+
+      validate_inclusion_of:
+        description: "ensure inclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+
+      validate_length_of:
+        description: "ensure length of {{attributes}}"
+        expectations:
+          less_than_min_length: "{{subject_name}} to be invalid when {{attribute}} length is less than {{minimum}} characters"
+          exactly_min_length: "{{subject_name}} to be valid when {{attribute}} length is {{minimum}} characters"
+          more_than_max_length: "{{subject_name}} to be invalid when {{attribute}} length is more than {{maximum}} characters"
+          exactly_max_length: "{{subject_name}} to be valid when {{attribute}} length is {{maximum}} characters"
+        optionals:
+          within:
+            positive: "is within {{inspect}} characters"
+          maximum:
+            positive: "is maximum {{inspect}} characters"
+          minimum:
+            positive: "is minimum {{inspect}} characters"
+          is:
+            positive: "is equal to {{inspect}} characters"
+          with_kind_of:
+            positive: "with kind of {{value}}"
+
+      validate_numericality_of:
+        description: "ensure numericality of {{attributes}}"
+        expectations:
+          only_numeric_values: "{{subject_name}} to allow only numeric values for {{attribute}}"
+          only_integer: "{{subject_name}} to {{not}}allow only integer values for {{attribute}}"
+          only_even: "{{subject_name}} to allow only even values for {{attribute}}"
+          only_odd: "{{subject_name}} to allow only odd values for {{attribute}}"
+          equals_to: "{{subject_name}} to be valid only when {{attribute}} is equal to {{count}}"
+          more_than_maximum: "{{subject_name}} to be invalid when {{attribute}} is greater than {{count}}"
+          less_than_minimum: "{{subject_name}} to be invalid when {{attribute}} is less than {{count}}"
+        optionals:
+          only_integer:
+            positive: "allowing only integer values"
+          odd:
+            positive: "allowing only odd values"
+          even:
+            positive: "allowing only even values"
+          equal_to:
+            positive: "is equal to {{inspect}}"
+          less_than:
+            positive: "is less than {{inspect}}"
+          greater_than:
+            positive: "is greater than {{inspect}}"
+          less_than_or_equal_to:
+            positive: "is less than or equal to {{inspect}}"
+          greater_than_or_equal_to:
+            positive: "is greater than or equal to {{inspect}}"
+
+      validate_presence_of:
+        description: "require {{attributes}} to be set"
+        expectations:
+          allow_nil: "{{subject_name}} to require {{attribute}} to be set"
+          
+      validate_uniqueness_of:
+        description: "require unique values for {{attributes}}"
+        expectations:
+          responds_to_scope: "{{subject_name}} instance responds to {{method}}"
+          is_unique: "{{subject_name}} to require unique values for {{attribute}}"
+          case_sensitive: "{{subject_name}} to {{not}}be case sensitive on {{attribute}} validation"
+          valid_with_new_scope: "{{subject_name}} to be valid when {{attribute}} scope ({{method}}) change"
+        optionals:
+          scope:
+            positive: "scoped to {{sentence}}"
+          case_sensitive:
+            positive: "case sensitive"
+            negative: "case insensitive"

data/spec/matchers/allow_values_for_matcher_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'allow_values_for' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :product do
+      include MongoMapper::Document
+      
+      key :title, String
+      key :category, String
+      
+      validates_format_of :title, options
+    end
+
+    allow_values_for(:title)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate(:with => /X|Y|Z/) }
+
+    it 'should contain a description' do
+      @matcher = allow_values_for(:title, "X", "Y", "Z")
+      @matcher.description.should == 'allow "X", "Y", and "Z" as values for title'
+    end
+
+    it 'should set is_valid? message' do
+      @matcher.in("A").matches?(subject)
+      @matcher.failure_message.should == 'Expected Product to be valid when title is set to "A"'
+    end
+
+    it 'should set allow_nil? message' do
+      @matcher.allow_nil.matches?(subject)
+      @matcher.failure_message.should == 'Expected Product to allow nil values for title'
+    end
+
+    it 'should set allow_blank? message' do
+      @matcher.allow_blank.matches?(subject)
+      @matcher.failure_message.should == 'Expected Product to allow blank values for title'
+    end
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate(:with => /X|Y|Z/).in('X', 'Y', 'Z') }
+    it { should_not define_and_validate(:with => /X|Y|Z/).in('A') }
+  
+    it { should define_and_validate(:with => /X|Y|Z/, :message => 'valid').in('X', 'Y', 'Z').message('valid') }
+  
+    create_optional_boolean_specs(:allow_nil, self, :with => /X|Y|Z/)
+    create_optional_boolean_specs(:allow_blank, self, :with => /X|Y|Z/)
+  end
+  
+  describe 'macros' do
+    before(:each){ define_and_validate(:with => /X|Y|Z/) }
+    
+    should_allow_values_for :title, 'X'
+    should_not_allow_values_for :title, 'A'
+  end
+  
+  describe 'failures' do
+    it "should fail if any of the values are valid on invalid cases" do
+      define_and_validate(:with => /X|Y|Z/)
+      
+      lambda {
+        should_not allow_values_for(:title, 'A', 'X', 'B')
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Did not expect Product to be valid/)
+    end
+  end
+end
+

data/spec/matchers/association_matcher_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'association_matcher' do
+  subject do
+    Article.new
+  end
+  
+  describe 'have_many' do
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = have_many(:comments)
+        matcher.description.should == 'have many comments'
+      end
+
+      it 'should set association_exists? message' do
+        matcher = have_many(:whatever)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many whatever, but the association does not exist'
+      end
+
+      it 'should set type_matches? message' do
+        matcher = belong_to(:comments)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to comments, got Article records have many comments'
+      end
+      
+      it 'should set klass_exists? message' do
+        matcher = have_many(:unknowns)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many unknowns, but the association class does not exist'
+      end
+      
+      it 'should set options_matches? message when :class_name is given' do
+        matcher = have_many(:ratings, :class_name => 'Rating')
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many ratings with options {:class_name=>"Rating"}, got {:class_name=>"Rate"}'
+      end
+      
+      it 'should set options_matches? message when :polymorphic is given' do
+        matcher = have_many(:assets, :polymorphic => true)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many assets with options {:polymorphic=>"true"}, got {:polymorphic=>""}'
+      end
+    end
+    
+    describe 'matchers' do
+      it { should have_many(:comments) }
+      it { should_not belong_to(:comment) }
+    end
+    
+    describe 'macros' do
+      should_have_many :comments
+      should_not_belong_to :comment
+    end
+
+  end
+  
+  describe 'belong_to' do
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = belong_to(:user)
+        matcher.description.should == 'belong to user'
+      end
+
+      it 'should set association_exists? message' do
+        matcher = belong_to(:whatever)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to whatever, but the association does not exist'
+      end
+      
+      it 'should set type_matches? message' do
+        matcher = have_many(:user)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many user, got Article records belong to user'
+      end
+      
+      it 'should set klass_exists? message' do
+        matcher = belong_to(:unknown)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to unknown, but the association class does not exist'
+      end
+      
+      it 'should set options_matches? message when :class_name is given' do
+        matcher = belong_to(:site, :class_name => 'Website')
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to site with options {:class_name=>"Website"}, got {:class_name=>"Site"}'
+      end
+    end
+    
+    describe 'matchers' do
+      it { should belong_to(:user) }
+      it { should_not have_many(:users) }
+    end
+    
+    describe 'macros' do
+      should_belong_to :user
+      should_not_have_many :users
+    end
+
+  end
+
+end

data/spec/matchers/have_key_matcher_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'have_key' do
+  subject do
+    Article.new
+  end
+  
+  describe 'messages' do
+
+    it 'should contain a description' do
+      matcher = have_key(:title, String)
+      matcher.description.should == 'have key(s) title with type String'
+    end
+
+    it 'should set has_key? message' do
+      matcher = have_key(:owner, String)
+      matcher.matches?(subject)
+      matcher.failure_message.should == 'Expected Article to have key named owner with type String'
+    end
+
+  end
+  
+  describe 'matchers' do
+    it { should have_key(:title, String) }
+    it { should have_keys(:title, :body, String) }
+  end
+
+  describe 'macros' do
+    should_have_key :title, String
+    should_have_keys :title, :body, String
+  end
+end

data/spec/matchers/validate_confirmation_of_matcher_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'validate_confirmation_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :person do
+      include MongoMapper::Document
+      
+      key :name, String
+      key :email, String
+      key :age, String
+      
+      validates_confirmation_of :name, :email, options
+    end
+
+    validate_confirmation_of(:name, :email)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate }
+
+    it 'should contain a description' do
+      @matcher.description.should == 'require name and email to be confirmed'
+    end
+
+    it 'should set responds_to_confirmation? message' do
+      @matcher = validate_confirmation_of(:age)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Person instance responds to age_confirmation'
+    end
+
+    it 'should set confirms? message' do
+      @model.instance_eval{ def age_confirmation=(*args); end }
+      @matcher = validate_confirmation_of(:age)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Person to be valid only when age is confirmed'
+    end
+
+  end
+
+  describe 'matchers' do
+
+    describe 'without options' do
+      before(:each){ define_and_validate }
+
+      it { should validate_confirmation_of(:name) }
+      it { should validate_confirmation_of(:name, :email) }
+      it { should_not validate_confirmation_of(:name, :age) }
+    end
+
+    create_message_specs(self)
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate }
+
+    should_validate_confirmation_of :name
+    should_validate_confirmation_of :name, :email
+    should_not_validate_confirmation_of :name, :age
+  end
+
+end

data/spec/matchers/validate_length_of_matcher_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'validate_length_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    options = options.merge(:within => 3..5) if options.slice(:within, :maximum, :minimum, :is).empty?
+
+    @model = define_model :product do
+      include MongoMapper::Document
+      
+      key :size, String
+      key :category, String
+      
+      validates_length_of :size, options
+    end
+
+    validate_length_of(:size)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate }
+  
+    it 'should contain a description' do
+      @matcher.within(3..5)
+      @matcher.description.should == 'ensure length of size is within 3..5 characters'
+
+      @matcher.within(nil).is(3)
+      @matcher.description.should == 'ensure length of size is equal to 3 characters'
+
+      @matcher.is(nil).maximum(5)
+      @matcher.description.should == 'ensure length of size is maximum 5 characters'
+
+      @matcher.maximum(nil).minimum(3)
+      @matcher.description.should == 'ensure length of size is minimum 3 characters'
+
+      @matcher.allow_nil(false)
+      @matcher.description.should == 'ensure length of size is minimum 3 characters and not allowing nil values'
+
+      @matcher.allow_blank
+      @matcher.description.should == 'ensure length of size is minimum 3 characters, not allowing nil values, and allowing blank values'
+    end
+
+    it 'should set less_than_min_length? message' do
+      @matcher.within(4..5).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be invalid when size length is less than 4 characters'
+    end
+
+    it 'should set exactly_min_length? message' do
+      @matcher.should_receive(:less_than_min_length?).and_return(true)
+      @matcher.within(2..5).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid when size length is 2 characters'
+    end
+
+    it 'should set more_than_max_length? message' do
+      @matcher.within(3..4).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be invalid when size length is more than 4 characters'
+    end
+
+    it 'should set exactly_max_length? message' do
+      @matcher.should_receive(:more_than_max_length?).and_return(true)
+      @matcher.within(3..6).matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid when size length is 6 characters'
+    end
+
+    it 'should set allow_blank? message' do
+      @matcher.within(3..5).allow_blank.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow blank values for size'
+    end
+
+    it 'should set allow_nil? message' do
+      @matcher.within(3..5).allow_nil.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow nil values for size'
+    end
+  end
+
+  describe 'matcher' do
+    # Wrap specs without options. Usually a couple specs.
+    describe 'without options' do
+      before(:each){ define_and_validate }
+
+      it { should validate_length_of(:size, :within => 3..5) }
+      it { should_not validate_length_of(:category, :within => 3..5) }
+    end
+
+    describe "with message option" do
+
+      # if RAILS_VERSION =~ /^2.3/
+      #   it { should define_and_validate(:message => 'not valid').within(3..5).message('not valid') }
+      #   it { should_not define_and_validate(:message => 'not valid').within(3..5).message('valid') }
+      # else
+      #   it { should define_and_validate(:too_short => 'not valid', :too_long => 'not valid').within(3..5).message('not valid') }
+      #   it { should_not define_and_validate(:too_short => 'not valid', :too_long => 'not valid').within(3..5).message('valid') }
+      # end
+
+      it { should define_and_validate(:is => 4, :message => 'not valid').is(4).message('not valid') }
+      it { should_not define_and_validate(:is => 4, :message => 'not valid').is(4).message('valid') }
+    end
+
+    describe "with within option" do
+      it { should define_and_validate(:within => 3..5).within(3..5)     }
+      it { should_not define_and_validate(:within => 3..5).within(2..5) }
+      it { should_not define_and_validate(:within => 3..5).within(4..5) }
+      it { should_not define_and_validate(:within => 3..5).within(3..4) }
+      it { should_not define_and_validate(:within => 3..5).within(3..6) }
+    end
+
+    describe "with minimum option" do
+      it { should define_and_validate(:minimum => 3).minimum(3)     }
+      it { should_not define_and_validate(:minimum => 3).minimum(2) }
+      it { should_not define_and_validate(:minimum => 3).minimum(4) }
+    end
+
+    describe "with maximum option" do
+      it { should define_and_validate(:maximum => 3).maximum(3)     }
+      it { should_not define_and_validate(:maximum => 3).maximum(2) }
+      it { should_not define_and_validate(:maximum => 3).maximum(4) }
+    end
+
+    describe "with is option" do
+      it { should define_and_validate(:is => 3).is(3)     }
+      it { should_not define_and_validate(:is => 3).is(2) }
+      it { should_not define_and_validate(:is => 3).is(4) }
+    end
+
+    # Those are macros to test optionals which accept only boolean values
+    create_optional_boolean_specs(:allow_nil, self)
+    create_optional_boolean_specs(:allow_blank, self)
+  end
+
+  # In macros we include just a few tests to assure that everything works properly
+  describe 'macros' do
+    before(:each) { define_and_validate }
+
+    should_validate_length_of :size, :within => 3..5
+
+    should_not_validate_length_of :size, :within => 2..5
+    should_not_validate_length_of :size, :within => 4..5
+    should_not_validate_length_of :size, :within => 3..4
+    should_not_validate_length_of :size, :within => 3..6
+
+    should_validate_length_of :size do |m|
+      m.within = 3..5
+    end
+  end
+end