shoulda-matchers 3.0.0 → 3.0.1

data/spec/unit/shoulda/matchers/active_model/validate_numericality_of_matcher_spec.rb

@@ -126,6 +126,42 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
         record = build_record_validating_numericality
         expect(record).to validate_numericality
       end
+
+      context 'when the column is an integer column' do
+        it 'raises an IneffectiveTestError' do
+          record = build_record_validating_numericality(
+            column_type: :integer
+          )
+          assertion = -> { expect(record).to validate_numericality }
+
+          expect(&assertion).
+            to raise_error(described_class::IneffectiveTestError)
+        end
+      end
+
+      context 'when the column is a float column' do
+        it 'raises an IneffectiveTestError' do
+          record = build_record_validating_numericality(
+            column_type: :float
+          )
+          assertion = -> { expect(record).to validate_numericality }
+
+          expect(&assertion).
+            to raise_error(described_class::IneffectiveTestError)
+        end
+      end
+
+      context 'when the column is a decimal column' do
+        it 'raises an IneffectiveTestError' do
+          record = build_record_validating_numericality(
+            column_type: :decimal,
+          )
+          assertion = -> { expect(record).to validate_numericality }
+
+          expect(&assertion).
+            to raise_error(described_class::IneffectiveTestError)
+        end
+      end
     end
 
     context 'and not validating anything' do
@@ -187,6 +223,39 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
         record = build_record_validating_numericality(odd: true)
         expect(record).to validate_numericality.odd
       end
+
+      context 'when the column is an integer column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :integer,
+            odd: true
+          )
+
+          expect(record).to validate_numericality.odd
+        end
+      end
+
+      context 'when the column is a float column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :float,
+            odd: true
+          )
+
+          expect(record).to validate_numericality.odd
+        end
+      end
+
+      context 'when the column is a decimal column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :decimal,
+            odd: true,
+          )
+
+          expect(record).to validate_numericality.odd
+        end
+      end
     end
 
     context 'and not validating with odd' do
@@ -204,10 +273,43 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
 
   context 'qualified with even' do
     context 'and validating with even' do
-      it 'allows even number values for that attribute' do
+      it 'accepts' do
         record = build_record_validating_numericality(even: true)
         expect(record).to validate_numericality.even
       end
+
+      context 'when the column is an integer column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :integer,
+            even: true
+          )
+
+          expect(record).to validate_numericality.even
+        end
+      end
+
+      context 'when the column is a float column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :float,
+            even: true
+          )
+
+          expect(record).to validate_numericality.even
+        end
+      end
+
+      context 'when the column is a decimal column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :decimal,
+            even: true,
+          )
+
+          expect(record).to validate_numericality.even
+        end
+      end
     end
 
     context 'and not validating with even' do
@@ -229,6 +331,39 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
         )
         expect(record).to validate_numericality.is_less_than_or_equal_to(18)
       end
+
+      context 'when the column is an integer column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :integer,
+            less_than_or_equal_to: 18
+          )
+
+          expect(record).to validate_numericality.is_less_than_or_equal_to(18)
+        end
+      end
+
+      context 'when the column is a float column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :float,
+            less_than_or_equal_to: 18
+          )
+
+          expect(record).to validate_numericality.is_less_than_or_equal_to(18)
+        end
+      end
+
+      context 'when the column is a decimal column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :decimal,
+            less_than_or_equal_to: 18,
+          )
+
+          expect(record).to validate_numericality.is_less_than_or_equal_to(18)
+        end
+      end
     end
 
     context 'and not validating with less_than_or_equal_to' do
@@ -254,6 +389,39 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
           to validate_numericality.
           is_less_than(18)
       end
+
+      context 'when the column is an integer column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :integer,
+            less_than: 18
+          )
+
+          expect(record).to validate_numericality.is_less_than(18)
+        end
+      end
+
+      context 'when the column is a float column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :float,
+            less_than: 18
+          )
+
+          expect(record).to validate_numericality.is_less_than(18)
+        end
+      end
+
+      context 'when the column is a decimal column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :decimal,
+            less_than: 18,
+          )
+
+          expect(record).to validate_numericality.is_less_than(18)
+        end
+      end
     end
 
     context 'and not validating with less_than' do
@@ -277,6 +445,39 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
         record = build_record_validating_numericality(equal_to: 18)
         expect(record).to validate_numericality.is_equal_to(18)
       end
