technicalpickles-shoulda 2.0.6 → 2.10.0

data/README.rdoc

@@ -2,19 +2,20 @@
 
 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.
+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.
+Matchers:: Rspec-compatible matchers providing the same tests as Shoulda macros.
 
 = Usage
 
-=== Context Helpers (ThoughtBot::Shoulda::Context)
+=== Context Helpers (Shoulda::Context)
 
 Stop killing your fingers with all of those underscores...  Name your tests with plain sentences!
 
-  class UserTest << Test::Unit::TestCase
+  class UserTest < Test::Unit::TestCase
     context "A User instance" do
       setup do
         @user = User.find(:first)
@@ -43,7 +44,7 @@ Produces the following test methods:
 
 So readable!
 
-=== ActiveRecord Tests (ThoughtBot::Shoulda::ActiveRecord::Macros)
+=== ActiveRecord Tests (Shoulda::ActiveRecord::Macros)
 
 Quick macro tests for your ActiveRecord associations and validations:
 
@@ -53,10 +54,10 @@ Quick macro tests for your ActiveRecord associations and validations:
     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
+    should_validate_uniqueness_of :title
+    should_validate_presence_of :body, :message => /wtf/
+    should_validate_presence_of :title
+    should_validate_numericality_of :user_id
   end
 
   class UserTest < Test::Unit::TestCase
@@ -66,12 +67,12 @@ Quick macro tests for your ActiveRecord associations and validations:
     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
+    should_not_allow_mass_assignment_of :password
   end
 
 Makes TDD so much easier.
 
-=== Controller Tests (ThoughtBot::Shoulda::Controller::Macros)
+=== Controller Tests (Shoulda::Controller::Macros)
 
 Macros to test the most common controller patterns...
 
@@ -90,7 +91,7 @@ Macros to test the most common controller patterns...
     end
   end
 
-=== Helpful Assertions (ThoughtBot::Shoulda::Assertions)
+=== Helpful Assertions (Shoulda::Assertions)
 
 More to come here, but have fun with what's there.
 
@@ -110,6 +111,55 @@ Any *.rb file under RAILS_ROOT/test/shoulda_macros/ or vendor/(plugins|gems)/gem
     end
   end
 
+= Rails Installation (Test::Unit)
+
+=== As a Gem
+
+Use this if you prefer to use versioned releases of shoulda.  Specify the gem dependency in your config/environment.rb file:
+
+  Rails::Initializer.run do |config|
+    config.gem "thoughtbot-shoulda", :lib => "shoulda", :source => "http://gems.github.com"
+  end
+
+Then:
+
+  $ rake gems:install
+  $ rake gems:unpack
+
+=== As a Plugin
+
+Use this if you prefer to use the edge version of shoulda:
+
+  $ script/plugin install git://github.com/thoughtbot/shoulda.git
+
+=== As a Plugin (using git submodules)
+
+Use this if you prefer the idea of being able to easily switch between using edge or a tagged version of shoulda:
+
+  $ git submodule add git://github.com/thoughtbot/shoulda.git vendor/plugins/shoulda
+
+= Rails Installation (RSpec)
+
+If you're using Shoulda with RSpec, we recommend that you add config.gem lines
+for RSpec and Shoulda in your config/environment/test.rb file, but do not ask
+Rails to load the RSpec and Shoulda libraries:
+
+  config.gem 'rspec', :lib => false
+  config.gem 'rspec-rails', :lib => false
+  config.gem 'thoughtbot-shoulda',
+             :lib => false,
+             :source => 'http://gems.github.com'
+
+Then require shoulda from your spec/spec_helper.rb file, before Spec::Runner is
+configured:
+
+  # requires for RSpec
+  require 'shoulda'
+  Spec::Runner.configure do |config|
+  # ...
+
+You should not need to require anything besides the top-level shoulda library.
+
 = Credits
 
 Shoulda is maintained by {Tammer Saleh}[mailto:tsaleh@thoughtbot.com], and is funded by Thoughtbot[http://www.thoughtbot.com], inc.

data/Rakefile

@@ -2,11 +2,13 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
-require 'lib/shoulda/context'
+
+$LOAD_PATH.unshift("lib")
+require 'shoulda'
 load 'tasks/shoulda.rake'
 
 # Test::Unit::UI::VERBOSE
-test_files_pattern = 'test/{unit,functional,other}/**/*_test.rb'
+test_files_pattern = 'test/{unit,functional,other,matchers}/**/*_test.rb'
 Rake::TestTask.new do |t|
   t.libs << 'lib'
   t.pattern = test_files_pattern
@@ -16,7 +18,7 @@ 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.options << '--line-numbers'
   rdoc.template = "#{ENV['template']}.rb" if ENV['template']
   rdoc.rdoc_files.include('README.rdoc', 'CONTRIBUTION_GUIDELINES.rdoc', 'lib/**/*.rb')
 }
