remarkable_rails 3.0.0

data/spec/action_controller/route_matcher_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'route_matcher' do
+  include FunctionalBuilder
+
+  describe 'messages' do
+    before(:each) do
+      @matcher = route(:get, '/projects', :controller => 'boo', :action => 'index')
+    end
+
+    it 'should contain a description message' do
+      @matcher.description.should match(/route GET "\/projects" to\/from/)
+    end
+
+    it 'should set map_to_path? message' do
+      @matcher.matches?(nil)
+      @matcher.failure_message.should match(/Expected to map/)
+    end
+
+    it 'should set map_to_path? message' do
+      @matcher.stub!(:map_to_path?).and_return(true)
+      @matcher.matches?(nil)
+      @matcher.failure_message.should match(/Expected to generate params/)
+    end
+  end
+
+  describe 'matchers' do
+    it { should route(:get,    '/projects',     :controller => :projects, :action => :index) }
+    it { should route(:delete, '/projects/1',   :controller => :projects, :action => :destroy, :id => 1) }
+    it { should route(:get,    '/projects/new', :controller => :projects, :action => :new) }
+
+    # explicitly specify :controller
+    it { should route(:post,   '/projects',     :controller => :projects, :action => :create) }
+
+    # non-string parameter
+    it { should route(:get,    '/projects/1',   :controller => :projects, :action => :show, :id => 1) }
+
+    # string-parameter
+    it { should route(:put,    '/projects/1',   :controller => :projects, :action => :update, :id => "1") }
+
+    # failing case
+    it { should_not route(:get, '/projects',    :controller => :projects, :action => :show) }
+  end
+
+  describe 'macros' do
+    should_route :get,    '/projects',     :controller => :projects, :action => :index
+    should_route :delete, '/projects/1',   :controller => :projects, :action => :destroy, :id => 1
+    should_route :get,    '/projects/new', :controller => :projects, :action => :new
+
+    # explicitly specify :controller
+    should_route :post,   '/projects',     :controller => :projects, :action => :create
+
+    # non-string parameter
+    should_route :get,    '/projects/1',   :controller => :projects, :action => :show,    :id => 1
+
+    # string-parameter
+    should_route :put,    '/projects/1',   :controller => :projects, :action => :update,  :id => "1"
+
+    # failing case
+    should_not_route :get, '/projects',    :controller => :projects, :action => :show
+  end
+
+  describe TasksController, :type => :routing do
+    controller_name 'tasks'
+
+    # Test the nested routes with implicit controller
+    should_route :get,    '/projects/5/tasks',     :action => :index,   :project_id => 5
+    should_route :post,   '/projects/5/tasks',     :action => :create,  :project_id => 5
+    should_route :get,    '/projects/5/tasks/1',   :action => :show,    :id => 1, :project_id => 5
+    should_route :delete, '/projects/5/tasks/1',   :action => :destroy, :id => 1, :project_id => 5
+    should_route :get,    '/projects/5/tasks/new', :action => :new,     :project_id => 5
+    should_route :put,    '/projects/5/tasks/1',   :action => :update,  :id => 1, :project_id => 5
+  end
+
+end

data/spec/action_controller/set_session_matcher_spec.rb

