kotovalexarian-likes-github
/
thoughtbot--shoulda-matchers
mirror of https://github.com/thoughtbot/shoulda-matchers.git
1
0
Fork 0
Code Releases Activity

Revert bunch of bad commits: 

2442d1f608
35213b5a1b
804f859435
fc938bb185

Getting the following error when running tests in a real project:

  ...activesupport/lib/active_support/dependencies.rb:276:in `load_missing_constant': uninitialized constant Shoulda::ActiveRecord::Base (NameError)

Think this is because of the namespace changes, but not sure.  Will investigate later.
This commit is contained in:
Tammer Saleh 2008-06-23 12:36:31 -04:00
parent 2442d1f608
commit b415bff884
18 changed files with 1701 additions and 1931 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
README.rdoc
View File

@ -10,7 +10,7 @@ Assertions:: Many common rails testing idioms have been distilled into a set of
= Usage
=== Context Helpers (Shoulda::Context)
=== Context Helpers (ThoughtBot::Shoulda::Context)
Stop killing your fingers with all of those underscores... Name your tests with plain sentences!
@ -43,7 +43,7 @@ Produces the following test methods:
So readable!
=== ActiveRecord Tests (Shoulda::ActiveRecord)
=== ActiveRecord Tests (ThoughtBot::Shoulda::ActiveRecord)
Quick macro tests for your ActiveRecord associations and validations:
@ -73,7 +73,7 @@ Quick macro tests for your ActiveRecord associations and validations:
Makes TDD so much easier.
=== Controller Tests (Shoulda::Controller::ClassMethods)
=== Controller Tests (ThoughtBot::Shoulda::Controller::ClassMethods)
Macros to test the most common controller patterns...
@ -105,7 +105,7 @@ Test entire controllers in a few lines...
should_be_restful generates 40 tests on the fly, for both html and xml requests.
=== Helpful Assertions (Shoulda::General)
=== Helpful Assertions (ThoughtBot::Shoulda::General)
More to come here, but have fun with what's there.

2
Rakefile
View File

@ -6,7 +6,7 @@ require 'rake/rdoctask'
Rake::TestTask.new do |t|
t.libs << 'lib'
t.pattern = 'test/**/*_test.rb'
t.pattern = 'test/{unit,functional,other}/**/*_test.rb'
t.verbose = false
end

155
lib/shoulda.rb
View File

@ -1,144 +1,43 @@
require 'shoulda/context'
require 'shoulda/gem/shoulda'
require 'shoulda/private_helpers'
require 'shoulda/general'
require 'shoulda/active_record_helpers'
require 'shoulda/controller_tests/controller_tests.rb'
require 'yaml'
require 'shoulda/active_record_helpers' if defined?(ActiveRecord)
require 'shoulda/controller_tests/controller_tests.rb' if defined?(ActionController)
config_files = []
config_files << "shoulda.conf"
config_files << File.join("test", "shoulda.conf")
config_files << File.join(RAILS_ROOT, "test", "shoulda.conf") if defined?(RAILS_ROOT)
config_files << File.join(ENV["HOME"], ".shoulda.conf") if ENV["HOME"]
shoulda_options = {}
config_files.each do |file|
shoulda_options.merge!(YAML.load_file(file).symbolize_keys) if File.exists? file
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 Shoulda
class << self
attr_accessor :current_context
end
# Should statements are just syntactic sugar over normal Test::Unit test methods. A should block
# contains all the normal code and assertions you're used to seeing, with the added benefit that
# they can be wrapped inside context blocks (see below).
#
# == Example:
#
# class UserTest << Test::Unit::TestCase
#
# def setup
# @user = User.new("John", "Doe")
# end
#
# should "return its full name"
# assert_equal 'John Doe', @user.full_name
# end
#
# end
#
# ...will produce the following test:
# * <tt>"test: User should return its full name. "</tt>
#
# Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
def should(name, &blk)
should_eventually(name) && return unless block_given?
if Shoulda.current_context
Shoulda.current_context.should(name, &blk)
else
context_name = self.name.gsub(/Test/, "")
context = Shoulda::Context.new(context_name, self) do
should(name, &blk)
end
context.build
end
end
# Just like should, but never runs, and instead prints a differed message in the Test::Unit output.
def should_eventually(name, &blk)
context_name = self.name.gsub(/Test/, "")
context = Shoulda::Context.new(context_name, self) do
should_eventually(name, &blk)
end
context.build
end
# A context block groups should statements under a common set of setup/teardown methods.
# Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
# and readability of your test code.
#
# A context block can contain setup, should, should_eventually, and teardown blocks.
#
# 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
# end
# end
#
# This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
#
# Contexts may be nested. Nested contexts run their setup blocks from out to in before each
# should statement. They then run their teardown blocks from in to out after each should statement.
#
# 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
#
# This code will produce the following methods
# * <tt>"test: A User instance should return its full name. "</tt>
# * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
#
# <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt>
# tests</b>. This means you do not have to fully commit to the context/should syntax in a test file.
def context(name, &blk)
if Shoulda.current_context
Shoulda.current_context.context(name, &blk)
else
context = Shoulda::Context.new(name, self, &blk)
context.build
end
end
end
module Test # :nodoc: all
module Unit
class TestCase
include Shoulda::General
include Shoulda::Controller
extend Shoulda::ActiveRecord
include ThoughtBot::Shoulda::General
include ThoughtBot::Shoulda::Controller
extend ThoughtBot::Shoulda::ActiveRecord
end
end
end
module ActionController #:nodoc: all
module Integration
class Session
include ThoughtBot::Shoulda::General
end
end
end

1052
lib/shoulda/active_record_helpers.rb
View File

File diff suppressed because it is too large Load Diff

22
lib/shoulda/color.rb
View File

@ -1,8 +1,6 @@
require 'test/unit/ui/console/testrunner'
# Completely stolen from redgreen gem (thanks Pat Eyler and Chris Wanstrath).
#
# NOTE: Is this now in autotest? Can I remove this, then?
# Completely stolen from redgreen gem
#
# Adds colored output to your tests. Specify <tt>color: true</tt> in
# your <tt>~/.shoulda.conf</tt> file to enable.
@ -11,7 +9,7 @@ require 'test/unit/ui/console/testrunner'
# every rake task, as though there was another (empty) set of tests.
# A fix would be most welcome.
#
module Shoulda::Color
module ThoughtBot::Shoulda::Color
COLORS = { :clear => 0, :red => 31, :green => 32, :yellow => 33 } # :nodoc:
def self.method_missing(color_name, *args) # :nodoc:
color(color_name) + args.first + color(:clear)
@ -27,7 +25,7 @@ module Test # :nodoc:
alias :old_to_s :to_s
def to_s
if old_to_s =~ /\d+ tests, \d+ assertions, (\d+) failures, (\d+) errors/
Shoulda::Color.send($1.to_i != 0 || $2.to_i != 0 ? :red : :green, $&)
ThoughtBot::Shoulda::Color.send($1.to_i != 0 || $2.to_i != 0 ? :red : :green, $&)
end
end
end
@ -45,16 +43,16 @@ module Test # :nodoc:
class Failure # :nodoc:
alias :old_long_display :long_display
def long_display
# old_long_display.sub('Failure', Shoulda::Color.red('Failure'))
Shoulda::Color.red(old_long_display)
# old_long_display.sub('Failure', ThoughtBot::Shoulda::Color.red('Failure'))
ThoughtBot::Shoulda::Color.red(old_long_display)
end
end
class Error # :nodoc:
alias :old_long_display :long_display
def long_display
# old_long_display.sub('Error', Shoulda::Color.yellow('Error'))
Shoulda::Color.yellow(old_long_display)
# old_long_display.sub('Error', ThoughtBot::Shoulda::Color.yellow('Error'))
ThoughtBot::Shoulda::Color.yellow(old_long_display)
end
end
@ -64,9 +62,9 @@ module Test # :nodoc:
def output_single(something, level=NORMAL)
return unless (output?(level))
something = case something
when '.' then Shoulda::Color.green('.')
when 'F' then Shoulda::Color.red("F")
when 'E' then Shoulda::Color.yellow("E")
when '.' then ThoughtBot::Shoulda::Color.green('.')
when 'F' then ThoughtBot::Shoulda::Color.red("F")
when 'E' then ThoughtBot::Shoulda::Color.yellow("E")
else something
end
@io.write(something)

140
lib/shoulda/context.rb
View File

@ -1,140 +0,0 @@
require File.join(File.dirname(__FILE__), 'extensions', 'proc')
module Shoulda
class Context
attr_accessor :name # my name
attr_accessor :parent # may be another context, or the original test::unit class.
attr_accessor :subcontexts # array of contexts nested under myself
attr_accessor :setup_block # block given via a setup method
attr_accessor :teardown_block # block given via a teardown method
attr_accessor :shoulds # array of hashes representing the should statements
attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
def initialize(name, parent, &blk)
Shoulda.current_context = self
self.name = name
self.parent = parent
self.setup_block = nil
self.teardown_block = nil
self.shoulds = []
self.should_eventuallys = []
self.subcontexts = []
blk.bind(self).call
Shoulda.current_context = nil
end
# Creates a context. See Shoulda#context.
def context(name, &blk)
subcontexts << Context.new(name, self, &blk)
Shoulda.current_context = self
end
# Creates a should statement. See Shoulda#should.
def should(name, &blk)
self.shoulds << { :name => name, :block => blk }
end
# Creates a should_eventually statement. See Shoulda#should_eventually.
def should_eventually(name, &blk)
self.should_eventuallys << { :name => name, :block => blk }
end
# Any code in a setup block will be run before the should statements in a
# context. Nested contexts will have their setup blocks run in order.
def setup(&blk)
self.setup_block = blk
end
# Any code in a teardown block will be run after the should statements in a
# context. Nested contexts will have their teardown blocks run in reverse
# order.
def teardown(&blk)
self.teardown_block = blk
end
# The full name of this context, including parents.
def full_name
parent_name = parent.full_name if subcontext?
return [parent_name, name].join(" ").strip
end
# Returns true if this context is nested
def subcontext?
parent.is_a?(self.class) # my parent is the same class as myself.
end
# Returns the root class that decends from Test::Unit.
def test_unit_class
subcontext? ? parent.test_unit_class : parent
end
# Creates a single test from a should hash
def create_test_from_should_hash(should)
test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
if test_unit_class.instance_methods.include?(test_name.to_s)
warn " * WARNING: '#{test_name}' is already defined"
end
context = self
test_unit_class.send(:define_method, test_name) do |*args|
begin
context.run_all_setup_blocks(self)
should[:block].bind(self).call
ensure
context.run_all_teardown_blocks(self)
end
end
end
# Runs all the setup blocks in order
def run_all_setup_blocks(binding)
self.parent.run_all_setup_blocks(binding) if subcontext?
setup_block.bind(binding).call if setup_block
end
# Runs all the teardown blocks in reverse order
def run_all_teardown_blocks(binding)
teardown_block.bind(binding).call if teardown_block
self.parent.run_all_teardown_blocks(binding) if subcontext?
end
# Prints the should_eventually names to stdout
def print_should_eventuallys
should_eventuallys.each do |should|
test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
puts " * DEFERRED: " + test_name
end
subcontexts.each { |context| context.print_should_eventuallys }
end
# Triggers the test method creation process, and prints the unimplemented tests.
def build
shoulds.each do |should|
create_test_from_should_hash(should)
end
subcontexts.each { |context| context.build }
print_should_eventuallys
end
# This delegates all method calls inside a context to the surrounding
# Test::Unit class. This allows us to call Test::Unit macros inside a
# context.
def method_missing(method, *args, &blk)
test_unit_class.send(method, *args, &blk)
end
end
end
module Test # :nodoc: all
module Unit
class TestCase
extend Shoulda
end
end
end

841
lib/shoulda/controller_tests/controller_tests.rb
View File

@ -1,472 +1,467 @@
module Shoulda
module Controller
def self.included(other) # :nodoc:
other.class_eval do
extend Shoulda::Controller::ClassMethods
include Shoulda::Controller::InstanceMethods
Shoulda::Controller::ClassMethods::VALID_FORMATS.each do |format|
include "Shoulda::Controller::#{format.to_s.upcase}".constantize
module ThoughtBot # :nodoc:
module Shoulda # :nodoc:
module Controller
def self.included(other) # :nodoc:
other.class_eval do
extend ThoughtBot::Shoulda::Controller::ClassMethods
include ThoughtBot::Shoulda::Controller::InstanceMethods
ThoughtBot::Shoulda::Controller::ClassMethods::VALID_FORMATS.each do |format|
include "ThoughtBot::Shoulda::Controller::#{format.to_s.upcase}".constantize
end
end
end
end
# = 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
#
# Furthermore, the should_be_restful helper will create an entire set of tests which will verify that your
# controller responds restfully to a variety of requested formats.
module ClassMethods
# Formats tested by #should_be_restful. Defaults to [:html, :xml]
VALID_FORMATS = Dir.glob(File.join(File.dirname(__FILE__), 'formats', '*.rb')).map { |f| File.basename(f, '.rb') }.map(&:to_sym) # :doc:
VALID_FORMATS.each {|f| require "shoulda/controller_tests/formats/#{f}.rb"}
# Actions tested by #should_be_restful
VALID_ACTIONS = [:index, :show, :new, :edit, :create, :update, :destroy] # :doc:
# A ResourceOptions object is passed into should_be_restful in order to configure the tests for your controller.
# = Macro test helpers for your controllers
#
# By using the macro helpers you can quickly and easily create concise and easy to read test suites.
#
# Example:
# class UsersControllerTest < Test::Unit::TestCase
# load_all_fixtures
#
# def setup
# ...normal setup code...
# @user = User.find(:first)
# This code segment:
# context "on GET to :show for first record" do
# setup do
# get :show, :id => 1
# end
#
# should_be_restful do |resource|
# resource.identifier = :id
# resource.klass = User
# resource.object = :user
# resource.parent = []
# resource.actions = [:index, :show, :new, :edit, :update, :create, :destroy]
# resource.formats = [:html, :xml]
#
# resource.create.params = { :name => "bob", :email => 'bob@bob.com', :age => 13}
# resource.update.params = { :name => "sue" }
#
# resource.create.redirect = "user_url(@user)"
# resource.update.redirect = "user_url(@user)"
# resource.destroy.redirect = "users_url"
#
# resource.create.flash = /created/i
# resource.update.flash = /updated/i
# resource.destroy.flash = /removed/i
# 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
#
# Whenever possible, the resource attributes will be set to sensible defaults.
# Would produce 5 tests for the +show+ action
#
class ResourceOptions
# Configuration options for the create, update, destroy actions under should_be_restful
class ActionOptions
# String evaled to get the target of the redirection.
# All of the instance variables set by the controller will be available to the
# evaled code.
#
# Example:
# resource.create.redirect = "user_url(@user.company, @user)"
#
# Defaults to a generated url based on the name of the controller, the action, and the resource.parents list.
attr_accessor :redirect
# Furthermore, the should_be_restful helper will create an entire set of tests which will verify that your
# controller responds restfully to a variety of requested formats.
module ClassMethods
# Formats tested by #should_be_restful. Defaults to [:html, :xml]
VALID_FORMATS = Dir.glob(File.join(File.dirname(__FILE__), 'formats', '*.rb')).map { |f| File.basename(f, '.rb') }.map(&:to_sym) # :doc:
VALID_FORMATS.each {|f| require "shoulda/controller_tests/formats/#{f}.rb"}
# String or Regexp describing a value expected in the flash. Will match against any flash key.
#
# Defaults:
# destroy:: /removed/
# create:: /created/
# update:: /updated/
attr_accessor :flash
# Hash describing the params that should be sent in with this action.
attr_accessor :params
end
# Actions tested by #should_be_restful
VALID_ACTIONS = [:index, :show, :new, :edit, :create, :update, :destroy] # :doc:
# Configuration options for the denied actions under should_be_restful
#
# A ResourceOptions object is passed into should_be_restful in order to configure the tests for your controller.
#
# Example:
# context "The public" do
# setup do
# @request.session[:logged_in] = false
# class UsersControllerTest < Test::Unit::TestCase
# load_all_fixtures
#
# def setup
# ...normal setup code...
# @user = User.find(:first)
# end
#
# should_be_restful do |resource|
# resource.parent = :user
# resource.identifier = :id
# resource.klass = User
# resource.object = :user
# resource.parent = []
# resource.actions = [:index, :show, :new, :edit, :update, :create, :destroy]
# resource.formats = [:html, :xml]
#
# resource.denied.actions = [:index, :show, :edit, :new, :create, :update, :destroy]
# resource.denied.flash = /get outta here/i
# resource.denied.redirect = 'new_session_url'
# end
# resource.create.params = { :name => "bob", :email => 'bob@bob.com', :age => 13}
# resource.update.params = { :name => "sue" }
#
# resource.create.redirect = "user_url(@user)"
# resource.update.redirect = "user_url(@user)"
# resource.destroy.redirect = "users_url"
#
# resource.create.flash = /created/i
# resource.update.flash = /updated/i
# resource.destroy.flash = /removed/i
# end
# end
#
class DeniedOptions
# String evaled to get the target of the redirection.
# All of the instance variables set by the controller will be available to the
# evaled code.
# Whenever possible, the resource attributes will be set to sensible defaults.
#
class ResourceOptions
# Configuration options for the create, update, destroy actions under should_be_restful
class ActionOptions
# String evaled to get the target of the redirection.
# All of the instance variables set by the controller will be available to the
# evaled code.
#
# Example:
# resource.create.redirect = "user_url(@user.company, @user)"
#
# Defaults to a generated url based on the name of the controller, the action, and the resource.parents list.
attr_accessor :redirect
# String or Regexp describing a value expected in the flash. Will match against any flash key.
#
# Defaults:
# destroy:: /removed/
# create:: /created/
# update:: /updated/
attr_accessor :flash
# Hash describing the params that should be sent in with this action.
attr_accessor :params
end
# Configuration options for the denied actions under should_be_restful
#
# Example:
# resource.create.redirect = "user_url(@user.company, @user)"
attr_accessor :redirect
# context "The public" do
# setup do
# @request.session[:logged_in] = false
# end
#
# should_be_restful do |resource|
# resource.parent = :user
#
# resource.denied.actions = [:index, :show, :edit, :new, :create, :update, :destroy]
# resource.denied.flash = /get outta here/i
# resource.denied.redirect = 'new_session_url'
# end
# end
#
class DeniedOptions
# String evaled to get the target of the redirection.
# All of the instance variables set by the controller will be available to the
# evaled code.
#
# Example:
# resource.create.redirect = "user_url(@user.company, @user)"
attr_accessor :redirect
# String or Regexp describing a value expected in the flash. Will match against any flash key.
# String or Regexp describing a value expected in the flash. Will match against any flash key.
#
# Example:
# resource.create.flash = /created/
attr_accessor :flash
# Actions that should be denied (only used by resource.denied). <i>Note that these actions will
# only be tested if they are also listed in +resource.actions+</i>
# The special value of :all will deny all of the REST actions.
attr_accessor :actions
end
# Name of key in params that references the primary key.
# Will almost always be :id (default), unless you are using a plugin or have patched rails.
attr_accessor :identifier
# Name of the ActiveRecord class this resource is responsible for. Automatically determined from
# test class if not explicitly set. UserTest => "User"
attr_accessor :klass
# Name of the instantiated ActiveRecord object that should be used by some of the tests.
# Defaults to the underscored name of the AR class. CompanyManager => :company_manager
attr_accessor :object
# Name of the parent AR objects. Can be set as parent= or parents=, and can take either
# the name of the parent resource (if there's only one), or an array of names (if there's
# more than one).
#
# Example:
# resource.create.flash = /created/
attr_accessor :flash
# Actions that should be denied (only used by resource.denied). <i>Note that these actions will
# only be tested if they are also listed in +resource.actions+</i>
# The special value of :all will deny all of the REST actions.
# # in the routes...
# map.resources :companies do
# map.resources :people do
# map.resources :limbs
# end
# end
#
# # in the tests...
# class PeopleControllerTest < Test::Unit::TestCase
# should_be_restful do |resource|
# resource.parent = :companies
# end
# end
#
# class LimbsControllerTest < Test::Unit::TestCase
# should_be_restful do |resource|
# resource.parents = [:companies, :people]
# end
# end
attr_accessor :parent
alias parents parent
alias parents= parent=
# Actions that should be tested. Must be a subset of VALID_ACTIONS (default).
# Tests for each actionw will only be generated if the action is listed here.
# The special value of :all will test all of the REST actions.
#
# Example (for a read-only controller):
# resource.actions = [:show, :index]
attr_accessor :actions
# Formats that should be tested. Must be a subset of VALID_FORMATS (default).
# Each action will be tested against the formats listed here. The special value
# of :all will test all of the supported formats.
#
# Example:
# resource.actions = [:html, :xml]
attr_accessor :formats
# ActionOptions object specifying options for the create action.
attr_accessor :create
# ActionOptions object specifying options for the update action.
attr_accessor :update
# ActionOptions object specifying options for the desrtoy action.
attr_accessor :destroy
# DeniedOptions object specifying which actions should return deny a request, and what should happen in that case.
attr_accessor :denied
def initialize # :nodoc:
@create = ActionOptions.new
@update = ActionOptions.new
@destroy = ActionOptions.new
@denied = DeniedOptions.new
@create.flash ||= /created/i
@update.flash ||= /updated/i
@destroy.flash ||= /removed/i
@denied.flash ||= /denied/i
@create.params ||= {}
@update.params ||= {}
@actions = VALID_ACTIONS
@formats = VALID_FORMATS
@denied.actions = []
end
def normalize!(target) # :nodoc:
@denied.actions = VALID_ACTIONS if @denied.actions == :all
@actions = VALID_ACTIONS if @actions == :all
@formats = VALID_FORMATS if @formats == :all
@denied.actions = @denied.actions.map(&:to_sym)
@actions = @actions.map(&:to_sym)
@formats = @formats.map(&:to_sym)
ensure_valid_members(@actions, VALID_ACTIONS, 'actions')
ensure_valid_members(@denied.actions, VALID_ACTIONS, 'denied.actions')
ensure_valid_members(@formats, VALID_FORMATS, 'formats')
@identifier ||= :id
@klass ||= target.name.gsub(/ControllerTest$/, '').singularize.constantize
@object ||= @klass.name.tableize.singularize
@parent ||= []
@parent = [@parent] unless @parent.is_a? Array
collection_helper = [@parent, @object.to_s.pluralize, 'url'].flatten.join('_')
collection_args = @parent.map {|n| "@#{object}.#{n}"}.join(', ')
@destroy.redirect ||= "#{collection_helper}(#{collection_args})"
member_helper = [@parent, @object, 'url'].flatten.join('_')
member_args = [@parent.map {|n| "@#{object}.#{n}"}, "@#{object}"].flatten.join(', ')
@create.redirect ||= "#{member_helper}(#{member_args})"
@update.redirect ||= "#{member_helper}(#{member_args})"
@denied.redirect ||= "new_session_url"
end
private
def ensure_valid_members(ary, valid_members, name) # :nodoc:
invalid = ary - valid_members
raise ArgumentError, "Unsupported #{name}: #{invalid.inspect}" unless invalid.empty?
end
end
# Name of key in params that references the primary key.
# Will almost always be :id (default), unless you are using a plugin or have patched rails.
attr_accessor :identifier
# Name of the ActiveRecord class this resource is responsible for. Automatically determined from
# test class if not explicitly set. UserTest => "User"
attr_accessor :klass
# Name of the instantiated ActiveRecord object that should be used by some of the tests.
# Defaults to the underscored name of the AR class. CompanyManager => :company_manager
attr_accessor :object
# Name of the parent AR objects. Can be set as parent= or parents=, and can take either
# the name of the parent resource (if there's only one), or an array of names (if there's
# more than one).
# :section: should_be_restful
# Generates a full suite of tests for a restful controller.
#
# Example:
# # in the routes...
# map.resources :companies do
# map.resources :people do
# map.resources :limbs
# end
# The following definition will generate tests for the +index+, +show+, +new+,
# +edit+, +create+, +update+ and +destroy+ actions, in both +html+ and +xml+ formats:
#
# should_be_restful do |resource|
# resource.parent = :user
#
# resource.create.params = { :title => "first post", :body => 'blah blah blah'}
# resource.update.params = { :title => "changed" }
# end
#
# # in the tests...
# class PeopleControllerTest < Test::Unit::TestCase
# should_be_restful do |resource|
# resource.parent = :companies
# end
# end
# This generates about 40 tests, all of the format:
# "on GET to :show should assign @user."
# "on GET to :show should not set the flash."
# "on GET to :show should render 'show' template."
# "on GET to :show should respond with success."
# "on GET to :show as xml should assign @user."
# "on GET to :show as xml should have ContentType set to 'application/xml'."
# "on GET to :show as xml should respond with success."
# "on GET to :show as xml should return <user/> as the root element."
# The +resource+ parameter passed into the block is a ResourceOptions object, and
# is used to configure the tests for the details of your resources.
#
# class LimbsControllerTest < Test::Unit::TestCase
# should_be_restful do |resource|
# resource.parents = [:companies, :people]
# end
# end
attr_accessor :parent
alias parents parent
alias parents= parent=
# Actions that should be tested. Must be a subset of VALID_ACTIONS (default).
# Tests for each actionw will only be generated if the action is listed here.
# The special value of :all will test all of the REST actions.
#
# Example (for a read-only controller):
# resource.actions = [:show, :index]
attr_accessor :actions
def should_be_restful(&blk) # :yields: resource
resource = ResourceOptions.new
blk.call(resource)
resource.normalize!(self)
# Formats that should be tested. Must be a subset of VALID_FORMATS (default).
# Each action will be tested against the formats listed here. The special value
# of :all will test all of the supported formats.
#
# Example:
# resource.actions = [:html, :xml]
attr_accessor :formats
# ActionOptions object specifying options for the create action.
attr_accessor :create
# ActionOptions object specifying options for the update action.
attr_accessor :update
# ActionOptions object specifying options for the desrtoy action.
attr_accessor :destroy
# DeniedOptions object specifying which actions should return deny a request, and what should happen in that case.
attr_accessor :denied
def initialize # :nodoc:
@create = ActionOptions.new
@update = ActionOptions.new
@destroy = ActionOptions.new
@denied = DeniedOptions.new
@create.flash ||= /created/i
@update.flash ||= /updated/i
@destroy.flash ||= /removed/i
@denied.flash ||= /denied/i
@create.params ||= {}
@update.params ||= {}
@actions = VALID_ACTIONS
@formats = VALID_FORMATS
@denied.actions = []
end
def normalize!(target) # :nodoc:
@denied.actions = VALID_ACTIONS if @denied.actions == :all
@actions = VALID_ACTIONS if @actions == :all
@formats = VALID_FORMATS if @formats == :all
@denied.actions = @denied.actions.map(&:to_sym)
@actions = @actions.map(&:to_sym)
@formats = @formats.map(&:to_sym)
ensure_valid_members(@actions, VALID_ACTIONS, 'actions')
ensure_valid_members(@denied.actions, VALID_ACTIONS, 'denied.actions')
ensure_valid_members(@formats, VALID_FORMATS, 'formats')
@identifier ||= :id
@klass ||= target.name.gsub(/ControllerTest$/, '').singularize.constantize
@object ||= @klass.name.tableize.singularize
@parent ||= []
@parent = [@parent] unless @parent.is_a? Array
collection_helper = [@parent, @object.to_s.pluralize, 'url'].flatten.join('_')
collection_args = @parent.map {|n| "@#{object}.#{n}"}.join(', ')
@destroy.redirect ||= "#{collection_helper}(#{collection_args})"
member_helper = [@parent, @object, 'url'].flatten.join('_')
member_args = [@parent.map {|n| "@#{object}.#{n}"}, "@#{object}"].flatten.join(', ')
@create.redirect ||= "#{member_helper}(#{member_args})"
@update.redirect ||= "#{member_helper}(#{member_args})"
@denied.redirect ||= "new_session_url"
end
private
def ensure_valid_members(ary, valid_members, name) # :nodoc:
invalid = ary - valid_members
raise ArgumentError, "Unsupported #{name}: #{invalid.inspect}" unless invalid.empty?
end
end
# :section: should_be_restful
# Generates a full suite of tests for a restful controller.
#
# The following definition will generate tests for the +index+, +show+, +new+,
# +edit+, +create+, +update+ and +destroy+ actions, in both +html+ and +xml+ formats:
#
# should_be_restful do |resource|
# resource.parent = :user
#
# resource.create.params = { :title => "first post", :body => 'blah blah blah'}
# resource.update.params = { :title => "changed" }
# end
#
# This generates about 40 tests, all of the format:
# "on GET to :show should assign @user."
# "on GET to :show should not set the flash."
# "on GET to :show should render 'show' template."
# "on GET to :show should respond with success."
# "on GET to :show as xml should assign @user."
# "on GET to :show as xml should have ContentType set to 'application/xml'."
# "on GET to :show as xml should respond with success."
# "on GET to :show as xml should return <user/> as the root element."
# The +resource+ parameter passed into the block is a ResourceOptions object, and
# is used to configure the tests for the details of your resources.
#
def should_be_restful(&blk) # :yields: resource
resource = ResourceOptions.new
blk.call(resource)
resource.normalize!(self)
resource.formats.each do |format|
resource.actions.each do |action|
if self.respond_to? :"make_#{action}_#{format}_tests"
self.send(:"make_#{action}_#{format}_tests", resource)
else
should "test #{action} #{format}" do
flunk "Test for #{action} as #{format} not implemented"
resource.formats.each do |format|
resource.actions.each do |action|
if self.respond_to? :"make_#{action}_#{format}_tests"
self.send(:"make_#{action}_#{format}_tests", resource)
else
should "test #{action} #{format}" do
flunk "Test for #{action} as #{format} not implemented"
end
end
end
end
end
end
# :section: Test macros
# 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)
if val
should "have #{val.inspect} in the flash" do
assert_contains flash.values, val, ", Flash: #{flash.inspect}"
# :section: Test macros
# 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)
if val
should "have #{val.inspect} in the flash" do
assert_contains flash.values, val, ", Flash: #{flash.inspect}"
end
else
should "not set the flash" do
assert_equal({}, flash, "Flash was set to:\n#{flash.inspect}")
end
end
else
should "not set the flash" do
assert_equal({}, flash, "Flash was set to:\n#{flash.inspect}")
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 the controller assigned to @name
#
# Example:
#
# should_assign_to :user
def should_assign_to(name)
should "assign @#{name}" do
assert assigns(name.to_sym), "The action isn't assigning to @#{name}"
end
end
# Macro that creates a test asserting that the controller did not assign to @name
#
# Example:
#
# should_not_assign_to :user
def should_not_assign_to(name)
should "not assign to @#{name}" do
assert !assigns(name.to_sym), "@#{name} was visible"
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
assert_response response
end
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 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 '"/"'
# should_redirect_to "users_url(@user)"
def should_redirect_to(url)
should "redirect to #{url.inspect}" do
instantiate_variables_from_assigns do
assert_redirected_to eval(url, self.send(:binding), __FILE__, __LINE__)
end
end
end
# Macro that creates a test asserting that the rendered view contains a <form> element.
def should_render_a_form
should "display a form" do
assert_select "form", true, "The template doesn't contain a <form> element"
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 the controller assigned to @name
#
# Example:
#
# should_assign_to :user
def should_assign_to(name)
should "assign @#{name}" do
assert assigns(name.to_sym), "The action isn't assigning to @#{name}"
end
end
# Macro that creates a test asserting that the controller did not assign to @name
#
# Example:
#
# should_not_assign_to :user
def should_not_assign_to(name)
should "not assign to @#{name}" do
assert !assigns(name.to_sym), "@#{name} was visible"
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
assert_response response
end
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 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 '"/"'
# should_redirect_to "users_url(@user)"
def should_redirect_to(url)
should "redirect to #{url.inspect}" do
instantiate_variables_from_assigns do
assert_redirected_to eval(url, self.send(:binding), __FILE__, __LINE__)
module InstanceMethods # :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
# Macro that creates a test asserting that the rendered view contains a <form> element.
def should_render_a_form
should "display a form" do
assert_select "form", true, "The template doesn't contain a <form> element"
def get_existing_record(res) # :nodoc:
returning(instance_variable_get("@#{res.object}")) do |record|
assert(record, "This test requires you to set @#{res.object} in your setup block")
end
end
end
end
module InstanceMethods # :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])
def make_parent_params(resource, record = nil, parent_names = nil) # :nodoc:
parent_names ||= resource.parents.reverse
return {} if parent_names == [] # Base case
parent_name = parent_names.shift
parent = record ? record.send(parent_name) : parent_name.to_s.classify.constantize.find(:first)
{ :"#{parent_name}_id" => parent.to_param }.merge(make_parent_params(resource, parent, parent_names))
end
end
def get_existing_record(res) # :nodoc:
returning(instance_variable_get("@#{res.object}")) do |record|
assert(record, "This test requires you to set @#{res.object} in your setup block")
end
end
def make_parent_params(resource, record = nil, parent_names = nil) # :nodoc:
parent_names ||= resource.parents.reverse
return {} if parent_names == [] # Base case
parent_name = parent_names.shift
parent = record ? record.send(parent_name) : parent_name.to_s.classify.constantize.find(:first)
{ :"#{parent_name}_id" => parent.to_param }.merge(make_parent_params(resource, parent, parent_names))
end
end
end
end
module ActionController #:nodoc: all
module Integration
class Session
include Shoulda::General
end
end
end
end

348
lib/shoulda/controller_tests/formats/html.rb
View File

@ -1,194 +1,196 @@
module Shoulda
module Controller # :nodoc:
module HTML # :nodoc: all
def self.included(other)
other.class_eval do
extend Shoulda::Controller::HTML::ClassMethods
end
end
module ClassMethods
def controller_name_from_class
self.name.gsub(/Test/, '')
end
def make_show_html_tests(res)
context "on GET to #{controller_name_from_class}#show" do
setup do
record = get_existing_record(res)
parent_params = make_parent_params(res, record)
get :show, parent_params.merge({ res.identifier => record.to_param })
end
if res.denied.actions.include?(:show)
should_not_assign_to res.object
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_assign_to res.object
should_respond_with :success
should_render_template :show
should_not_set_the_flash
end
module ThoughtBot # :nodoc:
module Shoulda # :nodoc:
module Controller # :nodoc:
module HTML # :nodoc: all
def self.included(other)
other.class_eval do
extend ThoughtBot::Shoulda::Controller::HTML::ClassMethods
end
end
module ClassMethods
def controller_name_from_class
self.name.gsub(/Test/, '')
end
def make_edit_html_tests(res)
context "on GET to #{controller_name_from_class}#edit" do
setup do
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
get :edit, parent_params.merge({ res.identifier => @record.to_param })
end
if res.denied.actions.include?(:edit)
should_not_assign_to res.object
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_assign_to res.object
should_respond_with :success
should_render_template :edit
should_not_set_the_flash
should_render_a_form
should "set @#{res.object} to requested instance" do
assert_equal @record, assigns(res.object)
def make_show_html_tests(res)
context "on GET to #{controller_name_from_class}#show" do
setup do
record = get_existing_record(res)
parent_params = make_parent_params(res, record)
get :show, parent_params.merge({ res.identifier => record.to_param })
end
end
end
end
def make_index_html_tests(res)
context "on GET to #{controller_name_from_class}#index" do
setup do
record = get_existing_record(res) rescue nil
parent_params = make_parent_params(res, record)
get(:index, parent_params)
end
if res.denied.actions.include?(:index)
should_not_assign_to res.object.to_s.pluralize
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_respond_with :success
should_assign_to res.object.to_s.pluralize
should_render_template :index
should_not_set_the_flash
end
end
end
def make_new_html_tests(res)
context "on GET to #{controller_name_from_class}#new" do
setup do
record = get_existing_record(res) rescue nil
parent_params = make_parent_params(res, record)
get(:new, parent_params)
end
if res.denied.actions.include?(:new)
should_not_assign_to res.object
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_respond_with :success
should_assign_to res.object
should_not_set_the_flash
should_render_template :new
should_render_a_form
end
end
end
def make_destroy_html_tests(res)
context "on DELETE to #{controller_name_from_class}#destroy" do
setup do
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
delete :destroy, parent_params.merge({ res.identifier => @record.to_param })
end
if res.denied.actions.include?(:destroy)
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
should "not destroy record" do
assert_nothing_raised { assert @record.reload }
end
else
should_set_the_flash_to res.destroy.flash
if res.destroy.redirect.is_a? Symbol
should_respond_with res.destroy.redirect
if res.denied.actions.include?(:show)
should_not_assign_to res.object
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_redirect_to res.destroy.redirect
should_assign_to res.object
should_respond_with :success
should_render_template :show
should_not_set_the_flash
end
end
end
should "destroy record" do
assert_raises(::ActiveRecord::RecordNotFound, "@#{res.object} was not destroyed.") do
@record.reload
def make_edit_html_tests(res)
context "on GET to #{controller_name_from_class}#edit" do
setup do
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
get :edit, parent_params.merge({ res.identifier => @record.to_param })
end
if res.denied.actions.include?(:edit)
should_not_assign_to res.object
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_assign_to res.object
should_respond_with :success
should_render_template :edit
should_not_set_the_flash
should_render_a_form
should "set @#{res.object} to requested instance" do
assert_equal @record, assigns(res.object)
end
end
end
end
end
def make_create_html_tests(res)
context "on POST to #{controller_name_from_class}#create with #{res.create.params.inspect}" do
setup do
record = get_existing_record(res) rescue nil
parent_params = make_parent_params(res, record)
@count = res.klass.count
post :create, parent_params.merge(res.object => res.create.params)
end
if res.denied.actions.include?(:create)
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
should_not_assign_to res.object
should "not create new record" do
assert_equal @count, res.klass.count
end
else
should_assign_to res.object
should_set_the_flash_to res.create.flash
if res.create.redirect.is_a? Symbol
should_respond_with res.create.redirect
def make_index_html_tests(res)
context "on GET to #{controller_name_from_class}#index" do
setup do
record = get_existing_record(res) rescue nil
parent_params = make_parent_params(res, record)
get(:index, parent_params)
end
if res.denied.actions.include?(:index)
should_not_assign_to res.object.to_s.pluralize
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_redirect_to res.create.redirect
should_respond_with :success
should_assign_to res.object.to_s.pluralize
should_render_template :index
should_not_set_the_flash
end
should "not have errors on @#{res.object}" do
assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"
end
end
end
end
end
def make_update_html_tests(res)
context "on PUT to #{controller_name_from_class}#update with #{res.create.params.inspect}" do
setup do
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
put :update, parent_params.merge(res.identifier => @record.to_param, res.object => res.update.params)
end
if res.denied.actions.include?(:update)
should_not_assign_to res.object
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_assign_to res.object
should_set_the_flash_to(res.update.flash)
if res.update.redirect.is_a? Symbol
should_respond_with res.update.redirect
else
should_redirect_to res.update.redirect
def make_new_html_tests(res)
context "on GET to #{controller_name_from_class}#new" do
setup do
record = get_existing_record(res) rescue nil
parent_params = make_parent_params(res, record)
get(:new, parent_params)
end
should "not have errors on @#{res.object}" do
assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"
if res.denied.actions.include?(:new)
should_not_assign_to res.object
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_respond_with :success
should_assign_to res.object
should_not_set_the_flash
should_render_template :new
should_render_a_form
end
end
end
def make_destroy_html_tests(res)
context "on DELETE to #{controller_name_from_class}#destroy" do
setup do
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
delete :destroy, parent_params.merge({ res.identifier => @record.to_param })
end
if res.denied.actions.include?(:destroy)
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
should "not destroy record" do
assert_nothing_raised { assert @record.reload }
end
else
should_set_the_flash_to res.destroy.flash
if res.destroy.redirect.is_a? Symbol
should_respond_with res.destroy.redirect
else
should_redirect_to res.destroy.redirect
end
should "destroy record" do
assert_raises(::ActiveRecord::RecordNotFound, "@#{res.object} was not destroyed.") do
@record.reload
end
end
end
end
end
def make_create_html_tests(res)
context "on POST to #{controller_name_from_class}#create with #{res.create.params.inspect}" do
setup do
record = get_existing_record(res) rescue nil
parent_params = make_parent_params(res, record)
@count = res.klass.count
post :create, parent_params.merge(res.object => res.create.params)
end
if res.denied.actions.include?(:create)
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
should_not_assign_to res.object
should "not create new record" do
assert_equal @count, res.klass.count
end
else
should_assign_to res.object
should_set_the_flash_to res.create.flash
if res.create.redirect.is_a? Symbol
should_respond_with res.create.redirect
else
should_redirect_to res.create.redirect
end
should "not have errors on @#{res.object}" do
assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"
end
end
end
end
def make_update_html_tests(res)
context "on PUT to #{controller_name_from_class}#update with #{res.create.params.inspect}" do
setup do
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
put :update, parent_params.merge(res.identifier => @record.to_param, res.object => res.update.params)
end
if res.denied.actions.include?(:update)
should_not_assign_to res.object
should_redirect_to res.denied.redirect
should_set_the_flash_to res.denied.flash
else
should_assign_to res.object
should_set_the_flash_to(res.update.flash)
if res.update.redirect.is_a? Symbol
should_respond_with res.update.redirect
else
should_redirect_to res.update.redirect
end
should "not have errors on @#{res.object}" do
assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"
end
end
end
end

304
lib/shoulda/controller_tests/formats/xml.rb
View File

@ -1,168 +1,170 @@
module Shoulda
module Controller # :nodoc:
module XML
def self.included(other) #:nodoc:
other.class_eval do
extend Shoulda::Controller::XML::ClassMethods
end
end
module ClassMethods
# Macro that creates a test asserting that the controller responded with an XML content-type
# and that the XML contains +<name/>+ as the root element.
def should_respond_with_xml_for(name = nil)
should "have ContentType set to 'application/xml'" do
assert_xml_response
end
if name
should "return <#{name}/> as the root element" do
body = @response.body.first(100).map {|l| " #{l}"}
assert_select name.to_s.dasherize, 1, "Body:\n#{body}...\nDoes not have <#{name}/> as the root element."
end
module ThoughtBot # :nodoc:
module Shoulda # :nodoc:
module Controller # :nodoc:
module XML
def self.included(other) #:nodoc:
other.class_eval do
extend ThoughtBot::Shoulda::Controller::XML::ClassMethods
end
end
alias should_respond_with_xml should_respond_with_xml_for
protected
def make_show_xml_tests(res) # :nodoc:
context "on GET to #{controller_name_from_class}#show as xml" do
setup do
request_xml
record = get_existing_record(res)
parent_params = make_parent_params(res, record)
get :show, parent_params.merge({ res.identifier => record.to_param })
module ClassMethods
# Macro that creates a test asserting that the controller responded with an XML content-type
# and that the XML contains +<name/>+ as the root element.
def should_respond_with_xml_for(name = nil)
should "have ContentType set to 'application/xml'" do
assert_xml_response
end
if res.denied.actions.include?(:show)
should_not_assign_to res.object
should_respond_with 401
else
should_assign_to res.object
should_respond_with :success
should_respond_with_xml_for res.object
end
end
end
def make_edit_xml_tests(res) # :nodoc:
# XML doesn't need an :edit action
end
def make_new_xml_tests(res) # :nodoc:
# XML doesn't need a :new action
end
def make_index_xml_tests(res) # :nodoc:
context "on GET to #{controller_name_from_class}#index as xml" do
setup do
request_xml
parent_params = make_parent_params(res)
get(:index, parent_params)
end
if res.denied.actions.include?(:index)
should_not_assign_to res.object.to_s.pluralize
should_respond_with 401
else
should_respond_with :success
should_respond_with_xml_for res.object.to_s.pluralize
should_assign_to res.object.to_s.pluralize
end
end
end
def make_destroy_xml_tests(res) # :nodoc:
context "on DELETE to #{controller_name_from_class}#destroy as xml" do
setup do
request_xml
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
delete :destroy, parent_params.merge({ res.identifier => @record.to_param })
end
if res.denied.actions.include?(:destroy)
should_respond_with 401
should "not destroy record" do
assert @record.reload
if name
should "return <#{name}/> as the root element" do
body = @response.body.first(100).map {|l| " #{l}"}
assert_select name.to_s.dasherize, 1, "Body:\n#{body}...\nDoes not have <#{name}/> as the root element."
end
else
should "destroy record" do
assert_raises(::ActiveRecord::RecordNotFound, "@#{res.object} was not destroyed.") do
@record.reload
end
end
alias should_respond_with_xml should_respond_with_xml_for
protected
def make_show_xml_tests(res) # :nodoc:
context "on GET to #{controller_name_from_class}#show as xml" do
setup do
request_xml
record = get_existing_record(res)
parent_params = make_parent_params(res, record)
get :show, parent_params.merge({ res.identifier => record.to_param })
end
if res.denied.actions.include?(:show)
should_not_assign_to res.object
should_respond_with 401
else
should_assign_to res.object
should_respond_with :success
should_respond_with_xml_for res.object
end
end
end
def make_edit_xml_tests(res) # :nodoc:
# XML doesn't need an :edit action
end
def make_new_xml_tests(res) # :nodoc:
# XML doesn't need a :new action
end
def make_index_xml_tests(res) # :nodoc:
context "on GET to #{controller_name_from_class}#index as xml" do
setup do
request_xml
parent_params = make_parent_params(res)
get(:index, parent_params)
end
if res.denied.actions.include?(:index)
should_not_assign_to res.object.to_s.pluralize
should_respond_with 401
else
should_respond_with :success
should_respond_with_xml_for res.object.to_s.pluralize
should_assign_to res.object.to_s.pluralize
end
end
end
def make_destroy_xml_tests(res) # :nodoc:
context "on DELETE to #{controller_name_from_class}#destroy as xml" do
setup do
request_xml
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
delete :destroy, parent_params.merge({ res.identifier => @record.to_param })
end
if res.denied.actions.include?(:destroy)
should_respond_with 401
should "not destroy record" do
assert @record.reload
end
else
should "destroy record" do
assert_raises(::ActiveRecord::RecordNotFound, "@#{res.object} was not destroyed.") do
@record.reload
end
end
end
end
end
def make_create_xml_tests(res) # :nodoc:
context "on POST to #{controller_name_from_class}#create as xml" do
setup do
request_xml
parent_params = make_parent_params(res)
@count = res.klass.count
post :create, parent_params.merge(res.object => res.create.params)
end
if res.denied.actions.include?(:create)
should_respond_with 401
should_not_assign_to res.object
should "not create new record" do
assert_equal @count, res.klass.count
end
else
should_assign_to res.object
should "not have errors on @#{res.object}" do
assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"
end
end
end
end
def make_update_xml_tests(res) # :nodoc:
context "on PUT to #{controller_name_from_class}#update as xml" do
setup do
request_xml
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
put :update, parent_params.merge(res.identifier => @record.to_param, res.object => res.update.params)
end
if res.denied.actions.include?(:update)
should_not_assign_to res.object
should_respond_with 401
else
should_assign_to res.object
should "not have errors on @#{res.object}" do
assert_equal [], assigns(res.object).errors.full_messages, "@#{res.object} has errors:"
end
end
end
end
end
def make_create_xml_tests(res) # :nodoc:
context "on POST to #{controller_name_from_class}#create as xml" do
setup do
request_xml
parent_params = make_parent_params(res)
@count = res.klass.count
post :create, parent_params.merge(res.object => res.create.params)
end
if res.denied.actions.include?(:create)
should_respond_with 401
should_not_assign_to res.object
# Sets the next request's format to 'application/xml'
def request_xml
@request.accept = "application/xml"
end
should "not create new record" do
assert_equal @count, res.klass.count
end
else
should_assign_to res.object
# Asserts that the controller's response was 'application/xml'
def assert_xml_response
content_type = (@response.headers["Content-Type"] || @response.headers["type"]).to_s
regex = %r{\bapplication/xml\b}
should "not have errors on @#{res.object}" do
assert_equal [], pretty_error_messages(assigns(res.object)), "@#{res.object} has errors:"
end
end
end
end
def make_update_xml_tests(res) # :nodoc:
context "on PUT to #{controller_name_from_class}#update as xml" do
setup do
request_xml
@record = get_existing_record(res)
parent_params = make_parent_params(res, @record)
put :update, parent_params.merge(res.identifier => @record.to_param, res.object => res.update.params)
end
if res.denied.actions.include?(:update)
should_not_assign_to res.object
should_respond_with 401
else
should_assign_to res.object
should "not have errors on @#{res.object}" do
assert_equal [], assigns(res.object).errors.full_messages, "@#{res.object} has errors:"
end
end
end
msg = "Content Type '#{content_type.inspect}' doesn't match '#{regex.inspect}'\n"
msg += "Body: #{@response.body.first(100).chomp} ..."
assert_match regex, content_type, msg
end
end
# Sets the next request's format to 'application/xml'
def request_xml
@request.accept = "application/xml"
end
# Asserts that the controller's response was 'application/xml'
def assert_xml_response
content_type = (@response.headers["Content-Type"] || @response.headers["type"]).to_s
regex = %r{\bapplication/xml\b}
msg = "Content Type '#{content_type.inspect}' doesn't match '#{regex.inspect}'\n"
msg += "Body: #{@response.body.first(100).chomp} ..."
assert_match regex, content_type, msg
end
end
end
end

17
lib/shoulda/extensions/proc.rb
View File

@ -1,17 +0,0 @@
begin
require 'active_support'
rescue LoadError
# 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
end

14
lib/shoulda/gem/proc_extensions.rb Normal file
View File

@ -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

241
lib/shoulda/gem/shoulda.rb Normal file
View File

@ -0,0 +1,241 @@
require File.join(File.dirname(__FILE__), 'proc_extensions')
module Thoughtbot
module Shoulda
class << self
attr_accessor :current_context
end
VERSION = '1.1.1'
# = Should statements
#
# Should statements are just syntactic sugar over normal Test::Unit test methods. A should block
# contains all the normal code and assertions you're used to seeing, with the added benefit that
# they can be wrapped inside context blocks (see below).
#
# == Example:
#
# class UserTest << Test::Unit::TestCase
#
# def setup
# @user = User.new("John", "Doe")
# end
#
# should "return its full name"
# assert_equal 'John Doe', @user.full_name
# end
#
# end
#
# ...will produce the following test:
# * <tt>"test: User should return its full name. "</tt>
#
# Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
def should(name, &blk)
should_eventually(name) && return unless block_given?
if Shoulda.current_context
Shoulda.current_context.should(name, &blk)
else
context_name = self.name.gsub(/Test/, "")
context = Thoughtbot::Shoulda::Context.new(context_name, self) do
should(name, &blk)
end
context.build
end
end
# Just like should, but never runs, and instead prints an 'X' in the Test::Unit output.
def should_eventually(name, &blk)
context_name = self.name.gsub(/Test/, "")
context = Thoughtbot::Shoulda::Context.new(context_name, self) do
should_eventually(name, &blk)
end
context.build
end
# = Contexts
#
# A context block groups should statements under a common set of setup/teardown methods.
# Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
# and readability of your test code.
#
# A context block can contain setup, should, should_eventually, and teardown blocks.
#
# 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
# end
# end
#
# This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
#
# Contexts may be nested. Nested contexts run their setup blocks from out to in before each
# should statement. They then run their teardown blocks from in to out after each should statement.
#
# 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
#
# This code will produce the following methods
# * <tt>"test: A User instance should return its full name. "</tt>
# * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
#
# <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt>
# tests</b>. This means you do not have to fully commit to the context/should syntax in a test file.
def context(name, &blk)
if Shoulda.current_context
Shoulda.current_context.context(name, &blk)
else
context = Thoughtbot::Shoulda::Context.new(name, self, &blk)
context.build
end
end
class Context # :nodoc:
attr_accessor :name # my name
attr_accessor :parent # may be another context, or the original test::unit class.
attr_accessor :subcontexts # array of contexts nested under myself
attr_accessor :setup_block # block given via a setup method
attr_accessor :teardown_block # block given via a teardown method
attr_accessor :shoulds # array of hashes representing the should statements
attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
def initialize(name, parent, &blk)
Shoulda.current_context = self
self.name = name
self.parent = parent
self.setup_block = nil
self.teardown_block = nil
self.shoulds = []
self.should_eventuallys = []
self.subcontexts = []
blk.bind(self).call
Shoulda.current_context = nil
end
def context(name, &blk)
subcontexts << Context.new(name, self, &blk)
Shoulda.current_context = self
end
def setup(&blk)
self.setup_block = blk
end
def teardown(&blk)
self.teardown_block = blk
end
def should(name, &blk)
self.shoulds << { :name => name, :block => blk }
end
def should_eventually(name, &blk)
self.should_eventuallys << { :name => name, :block => blk }
end
def full_name
parent_name = parent.full_name if am_subcontext?
return [parent_name, name].join(" ").strip
end
def am_subcontext?
parent.is_a?(self.class) # my parent is the same class as myself.
end
def test_unit_class
am_subcontext? ? parent.test_unit_class : parent
end
def create_test_from_should_hash(should)
test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
if test_unit_class.instance_methods.include?(test_name.to_s)
warn " * WARNING: '#{test_name}' is already defined"
end
context = self
test_unit_class.send(:define_method, test_name) do |*args|
begin
context.run_all_setup_blocks(self)
should[:block].bind(self).call
ensure
context.run_all_teardown_blocks(self)
end
end
end
def run_all_setup_blocks(binding)
self.parent.run_all_setup_blocks(binding) if am_subcontext?
setup_block.bind(binding).call if setup_block
end
def run_all_teardown_blocks(binding)
teardown_block.bind(binding).call if teardown_block
self.parent.run_all_teardown_blocks(binding) if am_subcontext?
end
def print_should_eventuallys
should_eventuallys.each do |should|
test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
puts " * DEFERRED: " + test_name
end
subcontexts.each { |context| context.print_should_eventuallys }
end
def build
shoulds.each do |should|
create_test_from_should_hash(should)
end
subcontexts.each { |context| context.build }
print_should_eventuallys
end
def method_missing(method, *args, &blk)
test_unit_class.send(method, *args, &blk)
end
end
end
end
module Test # :nodoc: all
module Unit
class TestCase
extend Thoughtbot::Shoulda
end
end
end

210
lib/shoulda/general.rb
View File

@ -1,116 +1,118 @@
module Shoulda
module General
def self.included(other) # :nodoc:
other.class_eval do
extend Shoulda::General::ClassMethods
end
end
module ClassMethods
# Loads all fixture files (<tt>test/fixtures/*.yml</tt>)
def load_all_fixtures
all_fixtures = Dir.glob(File.join(Test::Unit::TestCase.fixture_path, "*.yml")).collect do |f|
File.basename(f, '.yml').to_sym
module ThoughtBot # :nodoc:
module Shoulda # :nodoc:
module General
def self.included(other) # :nodoc:
other.class_eval do
extend ThoughtBot::Shoulda::General::ClassMethods
end
fixtures *all_fixtures
end
end
# Prints a message to stdout, tagged with the name of the calling method.
def report!(msg = "")
puts("#{caller.first}: #{msg}")
end
# Asserts that two arrays contain the same elements, the same number of times. Essentially ==, but unordered.
#
# assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
def assert_same_elements(a1, a2, msg = nil)
[:select, :inject, :size].each do |m|
[a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array? It doesn't respond to #{m}.") }
module ClassMethods
# Loads all fixture files (<tt>test/fixtures/*.yml</tt>)
def load_all_fixtures
all_fixtures = Dir.glob(File.join(Test::Unit::TestCase.fixture_path, "*.yml")).collect do |f|
File.basename(f, '.yml').to_sym
end
fixtures *all_fixtures
end
end
# Prints a message to stdout, tagged with the name of the calling method.
def report!(msg = "")
puts("#{caller.first}: #{msg}")
end
assert a1h = a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h }
assert a2h = a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
# Asserts that two arrays contain the same elements, the same number of times. Essentially ==, but unordered.
#
# assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
def assert_same_elements(a1, a2, msg = nil)
[:select, :inject, :size].each do |m|
[a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array? It doesn't respond to #{m}.") }
end
assert_equal(a1h, a2h, msg)
end
assert a1h = a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h }
assert a2h = a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
# Asserts that the given collection contains item x. If x is a regular expression, ensure that
# at least one element from the collection matches x. +extra_msg+ is appended to the error message if the assertion fails.
#
# assert_contains(['a', '1'], /\d/) => passes
# assert_contains(['a', '1'], 'a') => passes
# assert_contains(['a', '1'], /not there/) => fails
def assert_contains(collection, x, extra_msg = "")
collection = [collection] unless collection.is_a?(Array)
msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
case x
when Regexp: assert(collection.detect { |e| e =~ x }, msg)
else assert(collection.include?(x), msg)
end
end
# Asserts that the given collection does not contain item x. If x is a regular expression, ensure that
# none of the elements from the collection match x.
def assert_does_not_contain(collection, x, extra_msg = "")
collection = [collection] unless collection.is_a?(Array)
msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
case x
when Regexp: assert(!collection.detect { |e| e =~ x }, msg)
else assert(!collection.include?(x), msg)
end
end
# Asserts that the given object can be saved
#
# assert_save User.new(params)
def assert_save(obj)
assert obj.save, "Errors: #{pretty_error_messages obj}"
obj.reload
end
# Asserts that the given object is valid
#
# assert_valid User.new(params)
def assert_valid(obj)
assert obj.valid?, "Errors: #{pretty_error_messages obj}"
end
# Asserts that an email was delivered. Can take a block that can further
# narrow down the types of emails you're expecting.
#
# assert_sent_email
#
# Passes if ActionMailer::Base.deliveries has an email
#
# assert_sent_email do |email|
# email.subject =~ /hi there/ && email.to.include?('none@none.com')
# end
#
# Passes if there is an email with subject containing 'hi there' and
# 'none@none.com' as one of the recipients.
#
def assert_sent_email
emails = ActionMailer::Base.deliveries
assert !emails.empty?, "No emails were sent"
if block_given?
matching_emails = emails.select {|email| yield email }
assert !matching_emails.empty?, "None of the emails matched."
assert_equal(a1h, a2h, msg)
end
end
# Asserts that no ActionMailer mails were delivered
#
# assert_did_not_send_email
def assert_did_not_send_email
msg = "Sent #{ActionMailer::Base.deliveries.size} emails.\n"
ActionMailer::Base.deliveries.each { |m| msg << " '#{m.subject}' sent to #{m.to.to_sentence}\n" }
assert ActionMailer::Base.deliveries.empty?, msg
end
# Asserts that the given collection contains item x. If x is a regular expression, ensure that
# at least one element from the collection matches x. +extra_msg+ is appended to the error message if the assertion fails.
#
# assert_contains(['a', '1'], /\d/) => passes
# assert_contains(['a', '1'], 'a') => passes
# assert_contains(['a', '1'], /not there/) => fails
def assert_contains(collection, x, extra_msg = "")
collection = [collection] unless collection.is_a?(Array)
msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
case x
when Regexp: assert(collection.detect { |e| e =~ x }, msg)
else assert(collection.include?(x), msg)
end
end
def pretty_error_messages(obj)
obj.errors.map { |a, m| "#{a} #{m} (#{obj.send(a).inspect})" }
# Asserts that the given collection does not contain item x. If x is a regular expression, ensure that
# none of the elements from the collection match x.
def assert_does_not_contain(collection, x, extra_msg = "")
collection = [collection] unless collection.is_a?(Array)
msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
case x
when Regexp: assert(!collection.detect { |e| e =~ x }, msg)
else assert(!collection.include?(x), msg)
end
end
# Asserts that the given object can be saved
#
# assert_save User.new(params)
def assert_save(obj)
assert obj.save, "Errors: #{pretty_error_messages obj}"
obj.reload
end
# Asserts that the given object is valid
#
# assert_valid User.new(params)
def assert_valid(obj)
assert obj.valid?, "Errors: #{pretty_error_messages obj}"
end
# Asserts that an email was delivered. Can take a block that can further
# narrow down the types of emails you're expecting.
#
# assert_sent_email
#
# Passes if ActionMailer::Base.deliveries has an email
#
# assert_sent_email do |email|
# email.subject =~ /hi there/ && email.to.include?('none@none.com')
# end
#
# Passes if there is an email with subject containing 'hi there' and
# 'none@none.com' as one of the recipients.
#
def assert_sent_email
emails = ActionMailer::Base.deliveries
assert !emails.empty?, "No emails were sent"
if block_given?
matching_emails = emails.select {|email| yield email }
assert !matching_emails.empty?, "None of the emails matched."
end
end
# Asserts that no ActionMailer mails were delivered
#
# assert_did_not_send_email
def assert_did_not_send_email
msg = "Sent #{ActionMailer::Base.deliveries.size} emails.\n"
ActionMailer::Base.deliveries.each { |m| msg << " '#{m.subject}' sent to #{m.to.to_sentence}\n" }
assert ActionMailer::Base.deliveries.empty?, msg
end
def pretty_error_messages(obj)
obj.errors.map { |a, m| "#{a} #{m} (#{obj.send(a).inspect})" }
end
end
end
end

34
lib/shoulda/private_helpers.rb
View File

@ -1,20 +1,22 @@
module Shoulda
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 *ret
end
module ThoughtBot # :nodoc:
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 *ret
end
# Returns the model class constant, as determined by the test class name.
#
# class TestUser; model_class; end => User
def model_class
self.name.gsub(/Test$/, '').constantize
# Returns the model class constant, as determined by the test class name.
#
# class TestUser; model_class; end => User
def model_class
self.name.gsub(/Test$/, '').constantize
end
end
end
end

6
test/shoulda/context_test.rb → test/other/context_test.rb
View File

@ -64,4 +64,10 @@ class ContextTest < Test::Unit::TestCase # :nodoc:
end
end
should_eventually "should pass, since it's unimplemented" do
flunk "what?"
end
should_eventually "should not require a block when using should_eventually"
should "should pass without a block, as that causes it to piggyback to should_eventually"
end

0
test/shoulda/helpers_test.rb → test/other/helpers_test.rb
View File

2
test/shoulda/private_helpers_test.rb → test/other/private_helpers_test.rb
View File

@ -1,7 +1,7 @@
require File.join(File.dirname(__FILE__), '..', 'test_helper')
class PrivateHelpersTest < Test::Unit::TestCase # :nodoc:
include Shoulda::ActiveRecord
include ThoughtBot::Shoulda::ActiveRecord
context "get_options!" do
should "remove opts from args" do
args = [:a, :b, {}]

236
test/shoulda/shoulda_test.rb
View File

@ -1,236 +0,0 @@
require 'test/unit'
require 'rubygems'
require 'mocha'
class ShouldaTest < Test::Unit::TestCase # :nodoc:
should "be able to define a should statement outside of a context" do
assert true
end
should "see the name of my class as ShouldaTest" do
assert_equal "ShouldaTest", self.class.name
end
def self.should_see_class_methods
should "be able to see class methods" do
assert true
end
end
def self.should_see_a_context_block_like_a_Test_Unit_class
should "see a context block as a Test::Unit class" do
assert_equal "ShouldaTest", self.class.name
end
end
def self.should_see_blah
should "see @blah through a macro" do
assert @blah
end
end
def self.should_not_see_blah
should "not see @blah through a macro" do
assert_nil @blah
end
end
def self.should_be_able_to_make_context_macros(prefix = nil)
context "a macro" do
should "have the tests named correctly" do
assert_match(/^test: #{prefix}a macro should have the tests named correctly/, self.to_s)
end
end
end
context "Context" do
should_see_class_methods
should_see_a_context_block_like_a_Test_Unit_class
should_be_able_to_make_context_macros("Context ")
should "not define @blah" do
assert ! self.instance_variables.include?("@blah")
end
should_not_see_blah
should "be able to define a should statement" do
assert true
end
should "see the name of my class as ShouldaTest" do
assert_equal "ShouldaTest", self.class.name
end
context "with a subcontext" do
should_be_able_to_make_context_macros("Context with a subcontext ")
end
end
context "Context with setup block" do
setup do
@blah = "blah"
end
should "have @blah == 'blah'" do
assert_equal "blah", @blah
end
should_see_blah
should "have name set right" do
assert_match(/^test: Context with setup block/, self.to_s)
end
context "and a subcontext" do
setup do
@blah = "#{@blah} twice"
end
should "be named correctly" do
assert_match(/^test: Context with setup block and a subcontext should be named correctly/, self.to_s)
end
should "run the setup methods in order" do
assert_equal @blah, "blah twice"
end
should_see_blah
end
end
context "Another context with setup block" do
setup do
@blah = "foo"
end
should "have @blah == 'foo'" do
assert_equal "foo", @blah
end
should "have name set right" do
assert_match(/^test: Another context with setup block/, self.to_s)
end
should_see_blah
end
should_eventually "pass, since it's a should_eventually" do
flunk "what?"
end
should_eventually "should not require a block when using should_eventually"
should "should pass without a block, as that causes it to piggyback to should_eventually"
# Context creation and naming
def test_should_create_a_new_context
assert_nothing_raised do
Shoulda::Context.new("context name", self) do; end
end
end
def test_should_create_a_nested_context
assert_nothing_raised do
parent = Shoulda::Context.new("Parent", self) do; end
child = Shoulda::Context.new("Child", parent) do; end
end
end
def test_should_name_a_contexts_correctly
parent = Shoulda::Context.new("Parent", self) do; end
child = Shoulda::Context.new("Child", parent) do; end
grandchild = Shoulda::Context.new("GrandChild", child) do; end
assert_equal "Parent", parent.full_name
assert_equal "Parent Child", child.full_name
assert_equal "Parent Child GrandChild", grandchild.full_name
end
# Should statements
def test_should_have_should_hashes_when_given_should_statements
context = Shoulda::Context.new("name", self) do
should "be good" do; end
should "another" do; end
end
names = context.shoulds.map {|s| s[:name]}
assert_equal ["another", "be good"], names.sort
end
# setup and teardown
def test_should_capture_setup_and_teardown_blocks
context = Shoulda::Context.new("name", self) do
setup do; "setup"; end
teardown do; "teardown"; end
end
assert_equal "setup", context.setup_block.call
assert_equal "teardown", context.teardown_block.call
end
# building
def test_should_create_shoulda_test_for_each_should_on_build
context = Shoulda::Context.new("name", self) do
should "one" do; end
should "two" do; end
end
context.expects(:create_test_from_should_hash).with(has_entry(:name => "one"))
context.expects(:create_test_from_should_hash).with(has_entry(:name => "two"))
context.build
end
def test_should_create_test_methods_on_build
tu_class = Test::Unit::TestCase
context = Shoulda::Context.new("A Context", tu_class) do
should "define the test" do; end
end
tu_class.expects(:define_method).with(:"test: A Context should define the test. ")
context.build
end
def test_should_create_test_methods_on_build_when_subcontext
tu_class = Test::Unit::TestCase
context = Shoulda::Context.new("A Context", tu_class) do
context "with a child" do
should "define the test" do; end
end
end
tu_class.expects(:define_method).with(:"test: A Context with a child should define the test. ")
context.build
end
# Test::Unit integration
def test_should_create_a_new_context_and_build_it_on_Test_Unit_context
c = mock("context")
c.expects(:build)
Shoulda::Context.expects(:new).with("foo", kind_of(Class)).returns(c)
self.class.context "foo" do; end
end
def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should
s = mock("test")
Shoulda::Context.any_instance.expects(:should).with("rock").returns(s)
Shoulda::Context.any_instance.expects(:build)
self.class.should "rock" do; end
end
def test_should_define_a_test_on_should
s = mock("test")
Shoulda::Context.any_instance.expects(:should).with("rock").returns(s)
Shoulda::Context.any_instance.expects(:build)
self.class.should "rock" do; end
end
def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should_eventually
s = mock("test")
Shoulda::Context.any_instance.expects(:should_eventually).with("rock").returns(s)
Shoulda::Context.any_instance.expects(:build)
self.class.should_eventually "rock" do; end
end
end