@@ -38,7 +40,7 @@ task :default => ['test']
 
 spec = Gem::Specification.new do |s|
   s.name              = "shoulda"
-  s.version           = Thoughtbot::Shoulda::VERSION
+  s.version           = Shoulda::VERSION
   s.summary           = "Making tests easy on the fingers and eyes"
   s.homepage          = "http://thoughtbot.com/projects/shoulda"
   s.rubyforge_project = "shoulda"
@@ -48,7 +50,7 @@ spec = Gem::Specification.new do |s|
 
   s.has_rdoc         = true
   s.extra_rdoc_files = ["README.rdoc", "CONTRIBUTION_GUIDELINES.rdoc"]
-  s.rdoc_options     = ["--line-numbers", "--inline-source", "--main", "README.rdoc"]
+  s.rdoc_options     = ["--line-numbers", "--main", "README.rdoc"]
 
   s.authors = ["Tammer Saleh"]
   s.email   = "tsaleh@thoughtbot.com"

data/lib/shoulda.rb

@@ -1,17 +1,9 @@
-require 'shoulda/context'
-require 'shoulda/proc_extensions'
-require 'shoulda/assertions'
-require 'shoulda/macros'
-require 'shoulda/helpers'
-require 'shoulda/rails' if defined? RAILS_ROOT
+module Shoulda
+  VERSION = "2.10.0"
+end
 
-module Test # :nodoc: all
-  module Unit
-    class TestCase
-      extend Thoughtbot::Shoulda
-      include ThoughtBot::Shoulda::Assertions
-      extend ThoughtBot::Shoulda::Macros
-      include ThoughtBot::Shoulda::Helpers
-    end
-  end
+if defined? Spec
+  require 'shoulda/rspec'
+else
+  require 'shoulda/test_unit'
 end

data/lib/shoulda/action_controller.rb

@@ -0,0 +1,28 @@
+require 'shoulda'
+require 'shoulda/action_controller/helpers'
+require 'shoulda/action_controller/matchers'
+require 'shoulda/action_controller/macros'
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      include Shoulda::ActionController::Matchers
+      include Shoulda::ActionController::Helpers
+      extend Shoulda::ActionController::Macros
+    end
+  end
+end
+
+require 'shoulda/active_record/assertions'
+require 'shoulda/action_mailer/assertions'
+
+module ActionController #:nodoc: all
+  module Integration
+    class Session
+      include Shoulda::Assertions
+      include Shoulda::Helpers
+      include Shoulda::ActiveRecord::Assertions
+      include Shoulda::ActionMailer::Assertions
+    end
+  end
+end

data/lib/shoulda/action_controller/helpers.rb

@@ -0,0 +1,47 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Helpers # :nodoc:
+      private # :enddoc:
+
+      SPECIAL_INSTANCE_VARIABLES = %w{
+        _cookies
+        _flash
+        _headers
+        _params
+        _request
+        _response
+        _session
+        action_name
+        before_filter_chain_aborted
+        cookies
+        flash
+        headers
+        ignore_missing_templates
+        logger
+        params
+        request
+        request_origin
+        response
+        session
+        template
+        template_class
+        template_root
+        url
+        variables_added
+      }.map(&:to_s)
+
+      def instantiate_variables_from_assigns(*names, &blk)
+        old = {}
+        names = (@response.template.assigns.keys - SPECIAL_INSTANCE_VARIABLES) if names.empty?
+        names.each do |name|
+          old[name] = instance_variable_get("@#{name}")
+          instance_variable_set("@#{name}", assigns(name.to_sym))
+        end
+        blk.call
+        names.each do |name|
+          instance_variable_set("@#{name}", old[name])
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/action_controller/macros.rb

