nimboids-shoulda 2.11.3

data/lib/shoulda/macros.rb

@@ -0,0 +1,161 @@
+require 'shoulda/private_helpers'
+
+module Shoulda # :nodoc:
+  module Macros
+    # Deprecated.
+    #
+    # Macro that creates a test asserting a change between the return value
+    # of a block that is run before and after the current setup block
+    # is run. This is similar to Active Support's <tt>assert_difference</tt>
+    # assertion, but supports more than just numeric values.  See also
+    # should_not_change.
+    #
+    # The passed description will be used when generating the test name and failure messages.
+    #
+    # Example:
+    #
+    #   context "Creating a post" do
+    #     setup { Post.create }
+    #     should_change("the number of posts", :by => 1) { Post.count }
+    #   end
+    #
+    # As shown in this example, the <tt>:by</tt> option expects a numeric
+    # difference between the before and after values of the expression.  You
+    # may also specify <tt>:from</tt> and <tt>:to</tt> options:
+    #
+    #   should_change("the number of posts", :from => 0, :to => 1) { Post.count }
+    #   should_change("the post title", :from => "old", :to => "new") { @post.title }
+    #
+    # Combinations of <tt>:by</tt>, <tt>:from</tt>, and <tt>:to</tt> are allowed:
+    #
+    #   # Assert the value changed in some way:
+    #   should_change("the post title") { @post.title }
+    #
+    #   # Assert the value changed to anything other than "old:"
+    #   should_change("the post title", :from => "old") { @post.title }
+    #
+    #   # Assert the value changed to "new:"
+    #   should_change("the post title", :to => "new") { @post.title }
+    #
+    # This macro was deprecated because these tests aren't as valuable as
+    # alternative tests that explicitly test the final state.
+    #
+    # Consider an alternative:
+    #
+    #   context "updating a post" do
+    #     setup do
+    #       @post = Post.create(:title => "old")
+    #       put :update, :post => {:title => "new"}, :id => @post.to_param
+    #     end
+    #     should "update the title" do
+    #       assert_equal "new", @post.reload.title
+    #     end
+    #   end
+    def should_change(description, options = {}, &block)
+      ::ActiveSupport::Deprecation.warn("Not considered a useful test. Instead, test the end state explicitly.")
+      by, from, to = get_options!([options], :by, :from, :to)
+      stmt = "change #{description}"
+      stmt << " from #{from.inspect}" if from
+      stmt << " to #{to.inspect}" if to
+      stmt << " by #{by.inspect}" if by
+
+      before = lambda { @_before_should_change = block.bind(self).call }
+      should stmt, :before => before do
+        old_value = @_before_should_change
+        new_value = block.bind(self).call
+        assert_operator from, :===, old_value, "#{description} did not originally match #{from.inspect}" if from
+        assert_not_equal old_value, new_value, "#{description} did not change" unless by == 0
+        assert_operator to, :===, new_value, "#{description} was not changed to match #{to.inspect}" if to
+        assert_equal old_value + by, new_value if by
+      end
+    end
+
+    # Deprecated.
+    #
+    # Macro that creates a test asserting no change between the return value
+    # of a block that is run before and after the current setup block
+    # is run. This is the logical opposite of should_change.
+    #
+    # The passed description will be used when generating the test name and failure message.
+    #
+    # Example:
+    #
+    #   context "Updating a post" do
+    #     setup { @post.update_attributes(:title => "new") }
+    #     should_not_change("the number of posts") { Post.count }
+    #   end
+    #
+    # This macro was deprecated because these tests aren't as valuable as
+    # alternative tests that explicitly test the final state.
+    #
+    # Consider an alternative:
+    #
+    #   context "updating a post" do
+    #     setup do
+    #       @post = Post.create(:title => "old")
+    #       put :update, :post => {:title => ""}, :id => @post.to_param
+    #     end
+    #     should "not update the title" do
+    #       assert_equal "old", @post.reload.title
+    #     end
+    #   end
+    def should_not_change(description, &block)
+      ::ActiveSupport::Deprecation.warn("Not considered a useful test. Instead, test the end state explicitly.")
+      before = lambda { @_before_should_not_change = block.bind(self).call }
+      should "not change #{description}", :before => before do
+        new_value = block.bind(self).call
+        assert_equal @_before_should_not_change, new_value, "#{description} changed"
+      end
+    end
+
+    # Deprecated.
+    #
+    # Macro that creates a test asserting that a record of the given class was
+    # created.
+    #
+    # Example:
+    #
+    #   context "creating a post" do
+    #     setup { Post.create(post_attributes) }
+    #     should_create :post
+    #   end
+    def should_create(class_name)
+      ::ActiveSupport::Deprecation.warn
+      should_change_record_count_of(class_name, 1, 'create')
+    end
+
+    # Deprecated.
+    #
+    # Macro that creates a test asserting that a record of the given class was
+    # destroyed.
+    #
+    # Example:
+    #
+    #   context "destroying a post" do
+    #     setup { Post.first.destroy }
+    #     should_destroy :post
+    #   end
+    def should_destroy(class_name)
+      ::ActiveSupport::Deprecation.warn
+      should_change_record_count_of(class_name, -1, 'destroy')
+    end
+
+    private
+
+    def should_change_record_count_of(class_name, amount, action) # :nodoc:
+      klass = class_name.to_s.camelize.constantize
+      before = lambda do
+        @_before_change_record_count = klass.count
+      end
+      human_name = class_name.to_s.humanize.downcase
+      should "#{action} a #{human_name}", :before => before do
+        assert_equal @_before_change_record_count + amount,
+                     klass.count,
+                     "Expected to #{action} a #{human_name}"
+      end
+    end
+
+    include Shoulda::Private
+  end
+end
+

