active_validation 1.0.0 → 1.1.0

data/spec/lib/currency_validator_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe CurrencyValidator do
-
-  context "has a valid value" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :price, :name
-        validates :price, currency: true
-      end
-    end
-
-    subject { klass.new }
-
-    it { should allow_value(".00").for(:price) }
-    it { should allow_value("1.0").for(:price) }
-    it { should allow_value("1.00").for(:price) }
-    it { should allow_value("12345678.00").for(:price) }
-
-    it { should_not allow_value('').for(:price) }
-    it { should_not allow_value(' ').for(:price) }
-    it { should_not allow_value(nil).for(:price) }
-    it { should_not allow_value("1").for(:price) }
-    it { should_not allow_value("1.000").for(:price) }
-    it { should_not allow_value("$1.00").for(:price) }
-    it { should_not allow_value("! \#$%\`|").for(:price) }
-    it { should_not allow_value("<>@[]\`|").for(:price) }
-
-    it { should ensure_valid_currency_format_of(:price) }
-    it { should_not ensure_valid_currency_format_of(:name) }
-  end
-
-  context "with :strict option has a valid value" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :price, :name
-        validates :price, currency: { strict: true }
-      end
-    end
-
-    subject { klass.new }
-
-    it { should allow_value("1.00").for(:price) }
-    it { should allow_value("12345678.00").for(:price) }
-
-    it { should_not allow_value('').for(:price) }
-    it { should_not allow_value(' ').for(:price) }
-    it { should_not allow_value(nil).for(:price) }
-    it { should_not allow_value(".00").for(:price) }
-    it { should_not allow_value("1").for(:price) }
-    it { should_not allow_value("1.0").for(:price) }
-    it { should_not allow_value("1.000").for(:price) }
-    it { should_not allow_value("$1.00").for(:price) }
-    it { should_not allow_value("! \#$%\`|").for(:price) }
-    it { should_not allow_value("<>@[]\`|").for(:price) }
-
-    it { should ensure_valid_currency_format_of(:price) }
-    it { should_not ensure_valid_currency_format_of(:name) }
-  end
-
-end

data/spec/lib/cusip_validator_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe CusipValidator do
-
-  context "has a valid value" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :code, :name
-        validates :code, cusip: true
-      end
-    end
-
-    subject { klass.new }
-
-    it { should allow_value("125509BG3").for(:code) }
-
-    it { should_not allow_value('').for(:code) }
-    it { should_not allow_value(' ').for(:code) }
-    it { should_not allow_value(nil).for(:code) }
-    it { should_not allow_value("12345678AB").for(:code) }
-
-    it { should ensure_valid_cusip_format_of(:code) }
-    it { should_not ensure_valid_cusip_format_of(:name) }
-  end
-
-end

data/spec/lib/email_validator_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-describe EmailValidator do
-
-  subject { klass.new }
-
-  context "with valid format" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :email, :name
-        validates :email, email: true
-      end
-    end
-
-    [
-      "s_u@example.com",
-      "super.user@example.com",
-      "super+user@example.com",
-      "super-user@example.com",
-      "super+user@example-site.com",
-      "user@example.com",
-      "user@example-site.com",
-      "user@en.example.com",
-      "user@example.museum",
-      "user@123.com",
-      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@example.com",
-      "01234567890@example.com"
-    ].each do |email|
-      it "#{email.inspect} should be valid" do
-        should allow_value(email).for(:email)
-      end
-    end
-
-    [
-      "",
-      " ",
-      "example.com",
-      "super user@example.com",
-      " user@example.com",
-      " user@example.com ",
-      "user@example.com ",
-      "user",
-      "user@com",
-      "user@.com",
-      "user@example",
-      "user@example.",
-      "user@example.c",
-      "user_example.com",
-      "user@example_site.com",
-      "user@example.com@example.com",
-      "user@",
-      "user@! \"\#$%(),/;<>_[]\`|.com",
-      "user@127.0.0.1",
-      "user@127.0.0.1:25",
-      "user@example.com\n<script>alert('hello')</script>",
-      "@example.com",
-      "@example",
-      "@",
-      "! \#$%\`|@example.com",
-      "<>@[]\`|@example.com"
-    ].each do |email|
-      it "#{email.inspect} should be invalid" do
-        should_not allow_value(email).for(:email)
-      end
-    end
-
-    it { should ensure_valid_email_format_of(:email) }
-    it { should_not ensure_valid_email_format_of(:name) }
-  end
-
-  context "is in the specific domain" do
-    context "domain specified as string" do
-      let(:klass) do
-        Class.new do
-          include ActiveModel::Validations
-          attr_accessor :email, :name
-          validates :email, email: { domain: "edu" }
-        end
-      end
-
-      it { should allow_value("user@example.edu").for(:email) }
-      it { should_not allow_value("user@example.com").for(:email) }
-
-      it { should ensure_valid_email_format_of(:email) }
-      it { should_not ensure_valid_email_format_of(:name) }
-    end
-
-    context "set as an array of strings and symbols" do
-      let(:klass) do
-        Class.new do
-          include ActiveModel::Validations
-          attr_accessor :email, :name
-          validates :email, email: { domain: ['com', :edu, 'Com.Au'] }
-        end
-      end
-
-      it { should allow_value("user@example.com").for(:email) }
-      it { should allow_value("user@example.edu").for(:email) }
-      it { should allow_value("user@example.com.au").for(:email) }
-      it { should allow_value("user@example.Com.Au").for(:email) }
-      it { should_not allow_value("user@example.org").for(:email) }
-
-      it { should ensure_valid_email_format_of(:email) }
-      it { should_not ensure_valid_email_format_of(:name) }
-    end
-  end
-
-end

