easy-matchers 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0245d697cce0fbd8bf28805a1b2d8aa7d7323c5
+  data.tar.gz: 079b1507f271cf07673a1de11614bf1cc108daee
+SHA512:
+  metadata.gz: 6d20087c77bc3e33b085a677b563167f3be720aa61a4848fcb1ed0486d8c5b46a33f77a3f95c2d6fe3f02a05933e800f21f08e5359753b181edac23f8844a34c
+  data.tar.gz: c05719749f54633839f789db57b7b7574a9857ffb2123b18ae2e02c7ceed1a0414e17e953d0d1646bbbda73566e082fd97470f66a72ab66a2e7b86497aef4d54

data/.codeclimate.yml

@@ -0,0 +1,8 @@
+---
+engines:
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths: []

data/.rubocop.yml

@@ -0,0 +1,12 @@
+Style/Documentation:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Style/DotPosition:
+  Enabled: true
+  EnforcedStyle: leading
+
+Style/SpaceInsideStringInterpolation:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in `mongoid-rspec.gemspec`.
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2015 Igor Zubkov
+
+
+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,46 @@
+# Easy Matchers
+
+[![Code Climate](https://codeclimate.com/github/MLSDev/easy-matchers/badges/gpa.svg)](https://codeclimate.com/github/MLSDev/easy-matchers)
+
+Easy matchers provides RSpec matchers for common Rails functionality.
+
+----
+
+### ActiveModel::Validations matchers
+
+* validate_absence_of
+* validate_acceptance_of
+* validate_confirmation_of
+* validate_length_of
+* validate_numericality_of
+* validate_presence_of
+
+## Install and configure
+
+`gem install easy-matchers`
+
+or via bundler:
+
+`gem 'easy-matchers'`
+
+spec/support/easy-matchers.rb:
+```
+RSpec.configure do |config|
+  config.include Easy::Matchers::Validations, type: :model
+end
+```
+
+## License
+
+This work is licensed under a MIT License.
+
+## About MLSDev
+
+[<img src="/mlsdev-logo.png" alt="MLSDev.com">][mlsdev]
+
+Easy-Matcher are maintained by MLSDev, Inc. We specialize in providing all-in-one solution in mobile and web development. Our team follows Lean principles and works according to agile methodologies to deliver the best results reducing the budget for development and its timeline. 
+
+Find out more [here][mlsdev] and don't hesitate to [contact us][contact]!
+
+[mlsdev]: http://mlsdev.com
+[contact]: http://mlsdev.com/contact_us

data/Rakefile

@@ -0,0 +1,17 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "./spec/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = "./spec/**/*_spec.rb"
+  spec.rcov = true
+end

data/easy-matchers.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+
+require 'easy/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'easy-matchers'
+  spec.version     = Easy::Matchers::VERSION
+  spec.authors     = ['Igor Zubkov']
+  spec.email       = ['igor.zubkov@gmail.com']
+
+  spec.summary     = 'Extra RSpec matchers for Rails'
+  spec.description = 'Extra RSpec matches for Rails (ActiveModel::Validators, ActiveModel::Model)'
+  spec.homepage    = 'https://github.com/MLSDev/easy-matchers'
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin)/}) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.add_runtime_dependency 'rspec', '~> 3.4'
+  spec.add_runtime_dependency 'activemodel', '~> 4.2'
+end

data/lib/easy-matchers.rb

@@ -0,0 +1,7 @@
+require 'matchers/validations/base_validation_matcher'
+require 'matchers/validations/absence_of'
+require 'matchers/validations/acceptance_of'
+require 'matchers/validations/confirmation_of'
+require 'matchers/validations/length_of'
+require 'matchers/validations/numericality_of'
+require 'matchers/validations/presence_of'

data/lib/easy/version.rb

@@ -0,0 +1,5 @@
+module Easy
+  module Matchers
+    VERSION = '0.0.1'.freeze
+  end
+end

data/lib/matchers/validations.rb