+
+      context 'when the column is an integer column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :integer,
+            equal_to: 18
+          )
+
+          expect(record).to validate_numericality.is_equal_to(18)
+        end
+      end
+
+      context 'when the column is a float column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :float,
+            equal_to: 18
+          )
+
+          expect(record).to validate_numericality.is_equal_to(18)
+        end
+      end
+
+      context 'when the column is a decimal column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :decimal,
+            equal_to: 18,
+          )
+
+          expect(record).to validate_numericality.is_equal_to(18)
+        end
+      end
     end
 
     context 'and not validating with equal_to' do
@@ -302,6 +503,45 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
           to validate_numericality.
           is_greater_than_or_equal_to(18)
       end
+
+      context 'when the column is an integer column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :integer,
+            greater_than_or_equal_to: 18
+          )
+
+          expect(record).
+            to validate_numericality.
+            is_greater_than_or_equal_to(18)
+        end
+      end
+
+      context 'when the column is a float column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :float,
+            greater_than_or_equal_to: 18
+          )
+
+          expect(record).
+            to validate_numericality.
+            is_greater_than_or_equal_to(18)
+        end
+      end
+
+      context 'when the column is a decimal column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :decimal,
+            greater_than_or_equal_to: 18,
+          )
+
+          expect(record).
+            to validate_numericality.
+            is_greater_than_or_equal_to(18)
+        end
+      end
     end
 
     context 'not validating with greater_than_or_equal_to' do
@@ -327,6 +567,45 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
           to validate_numericality.
           is_greater_than(18)
       end
+
+      context 'when the column is an integer column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :integer,
+            greater_than: 18
+          )
+
+          expect(record).
+            to validate_numericality.
+            is_greater_than(18)
+        end
+      end
+
+      context 'when the column is a float column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :float,
+            greater_than: 18
+          )
+
+          expect(record).
+            to validate_numericality.
+            is_greater_than(18)
+        end
+      end
+
+      context 'when the column is a decimal column' do
+        it 'accepts (and does not raise an error)' do
+          record = build_record_validating_numericality(
+            column_type: :decimal,
+            greater_than: 18,
+          )
+
+          expect(record).
+            to validate_numericality.
+            is_greater_than(18)
+        end
+      end
     end
 
     context 'and not validating with greater_than' do
@@ -740,6 +1019,16 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
     end
   end
 
+  context 'against an ActiveModel model' do
+    it 'accepts' do
+      model = define_active_model_class :example, accessors: [:attr] do
+        validates_numericality_of :attr
+      end
+
+      expect(model.new).to validate_numericality_of(:attr)
+    end
+  end
+
   describe '#description' do
     context 'qualified with nothing' do
       it 'describes that it allows numbers' do
@@ -845,8 +1134,9 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :m
 
   def define_model_validating_numericality(options = {})
     attribute_name = options.delete(:attribute_name) { self.attribute_name }
+    column_type = options.delete(:column_type) { :string }
 
-    define_model 'Example', attribute_name => :string do |model|
+    define_model 'Example', attribute_name => { type: column_type } do |model|
       model.validates_numericality_of(attribute_name, options)
     end
   end

data/spec/unit/shoulda/matchers/active_record/validate_uniqueness_of_matcher_spec.rb

@@ -441,7 +441,7 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
   end
 
   context 'when the model has a case-sensitive validation' do
