rspec-be_valid_when_matcher 0.3.0 → 1.0.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-be_valid_when_matcher
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Marek Tuchowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-19 00:00:00.000000000 Z
+date: 2015-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -50,22 +50,14 @@ files:
 - README.md
 - lib/rspec/be_valid_when_matcher.rb
 - spec/examples.cache
-- spec/rspec/be_valid_when/is_array_spec.rb
-- spec/rspec/be_valid_when/is_bigdecimal_spec.rb
-- spec/rspec/be_valid_when/is_bignum_spec.rb
-- spec/rspec/be_valid_when/is_complex_spec.rb
-- spec/rspec/be_valid_when/is_fixnum_spec.rb
-- spec/rspec/be_valid_when/is_float_spec.rb
-- spec/rspec/be_valid_when/is_hash_spec.rb
 - spec/rspec/be_valid_when/is_not_present_spec.rb
-- spec/rspec/be_valid_when/is_number_spec.rb
-- spec/rspec/be_valid_when/is_rational_spec.rb
-- spec/rspec/be_valid_when/is_regex_spec.rb
 - spec/rspec/be_valid_when/is_spec.rb
-- spec/rspec/be_valid_when/is_string_spec.rb
-- spec/rspec/be_valid_when/is_symbol_spec.rb
+- spec/rspec/be_valid_when/is_type_spec.rb
 - spec/rspec/be_valid_when_matcher_spec.rb
 - spec/spec_helper.rb
+- spec/support/has_correct_description.rb
+- spec/support/returns_proper_results.rb
+- spec/support/takes_no_arguments.rb
 homepage: https://github.com/mtuchowski/rspec-be_valid_when_matcher
 licenses:
 - MIT
@@ -80,7 +72,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -95,19 +87,11 @@ summary: RSpec be_valid_when matcher for ActiveRecord models.
 test_files:
 - spec/spec_helper.rb
 - spec/rspec/be_valid_when_matcher_spec.rb
-- spec/rspec/be_valid_when/is_symbol_spec.rb
-- spec/rspec/be_valid_when/is_number_spec.rb
-- spec/rspec/be_valid_when/is_float_spec.rb
-- spec/rspec/be_valid_when/is_rational_spec.rb
-- spec/rspec/be_valid_when/is_bignum_spec.rb
 - spec/rspec/be_valid_when/is_spec.rb
 - spec/rspec/be_valid_when/is_not_present_spec.rb
-- spec/rspec/be_valid_when/is_fixnum_spec.rb
-- spec/rspec/be_valid_when/is_array_spec.rb
-- spec/rspec/be_valid_when/is_bigdecimal_spec.rb
-- spec/rspec/be_valid_when/is_complex_spec.rb
-- spec/rspec/be_valid_when/is_string_spec.rb
-- spec/rspec/be_valid_when/is_regex_spec.rb
-- spec/rspec/be_valid_when/is_hash_spec.rb
+- spec/rspec/be_valid_when/is_type_spec.rb
+- spec/support/returns_proper_results.rb
+- spec/support/has_correct_description.rb
+- spec/support/takes_no_arguments.rb
 - spec/examples.cache
 has_rdoc: 

data/spec/rspec/be_valid_when/is_array_spec.rb

@@ -1,80 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :array_field
-  attr_accessor :not_array_field
-
-  validate :array_field_should_be_array,
-           :array_field_cannot_be_empty,
-           :not_array_field_cannot_be_array
-
-  private
-
-  def array_field_should_be_array
-    errors.add(:array_field, 'should be array') unless array_field.is_a? Array
-  end
-
-  def array_field_cannot_be_empty
-    errors.add(:array_field, "can't be empty") if !array_field.nil? && array_field.length == 0
-  end
-
-  def not_array_field_cannot_be_array
-    errors.add(:not_array_field, "can't be array") if not_array_field.is_a? Array
-  end
-end
-
-describe 'be_valid_when#is_array' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #array_field is a array \(\[42\]\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:array_field).is_array }
-    let(:failing_matcher) { be_valid_when(:not_array_field).is_array }
-
-    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 #array_field is a array \(\[1, 2\]\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:array_field).is_array [1, 2] }
-    let(:failing_matcher) { be_valid_when(:array_field).is_array [] }
-
-    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 array' do
-      expect { be_valid_when(:array_field).is_array 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array 42.to_c }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array 42.to_r }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:array_field).is_array :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_bigdecimal_spec.rb

