riot 0.11.4 → 0.12.0.pre

data/CHANGELOG

@@ -1,3 +1,9 @@
+*0.12.0.pre*
+
+* Negative tests are finally here! Added support for `denies` and adjusted macros to care about it with `devaluate`. [jaknowlden, achiu]
+
+    denies("my name") { "Rumplestiltzkin" }.equals("Henry")
+
 *0.11.4*
 
 * Passing Proc's instead of lambdas to `instance_eval` to comply with ruby 1.9.2. [skade]

data/VERSION

@@ -1 +1 @@
-0.11.4
+0.12.0.pre

data/lib/riot/assertion.rb

@@ -8,18 +8,19 @@ module Riot
       end
     end
 
-    def initialize(description, &definition)
-      super
-      @expectings, @expectation_block = [], false, nil
+    def initialize(description, negative=false, &definition)
+      super(description, &definition)
+      @negative = negative
+      @expectings, @expectation_block = [], nil
       @macro = AssertionMacro.default
     end
 
     def run(situation)
       @expectings << situation.evaluate(&@expectation_block) if @expectation_block
       actual = situation.evaluate(&definition)
-      @macro.evaluate((@macro.expects_exception? ? nil : actual), *@expectings)
+      assert((@macro.expects_exception? ? nil : actual), *@expectings)
     rescue Exception => e
-      @macro.expects_exception? ? @macro.evaluate(e, *@expectings) : @macro.error(e)
+      @macro.expects_exception? ? assert(e, *@expectings) : @macro.error(e)
     end
   private
     def enhance_with_macro(name, *expectings, &expectation_block)
@@ -30,5 +31,9 @@ module Riot
       self
     end
     alias :method_missing :enhance_with_macro
+
+    def assert(*arguments)
+      @negative ? @macro.devaluate(*arguments) : @macro.evaluate(*arguments)
+    end
   end # Assertion
 end # Riot

data/lib/riot/assertion_macro.rb

@@ -22,6 +22,10 @@ module Riot
   #       def evaluate(actual)
   #         actual.length == 0 ? pass : fail(expected_message(actual).to_be_empty)
   #       end
+  #
+  #       def devaluate(actual)
+  #         actual.empty? ? fail(expected_message(actual).to_not_be_empty) : pass(new_message.is_empty)
+  #       end
   #     end
   #
   class AssertionMacro
@@ -55,10 +59,16 @@ module Riot
 
     def expects_exception?; self.class.expects_exception; end
 
+    # Supports positive assertion testing
     def evaluate(actual)
       actual ? pass : fail("Expected non-false but got #{actual.inspect} instead")
     end
 
+    # Supports negative/converse assertion testing
+    def devaluate(actual)
+      !actual ? pass : fail("Expected non-true but got #{actual.inspect} instead")
+    end
+
     # Messaging
 
     def new_message(*phrases) Message.new(*phrases); end

data/lib/riot/assertion_macros/any.rb

@@ -1,12 +1,26 @@
 module Riot
-  # Asserts the result has items
+  # In the positive case, asserts the result has items using the +any?+ operator.
+  #
   #   asserts("an array") { [1] }.any
   #   asserts("a hash") { {:name => 'washington'} }.any
+  #
+  # In the negative case, asserts the result has no items using the +any?+ operator.
+  #
+  #   denies("an empty array") { [] }.any
+  #   denies("an empty hash") { {} }.any
   class AnyMacro < AssertionMacro
     register :any
 
     def evaluate(actual)
-      actual.any? ? pass("is not empty") : fail(expected_message(actual).to_have_items)
+      any?(actual) ? pass("is not empty") : fail(expected_message(actual).to_have_items)
+    end
+
+    def devaluate(actual)
+      any?(actual) ? fail(expected_message(actual).not_to_have_elements) : pass("has elements")
+    end
+  private
+    def any?(object)
+      object.kind_of?(String) ? object.length > 0 : object.any?
     end
   end
 end

data/lib/riot/assertion_macros/assigns.rb

@@ -1,27 +1,53 @@
 module Riot
-  # Asserts that an instance variable is defined for the result of the assertion. Value of instance
-  # variable is expected to not be nil
+  # In the positive case, asserts that an instance variable is defined for the result of the assertion.
+  # Value of instance variable is expected to not be nil.
+  #
   #   setup { User.new(:email => "foo@bar.baz") }
