tpitale-shoulda 2.11.0

data/test/functional/posts_controller_test.rb

@@ -0,0 +1,121 @@
+require File.dirname(__FILE__) + '/../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
+      should_render_page_with_metadata :description => /Posts/, :title => /index/
+      should_render_page_with_metadata :keywords => "posts"
+    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'
+      should_respond_with_content_type :rss
+      should_respond_with_content_type /rss/
+      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_set_the_flash_to nil
+      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
+      should_render_a_form
+    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 File.dirname(__FILE__) + '/../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/active_record/allow_mass_assignment_of_matcher_test.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class AllowMassAssignmentOfMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "an attribute that is blacklisted from mass-assignment" do
+    setup do
+      define_model :example, :attr => :string do
+        attr_protected :attr
+      end
+      @model = Example.new
+    end
+
+    should "reject being mass-assignable" do
+      assert_rejects allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute that is not whitelisted for mass-assignment" do
+    setup do
+      define_model :example, :attr => :string, :other => :string do
+        attr_accessible :other
+      end
+      @model = Example.new
+    end
+
+    should "reject being mass-assignable" do
+      assert_rejects allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute that is whitelisted for mass-assignment" do
+    setup do
+      define_model :example, :attr => :string do
+        attr_accessible :attr
+      end
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute not included in the mass-assignment blacklist" do
+    setup do
+      define_model :example, :attr => :string, :other => :string do
+        attr_protected :other
+      end
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute on a class with no protected attributes" do
+    setup do
+      define_model :example, :attr => :string
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+end

data/test/matchers/active_record/allow_value_matcher_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class AllowValueMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "an attribute with a format validation" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /abc/
+      end
+      @model = Example.new
+    end
+
+    should "allow a good value" do
+      assert_accepts allow_value("abcde").for(:attr), @model
+    end
+    
+    should "not allow a bad value" do
+      assert_rejects allow_value("xyz").for(:attr), @model
+    end
+  end
+
+  context "an attribute with a format validation and a custom message" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /abc/, :message => 'bad value'
+      end
+      @model = Example.new
+    end
+
+    should "allow a good value" do
+      assert_accepts allow_value('abcde').for(:attr).with_message(/bad/),
+                     @model
+    end
+    
+    should "not allow a bad value" do
+      assert_rejects allow_value('xyz').for(:attr).with_message(/bad/),
+                     @model
+    end
+  end
+
+  context "an attribute with several validations" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_presence_of     :attr
+        validates_length_of       :attr, :within => 1..5
+        validates_numericality_of :attr, :greater_than_or_equal_to => 1,
+                                         :less_than_or_equal_to    => 50000
+      end
+      @model = Example.new
+    end
+
+    should "allow a good value" do
+      assert_accepts allow_value("12345").for(:attr), @model
+    end
+    
+    bad_values = [nil, "", "abc", "0", "50001", "123456"]
+    bad_values.each do |value|
+      should "not allow a bad value (#{value.inspect})" do
+        assert_rejects allow_value(value).for(:attr), @model
+      end
+    end
+  end
+
+end

data/test/matchers/active_record/association_matcher_test.rb

