rspec-be_valid_when_matcher 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dbf10b740ed23ee52f1dcd04f21344f1b80ce0fb
+  data.tar.gz: 2fa1b2a7c0177523425e1e3d94170a0c9dbf3dd4
+SHA512:
+  metadata.gz: 1365c63d51fe47a3013da2c205be06edc2a3a15ff799d831191a17ea914db8eb4d3923ecb10e1b38a2f10eb8fb6a9222182ebdeb511e0c739b70babef8a30782
+  data.tar.gz: 4543a03621ee16fab142d3d26a97bc60c7ff03e0e93072c762c0d38fe8c988c638d11f204e9fd599059f65a28f547587f27a29915225445c4bf48b5eef8539aa

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015 Marek Tuchowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# rspec-be_valid_when_matcher
+
+RSpec matcher for testing ActiveRecord models with a fluent and clear language.
+
+## Install
+
+First, add to your `Gemfile` (preferably in the `:test` group):
+
+```ruby
+gem 'rspec-be_valid_when_matcher'
+```
+
+Then, include `RSpec::BeValidWhenMatcher` in RSpec configuration:
+
+```ruby
+RSpec.configure do |config|
+  config.include RSpec::BeValidWhenMatcher
+end
+```
+
+Or, directly in your model spec(s):
+
+```ruby
+describe MyModel do
+  include RSpec::BeValidWhenMatcher
+
+  subject { build(:my_model) }
+
+  describe '#header' do
+    it { is_expected.not_to be_valid_when :header, nil }
+  end
+end
+```
+
+## Basic usage
+
+Here's an example using rspec-be_valid_when_matcher:
+
+```ruby
+RSpec.describe Person do
+  subject { Person.new }
+
+  it { is_expected.to be_valid_when :name, 'Frank', 'some text' }
+  it { is_expected.to be_valid_when :age, 42, 'positive number' }
+  it { is_expected.not_to be_valid_when :age, -1, 'negative number' }
+end
+```
+
+The `:name` and `:age` are names of fields belonging to `Person` instance. If the matcher will fail,
+say for negative number check, it'll display the following message:
+
+```console
+Failures:
+
+  1) Person should not be valid when #age is negative number (-1)
+     Failure/Error: it { is_expected.not_to be_valid_when :age, -1, 'negative number' }
+```
+
+To keep the specs more readable `#is(value, message)` method can be used to separate `field`
+from expected `value` and optional `message` declaration like so:
+
+```ruby
+RSpec.describe Person do
+  subject { Person.new }
+
+  it { is_expected.to be_valid_when(:name).is('Frank', 'some text') }
+  it { is_expected.to be_valid_when(:age).is(42, 'positive number') }
+  it { is_expected.not_to be_valid_when(:age).is(-1, 'negative number') }
+end
+```
+
+### Built-in checks
+
+#### Presence
+
+Test field validity with the `nil` value:
+
+```ruby
+be_valid_when(:field).is_not_present     # Uses nil value
+```
+
+#### Type
+
+Test field validity with specific type values:
+
+```ruby
+be_valid_when(:field).is_number 2          # Defaults to 42
+be_valid_when(:field).is_fixnum 2          # Defaults to 42
+be_valid_when(:field).is_bignum 1024**32   # Defaults to 42**13
+be_valid_when(:field).is_float 0.1         # Defaults to 3.14
+be_valid_when(:field).is_complex 2.to_c    # Defaults to 42+0i
+be_valid_when(:field).is_rational 2.to_r   # Defaults to 42/1
+be_valid_when(:field).is_bigdecimal BigDecimal('2') # Defaults to BigDecimal('42')
+be_valid_when(:field).is_string 'a'        # Defaults to 'value'
+be_valid_when(:field).is_regex /abc/       # Defaults to /^value$/
+be_valid_when(:field).is_array [1,2]       # Defaults to [42]
+be_valid_when(:field).is_hash { a: 1 }     # Defaults to { value: 42 }
+be_valid_when(:field).is_symbol :a         # Defaults to :value
+```
+
+## MIT Licensed
+
+See [LICENSE](https://github.com/mtuchowski/rspec-be_valid_when_matcher/blob/master/LICENSE) file
+for full license text.

data/lib/rspec/be_valid_when_matcher.rb

@@ -0,0 +1,192 @@
+# encoding: UTF-8
+require 'rspec'
+
+# RSpec's top level namespace.
+module RSpec
+  # Container module for be_valid_when matcher definition and implementation.
+  module BeValidWhenMatcher
+    # rubocop:disable Style/PredicateName
+
+    # Provides the implementation for `be_valid_when` matcher.
+    # Not intended to be instantiated directly.
+    # @api private
+    class BeValidWhen
+      # Returns a new instance of matcher.
+      # @param field (Symbol) field name to use.
+      # @raise ArgumentError if field name is not a symbol.
+      def initialize(field)
+        unless field.instance_of? Symbol
+          fail ArgumentError, "field name should be symbol (#{field.inspect})"
+        end
+
+        @field     = field
+        @value_set = false
+        @value     = nil
+        @model     = nil
+      end
+
+      # Passes if given `model` instance is valid.
+      #
+      # More specifically if it doesn't have any
+      # {http://api.rubyonrails.org/classes/ActiveModel/Validations.html#method-i-errors `errors`}
+      # on specified `field` after setting it's `value` and validating it. Does not take into
+      # account other fields and the validity of the whole object.
+      # @api private
+      # @param model [Object] an Object implementing `ActiveModel::Validations`.
+      # @return [Boolean] `true` if there are no errors on `field`, `false` otherwise.
+      def matches?(model)
+        setup_model model
+        @model.errors[@field].empty?
+      end
+
+      # Passes if given `model` instance is invalid.
+      #
+      # More specifically if it does have
+      # {http://api.rubyonrails.org/classes/ActiveModel/Validations.html#method-i-errors `errors`}
+      # on specified `field` after setting it's `value` and validating it. Does not take into
+      # account other fields.
+      # @api private
+      # @param model [Object] an Object implementing `ActiveModel::Validations`.
+      # @return [Boolean] `true` if there are errors on `field`, `false` otherwise.
+      def does_not_match?(model)
+        setup_model model
+        !@model.errors[@field].empty?
+      end
+
+      # Called when {#matches?} returns false.
+      # @api private
+      # @return [String] explaining what was expected.
+      def failure_message
+        assert_value_existence
+        assert_model_existance
+
+        "expected #{@model.inspect} to be valid when #{format_message}"
+      end
+
+      # Called when {#does_not_match?} returns false.
+      # @api private
+      # @return [String] explaining what was expected.
+      def failure_message_when_negated
+        assert_value_existence
+        assert_model_existance
+
+        "expected #{@model.inspect} not to be valid when #{format_message}"
+      end
+
+      # Used to generate the example's doc string in one-liner syntax.
+      # @api private
+      # @return [String] short description of what is expected.
+      def description
+        assert_value_existence
+
+        "be valid when #{format_message}"
+      end
+
+      # Indicates that this matcher doesn't provide actual and expected attributes.
+      # @api private
+      # @return [FalseClass]
+      def diffable?
+        false
+      end
+
+      # Indicates that this matcher cannot be used in a block expectation expression.
+      # @api private
+      # @return [FalseClass]
+      def supports_block_expectations?
+        false
+      end
+
+      # Used to set field `value` and optional custom failure `message`.
+      # @overload is(value)
+      #   Sets the field `value`.
+      #   @param value [Any] field `value` to use in matching.
+      # @overload is(value, message)
+      #   Sets the field `value` and custom failure `message`.
+      #   @param value [Any] field `value` to use in matching.
+      #   @param message [String] a `message` used for {#failure_message},
+      #   {#failure_message_when_negated} and {#description}.
+      # @return [self]
+      def is(*args)
+        number_of_arguments = args.size
+
+        if number_of_arguments > 2 || number_of_arguments == 0
+          fail ArgumentError, "wrong number of arguments (#{number_of_arguments} insted of 1 or 2)"
+        else
+          self.value = args.shift
+          @message = args.first
+        end
+
+        self
+      end
+
+      # Used to setup matcher for checking `nil` `value`.
+      def is_not_present
+        is(nil, 'not present')
+      end
+
+      # Used to setup matcher for checking for numeric values.
+      def is_number(number = 42)
+        fail ArgumentError, 'should be number' unless number.is_a? Numeric
+
+        is(number, 'number')
+      end
+
+      # Used to setup matcher for checking for fixnum values.
+      def is_fixnum(number = 42)
+        fail ArgumentError, 'should be a fixnum' unless number.is_a? Fixnum
+
+        is(number, 'a fixnum')
+      end
+
+      # Used to setup matcher for checking for bignum values.
+      def is_bignum(number = 42**13)
+        fail ArgumentError, 'should be a bignum' unless number.is_a? Bignum
+
+        is(number, 'a bignum')
+      end
+
+      private
+
+      attr_writer :message
+
+      def value=(value)
+        @value = value
+        @value_set = true
+      end
+
+      def assert_value_existence
+        fail ArgumentError, 'missing value' unless @value_set
+      end
+
+      def assert_model_existance
+        fail ArgumentError, 'missing model' if @model.nil?
+      end
+
+      def setup_model(model)
+        assert_value_existence
+
+        @model = model
+        @model.send "#{@field}=", @value
+        @model.validate
+      end
+
+      def format_message
+        value = @value.inspect
+        message = @message.nil? ? "is #{value}" : "is #{@message} (#{value})"
+        "##{@field} #{message}"
+      end
+    end
+
+    # Model validity assertion.
+    def be_valid_when(*args)
+      number_of_arguments = args.size
+      field_name = args.shift
+
+      if number_of_arguments == 1
+        BeValidWhen.new(field_name)
+      else
+        BeValidWhen.new(field_name).is(*args)
+      end
+    end
+  end
+end

data/spec/examples.cache

@@ -0,0 +1,59 @@
+example_id                                             | status | run_time        |
+------------------------------------------------------ | ------ | --------------- |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:1:1]    | passed | 0.00026 seconds |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:1:2]    | passed | 0.0123 seconds  |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:1]    | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:2]    | passed | 0.01276 seconds |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:3]    | passed | 0.00017 seconds |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:1:1]    | passed | 0.0005 seconds  |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:1:2]    | passed | 0.06739 seconds |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:1]    | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:2]    | passed | 0.0176 seconds  |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:3]    | passed | 0.00139 seconds |
+./spec/rspec/be_valid_when/is_not_present_spec.rb[1:1] | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when/is_not_present_spec.rb[1:2] | passed | 0.01358 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:1:1]    | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:1:2]    | passed | 0.01096 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:2:1]    | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:2:2]    | passed | 0.01177 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:2:3]    | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:1]             | passed | 0.00015 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:2:1]           | passed | 0.01055 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:3:1]           | passed | 0.01142 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:3:2]           | passed | 0.00298 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:4]             | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:1]      | passed | 0.00031 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:2]      | passed | 0.00008 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:3]      | passed | 0.00008 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:4]      | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:5]      | passed | 0.00009 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:6]      | passed | 0.00067 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:7]      | passed | 0.00009 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:8]      | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:9]      | passed | 0.00008 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:10]     | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:1]      | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:2]      | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:1]    | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:2]    | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:3]    | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:4]    | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:5]    | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:3:1]      | passed | 0.00009 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:3:2:1]    | passed | 0.0028 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:3:2:2]    | passed | 0.00367 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:4:1]      | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:4:2:1]    | passed | 0.00286 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:4:2:2]    | passed | 0.00272 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:5]        | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:6:1]      | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:6:2]      | passed | 0.00018 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:6:3]      | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:6:4]      | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:7:1:1]    | passed | 0.00278 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:7:1:2]    | passed | 0.00602 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:7:2:1]    | passed | 0.00285 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:7:2:2]    | passed | 0.00613 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:8:1]      | passed | 0.00287 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:8:2:1]    | passed | 0.00286 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:9:1]      | passed | 0.00012 seconds |