-  #   topic.assigns(:email)
+  #   asserts_topic.assigns(:email)
   #
   # If a value is provided in addition to the variable name, the actual value of the instance variable
-  # must equal the expected value
+  # must equal the expected value.
+  #
   #   setup { User.new(:email => "foo@bar.baz") }
-  #   topic.assigns(:email, "foo@bar.baz")
+  #   asserts_topic.assigns(:email, "foo@bar.baz")
+  #
+  # In the negative case, asserts that an instance variables *is not* defined or has a nil value. If a value
+  # is provided in addition to the name, then ensure that the actual value does not equal the expected value.
+  #
+  #   setup { User.new(:email => "foo@bar.baz") }
+  #   denies("topic") { topic }.assigns(:first_name)
+  #   denies("topic") { topic }.assigns(:email, "bar@baz.boo")
   class AssignsMacro < AssertionMacro
     register :assigns
 
     def evaluate(actual, *expectings)
-      variable, expected_value = expectings
-      variable_name = "@#{variable}"
-      actual_value = actual.instance_variable_defined?(variable_name) ? actual.instance_variable_get(variable_name) : nil
-      if actual_value.nil?
-        fail expected_message(variable).to_be_assigned_a_value
-      elsif !expected_value.nil? && expected_value != actual_value
-        fail expected_message(variable).to_be_equal_to(expected_value).not(actual_value)
-      else
-        pass
+      prepare(actual, *expectings) do |variable, expected_value, actual_value|
+        if actual_value.nil?
+          fail expected_message(variable).to_be_assigned_a_value
+        elsif !expected_value.nil? && expected_value != actual_value
+          fail expected_message(variable).to_be_equal_to(expected_value).not(actual_value)
+        else
+          pass
+        end
       end
     end
-  end
-end
+
+    def devaluate(actual, *expectings)
+      prepare(actual, *expectings) do |variable, expected_value, actual_value|
+        if actual_value.nil? || (expected_value && expected_value != actual_value)
+          pass
+        else
+          message = expected_message(variable).to_not_be
+          fail(expected_value.nil? ? message.assigned_a_value : message.equal_to(expected_value))
+        end
+      end
+    end
+
+  private
+
+    def prepare(actual, *expectings, &block)
+      variable, expected_value = expectings
+      yield(variable, expected_value, actual.instance_variable_get("@#{variable}"))
+    end
+  end # AssignsMacro
+end # Riot

data/lib/riot/assertion_macros/empty.rb

@@ -1,13 +1,24 @@
 module Riot
-  # Asserts the result is empty
+  # In the postive case, asserts the result of the test is empty.
+  #
   #   asserts("a string") { "" }.empty
   #   asserts("an array") { [] }.empty
   #   asserts("a hash") { Hash.new }.empty
+  #
+  # In the negative case, asserts the result of the test is not empty.
+  #
+  #   denies("a string") { "foo" }.empty
+  #   denies("an array") { [1] }.empty
+  #   denies("a hash") { {:foo => "bar" } }.empty
   class EmptyMacro < AssertionMacro
     register :empty
 
     def evaluate(actual)
-      actual.length == 0 ? pass : fail(expected_message(actual).to_be_empty)
+      actual.empty? ? pass(new_message.is_empty) : fail(expected_message(actual).to_be_empty)
+    end
+
+    def devaluate(actual)
+      actual.empty? ? fail(expected_message(actual).to_not_be_empty) : pass(new_message.is_empty)
     end
   end
 end

data/lib/riot/assertion_macros/equals.rb

@@ -1,9 +1,16 @@
 module Riot
-  # Asserts that the result of the test equals the expected value. Using the +==+ operator to assert
-  # equality.
+  # In the positive case, asserts that the result of the test equals the expected value. Using the +==+ 
+  # operator to assert equality.
+  #
   #   asserts("test") { "foo" }.equals("foo")
   #   should("test") { "foo" }.equals("foo")
   #   asserts("test") { "foo" }.equals { "foo" }
+  #
+  # In the negative case, asserts that the result of the test *does not* equal the expected value. Using the
+  # +==+ operator.
+  #
+  #   denies("test") { "foo" }.equals("bar")
+  #   denies("test") { "foo" }.equals { "bar" }
   class EqualsMacro < AssertionMacro
     register :equals
 
@@ -14,5 +21,13 @@ module Riot
         fail expected_message(expected).not(actual)
       end
     end
+
+    def devaluate(actual, expected)
+      if expected != actual
+        pass new_message.is_equal_to(expected).when_it_is(actual)
+      else
+        fail new_message.did_not_expect(actual)
+      end
+    end
   end
 end

data/lib/riot/assertion_macros/equivalent_to.rb

@@ -5,7 +5,12 @@ module Riot
   #   should("test") { "foo" }.equivalent_to("foo")
   #   asserts("test") { "foo" }.equivalent_to { "foo" }
   #
-  # Underneath the hood, this assertion macro says:
+  # You can also assert that the expected value is not equivalent to something else:
+  #
+  #   denies("test") { "foo" }.equivalent_to(Boolean)
+  #   denies("test") { "foo" }.equivalent_to("bar")
+  #
+  # Underneath the hood, this assertion macro uses:
   #
   #   expected === actual
   class EquivalentToMacro < AssertionMacro
@@ -18,5 +23,14 @@ module Riot
         fail expected_message(actual).to_be_equivalent_to(expected)
       end
     end
+    
+    def devaluate(actual, expected)
+      if expected === actual
+        fail expected_message(actual).not_to_be_equivalent_to(expected)
+      else
+        pass new_message.is_not_equivalent_to(expected)
+      end
+    end
+    
   end
 end

data/lib/riot/assertion_macros/exists.rb

@@ -1,15 +1,27 @@
 module Riot
   # Asserts that the result of the test is a non-nil value. This is useful in the case where you don't want
   # to translate the result of the test into a boolean value
+  #
   #   asserts("test") { "foo" }.exists
   #   should("test") { 123 }.exists
   #   asserts("test") { "" }.exists
   #   asserts("test") { nil }.exists # This would fail
+  #
+  # You can also test for non-existince (being nil), but if you would better if you used the +nil+ macro:
+  #
+  #   denies("test") { nil }.exists # would pass
+  #   asserts("test") { nil }.nil   # same thing
+  #
+  #   denies("test") { "foo" }.exists # would fail
   class ExistsMacro < AssertionMacro
     register :exists
 
     def evaluate(actual)
-      !actual.nil? ? pass("is not nil") : fail("expected a non-nil value")
+      actual.nil? ? fail("expected a non-nil value") : pass("is not nil")
+    end
+    
+    def devaluate(actual)
+      actual.nil? ? pass("is nil") : fail("expected a nil value")
     end
   end
 end

data/lib/riot/assertion_macros/includes.rb

@@ -1,8 +1,15 @@
 module Riot
   # Asserts the result contains the expected element
+  #
   #   asserts("a string") { "world" }.includes('o')
   #   asserts("an array") { [1,2,3] }.includes(2)
   #   asserts("a range") { (1..15) }.includes(10)
+  #
+  # You can also assert that the result does not contain an element:
+  #
+  #   denies("a string") { "world" }.includes('f')
+  #   denies("an array") { [1,2,3,4,5] }.includes(0)
+  #   denies("a range") { (1..15) }.includes(16)
   class IncludesMacro < AssertionMacro
     register :includes
 
@@ -13,5 +20,14 @@ module Riot
         fail expected_message(actual).to_include(expected)
       end
     end
+    
+    def devaluate(actual, expected)
+      if actual.include?(expected)
+        fail expected_message(actual).to_not_include(expected)
+      else
+        pass new_message.does_not_include(expected)
+      end
+    end
+    
   end
 end

data/lib/riot/assertion_macros/kind_of.rb

@@ -1,7 +1,12 @@
 module Riot
   # Asserts that the result of the test is an object that is a kind of the expected type
+  #
   #   asserts("test") { "foo" }.kind_of(String)
   #   should("test") { "foo" }.kind_of(String)
+  #
+  # You can also test the result is not a kind of a thing:
+  #
+  #   denies("test") { "foo" }.kind_of(Boolean)
   class KindOfMacro < AssertionMacro
     register :kind_of
 
@@ -12,5 +17,13 @@ module Riot
         fail expected_message.kind_of(expected).not(actual.class)
       end
     end
+    
+    def devaluate(actual, expected)
+      if actual.kind_of?(expected)
+        fail expected_message.not_kind_of(expected).not(actual.class)
+      else
+        pass new_message.is_not_a_kind_of(expected)
+      end
+    end
   end
 end

data/lib/riot/assertion_macros/matches.rb

