riot 0.12.2 → 0.12.3

data/CHANGELOG

@@ -1,3 +1,30 @@
+== 0.12.3
+
+==== Going nuts with context helpers: should_not, asserts/denies_topic arguments [achiu]
+
+This works now: `should_not("do something")` as an alias for `denies`
+
+You can now pass arguments to `asserts`, `denies`, `should`, and `should_not`.
+
+    context "Playing with hashes" do
+			setup do
+				{ "foo" => "bar" }
+			end
+
+			asserts(:[], "foo").equals("bar")
+			should(:[], "foo").equals("bar")
+			denies(:[], "foo").equals("goo")
+			should_not(:[], "foo").equals("goo")
+		end # Playing with hashes
+
+==== Exit gracefully if a child process exited with failing status [timgaleckas]
+
+No tests will run in this situation.
+
+==== No status displayed if no tests run [timgaleckas]
+
+==== Adding a `denies_topic` macro to Context [Mon-Ouie]
+
 == 0.12.2
 
 ==== RDoc'ed the hell out of everything [jaknowlden]

data/lib/riot.rb

@@ -37,7 +37,7 @@ module Riot
     the_reporter = reporter.new
     the_reporter.summarize do
       root_contexts.each { |ctx| ctx.run(the_reporter) }
-    end
+    end unless root_contexts.empty?
     the_reporter
   end
 
@@ -100,7 +100,16 @@ module Riot
     Riot.reporter = Riot::PrettyDotMatrixReporter
   end
 
-  at_exit { exit(run.success?) unless Riot.alone? }
+  # Making sure to account for Riot being run as part of a larger rake task (or something similar).
+  # If a child process exited with a failing status, probably don't want to run Riot tests; just exit
+  # with the child status.
+  at_exit do
+    unless Riot.alone?
+      status = $?.exitstatus unless ($?.nil? || $?.success?)
+      exit(status || run.success?)
+    end
+  end
+  
 end # Riot
 
 # A little bit of monkey-patch so we can have +context+ available anywhere.
@@ -115,3 +124,9 @@ class Object
   end
   alias_method :describe, :context
 end # Object
+
+class Array
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end

data/lib/riot/context_helpers.rb

@@ -80,13 +80,17 @@ module Riot
     #
     #   asserts(:size).equals(2)
     #
+    # Or with arguments:
+    # 
+    #   asserts(:foo,1,2).equals(3)
+    #
     # Passing a Symbol to +asserts+ enables this behaviour. For more information on
     # assertion macros, see {Riot::AssertionMacro}.
     #
     # @param [String, Symbol] what description of test or property to inspect on the topic
     # @return [Riot::Assertion]
-    def asserts(what, &definition)
-      new_assertion("asserts", what, &definition)
+    def asserts(*what, &definition)
+      new_assertion("asserts", *what, &definition)
     end
 
     # Same as #asserts, except it uses the phrase "should" in the report output. Sometimes you feel like a
@@ -94,10 +98,14 @@ module Riot
     #
     #   should("ensure expected") { "bar" }.equals("bar")
     #
+    #   #should also has the same shortcuts available to #asserts:
+    #
+    #   should(:bar,1,2).equals(3)
+    #
     # @param [String, Symbol] what description of test or property to inspect on the topic
     # @return [Riot::Assertion]
-    def should(what, &definition)
-      new_assertion("should", what, &definition)
+    def should(*what, &definition)
+      new_assertion("should", *what, &definition)
     end
 
     # Like an assertion, but expects negative results.
@@ -115,13 +123,39 @@ module Riot
     #
     #   denies(:size).equals(2)
     #
+    # the shorcut can also pass additional arguments to the method like:
+    #
+    #   denies(:foo,1,3).equals(2)
+    #
     # Passing a Symbol to +denies+ enables this behaviour. For more information on
     # assertion macros, see {Riot::AssertionMacro}.
     #
     # @param [String, Symbol] what description of test or property to inspect on the topic
     # @return [Riot::Assertion]
-    def denies(what, &definition)
-      new_assertion("denies", what, true, &definition)
+    def denies(*what, &definition)
+      what << {:negative => true}
+      new_assertion "denies", *what, &definition
+    end
+
+    # This is the negative form of #should. This is exactly like denies. Just here for syntactic sugar.
+    #
+    # A basic eample is:
+    #
+    #   should_not("have size equal 2") { topic.size == 2 }
+    #
+    # In addition, the #denies shortcut as available as well:
+    #
+    #   should_not(:size).equals 3
+    #
+    # Or passing in arguments
+    #
+    #   should_not(:foo,1,2).equals(2)
+    #
+    # @param [String,Symbol] what description or property to inspect on the topic
+    # @return [Riot::Assertion]
+    def should_not(*what, &definition)
+      what << {:negative => true}
+      new_assertion "should not", *what, &definition
     end
 
     # Makes an assertion on the topic itself, e.g.
