active_model-better_errors 1.6.3 → 1.6.5

data/spec/{lib/active_model/error_collecting → unit/lib/active_model/better_errors}/error_collection_spec.rb

@@ -1,14 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe ActiveModel::ErrorCollecting::ErrorCollection do
+describe ActiveModel::BetterErrors::ErrorCollection do
   subject(:collection) { klass.new(base) }
-  let(:klass) { ActiveModel::ErrorCollecting::ErrorCollection }
+  let(:klass) { ActiveModel::BetterErrors::ErrorCollection }
   let(:base)  { User.new }
-  let(:errors){{
-    :first_name =>  [ [ :too_long, { count: 3 } ] ],
-    'last_name' =>  [ [ :invalid, { message: "Invalid" } ] ],
-    :email  =>  [ :invalid ],
-  }}
+  let(:errors) do
+    {
+      :first_name =>  [[:too_long, { count: 3 }]],
+      'last_name' =>  [[:invalid, { message: 'Invalid' }]],
+      :email  =>  [:invalid],
+    }
+  end
 
   before do
     errors.each do |attribute, error_list|
@@ -18,12 +22,12 @@ describe ActiveModel::ErrorCollecting::ErrorCollection do
     end
   end
 
-  describe "#clear" do
+  describe '#clear' do
     before { collection.clear }
     it { should be_empty }
   end
 
-  describe "#include?" do
+  describe '#include?' do
     it { should be_include :first_name }
     it { should be_include :last_name }
     it { should be_include :email }
@@ -32,82 +36,82 @@ describe ActiveModel::ErrorCollecting::ErrorCollection do
     it { should_not be_include 'email' }
   end
 
-  describe "#get" do
+  describe '#get' do
     subject { collection.get(:first_name) }
-    it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+    it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
     its(:length) { should be 1 }
 
-    describe "when value is nil" do
+    describe 'when value is nil' do
       before { collection.delete :first_name }
       it { should be nil }
     end
   end
 
-  describe "#set" do
+  describe '#set' do
     subject { collection.get :first_name }
 
-    describe "when value is array" do
+    describe 'when value is array' do
       before { collection.set(:first_name, []) }
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
       its(:length) { should be 0 }
     end
 
-      describe "when value is nil" do
-        before { collection.set(:first_name, nil) }
-        it { should be_nil }
-      end
+    describe 'when value is nil' do
+      before { collection.set(:first_name, nil) }
+      it { should be_nil }
+    end
   end
 
-  describe "#delete" do
+  describe '#delete' do
     subject { collection.get(:first_name) }
     before { collection.delete(:first_name) }
     it { should be_nil }
   end
 
-  describe "#[]" do
+  describe '#[]' do
     subject { collection[:first_name] }
 
-    describe "when no error messages" do
+    describe 'when no error messages' do
       before { collection.clear }
       it { should be_blank }
       it { should_not be_nil }
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
     end
 
-    describe "when there are error messages" do
+    describe 'when there are error messages' do
       it { should_not be_blank }
       it { should_not be_nil }
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
     end
   end
 
-  describe "#[]=" do
+  describe '#[]=' do
     subject(:error_message_set) { collection.get field }
 
-    describe "when assigning existing attribute" do
+    describe 'when assigning existing attribute' do
       let(:field) { :first_name }
-      it "should append to existing set" do
-        expect {
+      it 'should append to existing set' do
+        expect do
           collection[field] = "I'm invalid."
-        }.to change { error_message_set.length }.by(1)
+        end.to change { error_message_set.length }.by(1)
       end
     end
 
-    describe "when assigning to new attribute" do
+    describe 'when assigning to new attribute' do
       let(:field) { :a_new_attribute }
       before { collection[field] = "I'm invalid" }
       it { should_not be_nil }
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
       its(:length) { should be 1 }
     end
   end
 
-  describe "#each" do
-    it "should loop through each error" do
+  describe '#each' do
+    it 'should loop through each error' do
       count = 0
       collection.each do |attribute, error|
         attribute.should be_a Symbol