data/spec/rspec/be_valid_when/is_bignum_spec.rb

@@ -0,0 +1,60 @@
+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
+  validates_length_of :not_bignum_field, minimum: 31
+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 '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 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 :value }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/rspec/be_valid_when/is_fixnum_spec.rb

@@ -0,0 +1,59 @@
+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
+  validates_length_of :not_fixnum_field, minimum: 31
+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 '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 3.14 }.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_not_present_spec.rb

@@ -0,0 +1,32 @@
+require 'active_model'
+
+# @private
+class FakeModel
+  include ActiveModel::Validations
+
+  attr_accessor :nil_field
+  attr_accessor :not_nil_field
+
+  validates_absence_of :nil_field
+  validates_presence_of :not_nil_field
+end
+
+describe 'be_valid_when#is_not_present' do
+  let(:model) { FakeModel.new }
+
+  let(:passing_matcher) { be_valid_when(:nil_field).is_not_present }
+  let(:failing_matcher) { be_valid_when(:not_nil_field).is_not_present }
+
+  let(:description) { /^be valid when #nil_field is not present \(nil\)$/ }
+
+  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

data/spec/rspec/be_valid_when/is_number_spec.rb

@@ -0,0 +1,58 @@
+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 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 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
+    end
+  end
+end

data/spec/rspec/be_valid_when/is_spec.rb

@@ -0,0 +1,62 @@
+require 'active_model'
+
+# @private
+class FakeModel
+  include ActiveModel::Validations
+
+  attr_accessor :field
+
+  validates_presence_of :field
+end
+
+RSpec.shared_examples 'sets the field value' do
+  it 'sets the field value' do
+    expect { subject.matches? model }.not_to raise_error
+    expect { subject.does_not_match? model }.not_to raise_error
+
+    expect(subject.matches? model).to eq true
+    expect(subject.does_not_match? model).to eq false
+
+    expect { subject.description }.not_to raise_error
+  end
+end
+
+describe 'be_valid_when#is' do
+  let(:model) { FakeModel.new }
+
+  it 'should fail if no arguments given' do
+    expect { be_valid_when(:field).is }.to raise_error ArgumentError
+  end
+
+  context 'when given one argument' do
+    subject { be_valid_when(:field).is('value') }
+
+    include_examples 'sets the field value'
+  end
+
+  context 'when given two arguments' do
+    subject { be_valid_when(:field).is('value', 'some text') }
+
+    let(:description_regex) { /^be valid when #field is some text \("value"\)$/ }
+    let(:message_regex) do
+      /^expected #<.*> to be valid when #field is some text \("value"\)$/
+    end
+    let(:negated_message_regex) do
+      /^expected #<.*> not to be valid when #field is some text \("value"\)$/
+    end
+
+    include_examples 'sets the field value'
+
+    it 'sets the custom message with second argument' do
+      subject.matches? model
+
+      expect(subject.description).to match description_regex
+      expect(subject.failure_message).to match message_regex
+      expect(subject.failure_message_when_negated).to match negated_message_regex
+    end
+  end
+
+  it 'should fail if more that two arguments given' do
+    expect { be_valid_when(:field).is('one', 'two', 'three') }.to raise_error ArgumentError
+  end
+end

data/spec/rspec/be_valid_when_matcher_spec.rb

@@ -0,0 +1,209 @@
+require 'active_model'
+
+# @private
+class FakeModel
+  include ActiveModel::Validations
+
+  attr_accessor :field
+  attr_accessor :other_field
+
+  validates :field, presence: true
+  validates :other_field, presence: true
+end
+
+describe 'be_valid_when' do
+  # Declarations
+
+  let(:model) { FakeModel.new }
+
+  # General specs
+
+  context 'matcher' do
+    subject { be_valid_when :field }
+
+    it 'is expected to be of proper type' do
+      expect(subject).to be_an_instance_of RSpec::BeValidWhenMatcher::BeValidWhen
+    end
+
+    it { is_expected.to respond_to :matches? }
+    it { is_expected.to respond_to :does_not_match? }
+    it { is_expected.to respond_to :failure_message }
+    it { is_expected.to respond_to :failure_message_when_negated }
+    it { is_expected.to respond_to :description }
+    it { is_expected.to respond_to :diffable? }
+    it { is_expected.to respond_to :supports_block_expectations? }
+
+    it 'does not support diffing' do
+      expect(subject.diffable?).to eq false
+    end
+
+    it 'does not support block expectations' do
+      expect(subject.supports_block_expectations?).to eq false
+    end
+  end
+
+  # Matcher arguments specs
+
+  context 'field name argument' do
+    it 'is expected to be provided' do
+      expect { be_valid_when }.to raise_error ArgumentError
+    end
+
+    it 'is expected to bo a symbol' do
+      expect { be_valid_when 42 }.to raise_error ArgumentError
+      expect { be_valid_when :field }.not_to raise_error
+    end
+
+    context 'when is the only argument provided' do
+      subject { be_valid_when :field }
+
+      it 'should fail on #matches?' do
+        expect { subject.matches? model }.to raise_error ArgumentError
+      end
+
+      it 'should fail on #does_not_match?' do
+        expect { subject.does_not_match? model }.to raise_error ArgumentError
+      end
+
+      it 'should fail on #failure_message' do
+        expect { subject.failure_message }.to raise_error ArgumentError
+      end
+
+      it 'should fail on #failure_message_when_negated' do
+        expect { subject.failure_message_when_negated }.to raise_error ArgumentError
+      end
+
+      it 'should fail on #description' do
+        expect { subject.description }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  context 'field value argument' do
+    it 'can be specified when declating matcher' do
+      expect { be_valid_when :field, 'value' }.not_to raise_error
+    end
+
+    context 'if provided' do
+      subject { be_valid_when :field, 'value' }
+
+      it 'should not fail on #matches?' do
+        expect { subject.matches? model }.not_to raise_error
+      end
+
+      it 'should not fail on #does_not_match?' do
+        expect { subject.does_not_match? model }.not_to raise_error
+      end
+    end
+  end
+
+  context 'custom message argument' do
+    it 'can be specified when declating matcher' do
+      expect { be_valid_when :field, 'value', 'some text' }.not_to raise_error
+    end
+
+    context 'if provided' do
+      subject { be_valid_when :field, 'value', 'some text' }
+
+      it 'should not fail on #matches?' do
+        expect { subject.matches? model }.not_to raise_error
+      end
+
+      it 'should not fail on #does_not_match?' do
+        expect { subject.does_not_match? model }.not_to raise_error
+      end
+    end
+  end
+
+  it 'should not accept more arguments than field symbol, field value and custom message' do
+    expect { be_valid_when :field, 'value', 'some text', 'other arg' }.to raise_error ArgumentError
+  end
+
+  # General matching interface specs
+
+  context 'if not provided with model to match' do
+    subject { be_valid_when :field, 'value' }
+
+    it 'should fail on #matches?' do
+      expect { subject.matches? }.to raise_error ArgumentError
+    end
+
+    it 'should fail on #does_not_match?' do
+      expect { subject.does_not_match? }.to raise_error ArgumentError
+    end
+
+    it 'should fail on #failure_message' do
+      expect { subject.failure_message }.to raise_error ArgumentError
+    end
+
+    it 'should fail on #failure_message_when_negated' do
+      expect { subject.failure_message_when_negated }.to raise_error ArgumentError
+    end
+  end
+
+  context 'when asserting validity of model' do
+    subject { be_valid_when :field }
+
+    context 'using #matches?' do
+      it 'is setting the proper field using the provided value' do
+        model.field = nil
+        subject.is('value').matches? model
+        expect(model.field).to eq 'value'
+      end
+
+      it 'returns proper result' do
+        expect(subject.is('value').matches? model).to eq true
+        expect(subject.is(nil).matches? model).to eq false
+      end
+    end
+
+    context 'using #does_not_match?' do
+      it 'is setting the proper field using the provided value' do
+        model.field = nil
+        subject.is('value').does_not_match? model
+        expect(model.field).to eq 'value'
+      end
+
+      it 'returns proper result' do
+        expect(subject.is('value').does_not_match? model).to eq false
+        expect(subject.is(nil).does_not_match? model).to eq true
+      end
+    end
+  end
+
+  # Message methods specs
+
+  context 'failure message' do
+    subject { be_valid_when :field, 'value' }
+
+    let(:message_regex) do
+      /^expected #<.*> to be valid when #field is "value"$/
+    end
+
+    it 'provides subject model, field name and field value' do
+      subject.matches?(model)
+      expect(subject.failure_message).to match message_regex
+    end
+
+    context 'when negated' do
+      let(:negated_message_regex) do
+        /^expected #<.*> not to be valid when #field is "value"$/
+      end
+
+      it 'provides subject model, field name and field value' do
+        subject.does_not_match?(model)
+        expect(subject.failure_message_when_negated).to match negated_message_regex
+      end
+    end
+  end
+
+  context 'description' do
+    subject { be_valid_when :field, 'value' }
+
+    let(:description_regex) { /^be valid when #field is "value"$/ }
+
+    it 'provides field name and field value' do
+      expect(subject.description).to match description_regex
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+# Conventionally, all specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this file to always
+# be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, keep this file as light-weight as possible. Requiring heavyweight
+# dependencies from this file will add to the boot time of test suite on EVERY test run, even for
+# an individual file that may not need all of that loaded. Instead, consider making a separate
+# helper file that requires the additional dependencies and performs the additional setup,
+# and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that are commonly wanted.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'rspec/be_valid_when_matcher'
+
+RSpec.configure do |config|
+  config.include RSpec::BeValidWhenMatcher
+
+  # rspec-expectations config goes here.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description` and
+    # `failure_message` of custom matchers include text for helper methods defined using
+    # `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+
+    # Only allow expect syntax.
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here.
+  config.mock_with :rspec do |mocks|
+    # Prevents from mocking or stubbing a method that does not exist on a real object.
+    # This is generally recommended, and will default to `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # Allows RSpec to persist some state between runs in order to support the `--only-failures` and
+  # `--next-failure` CLI options. Source control system should be configured to ignore this file.
+  config.example_status_persistence_file_path = 'spec/examples.cache'
+
+  # Run specs in random order to surface order dependencies. To debug an order dependency after
+  # finding one, fix the order by providing the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option. Setting this allows
+  # to use `--seed` to deterministically reproduce test failures related to randomization
+  # by passing the same `--seed` value as the one that triggered the failure.
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: rspec-be_valid_when_matcher
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Marek Tuchowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: RSpec matcher for testing ActiveRecord models with a fluent language.
+email: marek@tuchowski.com.pl
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- lib/rspec/be_valid_when_matcher.rb
+- spec/examples.cache
+- spec/rspec/be_valid_when/is_bignum_spec.rb
+- spec/rspec/be_valid_when/is_fixnum_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_spec.rb
+- spec/rspec/be_valid_when_matcher_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mtuchowski/rspec-be_valid_when_matcher
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset"
+- UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+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_number_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/examples.cache
+has_rdoc: