riot_rails 0.0.1 → 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+test/rails_root/log/*.log
+pkg/*
+

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/riot/action_controller/assertion_macros.rb

@@ -0,0 +1,94 @@
+module Riot #:nodoc:
+  module ActionController #:nodoc:
+
+    module AssertionMacros
+      # Asserts that the body of the response equals or matches the expected expression. Expects actual to
+      # be the controller.
+      #
+      #   controller.renders("a bunch of html")
+      #   controller.renders(/bunch of/)
+      def renders(expected)
+        actual_body = actual.response.body
+        if expected.kind_of?(Regexp)
+          msg = "expected response body #{actual_body.inspect} to match #{expected.inspect}"
+          actual_body =~ expected || fail(msg)
+        else
+          msg = "expected response body #{actual_body.inspect} to equal #{expected.inspect}"
+          expected == actual_body || fail(msg)
+        end
+      end
+
+      # 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
+      #
+      #   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
+      def renders_template(name)
+        name = name.to_s
+        actual_template_path = actual.response.rendered[:template].to_s
+        actual_template_name = File.basename(actual_template_path)
+        msg = "expected template #{name.inspect}, not #{actual_template_path.inspect}"
+        actual_template_name.to_s.match(/^#{name}(\.\w+)?$/) || fail(msg)
+      end
+
+      # Asserts that the HTTP response code equals your expectation. You can use the symbolized form of the
+      # 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)
+      #   
+      #   controller.response_code(:not_found)
+      #   controller.response_code(404)
+      #   
+      #   # A redirect
+      #   controller.response_code(:found)
+      #   controller.response_code(302)
+      #
+      # See +ActionController::StatusCodes+ for the list of available codes.
+      def response_code(expected_code)
+        if expected_code.kind_of?(Symbol)
+          expected_code = ::ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[expected_code]
+        end
+        actual_code = actual.response.response_code
+        expected_code == actual_code || fail("expected response code #{expected_code}, not #{actual_code}")
+      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
+      # 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 block. This is so you can use named
+      # routes, which is - as it turns out - handy. It's also what I would expect to be able to do.
+      #
+      #   controlling :people
+      #   setup do
+      #     post :create, :person { ... }
+      #   end
+      #
+      #   controller.redirected_to { person_path(...) }
+      #
+      # 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 :)
+      def redirected_to(&expectation_block)
+        actual_response_code = actual.response.response_code
+        if (300...400).member?(actual_response_code)
+          expected_redirect = actual.url_for(situation.instance_eval(&expectation_block))
+          actual_redirect = actual.url_for(actual.response.redirected_to)
+          msg = "expected to redirect to <#{expected_redirect}>, not <#{actual_redirect}>"
+          expected_redirect == actual_redirect || fail(msg)
+        else
+          fail("expected response to be a redirect, but was #{actual_response_code}")
+        end
+      end
+    end # AssertionMacros
+
+  end # ActionController
+end # Riot
+
+Riot::Assertion.instance_eval { include Riot::ActionController::AssertionMacros }

data/lib/riot/action_controller/context_macros.rb

@@ -0,0 +1,47 @@
+module Riot #: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.
+      #
+      #   context "the FooBarsController" do
+      #     controlling :foo_bars
+      #     setup { get :index }
+      #   end
+      def controlling(controller_name)
+        controller_class = "#{controller_name.to_s.camelize}Controller".constantize
+        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
+        end
+      end
+
+      # Creates a shortcut assertion that is to be used with the assertion macros for ActionController.
+      #
+      #   context "the FoosController" do
+      #     controlling :foos
+      #     setup { get :index }
+      #
+      #     controller.response_status(:found)
+      #     controller.redirected_to { new_foo_path }
+      #   end
+      #
+      # Works the same as if you wrote the following assertions:
+      #
+      #   asserts("controller") { @controller }.response_status(:found)
+      #   asserts("controller") { @controller }.redirected_to { new_foo_path }
+      def controller
+        asserts("controller") { @controller }
+      end
+    end # ContextMacros
+
+  end # ActionController
+end # Riot
+
+Riot::Context.instance_eval { include Riot::ActionController::ContextMacros }

data/lib/riot/action_controller/situation_macros.rb

@@ -0,0 +1,14 @@
+module Riot #:nodoc:
+  module ActionController #:nodoc:
+
+    module SituationMacros
+      attr_reader :controller, :request, :response
+    end # SituationMacros
+
+  end # ActionController
+end # Riot
+
+Riot::Situation.instance_eval do
+  include ActionController::TestProcess
+  include Riot::ActionController::SituationMacros
+end

data/lib/riot/action_controller.rb

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

data/lib/riot/active_record/{macros.rb → context_macros.rb}

@@ -1,6 +1,7 @@
 module Riot
   module ActiveRecord
-    module Macros
+
+    module ContextMacros
       # An ActiveRecord assertion that expects to fail when a given attribute or attributes are validated
       # when a nil value is provided to them.
       #
@@ -60,20 +61,9 @@ module Riot
           get_error_from_writing_value(copied_model, attribute, copied_value)
         end.exists
       end
-    end # Macros
-  end # ActiveRecord
+    end # ContextMacros
 
-  module Helpers
-    module Situation
-    private
-      def get_error_from_writing_value(model, attribute, value)
-        model.write_attribute(attribute, value)
-        model.valid?
-        model.errors.on(attribute)
-      end
-    end # Situation
-  end # Helpers
+  end # ActiveRecord
 end # Riot
 
-Riot::Context.instance_eval { include Riot::ActiveRecord::Macros }
-Riot::Situation.instance_eval { include Riot::Helpers::Situation }
+Riot::Context.instance_eval { include Riot::ActiveRecord::ContextMacros }

data/lib/riot/active_record/situation_macros.rb

@@ -0,0 +1,16 @@
+module Riot
+  module ActiveRecord
+
+    module SituationMacros
+    private
+      def get_error_from_writing_value(model, attribute, value)
+        model.write_attribute(attribute, value)
+        model.valid?
+        model.errors.on(attribute)
+      end
+    end # SituationMacros
+
+  end # ActiveRecord
+end # Riot
+
+Riot::Situation.instance_eval { include Riot::ActiveRecord::SituationMacros }

data/lib/riot/active_record.rb

@@ -0,0 +1,2 @@
+require 'riot/active_record/context_macros'
+require 'riot/active_record/situation_macros'

data/lib/riot/rails.rb

@@ -1,2 +1,3 @@
 require 'riot'
-require 'riot/active_record/macros'
+require 'riot/active_record'
+require 'riot/action_controller'

data/riot_rails.gemspec

@@ -5,30 +5,45 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot_rails}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2009-10-11}
+  s.date = %q{2009-10-16}
   s.description = %q{Riot specific test support for Rails apps. Protest the slow app.}
   s.email = %q{gus@gusg.us}
   s.extra_rdoc_files = [
     "README.markdown"
   ]
   s.files = [
-    "MIT-LICENSE",
+    ".gitignore",
+     "MIT-LICENSE",
      "README.markdown",
      "Rakefile",
      "VERSION",
-     "lib/riot/active_record/macros.rb",
+     "lib/riot/action_controller.rb",
+     "lib/riot/action_controller/assertion_macros.rb",
+     "lib/riot/action_controller/context_macros.rb",
+     "lib/riot/action_controller/situation_macros.rb",
+     "lib/riot/active_record.rb",
+     "lib/riot/active_record/context_macros.rb",
+     "lib/riot/active_record/situation_macros.rb",
      "lib/riot/rails.rb",
      "rails/init.rb",
      "riot_rails.gemspec",
+     "test/action_controller/action_assigns_variable_test.rb",
+     "test/action_controller/controller_context_test.rb",
+     "test/action_controller/redirected_to_test.rb",
+     "test/action_controller/renders_template_test.rb",
+     "test/action_controller/renders_test.rb",
+     "test/action_controller/response_status_test.rb",
+     "test/active_record/should_allow_values_for_test.rb",
+     "test/active_record/should_validate_presence_of_test.rb",
+     "test/active_record/should_validate_uniqueness_of_test.rb",
+     "test/rails_root/app/views/rendered_templates/foo_bar.erb",
+     "test/rails_root/config/routes.rb",
      "test/rails_root/db/schema.rb",
-     "test/should_allow_values_for_test.rb",
-     "test/should_validate_presence_of_test.rb",
-     "test/should_validate_uniqueness_of_test.rb",
-     "test/test_helper.rb"
+     "test/teststrap.rb"
   ]
   s.homepage = %q{http://github.com/thumblemonks/riot_rails}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -36,11 +51,18 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{Riot specific test support for Rails apps}
   s.test_files = [
-    "test/rails_root/db/schema.rb",
-     "test/should_allow_values_for_test.rb",
-     "test/should_validate_presence_of_test.rb",
-     "test/should_validate_uniqueness_of_test.rb",
-     "test/test_helper.rb"
+    "test/action_controller/action_assigns_variable_test.rb",
+     "test/action_controller/controller_context_test.rb",
+     "test/action_controller/redirected_to_test.rb",
+     "test/action_controller/renders_template_test.rb",
+     "test/action_controller/renders_test.rb",
+     "test/action_controller/response_status_test.rb",
+     "test/active_record/should_allow_values_for_test.rb",
+     "test/active_record/should_validate_presence_of_test.rb",
+     "test/active_record/should_validate_uniqueness_of_test.rb",
+     "test/rails_root/config/routes.rb",
+     "test/rails_root/db/schema.rb",
+     "test/teststrap.rb"
   ]
 
   if s.respond_to? :specification_version then

data/test/action_controller/controller_context_test.rb

@@ -0,0 +1,67 @@
+require 'teststrap'
+
+class FoosController < ActionController::Base
+end
+
+context "controlling in a context" do
+
+  setup do
+    @ctx = Riot::Context.new("foo", Riot::NilReport.new)
+    @ctx.controlling :foos
+    @ctx.situation
+  end
+
+  topic.assigns(:controller)
+  topic.assigns(:request)
+  topic.assigns(:response)
+  
+  context "the assigned controller" do
+    setup { topic.controller }
+
+    topic.kind_of(FoosController)
+
+    should("have an empty params hash") do
+      topic.params
+    end.equals({})
+
+    should("return a test request when asking for request") do
+      topic.request
+    end.kind_of(::ActionController::TestRequest)
+  end # the assigned controller
+
+  context "the assigned request" do
+    setup { topic.request }
+    topic.kind_of(::ActionController::TestRequest)
+  end # the assigned request
+
+  context "the assigned response" do
+    setup { topic.response }
+    topic.kind_of(::ActionController::TestResponse)
+  end # the assigned response
+
+  context "calling controller" do
+    setup { @ctx.controller }
+
+    topic.kind_of(Riot::Assertion)
+
+    asserts("assertion name") { topic.description }.equals("foo asserts controller")
+
+    should("return the controller as the actual value") do
+      topic.actual
+    end.kind_of(FoosController)
+  end # calling controller
+
+end # controlling in a context
+
+context "a controller test" do
+  controlling :foos
+
+  asserts("situation") { self }.respond_to(:get)
+  asserts("situation") { self }.respond_to(:post)
+  asserts("situation") { self }.respond_to(:put)
+  asserts("situation") { self }.respond_to(:delete)
+
+  asserts "an unknown action" do
+    get :burberry
+  end.raises(ActionController::UnknownAction, "No action responded to burberry")
+end # a controller

data/test/action_controller/redirected_to_test.rb

@@ -0,0 +1,60 @@
+require 'teststrap'
+
+class RedirectedToController < ActionController::Base
+  def index; redirect_to new_gremlin_path; end
+  def show; render :text => ""; end
+end
+
+context "asserting the redirect of an action" do
+
+  setup do
+    context = Riot::Context.new("redirected to", Riot::NilReport.new)
+    context.controlling :redirected_to
+    context
+  end
+
+  context "when doing an actual redirect" do
+
+    setup do
+      topic.setup { get :index }
+      topic
+    end
+
+    should "pass when expected url matches actual redirect url" do
+      assertion = topic.controller
+      assertion.redirected_to { new_gremlin_path }
+      assertion.passed?
+    end
+
+    context "and expected url does not match actual redirect url exactly" do
+      setup do
+        assertion = topic.controller
+        assertion.redirected_to { new_gremlin_url }
+        assertion
+      end
+
+      asserts("topic failed") { topic.failed? }
+
+      asserts("topic message") do
+        topic.result.message
+      end.matches(%r[expected to redirect to <http://test.host/gremlins/new>, not </gremlins/new>])
+    end # and expected url does not match actual redirect url exactly
+
+  end # when doing an actual redirect
+
+  context "when not actually doing a redirect" do
+    setup do
+      topic.setup { get :show }
+      assertion = topic.controller
+      assertion.redirected_to { new_gremlin_path }
+      assertion
+    end
+
+    asserts("topic failed") { topic.failed? }
+
+    asserts("topic message") do
+      topic.result.message
+    end.matches(%r[expected response to be a redirect, but was 200])
+  end # when not actually doing a redirect
+
+end # asserting the redirect of an action

data/test/action_controller/renders_template_test.rb

@@ -0,0 +1,93 @@
+require 'teststrap'
+
+class RenderedTemplatesController < ActionController::Base
+  def foo_bar; end
+  def text_me; render :text => "blah"; end
+end
+
+context "asserting the rendered template for an action" do
+
+  setup do
+    context = Riot::Context.new("rendered template", Riot::NilReport.new)
+    context.controlling :rendered_templates
+    context
+  end
+
+  context "that rendered a template" do
+    setup do
+      topic.setup { get :foo_bar }
+      topic
+    end
+
+    should "pass when rendered template name matches expectation" do
+      assertion = topic.controller
+      assertion.renders_template('foo_bar')
+      assertion.passed?
+    end
+
+    context "when rendered template does not match expectation" do
+      setup do
+        assertion = topic.controller
+        assertion.renders_template('bar_foo')
+        assertion
+      end
+
+      asserts("topic failed") { topic.failed? }
+
+      asserts("topic message") do
+        topic.result.message
+      end.matches(/expected template "bar_foo", not "rendered_templates\/foo_bar.erb"/)
+    end # when rendered template does not match expectation
+
+  end # that rendered a template
+
+  context "that did not render a template as expected" do
+    setup do
+      topic.setup { get :text_me }
+      topic
+    end
+
+    should "pass when providing nil as expectation" do
+      assertion = topic.controller
+      assertion.renders_template(nil)
+      assertion.passed?
+    end
+
+    should "pass when providing empty string as expectation" do
+      assertion = topic.controller
+      assertion.renders_template("")
+      assertion.passed?
+    end
+  end # that did not render a template as expected
+
+  context "that did not render a template but expected one" do
+    setup do
+      topic.setup { get :text_me }
+      assertion = topic.controller
+      assertion.renders_template('text_me')
+      assertion
+    end
+
+    asserts("topic failed") { topic.failed? }
+
+    asserts("topic message") do
+      topic.result.message
+    end.matches(/expected template "text_me", not ""/)
+  end # that did not render a template but expected one
+
+  context "that rendered a template with a partial match on template name" do
+    setup do
+      topic.setup { get :foo_bar }
+      assertion = topic.controller
+      assertion.renders_template('foo')
+      assertion
+    end
+
+    asserts("topic failed") { topic.failed? }
+
+    asserts("topic message") do
+      topic.result.message
+    end.matches(/expected template "foo", not "rendered_templates\/foo_bar.erb"/)
+  end # that rendered a template with a partial match on template name
+
+end # asserting the rendered template for an action

data/test/action_controller/renders_test.rb

@@ -0,0 +1,56 @@
+require 'teststrap'
+
+class RendersController < ActionController::Base
+  def index; render :text => "Yo mama"; end
+end
+
+context "asserting the body of a response" do
+
+  setup do
+    context = Riot::Context.new("renders", Riot::NilReport.new)
+    context.controlling :renders
+    context.setup { get :index }
+    context
+  end
+
+  should "assert rendered action body equals expected" do
+    assertion = topic.controller
+    assertion.renders("Yo mama")
+    assertion.passed?
+  end
+
+  context "when rendered action body does not equal expected" do
+    setup do
+      assertion = topic.controller
+      assertion.renders("Yo")
+      assertion
+    end
+
+    asserts("topic failed") { topic.failed? }
+
+    asserts("topic message") do
+      topic.result.message
+    end.matches(/expected response body "Yo mama" to equal "Yo"/)
+  end # when rendered action body does not equal expected
+
+  should "assert rendered action body matches expected" do
+    assertion = topic.controller
+    assertion.renders(/mama/)
+    assertion.passed?
+  end
+
+  context "when rendered action body does not match expected" do
+    setup do
+      assertion = topic.controller
+      assertion.renders(/obama/)
+      assertion
+    end
+
+    asserts("topic failed") { topic.failed? }
+
+    asserts("topic message") do
+      topic.result.message
+    end.matches(/expected response body "Yo mama" to match \/obama\//)
+  end # when rendered action body does not match expected
+
+end # asserting the body of a response

data/test/action_controller/response_status_test.rb

@@ -0,0 +1,88 @@
+require 'teststrap'
+
+class ResponseCodesController < ActionController::Base
+  def ok_go; render :text => ""; end
+  def fffound; redirect_to "http://your.momshou.se"; end
+  def make_me; render :text => "", :status => 201; end
+end
+
+context "asserting the response status for an action" do
+
+  setup do
+    context = Riot::Context.new("response status", Riot::NilReport.new)
+    context.controlling :response_codes
+    context
+  end
+
+  context "returning OK" do
+    setup do
+      topic.setup { get :ok_go }
+      topic
+    end
+
+    should "pass when asked if :ok" do
+      assertion = topic.controller
+      assertion.response_code(:ok)
+      assertion.passed?
+    end
+
+    should "pass when asked if 200" do
+      assertion = topic.controller
+      assertion.response_code(200)
+      assertion.passed?
+    end
+
+    context "but expected to return CONTINUE" do
+      setup do
+        assertion = topic.controller
+        assertion.response_code(100)
+        assertion
+      end
+
+      asserts("topic failed") { topic.failed? }
+
+      asserts("topic message") do
+        topic.result.message
+      end.matches(/expected response code 100, not 200/)
+    end # but expected to return CONTINUE
+  end # returning OK
+
+  context "that is redirecting" do
+    setup do
+      topic.setup { get :fffound }
+      topic
+    end
+
+    should "pass when asked if :ok" do
+      assertion = topic.controller
+      assertion.response_code(:found)
+      assertion.passed?
+    end
+
+    should "pass when asked if 200" do
+      assertion = topic.controller
+      assertion.response_code(302)
+      assertion.passed?
+    end
+  end # that is redirecting
+
+  context "that has explicit status" do
+    setup do
+      topic.setup { get :make_me }
+      topic
+    end
+
+    should "pass when asked if :created" do
+      assertion = topic.controller
+      assertion.response_code(:created)
+      assertion.passed?
+    end
+
+    should "pass when asked if 202" do
+      assertion = topic.controller
+      assertion.response_code(201)
+      assertion.passed?
+    end
+  end # that has explicit status
+
+end # asserting the status of a response

data/test/{should_allow_values_for_test.rb → active_record/should_allow_values_for_test.rb}

@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'teststrap'
 
 context "should_allow_values_for" do
   setup_and_run_context("when attribute allows a value", 1, 0, 0) do |test_ctx|

data/test/{should_validate_presence_of_test.rb → active_record/should_validate_presence_of_test.rb}

@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'teststrap'
 
 context "should_validate_presence_of" do
   setup_and_run_context("when attribute requires presence", 1, 0, 0) do |test_ctx|

data/test/{should_validate_uniqueness_of_test.rb → active_record/should_validate_uniqueness_of_test.rb}

@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'teststrap'
 
 context "should_validate_uniqueness_of" do
 

data/test/rails_root/config/routes.rb

@@ -0,0 +1,5 @@
+ActionController::Routing::Routes.draw do |map|
+  map.resources :gremlins
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end

data/test/{test_helper.rb → teststrap.rb}

@@ -1,8 +1,6 @@
 require 'rubygems'
-require 'riot/rails'
-require 'activerecord'
-
-RAILS_ROOT = File.dirname(__FILE__) + '/rails_root'
+require 'active_record'
+require 'action_controller'
 
 def shhh(&block)
   orig_out = $stdout
@@ -11,14 +9,24 @@ def shhh(&block)
   $stdout = orig_out
 end
 
-# Database setup
+#
+# Setup faux Rails environment
+
+RAILS_ROOT = File.join(File.dirname(__FILE__), 'rails_root')
+
+require File.join(RAILS_ROOT, "config", "routes.rb")
+
 shhh do
   ActiveRecord::Base.configurations = {"test" => { "adapter" => "sqlite3", "database" => ":memory:"}}
   ActiveRecord::Base.establish_connection("test")
   load(File.join(RAILS_ROOT, "db", "schema.rb"))
 end
 
+ActionController::Base.view_paths = [File.join(RAILS_ROOT, 'app', 'views')]
+
+#
 # Model definition
+
 class Room < ActiveRecord::Base
   validates_presence_of :location, :foo, :bar
   validates_format_of :email, :with => /^\w+@\w+\.\w+$/
@@ -29,7 +37,11 @@ class Room < ActiveRecord::Base
   end
 end
 
+#
 # Test refactorings
+
+require 'riot/rails'
+
 module RiotRails
   module Context
     def asserts_passes_failures_errors(passes=0, failures=0, errors=0)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: riot_rails
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-11 00:00:00 -05:00
+date: 2009-10-16 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,19 +41,34 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 files: 
+- .gitignore
 - MIT-LICENSE
 - README.markdown
 - Rakefile
 - VERSION
-- lib/riot/active_record/macros.rb
+- lib/riot/action_controller.rb
+- lib/riot/action_controller/assertion_macros.rb
+- lib/riot/action_controller/context_macros.rb
+- lib/riot/action_controller/situation_macros.rb
+- lib/riot/active_record.rb
+- lib/riot/active_record/context_macros.rb
+- lib/riot/active_record/situation_macros.rb
 - lib/riot/rails.rb
 - rails/init.rb
 - riot_rails.gemspec
+- test/action_controller/action_assigns_variable_test.rb
+- test/action_controller/controller_context_test.rb
+- test/action_controller/redirected_to_test.rb
+- test/action_controller/renders_template_test.rb
+- test/action_controller/renders_test.rb
+- test/action_controller/response_status_test.rb
+- test/active_record/should_allow_values_for_test.rb
+- test/active_record/should_validate_presence_of_test.rb
+- test/active_record/should_validate_uniqueness_of_test.rb
+- test/rails_root/app/views/rendered_templates/foo_bar.erb
+- test/rails_root/config/routes.rb
 - test/rails_root/db/schema.rb
-- test/should_allow_values_for_test.rb
-- test/should_validate_presence_of_test.rb
-- test/should_validate_uniqueness_of_test.rb
-- test/test_helper.rb
+- test/teststrap.rb
 has_rdoc: true
 homepage: http://github.com/thumblemonks/riot_rails
 licenses: []
@@ -83,8 +98,15 @@ signing_key:
 specification_version: 3
 summary: Riot specific test support for Rails apps
 test_files: 
+- test/action_controller/action_assigns_variable_test.rb
+- test/action_controller/controller_context_test.rb
+- test/action_controller/redirected_to_test.rb
+- test/action_controller/renders_template_test.rb
+- test/action_controller/renders_test.rb
+- test/action_controller/response_status_test.rb
+- test/active_record/should_allow_values_for_test.rb
+- test/active_record/should_validate_presence_of_test.rb
+- test/active_record/should_validate_uniqueness_of_test.rb
+- test/rails_root/config/routes.rb
 - test/rails_root/db/schema.rb
-- test/should_allow_values_for_test.rb
-- test/should_validate_presence_of_test.rb
-- test/should_validate_uniqueness_of_test.rb
-- test/test_helper.rb
+- test/teststrap.rb