@@ -133,19 +167,25 @@ module Riot
     def asserts_topic(what="that it")
       asserts(what) { topic }
     end
-  private
-    def new_assertion(scope, what, negative=false, &definition)
-      if what.kind_of?(Symbol)
-        definition ||= proc { topic.send(what) }
-        description = "#{scope} ##{what}"
-      elsif what.kind_of?(Array)
-        definition ||= proc { topic.send(*what) }
-        description = "#{scope} ##{what.first} with argument(s): #{what[1..-1]}"
-      else
-        description = "#{scope} #{what}"
-      end
 
-      (@assertions << assertion_class.new(description, negative, &definition)).last
+    # Makes a negative assertion on the topic itself, e.g.
+    #
+    #   denies_topic.matches(/^ab+/)
+    #
+    # @param [String] what description of test
+    # @return [Riot::Assertion]
+    def denies_topic(what="that it")
+      denies(what) { topic }
     end
+  private
+    
+    def new_assertion(scope, *args, &definition)
+      options = args.extract_options!
+      definition ||= proc { topic.send(*args) }
+      description = "#{scope} #{args.first}"
+      description << " with arguments(s): #{args.slice(1, args.length)}" if args.size > 1
+      (@assertions << assertion_class.new(description, options[:negative], &definition)).last
+    end
+
   end # AssertionHelpers
 end # Riot

data/lib/riot/version.rb

@@ -1,4 +1,4 @@
 module Riot
-  VERSION = "0.12.2"
+  VERSION = "0.12.3"
 end
 

data/test/core/context/asserts_topic_test.rb

@@ -19,3 +19,23 @@ context "The asserts_topic shortcut" do
     asserts(:to_s).equals("asserts get some")
   end
 end # The asserts_topic shortcut
+
+context "The denies_topic shortcut" do
+  setup do
+    Riot::Context.new("foo") {}.denies_topic
+  end
+
+  should("return an Assertion") { topic }.kind_of(Riot::Assertion)
+
+  should("return the actual topic as the result of evaling the assertion") do
+    (situation = Riot::Situation.new).instance_variable_set(:@_topic, "bar")
+    topic.equals("not bar").run(situation)
+  end.equals([:pass, %Q{is equal to "not bar" when it is "bar"}])
+
+  asserts(:to_s).equals("denies that it")
+
+  context "with an explicit description" do
+    setup { Riot::Context.new("foo") {}.denies_topic("get some") }
+    asserts(:to_s).equals("denies get some")
+  end
+end # The denies_topic shortcut

data/test/core/context/asserts_with_arguments_test.rb

@@ -2,7 +2,7 @@ require 'teststrap'
 
 context "an assertion made with arguments" do
   setup do
-    Riot::Context.new("foo") {}.asserts([:[], 0])
+    Riot::Context.new("foo") {}.asserts(:[], 0)
   end
 
   should("pass its argument to send, with the first argument as method name") do
@@ -10,3 +10,14 @@ context "an assertion made with arguments" do
     topic.equals(1).run(situation).first
   end.equals(:pass)
 end # assertion made with arguments
+
+context "a should made with arguments" do
+  setup do
+    Riot::Context.new("foo") {}.should(:[], 0)
+  end
+
+  should("pass its argument to send, with the first argument as method name") do
+    (situation = Riot::Situation.new).instance_variable_set(:@_topic, [1, 2])
+    topic.equals(1).run(situation).first
+  end.equals(:pass)
+end

data/test/core/context/denies_with_arguments_test.rb

@@ -0,0 +1,23 @@
+require 'teststrap'
+
+context "a negative assertion made with arguments" do
+  setup do
+    Riot::Context.new("foo") {}.denies(:[], 0)
+  end
+
+  should("pass its argument to send, with the first argument as method name") do
+    (situation = Riot::Situation.new).instance_variable_set(:@_topic, [1, 2])
+    topic.equals(1).run(situation).first
+  end.equals(:fail)
+end # assertion made with arguments
+
+context "a negative assertion made with arguments" do
+  setup do
+    Riot::Context.new("foo") {}.should_not(:[], 0)
+  end
+
+  should("pass its argument to send, with the first argument as method name") do
+    (situation = Riot::Situation.new).instance_variable_set(:@_topic, [1, 2])
+    topic.equals(1).run(situation).first
+  end.equals(:fail)
+end # assertion made with arguments

data/test/core/context/deny_test.rb

