remarkable_rails 3.0.0

data/spec/action_controller/assign_to_matcher_spec.rb

@@ -0,0 +1,143 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'assign_to' do
+  include FunctionalBuilder
+
+  describe 'messages' do
+    before(:each) do
+      @matcher = assign_to(:user).with('jose').with_kind_of(String)
+    end
+
+    it 'should contain a description message' do
+      @matcher = assign_to(:user)
+      @matcher.description.should == 'assign user'
+
+      @matcher.with_kind_of(String)
+      @matcher.description.should == 'assign user with kind of String'
+    end
+
+    it 'should set assigned_value? message' do
+      build_response
+      @matcher = assign_to(:user)
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected action to assign user, got no assignment'
+    end
+
+    it 'should set is_kind_of? message' do
+      build_response { @user = 1 }
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected assign user to be kind of String, got a Fixnum'
+    end
+
+    it 'should set is_equal_value? message' do
+      build_response { @user = 'joseph' }
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected assign user to be equal to "jose", got "joseph"'
+    end
+  end
+
+  describe 'matcher' do
+    before(:each) do
+      build_response {
+        @user  = 'jose'
+        @true  = true
+        @false = false
+        @nil   = nil
+      }
+    end
+
+    it { should assign_to(:user) }
+    it { should assign_to(:user).with('jose') }
+    it { should assign_to(:user).with_kind_of(String) }
+
+    it { should_not assign_to(:post) }
+    it { should_not assign_to(:user).with('joseph') }
+    it { should_not assign_to(:user).with_kind_of(Fixnum) }
+
+    it { should assign_to(:user){ 'jose' } }
+    it { should assign_to(:user, :with => proc{ 'jose' }) }
+
+    it { should_not assign_to(:user).with(nil) }
+    it { should_not assign_to(:user){ 'joseph' } }
+    it { should_not assign_to(:user, :with => proc{ 'joseph' }) }
+
+    it { should assign_to(:true) }
+    it { should assign_to(:true).with(true) }
+    it { should_not assign_to(:true).with(false) }
+
+    it { should assign_to(:false) }
+    it { should assign_to(:false).with(false) }
+    it { should_not assign_to(:false).with(true) }
+
+    it { should assign_to(:nil) }
+    it { should assign_to(:nil).with(nil) }
+    it { should_not assign_to(:nil).with(true) }
+  end
+
+  describe 'macro' do
+    before(:each) do
+      build_response {
+        @user  = 'jose'
+        @true  = true
+        @false = false
+        @nil   = nil
+      }
+    end
+
+    should_assign_to :user
+    should_assign_to :user, :with => 'jose'
+    should_assign_to :user, :with_kind_of => String
+
+    should_not_assign_to :post
+    should_not_assign_to :user, :with => 'joseph'
+    should_not_assign_to :user, :with_kind_of => Fixnum
+
+    should_assign_to(:user){ 'jose' }
+    should_assign_to :user, :with => proc{ 'jose' }
+
+    should_not_assign_to :user, :with => nil
+    should_not_assign_to(:user){ 'joseph' }
+    should_not_assign_to :user, :with => proc{ 'joseph' }
+
+    should_assign_to :true
+    should_assign_to :true, :with => true
+    should_not_assign_to :true, :with => false
+
+    should_assign_to :false
+    should_assign_to :false, :with => false
+    should_not_assign_to :false, :with => true
+
+    should_assign_to :nil
+    should_assign_to :nil, :with => nil
+    should_not_assign_to :nil, :with => true
+  end
+
+  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 expectations by default' 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')
+
+      assign_to(:user).matches?(@controller)
+    end
+
+    it 'should run stubs' do
+      String.should_receive(:stub!).with(:new).and_return(@mock=mock('chain'))
+      @mock.should_receive(:and_return).with('ola').and_return('ola')
+
+      assign_to(:user, :with_stubs => true).matches?(@controller)
+    end
+
+  end
+end

