class-action 0.0.1 → 1.1.0

data/lib/class_action/rspec/respond_to_format_matcher.rb

@@ -0,0 +1,72 @@
+module ClassAction
+  module RSpec
+
+    class RespondToFormatMatcher
+
+      def initialize(format)
+        @format = format.to_sym
+      end
+
+      def on(condition)
+        @condition = condition
+        self
+      end
+
+      def matches?(action, &block)
+        @action = action
+
+        if action.class._responders.key?([@format, @condition])
+
+          if block
+            # Response defined, we return true but we need to also execute the block,
+            # as it might contain additional checks. First run the action's response
+            # block, for this.
+            respond_block = action.class._responders[ [@format, @condition] ]
+            action.instance_exec &respond_block if respond_block
+            action.send :copy_assigns_to_controller
+            block.call
+          end
+
+          true
+        else
+          false
+        end
+      end
+
+      def description
+        if @condition
+          "respond to format :#{@format} on :#{@condition}"
+        else
+          "respond to format :#{@format}"
+        end
+      end
+
+      def failure_message_for_should
+        if @condition
+          "expected action of class #{@action.class} to respond to format :#{@format} on :#{@condition}"
+        else
+          "expected action of class #{@action.class} to respond to format :#{@format}"
+        end
+      end
+
+      def failure_message_for_should_not
+        if @condition
+          "expected action of class #{@action.class} not to respond to format :#{@format} on :#{@condition}"
+        else
+          "expected action of class #{@action.class} not to respond to format :#{@format}"
+        end
+      end
+
+    end
+
+  end
+end
+
+RSpec::Matchers.module_eval do
+  def respond_to_format(format)
+    ClassAction::RSpec::RespondToFormatMatcher.new(format)
+  end
+  def respond_to_any_format
+    ClassAction::RSpec::RespondToFormatMatcher.new(:any)
+  end
+end

data/lib/class_action/rspec/respond_with_matcher.rb

@@ -0,0 +1,60 @@
+module ClassAction
+  module RSpec
+
+    class RespondWithMatcher
+
+      def initialize(expected)
+        @expected = expected.to_sym
+      end
+
+      def on(condition)
+        @condition = condition
+        self
+      end
+
+      def matches?(action)
+        @action = action
+        @actual = action.class._responses[@condition].try(:to_sym)
+        @actual == @expected
+      end
+
+      def description
+        if @condition
+          "respond with method :#{@expected} on :#{@condition}"
+        else
+          "respond with method :#{@expected}"
+        end
+      end
+
+      def failure_message_for_should
+        suffix = if @actual
+          ", but it responds with :#{@actual}"
+        else
+          ", but it has no response method"
+        end
+
+        if @condition
+          "expected action of class #{@action.class} to respond with :#{@expected} on :#{@condition}#{suffix}"
+        else
+          "expected action of class #{@action.class} to respond with :#{@expected}#{suffix}"
+        end
+      end
+
+      def failure_message_for_should_not
+        if @condition
+          "expected action of class #{@action.class} not to respond with :#{@expected} on :#{@condition}"
+        else
+          "expected action of class #{@action.class} not to respond with :#{@expected}"
+        end
+      end
+
+    end
+
+  end
+end
+
+RSpec::Matchers.module_eval do
+  def respond_with(expected)
+    ClassAction::RSpec::RespondWithMatcher.new(expected)
+  end
+end

data/lib/class_action/rspec.rb

@@ -0,0 +1,3 @@
+Dir[ File.expand_path('../rspec/*.rb', __FILE__) ].each do |file|
+  require file
+end

data/lib/class_action/version.rb

@@ -1,3 +1,3 @@
 module ClassAction
-  VERSION = "0.0.1"
+  VERSION = "1.1.0"
 end

data/lib/class_action.rb

@@ -28,8 +28,13 @@ module ClassAction
         raise ArgumentError, "ClassAction does not support anonymous classes" if action_class.name.nil?
 
         class_eval <<-RUBY, __FILE__, __LINE__+1
