simple_params 1.6.9 → 2.0.4

data/spec/errors_spec.rb

@@ -92,154 +92,56 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "setting and getting errors", setters_getters: true do
-    it "get returns the errors for the provided key" do
+  describe '[]', getter: true do
+    it "gets the errors for the provided key" do
       errors = SimpleParams::Errors.new(self)
-      errors[:foo] = "omg"
-      errors.get(:foo).should eq(["omg"])
-    end
-
-    it "sets the error with the provided key" do
-      errors = SimpleParams::Errors.new(self)
-      errors.set(:foo, "omg")
-      errors.messages.should eq({ foo: "omg" })
-    end
-
-    it "values returns an array of messages" do
-      errors = SimpleParams::Errors.new(self)
-      errors.set(:foo, "omg")
-      errors.set(:baz, "zomg")
-      errors.values.should eq(["omg", "zomg"])
-    end
-
-    it "keys returns the error keys" do
-      errors = SimpleParams::Errors.new(self)
-      errors.set(:foo, "omg")
-      errors.set(:baz, "zomg")
-      errors.keys.should eq([:foo, :baz])
-    end    
-
-    describe "setting on model" do
-      it "assign error" do
-        person = Person.new
-        person.errors[:name] = 'should not be nil'
-        person.errors[:name].should eq(["should not be nil"])
-      end
-
-      it "add an error message on a specific attribute" do
-        person = Person.new
-        person.errors.add(:name, "can not be blank")
-        person.errors[:name].should eq(["can not be blank"])
-      end
-
-      it "add an error with a symbol" do
-        person = Person.new
-        person.errors.add(:name, :blank)
-        message = person.errors.generate_message(:name, :blank)
-        person.errors[:name].should eq([message])
-      end
-
-      it "add an error with a proc" do
-        person = Person.new
-        message = Proc.new { "can not be blank" }
-        person.errors.add(:name, message)
-        person.errors[:name].should eq(["can not be blank"])
-      end
-    end
-  end
-
-  describe "setting and getting nested error model", nested_model: true do
-    it "can access error model" do
-      person = Person.new
-      dog = person.dog
-      dog_errors = dog.errors
-      person.errors[:dog].should eq(dog_errors)
-    end
-
-    it "can add to nested errors through []" do
-      person = Person.new
-      person.errors[:dog] = 'should not be nil'
-      person.dog.errors[:base].should eq(['should not be nil'])
-    end
-
-    it "can add to nested errors through add" do
-      person = Person.new
-      person.errors.add(:dog, 'should not be nil')
-      person.dog.errors[:base].should eq(['should not be nil'])
+      errors.add(:foo, "omg")
+      errors[:foo].should eq(["omg"])
     end
 
-    it "can add multiple errors to nested errors through []" do
+    it "gets model with nested attributes" do
       person = Person.new
-      person.errors[:dog] = 'should not be nil'
-      person.errors[:dog] = 'must be cute'
-      person.dog.errors[:base].should eq(['should not be nil', 'must be cute'])
-    end
-
-    it "can add multiple errors to nested errors through add" do
-      person = Person.new
-      person.errors.add(:dog, 'should not be nil')
-      person.errors.add(:dog, 'must be cute')
-      person.dog.errors[:base].should eq(['should not be nil', 'must be cute'])
+      person.errors.add(:name, "can not be blank")
+      person.errors.add(:name, "can not be nil")
+      person.errors[:name].should eq(["can not be blank", "can not be nil"])
     end
 
-    it "can add individual errors to nested attributes through []" do
+    it "gets nested model errors" do
       person = Person.new
-      person.errors[:dog][:breed] = 'should not be nil'
-      person.dog.errors[:breed].should eq(['should not be nil'])
+      person.dog.errors.add(:breed, "can not be blank")
+      person.errors[:dog][:breed].should eq(["can not be blank"])
     end
 
-    it "can add individual errors to nested attributes through  add" do
+    it "gets nested model errors" do
       person = Person.new