data/lib/shoulda/private_helpers.rb

@@ -0,0 +1,13 @@
+module Shoulda # :nodoc:
+  module Private # :nodoc:
+    # Returns the values for the entries in the args hash who's keys are listed in the wanted array.
+    # Will raise if there are keys in the args hash that aren't listed.
+    def get_options!(args, *wanted)
+      ret  = []
+      opts = (args.last.is_a?(Hash) ? args.pop : {})
+      wanted.each {|w| ret << opts.delete(w)}
+      raise ArgumentError, "Unsupported options given: #{opts.keys.join(', ')}" unless opts.keys.empty?
+      return wanted.size == 1 ? ret.first : ret
+    end
+  end
+end

data/lib/shoulda/proc_extensions.rb

@@ -0,0 +1,14 @@
+# Stolen straight from ActiveSupport
+
+class Proc #:nodoc:
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end

data/lib/shoulda/rails.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'active_support'
+require 'shoulda'
+
+require 'shoulda/active_record'     if defined? ActiveRecord::Base
+require 'shoulda/action_controller' if defined? ActionController::Base
+require 'shoulda/action_mailer'     if defined? ActionMailer::Base
+

data/lib/shoulda/tasks/list_tests.rake

@@ -0,0 +1,29 @@
+namespace :shoulda do
+  desc "List the names of the test methods in a specification like format"
+  task :list do
+    $LOAD_PATH.unshift("test")
+
+    require 'test/unit'
+    require 'rubygems'
+    require 'active_support'
+
+    # bug in test unit.  Set to true to stop from running.
+    Test::Unit.run = true
+
+    test_files = Dir.glob(File.join('test', '**', '*_test.rb'))
+    test_files.each do |file|
+      load file
+      klass = File.basename(file, '.rb').classify
+      unless Object.const_defined?(klass.to_s)
+        puts "Skipping #{klass} because it doesn't map to a Class"
+        next
+      end
+      klass = klass.constantize
+
+      puts klass.name.gsub('Test', '')
+
+      test_methods = klass.instance_methods.grep(/^test/).map {|s| s.gsub(/^test: /, '')}.sort
+      test_methods.each {|m| puts "  " + m }
+    end
+  end
+end

data/lib/shoulda/tasks/yaml_to_shoulda.rake

@@ -0,0 +1,28 @@
+namespace :shoulda do
+  # From http://blog.internautdesign.com/2007/11/2/a-yaml_to_shoulda-rake-task
+  # David.Lowenfels@gmail.com
+  desc "Converts a YAML file (FILE=./path/to/yaml) into a Shoulda skeleton"
+  task :from_yaml do
+    require 'yaml'
+
+    def yaml_to_context(hash, indent = 0)
+      indent1 = '  ' * indent
+      indent2 = '  ' * (indent + 1)
+      hash.each_pair do |context, shoulds|
+        puts indent1 + "context \"#{context}\" do"
+        puts
+        shoulds.each do |should|
+          yaml_to_context( should, indent + 1 ) and next if should.is_a?( Hash )
+          puts indent2 + "should_eventually \"" + should.gsub(/^should +/,'') + "\" do"
+          puts indent2 + "end"
+          puts
+        end
+        puts indent1 + "end"
+      end
+    end
+
+    puts("Please pass in a FILE argument.") and exit unless ENV['FILE']
+
+    yaml_to_context( YAML.load_file( ENV['FILE'] ) )
+  end
+end

data/lib/shoulda/tasks.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), 'tasks', '*.rake')].each do |f|
+  load f
+end

data/lib/shoulda/version.rb

@@ -0,0 +1,4 @@
+module Shoulda
+  VERSION = "2.11.3"
+end
+

data/lib/shoulda.rb

@@ -0,0 +1,9 @@
+require 'shoulda/version'
+
+if defined?(RSpec)
+  require 'shoulda/integrations/rspec2'
+elsif defined?(Spec)
+  require 'shoulda/integrations/rspec'
+else
+  require 'shoulda/integrations/test_unit'
+end

data/rails/init.rb

@@ -0,0 +1,8 @@
+if RAILS_ENV == 'test'
+  if defined? Spec
+    require 'shoulda/integrations/rspec'
+  else
+    require 'shoulda/integrations/test_unit'
+    Shoulda.autoload_macros RAILS_ROOT, File.join("vendor", "{plugins,gems}", "*")
+  end
+end

data/test/README

@@ -0,0 +1,36 @@
+The Shoulda test suite (in particular - the tests that test shoulda)
+
+Quick overview:
+
+The test directory contains the following files and subdirectories:
+
+* rails_root - contains the stripped down rails application that the tests run against.  The rails root contains:
+** the models, controllers, and views defined under app/
+** the test.rb environment file
+** a migration file for each model
+** a shoulda initializer that simulates loading the plugin but without relying on vendor/plugins
+* fixtures - contain the sample DB data for each model
+* functional - controller tests for each of the controllers under rails_root/app
+* unit - model tests for each of the models under rails_root/app
+* other - tests for the shoulda contexts, should statements, and assertions
+* test_helper.rb - responsible for initializing the test environment
+** sets the rails_env to test
+** sets the rails_root
+** runs all the migrations against the in-memory sqlite3 db
+** adds some magic to load the right fixture files
+
+In order to add a new model (or controller) to the test suite:
+
+* add that model to rails_root/app/models
+* add a migration for that model
+* add a fixture file
+* add a test for that file under test/units
+
+Dependencies:
+
+* Rails gem installed in the host system
+* A working sqlite3 installation.
+
+If you have problems running these tests, please notify the mailing list:  shoulda@googlegroups.com
+
+- Tammer Saleh <tsaleh@thoughtbot.com>

data/test/fail_macros.rb

@@ -0,0 +1,55 @@
+module Shoulda
+  class << self
+    attr_accessor :expected_exceptions
+  end
+
+  module ClassMethods
+    # Enables the core shoulda test suite to test for failure scenarios.  For
+    # example, to ensure that a set of test macros should fail, do this:
+    #
+    #   should_fail do
+    #     should_validate_presence_of :comments
+    #     should_not_allow_mass_assignment_of :name
+    #   end
+    def should_fail(&block)
+      context "should fail when trying to run:" do
+        if defined?(Test::Unit::AssertionFailedError)
+          failures = [Test::Unit::AssertionFailedError]
+        elsif defined?(MiniTest::Assertion)
+          failures = [MiniTest::Assertion]
+        end
+        Shoulda.expected_exceptions = failures
+        yield block
+        Shoulda.expected_exceptions = nil
+      end
+    end
+  end
+
+  class Context
+    # alias_method_chain hack to allow the should_fail macro to work
+    def should_with_failure_scenario(*args, &block)
+      should_without_failure_scenario(*args, &block)
+      wrap_last_should_with_failure_expectation
+    end
+    alias_method_chain :should, :failure_scenario
+
+    # alias_method_chain hack to allow the should_fail macro to work
+    def should_not_with_failure_scenario(*args, &block)
+      should_not_without_failure_scenario(*args, &block)
+      wrap_last_should_with_failure_expectation
+    end
+    alias_method_chain :should_not, :failure_scenario
+
+    def wrap_last_should_with_failure_expectation
+      if Shoulda.expected_exceptions
+        expected_exceptions = Shoulda.expected_exceptions
+        should = self.shoulds.last
+        assertion_block = should[:block]
+        failure_block = lambda do
+          assert_raise(*expected_exceptions, &assertion_block.bind(self))
+        end
+        should[:block] = failure_block
+      end
+    end
+  end
+end