data/spec/action_controller/filter_params_matcher_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'filter_params' do
+  include FunctionalBuilder
+
+  describe 'messages' do
+    before(:each) do
+      @controller = define_controller :Posts do
+        filter_parameter_logging :password
+      end.new
+
+      @matcher = filter_params(:user)
+    end
+
+    it 'should contain a description message' do
+      @matcher.description.should == 'filter user parameters from log'
+    end
+
+    it 'should set respond_to_filter_params? message' do
+      @controller = define_controller(:Comments).new
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected controller to respond to filter_parameters (controller is not filtering any parameter)'
+    end
+
+    it 'should set is_filtered? message' do
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected user to be filtered, got no filtering'
+    end
+  end
+
+  describe 'filtering parameter' do
+    before(:each) do 
+      @controller = define_controller :Comments do
+        filter_parameter_logging :password
+      end.new
+
+      self.class.subject { @controller }
+    end
+
+    should_filter_params
+    should_filter_params(:password)
+    should_not_filter_params(:user)
+
+    it { should filter_params }
+    it { should filter_params(:password) }
+    it { should_not filter_params(:user) }
+  end
+
+  describe 'not filtering parameter' do
+    before(:each) do 
+      @controller = define_controller(:Comments).new
+      self.class.subject { @controller }
+    end
+
+    should_not_filter_params
+    should_not_filter_params(:password)
+    should_not_filter_params(:user)
+
+    it { should_not filter_params }
+    it { should_not filter_params(:user) }
+    it { should_not filter_params(:password) }
+  end
+
+end

