remarkable_rails 3.0.0

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

@@ -0,0 +1,94 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      # Do not inherit from ActionController::Base since it don't need all macro stubs behavior.
+      class RouteMatcher < Remarkable::Base #:nodoc:
+        arguments :method, :path
+
+        assertions :map_to_path?, :generate_params?
+
+        before_assert do
+          @options[:controller] ||= controller_name
+
+          @populated_path = @path.dup
+
+          @options.each do |key, value|
+            @options[key] = value.to_param if value.respond_to?(:to_param)
+            @populated_path.gsub!(key.inspect, value.to_s)
+          end
+
+          ::ActionController::Routing::Routes.reload if ::ActionController::Routing::Routes.empty?
+        end
+
+        private
+
+          def map_to_path?
+            route_for = ::ActionController::Routing::Routes.generate(@options) rescue nil
+            return route_for == @populated_path, :actual => route_for.inspect
+          end
+
+          def generate_params?
+            params_from = ::ActionController::Routing::Routes.recognize_path(@populated_path, :method => @method.to_sym)
+            return params_from == @options, :actual => params_from.inspect
+          end
+
+          # First tries to get the controller name from the subject, then from
+          # the spec class using controller class or finally, from the described
+          # class.
+          #
+          # We have to try the described class because we don't have neither the
+          # subject or the controller class in the RoutingExampleGroup.
+          #
+          def controller_name
+            spec_class = @spec.class unless @spec.class == Class
+
+            controller = if @subject && @subject.class.ancestors.include?(::ActionController::Base)
+              @subject.class
+            elsif spec_class.respond_to?(:controller_class)
+              spec_class.controller_class
+            elsif spec_class.respond_to?(:described_class)
+              spec_class.described_class
+            end
+
+            if controller && controller.ancestors.include?(::ActionController::Base)
+              controller.name.gsub(/Controller$/, '').tableize
+            else
+              raise ArgumentError, "I cannot guess the controller name in route. Please supply :controller as option"
+            end
+          end
+
+          def interpolation_options
+            { :options => @options.inspect, :method => @method.to_s.upcase, :path => @path.inspect }
+          end
+
+      end
+
+      # Assert route generation AND route recognition.
+      #
+      # == Examples
+      #
+      #   # autodetects the :controller
+      #   should_route :get,    '/posts',         :action => :index
+      #
+      #   # explicitly specify :controller
+      #   should_route :post,   '/posts',         :controller => :posts, :action => :create
+      #
+      #   # non-string parameter
+      #   should_route :get,    '/posts/1',       :controller => :posts, :action => :show,    :id => 1
+      #
+      #   # string-parameter
+      #   should_route :put,    '/posts/1',       :controller => :posts, :action => :update,  :id => "1"
+      #   should_route :delete, '/posts/1',       :controller => :posts, :action => :destroy, :id => 1
+      #   should_route :get,    '/posts/new',     :controller => :posts, :action => :new
+      #
+      #   # nested routes
+      #   should_route :get,    '/users/5/posts', :controller => :posts, :action => :index,   :user_id => 5
+      #   should_route :post,   '/users/5/posts', :controller => :posts, :action => :create,  :user_id => 5
+      #
+      def route(*params)
+        RouteMatcher.new(*params).spec(self)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Remarkable
+  module ActionController
+    module Matchers
+      class SetSessionMatcher < Remarkable::ActionController::Base #:nodoc:
+        arguments :collection => :keys, :as => :key, :block => :block
+
+        optional :to
+
+        assertion :is_not_empty?, :contains_value?
+        collection_assertions :assigned_value?, :is_equal_value?
+
+        before_assert :evaluate_expected_value
+
+        private
+
+          # When no keys are given:
+          #
+          #   should set_session
+          #
+          # We check if the session is not empty.
+          #
+          def is_not_empty?
+            !(@keys.empty? && session.empty?)
+          end
+
+          # When no keys are given and a comparision value is given:
+          #
+          #   should set_session.to(1)
+          #
+          # We check if any of the session data contains the given value.
+          #
+          def contains_value?
+            return true unless @keys.empty? && value_to_compare?
+            assert_contains(session.values, @options[:to])
+          end
+
+          def assigned_value?
+            session.key?(@key)
+          end
+
+          # Returns true if :to is not given and no block is given.
+          # In case :to is a proc or a block is given, we evaluate it in the
+          # @spec scope.
+          #
+          def is_equal_value?
+            return true unless value_to_compare?
+            session[@key] == @options[:to]
+          end
+
+          def session
+            raw_session.with_indifferent_access.except(:flash)
+          end
+
+          def raw_session
+            @subject ? @subject.response.session.data : {}
+          end
+
+          def value_to_compare?
+            @options.key?(:to) || @block
+          end
+
+          def interpolation_options
+            { :session_inspect => raw_session.except('flash').symbolize_keys!.inspect }
+          end
+
+          # Evaluate procs before assert to avoid them appearing in descriptions.
+          def evaluate_expected_value
+            if value_to_compare?
+              value = @options.key?(:to) ? @options[:to] : @block
+              value = @spec.instance_eval(&value) if value.is_a?(Proc)
+              @options[:to] = value
+            end
+          end
+
+      end
+
+      # Ensures that a session keys were set. If you want to check that a variable
+      # is not being set, please do:
+      #
+      #   should_not_set_session(:user)
+      #
+      # If you want to assure that a variable is being set to nil, do instead:
+      #
+      #   should_set_session(:user).to(nil)
+      #
+      # == Options
+      #
+      # * <tt>:to</tt> - The value to compare the session key.
+      #   It accepts procs and be also given as a block (see examples below).
+      #
+      # == Examples
+      #
+      #   should_set_session :user_id, :user
+      #   should_set_session :user_id, :to => 2
+      #   should_set_session :user, :to => proc{ users(:first) }
+      #   should_set_session(:user){ users(:first) }
+      #
+      #   it { should set_session(:user_id, :user) }
+      #   it { should set_session(:user_id, :to => 2) }
+      #   it { should set_session(:user, :to => users(:first)) }
+      #
+      def set_session(*args, &block)
+        SetSessionMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), 'set_session_matcher') 
+
+module Remarkable
+  module ActionController
+    module Matchers
+      class SetTheFlashMatcher < SetSessionMatcher #:nodoc:
+
+        protected
+          def session
+            @subject ? (@subject.response.session['flash'] || {}) : {}
+          end
+
+          def interpolation_options
+            { :flash_inspect => session.symbolize_keys!.inspect }
+          end
+
+      end
+
+      # Ensures that a session keys were set. If you want to check that a flash
+      # is not being set, please do:
+      #
+      #   should_not_set_the_flash(:user)
+      #
+      # If you want to assure that a flash is being set to nil, do instead:
+      #
+      #   should_set_the_flash(:user).to(nil)
+      #
+      # == Options
+      #
+      # * <tt>:to</tt> - The value to compare the flash key. It accepts procs and can also be given as a block (see examples below)
+      #
+      # == Examples
+      #
+      #   should_set_the_flash
+      #   should_not_set_the_flash
+      #
+      #   should_set_the_flash :to => 'message'
+      #   should_set_the_flash :notice, :warn
+      #   should_set_the_flash :notice, :to => 'message'
+      #   should_set_the_flash :notice, :to => proc{ 'hi ' + users(:first).name }
+      #   should_set_the_flash(:notice){ 'hi ' + users(:first).name }
+      #
+      #   it { should set_the_flash }
+      #   it { should set_the_flash.to('message') }
+      #   it { should set_the_flash(:notice, :warn) }
+      #   it { should set_the_flash(:notice, :to => 'message') }
+      #   it { should set_the_flash(:notice, :to => ('hi ' + users(:first).name)) }
+      #
+      def set_the_flash(*args, &block)
+        SetTheFlashMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_rails/action_controller.rb