@@ -0,0 +1,277 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    # = Macro test helpers for your controllers
+    #
+    # By using the macro helpers you can quickly and easily create concise and easy to read test suites.
+    #
+    # This code segment:
+    #   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
+    #
+    # Would produce 5 tests for the +show+ action
+    module Macros
+      include Matchers
+
+      # Macro that creates a test asserting that the flash contains the given value.
+      # val can be a String, a Regex, or nil (indicating that the flash should not be set)
+      #
+      # Example:
+      #
+      #   should_set_the_flash_to "Thank you for placing this order."
+      #   should_set_the_flash_to /created/i
+      #   should_set_the_flash_to nil
+      def should_set_the_flash_to(val)
+        matcher = set_the_flash.to(val)
+        if val
+          should matcher.description do
+            assert_accepts matcher, @controller
+          end
+        else
+          should "not #{matcher.description}" do
+            assert_rejects matcher, @controller
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the flash is empty.  Same as
+      # @should_set_the_flash_to nil@
+      def should_not_set_the_flash
+        should_set_the_flash_to nil
+      end
+
+      # Macro that creates a test asserting that filter_parameter_logging
+      # is set for the specified keys
+      #
+      # Example:
+      #
+      #   should_filter_params :password, :ssn
+      def should_filter_params(*keys)
+        keys.each do |key|
+          matcher = filter_param(key)
+          should matcher.description do
+            assert_accepts matcher, @controller
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the controller assigned to
+      # each of the named instance variable(s).
+      #
+      # Options:
+      # * <tt>:class</tt> - The expected class of the instance variable being checked.
+      # * <tt>:equals</tt> - A string which is evaluated and compared for equality with
+      # the instance variable being checked.
+      #
+      # Example:
+      #
+      #   should_assign_to :user, :posts
+      #   should_assign_to :user, :class => User
+      #   should_assign_to(:user) { @user }
+      def should_assign_to(*names, &block)
+        opts = names.extract_options!
+        if opts[:equals]
+          warn "[DEPRECATION] should_assign_to :var, :equals => 'val' " <<
+               "is deprecated. Use should_assign_to(:var) { 'val' } instead."
+        end
+        names.each do |name|
+          matcher = assign_to(name).with_kind_of(opts[:class])
+          test_name = matcher.description
+          test_name << " which is equal to #{opts[:equals]}" if opts[:equals]
+          should test_name do
+            if opts[:equals]
+              instantiate_variables_from_assigns do
+                expected_value = eval(opts[:equals],
+                                      self.send(:binding),
+                                      __FILE__,
+                                      __LINE__)
+                matcher = matcher.with(expected_value)
+              end
+            elsif block
+              expected_value = instance_eval(&block)
+              matcher = matcher.with(expected_value)
+            end
+
+            assert_accepts matcher, @controller
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the controller did not assign to
+      # any of the named instance variable(s).
+      #
+      # Example:
+      #
+      #   should_not_assign_to :user, :posts
+      def should_not_assign_to(*names)
+        names.each do |name|
+          matcher = assign_to(name)
+          should "not #{matcher.description}" do
+            assert_rejects matcher, @controller
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the controller responded with a 'response' status code.
+      # Example:
+      #
+      #   should_respond_with :success
+      def should_respond_with(response)
+        should "respond with #{response}" do
+          matcher = respond_with(response)
+          assert_accepts matcher, @controller
+        end
+      end
+
+      # Macro that creates a test asserting that the response content type was 'content_type'.
+      # Example:
+      #
+      #   should_respond_with_content_type 'application/rss+xml'
+      #   should_respond_with_content_type :rss
+      #   should_respond_with_content_type /rss/
+      def should_respond_with_content_type(content_type)
+        should "respond with content type of #{content_type}" do
+          matcher = respond_with_content_type(content_type)
+          assert_accepts matcher, @controller
+        end
+      end
+
+      # Macro that creates a test asserting that a value returned from the session is correct.
+      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
+      # set by the controller are available to the evaled string.
+      # Example:
+      #
+      #   should_set_session(:user_id) { '@user.id' }
+      #   should_set_session(:message) { "Free stuff" }
+      def should_set_session(key, expected = nil, &block)
+        matcher = set_session(key)
+        if expected
+          warn "[DEPRECATION] should_set_session :key, 'val' is deprecated. " <<
+               "Use should_set_session(:key) { 'val' } instead."
+        end
+        should matcher.description do
+          if expected
+            instantiate_variables_from_assigns do
+              expected_value = eval(expected, 
+                                    self.send(:binding),
+                                    __FILE__,
+                                    __LINE__)
+              matcher = matcher.to(expected_value)
+            end
+          else
+            expected_value = instance_eval(&block)
+            matcher = matcher.to(expected_value)
+          end
+          assert_accepts matcher, @controller
+        end
+      end
+
+      # Deprecated. See should_set_session
+      def should_return_from_session(key, expected)
+        warn "[DEPRECATION] should_require_attributes is deprecated. " <<
+             "Use should_set_session instead."
+        should_set_session(key, expected)
+      end
+
+      # Macro that creates a test asserting that the controller rendered the given template.
+      # Example:
+      #
+      #   should_render_template :new
+      def should_render_template(template)
+        should "render template #{template.inspect}" do
+          assert_template template.to_s
+        end
+      end
+
+      # Macro that creates a test asserting that the controller rendered with the given layout.
+      # Example:
+      #
+      #   should_render_with_layout 'special'
+      def should_render_with_layout(expected_layout = 'application')
+        matcher = render_with_layout(expected_layout)
+        if expected_layout
+          should matcher.description do
+            assert_accepts matcher, @controller
+          end
+        else
+          should "render without layout" do
+            assert_rejects matcher, @controller
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the controller rendered without a layout.
+      # Same as @should_render_with_layout false@
+      def should_render_without_layout
+        should_render_with_layout nil
+      end
+
+      # Macro that creates a test asserting that the controller returned a redirect to the given path.
+      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
+      # set by the controller are available to the evaled string.
+      # Example:
+      #
+      #   should_redirect_to("the user's profile") { user_url(@user) }
+      def should_redirect_to(description, &block)
+        unless block
+          warn "[DEPRECATION] should_redirect_to without a block is " <<
+               "deprecated. Use should_redirect_to('somewhere') { } instead."
+        end
+        should "redirect to #{description}" do
+          if block
+            url = instance_eval(&block)
+          else
+            instantiate_variables_from_assigns do
+              url = eval(description, self.send(:binding), __FILE__, __LINE__)
+            end
+          end
+          assert_redirected_to url
+        end
+      end
+
+      # Macro that creates a routing test. It tries to use the given HTTP
+      # +method+ on the given +path+, and asserts that it routes to the
+      # given +options+.
+      #
+      # If you don't specify a :controller, it will try to guess the controller
+      # based on the current test.
+      #
+      # +to_param+ is called on the +options+ given.
+      #
+      # Examples:
+      #
+      #   should_route :get, "/posts", :controller => :posts, :action => :index
+      #   should_route :get, "/posts/new", :action => :new
+      #   should_route :post, "/posts", :action => :create
+      #   should_route :get, "/posts/1", :action => :show, :id => 1
+      #   should_route :edit, "/posts/1", :action => :show, :id => 1
+      #   should_route :put, "/posts/1", :action => :update, :id => 1
+      #   should_route :delete, "/posts/1", :action => :destroy, :id => 1
+      #   should_route :get, "/users/1/posts/1",
+      #     :action => :show, :id => 1, :user_id => 1
+      #
+      def should_route(method, path, options)
+        unless options[:controller]
+          options[:controller] = self.name.gsub(/ControllerTest$/, '').tableize
+        end
+
+        matcher = route(method, path).to(options)
+
+        should matcher.description do
+          assert_accepts matcher.in_context(self), self
+        end
+      end
+    end
+  end
+end