instructure-active_model-better_errors 1.6.3.rails2

data/spec/lib/active_model/error_collecting/error_message_set_spec.rb

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

data/spec/lib/active_model/error_collecting/error_message_spec.rb

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+describe ActiveModel::ErrorCollecting::ErrorMessage do
+  let(:klass)     { ActiveModel::ErrorCollecting::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 == nil }
+      end
+
+      context "when options[:message] is nil" do
+        let(:options) { { message: nil } }
+        its(:type)    { should == message }
+        its(:message) { should == 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 == 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 == nil }
+        its(:message) { should == message }
+      end
+
+      context "when options[:message] is proc" do
+        let(:options) { { message: proc { "Not Really Valid!" } } }
+        its(:type)    { should == 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 == 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 == nil }
+        its(:message) { should == message.call }
+      end
+
+      context "when options[:message] is proc" do
+        let(:options) { { message: proc { "Not Really Valid!" } } }
+        its(:type)    { should == 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 == 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 == nil }
+      end
+
+      context "when options[:message] is nil" do
+        let(:options) { { } }
+        its(:type)    { should == nil }
+        its(:message) { should == nil }
+      end
+
+      context "when options[:message] is proc" do
+        let(:options) { { message: proc { "Not Really Valid!" } } }
+        its(:type)    { should == 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 '#<=>' 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 == nil }
+    end
+
+    context "when type is different" do
+      let(:e1) { klass.build base, :name, :invalid }
+      let(:e2) { klass.build base, :name, :invalid1 }
+      it {should == 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 == 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/lib/active_model/error_collecting/errors_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe ActiveModel::ErrorCollecting::Errors do
+  subject(:instance) { klass.new base }
+  let(:klass) { ActiveModel::ErrorCollecting::Errors }
+  let(:base)  { User.new }
+  let(:reporter_name) { :mock }
+  let(:mock_reporter) {
+    Class.new do
+      def initialize(collection)
+      end
+    end
+  }
+
+  describe "#initialize" do
+    its(:base) { should be base }
+  end
+
+  describe "#error_collection" do
+    subject { instance.error_collection }
+    it { should be_a ActiveModel::ErrorCollecting::ErrorCollection }
+    its(:base) { should be base }
+  end
+
+  describe "#message_reporter" do
+    subject { instance.message_reporter }
+    let(:mock_reporter) { mock() }
+    before {
+      instance.
+        should_receive(:get_reporter).
+        with(:message).
+        and_return(mock_reporter)
+    }
+
+    it { should be mock_reporter }
+  end
+
+  describe "#hash_reporter" do
+    subject { instance.hash_reporter }
+    let(:mock_reporter) { mock() }
+    before {
+      instance.
+        should_receive(:get_reporter).
+        with(:hash).
+        and_return(mock_reporter)
+    }
+
+    it { should be mock_reporter }
+  end
+
+  describe "#array_reporter" do
+    subject { instance.array_reporter }
+    let(:mock_reporter) { mock() }
+    before {
+      instance.
+        should_receive(:get_reporter).
+        with(:array).
+        and_return(mock_reporter)
+    }
+
+    it { should be mock_reporter }
+  end
+
+  describe "#set_reporter" do
+    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] = mock()
+      instance.set_reporter reporter_name, mock_reporter
+      reporters.has_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::ErrorCollecting.reporters }
+  end
+end

data/spec/lib/active_model/error_collecting/human_array_reporter_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ActiveModel::ErrorCollecting::HumanArrayReporter do
+  subject(:reporter)  { klass.new collection }
+  let(:klass)         { ActiveModel::ErrorCollecting::HumanArrayReporter }
+  let(:collection)    { ActiveModel::ErrorCollecting::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) { ['foo', 'bar'] }
+    before do
+      message_reporter = mock()
+      ActiveModel::ErrorCollecting::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/lib/active_model/error_collecting/human_hash_reporter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ActiveModel::ErrorCollecting::HumanHashReporter do
+  subject(:reporter)  { klass.new collection }
+  let(:klass)         { ActiveModel::ErrorCollecting::HumanHashReporter }
+  let(:collection)    { ActiveModel::ErrorCollecting::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) {{
+      first_name: ["is invalid", "can't be empty"],
+      last_name: ["is invalid"]
+    }}
+
+    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/human_message_formatter_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe ActiveModel::ErrorCollecting::HumanMessageFormatter do
+  subject(:formatter) { klass.new base, error_message }
+  let(:klass)         { ActiveModel::ErrorCollecting::HumanMessageFormatter }
+  let(:base)          { User.new }
+  let(:error_message) { ActiveModel::ErrorCollecting::ErrorMessage.build base, :first_name, :invalid }
+
+  describe "#initialize" do
+    its(:base) { should be base }
+    its(:error_message) { should be error_message }
+    its(:attribute) { should be error_message.attribute }
+    its(:type) { should be error_message.type }
+    its(:message) { should be error_message.message }
+    its(:options) { should be error_message.options }
+  end
+
+  describe "#format_message" do
+    subject { formatter.format_message }
+    it { should == "is invalid" }
+  end
+end

data/spec/lib/active_model/error_collecting/human_message_reporter_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe ActiveModel::ErrorCollecting::HumanMessageReporter do
+  subject(:reporter)  { klass.new collection }
+  let(:klass)         { ActiveModel::ErrorCollecting::HumanMessageReporter }
+  let(:collection)    { ActiveModel::ErrorCollecting::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) {[
+        "First name is invalid",
+        "First name can't be empty",
+        "Last name is invalid"
+    ]}
+
+    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
+
+    context "when passing strings as message" do
+      let(:type)      { "foo" }
+      let(:options)   { nil }
+      let(:expected)  { type }
+      it { should == expected }
+    end
+  end
+end

data/spec/lib/active_model/error_collecting/machine_array_reporter_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe ActiveModel::ErrorCollecting::MachineArrayReporter do
+  subject(:reporter)  { klass.new collection }
+  let(:klass)         { ActiveModel::ErrorCollecting::MachineArrayReporter }
+  let(:collection)    { ActiveModel::ErrorCollecting::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) {[{
+      attribute: 'first_name',
+      type:      :invalid
+    }, {
+      attribute: 'first_name',
+      type:      :too_short,
+      options:   { count: 3 }
+    },{
+      attribute: 'last_name',
+      type:      :invalid
+    }]}
+
+    it { should == expected }
+  end
+end