-      person.errors[:dog].add(:breed, 'should not be nil')
-      person.dog.errors[:breed].should eq(['should not be nil'])
+      person.cats.first.errors.add(:name, "can not be blank")
+      person.errors[:cats][0][:name].should eq(["can not be blank"])
     end
   end
 
-  describe "setting and getting nested array error model", nested_array: true do
-    it "can access error model" do
-      person = Person.new
-      cats = person.cats
-      cat_errors = cats.first.errors
-      person.errors[:cats][0].should eq(cat_errors)
-    end
-
-    it "can add to nested errors through []" do
-      person = Person.new
-      person.errors[:cats].first[:base] = 'should not be nil' 
-      person.errors[:cats].first[:base].should eq(['should not be nil']) 
-      person.cats.first.errors[:base].should eq(['should not be nil'])
-    end
-
-    it "can add to nested errors through add" do
-      person = Person.new
-      person.errors[:cats].first.add(:age, 'should not be nil')
-      person.cats.first.errors[:age].should eq(['should not be nil'])
-    end
-
-    it "can add multiple errors to nested errors through []" do
-      person = Person.new
-      person.errors[:cats].first[:name] = 'should not be nil'
-      person.errors[:cats].first[:name] = 'must be cute'
-      person.cats.first.errors[:name].should eq(['should not be nil', 'must be cute'])
+  describe '[]=', setter: true do
+    it "sets the errors for the provided key" do
+      errors = SimpleParams::Errors.new(self)
+      errors[:foo] = "omg"
+      errors[:foo].should eq(["omg"])
     end
 
-    it "can add multiple errors to nested errors through add" do
+    it "sets model with nested attributes" do
       person = Person.new
-      person.errors[:cats].first.add(:name, 'should not be nil')
-      person.errors[:cats].first.add(:name, 'must be cute')
-      person.cats.first.errors[:name].should eq(['should not be nil', 'must be cute'])
+      person.errors[:name] = "can not be blank"
+      person.errors[:name].should eq(["can not be blank"])
     end
 
-    it "can add individual errors to nested attributes through []" do
+    it "sets nested model errors" do
       person = Person.new
-      person.errors[:cats][0][:age] = 'should not be nil'
-      person.cats.first.errors[:age].should eq(['should not be nil'])
+      person.dog.errors[:breed] = "can not be blank"
+      person.errors[:dog][:breed].should eq(["can not be blank"])
     end
 
-    it "can add individual errors to nested attributes through add" do
+    it "sets nested model errors" do
       person = Person.new
-      person.errors[:cats].first.add(:age, 'should not be nil')
-      person.cats.first.errors[:age].should eq(['should not be nil'])
+      person.cats.first.errors[:name] = "can not be blank"
+      person.errors[:cats][0][:name].should eq(["can not be blank"])
     end
   end
 
@@ -292,51 +194,6 @@ describe SimpleParams::Errors do
     end
   end
 
-  describe "#added?", added: true do
-    it "added? detects if a specific error was added to the object" do
-      person = Person.new
-      person.errors.add(:name, "can not be blank")
-      person.errors.added?(:name, "can not be blank").should be_truthy
-    end
-
-    it "added? handles symbol message" do
-      person = Person.new
-      person.errors.add(:name, :blank)
-      person.errors.added?(:name, :blank).should be_truthy
-    end
-
-    it "added? handles proc messages" do
-      person = Person.new
-      message = Proc.new { "can not be blank" }
-      person.errors.add(:name, message)
-      person.errors.added?(:name, message).should be_truthy
-    end
-
-    it "added? defaults message to :invalid" do
-      person = Person.new
-      person.errors.add(:name)
-      person.errors.added?(:name).should be_truthy
-    end
-
-    it "added? matches the given message when several errors are present for the same attribute" do
-      person = Person.new
-      person.errors.add(:name, "can not be blank")
-      person.errors.add(:name, "is invalid")
-      person.errors.added?(:name, "can not be blank").should be_truthy
-    end
-
-    it "added? returns false when no errors are present" do
-      person = Person.new
-      person.errors.added?(:name).should_not be_truthy
-    end
-
-    it "added? returns false when checking a nonexisting error and other errors are present for the given attribute" do
-      person = Person.new
-      person.errors.add(:name, "is invalid")
-      person.errors.added?(:name, "can not be blank").should_not be_truthy
-    end    
-  end
-
   describe "#size", size: true do
     it "size calculates the number of error messages" do
       person = Person.new