@@ -1,81 +0,0 @@
-require 'active_model'
-require 'bigdecimal'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :bigdecimal_field
-  attr_accessor :not_bigdec_field
-
-  validates_numericality_of :bigdecimal_field, greater_than: 40
-  validate :not_bigdec_field_cannot_be_bigdecimal
-
-  private
-
-  def not_bigdec_field_cannot_be_bigdecimal
-    errors.add(:not_bigdec_field, "can't be bigdecimal") if not_bigdec_field.is_a? BigDecimal
-  end
-end
-
-describe 'be_valid_when#is_bigdecimal' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #bigdecimal_field is a bigdecimal \(0.42E2\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:bigdecimal_field).is_bigdecimal }
-    let(:failing_matcher) { be_valid_when(:not_bigdec_field).is_bigdecimal }
-
-    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 #bigdecimal_field is a bigdecimal \(0.5E2\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:bigdecimal_field).is_bigdecimal BigDecimal.new('50') }
-    let(:failing_matcher) { be_valid_when(:bigdecimal_field).is_bigdecimal BigDecimal.new('30') }
-
-    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 bigdecimal' do
-      expect { be_valid_when(:bigdecimal_field).is_bigdecimal 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:bigdecimal_field).is_bigdecimal 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:bigdecimal_field).is_bigdecimal 3.14 }.to raise_error ArgumentError
-      expect do
-        be_valid_when(:bigdecimal_field).is_bigdecimal 42.to_c
-      end.to raise_error ArgumentError
-      expect do
-        be_valid_when(:bigdecimal_field).is_bigdecimal 42.to_r
-      end.to raise_error ArgumentError
-      expect do
-        be_valid_when(:bigdecimal_field).is_bigdecimal 'value'
-      end.to raise_error ArgumentError
-      expect { be_valid_when(:bigdecimal_field).is_bigdecimal '42' }.to raise_error ArgumentError
-      expect do
-        be_valid_when(:bigdecimal_field).is_bigdecimal(/^value$/)
-      end.to raise_error ArgumentError
-      expect { be_valid_when(:bigdecimal_field).is_bigdecimal [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:bigdecimal_field).is_bigdecimal({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:bigdecimal_field).is_bigdecimal :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_bignum_spec.rb

@@ -1,72 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :bignum_field
-  attr_accessor :not_bignum_field
-
-  validates_numericality_of :bignum_field, greater_than: 30129469486639681537
-  validate :not_bignum_field_cannot_be_bignum
-
-  private
-
-  def not_bignum_field_cannot_be_bignum
-    errors.add(:not_bignum_field, "can't be bignum") if not_bignum_field.is_a? Bignum
-  end
-end
-
-describe 'be_valid_when#is_bignum' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #bignum_field is a bignum \(1265437718438866624512\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:bignum_field).is_bignum }
-    let(:failing_matcher) { be_valid_when(:not_bignum_field).is_bignum }
-
-    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 #bignum_field is a bignum \(2232232135326160725639168\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:bignum_field).is_bignum 2232232135326160725639168 }
-    let(:failing_matcher) { be_valid_when(:bignum_field).is_bignum 30129469486639681536 }
-
-    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 bignum' do
-      expect { be_valid_when(:bignum_field).is_bignum 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum 42.to_c }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum 42.to_r }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum BigDecimal.new }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_complex_spec.rb

@@ -1,74 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :complex_field
-  attr_accessor :not_complex_field
-
-  validates_numericality_of :complex_field, greater_than: 41
-  validate :not_complex_field_cannot_be_complex
-
-  private
-
-  def not_complex_field_cannot_be_complex
-    errors.add(:not_complex_field, "can't be complex") if not_complex_field.is_a? Complex
-  end
-end
-
-describe 'be_valid_when#is_complex' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #complex_field is a complex \(42\+0i\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:complex_field).is_complex }
-    let(:failing_matcher) { be_valid_when(:not_complex_field).is_complex }
-
-    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 #complex_field is a complex \(50\+0i\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:complex_field).is_complex 50.to_c }
-    let(:failing_matcher) { be_valid_when(:complex_field).is_complex 40.to_c }
-
-    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 complex' do
-      expect { be_valid_when(:complex_field).is_complex 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex 42.to_r }.to raise_error ArgumentError
-      expect do
-        be_valid_when(:complex_field).is_complex BigDecimal.new
-      end.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_fixnum_spec.rb