+          def _#{action}_action_class
+            @_class_action ||= #{action_class.name}.new self
+          end
+          private :_#{action}_action_class
+
           def #{action}
-            _execute_class_action :#{action}, #{action_class.name}
+            _#{action}_action_class._execute
           end
         RUBY
 
@@ -43,18 +48,18 @@ module ClassAction
     # mimes_for_respond_to hash.
     def inject_class_action_mimes(action, klass)
       # If no responders or a default responder is given, we don't do anything.
-      return if klass.responders.empty? || klass.responders.has_key?(:any)
+      return if klass._responders.empty? || klass._responders.any? { |(mime, _condition), _block| mime == :any }
 
       mimes = mimes_for_respond_to.dup
 
       # Make sure no extra mimes are allowed for the action.
       mimes.each do |mime, restrictions|
-        next if klass.responders.key?(mime)
+        next if klass._responders.any? { |(m, _codition), _block| m == mime }
         exclude_class_action_in_mime_type mime, restrictions, action
       end
 
       # Include all action mimes.
-      klass.responders.each do |mime, _block|
+      klass._responders.each do |(mime, _condition), _block|
         mimes[mime] ||= { :only => [] }
         include_class_action_in_mime_type mime, mimes[mime], action
       end
@@ -64,7 +69,7 @@ module ClassAction
 
     def include_class_action_in_mime_type(mime, restrictions, action)
       if restrictions && restrictions[:except] && restrictions[:except].include?(action)
-        logger.warn "Warning: action #{action} (ClassAction) responds to `#{mime}` but it does not accept this mime type"
+        logger.warn "Warning: action #{action} (ClassAction) responds to `#{mime}` but it does not accept this mime type" if logger
       elsif restrictions && restrictions[:only] && !restrictions[:only].include?(action)
         restrictions[:only] << action
       end
@@ -90,9 +95,8 @@ module ClassAction
 
   private
 
-  def _execute_class_action(name, klass)
-    @_class_action = klass.new(self)
-    @_class_action._execute
+  def _class_action
+    send(:"_#{action_name}_action_class")
   end
 
 end

data/spec/class_action/action_spec.rb

@@ -5,6 +5,7 @@ describe ClassAction::Action do
   let(:controller) { double(:controller, :view_assigns => {}, :response_body => nil) }
   let(:action_class) { Class.new(ClassAction::Action) }
   let(:action) { action_class.new(controller) }
+  before { allow(controller).to receive(:class_action).and_return(action) }
 
   it "should by default be available" do
     expect(action).to be_available
@@ -15,14 +16,16 @@ describe ClassAction::Action do
       expect(action_class.helpers).to be_a(Module)
     end
 
-    it "should define the helper method in the action's helpers module, which should call the method on the controller action" do
+    before do
       action_class.class_eval do
         def helper1
           'HELPER RESULT'
         end
         helper_method :helper1
       end
+    end
 
+    it "should define the helper method in the action's helpers module, which should call the method on the controller action" do
       helpers = action_class.helpers
       klass = Class.new do
         include helpers
@@ -38,20 +41,45 @@ describe ClassAction::Action do
       expect(controller).to receive(:class_action).and_return(action)
       expect(obj.helper1).to eql('HELPER RESULT')
     end
+
+    it "should also expose helper methods on the controller" do
+      action # Load the action up to include the helpers module.
+      expect(controller).to respond_to(:helper1)
+      expect(controller.helper1).to eql('HELPER RESULT')
+    end
+
+    it "should also expose helper methods defined in a superclass" do
+      action_subclass = Class.new(action_class) do
+        def helper2
+          'HELPER2'
+        end
+        helper_method :helper2
+      end
+
+      obj= Class.new{ include action_subclass.helpers }.new
+      expect(obj).to respond_to(:helper1)
+      expect(obj).to respond_to(:helper2)
+    end
+
   end
 