@@ -0,0 +1,76 @@
+module Easy
+  module Matchers
+    module Validations
+      class HaveValidationMatcher
+        def initialize(field, type)
+          @field = field
+          @type = type
+          @options = {}
+        end
+
+        def matches?(actual)
+          @klass = actual.is_a?(Class) ? actual : actual.class
+
+          @validator = @klass.validators_on(@field).detect{ |v|
+            v.kind == @type && (!v.options[:on] || on_options_matches?(v))
+          }
+
+          if @validator
+            @negative_result_message = "#{ @type.inspect } validator on #{ @field.inspect }"
+            @positive_result_message = "#{ @type.inspect } validator on #{ @field.inspect }"
+          else
+            @negative_result_message = "no #{ @type.inspect } validator on #{ @field.inspect }"
+            return false
+          end
+          @result = true
+          check_on if @options[:on]
+          @result
+        end
+
+        def failure_message
+          "Expected #{ @klass.inspect } to #{ description }; instead got #{ @negative_result_message }"
+        end
+
+        def failure_message_when_negated
+          "Expected #{ @klass.inspect } to not #{ description }; instead got #{ @positive_result_message }"
+        end
+
+        def description
+          desc = "have #{ @type } validator on #{ @field }"
+          desc << " on #{ @options[:on] }" if @options[:on]
+          desc
+        end
+
+        def on(*on_method)
+          @options[:on] = on_method.flatten
+          self
+        end
+
+        def check_on
+          validator_on_methods = [@validator.options[:on]].flatten
+
+          if validator_on_methods.any?
+            message = " on methods: #{ validator_on_methods }"
+
+            if on_options_covered_by?(@validator)
+              @positive_result_message << message
+            else
+              @negative_result_message << message
+              @result = false
+            end
+          end
+        end
+
+        private
+
+        def on_options_matches?(validator)
+          @options[:on] && validator.options[:on] && on_options_covered_by?(validator)
+        end
+
+        def on_options_covered_by?(validator)
+          ([@options[:on]].flatten - [validator.options[:on]].flatten).empty?
+        end
+      end
+    end
+  end
+end

data/lib/matchers/validations/absence_of.rb

@@ -0,0 +1,66 @@
+module Easy
+  module Matchers
+    module Validations
+      def validate_absence_of(*attributes)
+        ValidateAbsenceOfMatcher.new(attributes)
+      end
+
+      class ValidateAbsenceOfMatcher < BaseValidationMatcher
+        def initialize(attributes)
+          super(attributes, :absence)
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          matched_validator = class_name.validators.detect do |validator|
+            validator.kind == type &&
+              validator.attributes.sort == attributes.sort &&
+              validator.options.sort == options.sort
+          end
+
+          true if matched_validator
+        end
+
+        def description
+          "require #{ attributes.join(', ') } to not be set"
+        end
+
+        def with_message(message)
+          options[:message] = message
+          self
+        end
+
+        def if(symbol_name)
+          options[:if] = symbol_name
+          self
+        end
+
+        def unless(symbol_name)
+          options[:unless] = symbol_name
+          self
+        end
+
+        def on(context)
+          options[:on] = context
+          self
+        end
+
+        def allow_nil(value = true)
+          options[:allow_nil] = value
+          self
+        end
+
+        def allow_blank(value = true)
+          options[:allow_blank] = value
+          self
+        end
+
+        def strict(value)
+          options[:strict] = value
+          self
+        end
+      end
+    end
+  end
+end

data/lib/matchers/validations/acceptance_of.rb

@@ -0,0 +1,77 @@
+module Easy
+  module Matchers
+    module Validations
+      def validate_acceptance_of(*attributes)
+        ValidateAcceptanceOfMatcher.new(attributes)
+      end
+
+      class ValidateAcceptanceOfMatcher < BaseValidationMatcher
+        def initialize(attributes)
+          super(attributes, :acceptance)
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          add_allow_nil_and_accept_to_options
+
+          matched_validator = class_name.validators.detect do |validator|
+            validator.kind == type &&
+              validator.attributes.sort == attributes.sort &&
+              validator.options.sort == options.sort
+          end
+
+          true if matched_validator
+        end
+
+        def description
+          "require #{ attributes.join(', ') } to be accepted"
+        end
+
+        def with_message(message)
+          options[:message] = message
+          self
+        end
+
+        def if(symbol_name)
+          options[:if] = symbol_name
+          self
+        end
+
+        def unless(symbol_name)
+          options[:unless] = symbol_name
+          self
+        end
+
+        def on(context)
+          options[:on] = context
+          self
+        end
+
+        def allow_nil(value = true)
+          options[:allow_nil] = value
+          self
+        end
+
+        def allow_blank(value = true)
+          options[:allow_blank] = value
+          self
+        end
+
+        def strict(value)
+          options[:strict] = value
+          self
+        end
+
+        private
+
+        # TODO: check :allow_nil and :accept before setting
+        # NOTE: Rails adds this to options by defaults
+        def add_allow_nil_and_accept_to_options
+          options[:allow_nil] = true
+          options[:accept] = '1'
+        end
+      end
+    end
+  end
+end

data/lib/matchers/validations/base_validation_matcher.rb

