riot_rails 0.0.8 → 0.0.9.pre

data/lib/riot/active_record/assertion_macros.rb

@@ -1,158 +1,3 @@
-module RiotRails
-  module ActiveRecord
-
-    class AssertionMacro < ::Riot::AssertionMacro
-      def error_from_writing_value(model, attribute, value)
-        model.write_attribute(attribute, value)
-        model.valid?
-        model.errors.on(attribute)
-      end
-    end
-
-    # An ActiveRecord assertion that expects to fail when a given attribute is validated after a nil value
-    # is provided to it.
-    #
-    #    context "a User" do
-    #      setup { User.new }
-    #      topic.validates_presence_of(:name)
-    #    end
-    class ValidatesPresenceOfMacro < AssertionMacro
-      register :validates_presence_of
-
-      def evaluate(actual, attribute)
-        if error_from_writing_value(actual, attribute, nil)
-          pass("validates presence of #{attribute.inspect}")
-        else
-          fail("expected to validate presence of #{attribute.inspect}")
-        end
-      end
-    end
-
-    # An ActiveRecord assertion that expects to pass with a given value or set of values for a given
-    # attribute.
-    #
-    #    context "a User" do
-    #      setup { User.new }
-    #      topic.allows_values_for :email, "a@b.cd"
-    #      topic.allows_values_for :email, "a@b.cd", "e@f.gh"
-    #    end
-    class AllowsValuesForMacro < AssertionMacro
-      register :allows_values_for
-
-      def evaluate(actual, attribute, *values)
-        bad_values = []
-        values.each do |value|
-          bad_values << value if error_from_writing_value(actual, attribute, value)
-        end
-        failure_msg = "expected %s to allow value(s) %s"
-        bad_values.empty? ? pass : fail(failure_msg % [attribute.inspect, bad_values.inspect])
-      end
-    end
-
-    # An ActiveRecord assertion that expects to fail with a given value or set of values for a given
-    # attribute.
-    #
-    #    context "a User" do
-    #      setup { User.new }
-    #      topic.does_not_allow_values_for :email, "a"
-    #      topic.does_not_allow_values_for :email, "a@b", "e f@g.h"
-    #    end
-    class DoesNotAllowValuesForMacro < AssertionMacro
-      register :does_not_allow_values_for
-      def evaluate(actual, attribute, *values)
-        good_values = []
-        values.each do |value|
-          good_values << value unless error_from_writing_value(actual, attribute, value)
-        end
-        failure_msg = "expected %s not to allow value(s) %s"
-        good_values.empty? ? pass : fail(failure_msg % [attribute.inspect, good_values.inspect])
-      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.
-    #
-    #    context "a User" do
-    #      setup { User.new }
-    #      topic.is_invalid_when :email, "fake", "is invalid"
-    #      topic.is_invalid_when :email, "another fake", /invalid/
-    #    end
-    class IsInvalidWhenMacro < AssertionMacro
-      register :is_invalid_when
-
-      def evaluate(actual, attribute, value, expected_error=nil)
-        actual_errors = Array(error_from_writing_value(actual, attribute, value))
-        if actual_errors.empty?
-          fail("expected #{attribute.inspect} to be invalid when value is #{value.inspect}")
-        elsif expected_error && !has_error_message?(expected_error, actual_errors)
-          message = "expected %s to be invalid with error message %s"
-          fail(message % [attribute.inspect, expected_error.inspect])
-        else
-          pass("attribute #{attribute.inspect} 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 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?+.
-    #
-    #    context "a User" do
-    #      setup { User.create(:email => "a@b.cde", ... ) }
-    #      topic.validates_uniqueness_of :email
-    #    end
-    class ValidatesUniquenessOfMacro < AssertionMacro
-      register :validates_uniqueness_of
-      
-      def evaluate(actual, attribute)
-        actual_record = actual
-        if actual_record.new_record?
-          fail("topic is not a new record when testing uniqueness of #{attribute.inspect}")
-        else
-          copied_model = actual_record.class.new
-          actual_record.attributes.each do |dup_attribute, dup_value|
-            copied_model.write_attribute(dup_attribute, dup_value)
-          end
-          copied_value = actual_record.read_attribute(attribute)
-          if error_from_writing_value(copied_model, attribute, copied_value)
-            pass("#{attribute.inspect} is unique")
-          else
-            fail("expected to fail because #{attribute.inspect} is not unique")
-          end
-        end
-      end
-    end
-
-    # An ActiveRecord assertion macro that expects to pass when a given attribute is defined as +has_many+
-    # association. Will fail if an association is not defined for the attribute and if the association is
-    # not +has_many.jekyll
-    #
-    #   context "a Room" do
-    #     setup { Room.new }
-    #
-    #     topic.has_many(:doors)
-    #     topic.has_many(:floors) # should probably fail given our current universe :)
-    #   end
-    class HasManyMacro < AssertionMacro
-      register :has_many
-      
-      def evaluate(actual, attribute)
-        reflection = actual.class.reflect_on_association(attribute)
-        static_msg = "expected #{attribute.inspect} to be a has_many association, but was "
-        if reflection.nil?
-          fail(static_msg + "not")
-        elsif "has_many" != reflection.macro.to_s
-          fail(static_msg + "a #{reflection.macro} instead")
-        else
-          pass("has many #{attribute.inspect}")
-        end
-      end
-    end
-
-  end # ActiveRecord
-end # RiotRails
+require 'riot/active_record/validation_macros'
+require 'riot/active_record/reflection_macros'
+require 'riot/active_record/database_macros'

data/lib/riot/active_record/context_helper.rb

@@ -0,0 +1,19 @@
+module RiotRails
+  register_context_helper do
+    def prepare_context(context)
+      context.premium_setup { context.description.new } if active_record_context?(context)
+
+      context.transaction do |&original_block|
+        ::ActiveRecord::Base.transaction do
+          original_block.call
+          raise ::ActiveRecord::Rollback
+        end
+      end
+    end
+  private
+    def active_record_context?(context)
+      description = context.description
+      description.kind_of?(Class) && description.ancestors.include?(::ActiveRecord::Base)
+    end
+  end
+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/validation_macros.rb

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

data/lib/riot/active_record.rb

@@ -1 +1,3 @@
+require 'riot/rails'
 require 'riot/active_record/assertion_macros'
+require 'riot/active_record/context_helper'

data/lib/riot/rails.rb

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

data/lib/riot/rails_context.rb

@@ -0,0 +1,84 @@
+module RiotRails
+  def self.helpers; @helpers ||= []; end
+  def self.register_context_helper(&handler_block)
+    helpers << Class.new(&handler_block).new
+  end
+
+  class RailsContext < Riot::Context
+    def initialize(description, parent=nil, &definition)
+      @options = {:transactional => false}
+      transaction { |&default_block| raise Exception, "No transaction handler" }
+      super(description, parent, &definition)
+      apply_helpers
+    end
+
+    # We're going to allow any helper to help out. Not just one.
+    def apply_helpers
+      RiotRails.helpers.each { |helper| helper.prepare_context(self) }
+    end
+
+    # Set options for the specific rails_context. For instance, you can tell the context to be transactional
+    #
+    #   rails_context "Foo" do
+    #     set :transactional, true
+    #   end
+    def set(property, value) options[property] = value; end
+
+    # Technically, this is a secret ... but whatever. It's ruby. Basically, just make this setup more
+    # important than any of the others.
+    # 
+    # Yes I can. See ... I just did!
+    def premium_setup(&definition)
+      @setups.unshift(::Riot::Setup.new(&definition)).first;
+    end
+
+    # Returns true if current context or a parent context has the transactional option enabled. To enable,
+    # anywhere within a rails_context or a child context thereof, do:
+    #
+    #   rails_context Foo do
+    #     context "sub context" do
+    #       set :transactional, true
+    #     end
+    #   end
+    #
+    # Transactional support is disabled by default. When enabled, all transactions are rolled back when the
+    # context is done executing.
+    def transactional?
+      options[:transactional] || (parent.respond_to?(:transactional?) && parent.transactional?)
+    end
+
+    # TODO: cleanup how we handle transactions and context helpers
+    def transaction(&block) @transaction_block = block; end
+
+    def local_run(*args)
+      transactional? ? @transaction_block.call { super(*args) } : super
+    end
+  private
+    attr_reader :options
+  end
+
+  module Root
+    # Things an Object needs at the root level
+    # 
+    #   rails_context SomeKindOfClass do
+    #   end
+    def rails_context(description, &definition)
+      context(description, RailsContext, &definition)
+    end
+  end # Root
+
+  module Context
+    # Things a running context needs
+    # 
+    #   context "Something" do
+    #     rails_context SomeKindOfClass do
+    #     end
+    #   end
+    def rails_context(description, &definition)
+      new_context(description, RailsContext, &definition)
+    end
+  end # Context
+end # RiotRails
+
+Object.instance_eval { include RiotRails::Root }
+Riot::Context.instance_eval { include RiotRails::Context }