-  describe '.controller_method' do
-    before { allow(controller).to receive(:load_post) }
-    before { action_class.class_eval { controller_method :load_post } }
+  describe 'controller methods' do
+    let(:result) { double(:result) }
+    before { allow(controller).to receive(:load_post).and_return(result) }
 
-    it "should create a protected method :load_post" do
-      expect(action.protected_methods).to include(:load_post)
+    it "should make the action respond to :load_post, but protectedly" do
+      expect(action).not_to respond_to(:load_post)
+      expect(action.respond_to?(:load_post, true)).to be_true # matcher doesn't work with second argument
+    end
+
+    it "should pass the method :load_post on to the controller" do
+      expect(action.load_post).to be(result)
     end
 
-    it "should create a proxy to the controller" do
-      result = double(:result)
-      expect(controller).to receive(:load_post).and_return(result)
-      expect(action.send(:load_post)).to be(result)
+    it "should create a protected method :load_post the first time it is called" do
+      expect(action.protected_methods).not_to include(:load_post)
+      action.load_post
+      expect(action.protected_methods).to include(:load_post)
     end
 
     it "should copy assigns to the controller before executing the controller method, and copy them back afterwards" do
@@ -68,7 +96,6 @@ describe ClassAction::Action do
       end
 
       action_class.class_eval do
-        controller_method :increase_var
         def execute
           @var = 2
           increase_var
@@ -98,7 +125,7 @@ describe ClassAction::Action do
         def method4; end
       end
 
-      expect(action_class.action_methods).to eql([ :method1, :method2 ])
+      expect(action_class._action_methods).to eql([ :method1, :method2 ])
     end
   end
 
@@ -111,22 +138,65 @@ describe ClassAction::Action do
     it "should execute all action methods in the action, and call #copy_assigns_to_controller finally" do
       called = []
 
-      expect(action_class).to receive(:action_methods).and_return([:method1, :method2])
-      expect(action).to receive(:method1) { called << :method1 }
-      expect(action).to receive(:method2) { called << :method2 }
+      expect(action_class).to receive(:_action_methods).and_return([:method1, :method2])
+
+      action_class.class_eval do
+        def method1
+          @called << :method1
+        end
+        def method2
+          @called << :method2
+        end
+      end
 
+      action.instance_variable_set '@called', called
       action._execute
       expect(called).to eql([:method1, :method2])
     end
 
+    it "should skip methods that take arguments" do
+      action_class.class_eval do
+        def one
+          @called = []
+          @called << :one
+        end
+        def two(*args)
+          @called << :two
+        end
+        def three(arg)
+          @called << :three
+        end
+        def three(arg = nil)
+          @called << :four
+        end
+      end
+
+      action._execute
+      called = action.instance_variable_get('@called')
+      expect(called).to eql([:one])
+    end
+
     it "should stop executing when a response body is set" do
       called = []; response_body = nil
 
       allow(controller).to receive(:response_body) { response_body }
-      expect(action_class).to receive(:action_methods).and_return([:method1, :method2])
-      expect(action).to receive(:method1) { called << :method1; response_body = '<html></html>' }
-      expect(action).not_to receive(:method2)
+      allow(controller).to receive(:response).and_return(double())
+      allow(controller.response).to receive(:body) { response_body }
+      allow(controller.response).to receive(:body=) { |val| response_body = val }
+
+      expect(action_class).to receive(:_action_methods).and_return([:method1, :method2])
 
+      action_class.class_eval do
+        def method1
+          @called << :method1
+          response.body = '<html></html>'
+        end
+        def method2
+          @called << :method2
+        end
+      end
+
+      action.instance_variable_set '@called', called
       action._execute
       expect(called).to eql([:method1])
     end
@@ -134,11 +204,20 @@ describe ClassAction::Action do
     it "should call _respond at the end" do
       called = []
 
