instructure-active_model-better_errors 1.6.3.rails2.5 → 1.6.5.rails2.1

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

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

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe ActiveModel::BetterErrors::Errors do
+  subject(:instance) { klass.new base }
+  let(:klass) { ActiveModel::BetterErrors::Errors }
+  let(:base)  { User.new }
+  let(:reporter_name) { :mock }
+  let(:mock_reporter) do
+    Class.new do
+      def initialize(collection)
+      end
+    end
+  end
+
+  before { ActiveModel::BetterErrors.set_reporter(:mock, mock_reporter) }
+  after { ActiveModel::BetterErrors.set_reporter(:mock, nil) }
+
+  describe '#initialize' do
+    its(:base) { should be base }
+  end
+
+  describe '#error_collection' do
+    subject { instance.error_collection }
+    it { should be_a ActiveModel::BetterErrors::ErrorCollection }
+    its(:base) { should be base }
+  end
+
+  describe '#message_reporter' do
+    subject { instance.message_reporter }
+    before do
+      instance
+        .should_receive(:get_reporter)
+        .with(:message)
+        .and_return(mock_reporter)
+    end
+
+    it { should be mock_reporter }
+  end
+
+  describe '#hash_reporter' do
+    subject { instance.hash_reporter }
+    before do
+      instance
+        .should_receive(:get_reporter)
+        .with(:hash)
+        .and_return(mock_reporter)
+    end
+
+    it { should be mock_reporter }
+  end
+
+  describe '#array_reporter' do
+    subject { instance.array_reporter }
+    before do
+      instance
+        .should_receive(:get_reporter)
+        .with(:array)
+        .and_return(mock_reporter)
+    end
+
+    it { should be mock_reporter }
+  end
+
+  describe '#set_reporter' do
+    before { instance.get_reporter(:mock) }
+    it 'should set the reporter class' do
+      instance.set_reporter reporter_name, mock_reporter
+      reporter_classes = instance.instance_variable_get(:@reporter_classes)
+      reporter_classes[reporter_name.to_s].should == mock_reporter
+    end
+
+    it 'should delete old reporter instance' do
+      reporters = instance.instance_variable_get(:@reporters)
+      reporters[reporter_name] = double
+      instance.set_reporter reporter_name, mock_reporter
+      reporters.key?(reporter_name.to_s).should be false
+    end
+  end
+
+  describe '#get_reporter_class' do
+    subject { instance.get_reporter_class(reporter_name) }
+    before { instance.set_reporter reporter_name, mock_reporter }
+    it { should == mock_reporter }
+  end
+
+  describe '#get_reporter' do
+    subject { instance.get_reporter(reporter_name) }
+    before { instance.set_reporter reporter_name, mock_reporter }
+    it { should be_a mock_reporter }
+  end
+
+  describe '#reporter_classes' do
+    subject { instance.reporter_classes }
+    it { should == ::ActiveModel::BetterErrors.reporters }
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe ActiveModel::BetterErrors::HumanArrayReporter do
+  subject           { reporter }
+  let(:reporter)    { klass.new collection }
+  let(:klass)       { ActiveModel::BetterErrors::HumanArrayReporter }
+  let(:collection)  { ActiveModel::BetterErrors::ErrorCollection.new base }
+  let(:base)        { User.new }
+
+  describe '#initialize' do
+    its(:collection) { should be collection }
+  end
+
+  describe '#base' do
+    its(:base) { should be base }
+  end
+
+  describe '#to_a' do
+    subject { reporter.to_a }
+    let(:expected) do
+      %w(foo bar)
+    end
+
+    before do
+      message_reporter = double
+      ActiveModel::BetterErrors::HumanMessageReporter
+        .should_receive(:new)
+        .and_return(message_reporter)
+
+      message_reporter
+        .should_receive(:full_messages)
+        .and_return(expected)
+    end
+
+    it { should == expected }
+  end
+end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe ActiveModel::BetterErrors::HumanHashReporter do
+  subject { reporter }
+  let(:reporter)    { klass.new collection }
+  let(:klass)       { ActiveModel::BetterErrors::HumanHashReporter }
+  let(:collection)  { ActiveModel::BetterErrors::ErrorCollection.new base }
+  let(:base)        { User.new }
+
+  describe '#initialize' do
+    its(:collection) { should be collection }
+  end
+
+  describe '#base' do
+    its(:base) { should be base }
+  end
+
+  describe '#to_hash' do
+    subject { reporter.to_hash }
+    let(:expected) do
+      {
+        first_name: ['is invalid', "can't be empty"],
+        last_name: ['is invalid']
+      }
+    end
+
+    before  do
+      collection[:first_name] << :invalid
+      collection[:first_name] << :empty
+      collection[:last_name] << :invalid
+    end
+
+    it { should == expected }
+  end
+end

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