@@ -0,0 +1,22 @@
+module Remarkable
+  module ActionController
+  end
+end
+
+dir = File.dirname(__FILE__)
+require File.join(dir, 'action_controller', 'base')
+require File.join(dir, 'action_controller', 'macro_stubs')
+
+# Load matchers
+Dir[File.join(dir, 'action_controller', 'matchers', '*.rb')].each do |file|
+  require file
+end
+
+# Include macro_stubs and matchers in Spec::Rails
+if defined?(Spec::Rails)
+  Spec::Rails::Example::ControllerExampleGroup.send :include, Remarkable::ActionController::MacroStubs
+
+  Remarkable.include_matchers!(Remarkable::ActionController, Spec::Rails::Example::ControllerExampleGroup)
+  Remarkable.include_matchers!(Remarkable::ActionController, Spec::Rails::Example::RoutingExampleGroup)
+end
+

data/lib/remarkable_rails/action_view/base.rb

@@ -0,0 +1,7 @@
+module Remarkable
+  module ActionView
+    class Base < Remarkable::Base
+
+    end
+  end
+end

data/lib/remarkable_rails/action_view.rb

@@ -0,0 +1,18 @@
+module Remarkable
+  module ActionView
+  end
+end
+
+dir = File.dirname(__FILE__)
+require File.join(dir, 'action_view', 'base')
+
+# Load matchers
+Dir[File.join(dir, 'action_view', 'matchers', '*.rb')].each do |file|
+  require file
+end
+
+# Iinclude matchers in Spec::Rails
+if defined?(Spec::Rails)
+  Remarkable.include_matchers!(Remarkable::ActionView, Spec::Rails::Example::FunctionalExampleGroup)
+end
+

data/lib/remarkable_rails/active_orm.rb

@@ -0,0 +1,19 @@
+# This will responsable to check which ORM is loaded and include respective
+# matchers.
+#
+if defined?(ActiveRecord::Base)
+  unless Remarkable.const_defined?('ActiveRecord')
+    begin
+      require 'remarkable_activerecord'
+    rescue LoadError
+      require 'rubygems'
+      gem 'remarkable_activerecord'
+      require 'remarkable_activerecord'
+    end
+  end
+
+  # Include Remarkable ActiveRecord matcher in appropriate ExampleGroup
+  if defined?(Spec::Rails)
+    Remarkable.include_matchers!(Remarkable::ActiveRecord, Spec::Rails::Example::ModelExampleGroup)
+  end
+end