@@ -0,0 +1,57 @@
+module Easy
+  module Matchers
+    class BaseValidationMatcher
+      attr_reader :attributes,
+                  :failure_message,
+                  :failure_message_when_negated,
+                  :subject,
+                  :type,
+                  :options
+
+      def initialize(attributes, type)
+        @attributes = attributes
+        @failure_message = nil
+        @failure_message_when_negated = nil
+        @type = type
+        @options = {}
+      end
+
+      def matches?(subject)
+        @subject = subject
+        false
+      end
+
+      def class_name
+        subject.class
+      end
+
+      def description
+        raise NotImplementedError, 'Subclasses must implement a description method.'
+      end
+
+      def if
+        raise NotImplementedError, 'Subclasses must implement a if method.'
+      end
+
+      def unless
+        raise NotImplementedError, 'Subclasses must implement a unless method.'
+      end
+
+      def on(context)
+        raise NotImplementedError, 'Subclasses must implement a on method.'
+      end
+
+      def allow_nil
+        raise NotImplementedError, 'Subclasses must implement a allow_nil method.'
+      end
+
+      def allow_blank
+        raise NotImplementedError, 'Subclasses must implement a allow_blank method.'
+      end
+
+      def strict
+        raise NotImplementedError, 'Subclasses must implement a strict method.'
+      end
+    end
+  end
+end

data/lib/matchers/validations/confirmation_of.rb

@@ -0,0 +1,69 @@
+module Easy
+  module Matchers
+    module Validations
+      def validate_confirmation_of(*attributes)
+        ValidateConfirmationOfMatcher.new(attributes)
+      end
+
+      class ValidateConfirmationOfMatcher < BaseValidationMatcher
+        attr_reader :confirmation_attributes
+
+        def initialize(attributes)
+          super(attributes, :confirmation)
+          @confirmation_attributes = attributes
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          matched_validator = class_name.validators.detect do |validator|
+            validator.kind == type &&
+              validator.attributes.sort == attributes.sort &&
+              validator.options.sort == options.sort
+          end
+
+          true if matched_validator
+        end
+
+        def description
+          "require #{ confirmation_attributes.join(', ') } to match #{ attributes.join(', ') }"
+        end
+
+        def with_message(message)
+          options[:message] = message
+          self
+        end
+
+        def if(symbol_name)
+          options[:if] = symbol_name
+          self
+        end
+
+        def unless(symbol_name)
+          options[:unless] = symbol_name
+          self
+        end
+
+        def on(context)
+          options[:on] = context
+          self
+        end
+
+        def allow_nil(value = true)
+          options[:allow_nil] = value
+          self
+        end
+
+        def allow_blank(value = true)
+          options[:allow_blank] = value
+          self
+        end
+
+        def strict(value)
+          options[:strict] = value
+          self
+        end
+      end
+    end
+  end
+end

data/lib/matchers/validations/length_of.rb

@@ -0,0 +1,113 @@
+module Easy
+  module Matchers
+    module Validations
+      def validate_length_of(*attributes)
+        ValidateLengthOfMatcher.new(attributes)
+      end
+
+      class ValidateLengthOfMatcher < BaseValidationMatcher
+        def initialize(attributes)
+          super(attributes, :length)
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          matched_validator = class_name.validators.detect do |validator|
+            validator.kind == type &&
+              validator.attributes.sort == attributes.sort &&
+              validator.options.sort == options.sort
+          end
+
+          true if matched_validator
+        end
+
+        def with_message(message)
+          options[:message] = message
+          self
+        end
+
+        def if(symbol_name)
+          options[:if] = symbol_name
+          self
+        end
+
+        def unless(symbol_name)
+          options[:unless] = symbol_name
+          self
+        end
+
+        def on(context)
+          options[:on] = context
+          self
+        end
+
+        def allow_nil(value = true)
+          options[:allow_nil] = value
+          self
+        end
+
+        def allow_blank(value = true)
+          options[:allow_blank] = value
+          self
+        end
+
+        def strict(value)
+          options[:strict] = value
+          self
+        end
+
+        def is_at_most(value)
+          options[:maximum] = value
+          self
+        end
+
+        def is_at_least(value)
+          options[:minimum] = value
+          self
+        end
+
+        # def is_equal_to
+        #   @is = value
+        #   self
+        # end
+
+        def description
+          description = "ensure #{ attributes.join(', ') } has a length "
+        #   options_desc = []
+        #   options_desc << "with minimum of #{ @minimum }" if @minimum
+        #   options_desc << "with maximum of #{ @maximum }" if @maximum
+        #   # options_desc << "within the range of #{ @within }" if @within
+        #   # options_desc << "as exactly #{ @is }" if @is
+        #   options_desc << "with message '#{ @expected_message }'" if @expected_message
+        #   super << " #{ options_desc.to_sentence }"
+          description
+        end
+
+        private
+
+        # # def check_exact
+        # #   if actual_is == @is
+        # #     @positive_result_message << " as exactly #{@is}"
+        # #   else
+        # #     @negative_result_message << " as exactly #{actual_is}"
+        # #     @result = false
+        # #   end
+        # # end
+        #
+        # def check_expected_message
+        #   actual_message = @validator.options[:message]
+        #   if actual_message.nil?
+        #     @negative_result_message << ' with no custom message'
+        #     @result = false
+        #   elsif actual_message == @expected_message
+        #     @positive_result_message << " with custom message '#{ @expected_message }'"
+        #   else
+        #     @negative_result_message << " got message '#{ actual_message }'"
+        #     @result = false
+        #   end
+        # end
+      end
+    end
+  end
+end

