rspec-be_valid_when_matcher 0.3.0 → 1.0.0

data/spec/rspec/be_valid_when/is_rational_spec.rb

@@ -1,74 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :rational_field
-  attr_accessor :not_rational_field
-
-  validates_numericality_of :rational_field, greater_than: 40
-  validate :not_rational_field_cannot_be_rational
-
-  private
-
-  def not_rational_field_cannot_be_rational
-    errors.add(:not_rational_field, "can't be rational") if not_rational_field.is_a? Rational
-  end
-end
-
-describe 'be_valid_when#is_rational' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { %r{^be valid when #rational_field is a rational \(42/1\)$} }
-
-    let(:passing_matcher) { be_valid_when(:rational_field).is_rational }
-    let(:failing_matcher) { be_valid_when(:not_rational_field).is_rational }
-
-    it 'has the correct description' do
-      expect(passing_matcher.description).to match description
-    end
-
-    it 'returns proper result' do
-      expect(passing_matcher.matches? model).to eq true
-      expect(passing_matcher.does_not_match? model).to eq false
-      expect(failing_matcher.matches? model).to eq false
-      expect(failing_matcher.does_not_match? model).to eq true
-    end
-  end
-
-  context 'with one argument' do
-    let(:description) { %r{^be valid when #rational_field is a rational \(50/1\)$} }
-
-    let(:passing_matcher) { be_valid_when(:rational_field).is_rational 50.to_r }
-    let(:failing_matcher) { be_valid_when(:rational_field).is_rational 30.to_r }
-
-    it 'has the correct description' do
-      expect(passing_matcher.description).to match description
-    end
-
-    it 'returns proper result' do
-      expect(passing_matcher.matches? model).to eq true
-      expect(passing_matcher.does_not_match? model).to eq false
-      expect(failing_matcher.matches? model).to eq false
-      expect(failing_matcher.does_not_match? model).to eq true
-    end
-
-    it 'should fail if passed non rational' do
-      expect { be_valid_when(:rational_field).is_rational 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational 42.to_c }.to raise_error ArgumentError
-      expect do
-        be_valid_when(:rational_field).is_rational BigDecimal.new
-      end.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_regex_spec.rb

@@ -1,80 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :regexp_field
-  attr_accessor :not_regexp_field
-
-  validate :regexp_field_should_be_regexp,
-           :regexp_field_cannot_be_empty,
-           :not_regexp_field_cannot_be_regexp
-
-  private
-
-  def regexp_field_should_be_regexp
-    errors.add(:regexp_field, 'should be regexp') unless regexp_field.is_a? Regexp
-  end
-
-  def regexp_field_cannot_be_empty
-    errors.add(:regexp_field, "can't be empty") if regexp_field.inspect.length < 3
-  end
-
-  def not_regexp_field_cannot_be_regexp
-    errors.add(:not_regexp_field, "can't be regexp") if not_regexp_field.is_a? Regexp
-  end
-end
-
-describe 'be_valid_when#is_regexp' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { %r{^be valid when #regexp_field is a regexp \(/\^value\$/\)$} }
-
-    let(:passing_matcher) { be_valid_when(:regexp_field).is_regexp }
-    let(:failing_matcher) { be_valid_when(:not_regexp_field).is_regexp }
-
-    it 'has the correct description' do
-      expect(passing_matcher.description).to match description
-    end
-
-    it 'returns proper result' do
-      expect(passing_matcher.matches? model).to eq true
-      expect(passing_matcher.does_not_match? model).to eq false
-      expect(failing_matcher.matches? model).to eq false
-      expect(failing_matcher.does_not_match? model).to eq true
-    end
-  end
-
-  context 'with one argument' do
-    let(:description) { %r{^be valid when #regexp_field is a regexp \(/some regexp/\)$} }
-
-    let(:passing_matcher) { be_valid_when(:regexp_field).is_regexp(/some regexp/) }
-    let(:failing_matcher) { be_valid_when(:regexp_field).is_regexp(//) }
-
-    it 'has the correct description' do
-      expect(passing_matcher.description).to match description
-    end
-
-    it 'returns proper result' do
-      expect(passing_matcher.matches? model).to eq true
-      expect(passing_matcher.does_not_match? model).to eq false
-      expect(failing_matcher.matches? model).to eq false
-      expect(failing_matcher.does_not_match? model).to eq true
-    end
-
-    it 'should fail if passed non regexp' do
-      expect { be_valid_when(:regexp_field).is_regexp 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp 42.to_c }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp 42.to_r }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:regexp_field).is_regexp :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_string_spec.rb

@@ -1,70 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :string_field
-  attr_accessor :not_string_field
-
-  validates_length_of :string_field, minimum: 4
-  validate :not_string_field_cannot_be_string
-
-  private
-
-  def not_string_field_cannot_be_string
-    errors.add(:not_string_field, "can't be string") if not_string_field.is_a? String
-  end
-end
-
-describe 'be_valid_when#is_string' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #string_field is a string \("value"\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:string_field).is_string }
-    let(:failing_matcher) { be_valid_when(:not_string_field).is_string }
-
-    it 'has the correct description' do
-      expect(passing_matcher.description).to match description
-    end
-
-    it 'returns proper result' do
-      expect(passing_matcher.matches? model).to eq true
-      expect(passing_matcher.does_not_match? model).to eq false
-      expect(failing_matcher.matches? model).to eq false
-      expect(failing_matcher.does_not_match? model).to eq true
-    end
-  end
-
-  context 'with one argument' do
-    let(:description) { /^be valid when #string_field is a string \("some string"\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:string_field).is_string 'some string' }
-    let(:failing_matcher) { be_valid_when(:string_field).is_string 'a' }
-
-    it 'has the correct description' do
-      expect(passing_matcher.description).to match description
-    end
-
-    it 'returns proper result' do
-      expect(passing_matcher.matches? model).to eq true
-      expect(passing_matcher.does_not_match? model).to eq false
-      expect(failing_matcher.matches? model).to eq false
-      expect(failing_matcher.does_not_match? model).to eq true
-    end
-
-    it 'should fail if passed non string' do
-      expect { be_valid_when(:string_field).is_string 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:string_field).is_string 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:string_field).is_string 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:string_field).is_string 42.to_c }.to raise_error ArgumentError
-      expect { be_valid_when(:string_field).is_string 42.to_r }.to raise_error ArgumentError
-      expect { be_valid_when(:string_field).is_string(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:string_field).is_string [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:string_field).is_string({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:string_field).is_string :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_symbol_spec.rb

@@ -1,80 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :symbol_field
-  attr_accessor :not_symbol_field
-
-  validate :symbol_field_should_be_symbol,
-           :symbol_field_cannot_be_short,
-           :not_symbol_field_cannot_be_symbol
-
-  private
-
-  def symbol_field_should_be_symbol
-    errors.add(:symbol_field, 'should be symbol') unless symbol_field.is_a? Symbol
-  end
-
-  def symbol_field_cannot_be_short
-    errors.add(:symbol_field, "can't be short") if !symbol_field.nil? && symbol_field.length < 2
-  end
-
-  def not_symbol_field_cannot_be_symbol
-    errors.add(:not_symbol_field, "can't be symbol") if not_symbol_field.is_a? Symbol
-  end
-end
-
-describe 'be_valid_when#is_symbol' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #symbol_field is a symbol \(:value\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:symbol_field).is_symbol }
-    let(:failing_matcher) { be_valid_when(:not_symbol_field).is_symbol }
-
-    it 'has the correct description' do
-      expect(passing_matcher.description).to match description
-    end
-
-    it 'returns proper result' do
-      expect(passing_matcher.matches? model).to eq true
-      expect(passing_matcher.does_not_match? model).to eq false
-      expect(failing_matcher.matches? model).to eq false
-      expect(failing_matcher.does_not_match? model).to eq true
-    end
-  end
-
-  context 'with one argument' do
-    let(:description) { /^be valid when #symbol_field is a symbol \(:some_symbol\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:symbol_field).is_symbol :some_symbol }
-    let(:failing_matcher) { be_valid_when(:symbol_field).is_symbol :a }
-
-    it 'has the correct description' do
-      expect(passing_matcher.description).to match description
-    end
-
-    it 'returns proper result' do
-      expect(passing_matcher.matches? model).to eq true
-      expect(passing_matcher.does_not_match? model).to eq false
-      expect(failing_matcher.matches? model).to eq false
-      expect(failing_matcher.does_not_match? model).to eq true
-    end
-
-    it 'should fail if passed non symbol' do
-      expect { be_valid_when(:symbol_field).is_symbol 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol 42.to_c }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol 42.to_r }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:symbol_field).is_symbol({}) }.to raise_error ArgumentError
-    end
-  end
-end