simple_params 0.0.1pre2

data/spec/acceptance_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+class AcceptanceParams < SimpleParams::Params
+  param :name
+  param :age, type: Integer, optional: true
+  param :color, default: "red", validations: { inclusion: { in: ["red", "green"] }}
+
+  nested_hash :address do
+    param :street
+    param :city, validations: { length: { in: 4..40 } }
+    param :zip_code, optional: true
+    param :state, default: "North Carolina"
+  end
+end
+
+describe SimpleParams::Params do
+  describe "accessors", accessors: true do
+    let(:params) { AcceptanceParams.new }
+
+    it "has getter and setter methods for required param" do
+      params.should respond_to(:name)
+      params.name.should be_nil
+      params.name = "Tom"
+      params.name.should eq("Tom")
+    end
+    
+    it "has getter and setter methods for optional param" do
+      params.should respond_to(:age)
+      params.name.should be_nil
+      params.age = 19
+      params.age.should eq(19)
+    end
+
+    describe "nested params", nested: true do
+      it "has getter and setter methods for required param" do
+        params.address.should respond_to(:street)
+        params.address.street.should be_nil
+        params.address.street = "1 Main St."
+        params.address.street.should eq("1 Main St.")
+      end
+      
+      it "has getter and setter methods for optional param" do
+        params.address.should respond_to(:zip_code)
+        params.address.zip_code.should be_nil
+        params.address.zip_code = "20165"
+        params.address.zip_code.should eq("20165")
+      end
+    end
+  end
+
+  describe "array syntax", array_syntax: true do
+    let(:params) do 
+      AcceptanceParams.new(
+        name: "Bill", 
+        age: 30, 
+        address: { 
+          city: "Greenville" 
+        } 
+      )
+    end
+
+    it "can access 'name' through array syntax" do
+      params[:name].should eq("Bill")
+      params["name"].should eq("Bill")
+    end
+
+    it "can set 'name' through array syntax" do
+      params[:name] = "Tom"
+      params[:name].should eq("Tom")
+      params["name"].should eq("Tom")
+    end
+
+    it "can access 'age' through array syntax" do
+      params[:age].should eq(30)
+      params["age"].should eq(30)
+    end
+
+    it "can set 'age' through array syntax" do
+      params[:age] = 42
+      params[:age].should eq(42)
+      params["age"].should eq(42)
+    end
+
+    describe "nested params", nested: true do
+      it "can access 'city' through array syntax" do
+        params[:address][:city].should eq("Greenville")
+        params["address"]["city"].should eq("Greenville")
+      end
+
+      it "can set 'city' through array syntax" do
+        params[:address][:city] = "Asheville"
+        params[:address][:city].should eq("Asheville")
+        params["address"]["city"].should eq("Asheville")
+      end
+    end
+  end
+
+  describe "validations", validations: true do
+    let(:params) { AcceptanceParams.new }
+
+    it "validates presence of required param" do
+      params.should_not be_valid
+      params.errors[:name].should eq(["can't be blank"])
+    end
+
+    it "does not validate presence of optional param" do
+      params.should_not be_valid
+      params.errors[:age].should be_empty
+    end
+
+    it "does validate other validations of optional param" do
+      params = AcceptanceParams.new(color: "blue")
+      params.should_not be_valid
+      params.errors[:color].should eq(["is not included in the list"])
+    end
+
+    describe "nested params", nested: true do
+      it "validates presence of required param" do
+        params.should_not be_valid
+        params.errors[:address][:street].should eq(["can't be blank"])
+      end
+
+      it "does not validate presence of optional param" do
+        params.should_not be_valid
+        params.errors[:address][:zip_code].should be_empty
+      end
+    end
+  end
+end

data/spec/errors_spec.rb

