riot_rails 0.0.8 → 0.0.9.pre

data/CHANGELOG

@@ -0,0 +1,122 @@
+*0.0.9.pre*
+
+* To accommodate the last change, added concept of context helpers. It's so simple you can define your own. [jaknowlden]
+
+    module RiotRails
+      register_context_helper do
+        def prepare_context(original_description, context)
+          # ...
+          context.<do-something-before-the-context-runs-if-you-want-to>
+          # ...
+        end
+      end
+    end
+
+* Well. Aren't we special? We don't have include ActiveRecord or ActionController code if we don't want to. But if you do: [jaknowlden]
+
+    # teststrap.rb
+    require 'riot/activerecord'      # implicit riot/rails require
+    require 'riot/actioncontroller'  # also an implicit riot/rails require
+
+* Added asserts_request and asserts_response context macros. They also take a possible method to call.
+  [jaknowlden]
+
+    rails_context UsersController do
+      hookup { get :show, :id => 1 }
+
+      asserts_response.kind_of(ActionController::TestResponse)
+      asserts_response(:body).kind_of(String)
+
+      asserts_request.kind_of(ActionController::TestRequest)
+      asserts_request(:cookies).kind_of(Hash)
+    end
+
+* Controller assertions now no longer assume the actual value is a controller instance. Instead, the actual
+  value is something that should quack like a response. [jaknowlden]
+
+* Added asserts_assigned context macro [jaknowlden]
+
+    rails_context UsersController do
+      hookup { get :show, :id => 1 }
+
+      asserts_assigned(:user).kind_of(User)
+    end
+
+* rails_context now recognizes controllers [jaknowlden]
+
+    rails_context RoomsController do
+      hookup { get :index }
+      asserts_controller.reponse_status :ok
+    end
+
+  Plus, you can only use controlling within a rails_context now
+  
+    rails_context "rooms" do
+      controlling :rooms
+      hookup { get :index }
+      asserts_controller.reponse_status :ok
+    end
+
+* controlling now lets you pass a controller class reference in [jaknowlden]
+
+    rails_context "rooms" do
+      controlling RoomsController
+    end
+
+* Reflection macros now test the options [emschwar]
+
+    rails_context Room do
+      asserts_topic.has_one :floor, :class_name => "Surface"
+      asserts_topic.has_many :walls, :join_table => "foos"
+    end
+
+* Added the has_one reflection macro [emschwar]
+
+    rails_context Room do
+      asserts_topic.has_one :floor
+    end
+
+* Added the attribute_is_invalid validation macro [jaknowlden]
+
+    rails_context Room do
+      hookup { topic.location = nil }
+      asserts_topic.attribute_is_invalid(:location, "can't be blank")
+    end
+
+* Added validates_length_of assertion macro (minimalistic) [jaknowlden]
+
+    rails_context Room do
+      asserts_topic.validates_length_of :name, (2..36)
+    end
+
+* Added transactional support to RailsContext. Disabled by default [jaknowlden]
+
+    rails_context Room do
+      set :transactional, true
+    end
+
+* Added option enabling to RailsContext [jaknowlden]
+
+    rails_context Room do
+      set :this, "that"
+    end
+
+* Added initial #rails_context. Assumes ActiveRecord class for now [jaknowlden]
+
+    class Room < ActiveRecord::Base
+      # ...
+    end
+
+    # TEST
+
+    rails_context Room do
+      asserts_topic.belongs_to(:house)
+      asserts_topic.validates_presence_of(:house_id)
+    end
+
+* Added the #belongs_to ActiveRecord assertion macro [jaknowlden]
+
+    context "a Room" do
+      setup { Room.new }
+      asserts_topic.belongs_to(:house)
+    end

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Justin Knowlden, Thumble Monks
+Copyright (c) 2009 Justin Knowlden, Thumble Monks
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -1,16 +1,31 @@
-# Protest Rails
+# Riot Rails
 
 [Riot](http://github.com/thumblemonks/riot) macros for Rails application testing.
 
 LOTS more to come ...
 
+## Installation
+
+We're a gem! Install per the normal course of installing gems.
+
+    gem install riot_rails
+
+## Usage
+
+Tons of documentation to come. Try looking at the [RDoc](http://rdoc.info/projects/thumblemonks/riot_rails) for now. As a note, you will likely put this in your `teststrap.rb` or `test_helper.rb`:
+
+    require 'riot/rails'
+
 ### ActiveRecord
 
-Standard macros
+Awesome stuff in the works. Doc coming soon.
+
+### ActionController
+
+Awesome stuff in the works. Doc coming soon.
+
+### ActionMailer
 
-* #validates\_presence\_of
-* #allows\_values\_for
-* #does\_not\_allow\_values\_for
-* #validates\_uniquness\_of
+Awesome stuff coming soon. See [Shoulda Action Mailer](http://github.com/thumblemonks/shoulda_action_mailer) - which is also by us - in the meantime.
 
-Yes. Replacing Shoulda macros for now. Like I said with Riot, I love Shoulda.
+I told you we liked Shoulda.

data/Rakefile

@@ -32,8 +32,9 @@ begin
     gem.email = "gus@gusg.us"
     gem.homepage = "http://github.com/thumblemonks/riot_rails"
     gem.authors = ["Justin 'Gus' Knowlden"]
-    gem.add_dependency("riot", ">= 0.10.2")
-    gem.add_development_dependency("activerecord", ">= 2.3.2")
+    gem.add_dependency("riot", ">= 0.10.13.pre")
+    gem.add_development_dependency("activerecord", ">= 3.0.0.pre")
+    gem.add_development_dependency("actionpack", ">= 3.0.0.pre")
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9.pre

data/lib/riot/action_controller/assertion_macros.rb

@@ -1,20 +1,23 @@
 module RiotRails
   module ActionController
-    # Asserts that the body of the response equals or matches the expected expression. Expects actual to
-    # be the controller.
+    # Asserts that calling body on whatever is passed in matches the expected value. Expected value can be a
+    # literal string or a regular expression. It makes most sense to provide this macro with the response.
     #
-    #   controller.renders("a bunch of html")
-    #   controller.renders(/bunch of/)
+    #   rails_context UsersController do
+    #     hookup { get :index }
+    #     asserts(:response).renders("a bunch of html")
+    #     asserts(:response).renders(/bunch of/)
+    #   end
     class RendersMacro < Riot::AssertionMacro
       register :renders
 
       def evaluate(actual, expected)
-        actual_body = actual.response.body
+        actual_body = actual.body
         if (expected.kind_of?(Regexp) ? (actual_body =~ expected) : (expected == actual_body))
           pass
         else
           verb = expected.kind_of?(Regexp) ? "match" : "equal"
-          fail("expected response body #{actual_body.inspect} to #{verb} #{expected.inspect}")
+          fail expected_message.response_body(actual_body).to.push("#{verb} #{expected.inspect}")
         end
       end
     end
@@ -22,23 +25,28 @@ module RiotRails
     # Asserts that the name you provide is the basename of the rendered template. For instance, if you
     # expect the rendered template is named "foo_bar.html.haml" and you pass "foo_bar" into
     # renders_template, the assertion would pass. If instead you pass "foo" into renders_template, the
-    # assertion will fail. Using Rails' assert_template both assertions would pass
+    # assertion will fail. Using Rails' assert_template both assertions would pass.
+    #
+    # It's important to note that the actual value provided must respond to +#rendered+. It's best to run
+    # this assertion on the response
     #
-    #   controlling :things
-    #   controller.renders_template(:index)
-    #   controller.renders_template("index")
-    #   controller.renders_template("index.erb") # fails even if that's the name of the template
+    #   rails_context ThingsController do
+    #     hookup { get :index }
+    #     asserts(:response).renders_template(:index)
+    #     asserts(:response).renders_template("index")
+    #     asserts(:response).renders_template("index.erb") # fails even if that's the name of the template
+    #   end
     class RendersTemplateMacro < Riot::AssertionMacro
       register :renders_template
       
       def evaluate(actual, expected_name)
         name = expected_name.to_s
-        actual_template_path = actual.response.rendered[:template].to_s
+        actual_template_path = Array(actual.template.rendered[:template]).map(&:inspect).first.to_s # yuck
         actual_template_name = File.basename(actual_template_path)
-        if actual_template_name.to_s.match(/^#{name}(\.\w+)*$/)
-          pass("renders template #{name.inspect}")
+        if actual_template_name.to_s.match(%r[^#{name}(\.\w+)*$])
+          pass new_message.renders_template(name)
         else
-          fail("expected template #{name.inspect}, not #{actual_template_path.inspect}")
+          fail expected_message.template(name).not(actual_template_path)
         end
       end
     end
@@ -47,25 +55,28 @@ module RiotRails
     # status code or the integer code itself. Not currently supporting status ranges; such as: +:success+,
     # +:redirect+, etc.
     #
-    #   controller.response_code(:ok)
-    #   controller.response_code(200)
+    # It's important to note that the actual value provided must respond to +#response_code+. It's best to
+    # run this assertion on the response
+    #
+    #   asserts(:response).code(:ok)
+    #   asserts(:response).code(200)
     #   
-    #   controller.response_code(:not_found)
-    #   controller.response_code(404)
+    #   asserts(:response).code(:not_found)
+    #   asserts(:response).code(404)
     #   
     #   # A redirect
-    #   controller.response_code(:found)
-    #   controller.response_code(302)
+    #   asserts(:response).code(:found)
+    #   asserts(:response).code(302)
     #
     # See +ActionController::StatusCodes+ for the list of available codes.
     class ResponseCodeMacro < Riot::AssertionMacro
-      register :response_code
+      register :code
 
       def evaluate(actual, expected_code)
         if expected_code.kind_of?(Symbol)
-          expected_code = ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[expected_code]
+          expected_code = ::Rack::Utils::SYMBOL_TO_STATUS_CODE[expected_code]
         end
-        actual_code = actual.response.response_code
+        actual_code = actual.response_code
         if expected_code == actual_code
           pass("returns response code #{expected_code}")
         else
@@ -75,28 +86,31 @@ module RiotRails
     end
 
     # Asserts that the response from an action is a redirect and that the path or URL matches your
-    # expectations. If the response code is not in the 300s, the assertion will fail. If the reponse code
+    # expectations. If the response code is not in the 300s, the assertion will fail. If the ressponse code
     # is fine, but the redirect-to path or URL do not exactly match your expectation, the assertion will
     # fail.
     #
-    # +redirected_to+ expects you to provide your expected path in a lambda. This is so you can use named
-    # routes, which are - as it turns out - handy. It's also what I would expect to be able to do.
+    # In order to use named routes which are handy, provide the path in a block. +redirected_to+ expects the
+    # actual value to quack like a response object, which means it must respond to +response_code+ and
+    # +redirected_to+.
     #
-    #   controlling :people
-    #   setup do
-    #     post :create, :person { ... }
-    #   end
+    #   rails_context PeopleController do
+    #     hookup do
+    #       post :create, :person { ... }
+    #     end
     #
-    #   controller.redirected_to { person_path(...) }
+    #     asserts(:response).redirected_to { person_path(...) }
+    #   end
     #
     # PS: There is a difference between saying +named_route_path+ and +named_route_url+ and Riot Rails will
     # be very strict (read: annoying) about it :)
     class RedirectedToMacro < Riot::AssertionMacro
       register :redirected_to
+
       def evaluate(actual, expected_redirect)
-        actual_response_code = actual.response.response_code
+        actual_response_code = actual.response_code
         if (300...400).member?(actual_response_code)
-          actual_redirect = actual.url_for(actual.response.redirected_to)
+          actual_redirect = actual.redirect_url
           msg = "expected to redirect to <#{expected_redirect}>, not <#{actual_redirect}>"
           expected_redirect == actual_redirect ? pass("redirected to #{expected_redirect}") : fail(msg)
         else

data/lib/riot/action_controller/context_helper.rb

@@ -0,0 +1,12 @@
+module RiotRails
+  register_context_helper do
+    def prepare_context(context)
+      context.controlling(context.description) if action_controller_context?(context)
+    end
+  private
+    def action_controller_context?(context)
+      description = context.description
+      description.kind_of?(Class) && description.ancestors.include?(::ActionController::Base)
+    end
+  end
+end # RiotRails

data/lib/riot/action_controller/context_macros.rb

@@ -1,32 +1,32 @@
-module Riot #:nodoc:
+module RiotRails #:nodoc:
   module ActionController #:nodoc:
 
     module ContextMacros
       # Sets up a context (and possibly child contexts) for testing a controller. Right now, it just takes a
-      # symbol. Should change to allow you to pass in the class directly. You should put this at or near the
-      # top of your context definition.
+      # symbol. Should change to allow you to pass in the class directly.
       #
-      #   context "the FooBarsController" do
+      #   rails_context "the FooBarsController" do
       #     controlling :foo_bars
-      #     setup { get :index }
+      #     hookup { get :index }
       #   end
       def controlling(controller_name)
-        controller_class = "#{controller_name.to_s.camelize}Controller".constantize
-        setup do
+        controller_class = constantize_controller_name(controller_name)
+        premium_setup do
           controller_class.instance_eval { include ::ActionController::TestCase::RaiseActionExceptions }
           @request = ::ActionController::TestRequest.new
           @response = ::ActionController::TestResponse.new
           @controller = controller_class.new
           @controller.params = {}
           @controller.request = @request
+          @controller
         end
       end
 
       # Creates a shortcut assertion that is to be used with the assertion macros for ActionController.
       #
-      #   context "the FoosController" do
+      #   rails_context "the FoosController" do
       #     controlling :foos
-      #     setup { get :index }
+      #     hookup { get :index }
       #
       #     asserts_controller.response_status(:found)
       #     asserts_controller.redirected_to { new_foo_path }
@@ -39,9 +39,55 @@ module Riot #:nodoc:
       def asserts_controller
         asserts("controller") { controller }
       end
+
+      # Creates a shortcut assertion in order to test the response directly. If you provide an argument
+      # it is assumed you want to call the relevant method on the response in order test it's returned value.
+      #
+      #   rails_context "the FoosController" do
+      #     controlling :foos
+      #     hookup { get :index }
+      #
+      #     asserts_response.kind_of(ActionController::TestResponse)
+      #     asserts_response(:body).kind_of(String)
+      #   end
+      def asserts_response(shortcut_method=nil)
+        asserts("the response") { shortcut_method ? response.send(shortcut_method) : response }
+      end
+
+      # Creates a shortcut assertion in order to test the request directly. If you provide an argument
+      # it is assumed you want to call the relevant method on the request in order test it's returned value.
+      #
+      #   rails_context "the FoosController" do
+      #     controlling :foos
+      #     hookup { get :index }
+      #
+      #     asserts_request.kind_of(ActionController::TestRequest)
+      #     asserts_request(:cookies).kind_of(Hash)
+      #   end
+      def asserts_request(shortcut_method=nil)
+        asserts("the request") { shortcut_method ? request.send(shortcut_method) : request }
+      end
+
+      # Creates a shortcut assertion that returns the value of an assigned variable from the controller
+      #
+      #   rails_context UsersController do
+      #     hookup { get :show, :id => 1 }
+      #
+      #     asserts_assigned(:user).kind_of(User)
+      #   end
+      def asserts_assigned(variable)
+        asserts("value assigned to @#{variable}") do
+          @controller.instance_variable_get("@#{variable}".to_sym)
+        end
+      end
+    private
+      def constantize_controller_name(name)
+        name.kind_of?(Class) ? name : "#{name.to_s.camelize}Controller".constantize
+      end
     end # ContextMacros
 
+    # We do this everywhere because you never know when someone might define a rails_context that doesn't
+    # automatically translate to an ActionController context
+    RailsContext.instance_eval { include ContextMacros }
   end # ActionController
-end # Riot
-
-Riot::Context.instance_eval { include Riot::ActionController::ContextMacros }
+end # RiotRails

data/lib/riot/action_controller/situation_macros.rb

@@ -1,14 +1,81 @@
-module Riot #:nodoc:
+module RiotRails #:nodoc:
   module ActionController #:nodoc:
 
-    module SituationMacros
+    # Nabbed form actionpack-3.0.0.beta
+    module HttpSupport
       attr_reader :controller, :request, :response
-    end # SituationMacros
+      
+      # Simulates a GET HTTP request and handles response
+      def get(*args) submit_request("GET", *args); end
+
+      # Simulates a POST HTTP request and handles response
+      def post(*args) submit_request("POST", *args); end
+
+      # Simulates a PUT HTTP request and handles response
+      def put(*args) submit_request("PUT", *args); end
+
+      # Simulates a DELETE HTTP request and handles response
+      def delete(*args) submit_request("DELETE", *args); end
+
+      # Simulates a HEAD HTTP request and handles response
+      def head(*args) submit_request("HEAD", *args); end
+
+      # Simulates an XML HTTP Request (which allows for AJAX ya'll) for whatever HTTP method you want
+      def xml_http_request(request_method, *args)
+        # @request.env['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
+        # @request.env['HTTP_ACCEPT'] ||=  [Mime::JS, Mime::HTML, Mime::XML, 'text/xml', Mime::ALL].join(', ')
+        # returning submit_request(request_method.to_s.upcase, *args) do
+        #   @request.env.delete 'HTTP_X_REQUESTED_WITH'
+        #   @request.env.delete 'HTTP_ACCEPT'
+        # end
+      end
+      alias :xhr :xml_http_request
+    private
+      def submit_request(http_method, action, parameters = nil, session = nil, flash = nil)
+        @request.recycle!
+        @response.recycle!
+        @controller.response_body = nil
+        @controller.formats = nil
+        @controller.params = nil
+
+        @html_document = nil
+        @request.env['REQUEST_METHOD'] = http_method
+
+        parameters ||= {}
+        @request.assign_parameters(@controller.class.name.underscore.sub(/_controller$/, ''), action.to_s, parameters)
+
+        # @request.session = ActionController::TestSession.new(session) unless session.nil?
+        # @request.session["flash"] = @request.flash.update(flash || {})
+        # @request.session["flash"].sweep
+
+        @controller.request = @request
+        @controller.params.merge!(parameters)
+        build_request_uri(action, parameters)
+        ::ActionController::Base.class_eval { include ::ActionController::Testing }
+        @controller.process_with_new_base_test(@request, @response)
+        # @request.session.delete('flash') if @request.session['flash'].blank?
+        @response
+      end
+
+      def build_request_uri(action, parameters)
+        unless @request.env['REQUEST_URI']
+          options = @controller.__send__(:rewrite_options, parameters)
+          options.update(:only_path => true, :action => action)
+
+          url = ::ActionController::UrlRewriter.new(@request, parameters)
+          @request.request_uri = url.rewrite(options)
+        end
+      end
+    end # HttpSupport
 
   end # ActionController
-end # Riot
+end # RiotRails
 
 Riot::Situation.instance_eval do
-  include ActionController::TestProcess
-  include Riot::ActionController::SituationMacros
+  include RiotRails::ActionController::HttpSupport
+
+  # Making routes work in the situation
+  Rails::Application.routes.named_routes.install(self)
+  include ActionController::UrlFor
+  default_url_options[:host] = "test.host"
 end

data/lib/riot/action_controller.rb

@@ -1,6 +1,8 @@
 require 'action_controller/test_case'
 require 'action_view/test_case'
 
+require 'riot/rails'
 require 'riot/action_controller/context_macros'
 require 'riot/action_controller/assertion_macros'
 require 'riot/action_controller/situation_macros'
+require 'riot/action_controller/context_helper'