validators 2.5.3 → 2.5.4

data/spec/validators/validates_email_format_of_spec.rb

@@ -1,70 +0,0 @@
-require "spec_helper"
-
-describe ".validates_email_format_of" do
-  before do
-    User.validates_email_format_of :email, :corporate_email, :allow_blank => false
-    Buyer.validates_email_format_of :email, :message => "is not a valid e-mail"
-    Person.validates :email, :email => true
-  end
-
-  VALID_EMAILS.each do |email|
-    it "accepts #{email.inspect} as a valid email" do
-      user = User.new(:email => email, :corporate_email => email)
-      expect(user).to be_valid
-
-      user = Person.new(:email => email)
-      expect(user).to be_valid
-    end
-  end
-
-  INVALID_EMAILS.each do |email|
-    it "rejects #{email.inspect} as a valid email" do
-      user = User.new(:email => "invalid", :corporate_email => "invalid")
-      expect(user).not_to be_valid
-
-      user = Person.new(:email => "invalid")
-      expect(user).not_to be_valid
-    end
-  end
-
-  it "uses default error message" do
-    user = User.new(:email => "invalid")
-    expect(user).not_to be_valid
-    expect(user.errors[:email]).to eq(["is not a valid address"])
-  end
-
-  it "rejects nil value" do
-    user = User.new(:email => nil)
-    expect(user).not_to be_valid
-    expect(user.errors[:email]).not_to be_empty
-  end
-
-  it "rejects empty value" do
-    user = User.new(:email => "")
-    expect(user).not_to be_valid
-    expect(user.errors[:email]).not_to be_empty
-  end
-
-  it "validates multiple attributes" do
-    user = User.new(:corporate_email => "invalid")
-    expect(user).not_to be_valid
-    expect(user.errors[:corporate_email]).to eq(["is not a valid address"])
-  end
-
-  it "uses custom error message as :message options" do
-    buyer = Buyer.new(:email => "invalid")
-    expect(buyer).not_to be_valid
-    expect(buyer.errors[:email]).to eq(["is not a valid e-mail"])
-  end
-
-  it "uses I18n string as error message [pt-BR]" do
-    I18n.locale = :'pt-BR'
-    user = User.new(:email => "invalid")
-    expect(user).not_to be_valid
-    expect(user.errors[:email]).to eq(["não parece ser um e-mail válido"])
-  end
-
-  it "defines alias method" do
-    expect(User).to respond_to(:validates_email)
-  end
-end

data/spec/validators/validates_hostname_format_of_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe ".validates_hostname_format_of" do
-  context "with TLD validation" do
-    it 'rejects invalid TLD' do
-      server = ServerWithTLD.new('example.xy')
-      expect(server).not_to be_valid
-    end
-
-    it 'rejects only host label' do
-      server = ServerWithTLD.new('com')
-      expect(server).not_to be_valid
-    end
-
-    TLDs.each do |tld|
-      it "accepts #{tld} as TLD" do
-        server = ServerWithTLD.new("example.#{tld}")
-        expect(server).to be_valid
-      end
-    end
-
-    it "accepts example.com.br" do
-      server = ServerWithTLD.new("example.com.br")
-      expect(server).to be_valid
-    end
-  end
-
-  context "without TLD validation" do
-    VALID_HOSTNAMES.each do |host|
-      it "accepts #{host}" do
-        server = ServerWithoutTLD.new(host)
-        expect(server).to be_valid
-      end
-    end
-
-    INVALID_HOSTNAMES.each do |host|
-      it "rejects #{host}" do
-        server = ServerWithoutTLD.new(host)
-        expect(server).not_to be_valid
-      end
-    end
-
-    it 'rejects nil hostname' do
-      server = ServerWithoutTLD.new(nil)
-      expect(server).not_to be_valid
-    end
-
-    it 'rejects blank hostname' do
-      server = ServerWithoutTLD.new('')
-      expect(server).not_to be_valid
-    end
-  end
-end

data/spec/validators/validates_ip_address_spec.rb

@@ -1,59 +0,0 @@
-require "spec_helper"
-
-describe ".validates_ip_address" do
-  subject { User.new }
-
-  context "IPv4" do
-    it "is valid" do
-      User.validates_ip_address :url, :only => :v4
-      subject.url = "192.168.1.2"
-      expect(subject).to be_valid
-    end
-
-    it "is invalid" do
-      User.validates_ip_address :url, :only => :v4
-      subject.url = "FE80:0000:0000:0000:0202:B3FF:FE1E:8329"
-      expect(subject).not_to be_valid
-      expect(subject.errors[:url]).to eq(["is not a valid IPv4 address"])
-    end
-  end
-
-  context "IPv6" do
-    it "is valid" do
-      User.validates_ip_address :url, :only => :v6
-      subject.url = "FE80:0000:0000:0000:0202:B3FF:FE1E:8329"
-      expect(subject).to be_valid
-    end
-
-    it "is invalid" do
-      User.validates_ip_address :url, :only => :v6
-      subject.url = "192.168.1.2"
-      expect(subject).not_to be_valid
-      expect(subject.errors[:url]).to eq(["is not a valid IPv6 address"])
-    end
-  end
-
-  it "is valid with IPv4" do
-    User.validates_ip_address :url
-    subject.url = "192.168.1.2"
-    expect(subject).to be_valid
-  end
-
-  it "is valid with IPv6" do
-    User.validates_ip_address :url
-    subject.url = "FE80:0000:0000:0000:0202:B3FF:FE1E:8329"
-    expect(subject).to be_valid
-  end
-
-  it "allows blank values" do
-    User.validates_ip_address :url, :allow_blank => true
-    subject.url = ""
-    expect(subject).to be_valid
-  end
-
-  it "allows nil values" do
-    User.validates_ip_address :url, :allow_nil => true
-    subject.url = nil
-    expect(subject).to be_valid
-  end
-end

data/spec/validators/validates_ownership_of_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-
-describe ".validates_ownership_of" do
-  let!(:user) { User.create! }
-  let!(:another_user) { User.create! }
-  let!(:category) { Category.create!(:user => user) }
-  let!(:another_category) { Category.create!(:user => another_user) }
-  subject { Task.new(:user => user, :category => category) }
-
-  before do
-    Task.validates_ownership_of :category, :with => :user
-  end
-
-  it "is valid when record is owned by the correct user" do
-    expect(subject).to be_valid
-  end
-
-  it "is invalid when record is owned by a different user" do
-    subject.category = another_category
-    expect(subject).not_to be_valid
-  end
-
-  it "raises error without :with option" do
-    expect {
-      Task.validates_ownership_of :category
-    }.to raise_error(ArgumentError)
-  end
-
-  it "raises error when :with options is not a valid type" do
-    expect {
-      Task.validates_ownership_of :category, :with => user
-    }.to raise_error(ArgumentError)
-  end
-
-  it "is invalid when owner is not present" do
-    expect {
-      subject.user = nil
-      expect(subject).not_to be_valid
-    }.to_not raise_error
-  end
-
-  it "is invalid when attribute owner is not present" do
-    expect {
-      subject.category.user = nil
-      expect(subject).not_to be_valid
-    }.to_not raise_error
-  end
-
-  it "is valid when both owners are nil" do
-    expect {
-      subject.category.user = nil
-      subject.user = nil
-      expect(subject).to be_valid
-    }.to_not raise_error
-  end
-
-  it "is valid when attribute is nil" do
-    expect {
-      subject.category = nil
-      expect(subject).to be_valid
-    }.to_not raise_error
-  end
-
-  it "sets error message" do
-    subject.user = nil
-    expect(subject).not_to be_valid
-    expect(subject.errors[:category]).to eq(["is not associated with your user"])
-  end
-end

data/spec/validators/validates_ssh_private_key_spec.rb

@@ -1,152 +0,0 @@
-require "spec_helper"
-
-describe ".validates_ssh_private_key" do
-  context "common" do
-    let(:model) { Class.new {
-      def self.name
-        "User"
-      end
-
-      include ActiveModel::Model
-      validates_ssh_private_key :key
-      attr_accessor :key
-    } }
-
-    it "requires valid key" do
-      record = model.new(key: "invalid")
-      record.valid?
-
-      expect(record.errors[:key]).not_to be_empty
-    end
-
-    it "accepts valid key" do
-      record = model.new(key: SSHKey.generate.private_key)
-      record.valid?
-
-      expect(record.errors[:key]).to be_empty
-    end
-
-    it "sets translated error message" do
-      I18n.locale = "pt-BR"
-      message = "não é uma chave privada de SSH válida"
-
-      record = model.new(key: "invalid")
-      record.valid?
-
-      expect(record.errors[:key]).to include(message)
-    end
-  end
-
-  context "type validation (RSA)" do
-    let(:model) { Class.new {
-      def self.name
-        "User"
-      end
-
-      include ActiveModel::Model
-      validates_ssh_private_key :key, type: 'rsa'
-      attr_accessor :key
-    } }
-
-    it "accepts rsa key" do
-      record = model.new(key: SSHKey.generate(type: "rsa").private_key)
-      record.valid?
-
-      expect(record.errors[:key]).to be_empty
-    end
-
-    it "rejects dsa key" do
-      record = model.new(key: SSHKey.generate(type: "dsa").private_key)
-      record.valid?
-
-      expect(record.errors[:key]).not_to be_empty
-    end
-
-    it "sets translated error message" do
-      I18n.locale = "pt-BR"
-
-      record = model.new(key: SSHKey.generate(type: "dsa").private_key)
-      record.valid?
-
-      expect(record.errors[:key]).to include("precisa ser uma chave RSA")
-    end
-  end
-
-  context "type validation (DSA)" do
-    let(:model) { Class.new {
-      def self.name
-        "User"
-      end
-
-      include ActiveModel::Model
-      validates_ssh_private_key :key, type: "dsa"
-      attr_accessor :key
-    } }
-
-    it "accepts dsa key" do
-      record = model.new(key: SSHKey.generate(type: "dsa").private_key)
-      record.valid?
-
-      expect(record.errors[:key]).to be_empty
-    end
-
-    it "rejects rsa key" do
-      record = model.new(key: SSHKey.generate(type: 'rsa').private_key)
-      record.valid?
-
-      expect(record.errors[:key]).not_to be_empty
-    end
-
-    it "sets translated error message" do
-      I18n.locale = "pt-BR"
-
-      record = model.new(key: SSHKey.generate(type: 'rsa').private_key)
-      record.valid?
-
-      expect(record.errors[:key]).to include("precisa ser uma chave DSA")
-    end
-  end
-
-  context "bits" do
-    let(:model) { Class.new {
-      def self.name
-        "User"
-      end
-
-      include ActiveModel::Model
-      validates_ssh_private_key :key, bits: 2048
-      attr_accessor :key
-    } }
-
-    it "accepts bits equals to required" do
-      record = model.new(key: SSHKey.generate(bits: 2048).private_key)
-      record.valid?
-
-      expect(record.errors[:key]).to be_empty
-    end
-
-    it "accepts bits greater than required" do
-      record = model.new(key: SSHKey.generate(bits: 4096).private_key)
-      record.valid?
-
-      expect(record.errors[:key]).to be_empty
-    end
-
-    it "rejects invalid bits" do
-      record = model.new(key: SSHKey.generate(bits: 1024).private_key)
-      record.valid?
-
-      expect(record.errors[:key]).not_to be_empty
-    end
-
-    it "sets translated error message" do
-      I18n.locale = "pt-BR"
-      message = "precisa ter pelo menos 2048 bits; a sua chave tem 1024 bits"
-
-      record = model.new(key: SSHKey.generate(bits: 1024).private_key)
-      record.valid?
-
-      expect(record.errors[:key]).to include(message)
-    end
-  end
-end

data/spec/validators/validates_ssh_public_key_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-describe ".validates_ssh_public_key" do
-  context "common" do
-    let(:model) { Class.new {
-      def self.name
-        "User"
-      end
-
-      include ActiveModel::Model
-      validates_ssh_public_key :key
-      attr_accessor :key
-    } }
-
-    it "requires valid key" do
-      record = model.new(key: nil)
-      record.valid?
-
-      expect(record.errors[:key]).not_to be_empty
-    end
-
-    it "accepts valid key" do
-      record = model.new(key: SSHKey.generate.ssh_public_key)
-      record.valid?
-
-      expect(record.errors[:key]).to be_empty
-    end
-
-    it "sets translated error message" do
-      I18n.locale = "pt-BR"
-      message = "não é uma chave pública de SSH válida"
-
-      record = model.new(key: "invalid")
-      record.valid?
-
-      expect(record.errors[:key]).to include(message)
-    end
-  end
-end

data/spec/validators/validates_url_format_of_spec.rb

@@ -1,65 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-
-describe ".validates_url_format_of" do
-  context "validating TLD" do
-    it "rejects invalid TLD" do
-      user = UserWithTLD.new('http://example.xy')
-      expect(user).not_to be_valid
-    end
-
-    TLDs.each do |tld|
-      it "accepts #{tld} as TLD" do
-        user = UserWithTLD.new("http://example.#{tld}")
-        expect(user).to be_valid
-      end
-    end
-  end
-
-  context "without validating TLD" do
-    before do
-      User.validates_url_format_of :url, :allow_blank => false
-    end
-
-    VALID_URLS.each do |url|
-      it "accepts #{url.inspect} as a valid url" do
-        user = User.new(:url => url)
-        expect(user).to be_valid
-      end
-    end
-
-    INVALID_URLS.each do |url|
-      it "rejects #{url.inspect} as a valid url" do
-        user = User.new(:url => url)
-        expect(user).not_to be_valid
-      end
-    end
-
-    it "defines alias method" do
-      expect(User).to respond_to(:validates_url)
-    end
-
-    it "uses default error message" do
-      user = User.new(:url => "invalid")
-      expect(user).not_to be_valid
-      expect(user.errors[:url]).to eq(["is not a valid address"])
-    end
-
-    it "uses I18n string as error message [pt-BR]" do
-      I18n.locale = :'pt-BR'
-      user = User.new(:url => "invalid")
-      expect(user).not_to be_valid
-      expect(user.errors[:url]).to eq(["não parece ser uma URL válida"])
-    end
-
-    it "rejects nil urls" do
-      user = User.new(url: nil)
-      expect(user).not_to be_valid
-    end
-
-    it "rejects blank urls" do
-      user = User.new(url: '')
-      expect(user).not_to be_valid
-    end
-  end
-end