@@ -0,0 +1,135 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'set_session' do
+  include FunctionalBuilder
+
+  describe 'messages' do
+    before(:each) do
+      @matcher = set_session(:user).to(1)
+    end
+
+    it 'should contain a description message' do
+      @matcher = set_session(:user)
+      @matcher.description.should == 'set session variable user'
+
+      @matcher.to(1)
+      @matcher.description.should == 'set session variable user to 1'
+    end
+
+    it 'should set is_not_empty? message' do
+      build_response
+      @matcher = set_session
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected any session variable to be set, got {}'
+    end
+
+    it 'should set contains_value? message' do
+      build_response { session[:user] = 10 }
+      @matcher = set_session.to(1)
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected any session variable to be set to 1, got {:user=>10}'
+    end
+
+    it 'should set assigned_value? message' do
+      build_response
+      @matcher = set_session(:user)
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected session variable user to be set, got {}'
+    end
+
+    it 'should set is_equal_value? message' do
+      build_response { session[:user] = 2 }
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected session variable user to be set to 1, got {:user=>2}'
+    end
+  end
+
+  describe 'matcher' do
+    before(:each) do
+     build_response {
+        session[:user]    = 'jose'
+        session[:address] = 'Avenue'
+        session[:true]    = true
+        session[:false]   = false
+        session[:nil]     = nil
+      }
+    end
+
+    it { should set_session }
+    it { should set_session.to('jose') }
+    it { should set_session(:user) }
+    it { should set_session(:user).to('jose') }
+
+    it { should_not set_session.to('joseph') }
+    it { should_not set_session(:post) }
+    it { should_not set_session(:user).to('joseph') }
+
+    it { should set_session(:user){ 'jose' } }
+    it { should set_session(:user, :to => proc{ 'jose' }) }
+
+    it { should_not set_session(:user).to(nil) }
+    it { should_not set_session(:user){ 'joseph' } }
+    it { should_not set_session(:user, :to => proc{ 'joseph' }) }
+
+    it { should set_session(:true) }
+    it { should set_session(:true).to(true) }
+    it { should_not set_session(:true).to(false) }
+
+    it { should set_session(:false) }
+    it { should set_session(:false).to(false) }
+    it { should_not set_session(:false).to(true) }
+
+    it { should set_session(:nil) }
+    it { should set_session(:nil).to(nil) }
+    it { should_not set_session(:nil).to(true) }
+  end
+
+  describe 'macro' do
+    before(:each) do
+     build_response {
+        session[:user]    = 'jose'
+        session[:address] = 'Avenue'
+        session[:true]    = true
+        session[:false]   = false
+        session[:nil]     = nil
+      }
+    end
+
+    should_set_session
+    should_set_session :to => 'jose'
+    should_set_session :user
+    should_set_session :user, :to => 'jose'
+
+    should_not_set_session :to => 'joseph'
+    should_not_set_session :post
+    should_not_set_session :user, :to => 'joseph'
+
+    should_set_session(:user){ 'jose' }
+    should_set_session :user, :to => proc{ 'jose' }
+
+    should_not_set_session :user, :to => nil
+    should_not_set_session(:user){ 'joseph' }
+    should_not_set_session :user, :to => proc{ 'joseph' }
+
+    should_set_session :true
+    should_set_session :true, :to => true
+    should_not_set_session :true, :to => false
+
+    should_set_session :false
+    should_set_session :false, :to => false
+    should_not_set_session :false, :to => true
+
+    should_set_session :nil
+    should_set_session :nil, :to => nil
+    should_not_set_session :nil, :to => true
+  end
+
+  describe 'with no parameter' do
+    before(:each) { build_response }
+
+    should_not_set_session
+    it { should_not set_session }
+  end
+
+  generate_macro_stubs_specs_for(:set_session)
+end

data/spec/action_controller/set_the_flash_matcher_spec.rb

@@ -0,0 +1,95 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'set_the_flash' do
+  include FunctionalBuilder
+
+  describe 'messages' do
+    before(:each) do
+      @matcher = set_the_flash(:notice).to('hi')
+    end
+
+    it 'should contain a description message' do
+      @matcher = set_the_flash(:notice)
+      @matcher.description.should == 'set the flash message notice'
+
+      @matcher.to('hi')
+      @matcher.description.should == 'set the flash message notice to "hi"'
+    end
+
+    it 'should set is_not_empty? message' do
+      build_response
+      @matcher = set_the_flash
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected any flash message to be set, got {}'
+    end
+
+    it 'should set contains_value? message' do
+      build_response { flash[:notice] = 'bye' }
+      @matcher = set_the_flash.to('hi')
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected any flash message to be set to "hi", got {:notice=>"bye"}'
+    end
+
+    it 'should set assigned_value? message' do
+      build_response
+      @matcher = set_the_flash(:notice)
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected flash message notice to be set, got {}'
+    end
+
+    it 'should set is_equal_value? message' do
+      build_response { flash[:notice] = 'bye' }
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected flash message notice to be set to "hi", got {:notice=>"bye"}'
+    end
+  end
+
+  describe 'matcher' do
+    before(:each) { build_response { flash[:notice] = 'jose' } }
+
+    it { should set_the_flash }
+    it { should set_the_flash.to('jose') }
+    it { should set_the_flash(:notice) }
+    it { should set_the_flash(:notice).to('jose') }
+
+    it { should_not set_the_flash.to('joseph') }
+    it { should_not set_the_flash(:error) }
+    it { should_not set_the_flash(:notice).to('joseph') }
+
+    it { should set_the_flash(:notice){ 'jose' } }
+    it { should set_the_flash(:notice, :to => proc{ 'jose' }) }
+
+    it { should_not set_the_flash(:notice).to(nil) }
+    it { should_not set_the_flash(:notice){ 'joseph' } }
+    it { should_not set_the_flash(:notice, :to => proc{ 'joseph' }) }
+  end
+
+  describe 'macro' do
+    before(:each) { build_response { flash[:notice] = 'jose' } }
+
+    should_set_the_flash
+    should_set_the_flash :to => 'jose'
+    should_set_the_flash :notice
+    should_set_the_flash :notice, :to => 'jose'
+
+    should_not_set_the_flash :to => 'joseph'
+    should_not_set_the_flash :error
+    should_not_set_the_flash :notice, :to => 'joseph'
+
+    should_set_the_flash(:notice){ 'jose' }
+    should_set_the_flash :notice, :to => proc{ 'jose' }
+
+    should_not_set_the_flash :notice, :to => nil
+    should_not_set_the_flash(:notice){ 'joseph' }
+    should_not_set_the_flash :notice, :to => proc{ 'joseph' }
+  end
+
+  describe 'with no parameter' do
+    before(:each) { build_response }
+
+    should_not_set_the_flash
+    it { should_not set_the_flash }
+  end
+
+  generate_macro_stubs_specs_for(:set_the_flash)
+end