@@ -0,0 +1,453 @@
+require 'spec_helper'
+
+describe SimpleParams::Errors do
+  class Person
+    extend ActiveModel::Naming
+    def initialize
+      @errors = SimpleParams::Errors.new(self, ["dog"])
+    end
+
+    attr_accessor :name, :age
+    attr_reader   :errors
+
+    def dog
+      @dog ||= Dog.new
+    end
+
+    def read_attribute_for_validation(attr)
+      send(attr)
+    end
+
+    def self.human_attribute_name(attr, options = {})
+      attr
+    end
+
+    def self.lookup_ancestors
+      [self]
+    end
+  end
+
+  class Dog
+    extend ActiveModel::Naming
+    def initialize
+      @errors = SimpleParams::Errors.new(self)
+    end
+
+    attr_accessor :breed
+    attr_reader   :errors
+
+    def read_attribute_for_validation(attr)
+      send(attr)
+    end
+
+    def self.human_attribute_name(attr, options = {})
+      attr
+    end
+
+    def self.lookup_ancestors
+      [self]
+    end
+  end
+
+  describe "setting and getting errors" 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"])
+    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" 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'])
+    end
+
+    it "can add multiple errors to nested errors through []" 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'])
+    end
+
+    it "can add individual errors to nested attributes through []" do
+      person = Person.new
+      person.errors[:dog][:breed] = 'should not be nil'
+      person.dog.errors[:breed].should eq(['should not be nil'])
+    end
+
+    it "can add individual errors to nested attributes through  add" do
+      person = Person.new
+      person.errors[:dog].add(:breed, 'should not be nil')
+      person.dog.errors[:breed].should eq(['should not be nil'])
+    end
+  end
+
+  describe "#clear" do
+    it "clears errors" do
+      person = Person.new
+      person.errors[:name] = 'should not be nil'
+      person.errors[:name].should eq(["should not be nil"])
+      person.errors.clear
+      person.errors.should be_empty
+    end
+
+    it "clears nested errors" do
+      person = Person.new
+      person.errors[:name] = 'should not be nil'
+      person.errors[:name].should eq(["should not be nil"])
+      person.errors[:dog] = 'should not be nil'
+      person.dog.errors[:base].should eq(['should not be nil'])
+      person.errors.clear
+      person.errors.should be_empty
+      person.dog.errors.should be_empty
+    end
+  end
+
+  describe "#empty?, #blank?, and #include?" do
+    it "is empty without any errors" do
+      person = Person.new
+      person.errors.should be_empty
+      person.errors.should be_blank
+      person.errors.should_not have_key(:name)
+      person.errors.should_not have_key(:dog)
+    end
+
+    it "is not empty with errors" do
+      person = Person.new
+      person.errors[:name] = 'should not be nil'
+      person.errors.should_not be_empty
+      person.errors.should_not be_blank
+      person.errors.should have_key(:name)
+      person.errors.should_not have_key(:dog)
+    end
+
+    it "is not empty with nested errors" do
+      person = Person.new
+      person.errors[:dog] = 'should not be nil'
+      person.errors.should_not be_empty
+      person.errors.should_not be_blank
+      person.errors.should_not have_key(:name)
+      person.errors.should have_key(:dog)
+    end
+  end
+
+  describe "#added?" 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" do
+    it "size calculates the number of error messages" do
+      person = Person.new
+      person.errors.add(:name, "can not be blank")
+      person.errors.size.should eq(1)
+    end
+
+    it "includes nested attributes in size count" do
+      person = Person.new
+      person.errors.add(:dog, "can not be blank")
+      person.errors.size.should eq(1)
+    end
+  end
+
+  describe "#to_a" do
+    it "to_a returns the list of errors with complete messages containing the attribute names" do
+      person = Person.new
+      person.errors.add(:name, "can not be blank")
+      person.errors.add(:name, "can not be nil")
+      person.errors.to_a.should eq(["name can not be blank", "name can not be nil"])
+    end
+
+    it "handles nested attributes" do
+      person = Person.new
+      person.errors.add(:name, "can not be blank")
+      person.dog.errors.add(:breed, "can not be nil")
+      person.errors.to_a.should eq(["name can not be blank", "dog breed can not be nil"])
+    end
+  end
+
+  describe "#to_hash" do
+    it "to_hash returns the error messages hash" do
+      person = Person.new
+      person.errors.add(:name, "can not be blank")
+      person.errors.to_hash.should eq({ name: ["can not be blank"] })
+    end
+
+    it "handles nested attributes" 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({ 
+        name: ["can not be blank"],
+        dog: {
+          breed: ["can not be nil"]
+        }
+      })
+    end
+
+    it "handles nested attributes with base errors" do
+      person = Person.new
+      person.errors.add(:base, :invalid)
+      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({ 
+        base: ["is invalid"],
+        name: ["can not be blank"],
+        dog: {
+          base: ["is invalid"],
+          breed: ["can not be nil"]
+        }
+      })
+    end
+  end
+
+  describe "#as_json" do
+    it "as_json creates a json formatted representation of the errors hash" do
+      person = Person.new
+      person.errors[:name] = 'can not be nil'
+      person.errors[:name].should eq(["can not be nil"])
+      person.errors.as_json.should eq({ name: ["can not be nil"] })
+    end
+
+    it "as_json with :full_messages option creates a json formatted representation of the errors containing complete messages" do
+      person = Person.new
+      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    
+
+    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({ 
+        name: ["can not be nil"],
+        dog: {
+          breed: ["is invalid"]
+        }
+      })
+    end
+
+    it "handles nested attributes with full_messages" 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({ 
+        name: ["name can not be nil"],
+        dog: {
+          breed: ["breed is invalid"]
+        }
+      })
+    end
+  end
+
+  describe "#full_messages" do
+    it "full_messages creates a list of error messages with the attribute name included" do
+      person = Person.new
+      person.errors.add(:name, "can not be blank")
+      person.errors.add(:name, "can not be nil")
+      person.errors.full_messages.should eq(["name can not be blank", "name can not be nil"])
+    end
+
+    it "full_messages_for contains all the error messages for the given attribute" do
+      person = Person.new
+      person.errors.add(:name, "can not be blank")
+      person.errors.add(:name, "can not be nil")
+      person.errors.full_messages_for(:name).should eq(["name can not be blank", "name can not be nil"])
+    end
+
+    it "full_messages_for does not contain error messages from other attributes" do
+      person = Person.new
+      person.errors.add(:name, "can not be blank")
+      person.errors.add(:email, "can not be blank")
+      person.errors.full_messages_for(:name).should eq(["name can not be blank"])
+    end
+
+    it "full_messages_for returns an empty list in case there are no errors for the given attribute" do
+      person = Person.new
+      person.errors.add(:name, "can not be blank")
+      person.errors.full_messages_for(:email).should eq([])
+    end
+
+    it "full_message returns the given message when attribute is :base" do
+      person = Person.new
+      person.errors.full_message(:base, "press the button").should eq("press the button")
+    end
+
+    it "full_message returns the given message with the attribute name included" do
+      person = Person.new
+      person.errors.full_message(:name, "can not be blank").should eq("name can not be blank")
+      person.errors.full_message(:name_test, "can not be blank").should eq("name_test can not be blank")
+    end
+  end
+
+  describe "#generate_message" 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" 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" 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