data/spec/lib/equality_validator_spec.rb

@@ -1,334 +0,0 @@
-require 'spec_helper'
-
-describe EqualityValidator do
-
-  context "value less than" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :bid, :price, :name
-        validates :bid, equality: { operator: :less_than, to: :price }
-      end
-    end
-
-    subject(:model){ klass.new }
-
-    specify "first field less than the second" do
-      model.bid = 1
-      model.price = 2
-      expect(model).to be_valid
-    end
-
-    specify "first field equal to the second" do
-      model.bid = 1
-      model.price = 1
-      expect(model).to be_invalid
-    end
-
-    specify "first field greater than the second" do
-      model.bid = 1
-      model.price = 0
-      expect(model).to be_invalid
-    end
-
-    specify "first field is empty, the second is blank" do
-      model.bid = ""
-      model.price = " "
-      expect(model).to be_valid
-    end
-
-    specify "first field is blank, the second is empty" do
-      model.bid = " "
-      model.price = ""
-      expect(model).to be_invalid
-    end
-  end
-
-  context "value less than or equal to" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :bid, :price, :name
-        validates :bid, equality: { operator: :less_than_or_equal_to, to: :price }
-      end
-    end
-
-    subject(:model){ klass.new }
-
-    specify "first field equal to the second" do
-      model.bid = 1
-      model.price = 1
-      expect(model).to be_valid
-    end
-
-    specify "first field less than the second" do
-      model.bid = 1
-      model.price = 2
-      expect(model).to be_valid
-    end
-
-    specify "first field greater than the second" do
-      model.bid = 1
-      model.price = 0
-      expect(model).to be_invalid
-    end
-
-    specify "first field is empty, the second is blank" do
-      model.bid = ""
-      model.price = " "
-      expect(model).to be_valid
-    end
-
-    specify "first field is blank, the second is empty" do
-      model.bid = " "
-      model.price = ""
-      expect(model).to be_invalid
-    end
-
-    specify "both fields are blank" do
-      model.bid = model.price = ""
-      expect(model).to be_valid
-    end
-
-    specify "both fields are empty" do
-      model.bid = model.price = " "
-      expect(model).to be_valid
-    end
-  end
-
-  context "value greater than" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :bid, :price, :name
-        validates :bid, equality: { operator: :greater_than, to: :price }
-      end
-    end
-
-    subject(:model){ klass.new }
-
-    specify "first field greater than the second" do
-      model.bid = 1
-      model.price = 0
-      expect(model).to be_valid
-    end
-
-    specify "first field less than the second" do
-      model.bid = 1
-      model.price = 2
-      expect(model).to be_invalid
-    end
-
-    specify "first field equal to the second" do
-      model.bid = 1
-      model.price = 1
-      expect(model).to be_invalid
-    end
-
-    specify "first field is empty, the second is blank" do
-      model.bid = ""
-      model.price = " "
-      expect(model).to be_invalid
-    end
-
-    specify "first field is blank, the second is empty" do
-      model.bid = " "
-      model.price = ""
-      expect(model).to be_valid
-    end
-  end
-
-  context "value greater than or equal to" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :bid, :price, :name
-        validates :bid, equality: { operator: :greater_than_or_equal_to, to: :price }
-      end
-    end
-
-    subject(:model){ klass.new }
-
-    specify "first field equal to the second" do
-      model.bid = 1
-      model.price = 1
-      expect(model).to be_valid
-    end
-
-    specify "first field greater than the second" do
-      model.bid = 1
-      model.price = 0
-      expect(model).to be_valid
-    end
-
-    specify "first field less than the second" do
-      model.bid = 1
-      model.price = 2
-      expect(model).to be_invalid
-    end
-
-    specify "first field is empty, the second is blank" do
-      model.bid = ""
-      model.price = " "
-      expect(model).to be_invalid
-    end
-
-    specify "first field is blank, the second is empty" do
-      model.bid = " "
-      model.price = ""
-      expect(model).to be_valid
-    end
-
-    specify "both fields are blank" do
-      model.bid = model.price = ""
-      expect(model).to be_valid
-    end
-
-    specify "both fields are empty" do
-      model.bid = model.price = " "
-      expect(model).to be_valid
-    end
-  end
-
-  context "value equal to" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :bid, :price, :name
-        validates :bid, equality: { operator: :equal_to, to: :price }
-      end
-    end
-
-    subject(:model){ klass.new }
-
-    specify "first field equal to the second" do
-      model.bid = 1
-      model.price = 1
-      expect(model).to be_valid
-    end
-
-    specify "first field less than the second" do
-      model.bid = 1
-      model.price = 2
-      expect(model).to be_invalid
-    end
-
-    specify "first field greater than the second" do
-      model.bid = 1
-      model.price = 0
-      expect(model).to be_invalid
-    end
-
-    specify "first field has value, the second is nil" do
-      model.bid = 1
-      model.price = nil
-      expect(model).to be_invalid
-    end
-
-    specify "first field is nil, the second has value" do
-      model.bid = nil
-      model.price = 1
-      expect(model).to be_invalid
-    end
-
-    specify "both fields are nil" do
-      model.bid = model.price = nil
-      expect(model).to be_valid
-    end
-
-    specify "first field is empty, the second is blank" do
-      model.bid = ""
-      model.price = " "
-      expect(model).to be_invalid
-    end
-
-    specify "first field is blank, the second is empty" do
-      model.bid = " "
-      model.price = ""
-      expect(model).to be_invalid
-    end
-
-    specify "both fields are blank" do
-      model.bid = model.price = ""
-      expect(model).to be_valid
-    end
-
-    specify "both fields are empty" do
-      model.bid = model.price = " "
-      expect(model).to be_valid
-    end
-  end
-
-  context "value not equal to" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :bid, :price, :name
-        validates :bid, equality: { operator: :not_equal_to, to: :price }
-      end
-    end
-
-    subject(:model){ klass.new }
-
-    specify "first field equal to the second" do
-      model.bid = 1
-      model.price = 1
-      expect(model).to be_invalid
-    end
-
-    specify "first field less than the second" do
-      model.bid = 1
-      model.price = 2
-      expect(model).to be_valid
-    end
-
-    specify "first field greater than the second" do
-      model.bid = 1
-      model.price = 0
-      expect(model).to be_valid
-    end
-
-    specify "first field has value, the second is nil" do
-      model.bid = 1
-      model.price = nil
-      expect(model).to be_valid
-    end
-
-    specify "first field is nil, the second has value" do
-      model.bid = nil
-      model.price = 1
-      expect(model).to be_valid
-    end
-
-    specify "both fields are nil" do
-      model.bid = model.price = nil
-      expect(model).to be_invalid
-    end
-
-    specify "first field is empty, the second is blank" do
-      model.bid = ""
-      model.price = " "
-      expect(model).to be_valid
-    end
-
-    specify "first field is blank, the second is empty" do
-      model.bid = " "
-      model.price = ""
-      expect(model).to be_valid
-    end
-
-    specify "both fields are blank" do
-      model.bid = model.price = ""
-      expect(model).to be_invalid
-    end
-
-    specify "both fields are empty" do
-      model.bid = model.price = " "
-      expect(model).to be_invalid
-    end
-  end
-
-  #it { should ensure_equality_of(:bid).to(:price).operator(:less_than) }
-  #it { should_not ensure_equality_of(:bid).to(:name).operator(:less_than) }
-
-end