-        error.should be_a ActiveModel::ErrorCollecting::ErrorMessage
+        error.should be_a ActiveModel::BetterErrors::ErrorMessage
         count += 1
       end
 
@@ -115,51 +119,51 @@ describe ActiveModel::ErrorCollecting::ErrorCollection do
     end
   end
 
-  describe "#size" do
+  describe '#size' do
     subject { collection.size }
     it { should be 3 }
 
-    describe "when adding one more error" do
-      before { collection[:name] = "Not Valid" }
+    describe 'when adding one more error' do
+      before { collection[:name] = 'Not Valid' }
       it { should be 4 }
     end
   end
 
-  describe "#values" do
+  describe '#values' do
     subject { collection.values }
 
     it { should be_a Array }
     its(:length) { should be 3 }
 
-    it "should contain ErrorMessageSet as elements" do
+    it 'should contain ErrorMessageSet as elements' do
       collection.values.each do |el|
-        el.should be_a ActiveModel::ErrorCollecting::ErrorMessageSet
+        el.should be_a ActiveModel::BetterErrors::ErrorMessageSet
       end
     end
   end
 
-  describe "#keys" do
+  describe '#keys' do
     subject { collection.keys }
     it { should == [:first_name, :last_name, :email] }
   end
 
-  describe "#to_a" do
+  describe '#to_a' do
     subject { collection.to_a }
     its(:size) { should == 3 }
 
-    describe "when adding one more error" do
-      before { collection[:name] = "Not Valid" }
+    describe 'when adding one more error' do
+      before { collection[:name] = 'Not Valid' }
       its(:size) { should == 4 }
     end
 
-    it "should contain ErrorMessage as elements" do
+    it 'should contain ErrorMessage as elements' do
       collection.to_a.each do |error|
-        error.should be_a ActiveModel::ErrorCollecting::ErrorMessage
+        error.should be_a ActiveModel::BetterErrors::ErrorMessage
       end
     end
   end
 
-  describe "#to_hash" do
+  describe '#to_hash' do
     subject { collection.to_hash }
 
     it { should be_a Hash }
@@ -167,38 +171,38 @@ describe ActiveModel::ErrorCollecting::ErrorCollection do
     it { should_not be collection.instance_variable_get(:@collection) }
   end
 
-  describe "#empty?" do
+  describe '#empty?' do
     subject { collection.empty? }
-    it{ should be false }
+    it { should be false }
 
-    describe "after clearing the collection" do
+    describe 'after clearing the collection' do
       before { collection.clear }
 
       it { should be true }
     end
   end
 
-  describe "#add" do
-    it "should add error to collection" do
-      expect {
-        collection.add :name, "Invalid"
-        }.to change { collection[:name].length }.by(1)
+  describe '#add' do
+    it 'should add error to collection' do
+      expect do
+        collection.add(:name, 'Invalid')
+      end.to change { collection[:name].length }.by(1)
     end
   end
 
-  describe "#added?" do
-    describe "when an error message is not added" do
+  describe '#added?' do
+    describe 'when an error message is not added' do
       subject { collection.added? :name, :not_there }
       it { should be false }
     end
 
-    describe "when an error message with the same option is added" do
-      subject { collection.added? :first_name, :too_long, { :count => 3 } }
+    describe 'when an error message with the same option is added' do
+      subject { collection.added? :first_name, :too_long, count: 3 }
       it { should be true }
     end
 
-    describe "when an error message with the different option is added" do
-      subject { collection.added? :first_name, :too_long, { :count => 4 } }
+    describe 'when an error message with the different option is added' do
+      subject { collection.added? :first_name, :too_long, count: 4 }
       it { should be false }
     end
   end

data/spec/{lib/active_model/error_collecting → unit/lib/active_model/better_errors}/error_message_set_spec.rb

@@ -1,66 +1,68 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe ActiveModel::ErrorCollecting::ErrorMessageSet do
+describe ActiveModel::BetterErrors::ErrorMessageSet do
   subject(:set)   { klass.new base, attribute, errors }
