pager-resource_controller 1.0.20080513

data/test/vendor/plugins/shoulda/README

@@ -0,0 +1,123 @@
+= Shoulda - Making tests easy on the fingers and eyes
+
+Shoulda makes it easy to write elegant, understandable, and maintainable tests.  Shoulda consists of test macros, assertions, and helpers added on to the Test::Unit framework.  It's fully compatible with your existing tests, and requires no retooling to use.
+
+Helpers:: #context and #should give you rSpec like test blocks.  
+          In addition, you get nested contexts and a much more readable syntax.
+Macros:: Generate hundreds of lines of Controller and ActiveRecord tests with these powerful macros.  
+         They get you started quickly, and can help you ensure that your application is conforming to best practices.
+Assertions:: Many common rails testing idioms have been distilled into a set of useful assertions. 
+
+= Usage
+
+=== Context Helpers (ThoughtBot::Shoulda::Context)
+
+Stop killing your fingers with all of those underscores...  Name your tests with plain sentences!
+
+  class UserTest << Test::Unit::TestCase 
+    context "A User instance" do
+      setup do
+        @user = User.find(:first)
+      end
+    
+      should "return its full name"
+        assert_equal 'John Doe', @user.full_name
+      end
+    
+      context "with a profile" do
+        setup do
+          @user.profile = Profile.find(:first)
+        end
+      
+        should "return true when sent #has_profile?"
+          assert @user.has_profile?
+        end
+      end
+    end
+  end
+
+Produces the following test methods:
+
+  "test: A User instance should return its full name."
+  "test: A User instance with a profile should return true when sent #has_profile?."
+
+So readable!
+
+=== ActiveRecord Tests (ThoughtBot::Shoulda::ActiveRecord)
+
+Quick macro tests for your ActiveRecord associations and validations:
+
+  class PostTest < Test::Unit::TestCase
+    load_all_fixtures
+
+    should_belong_to :user
+    should_have_many :tags, :through => :taggings
+
+    should_require_unique_attributes :title
+    should_require_attributes :body, :message => /wtf/
+    should_require_attributes :title
+    should_only_allow_numeric_values_for :user_id
+  end
+
+  class UserTest < Test::Unit::TestCase
+    load_all_fixtures
+
+    should_have_many :posts
+
+    should_not_allow_values_for :email, "blah", "b lah"
+    should_allow_values_for :email, "a@b.com", "asdf@asdf.com"
+    should_ensure_length_in_range :email, 1..100
+    should_ensure_value_in_range :age, 1..100
+    should_protect_attributes :password
+  end
+
+Makes TDD so much easier.
+
+=== Controller Tests (ThoughtBot::Shoulda::Controller::ClassMethods)
+
+Macros to test the most common controller patterns...
+
+  context "on GET to :show for first record" do
+    setup do
+      get :show, :id => 1
+    end
+  
+    should_assign_to :user
+    should_respond_with :success
+    should_render_template :show
+    should_not_set_the_flash
+
+    should "do something else really cool" do
+      assert_equal 1, assigns(:user).id
+    end
+  end
+
+Test entire controllers in a few lines...
+
+  class PostsControllerTest < Test::Unit::TestCase
+    should_be_restful do |resource|
+      resource.parent = :user
+
+      resource.create.params = { :title => "first post", :body => 'blah blah blah'}
+      resource.update.params = { :title => "changed" }
+    end
+  end
+
+should_be_restful generates 40 tests on the fly, for both html and xml requests.
+
+=== Helpful Assertions (ThoughtBot::Shoulda::General)
+
+More to come here, but have fun with what's there.
+
+  load_all_fixtures
+  assert_same_elements([:a, :b, :c], [:c, :a, :b])
+  assert_contains(['a', '1'], /\d/)
+  assert_contains(['a', '1'], 'a')
+
+= Credits
+
+Shoulda is maintained by {Tammer Saleh}[mailto:tsaleh@thoughtbot.com], and is funded by Thoughtbot[http://www.thoughtbot.com], inc.
+
+= License
+
+Shoulda is Copyright © 2006-2007 Tammer Saleh, Thoughtbot. It is free software, and may be redistributed under the terms specified in the README file of the Ruby distribution.

data/test/vendor/plugins/shoulda/Rakefile

@@ -0,0 +1,29 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+#require 'tasks/list_tests.rake'
+
+# Test::Unit::UI::VERBOSE
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/{unit,functional,other}/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Shoulda -- Making tests easy on the fingers and eyes"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README', 'lib/**/*.rb')
+}
+
+desc 'Update documentation on website'
+task :sync_docs => 'rdoc' do
+  `rsync -ave ssh doc/ dev@dev.thoughtbot.com:/home/dev/www/dev.thoughtbot.com/shoulda`
+end
+
+desc 'Default: run tests.'
+task :default => ['test']