@@ -2,24 +2,52 @@ require 'teststrap'
 
 context "Using denies" do
 
-  helper(:denial_context) do |&assertion_block|
+  helper(:denial_context) do |actual|
     report = Riot::Context.new("Apple Jackie") do
-      denies("with false", &assertion_block)
+      denies("with false") { actual }
     end.run(MockReporter.new)
 
     [report.passes, report.failures, report.errors]
   end # denial_context
 
   asserts("result when returning false from the assertion block") do
-    denial_context { false }
+    denial_context(false)
   end.equals([1,0,0])
 
   asserts("result when returning true from the assertion block") do
-    denial_context { true }
+    denial_context(true)
   end.equals([0,1,0])
 
   asserts("result when assertion block has an exception") do
-    denial_context { raise Exception }
-  end.equals([0,0,1])
+    Riot::Context.new("Apple Jackie") do
+      denies("with false") { raise Exception }
+    end.run(MockReporter.new).errors
+  end.equals(1)
 
 end # Using denies
+
+context "Using should_not" do
+
+  helper(:denial_context) do |actual|
+    report = Riot::Context.new("Apple Jackie") do
+      should_not("with false") { actual }
+    end.run(MockReporter.new)
+
+    [report.passes, report.failures, report.errors]
+  end # denial_context
+
+  asserts("result when returning false from the assertion block") do
+    denial_context(false)
+  end.equals([1,0,0])
+
+  asserts("result when returning true from the assertion block") do
+    denial_context(true)
+  end.equals([0,1,0])
+
+  asserts("result when assertion block has an exception") do
+    Riot::Context.new("Apple Jackie") do
+      should_not("with false") { raise Exception }
+    end.run(MockReporter.new).errors
+  end.equals(1)
+
+end # Using should_not

data/test/core/runnable/negative_assertion_test.rb

@@ -2,35 +2,35 @@ require 'teststrap'
 
 context "A negative assertion test" do
 
-  helper(:negative_assertion) do |&definition|
-    Riot::Assertion.new("foo", true, &definition)
+  helper(:negative_assertion) do |definition|
+    Riot::Assertion.new("foo", true) { definition }
   end
 
   asserts("response when evaluated with false result") do
-    negative_assertion { false }.run(Riot::Situation.new)
+    negative_assertion(false).run(Riot::Situation.new)
   end.equals([:pass, ""])
   
   asserts("response when evaluated with nil result") do
-    negative_assertion { false }.run(Riot::Situation.new)
+    negative_assertion(false).run(Riot::Situation.new)
   end.equals([:pass, ""])
   
   asserts("response when evaluated with true result") do
-    negative_assertion { true }.run(Riot::Situation.new)
+    negative_assertion(true).run(Riot::Situation.new)
   end.equals([:fail, "Expected non-true but got true instead", nil, nil])
 
   asserts("response when evaluated with \"bar\" result") do
-    negative_assertion { "bar" }.run(Riot::Situation.new)
+    negative_assertion("bar").run(Riot::Situation.new)
   end.equals([:fail, "Expected non-true but got \"bar\" instead", nil, nil])
 
   asserts("response when evaluated with 0 result") do
-    negative_assertion { 0 }.run(Riot::Situation.new)
+    negative_assertion(0).run(Riot::Situation.new)
   end.equals([:fail, "Expected non-true but got 0 instead", nil, nil])
 
   helper(:big_exception) { @exception ||= Exception.new("blah") }
 
   asserts("response when evaluation errors") do
     exception = big_exception # :\
-    negative_assertion { raise exception }.run(Riot::Situation.new)
+    Riot::Assertion.new("foo", true) { raise exception }.run(Riot::Situation.new)
   end.equals { [:error, big_exception] }
 
 end # A negative assertion test

metadata

@@ -2,7 +2,7 @@
 name: riot
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.12.2
+  version: 0.12.3
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-27 00:00:00 -06:00
+date: 2011-03-10 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -97,6 +97,7 @@ files:
 - test/core/context/asserts_with_arguments_test.rb
 - test/core/context/context_test.rb
 - test/core/context/context_with_options_test.rb
+- test/core/context/denies_with_arguments_test.rb
 - test/core/context/deny_test.rb
 - test/core/context/helper_test.rb
 - test/core/context/hookup_test.rb
@@ -168,6 +169,7 @@ test_files:
 - test/core/context/asserts_with_arguments_test.rb
 - test/core/context/context_test.rb
 - test/core/context/context_with_options_test.rb
+- test/core/context/denies_with_arguments_test.rb
 - test/core/context/deny_test.rb
 - test/core/context/helper_test.rb
 - test/core/context/hookup_test.rb