@@ -0,0 +1,263 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class AssociationMatcherTest < ActiveSupport::TestCase # :nodoc:
+
+  context "belong_to" do
+    setup do
+      @matcher = belong_to(:parent)
+    end
+
+    should "accept a good association with the default foreign key" do
+      define_model :parent
+      define_model :child, :parent_id => :integer do
+        belongs_to :parent
+      end
+      assert_accepts @matcher, Child.new
+    end
+
+    should "reject a nonexistent association" do
+      define_model :child
+      assert_rejects @matcher, Child.new
+    end
+
+    should "reject an association of the wrong type" do
+      define_model :parent, :child_id => :integer
+      child_class = define_model :child do
+        has_one :parent
+      end
+      assert_rejects @matcher, Child.new
+    end
+
+    should "reject an association that has a nonexistent foreign key" do
+      define_model :parent
+      define_model :child do
+        belongs_to :parent
+      end
+      assert_rejects @matcher, Child.new
+    end
+
+    should "accept an association with an existing custom foreign key" do
+      define_model :parent
+      define_model :child, :guardian_id => :integer do
+        belongs_to :parent, :foreign_key => 'guardian_id'
+      end
+      assert_accepts @matcher, Child.new
+    end
+
+    should "accept a polymorphic association" do
+      define_model :child, :parent_type => :string,
+                                :parent_id   => :integer do
+        belongs_to :parent, :polymorphic => true
+      end
+      assert_accepts @matcher, Child.new
+    end
+
+    should "accept an association with a valid :dependent option" do
+      define_model :parent
+      define_model :child, :parent_id => :integer do
+        belongs_to :parent, :dependent => :destroy
+      end
+      assert_accepts @matcher.dependent(:destroy), Child.new
+    end
+
+    should "reject an association with a bad :dependent option" do
+      define_model :parent
+      define_model :child, :parent_id => :integer do
+        belongs_to :parent
+      end
+      assert_rejects @matcher.dependent(:destroy), Child.new
+    end
+  end
+
+  context "have_many" do
+    setup do
+      @matcher = have_many(:children)
+    end
+
+    should "accept a valid association without any options" do
+      define_model :child, :parent_id => :integer
+      define_model :parent do
+        has_many :children
+      end
+      assert_accepts @matcher, Parent.new
+    end
+
+    should "accept a valid association with a :through option" do
+      define_model :child
+      define_model :conception, :child_id  => :integer,
+                                     :parent_id => :integer do
+        belongs_to :child
+      end
+      define_model :parent do
+        has_many :conceptions
+        has_many :children, :through => :conceptions
+      end
+      assert_accepts @matcher, Parent.new
+    end
+
+    should "accept a valid association with an :as option" do
+      define_model :child, :guardian_type => :string,
+                                :guardian_id   => :integer
+      define_model :parent do
+        has_many :children, :as => :guardian
+      end
+      assert_accepts @matcher, Parent.new
+    end
+
+    should "reject an association that has a nonexistent foreign key" do
+      define_model :child
+      define_model :parent do
+        has_many :children
+      end
+      assert_rejects @matcher, Parent.new
+    end
+
+    should "reject an association with a bad :as option" do
+      define_model :child, :caretaker_type => :string,
+                                :caretaker_id   => :integer
+      define_model :parent do
+        has_many :children, :as => :guardian
+      end
+      assert_rejects @matcher, Parent.new
+    end
+
+    should "reject an association that has a bad :through option" do
+      define_model :child, :parent_id => :integer
+      define_model :parent do
+        has_many :children
+      end
+      assert_rejects @matcher.through(:conceptions),
+        Parent.new,
+        :message => /does not have any relationship to conceptions/
+    end
+
+    should "reject an association that has the wrong :through option" do
+      define_model :child
+      define_model :conception, :child_id  => :integer,
+                                     :parent_id => :integer do
+        belongs_to :child
+      end
+      define_model :parent do
+        has_many :conceptions
+        has_many :relationships
+        has_many :children, :through => :conceptions
+      end
+      assert_rejects @matcher.through(:relationships),
+                     Parent.new,
+                     :message => /through relationships, but got it through conceptions/
+    end
+
+    should "accept an association with a valid :dependent option" do
+      define_model :child, :parent_id => :integer
+      define_model :parent do
+        has_many :children, :dependent => :destroy
+      end
+      assert_accepts @matcher.dependent(:destroy), Parent.new
+    end
+
+    should "reject an association with a bad :dependent option" do
+      define_model :child, :parent_id => :integer
+      define_model :parent do
+        has_many :children
+      end
+      assert_rejects @matcher.dependent(:destroy), Parent.new
+    end
+  end
+
+  context "have_one" do
+    setup do
+      @matcher = have_one(:profile)
+    end
+
+    should "accept a valid association without any options" do
+      define_model :profile, :person_id => :integer
+      define_model :person do
+        has_one :profile
+      end
+      assert_accepts @matcher, Person.new
+    end
+
+    should "accept a valid association with an :as option" do
+      define_model :profile, :profilable_id   => :integer,
+                                  :profilable_type => :string
+      define_model :person do
+        has_one :profile, :as => :profilable
+      end
+      assert_accepts @matcher, Person.new
+    end
+
+    should "reject an association that has a nonexistent foreign key" do
+      define_model :profile
+      define_model :person do
+        has_one :profile
+      end
+      assert_rejects @matcher, Person.new
+    end
+
+    should "reject an association with a bad :as option" do
+      define_model :profile, :profilable_id   => :integer,
+                                  :profilable_type => :string
+      define_model :person do
+        has_one :profile, :as => :describable
+      end
+      assert_rejects @matcher, Person.new
+    end
+
+    should "accept an association with a valid :dependent option" do
+      define_model :profile, :person_id => :integer
+      define_model :person do
+        has_one :profile, :dependent => :destroy
+      end
+      assert_accepts @matcher.dependent(:destroy), Person.new
+    end
+
+    should "reject an association with a bad :dependent option" do
+      define_model :profile, :person_id => :integer
+      define_model :person do
+        has_one :profile
+      end
+      assert_rejects @matcher.dependent(:destroy), Person.new
+    end
+  end
+
+  context "have_and_belong_to_many" do
+    setup do
+      @matcher = have_and_belong_to_many(:relatives)
+    end
+
+    should "accept a valid association" do
+      define_model :relatives
+      define_model :person do
+        has_and_belongs_to_many :relatives
+      end
+      define_model :people_relative, :person_id   => :integer,
+                                          :relative_id => :integer
+      assert_accepts @matcher, Person.new
+    end
+
+    should "reject a nonexistent association" do
+      define_model :relatives
+      define_model :person
+      define_model :people_relative, :person_id   => :integer,
+                                          :relative_id => :integer
+      assert_rejects @matcher, Person.new
+    end
+
+    should "reject an association with a nonexistent join table" do
+      define_model :relatives
+      define_model :person do
+        has_and_belongs_to_many :relatives
+      end
+      assert_rejects @matcher, Person.new
+    end
+
+    should "reject an association of the wrong type" do
+      define_model :relatives, :person_id => :integer
+      define_model :person do
+        has_many :relatives
+      end
+      assert_rejects @matcher, Person.new
+    end
+  end
+
+end