data/spec/action_controller/macro_stubs_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+# Define a metaclass in the Object because we are going to need it.
+class Object; def metaclass; class << self; self; end; end; end
+
+describe 'MacroStubs' do
+  controller_name 'tasks'
+  mock_models :task
+
+  def current_id; '37'; end
+
+  describe 'mock_models' do
+    before(:each) do
+      self.class.metaclass.send(:undef_method, :mock_project) if self.class.respond_to?(:mock_project)
+      self.class.send(:undef_method, :mock_project)           if self.respond_to?(:mock_project)
+    end
+
+    it 'should create a class mock method' do
+      self.class.respond_to?(:mock_project).should be_false
+      self.class.mock_models :project
+      self.class.respond_to?(:mock_project).should be_true
+    end
+
+    it 'should create an instance mock method' do
+      self.respond_to?(:mock_project).should be_false
+      self.class.mock_models :project
+      self.respond_to?(:mock_project).should be_true
+    end
+
+    it 'should create just an instance method when :class_method is false' do
+      self.class.respond_to?(:mock_project).should be_false
+      self.respond_to?(:mock_project).should be_false
+      self.class.mock_models :project, :class_method => false
+      self.class.respond_to?(:mock_project).should be_false
+      self.respond_to?(:mock_project).should be_true
+    end
+
+    it 'should create procs which evals to mocks dynamically' do
+      proc = self.class.mock_task
+      proc.should be_kind_of(Proc)
+
+      self.instance_variable_get('@task').should be_nil
+      instance_eval(&proc)
+      self.instance_variable_get('@task').should_not be_nil
+    end
+  end
+
+  describe 'when extending describe group behavior' do
+    expects :find, :on => Task, :with => proc{ current_id }, :returns => mock_task
+
+    get :show, :id => 37
+    params :special_task_id => 42
+    mime Mime::HTML
+
+    it 'should run action declared in a class method' do
+      @controller.send(:performed?).should_not be_true
+
+      run_action!(false)
+
+      @controller.action_name.should == 'show'
+      @controller.request.method.should == :get
+      @controller.send(:performed?).should be_true
+    end
+
+    it 'should use parameters given in params on request' do
+      self.should_receive(:current_id).once.and_return('37')
+      run_action!
+      @request.parameters[:special_task_id].should == '42'
+    end
+
+    it 'should respond with the supplied mime type' do
+      self.should_receive(:current_id).once.and_return('37')
+      run_action!
+      @response.content_type.should == Mime::HTML.to_s
+    end
+
+    it 'should run action with expectations' do
+      self.should_receive(:current_id).once.and_return('37')
+      run_action!
+      @controller.send(:performed?).should be_true
+    end
+
+    it 'should not run action twice' do
+      run_action!
+      @controller.send(:performed?).should be_true
+      proc{ run_action!.should be_false }.should_not raise_error
+    end
+
+    it 'should run expectations without performing an action' do
+      self.should_receive(:current_id).once.and_return('37')
+      run_expectations!
+      @controller.send(:performed?).should_not be_true
+      Task.find('37') # Execute expectations by hand
+    end
+
+    it 'should run action with stubs' do
+      self.should_receive(:current_id).never
+      run_action!(false)
+      @controller.send(:performed?).should be_true
+    end
+
+    it 'should run stubs without performing an action' do
+      self.should_receive(:current_id).never
+      run_stubs!
+      @controller.send(:performed?).should_not be_true
+    end
+
+    describe Mime::XML do
+      expects :to_xml, :on => mock_task, :returns => 'XML'
+
+      it 'should provide a description based on the mime given in describe' do
+        self.class.description.should =~ /with xml$/
+      end
+
+      it 'should run action based on inherited declarations' do
+        @controller.send(:performed?).should_not be_true
+
+        run_action!
+
+        @controller.action_name.should == 'show'
+        @controller.request.method.should == :get
+        @controller.send(:performed?).should be_true
+        @controller.response.body.should == 'XML'
+        @request.parameters[:special_task_id].should == '42'
+      end
+    end
+
+    describe 'and running actions in a before(:all) filter' do
+      get :show, :id => 37
+
+      get! do
+        @request.should_not be_nil
+      end
+
+      get! do
+        @flag = true
+      end
+
+      get! do
+        @controller.should_not be_nil
+      end
+
+      it 'should run the action before each example' do
+        @controller.send(:performed?).should be_true
+      end
+
+      it 'should execute the given block' do
+        @flag.should be_true
+      end
+    end
+  end
+
+  describe 'with matcher macros' do
+
+    [:delete, :delete!].each do |method|
+
+      describe method => :destroy, :id => 37 do
+        expects :find,    :on => Task,     :with => '37', :returns => mock_task
+        expects :destroy, :on => mock_task
+
+        subject { controller }
+
+        should_assign_to :task
+        should_assign_to :task, :with => mock_task
+        should_assign_to :task, :with_kind_of => Task
+
+        should_set_the_flash
+        should_set_the_flash :notice
+        should_set_the_flash :notice, :to => 'Task deleted.'
+
+        should_set_session
+        should_set_session :last_task_id
+        should_set_session :last_task_id, :to => 37
+
+        should_redirect_to{ project_tasks_url(10) }
+        should_redirect_to proc{ project_tasks_url(10) }, :with => 302
+
+        it 'should run action declared in describe' do
+          @controller.send(:performed?).should_not be_true unless method == :delete!
+
+          run_action!
+
+          @controller.action_name.should == 'destroy'
+          @controller.request.method.should == :delete
+          @controller.send(:performed?).should be_true
+        end
+
+        it 'should provide a description based on parameters given in describe' do
+          self.class.description.should =~ /responding to #DELETE destroy$/
+        end
+      end
+
+    end
+
+  end
+end

