remarkable_rails 3.1.0 → 3.1.1

data/CHANGELOG

@@ -1,3 +1,28 @@
+* mock_models now creates a second class method to be used on the index action [#71]
+  In other words, mock_models :project will create:
+
+    def self.mock_project
+     proc { mock_project }
+    end
+
+    # This was added to be used on index actions
+    def self.mock_projects
+      proc { [ mock_project ] }
+    end
+
+    def mock_project(stubs={})
+      @project ||= mock_model(Project, stubs)
+    end
+
+* Allow multiple args to be given to :with in expects. If you need to verify that
+  an array is being sent, you need to send an array inside another array [#70]
+
+* Allow procs or blocks to be given to respond_with_body and respond_with :body [#67]
+
+* Allow ordered to be given to macro stubs as option [#66]
+
+* Allow multiple methods to be given to expects [#65]
+
 # v3.1
 
 * Ensure set_cookies and set_session work with arrays [#55]

data/lib/remarkable_rails/action_controller/macro_stubs.rb

@@ -56,12 +56,27 @@ module Remarkable
     # This also works in the rspec way:
     #
     #   it { should assign_to(:project).with_stubs            }
-    #   it { should render_tempalte('show').with_expectations }
+    #   it { should render_template('show').with_expectations }
+    #
+    # == Attention!
+    #
+    # If you need to check that an array is being sent to a method, you need to
+    # give an array inside another array, for example:
+    #
+    #   expects :comment_ids=, :on => Post, :with => [1,2,3]
+    #
+    # Is the same as:
+    #
+    #   Post.comment_ids = (1, 2, 3)
+    #
+    # And it won't work. The right way to handle this is:
+    #
+    #   expects :comment_ids=, :on => Post, :with => [[1,2,3]]
     #
     # == mock_models
     #
     # You don't have to play with proc all the time. You can call mock_models which
-    # creates a class method that simply returns a proc and a instance method that
+    # creates two class methods that simply returns a proc and a instance method that
     # do the actual mock.
     #
     #   describe ProjectsController do
@@ -71,6 +86,11 @@ module Remarkable
     #
     #   def self.mock_project
     #     proc { mock_project }
+    #   end
+    #
+    #   # To be used on index actions
+    #   def self.mock_projects
+    #     proc { [mock_project] }
     #   end
     #
     #   def mock_project(stubs={})
@@ -180,8 +200,9 @@ module Remarkable
       module ClassMethods
 
         # Creates a chain that will be evaluated as stub or expectation. The
-        # first parameter is the method expected. Also, a block can be given
-        # to calculate the returned value. See examples below.
+        # first parameter is the method expected. You can also specify multiple
+        # methods to stub and give a block to calculate the returned value. See
+        # examples below.
         #
         # == Options
         #
@@ -195,18 +216,26 @@ module Remarkable
         #   required.
         #
         # * <tt>:times</tt> - The number of times the object will receive the
-        #   method. Used only in expectations and when not given, defaults to 1.
+        #   method. Used only in expectations and when not given, defaults to 1.
+        #
+        # * <tt>:ordered</tt> - When true specifies that expectations should
+        #   be received in order.
         #
         # == Example
         #
         #   expects :new, :on => Project, :returns => :mock_project, :times => 2
         #
+        #   expects :new, :find, :on => Project, :returns => :mock_project
+        #
         #   expects :human_attribute_name, :on => Project, :with => :title do |attr|
         #     attr.to_s.humanize
         #   end
         #
         def expects(*args, &block)
-          write_inheritable_array(:expects_chain, [args << block])
+          options = args.extract_options!
+          args.each do |arg|
+            write_inheritable_array(:expects_chain, [ [ arg, options, block] ])
+          end
         end
 
         # The mime type of the request. The value given will be called transformed
@@ -396,15 +425,20 @@ module Remarkable
         #     mock_models :project
         #   end
         #
-        # Will create a class and instance mock method for you:
+        # Will create one instance and two class mock methods for you:
         #
         #   def self.mock_project
         #     proc { mock_project }
+        #   end
+        #
+        #   # To be used on index actions
+        #   def self.mock_projects
+        #     proc { [ mock_project ] }
         #   end
         #
         #   def mock_project(stubs={})
         #     @project ||= mock_model(Project, stubs)
-        #   end
+        #   end
         #
         # If you want to create just the instance method, you can give
         # :class_method => false as option.
@@ -413,12 +447,14 @@ module Remarkable
           options = models.extract_options!
           options = { :class_method => true }.merge(options)
 
-          models.each do |model|
+          models.each do |model|
+            model = model.to_s
             self.class_eval <<-METHOD
-              #{"def self.mock_#{model}; proc { mock_#{model} }; end" if options[:class_method]}
+              #{"def self.mock_#{model}; proc { mock_#{model} }; end"               if options[:class_method]}
+              #{"def self.mock_#{model.pluralize}; proc { [ mock_#{model} ] }; end" if options[:class_method]}
 
               def mock_#{model}(stubs={})
-                @#{model} ||= mock_model(#{model.to_s.classify}, stubs)
+                @#{model} ||= mock_model(#{model.classify}, stubs)
               end
             METHOD
           end
@@ -433,19 +469,22 @@ module Remarkable
         def evaluate_expectation_chain(use_expectations=true) #:nodoc:
           return if self.expects_chain.nil?
 
-          self.expects_chain.each do |method, default_options, block|
-            options = default_options.dup
-
-            # Those are used both in expectations and stubs
-            object       = evaluate_value(options.delete(:on))
-            return_value = evaluate_value(options.delete(:returns))
-
+          self.expects_chain.each do |method, options, block|
+            object = evaluate_value(options[:on])
             raise ScriptError, "You have to give me :on as an option when calling :expects." if object.nil?
 
             if use_expectations
-              chain = object.should_receive(method)
-              chain = chain.with(evaluate_value(options.delete(:with))) if options.key?(:with)
-              chain = chain.exactly(options.delete(:times) || 1).times
+              chain = object.should_receive(method)
+
+              if options.key?(:with)
+                with  = evaluate_value(options[:with])
+                chain = chain.with(*with)
+              end
+
+              times = options[:times] || 1
+              chain = chain.exactly(times).times
+
+              chain = chain.ordered if options[:ordered]
             else
               chain = object.stub!(method)
             end
@@ -453,6 +492,7 @@ module Remarkable
             chain = if block
               chain.and_return(&block)
             else
+              return_value = evaluate_value(options[:returns])
               chain.and_return(return_value)
             end
           end

data/lib/remarkable_rails/action_controller/matchers/render_template_matcher.rb

@@ -122,23 +122,26 @@ module Remarkable
       # Extensions check does not work in Rails 2.1.x.
       #
       def render_template(*args, &block)
-        options = args.extract_options!
-        RenderTemplateMatcher.new(options.merge(:template => args.first), &block).spec(self)
+        options = args.extract_options!
+        options.merge!(:template => args.first)
+        RenderTemplateMatcher.new(options, &block).spec(self)
       end
 
       # This is just a shortcut for render_template :layout => layout. It's also
       # used for Shoulda compatibility. Check render_template for more information.
       #
       def render_with_layout(*args, &block)
-        options = args.extract_options!
-        RenderTemplateMatcher.new(options.merge(:layout => args.first), &block).spec(self)
+        options = args.extract_options!
+        options.merge!(:layout => args.first)
+        RenderTemplateMatcher.new(options, &block).spec(self)
       end
 
       # This is just a shortcut for render_template :layout => nil. It's also
       # used for Shoulda compatibility. Check render_template for more information.
       #
-      def render_without_layout(options={}, &block)
-        RenderTemplateMatcher.new(options.merge(:layout => nil), &block).spec(self)
+      def render_without_layout(options={}, &block)
+        options.merge!(:layout => nil)
+        RenderTemplateMatcher.new(options, &block).spec(self)
       end
 
     end

data/lib/remarkable_rails/action_controller/matchers/respond_with_matcher.rb

@@ -2,7 +2,7 @@ module Remarkable
   module ActionController
     module Matchers
       class RespondWithMatcher < Remarkable::ActionController::Base #:nodoc:
-        arguments
+        arguments :block => true
 
         optional :with, :body, :content_type
 
@@ -11,7 +11,7 @@ module Remarkable
           @controller = @spec.instance_variable_get('@controller')
         end
 
-        before_assert :evaluate_content_type
+        before_assert :evaluate_content_type, :evaluate_body
 
         assertions :status_matches?, :body_matches?, :content_type_matches?
 
@@ -45,7 +45,6 @@ module Remarkable
             assert_contains(@response.content_type, @options[:content_type])
           end
 
-          # Evaluate content_type before assertions to have nice descriptions
           def evaluate_content_type
             return unless @options.key?(:content_type)
 
@@ -57,6 +56,14 @@ module Remarkable
               else
                 @options[:content_type].to_s
             end
+          end
+
+          def evaluate_body
+            if @options.key?(:body) || @block
+              value = @options.key?(:body) ? @options[:body] : @block
+              value = @spec.instance_eval(&value) if value.is_a?(Proc)
+              @options[:body] = value
+            end
           end
 
           def interpolation_options
@@ -98,16 +105,20 @@ module Remarkable
       #   it { should respond_with(300..399).content_type(Mime::XML) }
       #
       def respond_with(*args, &block)
-        options = args.extract_options!
-        RespondWithMatcher.new(options.merge(:with => args.first), &block).spec(self)
+        options = args.extract_options!
+        options.merge!(:with => args.first)
+        RespondWithMatcher.new(options, &block).spec(self)
       end
 
       # This is just a shortcut for respond_with :body => body. Check respond_with
       # for more information.
       #
       def respond_with_body(*args, &block)
-        options = args.extract_options!
-        RespondWithMatcher.new(options.merge(:body => args.first), &block).spec(self)
+        options = args.extract_options!
+        # Since body can be also given as block, only merge if any arguments was
+        # actually sent.
+        options.merge!(:body => args.first) unless args.empty?
+        RespondWithMatcher.new(options, &block).spec(self)
       end
 
       # This is just a shortcut for respond_with :content_type => content_type.
@@ -115,8 +126,9 @@ module Remarkable
       # information.
       #
       def respond_with_content_type(*args, &block)
-        options = args.extract_options!
-        RespondWithMatcher.new(options.merge(:content_type => args.first), &block).spec(self)
+        options = args.extract_options!
+        options.merge!(:content_type => args.first)
+        RespondWithMatcher.new(options, &block).spec(self)
       end
 
     end

data/spec/action_controller/macro_stubs_spec.rb

@@ -10,15 +10,22 @@ describe 'MacroStubs' do
   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)
+    before(:each) do
+      self.class.metaclass.send(:undef_method, :mock_projects) if self.class.respond_to?(:mock_projects)
+      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
+    it 'should create a class singular 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 a class plural mock method' do
+      self.class.respond_to?(:mock_projects).should be_false
+      self.class.mock_models :project
+      self.class.respond_to?(:mock_projects).should be_true
     end
 
     it 'should create an instance mock method' do
@@ -35,18 +42,66 @@ describe 'MacroStubs' do
       self.respond_to?(:mock_project).should be_true
     end
 
-    it 'should create procs which evals to mocks dynamically' do
+    it 'should create procs which evals to a mock 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
+      @task.should be_nil
+      instance_eval(&proc).should == mock_task
+      @task.should_not be_nil
+    end
+
+    it 'should create procs which evals to an array of mocks dynamically' do
+      proc = self.class.mock_tasks
+      proc.should be_kind_of(Proc)
+
+      @task.should be_nil
+      instance_eval(&proc).should == [ mock_task ]
+      @task.should == mock_task
     end
+  end
+
+  describe 'failures' do
+    expects :find, :on => Task, :with => proc{ current_id }, :returns => mock_task
+    expects :max, :min, :count, :on => Task, :ordered => true
+
+    get :show, :id => 37
+
+    it 'should fail if expectation is not met' do
+      self.stub!(:current_id).and_return("42")
+
+      lambda {
+        run_action!(true)
+      }.should raise_error(Spec::Mocks::MockExpectationError, /expected :find with \("42"\) but received it with \("37"\)/)
+    end
+
+    it 'should fail if expectations are received out of order' do
+      lambda {
+        run_action!(true)
+      }.should raise_error(Spec::Mocks::MockExpectationError, /received :count out of order/)
+    end
+
+    it 'should splat an array given to with' do
+      self.stub!(:current_id).and_return([1, 2, 3])
+      run_expectations!
+
+      lambda {
+        Task.find([1,2,3])
+      }.should raise_error(Spec::Mocks::MockExpectationError, /expected :find with \(1\, 2\, 3\) but received it with \(\[1\, 2\, 3\]\)/)
+
+      lambda {
+        Task.find(1, 2, 3)
+      }.should_not raise_error
+    end
+
+    after(:each) do
+      teardown_mocks_for_rspec
+    end
   end
 
   describe 'when extending describe group behavior' do
-    expects :find, :on => Task, :with => proc{ current_id }, :returns => mock_task
+    expects :find, :on => Task, :with => proc{ current_id }, :returns => mock_task
+    expects :count, :max, :min, :on => Task
 
     get :show, :id => 37
     params :special_task_id => 42
@@ -89,8 +144,8 @@ describe 'MacroStubs' do
     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
+      @controller.send(:performed?).should_not be_true
+      get :show, :id => '37' # Execute the action to match expectations
     end
 
     it 'should run action with stubs' do

data/spec/action_controller/respond_with_matcher_spec.rb

@@ -77,7 +77,9 @@ describe 'respond_with' do
       before(:each) { build_response { respond_to{ |format| format.xml { render :xml => [].to_xml } } } }
 
       it { should respond_with_body(%{<?xml version="1.0" encoding="UTF-8"?>\n<nil-classes type="array"/>\n}) }
-      it { should respond_with_body(/xml/)       }
+      it { should respond_with_body(/xml/)       }
+      it { should respond_with_body{/xml/}       }
+      it { should respond_with_body proc{/xml/}  }
       it { should_not respond_with_body('html')  }
       it { should_not respond_with_body(/html/)  }
     end

data/spec/application/tasks_controller.rb

@@ -11,7 +11,12 @@ class TasksController < ApplicationController
   end
 
   def show
-    @task = Task.find(params[:id])
+    @task = Task.find(params[:id])
+
+    # Multiple expects
+    Task.count
+    Task.max
+    Task.min
 
     respond_to do |format|
       format.html { render :text => 'show' }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_rails
 version: !ruby/object:Gem::Version 
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors: 
 - Carlos Brando
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-04 00:00:00 +02:00
+date: 2009-05-13 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,7 +31,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.1.0
+        version: 3.1.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: remarkable_activerecord
@@ -41,7 +41,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.1.0
+        version: 3.1.1
     version: 
 description: "Remarkable Rails: collection of matchers and macros with I18n for Rails"
 email: