schlick-active-matchers 0.3.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Pat Allan & James Healy
+
+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/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+
+require 'active-matchers'
+
+GEM = "active-matchers"
+GEM_VERSION = ActiveMatchers::Version::STRING
+AUTHOR = "Pat Allan"
+EMAIL = "pat@freelancing-gods.com"
+HOMEPAGE = "http://am.freelancing-gods.com"
+SUMMARY = "Helpful rspec matchers for testing validations and associations."
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.rubyforge_project = GEM
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.textile','LICENSE']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  s.add_dependency 'activerecord'
+  
+  s.require_path = 'lib'
+  s.files = %w(README.textile LICENSE Rakefile init.rb) + Dir.glob("{lib,specs}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end

data/init.rb

@@ -0,0 +1 @@
+require "active-matchers"

data/lib/active-matchers.rb

@@ -0,0 +1,20 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "active_record"
+require "active-matchers/assoc_reflection_methods"
+require "active-matchers/matchers"
+
+ActiveRecord::Reflection::AssociationReflection.send(:include,
+  ActiveMatchers::AssociationReflectionMethods)
+
+module ActiveMatchers
+  module Version #:nodoc:
+    MAJOR = 0
+    MINOR = 3
+    TINY  = 1
+    MICRO = 1
+    
+    STRING = [MAJOR, MINOR, TINY, MICRO].join('.').freeze
+  end
+end

data/lib/active-matchers/assoc_reflection_methods.rb

@@ -0,0 +1,10 @@
+module ActiveMatchers
+  module AssociationReflectionMethods
+    def to_hash
+      {
+        :macro => @macro,
+        :options => @options
+      }
+    end
+  end
+end

data/lib/active-matchers/matchers.rb

@@ -0,0 +1,113 @@
+require "active-matchers/matchers/association_matcher"
+require "active-matchers/matchers/validation_matcher"
+require "active-matchers/matchers/response_matchers"
+
+module ActiveMatchers
+  module Matchers
+    # Test validates_presence_of :name
+    #   Model.should need(:name).using(@valid_attributes)
+    #
+    # Test validates_uniqueness_of :name
+    #   Model.should need(:name).to_be_unique.using(@valid_attributes)
+    #
+    # Test presence of at least one field being required
+    #   Model.should need.one_of(:first_name, :last_name).using(@valid_attributes)
+    # 
+    def need(*fields)
+      ValidationMatcher.new(:require, *fields).using(@base_attributes)
+    end
+    
+    alias_method :mandate, :need
+    
+    # Test validates_length_of :name matches database field length
+    #   Model.should limit_length_of(:name).using(@valid_attributes)
+    #
+    # Test validates_length_of :name, :maximum => 255
+    #   Model.should limit_length_of(:name).to(255).using(@valid_attributes)
+    #
+    def limit_length_of(*fields)
+      ValidationMatcher.new(:length, *fields).using(@base_attributes)
+    end
+    
+    # Test belongs_to :parent
+    #   Model.should belong_to(:parent)
+    #
+    # Test belongs_to :parent, :class_name => "CustomClass", :foreign_key => "some_id"
+    #   Model.should belong_to(:parent).with_options(
+    #     :class_name => "CustomClass", :foreign_key => "some_id")
+    #
+    def belong_to(*fields)
+      AssociationMatcher.new(:belongs_to, *fields)
+    end
+    
+    # Test has_many :items
+    #   Model.should have_many(:items)
+    #
+    # Test has_many :items, :class_name => "CustomClass", :foreign_key => "some_id"
+    #   Model.should have_many(:items).with_options(
+    #     :class_name => "CustomClass", :foreign_key => "some_id")
+    #
+    def have_many(*fields)
+      AssociationMatcher.new(:has_many, *fields)
+    end
+    
+    # Test has_one :item
+    #   Model.should have_one(:item)
+    #
+    # Test has_one :item, :class_name => "CustomClass", :foreign_key => "some_id"
+    #   Model.should have_one(:item).with_options(
+    #     :class_name => "CustomClass", :foreign_key => "some_id")
+    #
+    def have_one(*fields)
+      AssociationMatcher.new(:has_one, *fields)
+    end
+    
+    # Test has_and_belongs_to_many :items
+    #   Model.should have_and_belong_to_many(:items)
+    #
+    # Test has_and_belongs_to_many :items, :class_name => "CustomClass"
+    #   Model.should have_one(:item).with_options(
+    #     :class_name => "CustomClass")
+    #
+    def have_and_belong_to_many(*fields)
+      AssociationMatcher.new(:has_and_belongs_to_many, *fields)
+    end
+    
+    # Useful for multiple requests using the same base attributes
+    #
+    #   using(@valid_attributes) do
+    #     Model.should need(:name)
+    #     Model.should limit_length_of(:name).to(100)
+    #   end
+    #
+    def using(base_attributes={}, &block)
+      @base_attributes = base_attributes
+      yield
+      @base_attributes= {}
+    end
+    
+    #
+    def succeed
+      ResponseMatchers::SuccessMatcher.new(@controller)
+    end
+    
+    # Use to confirm whether a response is/is not a 404
+    #
+    #   response.should be_a_404
+    #
+    def be_a_404
+      ResponseMatchers::NotFoundMatcher.new
+    end
+    
+    # Use to confirm whether a response redirected
+    #
+    #   response.should redirect
+    #   response.should_not redirect
+    #   response.should redirect.to("url")
+    #   response.should_not redirect.to("url")
+    #
+    def redirect
+      ResponseMatchers::RedirectMatcher.new
+    end
+  end
+end

data/lib/active-matchers/matchers/association_matcher.rb

@@ -0,0 +1,57 @@
+module ActiveMatchers
+  module Matchers
+    class AssociationMatcher
+      def initialize(macro, *attributes)
+        @macro = macro
+        @attributes = attributes
+      end
+      
+      def matches?(model)
+        @model = model
+        confirm_association
+      end
+      
+      def failure_message
+        "Error: #{@error}"
+      end
+      
+      def with_options(options)
+        @options = options
+        self
+      end
+      
+      def through(assoc)
+        @options ||= {}
+        @options[:through] = assoc
+        self
+      end
+      
+      private
+      
+      def confirm_association
+        return if @attributes.empty?
+        
+        @options ||= {}
+        @options[:extend] ||= []
+  
+        @attributes.each do |attribute|
+          assoc = @model.reflect_on_association(attribute)
+          if assoc.nil?
+            @error = "#{@model.name} is missing the association #{attribute}"
+            return false
+          end
+          if assoc.to_hash[:macro] != @macro
+            @error = "#{@model.name}.#{attribute} should be #{@macro}, but is #{assoc.to_hash[:macro]}"
+            return false
+          end
+          if assoc.to_hash[:options] != @options
+            @error = "#{@model.name}.#{attribute} should have options #{@options.inspect}, but has options #{assoc.to_hash[:options].inspect}"
+            return false
+          end
+        end
+        
+        true
+      end
+    end
+  end
+end

data/lib/active-matchers/matchers/response_matchers.rb

@@ -0,0 +1,105 @@
+module ActiveMatchers
+  module Matchers
+    module ResponseMatchers
+      class SuccessMatcher
+        def initialize(controller)
+          @controller = controller
+        end
+        
+        def matches?(response)
+          @response = response
+          if @template.nil?
+            @response.success?
+          else
+            @response.success? && full_path(@template) == full_path(@response.rendered_file)
+          end
+        end
+        
+        def with_template(template)
+          @template = template
+          self
+        end
+        
+        def failure_message
+          if @template.nil? || !@response.success?
+            "Response should have succeeded, but returned with code #{@response.response_code}."
+          else
+            "Response should have rendered #{@template}, but instead rendered #{@response.rendered_file}."
+          end
+        end
+        
+        def negative_failure_message
+          if @response.success?
+            "Response should not have succeeded, but did."
+          else
+            "Response should not have rendered #{@template}, but did."
+          end
+        end
+        
+        private
+        
+        def full_path(path)
+          return nil if path.nil?
+          path.include?('/') ? path : "#{@controller.class.to_s.underscore.gsub('_controller','')}/#{path}"
+        end
+      end
+      
+      class NotFoundMatcher
+        def matches?(response)
+          @response = response
+          response.response_code == 404
+        end
+        
+        def failure_message
+          "Response should have had a status of 404 Not Found, but had #{@response.response_code}."
+        end
+        
+        def negative_failure_message
+          "Response should not have a status of 404 Not Found, but does."
+        end
+      end
+      
+      class RedirectMatcher
+        def initialize
+          @action = :what
+        end
+        
+        def matches?(response)
+          @response = response
+          case @action
+          when :what
+            @response.redirect?
+          when :where
+            @response.redirect? && @response.redirect_url == @url
+          else
+            false
+          end
+        end
+        
+        def to(url)
+          @action = :where
+          @url = url
+          self
+        end
+        
+        def failure_message
+          case @action
+          when :what
+            "Response should have redirected, but didn't."
+          when :where
+            "Response should have redirected to #{@url}, but didn't."
+          end
+        end
+        
+        def negative_failure_message
+          case @action
+          when :what
+            "Response shouldn't have redirected, but did."
+          when :where
+            "Response shouldn't have redirected to #{@url}, but did."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active-matchers/matchers/validation_matcher.rb

@@ -0,0 +1,240 @@
+module ActiveMatchers
+  module Matchers
+    class ValidationMatcher
+      def initialize(type, *attributes)
+        @type = type
+        @attributes = attributes
+        @create_action = 'create'
+        @new_action = 'new'
+      end
+      
+      def matches?(model)
+        @model = model
+        case @type
+        when :require
+          confirm_required(&@if)
+        when :unique
+          confirm_unique
+        when :one_of_many
+          confirm_one_of_many
+        when :length
+          confirm_length
+        when :numeric
+          confirm_numericality
+        when :unsigned
+          confirm_zero_or_greater
+        else
+          false
+        end
+      end
+      
+      def failure_message
+        "Error: #{@error}"
+      end
+      
+      def to_be_unique
+        @type = :unique
+        self
+      end
+      
+      def to_be_numeric
+        @type = :numeric
+        self
+      end
+      
+      def to_be_unsigned
+        @type = :unsigned
+        self
+      end
+      
+      def using(attributes={})
+        @base_attributes = attributes
+        self
+      end
+      
+      def if(&block)
+        @if = block
+        self
+      end
+      
+      def one_of(*attributes)
+        @attributes = attributes
+        @type = :one_of_many
+        self
+      end
+      
+      def to(upper_limit)
+        @upper_limit = upper_limit
+        self
+      end
+      
+      def from(lower_limit)
+        @lower_limit = lower_limit
+        self
+      end
+      
+      # Override the assumed default 'create' action and allow another one to be used.
+      # This makes it possible to use an 'unsafe' create to bypass attr_accessible and friends.
+      def with_create(action)
+        @create_action = action
+        self
+      end
+
+      # Override the assumed default 'new' action and allow another one to be used.
+      # This makes it possible to use an 'unsafe' new to bypass attr_accessible and friends.
+      def with_new(action)
+        @new_action = action
+        self
+      end
+      
+      private
+      
+      def confirm_required
+        return true if @attributes.empty?
+
+        @attributes.each do |attribute|
+          obj = @model.send @new_action, @base_attributes.except(*attribute)
+          yield obj if block_given?
+          
+          if obj.valid?
+            @error = "#{@model.name}.valid? should be false without #{attribute}, but returned true"
+            return false
+          end
+          if obj.errors.on(attribute).empty?
+            @error = "#{@model.name} should have errors on #{attribute} when #{attribute} is missing"
+            return false
+          end
+          obj.send "#{attribute.to_s}=", @base_attributes[attribute]
+          unless obj.valid?
+            @error = "#{@model.name} should be valid when #{attribute} is supplied"
+            return false
+          end
+        end
+        
+        true
+      end
+            
+      def confirm_unique
+        return true if @attributes.empty?
+
+        # Create first
+        @model.send @create_action, @base_attributes
+        # Create second, which will be invalid because unique values
+        # are duplicated
+        obj = @model.send @new_action, @base_attributes
+        if obj.valid?
+          @error = "#{@model.name} should not be valid when it is a duplicate"
+          return false 
+        end
+        # Change the values of the unique attributes to remove collisions
+        @attributes.each do |attribute|
+          if obj.errors.on(attribute).empty?
+            @error = "#{@model.name} should have a value collision for #{attribute}"
+            return false 
+          end
+          obj.send "#{attribute.to_s}=", "#{@base_attributes[attribute]} - Edit"
+        end
+        unless obj.valid?
+          @error = "#{@model.name} should be valid without duplicate values"
+          return false
+        end
+        true
+      end
+      
+      def confirm_one_of_many
+        return true if @attributes.empty?
+
+        obj = @model.send @new_action, @base_attributes.except(*@attributes)
+        return false if obj.valid?
+        @attributes.each do |attribute|
+          obj.send "#{attribute.to_s}=", @base_attributes[attribute]
+          return false unless obj.valid?
+          obj.send "#{attribute.to_s}=", nil
+          return false if obj.valid?
+        end
+        
+        true
+      end
+      
+      def confirm_length
+        return true if @attributes.empty?
+        
+        error_msgs = []
+        @lower_limit ||= 0
+        
+        @attributes.each do |attribute|
+          obj = @model.send @new_action, @base_attributes.except(attribute)
+          
+          if @lower_limit > 0
+            obj.send "#{attribute.to_s}=", 'a'*(@lower_limit)
+            error_msgs << "#{@model.name}.valid? should be true when #{attribute} has a length of #{@lower_limit}, but returned false" unless obj.valid?
+          
+            obj.send "#{attribute.to_s}=", 'a'*(@lower_limit-1)
+            error_msgs << "#{@model.name}.valid? should be false when #{attribute} has a length less than #{@lower_limit}, but returned true" if obj.valid?
+          end
+          
+          @upper_limit ||= @model.columns_hash[attribute.to_s].limit unless @lower_limit > 0
+          
+          if @upper_limit
+            obj.send "#{attribute.to_s}=", 'a'*(@upper_limit)
+            error_msgs << "#{@model.name}.valid? should be true when #{attribute} has a length of #{@upper_limit}, but returned false" unless obj.valid?
+      
+            obj.send "#{attribute.to_s}=", 'a'*(@upper_limit+1)
+            error_msgs << "#{@model.name}.valid? should be false when #{attribute} has a length greater than #{@upper_limit}, but returned true" if obj.valid?
+          end
+          
+          unless error_msgs.empty?
+            @error = "#{@model.name} " + error_msgs.join(' and ')
+            return false
+          end
+        end
+        
+        true
+      end
+      
+      def confirm_numericality
+        return true if @attributes.empty?
+        
+        obj = @model.send @new_action, @base_attributes
+        
+        @attributes.each do |attribute|
+          
+          unless obj.valid?
+            @error = "#{@model.name}.valid? should be true when #{attribute} is numeric, but returned false"
+            return false
+          end
+          
+          # Change the attribute to a string
+          obj.send "#{attribute.to_s}=", "String"
+          if obj.valid?
+            @error = "#{@model.name}.valid? should be false when #{attribute} is not numeric, but returned true"
+            return false
+          end
+          
+          obj.send "#{attribute.to_s}=", @base_attributes[attribute]
+        end
+        
+        true
+      end
+      
+      def confirm_zero_or_greater
+        return true if @attributes.empty?
+        
+        obj = @model.send @new_action, @base_attributes
+        
+        @attributes.each do |attribute|
+          obj.send("#{attribute.to_s}=",-1)
+          if obj.valid?
+            @error = "#{@model.name}.valid? should be false when #{attribute} is less than zero, but returned true"
+            return false
+          end
+          
+          obj.send "#{attribute.to_s}=", @base_attributes[attribute]
+        end
+        
+        true
+      end
+      
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: schlick-active-matchers
+version: !ruby/object:Gem::Version 
+  version: 0.3.1.1
+platform: ruby
+authors: 
+- Pat Allan
+autorequire: active-matchers
+bindir: bin
+cert_chain: []
+
+date: 2008-07-02 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Helpful rspec matchers for testing validations and associations.
+email: pat@freelancing-gods.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- README
+- LICENSE
+- Rakefile
+- init.rb
+- lib/active-matchers
+- lib/active-matchers/assoc_reflection_methods.rb
+- lib/active-matchers/matchers
+- lib/active-matchers/matchers/association_matcher.rb
+- lib/active-matchers/matchers/response_matchers.rb
+- lib/active-matchers/matchers/validation_matcher.rb
+- lib/active-matchers/matchers.rb
+- lib/active-matchers.rb
+has_rdoc: true
+homepage: http://am.freelancing-gods.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Helpful rspec matchers for testing validations and associations.
+test_files: []
+