data/test/vendor/plugins/shoulda/bin/convert_to_should_syntax

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+
+def usage(msg = nil)
+  puts "Error: #{msg}" if msg
+  puts if msg
+  puts "Usage: #{File.basename(__FILE__)} normal_test_file.rb"
+  puts
+  puts "Will convert an existing test file with names like "
+  puts
+  puts "  def test_should_do_stuff"
+  puts "    ..."
+  puts "  end"
+  puts
+  puts "to one using the new syntax: "
+  puts
+  puts "  should \"be super cool\" do"
+  puts "    ..."
+  puts "  end"
+  puts
+  puts "A copy of the old file will be left under /tmp/ in case this script just seriously screws up"
+  puts
+  exit (msg ? 2 : 0)
+end
+
+usage("Wrong number of arguments.") unless ARGV.size == 1
+usage("This system doesn't have a /tmp directory.  wtf?") unless File.directory?('/tmp')
+
+file = ARGV.shift
+tmpfile = "/tmp/#{File.basename(file)}"
+usage("File '#{file}' doesn't exist") unless File.exists?(file)
+
+FileUtils.cp(file, tmpfile)
+contents = File.read(tmpfile)
+contents.gsub!(/def test_should_(.*)\s*$/, 'should "\1" do')
+contents.gsub!(/def test_(.*)\s*$/, 'should "RENAME ME: test \1" do')
+contents.gsub!(/should ".*" do$/) {|line| line.tr!('_', ' ')}
+File.open(file, 'w') { |f| f.write(contents) }
+
+puts "File '#{file}' has been converted to 'should' syntax.  Old version has been stored in '#{tmpfile}'"

data/test/vendor/plugins/shoulda/init.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'active_support'
+require 'shoulda'

data/test/vendor/plugins/shoulda/lib/shoulda.rb

@@ -0,0 +1,47 @@
+require 'yaml'
+require 'shoulda/private_helpers'
+require 'shoulda/general'
+require 'shoulda/context'
+require 'shoulda/active_record_helpers'
+require 'shoulda/controller_tests/controller_tests.rb'
+
+shoulda_options = {}
+
+possible_config_paths = []
+possible_config_paths << File.join(ENV["HOME"], ".shoulda.conf")       if ENV["HOME"]
+possible_config_paths << "shoulda.conf"
+possible_config_paths << File.join("test", "shoulda.conf")
+possible_config_paths << File.join(RAILS_ROOT, "test", "shoulda.conf") if defined?(RAILS_ROOT) 
+
+possible_config_paths.each do |config_file|
+  if File.exists? config_file
+    shoulda_options = YAML.load_file(config_file).symbolize_keys
+    break
+  end
+end
+
+require 'shoulda/color' if shoulda_options[:color]
+
+module Test # :nodoc: all
+  module Unit 
+    class TestCase
+
+      include ThoughtBot::Shoulda::Controller
+      include ThoughtBot::Shoulda::General
+
+      class << self
+        include ThoughtBot::Shoulda::Context
+        include ThoughtBot::Shoulda::ActiveRecord
+        # include ThoughtBot::Shoulda::General::ClassMethods    
+      end
+    end
+  end
+end
+
+module ActionController #:nodoc: all
+  module Integration
+    class Session 
+      include ThoughtBot::Shoulda::General
+    end
+  end
+end

data/test/vendor/plugins/shoulda/lib/shoulda/active_record_helpers.rb