-      expect(action_class).to receive(:action_methods).and_return([:method1, :method2])
-      expect(action).to receive(:method1) { called << :method1 }
-      expect(action).to receive(:method2) { called << :method2 }
+      expect(action_class).to receive(:_action_methods).and_return([:method1, :method2])
+
+      action_class.class_eval do
+        def method1
+          @called << :method1
+        end
+        def method2
+          @called << :method2
+        end
+      end
+
       expect(action).to receive(:_respond) { called << :_respond }
 
+      action.instance_variable_set '@called', called
       action._execute
       expect(called).to eql([:method1, :method2, :_respond])
     end
@@ -168,7 +247,7 @@ describe ClassAction::Action do
       action._execute
     end
 
-    context "with no respond with or responders" do
+    context "with no response method or responders" do
       it "should not call a respond method, but copy all instance variables into the controller at the end" do
         expect(controller).not_to receive(:respond_with)
         expect(controller).not_to receive(:respond_to)
@@ -176,16 +255,21 @@ describe ClassAction::Action do
       end
     end
 
-    context "having set a respond_with" do
+    context "having set a response method" do
       let(:response) { double(:response) }
       before do
         action_class.class_eval do
           respond_with :response
+          respond_with :invalid_response, on: :invalid
+
+          protected
+
+          def invalid?() false end
         end
-        expect(action).to receive(:response).and_return(response)
       end
 
-      it "should call the respond_with method and use it in the response" do
+      it "should use the value of #response" do
+        expect(action).to receive(:response).and_return(response)
         expect(controller).to receive(:respond_with).with(response) do |&blk|
           expect(blk).to be_nil
         end
@@ -193,10 +277,27 @@ describe ClassAction::Action do
         action._execute
       end
 
+      it "should use the value of #invalid_response if invalid? returns true" do
+        allow(action).to receive(:invalid?).and_return(true)
+        expect(action).to receive(:invalid_response).and_return(response)
+        expect(controller).to receive(:respond_with).with(response)
+        action._execute
+      end
+
+      it "should read an instance variable if this is set" do
+        action_class.class_eval do
+          respond_with :@response
+        end
+        action.instance_variable_set '@response', response
+        expect(controller).to receive(:respond_with).with(response)
+        action._execute
+      end
+
       it "should use the _respond_block if it is set" do
         block = proc{}
         allow(action).to receive(:_respond_block).and_return(block)
 
+        expect(action).to receive(:response).and_return(response)
         expect(controller).to receive(:respond_with).with(response) do |&blk|
           expect(blk).to be(block)
         end
@@ -227,18 +328,29 @@ describe ClassAction::Action do
 
     # Private method, but specced individually to make spec terser.
 
-    let(:respond_block) { action.send(:_respond_block) }
+    def respond_block
+      action.send(:_respond_block)
+    end
 
     it "should create a block using the given responders, which is executed on the action" do
       called = nil; receiver = nil
       json_block = proc { receiver = self; called = :json }
       html_block = proc { receiver = self; called = :html }
-      any_block = proc { receiver = self; called = :any }
+      html_invalid_block = proc { receiver = self; called = :html_invalid }
+      any_ok_block = proc { receiver = self; called = :any_ok }
 
       action_class.class_eval do
         respond_to :json, &json_block
         respond_to :html, &html_block
-        respond_to_any &any_block
+        respond_to :html, on: :invalid, &html_invalid_block
+        respond_to_any on: :ok, &any_ok_block
+
+        attr_accessor :status
+
+        protected
+
+          def ok?() status == :ok end
+          def invalid?() status == :invalid end
       end
 
       # Simulate ActionController's format collector.
@@ -247,16 +359,77 @@ describe ClassAction::Action do
       def collector.html(&block) @html_block = block end
       def collector.any(&block) @any_block = block end
 
+      action.status = :ok
       respond_block.call collector
+      collector.json_block.call
+      expect(receiver).to be(action); expect(called).to be(:json)
 
+      action.status = :invalid
+      respond_block.call collector
       collector.json_block.call
       expect(receiver).to be(action); expect(called).to be(:json)
 