data/test/fixtures/addresses.yml

@@ -0,0 +1,3 @@
+first:
+  title: Home
+  addressable: first (User)

data/test/fixtures/posts.yml

@@ -0,0 +1,5 @@
+first:
+  id: 1
+  title: My Cute Kitten!
+  body: This is totally a cute kitten
+  user_id: 1

data/test/fixtures/tags.yml

@@ -0,0 +1,9 @@
+first:
+  id: 1
+  name: Stuff
+second:
+  id: 2
+  name: Rails
+third:
+  id: 3
+  name: Nothing

data/test/fixtures/users.yml

@@ -0,0 +1,6 @@
+first:
+  id: 1
+  name: Some dude
+  age: 2
+  email: none@none.com
+  ssn: 123456789

data/test/functional/posts_controller_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+require 'posts_controller'
+
+# Re-raise errors caught by the controller.
+class PostsController; def rescue_action(e) raise e end; end
+
+class PostsControllerTest < ActionController::TestCase
+  fixtures :all
+
+  def setup
+    @controller = PostsController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    @post       = Post.find(:first)
+  end
+
+  # autodetects the :controller
+  should_route :get,    '/posts',     :action => :index
+  # explicitly specify :controller
+  should_route :post,   '/posts',     :controller => :posts, :action => :create
+  # non-string parameter
+  should_route :get,    '/posts/1',   :action => :show, :id => 1
+  # string-parameter
+  should_route :put,    '/posts/1',   :action => :update, :id => "1"
+  should_route :delete, '/posts/1',   :action => :destroy, :id => 1
+  should_route :get,    '/posts/new', :action => :new
+
+  # Test the nested routes
+  should_route :get,    '/users/5/posts',     :action => :index, :user_id => 5
+  should_route :post,   '/users/5/posts',     :action => :create, :user_id => 5
+  should_route :get,    '/users/5/posts/1',   :action => :show, :id => 1, :user_id => 5
+  should_route :delete, '/users/5/posts/1',   :action => :destroy, :id => 1, :user_id => 5
+  should_route :get,    '/users/5/posts/new', :action => :new, :user_id => 5
+  should_route :put,    '/users/5/posts/1',   :action => :update, :id => 1, :user_id => 5
+
+  context "Logged in" do
+    setup do
+      @request.session[:logged_in] = true
+    end
+
+    context "viewing posts for a user" do
+      setup do
+        get :index, :user_id => users(:first)
+      end
+      should_respond_with :success
+      should_assign_to :user, :class => User
+      should_render_template :index
+      should_assign_to(:user) { users(:first) }
+      should_fail do
+        should_assign_to :user, :class => Post
+      end
+      should_fail do
+        should_assign_to(:user) { posts(:first) }
+      end
+      should_assign_to :posts
+      should_not_assign_to :foo, :bar
+    end
+
+    context "viewing posts for a user with rss format" do
+      setup do
+        get :index, :user_id => users(:first), :format => 'rss'
+        @user = users(:first)
+      end
+      should_respond_with :success
+      should_respond_with_content_type 'application/rss+xml'
+      context "with a symbol" do
+        should_respond_with_content_type :rss
+      end
+      context "with a regexp" do
+        should_respond_with_content_type /rss/
+      end
+      should_set_session(:mischief) { nil }
+      should_set_session(:special) { '$2 off your next purchase' }
+      should_set_session(:special_user_id) { @user.id }
+      should_set_session(:false_var) { false }
+      should_fail do
+        should_set_session(:special_user_id) { 'value' }
+      end
+      should_assign_to :user, :posts
+      should_not_assign_to :foo, :bar
+    end
+
+    context "viewing a post on GET to #show" do
+      setup { get :show, :user_id => users(:first), :id => posts(:first) }
+      should_render_with_layout 'wide'
+      context "with a symbol" do # to avoid redefining a test
+        should_render_with_layout :wide
+      end
+      should_assign_to :false_flag
+      should_fail do
+        should_set_the_flash_to /.*/
+      end
+    end
+
+    context "on GET to #new" do
+      setup { get :new, :user_id => users(:first) }
+      should_render_without_layout
+      should_not_set_the_flash
+    end
+
+    context "on POST to #create" do
+      setup do
+        post :create, :user_id => users(:first),
+                      :post    => { :title => "first post",
+                                    :body  => 'blah blah blah' }
+      end
+
+      should_redirect_to('the created post') { user_post_url(users(:first),
+                                                             assigns(:post)) }
+      should_fail do
+        should_redirect_to('elsewhere') { user_posts_url(users(:first)) }
+      end
+
+      should_set_the_flash_to /success/
+      should_fail do
+        should_not_set_the_flash
+      end
+    end
+  end
+
+end

data/test/functional/users_controller_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+require 'users_controller'
+
+# Re-raise errors caught by the controller.
+class UsersController; def rescue_action(e) raise e end; end
+
+class UsersControllerTest < ActionController::TestCase
+  fixtures :all
+
+  def setup
+    @controller = UsersController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    @user       = User.find(:first)
+  end
+  
+  should_filter_params :ssn
+
+end

data/test/matchers/action_mailer/have_sent_email_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class HaveSentEmailTest < ActiveSupport::TestCase # :nodoc:
+  def add_mail_to_deliveries
+    if defined?(AbstractController::Rendering)
+      ::ActionMailer::Base.deliveries << Mailer.the_email
+    else
+      ::ActionMailer::Base.deliveries << Mailer.create_the_email
+    end
+  end
+
+  context "an email" do
+    setup do
+      define_mailer :mailer, [:the_email] do
+        def the_email
+          if defined?(AbstractController::Rendering)
+            mail :from    => "do-not-reply@example.com",
+                 :to      => "myself@me.com",
+                 :subject => "This is spam",
+                 :body    => "Every email is spam."
+          else
+            from       "do-not-reply@example.com"
+            recipients "myself@me.com"
+            subject    "This is spam"
+            body       "Every email is spam."
+          end
+        end
+      end
+      add_mail_to_deliveries
+    end
+
+    teardown { ::ActionMailer::Base.deliveries.clear }
+
+    should "accept based on the subject" do
+      assert_accepts have_sent_email.with_subject(/is spam$/), nil
+      assert_rejects have_sent_email.with_subject(/totally safe/), nil,
+                     :message => /Expected sent email with subject/
+    end
+
+    should "accept based on a string sender" do
+      assert_accepts have_sent_email.from('do-not-reply@example.com'), nil
+      assert_rejects have_sent_email.from('you@example.com'), nil,
+                     :message => /Expected sent email from/
+    end
+
+    should "accept based on a regexp sender" do
+      assert_accepts have_sent_email.from(/@example\.com/), nil
+      assert_rejects have_sent_email.from(/you@/), nil,
+                     :message => /Expected sent email from/
+    end
+
+    should "accept based on the body" do
+      assert_accepts have_sent_email.with_body(/is spam\./), nil
+      assert_rejects have_sent_email.with_body(/totally safe/), nil,
+                     :message => /Expected sent email with body/
+    end
+
+    should "accept based on the recipient" do
+      assert_accepts have_sent_email.to('myself@me.com'), nil
+      assert_rejects have_sent_email.to('you@example.com'), nil,
+                     :message => /Expected sent email to/
+    end
+
+    should "list all deliveries within failure message" do
+      add_mail_to_deliveries
+
+      assert_rejects have_sent_email.to('you@example.com'), nil,
+                                        :message => /Deliveries:\n"This is spam" to \["myself@me\.com"\]\n"This is spam" to \["myself@me\.com"\]/
+    end
+
+    should "chain" do
+      assert_accepts have_sent_email.with_subject(/spam/).from('do-not-reply@example.com').with_body(/spam/).to('myself@me.com'), nil
+      assert_rejects have_sent_email.with_subject(/ham/).from('you@example.com').with_body(/ham/).to('them@example.com'), nil
+    end
+  end
+end