isabella232 / remarkable-rails Goto Github PK

= Remarkable Rails

Remarkable Rails is a collection of matchers to Rails. This package has some
ActionController matchers and soon some ActionView matchers.

Whenever using the Remarkable Rails gem, it will automatically add your ActiveRecord
matchers. So just one line is needed to install both:

  sudo gem install remarkable_rails

If you are using Rails 2.3, you need to have this configuration on your
config/environments/test.rb:

  config.gem "rspec",            :lib => false
  config.gem "rspec-rails",      :lib => false
  config.gem "remarkable_rails", :lib => false

And then require remarkable inside your spec_helper.rb, after "spec/rails":

  require 'spec/rails'
  require 'remarkable_rails'

== Matchers & Macros

The supported matchers and macros are:

  assign_to, filter_params, render_with_layout, respond_with, 
  respond_with_content_type, route, set_session and set_the_flash matchers.

In Remarkable 3.0, we also ported and extended redirect to and render template
from rspec rails matchers to provide I18n. You can also do:

  render_template 'edit', :layout => 'default'
  respond_with 404, :content_type => Mime::XML, :body => /Not found/

== Macro stubs

Another cool feature in Remarkable 3.0 is macro stubs, which makes your mocks
and stubs DRY and easier to maintain. An rspec default scaffold would be:

  describe TasksController do
    def mock_task(stubs={})
      @task ||= mock_model(Task, stubs)
    end

    describe “responding to #POST create” do
      it "exposes a newly created task as @task" do
        Task.should_receive(:new).with({'these' => 'params'}).
                                  and_return(mock_task(:save => true))
        post :create, :task => {:these => 'params'}
        assigns[:task].should equal(mock_task)
      end

      it "redirects to the created task" do
        Task.stub!(:new).and_return(mock_task(:save => true))
        post :create, :task => {}
        response.should redirect_to(task_url(mock_task))
      end
    end
  end

An equivalent in remarkable would be:

  describe TasksController do
    mock_models :task

    describe :post => :create, :task => { :these => 'params' } do
      expects :new,  :on => Task, :with => {'these' => 'params'}, :returns => task_proc
      expects :save, :on => task_proc, :returns => true

      should_assign_to :task, :with => task_proc
      should_redirect_to { task_url(mock_task) }
    end
  end

It automatically performs the action before running each macro. It executes the
expects as expectations (:should_receive), but you can supply :with_stubs => true
if you want it to be executed with stubs.

There are also params and mime methods:

  describe TasksController
    params :project_id => 42
    mime Mime::HTML

    describe :get => :show, :id => 37 do
      should_assign_to :project, :task

      describe Mime::XML do
        should_assign_to :project, :task
      end
    end
  end

And much more. Be sure to check macro stubs documentation.

== Rails plugin developers

Remarkable automatically loads files at the remarkable directory on your plugins
and frozen gems if RAILS_ROOT is defined. The lookup happens like this:

  RAILS_ROOT/spec/remarkable
  RAILS_ROOT/vendor/gems/*/remarkable
  RAILS_ROOT/vendor/plugins/*/remarkable

Remarkable will load both ruby files (.rb) and Remarkable locale files (.yml).

The only step remaining is to include the matchers, which Remarkable will not
do automatically if the user is not using a Remarkable namespace. For example,
if the developer includes his matchers to Remarkable::ActiveRecord::Matchers,
the matchers will be automatically available in users spec. But if he creates
a new namespace, like MyPlugin::Matchers, he has to tell Remarkable to include
them in the proper example group:

  Remarkable.include_matchers!(MyPlugin::Matchers, Spec::Rails::Example::ModelExampleGroup)