data/lib/remarkable_rails.rb

@@ -0,0 +1,30 @@
+# Load Remarkable
+unless Object.const_defined?('Remarkable')
+  begin
+    require 'remarkable'
+  rescue LoadError
+    require 'rubygems'
+    gem 'remarkable'
+    require 'remarkable'
+  end
+end
+
+# Load spec/rails
+if defined?(Spec)
+  begin
+    require 'spec/rails'
+  rescue LoadError
+    require 'rubygems'
+    gem 'rspec-rails'
+    require 'spec/rails'
+  end
+end
+
+# Load Remarkable Rails base files
+dir = File.dirname(__FILE__)
+require File.join(dir, 'remarkable_rails', 'active_orm')
+require File.join(dir, 'remarkable_rails', 'action_controller')
+require File.join(dir, 'remarkable_rails', 'action_view')
+
+# Load locale file
+Remarkable.add_locale File.join(dir, '..', 'locale', 'en.yml')

data/locale/en.yml

@@ -0,0 +1,87 @@
+en:
+  remarkable:
+    action_controller:
+      responding: "responding to #{{verb}} {{action}}"
+      mime_type: "with {{format}}"
+      assign_to:
+        description: "assign {{names}}"
+        expectations:
+          assigned_value: "action to assign {{name}}, got no assignment"
+          is_kind_of: "assign {{name}} to be kind of {{with_kind_of}}, got a {{assign_class}}"
+          is_equal_value: "assign {{name}} to be equal to {{with}}, got {{assign_inspect}}"
+        optionals:
+          with_kind_of:
+            positive: "with kind of {{value}}"
+      filter_params:
+        description: "filter {{params}} parameters from log"
+        expectations:
+          respond_to_filter_params: "controller to respond to filter_parameters (controller is not filtering any parameter)"
+          is_filtered: "{{param}} to be filtered, got no filtering"
+      redirect_to:
+        description: "redirect to {{expected}}"
+        expectations:
+          redirected: "redirect to {{expected}}, got no redirect"
+          status_matches: "redirect to {{expected}} with status {{with}}, got status {{status}}"
+          url_matches: "redirect to {{expected}}, got redirect to {{actual}}"
+        optionals:
+          with:
+            positive: "with status {{inspect}}"
+      render_template:
+        description: "render"
+        expectations:
+          rendered: "template {{template}} to be rendered, got no render"
+          template_matches: "template {{template}} to be rendered, got {{actual_template}}"
+          layout_matches: "to render with layout {{layout}}, got {{actual_layout}}"
+          status_matches: "to render with {{with}}, got {{actual_status}}"
+          body_matches: "to render with body equals to {{body}}, got {{actual_body}}"
+          content_type_matches: "to render with content type {{content_type}}, got {{actual_content_type}}"
+        optionals:
+          template:
+            positive: "template {{inspect}}"
+          layout:
+            positive: "with layout {{inspect}}"
+            negative: "with no layout"
+          with:
+            positive: "with {{value}}"
+          body:
+            positive: "with body {{inspect}}"
+          content_type:
+            positive: "with content type {{inspect}}"
+      respond_with:
+        description: "respond"
+        expectations:
+          status_matches: "to respond with {{with}}, got {{actual_status}}"
+          body_matches: "to respond with body equals to {{body}}, got {{actual_body}}"
+          content_type_matches: "to respond with content type {{content_type}}, got {{actual_content_type}}"
+        optionals:
+          with:
+            positive: "with {{value}}"
+          body:
+            positive: "with body {{inspect}}"
+          content_type:
+            positive: "with content type {{inspect}}"
+      route:
+        description: "route {{method}} {{path}} to/from {{options}}"
+        expectations:
+          map_to_path: "to map {{options}} to {{method}} {{path}}, got {{actual}}"
+          generate_params: "to generate params {{options}} from {{method}} {{path}}, got {{actual}}"
+      set_session:
+        description: "set session variable {{keys}}"
+        expectations:
+          is_not_empty: "any session variable to be set, got {{session_inspect}}"
+          contains_value: "any session variable to be set to {{to}}, got {{session_inspect}}"
+          assigned_value: "session variable {{key}} to be set, got {{session_inspect}}"
+          is_equal_value: "session variable {{key}} to be set to {{to}}, got {{session_inspect}}"
+        optionals:
+          to:
+            positive: "to {{inspect}}"
+      set_the_flash:
+        description: "set the flash message {{keys}}"
+        expectations:
+          is_not_empty: "any flash message to be set, got {{flash_inspect}}"
+          contains_value: "any flash message to be set to {{to}}, got {{flash_inspect}}"
+          assigned_value: "flash message {{key}} to be set, got {{flash_inspect}}"
+          is_equal_value: "flash message {{key}} to be set to {{to}}, got {{flash_inspect}}"
+        optionals:
+          to:
+            positive: "to {{inspect}}"