### Home Classes Methods

### In Files

- lib/shoulda/macros.rb

### Methods

- #should_change
- #should_create
- #should_destroy
- #should_not_change

### Files

- CONTRIBUTION_GUIDELINES.rdoc
- README.rdoc

### Class/Module Index

Quicksearch

- Shoulda
- Shoulda::ActionController
- Shoulda::ActionController::Macros
- Shoulda::ActionController::Matchers
- Shoulda::ActionMailer
- Shoulda::ActionMailer::Assertions
- Shoulda::ActionMailer::Matchers
- Shoulda::ActiveRecord
- Shoulda::ActiveRecord::Assertions
- Shoulda::ActiveRecord::Helpers
- Shoulda::ActiveRecord::Macros
- Shoulda::ActiveRecord::Matchers
- Shoulda::Assertions
- Shoulda::ClassMethods
- Shoulda::Helpers
- Shoulda::InstanceMethods
- Shoulda::Macros
- ActionController
- Test

No matching classes.

# Shoulda::Macros

### Public Instance Methods

should_change(description, options = {}, &block) click to toggle source

Deprecated.

Macro that creates a test asserting a change between the return value of a block that is run before and after the current setup block is run. This is similar to Active Support’s `assert_difference` assertion, but supports more than just numeric values. See also should_not_change.

The passed description will be used when generating the test name and failure messages.

Example:

    context "Creating a post" do
      setup { Post.create }
      should_change("the number of posts", :by => 1) { Post.count }
    end

As shown in this example, the `:by` option expects a numeric difference between the before and after values of the expression. You may also specify `:from` and `:to` options:

    should_change("the number of posts", :from => 0, :to => 1) { Post.count }
    should_change("the post title", :from => "old", :to => "new") { @post.title }

Combinations of `:by`, `:from`, and `:to` are allowed:

    # Assert the value changed in some way:
    should_change("the post title") { @post.title }

    # Assert the value changed to anything other than "old:"
    should_change("the post title", :from => "old") { @post.title }

    # Assert the value changed to "new:"
    should_change("the post title", :to => "new") { @post.title }

    # File lib/shoulda/macros.rb, line 39
    def should_change(description, options = {}, &block)
      ::ActiveSupport::Deprecation.warn
      by, from, to = get_options!([options], :by, :from, :to)
      stmt = "change #{description}"
      stmt << " from #{from.inspect}" if from
      stmt << " to #{to.inspect}" if to
      stmt << " by #{by.inspect}" if by

      before = lambda { @_before_should_change = block.bind(self).call }
      should stmt, :before => before do
        old_value = @_before_should_change
        new_value = block.bind(self).call
        assert_operator from, :===, old_value, "#{description} did not originally match #{from.inspect}" if from
        assert_not_equal old_value, new_value, "#{description} did not change" unless by == 0
        assert_operator to, :===, new_value, "#{description} was not changed to match #{to.inspect}" if to
        assert_equal old_value + by, new_value if by
      end
    end

should_create(class_name) click to toggle source

Deprecated.

Macro that creates a test asserting that a record of the given class was created.

Example:

    context "creating a post" do
      setup { Post.create(post_attributes) }
      should_create :post
    end

    # File lib/shoulda/macros.rb, line 92
    def should_create(class_name)
      ::ActiveSupport::Deprecation.warn
      should_change_record_count_of(class_name, 1, 'create')
    end

should_destroy(class_name) click to toggle source

Deprecated.

Macro that creates a test asserting that a record of the given class was destroyed.

Example:

    context "destroying a post" do
      setup { Post.first.destroy }
      should_destroy :post
    end

    # File lib/shoulda/macros.rb, line 108
    def should_destroy(class_name)
      ::ActiveSupport::Deprecation.warn
      should_change_record_count_of(class_name, -1, 'destroy')
    end

should_not_change(description, &block) click to toggle source

Deprecated.

Macro that creates a test asserting no change between the return value of a block that is run before and after the current setup block is run. This is the logical opposite of should_change.

The passed description will be used when generating the test name and failure message.

Example:

    context "Updating a post" do
      setup { @post.update_attributes(:title => "new") }
      should_not_change("the number of posts") { Post.count }
    end

    # File lib/shoulda/macros.rb, line 72
    def should_not_change(description, &block)
      ::ActiveSupport::Deprecation.warn
      before = lambda { @_before_should_not_change = block.bind(self).call }
      should "not change #{description}", :before => before do
        new_value = block.bind(self).call
        assert_equal @_before_should_not_change, new_value, "#{description} changed"
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.