-  let(:klass)     { ActiveModel::ErrorCollecting::ErrorMessageSet }
+  let(:klass)     { ActiveModel::BetterErrors::ErrorMessageSet }
   let(:attribute) { :first_name }
   let(:errors)    { [] }
   let(:base)      { User.new }
 
-  describe "#initialize" do
-    context "with no errors" do
+  describe '#initialize' do
+    context 'with no errors' do
       its(:length) { should == 0 }
     end
 
-    context "with one error" do
+    context 'with one error' do
       let(:errors) { [:invalid] }
       its(:length) { should == 1 }
     end
   end
 
-  describe "#push" do
+  describe '#push' do
     before { set.push error, options }
     let(:error)  { :invalid }
     let(:options)   { nil }
     subject { set.first }
 
-    describe "without options" do
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessage }
-      its(:message)   { should == nil }
+    describe 'without options' do
+      it { should be_a ActiveModel::BetterErrors::ErrorMessage }
+      its(:message)   { should be_nil }
       its(:type)      { should == error }
     end
 
-    describe "with options" do
+    describe 'with options' do
       let(:options)   { { message: 'Invalid' } }
 
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessage }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessage }
       its(:message)   { should == options[:message] }
       its(:type)      { should == error }
     end
   end
 
-  describe "#<<" do
+  describe '#<<' do
     before  { set << error }
     subject { set.first }
 
-    describe "when accepting error as a symbol" do
+    describe 'when accepting error as a symbol' do
       let(:error)  { :invalid }
 
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessage }
-      its(:message)   { should == nil }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessage }
+      its(:message)   { should be_nil }
       its(:type)      { should == error }
     end
 
-    describe "when accepting error as a tuple" do
-      let(:error)  { [ :invalid, { message: "OMG!!" } ]}
+    describe 'when accepting error as a tuple' do
+      let(:error)  { [:invalid, { message: 'OMG!!' }] }
 
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessage }
-      its(:message)   { should == "OMG!!" }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessage }
+      its(:message)   { should == 'OMG!!' }
       its(:type)      { should == :invalid }
     end
   end
 
-  describe "#to_a" do
+  describe '#to_a' do
     let(:errors) { [:invalid, :too_long] }
     subject { set.to_a }
 
@@ -68,23 +70,23 @@ describe ActiveModel::ErrorCollecting::ErrorMessageSet do
     its(:length) { should == 2 }
   end
 
-  describe "#empty?" do
+  describe '#empty?' do
     subject { set.empty? }
 
-    describe "when no error messages" do
+    describe 'when no error messages' do
       it { should be_true }
     end
 
-    describe "when contains error messages" do
+    describe 'when contains error messages' do
       let(:errors) { [:invalid, :too_long] }
       it { should be_false }
     end
   end
 
-  describe "#==" do
+  describe '#==' do
     subject { errors == set }
     let(:errors) { [:invalid] }
-    let(:expected) { ["is invalid"] }
+    let(:expected) { ['is invalid'] }
     specify do
       set.should == expected
     end

data/spec/unit/lib/active_model/better_errors/error_message_spec.rb