data/spec/application/application.rb

@@ -0,0 +1,15 @@
+# Create an application controller to satisfy rspec-rails, a dummy controller
+# and define routes.
+#
+class ApplicationController < ActionController::Base
+end
+
+class Task; end
+
+# Define routes
+ActionController::Routing::Routes.draw do |map|
+  map.resources :projects, :has_many => :tasks
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end
+

data/spec/application/tasks_controller.rb

@@ -0,0 +1,34 @@
+class TasksController < ApplicationController
+  filter_parameter_logging :password
+
+  def index
+    @tasks = Task.find(:all)
+    render :text => 'index'
+  end
+
+  def new
+    render :nothing => true
+  end
+
+  def show
+    @task = Task.find(params[:id])
+
+    respond_to do |format|
+      format.html { render :text => 'show' }
+      format.xml  { render :xml => @task.to_xml }
+    end
+  end
+
+  def destroy
+    @task = Task.find(params[:id])
+    @task.destroy
+
+    flash[:notice]         = 'Task deleted.'
+    session[:last_task_id] = 37
+
+    respond_to do |format|
+     format.html { redirect_to project_tasks_url(10) }
+     format.xml  { head :ok }
+    end
+  end
+end

data/spec/functional_builder.rb

@@ -0,0 +1,93 @@
+# This is based on Shoulda model builder for Test::Unit.
+#
+module FunctionalBuilder
+  def self.included(base)
+    base.class_eval do
+      return unless base.name =~ /^Spec/
+
+      base.controller_name 'application'
+      base.integrate_views false
+
+      after(:each) do
+        if @defined_constants
+          @defined_constants.each do |class_name| 
+            Object.send(:remove_const, class_name)
+          end
+        end
+      end
+    end
+
+    base.extend ClassMethods
+  end
+
+  def build_response(&block)
+    klass = defined?(ExamplesController) ? ExamplesController : define_controller('Examples')
+    block ||= lambda { render :nothing => true }
+    klass.class_eval { define_method(:example, &block) }
+
+    @controller = klass.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    get :example
+
+    self.class.subject { @controller }
+  end
+
+  def define_controller(class_name, &block)
+    class_name = class_name.to_s
+    class_name << 'Controller' unless class_name =~ /Controller$/
+    define_constant(class_name, ApplicationController, &block)
+  end
+
+  def define_constant(class_name, base, &block)
+    class_name = class_name.to_s.camelize
+
+    klass = Class.new(base)
+    Object.const_set(class_name, klass)
+
+    klass.class_eval(&block) if block_given?
+
+    @defined_constants ||= []
+    @defined_constants << class_name
+
+    klass
+  end
+
+  module ClassMethods
+    def generate_macro_stubs_specs_for(matcher, *args)
+      stubs_args = args.dup
+
+      options = args.extract_options!
+      expectations_args = (args << options.merge(:with_expectations => true))
+
+      describe 'macro stubs' do
+        before(:each) do
+          @controller = TasksController.new
+          @request    = ActionController::TestRequest.new
+          @response   = ActionController::TestResponse.new
+        end
+
+        expects :new, :on => String, :with => 'ola', :returns => 'ola'
+        get :new
+
+        it 'should run stubs by default' do
+          String.should_receive(:stub!).with(:new).and_return(@mock=mock('chain'))
+          @mock.should_receive(:and_return).with('ola').and_return('ola')
+
+          send(matcher, *stubs_args).matches?(@controller)
+        end
+
+        it 'should run expectations' do
+          String.should_receive(:should_receive).with(:new).and_return(@mock=mock('chain'))
+          @mock.should_receive(:with).with('ola').and_return(@mock)
+          @mock.should_receive(:exactly).with(1).and_return(@mock)
+          @mock.should_receive(:times).and_return(@mock)
+          @mock.should_receive(:and_return).with('ola').and_return('ola')
+
+          send(matcher, *expectations_args).matches?(@controller)
+        end
+      end
+
+    end
+  end
+end