filter_assertions 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle/
+log/*.log
+pkg/
+test/dummy/db/*.sqlite3
+test/dummy/log/*.log
+test/dummy/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in filter_assertions.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Daniel Pietzsch, Vít Krchov
+
+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,52 @@
+# filter_assertions gem for Rails 3
+
+This gem extends the class `ActiveSupport::TestCase` by adding assertions to test if before filters have been applied (via `before_filter` or `append_before_filter`) or skipped (via `skip_before_filter`).
+
+These assertions are added for use in your functional tests:
+
+ * `assert_before_filter`: use this to test your `before_filter` or `append_before_filter` statements.
+ * `assert_no_before_filter`: use this to test your `skip_before_filter` statements.
+ * `assert_forgery_protection`: use this to test your `protect_from_forgery` statements.
+
+## Installation
+
+Include the gem in your Gemfile:
+
+	gem "filter_assertions"
+
+## Examples
+
+	# Test if the before_filter :authenticate applies to all actions in the controller
+	assert_before_filter :authenticate
+
+	# Test if the filter only applies to actions 'index' and 'new'
+	assert_before_filter :authenticate, :only => [:index, :new]
+
+	# Test if the filter applies to all actions axcept 'index'
+	assert_before_filter :authenticate, :except => :index
+
+The `assert_no_before_filter` assertion takes the same options and the `assert_forgery_protection` *only takes the `:except` or `:only` options*.
+
+There are different ways to test for the same functionality:
+
+	# These two assertion are equivalent
+	assert_before_filter :authenticate, :except => :index
+	assert_no_before_filter :authenticate, :only => :index
+
+## How it works
+
+The assertions of this plugin do not test for functionality of your before\_filters. It looks for the specified filters in the controller's filter\_chain and checks if the filters are applied or skipped for the specified actions.
+That means you can even check for before\_filters when you usually skip them in your functional tests.
+
+## Why would I want to test for before_filters like that?
+
+It's usually a good idea to test your controllers *including* its before\_filters and create different tests for when a before_filter applies and for when it doesn't.
+But there might be cases when you can't do this easily. Maybe there's an external dependency a filter relies on - such as an external service or app for authentication for example. With this plugin, you could skip all before\_filters for your tests and still be able to test if they would normally apply (deployed on a server for example).
+
+However - as said before - this plugin does not test any functionality of the filters themselves. The assertions only check if the filters apply to all actions or a subset of actions of the controller you are testing.
+
+## Credits
+
+This gem is based on the plugin [filter_assertions](https://github.com/pie4dan/filter_assertions) created by Daniel Pietzsch.
+
+Copyright (c) 2011 Daniel Pietzsch and Vít Krchov, released under the MIT license

data/Rakefile

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+require 'rubygems'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'rake/rdoctask'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FilterAssertions'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/filter_assertions.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path('../lib/filter_assertions/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'filter_assertions'
+  s.version     = FilterAssertions::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = 'Gem adding assertions to test if before filters have been applied.'
+  s.description = <<-DESC
+    Gem extends the class ActiveSupport::TestCase by adding assertions to test if before filters have been applied (via before_filter or append_before_filter) or skipped (via skip_before_filter).
+  DESC
+  s.authors     = ['Daniel Pietzsch', 'Vít Krchov']
+  s.email       = 'vit.krchov@gmail.com'
+  s.homepage    = 'https://github.com/vita/filter_assertions'
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+
+  s.add_dependency 'bundler', '~> 1.0.0'
+  s.add_dependency 'rails', '>= 3.0.0'
+
+  s.add_development_dependency 'turn'
+  s.add_development_dependency 'shoulda'
+  s.add_development_dependency 'sqlite3-ruby'
+end

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/filter_assertions.rb

@@ -0,0 +1,7 @@
+require 'filter_assertions/assertions'
+
+# Extends the ActiveSupport::TestCase class.
+# Adds assertions to test if a before_filter is applied or skipped
+class ActiveSupport::TestCase
+  include FilterAssertions::Assertions
+end

data/lib/filter_assertions/assertions.rb

@@ -0,0 +1,130 @@
+# Assertions to test if a before_filter is applied or skipped
+module FilterAssertions
+  module Assertions
+    # This method is the matching assertion to the before_filter or append_before_filter methods
+    #
+    # Examples:
+    # - assert_before_filter :authenticate
+    # - assert_before_filter :authenticate, :only => [:index, :new]
+    # - assert_before_filter :authenticate, :except => :index
+    def assert_before_filter(before_filter_name, options = {})
+      filter = find_matching_before_filter(before_filter_name)
+
+      raise NameError, "Couldn't find filter '#{before_filter_name}'" if filter.nil?
+
+      if options.blank?
+        # When the filter's options are empty, it means the filter applies to all controller methods.
+        assert (filter.options[:only].blank? and filter.options[:except].blank?), "The filter #{before_filter_name} has only/except options and does not apply to all actions."
+      else
+        # The Array() cast makes sure that if you only enter one action without brackets
+        # (instead of listing multiple actions), that it's converted to an Array
+        # and can be processed with the code below
+        actions_only   = Array(options[:only])
+        actions_except = Array(options[:except])
+
+        raise ArgumentError, "Unrecognised options. Valid options: :only and :except" if actions_only.blank? && actions_except.blank?
+
+        assert_block "The filter '#{before_filter_name}' does NOT apply to all the actions specified." do
+          filter_only_applies_to_actions?(filter, actions_only)
+        end if actions_only.present?
+
+        assert_block "The filter '#{before_filter_name}' applies to more actions than specified." do
+          filter_is_excepted_from_actions?(filter, actions_except)
+        end if actions_except.present?
+      end
+    end
+
+    # This method is the matching assertion to the skip_before_filter method
+    #
+    # Examples:
+    # - assert_no_before_filter :authenticate
+    # - assert_no_before_filter :authenticate, :only => [:index, :new]
+    # - assert_no_before_filter :authenticate, :except => :index
+    def assert_no_before_filter(before_filter_name, options = {})
+      filter = find_matching_before_filter(before_filter_name)
+
+      if options.blank?
+        # if the options are blank no filter should have been found, because it is then skipped for all actions
+        assert filter.nil?, "The filter #{before_filter_name} has only/except options and is not skipped for all actions."
+      else
+        # The Array() cast makes sure that if you only enter one action without brackets
+        # (instead of listing multiple actions), that it's converted to an Array
+        # and can be processed with the code below
+        actions_only   = Array(options[:only])
+        actions_except = Array(options[:except])
+
+        raise ArgumentError, "Unrecognised options. Valid options are :only and :except" if actions_only.blank? && actions_except.blank?
+
+        assert_block "The filter '#{before_filter_name}' is NOT skipped for all the actions specified." do
+          filter_is_excepted_from_actions?(filter, actions_only)
+        end if actions_only.present?
+
+        assert_block "The filter '#{before_filter_name}' is skipped for more actions than specified." do
+          filter_only_applies_to_actions?(filter, actions_except)
+        end if actions_except.present?
+      end
+    end
+
+    # The protect_from_forgery method is just a wrapper for
+    # another before_filter. And so is this assertion method
+    # just a wrapper for the assert_before_filter method.
+    def assert_forgery_protection(options = {})
+      assert_before_filter(:verify_authenticity_token, options)
+    end
+
+    #########################
+    private
+    #########################
+
+    # Returns the ActiveSupport::Callbacks::Callback object matching before_filter_name or nil
+    def find_matching_before_filter(before_filter_name)
+      @controller._process_action_callbacks.each do |c|
+        return c if c.kind == :before and c.filter == before_filter_name
+      end
+
+      nil
+    end
+
+    def filter_only_applies_to_actions?(filter, actions)
+      all_actions_without_supplied_ones = get_all_controller_actions.reject { |action| actions.include?(action) }
+
+      filter_applies_to_all_actions?(filter, actions) && filter_is_skipped_for_all_actions?(filter, all_actions_without_supplied_ones)
+    end
+
+    def filter_is_excepted_from_actions?(filter, actions)
+      all_actions_without_supplied_ones = get_all_controller_actions.reject { |action| actions.include?(action) }
+
+      filter_is_skipped_for_all_actions?(filter, actions) && filter_applies_to_all_actions?(filter, all_actions_without_supplied_ones)
+    end
+
+    def filter_applies_to_all_actions?(filter, actions)
+      actions.all? { |action| before_filter_applied?(filter, action) }
+    end
+
+    def filter_is_skipped_for_all_actions?(filter, actions)
+      actions.all? { |action| !before_filter_applied?(filter, action) }
+    end
+
+    # Checks if the given filter is applied to the given action
+    def before_filter_applied?(filter, action)
+      return false if filter.nil? || action.nil?
+
+      # if it is a skip_before_filter
+      if filter.per_key and (filter.per_key[:if].present? or filter.per_key[:unless].present?)
+        action_name = action.to_s
+        return  eval(filter.per_key[:if].to_s) if filter.per_key[:if].present?
+        return  !eval(filter.per_key[:unless].to_s) if filter.per_key[:unless].present?
+      else
+        return true if filter.options.empty? # because then a normal filter would be applied to all actions
+        return !filter.options[:except].include?(action) if filter.options[:except].present?
+        return filter.options[:only].include?(action) if filter.options[:only].present?
+      end
+    end
+
+    # Gets all the actions of the tested controller
+    # Returns an Array of Symbols (the names of the actions)
+    def get_all_controller_actions
+      @controller.action_methods.map(&:to_sym)
+    end
+  end
+end

data/lib/filter_assertions/version.rb

@@ -0,0 +1,3 @@
+module FilterAssertions
+  VERSION = '0.1.0'
+end

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+require 'rake'
+
+Dummy::Application.load_tasks

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,21 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+
+  before_filter :authenticate
+  before_filter :find_news
+  before_filter :find_posts
+
+  private
+
+  def authenticate
+    # code ...
+  end
+
+  def find_news
+    # code ...
+  end
+
+  def find_posts
+    # code
+  end
+end

data/test/dummy/app/controllers/posts_controller.rb

@@ -0,0 +1,37 @@
+class PostsController < ApplicationController
+
+  skip_before_filter :authenticate, :only => [:index, :show]
+  before_filter :increment_counter, :only => [:show]
+  before_filter :find_top_posts
+  skip_before_filter :find_news
+  before_filter :find_post, :except => [:index]
+  skip_before_filter :find_posts, :except => [:index]
+
+  def index; end
+
+  def show; end
+
+  def new; end
+
+  def create; end
+
+  def edit; end
+
+  def update; end
+
+  def destroy; end
+
+  private
+
+  def increment_counter
+    # code ...
+  end
+
+  def find_top_posts
+    # code ...
+  end
+
+  def find_post
+    # code ...
+  end
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/helpers/posts_helper.rb

@@ -0,0 +1,2 @@
+module PostsHelper
+end

data/test/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag :all %>
+  <%= javascript_include_tag :defaults %>
+  <%= csrf_meta_tag %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/test/dummy/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run Dummy::Application

data/test/dummy/config/application.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../boot', __FILE__)
+
+require "active_model/railtie"
+require "active_record/railtie"
+require "action_controller/railtie"
+require "action_view/railtie"
+require "action_mailer/railtie"
+
+Bundler.require
+require "filter_assertions"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Custom directories with classes and modules you want to be autoloadable.
+    # config.autoload_paths += %W(#{config.root}/extras)
+
+    # Only load the plugins named here, in the order given (default is alphabetical).
+    # :all can be used as a placeholder for all plugins not explicitly named.
+    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+    # Activate observers that should always be running.
+    # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # JavaScript files you want as :defaults (application.js is always included).
+    # config.action_view.javascript_expansions[:defaults] = %w(jquery rails)
+
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+  end
+end