@@ -394,7 +251,7 @@ describe SimpleParams::Errors do
       person = Person.new
       person.errors.add(:name, "can not be blank")
       person.dog.errors.add(:breed, "can not be nil")
-      person.errors.to_hash.should eq({ 
+      person.errors.to_hash.should eq({
         name: ["can not be blank"],
         dog: {
           breed: ["can not be nil"]
@@ -408,7 +265,7 @@ describe SimpleParams::Errors do
       person.errors.add(:name, "can not be blank")
       person.dog.errors.add(:base, :invalid)
       person.dog.errors.add(:breed, "can not be nil")
-      person.errors.to_hash.should eq({ 
+      person.errors.to_hash.should eq({
         base: ["is invalid"],
         name: ["can not be blank"],
         dog: {
@@ -425,7 +282,7 @@ describe SimpleParams::Errors do
       person.dog.errors.add(:base, :invalid)
       person.dog.errors.add(:breed, "can not be nil")
       person.cats.first.errors.add(:name, "can not be blank")
-      person.errors.to_hash.should eq({ 
+      person.errors.to_hash.should eq({
         base: ["is invalid"],
         name: ["can not be blank"],
         dog: {
@@ -454,13 +311,13 @@ describe SimpleParams::Errors do
       person.errors[:name] = 'can not be nil'
       person.errors[:name].should eq(["can not be nil"])
       person.errors.as_json(full_messages: true).should eq({ name: ["name can not be nil"] })
-    end    
+    end
 
     it "handles nested attributes without full_messages" do
       person = Person.new
       person.errors[:name] = 'can not be nil'
       person.dog.errors[:breed] = 'is invalid'
-      person.errors.as_json.should eq({ 
+      person.errors.as_json.should eq({
         name: ["can not be nil"],
         dog: {
           breed: ["is invalid"]
@@ -472,7 +329,7 @@ describe SimpleParams::Errors do
       person = Person.new
       person.errors[:name] = 'can not be nil'
       person.dog.errors[:breed] = 'is invalid'
-      person.errors.as_json(full_messages: true).should eq({ 
+      person.errors.as_json(full_messages: true).should eq({
         name: ["name can not be nil"],
         dog: {
           breed: ["breed is invalid"]
@@ -520,63 +377,4 @@ describe SimpleParams::Errors do
       person.errors.full_message(:name_test, "can not be blank").should eq("name_test can not be blank")
     end
   end
-
-  describe "#generate_message", generate_message: true do
-    it "generate_message works without i18n_scope" do
-      person = Person.new
-      Person.should_not respond_to(:i18n_scope)
-      expect {
-        person.errors.generate_message(:name, :blank)
-      }.to_not raise_error
-    end
-  end
-
-  describe "#adds_on_empty", add_on_empty: true do
-    it "add_on_empty generates message" do
-      person = Person.new
-      person.errors.should_receive(:generate_message).with(:name, :empty, {})
-      person.errors.add_on_empty :name
-    end
-
-    it "add_on_empty generates message for multiple attributes" do
-      person = Person.new
-      person.errors.should_receive(:generate_message).with(:name, :empty, {})
-      person.errors.should_receive(:generate_message).with(:age, :empty, {})
-      person.errors.add_on_empty [:name, :age]
-    end
-
-    it "add_on_empty generates message with custom default message" do
-      person = Person.new
-      person.errors.should_receive(:generate_message).with(:name, :empty, { message: 'custom' })
-      person.errors.add_on_empty :name, message: 'custom'
-    end
-
-    it "add_on_empty generates message with empty string value" do
-      person = Person.new
-      person.name = ''
-      person.errors.should_receive(:generate_message).with(:name, :empty, {})
-      person.errors.add_on_empty :name
-    end
-  end
-
-  describe "#adds_on_blank", add_on_blank: true do
-    it "add_on_blank generates message" do
-      person = Person.new
-      person.errors.should_receive(:generate_message).with(:name, :blank, {})
-      person.errors.add_on_blank :name
-    end
-
-    it "add_on_blank generates message for multiple attributes" do
-      person = Person.new
-      person.errors.should_receive(:generate_message).with(:name, :blank, {})
-      person.errors.should_receive(:generate_message).with(:age, :blank, {})
-      person.errors.add_on_blank [:name, :age]
-    end
-
-    it "add_on_blank generates message with custom default message" do
-      person = Person.new
-      person.errors.should_receive(:generate_message).with(:name, :blank, { message: 'custom' })
-      person.errors.add_on_blank :name, message: 'custom'
-    end
-  end
 end

data/spec/nested_errors_spec.rb

@@ -53,59 +53,32 @@ describe SimpleParams::NestedErrors do
     end
   end
 
-  describe "setting and getting errors", setters_getters: true do
-    it "get returns the errors for the provided key" do
-      errors = SimpleParams::Errors.new(self)
-      errors[:foo] = "omg"
-      errors.get(:foo).should eq(["omg"])
+  describe '[]', getter: true do
+    it "gets the errors for the provided key" do
+      errors = SimpleParams::NestedErrors.new(self)
+      errors.add(:foo, "omg")
+      errors[:foo].should eq(["omg"])
     end
 
-    it "sets the error with the provided key" do
-      errors = SimpleParams::Errors.new(self)
-      errors.set(:foo, "omg")
-      errors.messages.should eq({ foo: "omg" })
+    it "gets model errors" do
+      car = Car.new
+      car.errors.add(:make, "can not be blank")
+      car.errors.add(:make, "can not be nil")
+      car.errors[:make].should eq(["can not be blank", "can not be nil"])
     end
+  end
 
-    it "values returns an array of messages" do
+  describe '[]=', setter: true do
+    it "sets the errors for the provided key" do
       errors = SimpleParams::Errors.new(self)
-      errors.set(:foo, "omg")
-      errors.set(:baz, "zomg")
-      errors.values.should eq(["omg", "zomg"])
+      errors[:foo] = "omg"
+      errors[:foo].should eq(["omg"])
     end
 
-    it "keys returns the error keys" do
-      errors = SimpleParams::Errors.new(self)
-      errors.set(:foo, "omg")
-      errors.set(:baz, "zomg")
-      errors.keys.should eq([:foo, :baz])
-    end    
-
-    describe "setting on model" do
-      it "assign error" do
-        car = Car.new
-        car.errors[:make] = 'should not be nil'
-        car.errors[:make].should eq(["should not be nil"])
-      end
-
-      it "add an error message on a specific attribute" do
-        car = Car.new
-        car.errors.add(:make, "can not be blank")
-        car.errors[:make].should eq(["can not be blank"])
-      end
-
-      it "add an error with a symbol" do
-        car = Car.new
-        car.errors.add(:make, :blank)
-        message = car.errors.generate_message(:make, :blank)
-        car.errors[:make].should eq([message])
-      end
-
-      it "add an error with a proc" do
-        car = Car.new
-        message = Proc.new { "can not be blank" }
-        car.errors.add(:make, message)
-        car.errors[:make].should eq(["can not be blank"])
-      end
+    it "sets model errors" do
+      car = Car.new
+      car.errors[:make] = "can not be blank"
+      car.errors[:make].should eq(["can not be blank"])
     end
   end
 
@@ -136,51 +109,6 @@ describe SimpleParams::NestedErrors do
     end
   end
 
-  describe "#added?", added: true do
-    it "added? detects if a specific error was added to the object" do
-      car = Car.new
-      car.errors.add(:make, "can not be blank")
-      car.errors.added?(:make, "can not be blank").should be_truthy
-    end
-
-    it "added? handles symbol message" do
-      car = Car.new
-      car.errors.add(:make, :blank)
-      car.errors.added?(:make, :blank).should be_truthy
-    end
-
-    it "added? handles proc messages" do
-      car = Car.new
-      message = Proc.new { "can not be blank" }
-      car.errors.add(:make, message)
-      car.errors.added?(:make, message).should be_truthy
-    end
-
-    it "added? defaults message to :invalid" do
-      car = Car.new
-      car.errors.add(:make)
-      car.errors.added?(:make).should be_truthy
-    end
-
-    it "added? matches the given message when several errors are present for the same attribute" do
-      car = Car.new
-      car.errors.add(:make, "can not be blank")
-      car.errors.add(:make, "is invalid")
-      car.errors.added?(:make, "can not be blank").should be_truthy
-    end
-
-    it "added? returns false when no errors are present" do
-      car = Car.new
-      car.errors.added?(:make).should_not be_truthy
-    end
-
-    it "added? returns false when checking a nonexisting error and other errors are present for the given attribute" do
-      car = Car.new
-      car.errors.add(:make, "is invalid")
-      car.errors.added?(:make, "can not be blank").should_not be_truthy
-    end    
-  end
-
   describe "#size", size: true do
     it "size calculates the number of error messages" do
       car = Car.new
@@ -205,7 +133,6 @@ describe SimpleParams::NestedErrors do
       car.errors.add(:make, "can not be nil")
       car.errors.to_s.should eq("make can not be blank, make can not be nil")
     end
-
   end
 
   describe "#to_hash", to_hash: true do
@@ -281,53 +208,4 @@ describe SimpleParams::NestedErrors do
       }.to_not raise_error
     end
   end
-
-  describe "#adds_on_empty", add_on_empty: true do
-    it "add_on_empty generates message" do
-      car = Car.new
-      car.errors.should_receive(:generate_message).with(:make, :empty, {})
-      car.errors.add_on_empty :make
-    end
-
-    it "add_on_empty generates message for multiple attributes" do
-      car = Car.new
-      car.errors.should_receive(:generate_message).with(:make, :empty, {})
-      car.errors.should_receive(:generate_message).with(:model, :empty, {})
-      car.errors.add_on_empty [:make, :model]
-    end
-
-    it "add_on_empty generates message with custom default message" do
-      car = Car.new
-      car.errors.should_receive(:generate_message).with(:make, :empty, { message: 'custom' })
-      car.errors.add_on_empty :make, message: 'custom'
-    end
-
-    it "add_on_empty generates message with empty string value" do
-      car = Car.new
-      car.make = ''
-      car.errors.should_receive(:generate_message).with(:make, :empty, {})
-      car.errors.add_on_empty :make
-    end
-  end
-
-  describe "#adds_on_blank", add_on_blank: true do
-    it "add_on_blank generates message" do
-      car = Car.new
-      car.errors.should_receive(:generate_message).with(:make, :blank, {})
-      car.errors.add_on_blank :make
-    end
-
-    it "add_on_blank generates message for multiple attributes" do
-      car = Car.new
-      car.errors.should_receive(:generate_message).with(:make, :blank, {})
-      car.errors.should_receive(:generate_message).with(:model, :blank, {})
-      car.errors.add_on_blank [:make, :model]
-    end
-
-    it "add_on_blank generates message with custom default message" do
-      car = Car.new
-      car.errors.should_receive(:generate_message).with(:make, :blank, { message: 'custom' })
-      car.errors.add_on_blank :make, message: 'custom'
-    end
-  end
 end