@@ -1,72 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :fixnum_field
-  attr_accessor :not_fixnum_field
-
-  validates_numericality_of :fixnum_field, greater_than: 40
-  validate :not_fixnum_field_cannot_be_fixnum
-
-  private
-
-  def not_fixnum_field_cannot_be_fixnum
-    errors.add(:not_fixnum_field, "can't be fixnum") if not_fixnum_field.is_a? Fixnum
-  end
-end
-
-describe 'be_valid_when#is_fixnum' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #fixnum_field is a fixnum \(42\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:fixnum_field).is_fixnum }
-    let(:failing_matcher) { be_valid_when(:not_fixnum_field).is_fixnum }
-
-    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 #fixnum_field is a fixnum \(50\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:fixnum_field).is_fixnum 50 }
-    let(:failing_matcher) { be_valid_when(:fixnum_field).is_fixnum 30 }
-
-    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 fixnum' do
-      expect { be_valid_when(:fixnum_field).is_fixnum 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum 42.to_c }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum 42.to_r }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum BigDecimal.new }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_float_spec.rb

@@ -1,72 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :float_field
-  attr_accessor :not_float_field
-
-  validates_numericality_of :float_field, greater_than: 3.0
-  validate :not_float_field_cannot_be_float
-
-  private
-
-  def not_float_field_cannot_be_float
-    errors.add(:not_float_field, "can't be float") if not_float_field.is_a? Float
-  end
-end
-
-describe 'be_valid_when#is_float' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #float_field is a float \(3.141592653589793\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:float_field).is_float }
-    let(:failing_matcher) { be_valid_when(:not_float_field).is_float }
-
-    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 #float_field is a float \(4.2\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:float_field).is_float 4.2 }
-    let(:failing_matcher) { be_valid_when(:float_field).is_float 2.4 }
-
-    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 float' do
-      expect { be_valid_when(:float_field).is_float 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float 42.to_c }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float 42.to_r }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float BigDecimal.new }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_hash_spec.rb

@@ -1,80 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :hash_field
-  attr_accessor :not_hash_field
-
-  validate :hash_field_should_be_hash,
-           :hash_field_cannot_be_empty,
-           :not_hash_field_cannot_be_hash
-
-  private
-
-  def hash_field_should_be_hash
-    errors.add(:hash_field, 'should be hash') unless hash_field.is_a? Hash
-  end
-
-  def hash_field_cannot_be_empty
-    errors.add(:hash_field, "can't be empty") if !hash_field.nil? && hash_field.keys.length == 0
-  end
-
-  def not_hash_field_cannot_be_hash
-    errors.add(:not_hash_field, "can't be hash") if not_hash_field.is_a? Hash
-  end
-end
-
-describe 'be_valid_when#is_hash' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #hash_field is a hash \(\{:value=>42\}\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:hash_field).is_hash }
-    let(:failing_matcher) { be_valid_when(:not_hash_field).is_hash }
-
-    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 #hash_field is a hash \({:a=>1\}\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:hash_field).is_hash(a: 1) }
-    let(:failing_matcher) { be_valid_when(:hash_field).is_hash({}) }
-
-    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 hash' do
-      expect { be_valid_when(:hash_field).is_hash 42 }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash 42**42 }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash 3.14 }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash 42.to_c }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash 42.to_r }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:hash_field).is_hash :value }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/rspec/be_valid_when/is_number_spec.rb

@@ -1,61 +0,0 @@
-require 'active_model'
-
-# @private
-class FakeModel
-  include ActiveModel::Validations
-
-  attr_accessor :number_field
-  attr_accessor :not_number_field
-
-  validates_numericality_of :number_field, greater_than: 40
-  validates_length_of :not_number_field, minimum: 31
-end
-
-describe 'be_valid_when#is_number' do
-  let(:model) { FakeModel.new }
-
-  context 'with no arguments' do
-    let(:description) { /^be valid when #number_field is a number \(42\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:number_field).is_number }
-    let(:failing_matcher) { be_valid_when(:not_number_field).is_number }
-
-    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 #number_field is a number \(50\)$/ }
-
-    let(:passing_matcher) { be_valid_when(:number_field).is_number 50 }
-    let(:failing_matcher) { be_valid_when(:number_field).is_number 30 }
-
-    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 number' do
-      expect { be_valid_when(:number_field).is_number 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:number_field).is_number '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:number_field).is_number(/^value$/) }.to raise_error ArgumentError
-      expect { be_valid_when(:number_field).is_number [1, 2] }.to raise_error ArgumentError
-      expect { be_valid_when(:number_field).is_number({}) }.to raise_error ArgumentError
-      expect { be_valid_when(:number_field).is_number :value }.to raise_error ArgumentError
-    end
-  end
-end