-    context 'when case_insensitive is not specified' do
+    context 'when the matcher is not qualified with case_insensitive' do
       it 'accepts' do
         record = build_record_validating_uniqueness(
           attribute_type: :string,
@@ -450,9 +450,23 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
 
         expect(record).to validate_uniqueness
       end
+
+      context 'given an existing record where the value of the attribute under test is not case-swappable' do
+        it 'raises a NonCaseSwappableValueError' do
+          model = define_model_validating_uniqueness(
+            attribute_type: :string,
+            validation_options: { case_sensitive: true },
+          )
+          record = create_record_from(model, attribute_name => '123')
+          running_matcher = -> { validate_uniqueness.matches?(record) }
+
+          expect(&running_matcher).
+            to raise_error(described_class::NonCaseSwappableValueError)
+        end
+      end
     end
 
-    context 'when case_insensitive is specified' do
+    context 'when the matcher is qualified with case_insensitive' do
       it 'rejects' do
         record = build_record_validating_uniqueness(
           attribute_type: :string,

data/spec/unit/shoulda/matchers/util/word_wrap_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+require 'shoulda/matchers/util/word_wrap'
+
+describe Shoulda::Matchers, ".word_wrap" do
+  it "can wrap a simple paragraph" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus, ipsum sit amet efficitur feugiat
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus,
+ipsum sit amet efficitur feugiat
+    MESSAGE
+  end
+
+  it "does not split words up when wrapping" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean lusciousness, ipsum sit amet efficitur feugiat
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean
+lusciousness, ipsum sit amet efficitur feugiat
+    MESSAGE
+  end
+
+  it "considers punctuation as part of a word" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luscious, ipsum sit amet efficitur feugiat
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean
+luscious, ipsum sit amet efficitur feugiat
+    MESSAGE
+  end
+
+  it "re-wraps entire paragraphs" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+Lorem ipsum dolor sit amet,
+consectetur adipiscing elit.
+Aenean luctus,
+ipsum sit amet efficitur feugiat,
+dolor mauris fringilla erat, sed posuere diam ex ut velit.
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus,
+ipsum sit amet efficitur feugiat, dolor mauris fringilla erat, sed
+posuere diam ex ut velit.
+    MESSAGE
+  end
+
+  it "can wrap multiple paragraphs" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla erat, sed posuere diam ex ut velit.
+
+Etiam ultrices cursus ligula eget feugiat. Vestibulum eget tincidunt risus, non faucibus sem. 
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus,
+ipsum sit amet efficitur feugiat, dolor mauris fringilla erat, sed
+posuere diam ex ut velit.
+
+Etiam ultrices cursus ligula eget feugiat. Vestibulum eget tincidunt
+risus, non faucibus sem.
+    MESSAGE
+  end
+
+  it "can wrap a bulleted list" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+* Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla erat, sed posuere diam ex ut velit.
+* And the beat goes on.
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+* Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean
+  luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla
+  erat, sed posuere diam ex ut velit.
+* And the beat goes on.
+    MESSAGE
+  end
+
+  it "re-wraps bulleted lists" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+* Lorem ipsum dolor sit amet,
+  consectetur adipiscing elit.
+  Aenean luctus,
+  ipsum sit amet efficitur feugiat,
+  dolor mauris fringilla erat,
+  sed posuere diam ex ut velit.
+* And the beat goes on.
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+* Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean
+  luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla
+  erat, sed posuere diam ex ut velit.
+* And the beat goes on.
+    MESSAGE
+  end
+
+  it "can wrap a numbered list" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+1. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla erat, sed posuere diam ex ut velit.
+2. And the beat goes on.
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+1. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean
+   luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla
+   erat, sed posuere diam ex ut velit.
+2. And the beat goes on.
+    MESSAGE
+  end
+
+  it "re-wraps numbered lists" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+1. Lorem ipsum dolor sit amet,
+   consectetur adipiscing elit.
+   Aenean luctus,
+   ipsum sit amet efficitur feugiat,
+   dolor mauris fringilla erat,
+   sed posuere diam ex ut velit.
+2. And the beat goes on.
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+1. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean
+   luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla
+   erat, sed posuere diam ex ut velit.
+2. And the beat goes on.
+    MESSAGE
+  end
+
+  it "can wrap a numbered list, using x) instead of x. as the leader" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+1) Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla erat, sed posuere diam ex ut velit.
+2) And the beat goes on.
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+1) Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean
+   luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla
+   erat, sed posuere diam ex ut velit.
+2) And the beat goes on.
+    MESSAGE
+  end
+
+  it "re-wraps numbered lists using x) instead of x. as the leader" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+1) Lorem ipsum dolor sit amet,
+   consectetur adipiscing elit.
+   Aenean luctus,
+   ipsum sit amet efficitur feugiat,
+   dolor mauris fringilla erat,
+   sed posuere diam ex ut velit.
+2) And the beat goes on.
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+1) Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean
+   luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla
+   erat, sed posuere diam ex ut velit.
+2) And the beat goes on.
+    MESSAGE
+  end
+
+  it "doesn't mess with indented blocks" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+Some text is gonna go here.
+
+    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla erat, sed posuere diam ex ut velit.
+
+And now we return.
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+Some text is gonna go here.
+
+    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean luctus, ipsum sit amet efficitur feugiat, dolor mauris fringilla erat, sed posuere diam ex ut velit.
+
+And now we return.
+    MESSAGE
+  end
+
+  it "doesn't get stuck trying to wrap a line that can't be wrapped" do
+    wrapped_message = described_class.word_wrap(<<-MESSAGE)
+Loremipsumdolorsitamet,consecteturadipiscingelit.Aeneanluctus,ipsumsitametefficiturfeugiat,
+    MESSAGE
+
+    expect(wrapped_message).to eq(<<-MESSAGE.strip)
+Loremipsumdolorsitamet,consecteturadipiscingelit.Aeneanluctus,ipsumsitametefficiturfeugiat,
+    MESSAGE
+  end
+end