benhutton-remarkable_rails 4.0.0.alpha4

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

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), 'set_session_matcher')
+
+module Remarkable
+  module ActionController
+    module Matchers
+      class SetCookiesMatcher < SetSessionMatcher #:nodoc:
+
+        # For cookies to work properly, we have:
+        #
+        # On Rails 2.1.2 and 2.2.2:
+        #
+        #   1. Wrap :to values in an array;
+        #   2. When :to is false or nil, make it be an empty array;
+        #   3. Convert all keys to string.
+        #
+        # On Rails 2.3.2:
+        #
+        #   1. Return nil if nil, join when array or convert to string;
+        #   2. Convert all keys to string.
+        #
+        before_assert do
+          if @options.key?(:to)
+            if @subject.request.env.key?("rack.input")
+              @options[:to] = case @options[:to]
+                when nil
+                  nil
+                when Array
+                  @options[:to].join('&')
+                else
+                  @options[:to].to_s
+              end
+            else
+              @options[:to] = @options[:to] ? Array(@options[:to]) : []
+            end
+          end
+
+          @keys.collect!(&:to_s)
+        end
+
+        protected
+          def session
+            @subject ? (@subject.response.cookies || {}) : {}
+          end
+
+          def interpolation_options
+            { :cookies_inspect => session.symbolize_keys!.inspect }
+          end
+
+      end
+
+      # Ensures that the given cookie keys were set. If you want to check that
+      # a cookie is not being set, just do:
+      #
+      #   should_not_set_cookies :user
+      #
+      # If you want to assure that a cookie is being set to nil, do instead:
+      #
+      #   should_set_cookies :user, :to => nil
+      #
+      # Note: this method is also aliased as <tt>set_cookie</tt>.
+      #
+      # == 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_cookies :user_id, :user
+      #   should_set_cookies :user_id, :to => 2
+      #   should_set_cookies :user, :to => proc{ users(:first) }
+      #   should_set_cookies(:user){ users(:first) }
+      #
+      #   it { should set_cookies(:user_id, :user) }
+      #   it { should set_cookies(:user_id, :to => 2) }
+      #   it { should set_cookies(:user, :to => users(:first)) }
+      #
+      def set_cookies(*args, &block)
+        SetCookiesMatcher.new(*args, &block).spec(self)
+      end
+      alias :set_cookie :set_cookies
+
+    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 => true
+
+        optional :to, :block => true
+
+        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?
+            assert_contains([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 the given session keys were set. If you want to check that
+      # a variable is not being set, just 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,56 @@
+require File.join(File.dirname(__FILE__), 'set_session_matcher') 
+
+module Remarkable
+  module ActionController
+    module Matchers
+      class SetTheFlashMatcher < SetSessionMatcher #:nodoc:
+
+        protected
+          def session
+            @subject ? (@subject.request.session['flash'] || {}) : {}
+          end
+
+          def interpolation_options
+            { :flash_inspect => session.symbolize_keys!.inspect }
+          end
+
+      end
+
+      # Ensures that a flash message is being set. If you want to check that a
+      # flash is not being set, just 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_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?(RSpec::Rails)
+  Remarkable.include_matchers!(Remarkable::ActionView, RSpec::Rails::ViewExampleGroup)
+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/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?(RSpec::Rails)
+    Remarkable.include_matchers!(Remarkable::ActiveRecord, RSpec::Rails::ModelExampleGroup)
+  end
+end

data/locale/en.yml

@@ -0,0 +1,110 @@
+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 status %{with}, got %{actual_status}"
+          body_matches: "to render with body %{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 status %{with}, got %{actual_status}"
+          body_matches: "to respond with body %{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_cookies:
+        description: "set cookies %{keys}"
+        expectations:
+          is_not_empty: "any cookie to be set, got %{cookies_inspect}"
+          contains_value: "any cookie to be set to %{to}, got %{cookies_inspect}"
+          assigned_value: "cookie %{key} to be set, got %{cookies_inspect}"
+          is_equal_value: "cookie %{key} to be set to %{to}, got %{cookies_inspect}"
+        optionals:
+          to:
+            positive: "to %{inspect}"
+            negative: "to %{inspect}"
+
+      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}"
+            negative: "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}"
+            negative: "to %{inspect}"
+

data/remarkable_rails.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{remarkable_rails}
+  s.version = "4.0.0.alpha4"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Carlos Brando", "José Valim"]
+  s.date = %q{2010-10-18}
+  s.description = %q{Remarkable Rails: collection of matchers and macros with I18n for Rails}
+  s.email = ["eduardobrando@gmail.com", "jose.valim@gmail.com"]
+  s.extra_rdoc_files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README",
+     "lib/remarkable_rails.rb",
+     "lib/remarkable_rails/action_controller.rb",
+     "lib/remarkable_rails/action_controller/base.rb",
+     "lib/remarkable_rails/action_controller/macro_stubs.rb",
+     "lib/remarkable_rails/action_controller/matchers/assign_to_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/filter_params_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/redirect_to_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/render_template_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/respond_with_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/route_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/set_cookies_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/set_session_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/set_the_flash_matcher.rb",
+     "lib/remarkable_rails/action_view.rb",
+     "lib/remarkable_rails/action_view/base.rb",
+     "lib/remarkable_rails/active_orm.rb",
+     "locale/en.yml"
+  ]
+  s.homepage = %q{http://github.com/carlosbrando/remarkable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{remarkable}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Remarkable Rails: collection of matchers and macros with I18n for Rails}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rspec>, [">= 2.0.0.alpha11"])
+      s.add_runtime_dependency(%q<rspec-rails>, [">= 2.0.0.alpha11"])
+      s.add_runtime_dependency(%q<remarkable>, ["~> 4.0.0.alpha4"])
+      s.add_runtime_dependency(%q<remarkable_activerecord>, ["~> 4.0.0.alpha4"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.0.0.alpha11"])
+      s.add_dependency(%q<rspec-rails>, [">= 2.0.0.alpha11"])
+      s.add_dependency(%q<remarkable>, ["~> 4.0.0.alpha4"])
+      s.add_dependency(%q<remarkable_activerecord>, ["~> 4.0.0.alpha4"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.0.0.alpha11"])
+    s.add_dependency(%q<rspec-rails>, [">= 2.0.0.alpha11"])
+    s.add_dependency(%q<remarkable>, ["~> 4.0.0.alpha4"])
+    s.add_dependency(%q<remarkable_activerecord>, ["~> 4.0.0.alpha4"])
+  end
+end
+