riot-rails 0.0.10.pre.3

data/.gitignore

@@ -0,0 +1,4 @@
+test/rails_root/log/*
+pkg/*
+riot-rails.tmproj
+test/rails_root/db/*.db

data/CHANGELOG

@@ -0,0 +1,144 @@
+*0.0.10.pre.3*
+
+* Renamed to riot-rails and am hoping @dasch is kind of enough to let me be an owner on the gem he originally pushed. The ol' bait and and switch. [jaknowlden]
+
+* Added asserts_response context macro. You can also provide method names to be called against the response. [jaknowlden]
+
+    context FoosController do
+      setup { get "/foos" }
+
+      asserts_response.exists
+      asserts_response(:status).equals(200)
+      asserts_response(:body).matches(/Bar baz/)
+    end # FoosController
+
+* Added GET support for ActionController testing, a la Rack testing methods. [jaknowlden]
+
+    context MyController do
+      setup { get "/my/dashboard", "foo" => "bar" }
+    end # MyController
+
+* Redoing support for ActionController. Dropped everything started from scratch. Also, moved the context-helper stuff into Riot and called it ContextMiddleware. Reimplemented helpers as middleware here. [jaknowlden]
+
+*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

@@ -0,0 +1,20 @@
+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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,31 @@
+# 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
+
+Awesome stuff in the works. Doc coming soon.
+
+### ActionController
+
+Awesome stuff in the works. Doc coming soon.
+
+### ActionMailer
+
+Awesome stuff coming soon. See [Shoulda Action Mailer](http://github.com/thumblemonks/shoulda_action_mailer) - which is also by us - in the meantime.
+
+I told you we liked Shoulda.

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'rake'
+
+task :default => [:test]
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+desc "Run Flog against library (except tests)"
+task :flog do
+  puts %x[find ./lib -name *.rb | xargs flog]
+end
+
+desc "Run Roodi against library (except tests)"
+task :roodi do
+  puts %x[find ./lib -name *.rb | xargs roodi]
+end
+
+#
+# Some monks like diamonds. I like gems.
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "riot-rails"
+    gem.summary = "Riot specific test support for Rails apps"
+    gem.description = "Riot specific test support for Rails apps. Protest the slow app."
+    gem.email = "gus@gusg.us"
+    gem.homepage = "http://github.com/thumblemonks/riot-rails"
+    gem.authors = ["Justin 'Gus' Knowlden"]
+    gem.add_dependency("riot", ">= 0.11.0")
+    gem.add_dependency("rack-test", ">= 0.5.3")
+    gem.add_development_dependency("activerecord", ">= 3.0.0.beta3")
+    gem.add_development_dependency("actionpack", ">= 3.0.0.beta3")
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.10.pre.3

data/lib/riot/action_controller/context_macros/asserts_response.rb

@@ -0,0 +1,15 @@
+module RiotRails
+  module ActionController
+    module AssertsResponse
+
+      def asserts_response(method_name=nil)
+        if method_name
+          asserts("response ##{method_name.to_s}") { response.send(method_name) }
+        else
+          asserts("response") { response }
+        end
+      end
+
+    end # AssertsResponse
+  end # ActionController
+end # RiotRails

data/lib/riot/action_controller/context_middleware.rb

@@ -0,0 +1,45 @@
+module RiotRails
+  class ActionControllerMiddleware < Riot::ContextMiddleware
+    register
+
+    def handle?(context)
+      description = context.description
+      description.kind_of?(Class) && description.ancestors.include?(::ActionController::Base)
+    end # handle?
+
+    def call(context)
+      setup_context_macros(context)
+      setup_situation(context)
+    end
+  private
+    def setup_context_macros(context)
+      context.class_eval do
+        include RiotRails::ActionController::AssertsResponse
+      end
+    end
+
+    def setup_situation(context)
+      context.helper(:app) { @app }
+      context.helper(:env) { @env }
+      context.helper(:controller) { env["action_controller.instance"] }
+
+      context.helper(:request) do
+        return controller.request if controller
+        raise Exception, "No request made yet"
+      end
+
+      context.helper(:response) do
+        return controller.response if controller
+        raise Exception, "No response since no request made yet"
+      end
+
+      context.setup(true) do
+        self.class_eval { include RiotRails::ActionController::HttpMethods }
+        @app = ::Rails.application
+        http_reset
+        context.description
+      end # context.setup(true)
+    end # call
+
+  end # ActionControllerMiddleware
+end # RiotRails

data/lib/riot/action_controller/http_methods.rb

@@ -0,0 +1,19 @@
+module RiotRails
+  module ActionController
+    module HttpMethods
+      def http_reset; @env = {}; end
+      def get(uri, params={}) perform_request("GET", uri, params); end
+      def post(uri, params={}) perform_request("POST", uri, params); end
+      def put(uri, params={}); perform_request("PUT", uri, params); end
+      def delete(uri, params={}); perform_request("DELETE", uri, params); end
+    private
+      def perform_request(request_method, uri, params)
+        http_reset
+        params = params.inject({}) { |acc,(key,val)| acc[key] = val.to_s; acc }
+        @env = ::Rack::MockRequest.env_for(uri, {:params => params, :method => request_method}).merge(@env)
+        @env['action_dispatch.show_exceptions'] = false
+        @app.call(@env)
+      end
+    end # HttpMethods
+  end # ActionController
+end # RiotRails

data/lib/riot/action_controller.rb

@@ -0,0 +1,4 @@
+require 'riot/rails'
+require 'riot/action_controller/context_middleware'
+require 'riot/action_controller/context_macros/asserts_response'
+require 'riot/action_controller/http_methods'

data/lib/riot/active_record/assertion_macros.rb

@@ -0,0 +1,3 @@
+require 'riot/active_record/validation_macros'
+require 'riot/active_record/reflection_macros'
+require 'riot/active_record/database_macros'

data/lib/riot/active_record/context_middleware.rb

@@ -0,0 +1,15 @@
+module RiotRails
+  class ActiveRecordMiddleware < Riot::ContextMiddleware
+    register
+
+    def handle?(context)
+      description = context.description
+      description.kind_of?(Class) && description.ancestors.include?(::ActiveRecord::Base)
+    end
+
+    def call(context)
+      context.setup(true) { context.description.new }
+    end
+
+  end # ActiveRecordMiddleware
+end # RiotRails

data/lib/riot/active_record/database_macros.rb

@@ -0,0 +1,58 @@
+module RiotRails
+  module ActiveRecord
+
+    # An ActiveRecord assertion macro that looks for an index on a given set of attributes in the table
+    # used by the model under test (aka: topic).
+    #
+    #   asserts_topic.has_database_index_on :name
+    #   asserts_topic.has_database_index_on :email, :group_name
+    #
+    # In the form used above, the assertion will pass if any index is found with the attributes listed
+    # (unique or not). To be specific about uniqueness, provide the +:unique+ option.
+    #
+    #   asserts_topic.has_database_index_on :email, :unique => true
+    #   asserts_topic.has_database_index_on :name, :unique => false
+    #
+    # The last example will require that the index not be a unique one.
+    class HasDatabaseIndexOnMacro < Riot::AssertionMacro
+      register :has_database_index_on
+
+      def initialize(database_connection=nil) # Good for testing :)
+        @database_connection = database_connection
+      end
+
+      def evaluate(actual, *attributes_and_options)
+        attributes, options = extract_options_from(attributes_and_options)
+        unique = options[:unique]
+
+        index = find_index(actual, attributes, unique)
+
+        static_message = "#{unique ? "unique" : ""} index on #{attributes.inspect}".strip
+        index.nil? ? fail("expected #{static_message}") : pass("has #{static_message}")
+      end
+    private
+      def database_connection; @database_connection || ::ActiveRecord::Base.connection; end
+
+      def find_index(model, attributes, uniqueness, &block)
+        database_connection.indexes(model.class.table_name).find do |the_index|
+          unique_enough?(uniqueness, the_index) && attributes_match?(attributes, the_index)
+        end
+      end
+
+      def unique_enough?(uniqueness, index)
+        return true if uniqueness.nil?
+        index.unique == uniqueness
+      end
+
+      def attributes_match?(attributes, index)
+        Set.new(attributes.map(&:to_s)) == Set.new(index.columns)
+      end
+
+      def extract_options_from(attributes)
+        options = attributes.last.kind_of?(Hash) ? attributes.pop : {}
+        [attributes, options]
+      end
+    end
+
+  end # ActiveRecord
+end # RiotRails

data/lib/riot/active_record/reflection_macros.rb

@@ -0,0 +1,106 @@
+module RiotRails
+  module ActiveRecord
+  protected
+
+    class ReflectionAssertionMacro < Riot::AssertionMacro
+    private
+      def reflection_match?(expected, reflection)
+        !reflection.nil? && (expected == reflection.macro.to_s)
+      end
+
+      def options_match_for_reflection?(reflection, options)
+        options.all? { |k, v| reflection.options[k] == v }
+      end
+
+      def assert_reflection(expected, record, attribute, options=nil)
+        options ||= {}
+        reflection = record.class.reflect_on_association(attribute)
+        if reflection_match?(expected, reflection)
+          if options_match_for_reflection?(reflection, options)
+            pass new_message(attribute).is_a.push(expected).association
+          else
+            fail expected_message.push("#{expected} #{attribute.inspect}").with(options)
+          end
+        else
+          fail new_message(attribute).is_not_a.push(expected).association
+        end
+      end
+    end
+
+  public
+
+    # An ActiveRecord assertion macro that expects to pass when a given attribute is defined as a +has_many+
+    # association. Will fail if an association is not defined for the attribute or if the association is
+    # not +has_many+.
+    #
+    #   context "a Room" do
+    #     setup { Room.new }
+    #
+    #     asserts_topic.has_many(:doors)
+    #     asserts_topic.has_many(:floors) # should probably fail given our current universe :)
+    #   end
+    class HasManyMacro < ReflectionAssertionMacro
+      register :has_many
+
+      def evaluate(actual, *expectings)
+        attribute, options = *expectings
+        assert_reflection("has_many", actual, attribute, options)
+      end
+    end
+
+    # An ActiveRecord assertion macro that expects to pass when a given attribute is defined as a
+    # +has_one+ association. Will fail if an association is not defined for the attribute or if the
+    # association is not +has_one+.
+    #
+    #   context "a Room" do
+    #     setup { Room.new }
+    #
+    #     asserts_topic.has_one(:floor)
+    #   end
+    class HasOneMacro < ReflectionAssertionMacro
+      register :has_one
+
+      def evaluate(actual, *expectings)
+        attribute, options = *expectings
+        assert_reflection("has_one", actual, attribute, options)
+      end
+    end
+
+    # An ActiveRecord assertion macro that expects to pass when a given attribute is defined as a 
+    # +belongs_to+ association. Will fail if an association is not defined for the attribute or if the
+    # association is not +belongs_to+.
+    #
+    #   context "a Room" do
+    #     setup { Room.new }
+    #
+    #     asserts_topic.belongs_to(:house)
+    #   end
+    class BelongsToMacro < ReflectionAssertionMacro
+      register :belongs_to
+
+      def evaluate(actual, *expectings)
+        attribute, options = *expectings
+        assert_reflection("belongs_to", actual, attribute, options)
+      end
+    end
+
+    # An ActiveRecord assertion macro that expects to pass when a given attribute is defined as a
+    # +has_and_belongs_to_many+ association. Will fail if an association is not defined for the attribute or 
+    # if the association is not +has_and_belongs_to_many+.
+    #
+    #   context "a Room" do
+    #     setup { Room.new }
+    #
+    #     asserts_topic.has_and_belongs_to_many(:walls)
+    #   end
+    class HasAndBelongsToManyMacro < ReflectionAssertionMacro
+      register :has_and_belongs_to_many
+
+      def evaluate(actual, *expectings)
+        attribute, options = *expectings
+        assert_reflection("has_and_belongs_to_many", actual, attribute, options)
+      end
+    end
+
+  end # ActiveRecord
+end # RiotRails

data/lib/riot/active_record/transactional_middleware.rb

@@ -0,0 +1,21 @@
+module RiotRails
+  class TransactionalMiddleware < Riot::ContextMiddleware
+    register
+    
+    def handle?(context)
+      context.option(:transactional) == true
+    end
+
+    def call(context)
+      context.class.class_eval do
+        alias_method :transactionless_local_run, :local_run
+        def local_run(*args)
+          ::ActiveRecord::Base.transaction do
+            transactionless_local_run(*args)
+            raise ::ActiveRecord::Rollback
+          end
+        end
+      end
+    end
+  end
+end # RiotRails