@@ -0,0 +1,315 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe ActiveModel::BetterErrors::ErrorMessage do
+  let(:klass)     { ActiveModel::BetterErrors::ErrorMessage }
+  let(:attribute) { :name }
+  let(:base)      { User.new }
+  subject(:error_message) { klass.build(base, attribute, message, options) }
+
+  describe '.normalize' do
+    subject { klass.normalize message }
+    context 'when message is a symbol' do
+      let(:message) { :invalid }
+      it { should == message }
+    end
+
+    context 'when message is nil' do
+      let(:message) { nil }
+      it { should be nil }
+    end
+
+    context 'when message is a string' do
+      let(:message) { 'bad' }
+      it { should == message }
+    end
+
+    context 'when message is a proc' do
+      let(:message) { proc { 'bad' } }
+      it { should == 'bad' }
+    end
+  end
+
+  describe '.identify' do
+    subject { klass.identify message, override }
+    context 'when message is a symbol and' do
+      let(:message) { :invalid }
+
+      context 'when override is a symbol' do
+        let(:override) { :not_good }
+        it { should == [:not_good, nil] }
+      end
+
+      context 'when override is nil' do
+        let(:override) { nil }
+        it { should == [:invalid, nil] }
+      end
+
+      context 'when override is a string' do
+        let(:override) { 'invalid' }
+        it { should == [:invalid, 'invalid'] }
+      end
+
+      context 'when override is a proc' do
+        let(:override) { proc { 'Not good' } }
+        it { should == [:invalid, 'Not good'] }
+      end
+    end
+
+    context 'when message is a string and' do
+      let(:message) { 'Invalid' }
+
+      context 'when override is a symbol' do
+        let(:override) { :not_good }
+        it { should == [:not_good, 'Invalid'] }
+      end
+
+      context 'when override is nil' do
+        let(:override) { nil }
+        it { should == [nil, 'Invalid'] }
+      end
+
+      context 'when override is a string' do
+        let(:override) { 'not good' }
+        it { should == [nil, 'not good'] }
+      end
+
+      context 'when override is a proc' do
+        let(:override) { proc { 'Not Good' } }
+        it { should == [nil, 'Not Good'] }
+      end
+    end
+
+    context 'when message is nil and' do
+      let(:message) { nil }
+
+      context 'when override is a symbol' do
+        let(:override) { :not_good }
+        it { should == [:not_good, nil] }
+      end
+
+      context 'when override is nil' do
+        let(:override) { nil }
+        it { should == [nil, nil] }
+      end
+
+      context 'when override is a string' do
+        let(:override) { 'not good' }
+        it { should == [nil, 'not good'] }
+      end
+
+      context 'when override is a proc' do
+        let(:override) { proc { 'Not Good' } }
+        it { should == [nil, 'Not Good'] }
+      end
+    end
+
+    context 'when message is a proc and' do
+      let(:message) { proc { 'invalid' } }
+
+      context 'when override is a symbol' do
+        let(:override) { :not_good }
+        it { should == [:not_good, 'invalid'] }
+      end
+
+      context 'when override is nil' do
+        let(:override) { nil }
+        it { should == [nil, 'invalid'] }
+      end
+
+      context 'when override is a string' do
+        let(:override) { 'not good' }
+        it { should == [nil, 'not good'] }
+      end
+
+      context 'when override is a proc' do
+        let(:override) { proc { 'Not Good' } }
+        it { should == [nil, 'Not Good'] }
+      end
+    end
+  end
+
+  describe '.build' do
+    context 'when message is a symbol and' do
+      let(:message) { :invalid }
+
+      context 'when options[:message] is a string' do
+        let(:options) { { message: 'Not Really Valid!' } }
+        its(:type)    { should == message }
+        its(:message) { should == options[:message] }
+      end
+
+      context 'when options[:message] is a symbol' do
+        let(:options) { { message: :not_really_valid } }
+        its(:type)    { should == options[:message] }
+        its(:message) { should be_nil }
+      end
+
+      context 'when options[:message] is nil' do
+        let(:options) { { message: nil } }
+        its(:type)    { should == message }
+        its(:message) { should be_nil }
+      end
+
+      context 'when options[:message] is proc' do
+        let(:options) { { message: proc { 'Not Really Valid!' } } }
+        its(:type)    { should == message }
+        its(:message) { should == options[:message].call }
+      end
+    end
+
+    context 'when message is a string and' do
+      let(:message) { 'Invalid!' }
+
+      context 'when options[:message] is a string' do
+        let(:options) { { message: 'Not Really Valid!' } }
+        its(:type)    { should be_nil }
+        its(:message) { should == options[:message] }
+      end
+
+      context 'when options[:message] is a symbol' do
+        let(:options) { { message: :not_really_valid } }
+        its(:type)    { should == options[:message] }
+        its(:message) { should == message }
+      end
+
+      context 'when options[:message] is nil' do
+        let(:options) { {} }
+        its(:type)    { should be_nil }
+        its(:message) { should == message }
+      end
+
+      context 'when options[:message] is proc' do
+        let(:options) { { message: proc { 'Not Really Valid!' } } }
+        its(:type)    { should be_nil }
+        its(:message) { should == options[:message].call }
+      end
+    end
+
+    context 'when message is a proc and' do
+      let(:message) { proc { 'Invalid!' } }
+
+      context 'when options[:message] is a string' do
+        let(:options) { { message: 'Not Really Valid!' } }
+        its(:type)    { should be_nil }
+        its(:message) { should == options[:message] }
+      end
+
+      context 'when options[:message] is a symbol' do
+        let(:options) { { message: :not_really_valid } }
+        its(:type)    { should == options[:message] }
+        its(:message) { should == message.call }
+      end
+
+      context 'when options[:message] is nil' do
+        let(:options) { {} }
+        its(:type)    { should be_nil }
+        its(:message) { should == message.call }
+      end
+
+      context 'when options[:message] is proc' do
+        let(:options) { { message: proc { 'Not Really Valid!' } } }
+        its(:type)    { should be_nil }
+        its(:message) { should == options[:message].call }
+      end
+    end
+
+    context 'when message is nil and' do
+      let(:message) { nil }
+
+      context 'when options[:message] is a string' do
+        let(:options) { { message: 'Not Really Valid!' } }
+        its(:type)    { should be_nil }
+        its(:message) { should == options[:message] }
+      end
+
+      context 'when options[:message] is a symbol' do
+        let(:options) { { message: :not_really_valid } }
+        its(:type)    { should == options[:message] }
+        its(:message) { should be_nil }
+      end
+
+      context 'when options[:message] is nil' do
+        let(:options) { {} }
+        its(:type)    { should be_nil }
+        its(:message) { should be_nil }
+      end
+
+      context 'when options[:message] is proc' do
+        let(:options) { { message: proc { 'Not Really Valid!' } } }
+        its(:type)    { should be_nil }
+        its(:message) { should == options[:message].call }
+      end
+    end
+
+    [
+      :if, :unless, :on, :allow_nil, :allow_blank, :strict, :message
+    ].each do |field|
+      context "when options includes :#{field}" do
+        let(:message) { :invalid }
+        let(:options) { {} }
+        before { options[field] = proc {} }
+        its(:options) { should == {} }
+      end
+    end
+  end
+
+  describe '#initialize' do
+    let(:message) { :invalid }
+    let(:options) { { message: 'Invalid!', count: 12 } }
+
+    its(:options)   { should == { count: 12 } }
+    its(:attribute) { should == attribute }
+  end
+
+  describe '#to_hash' do
+    let(:message) { :invalid }
+    let(:options) { {} }
+    let(:expected) do
+      { attribute: attribute, type: :invalid, message: nil, options: {} }
+    end
+
+    its(:to_hash) { should == expected }
+  end
+
+  describe '#as_json' do
+    let(:message) { :invalid }
+    let(:options) { {} }
+    let(:expected) do
+      { attribute: attribute, type: :invalid, message: nil, options: {} }
+    end
+
+    it 'should respond to as_json taking json arguments' do
+      subject.as_json(test: :arguments).should == expected
+    end
+  end
+
+  describe '#<=>' do
+    subject { e1 <=> e2 }
+
+    context 'when attribute is different' do
+      let(:e1) { klass.build base, :name, :invalid }
+      let(:e2) { klass.build base, :name1, :invalid }
+      it { should be_nil }
+    end
+
+    context 'when type is different' do
+      let(:e1) { klass.build base, :name, :invalid }
+      let(:e2) { klass.build base, :name, :invalid1 }
+      it { should be_nil }
+    end
+
+    context 'when message is different' do
+      let(:e1) { klass.build base, :name, :invalid, message: 'a' }
+      let(:e2) { klass.build base, :name, :invalid, message: 'b' }
+      it { should be_nil }
+    end
+
+    context 'when it is the same' do
+      let(:e1) { klass.build base, :name, :invalid }
+      let(:e2) { klass.build base, :name, :invalid }
+      it { should == 0 }
+    end
+  end
+end