data/spec/action_controller/redirect_to_matcher_spec.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'redirect_to' do
+  include FunctionalBuilder
+
+  describe 'messages' do
+    before(:each) do
+      build_response { redirect_to projects_url }
+      @matcher = redirect_to(project_tasks_url(1)).with(302)
+    end
+
+    it 'should contain a description message' do
+      @matcher = redirect_to(project_tasks_url(1))
+      @matcher.description.should == 'redirect to "http://test.host/projects/1/tasks"'
+
+      @matcher.with(301)
+      @matcher.description.should == 'redirect to "http://test.host/projects/1/tasks" with status 301'
+    end
+
+    it 'should set redirected? message' do
+      build_response
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected redirect to "http://test.host/projects/1/tasks", got no redirect'
+    end
+
+    it 'should set status_matches? message' do
+      @matcher.with(200).matches?(@controller)
+      @matcher.failure_message.should == 'Expected redirect to "http://test.host/projects/1/tasks" with status 200, got status 302'
+    end
+
+    it 'should set url_matches? message' do
+      @matcher.matches?(@controller)
+      @matcher.failure_message.should == 'Expected redirect to "http://test.host/projects/1/tasks", got redirect to "http://test.host/projects"'
+    end
+  end
+
+  describe 'matcher' do
+
+    {
+      :hash => { :controller => 'tasks', :action => 'index', :project_id => 1 },
+      :url =>  'http://test.host/projects/1/tasks',
+      :path => '/projects/1/tasks'
+    }.each do |type, route|
+      describe "redirecting to an #{type}" do 
+        before(:each){ build_response { redirect_to route } }
+
+        it { should redirect_to(project_tasks_url(1)) }
+        it { should redirect_to(project_tasks_path(1)) }
+        it { should redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1) }
+        it { should redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1).with(302) }
+
+        it { should_not redirect_to(project_tasks_url(2)) }
+        it { should_not redirect_to(project_tasks_path(2)) }
+        it { should_not redirect_to(:controller => 'tasks', :action => 'index', :project_id => 2) }
+        it { should_not redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1).with(301) }
+
+        it { response.should redirect_to(project_tasks_url(1)) }
+        it { response.should redirect_to(project_tasks_path(1)) }
+        it { response.should redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1) }
+        it { response.should redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1).with(302) }
+
+        it { response.should_not redirect_to(project_tasks_url(2)) }
+        it { response.should_not redirect_to(project_tasks_path(2)) }
+        it { response.should_not redirect_to(:controller => 'tasks', :action => 'index', :project_id => 2) }
+        it { response.should_not redirect_to(:controller => 'tasks', :action => 'index', :project_id => 1).with(301) }
+      end
+    end
+
+  end
+
+  describe 'macro' do
+
+    {
+      :hash => { :controller => 'tasks', :action => 'index', :project_id => 1 },
+      :url =>  'http://test.host/projects/1/tasks',
+      :path => '/projects/1/tasks'
+    }.each do |type, route|
+      describe "redirecting to an #{type}" do 
+        before(:each){ build_response { redirect_to route } }
+
+        should_redirect_to{ project_tasks_url(1) }
+        should_redirect_to{ project_tasks_path(1) }
+        should_redirect_to proc{ project_tasks_url(1) }
+        should_redirect_to proc{ project_tasks_path(1) }
+        should_redirect_to proc{ project_tasks_url(1) }, :with => 302
+        should_redirect_to proc{ project_tasks_path(1) }, :with => 302
+        should_redirect_to :controller => 'tasks', :action => 'index', :project_id => 1
+
+        should_not_redirect_to{ project_tasks_url(2) }
+        should_not_redirect_to{ project_tasks_path(2) }
+        should_not_redirect_to proc{ project_tasks_url(2) }
+        should_not_redirect_to proc{ project_tasks_path(2) }
+        should_not_redirect_to proc{ project_tasks_url(1) }, :with => 301
+        should_not_redirect_to proc{ project_tasks_path(1) }, :with => 301
+        should_not_redirect_to :controller => 'tasks', :action => 'index', :project_id => 2
+      end
+    end
+
+  end
+
+  generate_macro_stubs_specs_for(:redirect_to, 'http://google.com/')
+end