@@ -1,7 +1,12 @@
 module Riot
   # Asserts that the result of the test equals matches against the proved expression
+  #
   #   asserts("test") { "12345" }.matches(/\d+/)
   #   should("test") { "12345" }.matches(/\d+/)
+  #
+  # You can also test that the result does not match your regex:
+  #
+  #   denies("test") { "hello, world"}.matches(/\d+/)
   class MatchesMacro < AssertionMacro
     register :matches
 
@@ -13,5 +18,14 @@ module Riot
         fail(expected_message(expected).to_match(actual))
       end
     end
+    
+    def devaluate(actual, expected)
+      expected = %r[#{Regexp.escape(expected)}] if expected.kind_of?(String)
+      if actual.to_s =~ expected
+        fail(expected_message(expected).not_to_match(actual))
+      else
+        pass(new_message.does_not_match(expected))
+      end
+    end
   end
 end

data/lib/riot/assertion_macros/nil.rb

@@ -1,12 +1,22 @@
 module Riot
   # Asserts that the result of the test is nil
+  #
   #   asserts("test") { nil }.nil
   #   should("test") { nil }.nil
+  #
+  # You could test that the result is not nil, but it would make more sense to use the +exists+ macro:
+  #
+  #   denies("test") { "foo" }.nil
+  #   asserts("test") { "foo" }.exists
   class NilMacro < AssertionMacro
     register :nil
 
     def evaluate(actual)
       actual.nil? ? pass("is nil") : fail(expected_message.nil.not(actual))
     end
+    
+    def devaluate(actual)
+      actual.nil? ? fail(expected_message.is_nil.not('non-nil')) : pass("is not nil")
+    end
   end
 end

data/lib/riot/assertion_macros/not_borat.rb

@@ -1,16 +1,26 @@
 module Riot
   # Asserts the result of the test is a non-truthy value. Read the following assertions in the way Borat
   # learned about humor:
+  #
   #   asserts("you are funny") { false }.not!
   #   should("be funny") { nil }.not!
   #
   # Thusly, Borat would say "You are funny ... not!" The above two assertions would pass because the values
   # are non-truthy.
+  #
+  # You can also apply not to the negative assertion (denies), but I'm not sure how much sense it would make.
+  # It would be kind of like a double negative:
+  #
+  #   denies("you are funny") { true }.not!
   class NotMacro < AssertionMacro
     register :not!
 
     def evaluate(actual)
       actual ? fail("expected to exist ... not!") : pass("does exist ... not!")
     end
+    
+    def devaluate(actual)
+      actual ? pass("does not exist ... not!") : fail("expected to not exist ... not!")
+    end
   end
 end

data/lib/riot/assertion_macros/raises.rb

@@ -7,6 +7,13 @@ module Riot
   # from the actual raised exception will be converted to a string before any comparison is executed.
   #   asserts("test") { raise My::Exception, "Foo" }.raises(My::Exception, "Foo")
   #   asserts("test") { raise My::Exception, "Foo Bar" }.raises(My::Exception, /Bar/)
+  #
+  # In the negative case, you can test that an exception was not raised or that if an exception was raised
+  # that the type of exception was different (sounds confusing).
+  #
+  #   denies("test") { "foo" }.raises(Exception) # would pass
+  #   denies("test") { raise Exception }.raises(My::Exception) # would pass
+  #   denies("test") { raise Exception }.raises(Exception) # would fail
   class RaisesMacro < AssertionMacro
     register :raises
     expects_exception!
@@ -24,5 +31,26 @@ module Riot
         pass(expected_message ? message.with_message(expected_message) : message)
       end
     end # evaluate
+
+    def devaluate(actual_exception, expected_class, expected_message=nil)
+      actual_message = actual_exception && actual_exception.message
+      if actual_exception.nil?
+        pass new_message.raised_nothing
+      elsif expected_class != actual_exception.class
+        if expected_message && !(actual_message.to_s =~ %r[#{expected_message}])
+          pass new_message.not_raised(expected_class).with_message(expected_message)
+        else
+          pass new_message.not_raised(expected_class)
+        end
+      else
+        message = should_have_message.not_raised(expected_class)
+        if expected_message
+          fail message.with_message(expected_message).but.raised(actual_exception.class).
+            with_message(actual_exception.message)
+        else
+          fail message.but.raised(actual_exception.class)
+        end
+      end
+    end # devaluate
   end # RaisesMacro
 end