@@ -0,0 +1,338 @@
+module ThoughtBot # :nodoc:
+  module Shoulda # :nodoc:
+    # = Macro test helpers for your active record models
+    #
+    # These helpers will test most of the validations and associations for your ActiveRecord models.
+    #
+    #   class UserTest < Test::Unit::TestCase
+    #     should_require_attributes :name, :phone_number
+    #     should_not_allow_values_for :phone_number, "abcd", "1234"
+    #     should_allow_values_for :phone_number, "(123) 456-7890"
+    #     
+    #     should_protect_attributes :password
+    #     
+    #     should_have_one :profile
+    #     should_have_many :dogs
+    #     should_have_many :messes, :through => :dogs
+    #     should_belong_to :lover
+    #   end
+    #
+    # For all of these helpers, the last parameter may be a hash of options.
+    #
+    module ActiveRecord
+      # Ensures that the model cannot be saved if one of the attributes listed is not present.
+      # Requires an existing record.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/blank/</tt>
+      #
+      # Example:
+      #   should_require_attributes :name, :phone_number
+      def should_require_attributes(*attributes)
+        message = get_options!(attributes, :message)
+        message ||= /blank/
+        klass = model_class
+        
+        attributes.each do |attribute|
+          should "require #{attribute} to be set" do
+            object = klass.new
+            assert !object.valid?, "#{klass.name} does not require #{attribute}."
+            assert object.errors.on(attribute), "#{klass.name} does not require #{attribute}."
+            assert_contains(object.errors.on(attribute), message)
+          end
+        end
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not unique.
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/taken/</tt>
+      #
+      # Example:
+      #   should_require_unique_attributes :keyword, :username
+      def should_require_unique_attributes(*attributes)
+        message, scope = get_options!(attributes, :message, :scoped_to)
+        message ||= /taken/
+        
+        klass = model_class
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+          should "require unique value for #{attribute}#{" scoped to #{scope}" if scope}" do
+            assert existing = klass.find(:first), "Can't find first #{klass}"
+            object = klass.new
+            
+            object.send(:"#{attribute}=", existing.send(attribute))
+            if scope
+              assert_respond_to object, :"#{scope}=", "#{klass.name} doesn't seem to have a #{scope} attribute."
+              object.send(:"#{scope}=", existing.send(scope))
+            end
+            
+            assert !object.valid?, "#{klass.name} does not require a unique value for #{attribute}."
+            assert object.errors.on(attribute), "#{klass.name} does not require a unique value for #{attribute}."
+            
+            assert_contains(object.errors.on(attribute), message)
+            
+            if scope
+              # Now test that the object is valid when changing the scoped attribute
+              # TODO:  actually find all values for scope and create a unique one.
+              object.send(:"#{scope}=", existing.send(scope).nil? ? 1 : existing.send(scope).next)
+              object.errors.clear
+              object.valid?
+              assert_does_not_contain(object.errors.on(attribute), message, 
+                                      "after :#{scope} set to #{object.send(scope.to_sym)}")
+            end
+          end
+        end
+      end
+
+      # Ensures that the attribute cannot be set on update
+      # Requires an existing record
+      #
+      #   should_protect_attributes :password, :admin_flag
+      def should_protect_attributes(*attributes)
+        get_options!(attributes)
+        klass = model_class
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+          should "not allow #{attribute} to be changed by update" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            value = object[attribute]
+            # TODO:  1 may not be a valid value for the attribute (due to validations)
+            assert object.update_attributes({ attribute => 1 }),
+                   "Cannot update #{klass} with { :#{attribute} => 1 }, #{object.errors.full_messages.to_sentence}"
+            assert object.valid?, "#{klass} isn't valid after changing #{attribute}"
+            assert_equal value, object[attribute], "Was able to change #{klass}##{attribute}"
+          end
+        end
+      end
+  
+      # Ensures that the attribute cannot be set to the given values
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/invalid/</tt>
+      #
+      # Example:
+      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
+      def should_not_allow_values_for(attribute, *bad_values)
+        message = get_options!(bad_values, :message)
+        message ||= /invalid/
+        klass = model_class
+        bad_values.each do |v|
+          should "not allow #{attribute} to be set to \"#{v}\"" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", v)
+            assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
+            assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
+            assert_contains(object.errors.on(attribute), message, "when set to \"#{v}\"")
+          end
+        end
+      end
+  
+      # Ensures that the attribute can be set to the given values.
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/invalid/</tt>
+      #
+      # Example:
+      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
+      def should_allow_values_for(attribute, *good_values)
+        message = get_options!(good_values, :message)
+        message ||= /invalid/
+        klass = model_class
+        good_values.each do |v|
+          should "allow #{attribute} to be set to \"#{v}\"" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", v)
+            object.save
+            assert_does_not_contain(object.errors.on(attribute), message, "when set to \"#{v}\"")
+          end
+        end
+      end
+
+      # Ensures that the length of the attribute is in the given range
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/short/</tt>
+      # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/long/</tt>
+      #
+      # Example:
+      #   should_ensure_length_in_range :password, (6..20)
+      def should_ensure_length_in_range(attribute, range, opts = {})
+        short_message, long_message = get_options!([opts], :short_message, :long_message)
+        short_message ||= /short/
+        long_message  ||= /long/
+        
+        klass = model_class
+        min_length = range.first
+        max_length = range.last
+
+        if min_length > 0
+          min_value = "x" * (min_length - 1)
+          should "not allow #{attribute} to be less than #{min_length} chars long" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send("#{attribute}=", min_value)
+            assert !object.save, "Saved #{klass} with #{attribute} set to \"#{min_value}\""
+            assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{min_value}\""
+            assert_contains(object.errors.on(attribute), short_message, "when set to \"#{min_value}\"")
+          end
+        end
+    
+        max_value = "x" * (max_length + 1)
+        should "not allow #{attribute} to be more than #{max_length} chars long" do
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", max_value)
+          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{max_value}\""
+          assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{max_value}\""
+          assert_contains(object.errors.on(attribute), long_message, "when set to \"#{max_value}\"")
+        end
+      end    
+
+      # Ensure that the attribute is in the range specified
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/included/</tt>
+      # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/included/</tt>
+      #
+      # Example:
+      #   should_ensure_value_in_range :age, (0..100)
+      def should_ensure_value_in_range(attribute, range, opts = {})
+        low_message, high_message = get_options!([opts], :low_message, :high_message)
+        low_message  ||= /included/
+        high_message ||= /included/
+        
+        klass = model_class
+        min   = range.first
+        max   = range.last
+
+        should "not allow #{attribute} to be less than #{min}" do
+          v = min - 1
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", v)
+          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
+          assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
+          assert_contains(object.errors.on(attribute), low_message, "when set to \"#{v}\"")
+        end
+    
+        should "not allow #{attribute} to be more than #{max}" do
+          v = max + 1
+          assert object = klass.find(:first), "Can't find first #{klass}"
+          object.send("#{attribute}=", v)
+          assert !object.save, "Saved #{klass} with #{attribute} set to \"#{v}\""
+          assert object.errors.on(attribute), "There are no errors set on #{attribute} after being set to \"#{v}\""
+          assert_contains(object.errors.on(attribute), high_message, "when set to \"#{v}\"")
+        end
+      end    
+      
+      # Ensure that the attribute is numeric
+      # Requires an existing record
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.  
+      #   Regexp or string.  Default = <tt>/number/</tt>
+      #
+      # Example:
+      #   should_only_allow_numeric_values_for :age
+      def should_only_allow_numeric_values_for(*attributes)
+        message = get_options!(attributes, :message)
+        message ||= /number/
+        klass = model_class
+        attributes.each do |attribute|
+          attribute = attribute.to_sym
+          should "only allow numeric values for #{attribute}" do
+            assert object = klass.find(:first), "Can't find first #{klass}"
+            object.send(:"#{attribute}=", "abcd")
+            assert !object.valid?, "Instance is still valid"
+            assert_contains(object.errors.on(attribute), message)
+          end
+        end
+      end
+
+      # Ensures that the has_many relationship exists.
+      # 
+      # Options:
+      # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
+      #
+      # Example:
+      #   should_have_many :friends
+      #   should_have_many :enemies, :through => :friends
+      def should_have_many(*associations)
+        through = get_options!(associations, :through)
+        klass = model_class
+        associations.each do |association|
+          should "have many #{association}#{" through #{through}" if through}" do
+            reflection = klass.reflect_on_association(association)
+            assert reflection, "#{klass.name} does not have any relationship to #{association}"
+            assert_equal :has_many, reflection.macro
+            if through
+              through_reflection = klass.reflect_on_association(through)
+              assert through_reflection, "#{klass.name} does not have any relationship to #{through}"
+              assert_equal(through, reflection.options[:through])
+            end
+          end
+        end
+      end
+
+      # Ensures that the has_and_belongs_to_many relationship exists.  
+      #
+      #   should_have_and_belong_to_many :posts, :cars
+      def should_have_and_belong_to_many(*associations)
+        get_options!(associations)
+        klass = model_class
+        associations.each do |association|
+          should "should have and belong to many #{association}" do
+            assert klass.reflect_on_association(association), "#{klass.name} does not have any relationship to #{association}"
+            assert_equal :has_and_belongs_to_many, klass.reflect_on_association(association).macro
+          end
+        end
+      end
+  
+      # Ensure that the has_one relationship exists.
+      #
+      #   should_have_one :god # unless hindu
+      def should_have_one(*associations)
+        get_options!(associations)
+        klass = model_class
+        associations.each do |association|
+          should "have one #{association}" do
+            assert klass.reflect_on_association(association), "#{klass.name} does not have any relationship to #{association}"
+            assert_equal :has_one, klass.reflect_on_association(association).macro
+          end
+        end
+      end
+  
+      # Ensure that the belongs_to relationship exists.
+      #
+      #   should_belong_to :parent
+      def should_belong_to(*associations)
+        get_options!(associations)
+        klass = model_class
+        associations.each do |association|
+          should "belong_to #{association}" do
+            reflection = klass.reflect_on_association(association)
+            assert reflection, "#{klass.name} does not have any relationship to #{association}"
+            assert_equal :belongs_to, reflection.macro
+            fk = reflection.options[:foreign_key] || "#{association}_id"
+            assert klass.column_names.include?(fk), "#{klass.name} does not have a #{fk} foreign key."
+          end
+        end
+      end
+      
+      private
+      
+      include ThoughtBot::Shoulda::Private
+    end
+  end
+end