thoughtbot-shoulda 2.10.2 → 2.11.1

data/CONTRIBUTION_GUIDELINES.rdoc

@@ -1,10 +1,10 @@
-We're using GitHub[http://github.com/thoughtbot/shoulda/tree/master], and we've been getting any combination of github pull requests, tickets, patches, emails, etc.  We need to normalize this workflow to make sure we don't miss any fixes. 
+We're using GitHub[http://github.com/thoughtbot/shoulda/tree/master], and we've been getting any combination of github pull requests, tickets, patches, emails, etc.  We need to normalize this workflow to make sure we don't miss any fixes.
 
 * Make sure you're accessing the source from the {official repository}[http://github.com/thoughtbot/shoulda/tree/master].
 * We prefer git branches over patches, but we can take either.
-* If you're using git, please make a branch for each separate contribution.  We can cherry pick your commits, but pulling from a branch is easier. 
+* If you're using git, please make a branch for each separate contribution.  We can cherry pick your commits, but pulling from a branch is easier.
 * If you're submitting patches, please cut each fix or feature into a separate patch.
-* There should be an issue[http://github.com/thoughtbot/shoulda/issues] for any submission.  If you've found a bug and want to fix it, open a new ticket at the same time. 
-* Please <b>don't send pull requests</b>  Just update the issue with the url for your fix (or attach the patch) when it's ready.  The github pull requests pretty much get dropped on the floor until someone with commit rights notices them in the mailbox. 
-* Contributions without tests won't be accepted.  The file <tt>/test/README</tt> explains the testing system pretty thoroughly. 
+* There should be an issue[http://github.com/thoughtbot/shoulda/issues] for any submission.  If you've found a bug and want to fix it, open a new ticket at the same time.
+* Please <b>don't send pull requests</b>  Just update the issue with the url for your fix (or attach the patch) when it's ready.  The github pull requests pretty much get dropped on the floor until someone with commit rights notices them in the mailbox.
+* Contributions without tests won't be accepted.  The file <tt>/test/README</tt> explains the testing system pretty thoroughly.
 

data/README.rdoc

@@ -1,16 +1,64 @@
 = 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.
+Shoulda makes it easy to write elegant, understandable, and maintainable tests. Shoulda consists of matchers, test helpers, and assertions. It's fully compatible with your existing tests in Test::Unit or RSpec, and requires no retooling to use.
 
-Helpers:: #context and #should give you RSpec like test blocks.
+Matchers:: Test::Unit- and RSpec-compatible one-liners that test common Rails functionality.
+           These tests would otherwise be much longer, more complex, and error-prone.
+Helpers:: #context and #should give you RSpec like test blocks in Test::Unit.
           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.
+Assertions:: Many common Rails testing idioms have been distilled into a set of useful assertions.
 
 = Usage
 
+=== ActiveRecord Tests (Shoulda::ActiveRecord::Matchers)
+
+Test your ActiveRecord associations and validations with these powerful matchers:
+
+  class PostTest < Test::Unit::TestCase
+    should belong_to(:user)
+    should have_many(:tags).through(:taggings)
+
+    should validate_uniqueness_of(:title)
+    should validate_presence_of(:body).with_message(/wtf/)
+    should validate_presence_of(:title)
+    should validate_numericality_of(:user_id)
+  end
+
+  class UserTest < Test::Unit::TestCase
+    should have_many(:posts)
+
+    should_not allow_value("blah").for(:email)
+    should_not allow_value("b lah").for(:email)
+    should allow_value("a@b.com").for(:email)
+    should allow_value("asdf@asdf.com").for(:email)
+    should ensure_inclusion_of(:email).in_range(1..100)
+    should ensure_inclusion_of(:age).in_range(1..100)
+    should_not allow_mass_assignment_of(:password)
+  end
+
+Makes TDD so much easier.
+
+=== Controller Tests (Shoulda::Controller::Matchers)
+
+Matchers to test the most common controller patterns...
+
+  class PostsControllerTest < ActionController::TestCase
+    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
+  end
+
 === Context Helpers (Shoulda::Context)
 
 Stop killing your fingers with all of those underscores...  Name your tests with plain sentences!
@@ -44,55 +92,6 @@ Produces the following test methods:
 
 So readable!
 
-=== ActiveRecord Tests (Shoulda::ActiveRecord::Macros)
-
-Quick macro tests for your ActiveRecord associations and validations:
-
-  class PostTest < Test::Unit::TestCase
-    fixtures :all
-
-    should_belong_to :user
-    should_have_many :tags, :through => :taggings
-
-    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
-    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_not_allow_mass_assignment_of :password
-  end
-
-Makes TDD so much easier.
-
-=== Controller Tests (Shoulda::Controller::Macros)
-
-Macros to test the most common controller patterns...
-  
-  class PostsControllerTest < ActionController::TestCase
-    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
-  end
-  
 === Helpful Assertions (Shoulda::Assertions)
 
 More to come here, but have fun with what's there.
@@ -101,26 +100,12 @@ More to come here, but have fun with what's there.
   assert_contains(['a', '1'], /\d/)
   assert_contains(['a', '1'], 'a')
 
-=== 3rd Party and Application Specific Macros
-
-Any *.rb file under RAILS_ROOT/test/shoulda_macros/ or vendor/(plugins|gems)/gem_name/shoulda_macros/ will be automatically required when you run your tests.  This allows you to distribute macros with your plugins, or to organize the macros inside your application.  Remember to add your macro to Test::Unit::TestCase in the macro file:
-
-  # test/shoulda_macros/security.rb
-  class Test::Unit::TestCase
-    def self.should_be_denied(opts = {})
-      should_set_the_flash_to(opts[:flash] || /Please log in/i)
-      should_redirect_to(opts[:redirect]   || 'login_url')
-    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:
+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"
+    config.gem "shoulda", :lib => "shoulda"
   end
 
 Then:
@@ -128,29 +113,15 @@ 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',       :lib => false
   config.gem 'rspec-rails', :lib => false
-  config.gem 'thoughtbot-shoulda',
-             :lib => false,
-             :source => 'http://gems.github.com'
+  config.gem 'shoulda',     :lib => false
 
 Then require shoulda from your spec/spec_helper.rb file, before Spec::Runner is
 configured:
@@ -162,10 +133,22 @@ configured:
 
 You should not need to require anything besides the top-level shoulda library.
 
+= Rails 3 Installation (RSpec)
+
+With Rails 3 and Bundler, requiring Shoulda is as easy as adding it to your Gemfile:
+
+  group :test do
+    gem "shoulda"
+    gem "rspec-rails", "2.0.0.beta.12"
+  end
+
+Shoulda will automatically include matchers into the appropriate example
+groups.
+
 = Credits
 
-Shoulda is maintained by {Tammer Saleh}[mailto:tsaleh@thoughtbot.com], and is funded by Thoughtbot[http://www.thoughtbot.com], inc.
+Shoulda is maintained and funded by {thougthbot}[http://thoughtbot.com/community]
 
 = License
 
-Shoulda is Copyright © 2006-2008 Tammer Saleh, Thoughtbot. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.
+Shoulda is Copyright © 2006-2010 Tammer Saleh, Thoughtbot. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/Rakefile

@@ -1,16 +1,18 @@
+require 'rubygems'
 require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
+require 'cucumber/rake/task'
 
 $LOAD_PATH.unshift("lib")
-require 'shoulda'
+require 'shoulda/version'
 load 'tasks/shoulda.rake'
 
 # Test::Unit::UI::VERBOSE
 test_files_pattern = 'test/{unit,functional,other,matchers}/**/*_test.rb'
 Rake::TestTask.new do |t|
-  t.libs << 'lib'
+  t.libs << 'lib' << 'test'
   t.pattern = test_files_pattern
   t.verbose = false
 end
@@ -30,33 +32,8 @@ task :coverage do
   system "rcov --rails --sort coverage -Ilib #{files.join(' ')}"
 end
 
-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']
-
-spec = Gem::Specification.new do |s|
-  s.name              = "shoulda"
-  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"
-
-  s.files       = FileList["[A-Z]*", "{bin,lib,rails,test}/**/*"]
-  s.executables = s.files.grep(/^bin/) { |f| File.basename(f) }
-
-  s.has_rdoc         = true
-  s.extra_rdoc_files = ["README.rdoc", "CONTRIBUTION_GUIDELINES.rdoc"]
-  s.rdoc_options     = ["--line-numbers", "--main", "README.rdoc"]
-
-  s.authors = ["Tammer Saleh"]
-  s.email   = "tsaleh@thoughtbot.com"
-end
-
-Rake::GemPackageTask.new spec do |pkg|
+eval("$specification = begin; #{IO.read('shoulda.gemspec')}; end")
+Rake::GemPackageTask.new $specification do |pkg|
   pkg.need_tar = true
   pkg.need_zip = true
 end
@@ -64,9 +41,30 @@ end
 desc "Clean files generated by rake tasks"
 task :clobber => [:clobber_rdoc, :clobber_package]
 
-desc "Generate a gemspec file for GitHub"
-task :gemspec do
-  File.open("#{spec.name}.gemspec", 'w') do |f|
-    f.write spec.to_ruby
+namespace :cucumber do
+  Cucumber::Rake::Task.new(:rails2, "Run the cucumber features in Rails 2") do |t|
+    t.fork = true
+    t.cucumber_opts = ['--format', (ENV['CUCUMBER_FORMAT'] || 'progress')]
+    t.profile = 'rails2'
+  end
+
+  Cucumber::Rake::Task.new(:rails3, "Run the cucumber features in Rails 3") do |t|
+    t.fork = true
+    t.cucumber_opts = ['--format', (ENV['CUCUMBER_FORMAT'] || 'progress')]
+    t.profile = 'rails3'
+  end
+end
+
+desc "Run the cucumber features in both Rails 2 and 3"
+task :cucumber => ["cucumber:rails2", "cucumber:rails3"]
+
+desc 'run tests for all supported versions of Rails'
+task :test_all do
+  %w(2.3.8 3.0.0.beta4).each do |version|
+    system("RAILS_VERSION=#{version} rake -s test;")
   end
 end
+
+desc 'Default: run test and cucumber features for support versions'
+task :default => [:test_all, :cucumber]
+

data/lib/shoulda.rb

@@ -1,9 +1,9 @@
-module Shoulda
-  VERSION = "2.10.2"
-end
+require 'shoulda/version'
 
-if defined? Spec
-  require 'shoulda/rspec'
+if defined?(RSpec)
+  require 'shoulda/integrations/rspec2'
+elsif defined?(Spec)
+  require 'shoulda/integrations/rspec'
 else
-  require 'shoulda/test_unit'
+  require 'shoulda/integrations/test_unit'
 end

data/lib/shoulda/action_controller.rb

@@ -24,3 +24,11 @@ module ActionController #:nodoc: all
     end
   end
 end
+
+if defined?(ActionController::TestCase)
+  class ActionController::TestCase
+    def subject
+      @controller
+    end
+  end
+end

data/lib/shoulda/action_controller/macros.rb

@@ -24,37 +24,30 @@ module Shoulda # :nodoc:
     module Macros
       include Matchers
 
+      # Deprecated: use ActionController::Matchers#set_the_flash instead.
+      #
       # Macro that creates a test asserting that the flash contains the given
       # value. Expects a +String+ or +Regexp+.
       #
-      # If the argument is +nil+, it will assert that the flash is not set.
-      # This behavior is deprecated.
-      #
       # Example:
       #
       #   should_set_the_flash_to "Thank you for placing this order."
       #   should_set_the_flash_to /created/i
       def should_set_the_flash_to(val)
-        if val
-          matcher = set_the_flash.to(val)
-          should matcher.description do
-            assert_accepts matcher, @controller
-          end
-        else
-          warn "[DEPRECATION] should_set_the_flash_to nil is deprecated. " <<
-               "Use should_not_set_the_flash instead."
-          should_not_set_the_flash
-        end
+        ::ActiveSupport::Deprecation.warn("use: should set_the_flash")
+        should set_the_flash.to(val)
       end
 
+      # Deprecated: use ActionController::Matchers#set_the_flash instead.
+      #
       # Macro that creates a test asserting that the flash is empty.
       def should_not_set_the_flash
-        matcher = set_the_flash
-        should "not #{matcher.description}" do
-          assert_rejects matcher, @controller
-        end
+        ::ActiveSupport::Deprecation.warn("use: should_not set_the_flash")
+        should_not set_the_flash
       end
 
+      # Deprecated: use ActionController::Matchers#filter_param instead.
+      #
       # Macro that creates a test asserting that filter_parameter_logging
       # is set for the specified keys
       #
@@ -62,14 +55,14 @@ module Shoulda # :nodoc:
       #
       #   should_filter_params :password, :ssn
       def should_filter_params(*keys)
+        ::ActiveSupport::Deprecation.warn("use: should filter_param")
         keys.each do |key|
-          matcher = filter_param(key)
-          should matcher.description do
-            assert_accepts matcher, @controller
-          end
+          should filter_param(key)
         end
       end
 
+      # Deprecated: use ActionController::Matchers#assign_to instead.
+      #
       # Macro that creates a test asserting that the controller assigned to
       # each of the named instance variable(s).
       #
@@ -85,20 +78,17 @@ module Shoulda # :nodoc:
       #   should_assign_to :user, :class => User
       #   should_assign_to(:user) { @user }
       def should_assign_to(*names, &block)
+        ::ActiveSupport::Deprecation.warn("use: should assign_to")
         klass = get_options!(names, :class)
         names.each do |name|
           matcher = assign_to(name).with_kind_of(klass)
-          should matcher.description do
-            if block
-              expected_value = instance_eval(&block)
-              matcher = matcher.with(expected_value)
-            end
-
-            assert_accepts matcher, @controller
-          end
+          matcher = matcher.with(&block) if block
+          should matcher
         end
       end
 
+      # Deprecated: use ActionController::Matchers#assign_to instead.
+      #
       # Macro that creates a test asserting that the controller did not assign to
       # any of the named instance variable(s).
       #
@@ -106,25 +96,25 @@ module Shoulda # :nodoc:
       #
       #   should_not_assign_to :user, :posts
       def should_not_assign_to(*names)
+        ::ActiveSupport::Deprecation.warn("use: should_not assign_to")
         names.each do |name|
-          matcher = assign_to(name)
-          should "not #{matcher.description}" do
-            assert_rejects matcher, @controller
-          end
+          should_not assign_to(name)
         end
       end
 
+      # Deprecated: use ActionController::Matchers#respond_with instead.
+      #
       # 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
+        ::ActiveSupport::Deprecation.warn("use: should respond_with")
+        should respond_with(response)
       end
 
+      # Deprecated: use ActionController::Matchers#respond_with_content_type instead.
+      #
       # Macro that creates a test asserting that the response content type was 'content_type'.
       # Example:
       #
@@ -132,12 +122,12 @@ module Shoulda # :nodoc:
       #   should_respond_with_content_type :rss
       #   should_respond_with_content_type /rss/
       def should_respond_with_content_type(content_type)
-        matcher = respond_with_content_type(content_type)
-        should matcher.description do
-          assert_accepts matcher, @controller
-        end
+        ::ActiveSupport::Deprecation.warn("use: should respond_with_content_type")
+        should respond_with_content_type(content_type)
       end
 
+      # Deprecated: use ActionController::Matchers#set_session instead.
+      #
       # Macro that creates a test asserting that a value returned from the
       # session is correct. Expects the session key as a parameter, and a block
       # that returns the expected value.
@@ -147,47 +137,45 @@ module Shoulda # :nodoc:
       #   should_set_session(:user_id) { @user.id }
       #   should_set_session(:message) { "Free stuff" }
       def should_set_session(key, &block)
+        ::ActiveSupport::Deprecation.warn("use: should set_session")
         matcher = set_session(key)
-        should matcher.description do
-          expected_value = instance_eval(&block)
-          matcher = matcher.to(expected_value)
-          assert_accepts matcher, @controller
-        end
+        matcher = matcher.to(&block) if block
+        should matcher
       end
 
+      # Deprecated: use ActionController::Matchers#render_template instead.
+      #
       # 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
+        ::ActiveSupport::Deprecation.warn("use: should render_template")
+        should render_template(template)
       end
 
+      # Deprecated: use ActionController::Matchers#render_with_layout instead.
+      #
       # 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
+        ::ActiveSupport::Deprecation.warn("use: should render_with_layout")
+        should render_with_layout(expected_layout)
       end
 
+      # Deprecated: use ActionController::Matchers#render_with_layout instead.
+      #
       # 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
+        ::ActiveSupport::Deprecation.warn("use: should_not render_with_layout")
+        should_not render_with_layout
       end
 
+      # Deprecated: use ActionController::Matchers#redirect_to instead.
+      #
       # Macro that creates a test asserting that the controller returned a
       # redirect to the given path. The passed description will be used when
       # generating a test name. Expects a block that returns the expected path
@@ -197,12 +185,12 @@ module Shoulda # :nodoc:
       #
       #   should_redirect_to("the user's profile") { user_url(@user) }
       def should_redirect_to(description, &block)
-        should "redirect to #{description}" do
-          expected_url = instance_eval(&block)
-          assert_redirected_to expected_url
-        end
+        ::ActiveSupport::Deprecation.warn("use: should redirect_to")
+        should redirect_to(description, &block)
       end
 
+      # Deprecated: use ActionController::Matchers#route instead.
+      #
       # 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+.
@@ -225,15 +213,8 @@ module Shoulda # :nodoc:
       #     :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
+        ::ActiveSupport::Deprecation.warn("use: should route")
+        should route(method, path).to(options)
       end
     end
   end