+      action.status = :ok
+      respond_block.call collector
       collector.html_block.call
       expect(receiver).to be(action); expect(called).to be(:html)
 
+      action.status = :invalid
+      respond_block.call collector
+      collector.html_block.call
+      expect(receiver).to be(action); expect(called).to be(:html_invalid)
+
+      action.status = :ok
+      respond_block.call collector
       collector.any_block.call
-      expect(receiver).to be(action); expect(called).to be(:any)
+      expect(receiver).to be(action); expect(called).to be(:any_ok)
+
+      receiver = nil
+      called = nil
+
+      action.status = :invalid
+      expect(collector).not_to receive(:any)
+      respond_block.call collector
+    end
+
+    it "should copy assigns back to the controller after responding" do
+      action_class.class_eval do
+        respond_to :html do
+          @my_var = :value
+        end
+      end
+
+      collector = Class.new{ attr_reader :html_block }.new
+      def collector.html(&block) @html_block = block end
+      respond_block.call collector
+
+      collector.html_block.call
+      expect(controller.instance_variable_get('@my_var')).to be(:value)
+    end
+
+    it "should take responders to a subclass" do
+      action_class.class_eval do
+        respond_to :html
+      end
+      action_subclass = Class.new(action_class) do
+        respond_to :json
+      end
+
+      expect(action_subclass._responders).to eql(
+        [ :html, nil ] => nil,
+        [ :json, nil ] => nil
+      )
+    end
+
+    it "should copy the respond_with_method to a subclass" do
+      action_class.class_eval do
+        respond_with :post
+      end
+
+      action_subclass = Class.new(action_class)
+      expect(action_subclass).to have(1)._response
+      expect(action_subclass._responses.keys[0]).to be_nil
+      expect(action_subclass._responses.values[0]).to be(:post)
     end
 
   end

data/spec/class_action/rspec/have_class_action_matcher_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'class_action/rspec'
+
+describe ClassAction::RSpec::HaveClassActionMatcher do
+
+  class ClassActionTestController < ActionController::Base
+    class Index < ClassAction::Action
+    end
+  end
+
+  let(:controller) { ClassActionTestController.new }
+
+  it "should fail if the controller does not support class actions" do
+    expect { expect(controller).to have_class_action(:index) }.to \
+      raise_error(
+        RSpec::Expectations::ExpectationNotMetError,
+        "expected controller of class ClassActionTestController to have class action :index, but it does not support class actions"
+      )
+  end
+
+  context "having included ClassAction" do
+    before { ClassActionTestController.send :include, ClassAction }
+
+    it "should fail if the controller does not have an index action" do
+      expect { expect(controller).to have_class_action(:index) }.to \
+        raise_error(
+          RSpec::Expectations::ExpectationNotMetError,
+          "expected controller of class ClassActionTestController to have class action :index"
+        )
+    end
+
+    it "should fail if the controller's index action is not a class action" do
+      ClassActionTestController.class_eval do
+        def index
+        end
+      end
+
+      expect { expect(controller).to have_class_action(:index) }.to \
+        raise_error(
+          RSpec::Expectations::ExpectationNotMetError,
+          "expected action ClassActionTestController#index to be a class action"
+        )
+    end
+
+    it "should pass if the index action is a class action" do
+      ClassActionTestController.class_eval do
+        class_action :index
+      end
+
+      expect { expect(controller).to have_class_action(:index) }.not_to raise_error
+    end
+
+    it "should fail if the controller's index action uses a different class" do
+      ClassActionTestController.class_eval do
+        class Index2 < ClassAction::Action
+        end
+
+        class_action :index2, Index2
+      end
+
+      expect { expect(controller).to have_class_action(:index2).using_class(ClassActionTestController::Index) }.to \
+        raise_error(
+          RSpec::Expectations::ExpectationNotMetError,
+          "expected action ClassActionTestController#index2 to use class ClassActionTestController::Index, but it used Index2"
+        )
+    end
+  end
+
+end