shoulda 2.11.3 → 3.0.0.beta1

data/test/fixtures/posts.yml

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

data/test/fixtures/tags.yml

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

data/test/fixtures/users.yml

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

data/test/functional/posts_controller_test.rb

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

data/test/functional/users_controller_test.rb

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

data/test/matchers/action_mailer/have_sent_email_test.rb

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

data/test/matchers/active_record/allow_mass_assignment_of_matcher_test.rb

@@ -1,74 +0,0 @@
-require '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
-
-    should "assign a negative failure message" do
-      matcher = allow_mass_assignment_of(:attr)
-      matcher.matches?(@model)
-      assert_not_nil matcher.negative_failure_message
-    end
-  end
-
-end

data/test/matchers/active_record/allow_value_matcher_test.rb

@@ -1,64 +0,0 @@
-require '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

@@ -1,263 +0,0 @@
-require '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(:detail)
-    end
-
-    should "accept a valid association without any options" do
-      define_model :detail, :person_id => :integer
-      define_model :person do
-        has_one :detail
-      end
-      assert_accepts @matcher, Person.new
-    end
-
-    should "accept a valid association with an :as option" do
-      define_model :detail, :detailable_id   => :integer,
-                                  :detailable_type => :string
-      define_model :person do
-        has_one :detail, :as => :detailable
-      end
-      assert_accepts @matcher, Person.new
-    end
-
-    should "reject an association that has a nonexistent foreign key" do
-      define_model :detail
-      define_model :person do
-        has_one :detail
-      end
-      assert_rejects @matcher, Person.new
-    end
-
-    should "reject an association with a bad :as option" do
-      define_model :detail, :detailable_id   => :integer,
-                                  :detailable_type => :string
-      define_model :person do
-        has_one :detail, :as => :describable
-      end
-      assert_rejects @matcher, Person.new
-    end
-
-    should "accept an association with a valid :dependent option" do
-      define_model :detail, :person_id => :integer
-      define_model :person do
-        has_one :detail, :dependent => :destroy
-      end
-      assert_accepts @matcher.dependent(:destroy), Person.new
-    end
-
-    should "reject an association with a bad :dependent option" do
-      define_model :detail, :person_id => :integer
-      define_model :person do
-        has_one :detail
-      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