@@ -1,12 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe ActiveModel::ErrorCollecting::HumanMessageFormatter do
+describe ActiveModel::BetterErrors::HumanMessageFormatter do
   subject(:formatter) { klass.new base, error_message }
-  let(:klass)         { ActiveModel::ErrorCollecting::HumanMessageFormatter }
+  let(:klass)         { ActiveModel::BetterErrors::HumanMessageFormatter }
   let(:base)          { User.new }
-  let(:error_message) { ActiveModel::ErrorCollecting::ErrorMessage.build base, :first_name, :invalid }
+  let(:error_message) do
+    ActiveModel::BetterErrors::ErrorMessage.build(
+      base, :first_name, :invalid
+    )
+  end
 
-  describe "#initialize" do
+  describe '#initialize' do
     its(:base) { should be base }
     its(:error_message) { should be error_message }
     its(:attribute) { should be error_message.attribute }
@@ -15,8 +21,8 @@ describe ActiveModel::ErrorCollecting::HumanMessageFormatter do
     its(:options) { should be error_message.options }
   end
 
-  describe "#format_message" do
+  describe '#format_message' do
     subject { formatter.format_message }
-    it { should == "is invalid" }
+    it { should == 'is invalid' }
   end
-end
+end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe ActiveModel::BetterErrors::HumanMessageReporter do
+  subject { reporter }
+  let(:reporter)    { klass.new collection }
+  let(:klass)       { ActiveModel::BetterErrors::HumanMessageReporter }
+  let(:collection)  { ActiveModel::BetterErrors::ErrorCollection.new base }
+  let(:base)        { User.new }
+
+  describe '#initialize' do
+    its(:collection) { should be collection }
+  end
+
+  describe '#base' do
+    its(:base) { should be base }
+  end
+
+  describe '#full_message' do
+    subject { reporter.full_message attribute, message }
+    let(:attribute) { :first_name }
+    let(:message)   { 'is invalid' }
+
+    it { should == 'First name is invalid' }
+  end
+
+  describe '#full_messages' do
+    subject { reporter.full_messages }
+    let(:expected) do
+      [
+        'First name is invalid',
+        "First name can't be empty",
+        'Last name is invalid'
+      ]
+    end
+
+    before  do
+      collection[:first_name] << :invalid
+      collection[:first_name] << :empty
+      collection[:last_name] << :invalid
+    end
+
+    it { should == expected }
+  end
+
+  describe '#generate_message' do
+    subject { reporter.generate_message attribute, type, options }
+    let(:attribute) { :first_name }
+
+    context 'when passing symbols as message' do
+      let(:type)      { :too_short }
+      let(:options)   { { count: 3 } }
+      let(:expected)  { 'is too short (minimum is 3 characters)' }
+      it { should == expected }
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe ActiveModel::BetterErrors::MachineArrayReporter do
+  subject           { reporter }
+  let(:reporter)    { klass.new collection }
+  let(:klass)       { ActiveModel::BetterErrors::MachineArrayReporter }
+  let(:collection)  { ActiveModel::BetterErrors::ErrorCollection.new base }
+  let(:base)        { User.new }
+
+  describe '#initialize' do
+    its(:collection) { should be collection }
+  end
+
+  describe '#base' do
+    its(:base) { should be base }
+  end
+
+  describe '#to_a' do
+    subject { reporter.to_a }
+
+    before  do
+      collection[:first_name] << :invalid
+      collection[:first_name] << [:too_short, { count: 3 }]
+      collection[:last_name] << :invalid
+    end
+
+    let(:expected) do
+      [{
+        attribute: 'first_name',
+        type:      :invalid
+      }, {
+        attribute: 'first_name',
+        type:      :too_short,
+        options:   { count: 3 }
+      }, {
+        attribute: 'last_name',
+        type:      :invalid
+      }]
+    end
+
+    it { should == expected }
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe ActiveModel::BetterErrors::MachineHashReporter do
+  subject           { reporter }
+  let(:reporter)    { klass.new collection }
+  let(:klass)       { ActiveModel::BetterErrors::MachineHashReporter }
+  let(:collection)  { ActiveModel::BetterErrors::ErrorCollection.new base }
+  let(:base)        { User.new }
+
+  describe '#initialize' do
+    its(:collection) { should be collection }
+  end
+
+  describe '#base' do
+    its(:base) { should be base }
+  end
+
+  describe '#to_hash' do
+    subject { reporter.to_hash }
+
+    before  do
+      collection[:first_name] << :invalid
+      collection[:first_name] << [:too_short, { count: 3 }]
+      collection[:last_name] << :invalid
+    end
+
+    let(:expected) do
+      {
+        first_name: [{
+          type:      :invalid
+        }, {
+          type:      :too_short,
+          options:   { count: 3 }
+        }],
+        last_name: [{
+          type:      :invalid
+        }]
+      }
+    end
+
+    it { should == expected }
+  end
+end