riot-rails 0.0.10.pre.3 → 0.1.0

data/MIT-LICENSE

@@ -1,20 +0,0 @@
-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

@@ -1,31 +0,0 @@
-# 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/lib/riot/action_controller.rb

@@ -1,4 +0,0 @@
-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/action_controller/context_macros/asserts_response.rb

@@ -1,15 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/active_record.rb

@@ -1,4 +0,0 @@
-require 'riot/rails'
-require 'riot/active_record/assertion_macros'
-require 'riot/active_record/context_middleware'
-require 'riot/active_record/transactional_middleware'

data/lib/riot/active_record/assertion_macros.rb

@@ -1,3 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

data/lib/riot/active_record/validation_macros.rb

@@ -1,187 +0,0 @@
-module RiotRails
-  module ActiveRecord
-  protected
-
-    class ValidationAssertionMacro < Riot::AssertionMacro
-    private
-      def errors_from_writing_value(model, attribute, value)
-        # TODO: Fix me to not use __send__
-        model.__send__(:write_attribute, attribute, value)
-        model.valid?
-        model.errors[attribute]
-      end
-
-      def errors_from_writing_value?(*args)
-        errors_from_writing_value(*args).any?
-      end
-    end
-
-  public
-
-    # An ActiveRecord assertion that expects to pass with a given value or set of values for a given
-    # attribute.
-    #
-    #    rails_context User do
-    #      asserts_topic.allows_values_for :email, "a@b.cd"
-    #      asserts_topic.allows_values_for :email, "a@b.cd", "e@f.gh"
-    #    end
-    class AllowsValuesForMacro < ValidationAssertionMacro
-      register :allows_values_for
-
-      def evaluate(actual, attribute, *values)
-        bad_values = []
-        values.each do |value|
-          bad_values << value if errors_from_writing_value?(actual, attribute, value)
-        end
-        bad_values.empty? ? pass : fail(expected_message(attribute).to_allow_values(bad_values))
-      end
-    end
-
-    # An ActiveRecord assertion that expects to fail with a given value or set of values for a given
-    # attribute.
-    #
-    #    rails_context User do
-    #      asserts_topic.does_not_allow_values_for :email, "a"
-    #      asserts_topic.does_not_allow_values_for :email, "a@b", "e f@g.h"
-    #    end
-    class DoesNotAllowValuesForMacro < ValidationAssertionMacro
-      register :does_not_allow_values_for
-      def evaluate(actual, attribute, *values)
-        good_values = []
-        values.each do |value|
-          good_values << value unless errors_from_writing_value?(actual, attribute, value)
-        end
-        good_values.empty? ? pass : fail(expected_message(attribute).not_to_allow_values(good_values))
-      end
-    end
-
-    # An ActiveRecord assertion that expects to fail with invalid value for an attribute. Optionally, the 
-    # error message can be provided as the exact string or as regular expression.
-    #
-    #    rails_context User do
-    #      asserts_topic.is_invalid_when :email, "fake", "is invalid"
-    #      asserts_topic.is_invalid_when :email, "another fake", /invalid/
-    #    end
-    class IsInvalidWhenMacro < ValidationAssertionMacro
-      register :is_invalid_when
-
-      def evaluate(actual, attribute, value, expected_error=nil)
-        actual_errors = errors_from_writing_value(actual, attribute, value)
-        if actual_errors.empty?
-          fail expected_message(attribute).to_be_invalid_when_value_is(value)
-        elsif expected_error && !has_error_message?(expected_error, actual_errors)
-          fail expected_message(attribute).to_be_invalid_with_error_message(expected_error)
-        else
-          pass new_message.attribute(attribute).is_invalid
-        end
-      end
-    private
-      def has_error_message?(expected, errors)
-        return true unless expected
-        expected.kind_of?(Regexp) ? errors.any? {|e| e =~ expected } : errors.any? {|e| e == expected }
-      end
-    end
-
-    # An ActiveRecord assertion that expects to fail when a given attribute is validated after a nil value
-    # is provided to it.
-    #
-    #    rails_context User do
-    #      asserts_topic.validates_presence_of(:name)
-    #    end
-    class ValidatesPresenceOfMacro < ValidationAssertionMacro
-      register :validates_presence_of
-
-      def evaluate(actual, attribute)
-        if errors_from_writing_value?(actual, attribute, nil)
-          pass new_message.validates_presence_of(attribute)
-        else
-          fail expected_message.to_validate_presence_of(attribute)
-        end
-      end
-    end
-
-    # An ActiveRecord assertion that expects to fail with an attribute is not valid for record because the
-    # value of the attribute is not unique. Requires the topic of the context to be a created record; one
-    # that returns false for a call to +new_record?+.
-    #
-    #    rails_context User do
-    #      setup { User.create(:email => "a@b.cde", ... ) }
-    #      asserts_topic.validates_uniqueness_of :email
-    #    end
-    class ValidatesUniquenessOfMacro < ValidationAssertionMacro
-      register :validates_uniqueness_of
-      
-      def evaluate(actual, attribute)
-        actual_record = actual
-        if actual_record.new_record?
-          fail new_message.must_use_a_persisted_record_when_testing_uniqueness_of(attribute)
-        else
-          copied_model = actual_record.class.new
-          actual_record.attributes.each do |dup_attribute, dup_value|
-            copied_model.__send__(:write_attribute, dup_attribute, dup_value)
-          end
-          copied_value = actual_record.__send__(:read_attribute, attribute)
-          if errors_from_writing_value?(copied_model, attribute, copied_value)
-            pass new_message(attribute).is_unique
-          else
-            fail expected_message.to_fail_because(attribute).is_not_unique
-          end
-        end
-      end
-    end
-
-    # An ActiveRecord assertion to test that the length of the value of an attribute must be within a 
-    # specified range. Assertion fails if: there are errors when min/max characters are used, there are no 
-    # errors when min-1/max+1 characters are used.
-    #
-    #    rails_context User do
-    #      asserts_topic.validates_length_of :name, (2..36)
-    #    end
-    #
-    # TODO: allow for options on what to validate
-    class ValidatesLengthOfMacro < ValidationAssertionMacro
-      register :validates_length_of
-
-      def evaluate(actual, attribute, range)
-        min, max = range.first, range.last
-        [min, max].each do |length|
-          if errors_from_writing_value?(actual, attribute, "r" * length)
-            return fail(new_message(attribute).should_be_able_to_be(length).characters)
-          end
-        end
-
-        if (min-1) > 0 && !errors_from_writing_value?(actual, attribute, "r" * (min-1))
-          fail new_message(attribute).expected_to_be_more_than(min - 1).characters
-        elsif !errors_from_writing_value?(actual, attribute, "r" * (max+1))
-          fail new_message(attribute).expected_to_be_less_than(max + 1).characters
-        else
-          pass new_message.validates_length_of(attribute).is_within(range)
-        end
-      end
-    end
-
-    # An ActiveRecord assertion to test that an attribute is invalid along with the expected error message
-    # (or error message partial). The assumption is that a value has already been set.
-    #
-    #    rails_context User do
-    #      hookup { topic.bio = "I'm a goofy clown" }
-    #      asserts_topic.attribute_is_invalid :bio, "cannot contain adjectives"
-    #    end
-    class AttributeIsInvalidMacro < ValidationAssertionMacro
-      register :attribute_is_invalid
-
-      def evaluate(actual, attribute, error_message)
-        actual.valid?
-        errors = actual.errors[attribute]
-        if errors.empty?
-          fail new_message(attribute).expected_to_be_invalid
-        elsif errors.include?(error_message)
-          pass new_message(attribute).is_invalid
-        else
-          fail new_message(attribute).is_invalid.but(error_message).is_not_a_valid_error_message
-        end
-      end
-    end
-
-  end # ActiveRecord
-end # RiotRails