data/lib/matchers/validations/numericality_of.rb

@@ -0,0 +1,111 @@
+module Easy
+  module Matchers
+    module Validations
+      def validate_numericality_of(*attributes)
+        ValidateNumericalityOfMatcher.new(attributes)
+      end
+
+      class ValidateNumericalityOfMatcher < BaseValidationMatcher
+        def initialize(attributes)
+          super(attributes, :numericality)
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          matched_validator = class_name.validators.detect do |validator|
+            validator.kind == type &&
+              validator.attributes.sort == attributes.sort &&
+              validator.options.sort == options.sort
+          end
+
+          true if matched_validator
+        end
+
+        def description
+          "require #{ attributes.join(', ') } to be numeric"
+        end
+
+        def with_message(message)
+          options[:message] = message
+          self
+        end
+
+        def if(symbol_name)
+          options[:if] = symbol_name
+          self
+        end
+
+        def unless(symbol_name)
+          options[:unless] = symbol_name
+          self
+        end
+
+        def on(context)
+          options[:on] = context
+          self
+        end
+
+        def allow_nil(value = true)
+          options[:allow_nil] = value
+          self
+        end
+
+        def allow_blank(value = true)
+          options[:allow_blank] = value
+          self
+        end
+
+        def strict(value)
+          options[:strict] = value
+          self
+        end
+
+        def only_integer(value = true)
+          options[:only_integer] = value
+          self
+        end
+
+        def is_greater_than(value)
+          options[:greater_than] = value
+          self
+        end
+
+        def is_greater_than_or_equal_to(value)
+          options[:greater_than_or_equal_to] = value
+          self
+        end
+
+        def is_equal_to(value)
+          options[:equal_to] = value
+          self
+        end
+
+        def is_less_than(value)
+          options[:less_than] = value
+          self
+        end
+
+        def is_less_than_or_equal_to(value)
+          options[:less_than_or_equal_to] = value
+          self
+        end
+
+        def is_other_than(value)
+          options[:other_than] = value
+          self
+        end
+
+        def even(value = true)
+          options[:even] = value
+          self
+        end
+
+        def odd(value = true)
+          options[:odd] = value
+          self
+        end
+      end
+    end
+  end
+end

data/lib/matchers/validations/presence_of.rb

@@ -0,0 +1,66 @@
+module Easy
+  module Matchers
+    module Validations
+      def validate_presence_of(*attributes)
+        ValidatePresenceOfMatcher.new(attributes)
+      end
+
+      class ValidatePresenceOfMatcher < BaseValidationMatcher
+        def initialize(attributes)
+          super(attributes, :presence)
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          matched_validator = class_name.validators.detect do |validator|
+            validator.kind == type &&
+              validator.attributes.sort == attributes.sort &&
+              validator.options.sort == options.sort
+          end
+
+          true if matched_validator
+        end
+
+        def description
+          "require #{ attributes.join(', ') } to be set"
+        end
+
+        def with_message(message)
+          options[:message] = message
+          self
+        end
+
+        def if(symbol_name)
+          options[:if] = symbol_name
+          self
+        end
+
+        def unless(symbol_name)
+          options[:unless] = symbol_name
+          self
+        end
+
+        def on(context)
+          options[:on] = context
+          self
+        end
+
+        def allow_nil(value = true)
+          options[:allow_nil] = value
+          self
+        end
+
+        def allow_blank(value = true)
+          options[:allow_blank] = value
+          self
+        end
+
+        def strict(value)
+          options[:strict] = value
+          self
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: easy-matchers
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Igor Zubkov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: Extra RSpec matches for Rails (ActiveModel::Validators, ActiveModel::Model)
+email:
+- igor.zubkov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codeclimate.yml"
+- ".rubocop.yml"
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- easy-matchers.gemspec
+- lib/easy-matchers.rb
+- lib/easy/version.rb
+- lib/matchers/validations.rb
+- lib/matchers/validations/absence_of.rb
+- lib/matchers/validations/acceptance_of.rb
+- lib/matchers/validations/base_validation_matcher.rb
+- lib/matchers/validations/confirmation_of.rb
+- lib/matchers/validations/length_of.rb
+- lib/matchers/validations/numericality_of.rb
+- lib/matchers/validations/presence_of.rb
+- mlsdev-logo.png
+homepage: https://github.com/MLSDev/easy-matchers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.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: Extra RSpec matchers for Rails
+test_files: []