riot 0.9.12 → 0.10.0

data/lib/riot/reporter.rb

@@ -0,0 +1,77 @@
+module Riot
+  class Reporter
+    attr_accessor :passes, :failures, :errors
+    def initialize
+      @passes = @failures = @errors = 0
+    end
+
+    def summarize(&block)
+      started = Time.now
+      yield
+    ensure
+      results(Time.now - started)
+    end
+
+    def describe_context(msg); end
+
+    def report(description, response)
+      code, result = *response
+      case code
+      when :pass then
+        @passes += 1
+        pass(description)
+      when :fail then
+        @failures += 1
+        fail(description, result)
+      when :error then
+        @errors += 1
+        error(description, result)
+      end
+    end
+  end # Reporter
+
+  class IOReporter < Reporter
+    def initialize(writer=nil)
+      super()
+      @writer = writer || STDOUT
+    end
+    def say(message) @writer.puts(message); end
+
+    def results(time_taken)
+      values = [@passes, @failures, @errors, ("%0.6f" % time_taken)]
+      say "\n%d passes, %d failures, %d errors in %s seconds" % values
+    end
+  end
+
+  class StoryReporter < IOReporter
+    def describe_context(description) say description; end
+    def pass(description) say "  + " + description.green; end
+    def fail(description, message) say "  - " + "#{description}: #{message}".yellow; end
+    def error(description, e) say "  ! " + "#{description}: #{e.message}".red; end
+  end
+
+  class DotMatrixReporter < IOReporter
+    def pass(description); @writer.write ".".green; end
+    def fail(description, message); @writer.write "F".yellow; end
+    def error(description, e); @writer.write "E".red; end
+  end
+
+  class SilentReporter < Reporter
+    def pass(description); end
+    def fail(description, message); end
+    def error(description, e); end
+    def results(time_taken); end
+  end
+end # Riot
+
+begin
+  raise LoadError if ENV["TM_MODE"]
+  require 'rubygems'
+  require 'colorize'
+rescue LoadError
+  class ::String
+    def green; self; end
+    alias :red :green
+    alias :yellow :green
+  end
+end

data/lib/riot/runnable.rb

@@ -0,0 +1,50 @@
+module Riot
+  class RunnableBlock
+    def initialize(description, &definition)
+      @description, @definition = description, definition
+    end
+
+    def to_s
+      @description
+    end
+  end # RunnableBlock
+
+  class Setup < RunnableBlock
+    def initialize(&definition)
+      super("setup", &definition)
+    end
+
+    def run(situation)
+      situation.setup(&@definition)
+      [:setup]
+    end
+  end # Setup
+
+  class Assertion < RunnableBlock
+    def self.pass() [:pass]; end
+    def self.fail(message) [:fail, message]; end
+    def self.error(e) [:error, e]; end
+
+    def run(situation)
+      process_macro(situation, false) do |actual|
+        actual ? Assertion.pass : Assertion.fail("Expected non-false but got #{actual.inspect} instead")
+      end
+    end
+
+    def self.assertion(name, expect_exception=false, &assertion_block)
+      define_method(name) do |*expectings|
+        (class << self; self; end).send(:define_method, :run) do |situation|
+          process_macro(situation, expect_exception) { |actual| assertion_block.call(actual, *expectings) }
+        end # redefine run method when the assertion is called
+        self
+      end # define_method for assertion
+    end
+  private
+    def process_macro(situation, expect_exception)
+      actual = situation.evaluate(&@definition)
+      yield(expect_exception ? nil : actual)
+    rescue Exception => e
+      expect_exception ? yield(e) : Assertion.error(e)
+    end
+  end # Assertion
+end # Riot

data/lib/riot/situation.rb

@@ -1,9 +1,12 @@
 module Riot
   class Situation
     attr_accessor :topic
+    def setup(&block)
+      @topic = self.instance_eval(&block)
+    end
 
-    def fail(message)
-      raise Failure.new(message)
+    def evaluate(&block)
+      self.instance_eval(&block)
     end
   end # Situation
-end # Riot
+end # Riot

data/riot.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot}
-  s.version = "0.9.12"
+  s.version = "0.10.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2009-10-22}
+  s.date = %q{2009-11-21}
   s.description = %q{An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks. Protest the slow test.}
   s.email = %q{gus@gusg.us}
   s.extra_rdoc_files = [
@@ -22,25 +22,29 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "lib/riot.rb",
-     "lib/riot/assertion.rb",
      "lib/riot/assertion_macros.rb",
      "lib/riot/context.rb",
-     "lib/riot/errors.rb",
-     "lib/riot/report.rb",
+     "lib/riot/reporter.rb",
+     "lib/riot/runnable.rb",
      "lib/riot/situation.rb",
      "riot.gemspec",
-     "test/assertion_macros/assertion_macro_assigns_test.rb",
-     "test/assertion_macros/assertion_macro_equals_test.rb",
-     "test/assertion_macros/assertion_macro_exists_test.rb",
-     "test/assertion_macros/assertion_macro_kind_of_test.rb",
-     "test/assertion_macros/assertion_macro_matching_test.rb",
-     "test/assertion_macros/assertion_macro_nil_test.rb",
-     "test/assertion_macros/assertion_macro_raises_test.rb",
-     "test/assertion_macros/assertion_macro_respond_to_test.rb",
+     "test/assertion_macros/assigns_test.rb",
+     "test/assertion_macros/equals_test.rb",
+     "test/assertion_macros/exists_test.rb",
+     "test/assertion_macros/kind_of_test.rb",
+     "test/assertion_macros/matching_test.rb",
+     "test/assertion_macros/nil_test.rb",
+     "test/assertion_macros/raises_test.rb",
+     "test/assertion_macros/respond_to_test.rb",
+     "test/assertion_macros/same_elements_test.rb",
      "test/assertion_test.rb",
      "test/benchmark/riot_vs_minitest.rb",
+     "test/benchmark/same_elements_vs_set.rb",
      "test/benchmark/simple_context_and_assertions.rb",
      "test/context_test.rb",
+     "test/report_test.rb",
+     "test/setup_test.rb",
+     "test/situation_test.rb",
      "test/teststrap.rb"
   ]
   s.homepage = %q{http://github.com/thumblemonks/riot}
@@ -49,18 +53,23 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.}
   s.test_files = [
-    "test/assertion_macros/assertion_macro_assigns_test.rb",
-     "test/assertion_macros/assertion_macro_equals_test.rb",
-     "test/assertion_macros/assertion_macro_exists_test.rb",
-     "test/assertion_macros/assertion_macro_kind_of_test.rb",
-     "test/assertion_macros/assertion_macro_matching_test.rb",
-     "test/assertion_macros/assertion_macro_nil_test.rb",
-     "test/assertion_macros/assertion_macro_raises_test.rb",
-     "test/assertion_macros/assertion_macro_respond_to_test.rb",
+    "test/assertion_macros/assigns_test.rb",
+     "test/assertion_macros/equals_test.rb",
+     "test/assertion_macros/exists_test.rb",
+     "test/assertion_macros/kind_of_test.rb",
+     "test/assertion_macros/matching_test.rb",
+     "test/assertion_macros/nil_test.rb",
+     "test/assertion_macros/raises_test.rb",
+     "test/assertion_macros/respond_to_test.rb",
+     "test/assertion_macros/same_elements_test.rb",
      "test/assertion_test.rb",
      "test/benchmark/riot_vs_minitest.rb",
+     "test/benchmark/same_elements_vs_set.rb",
      "test/benchmark/simple_context_and_assertions.rb",
      "test/context_test.rb",
+     "test/report_test.rb",
+     "test/setup_test.rb",
+     "test/situation_test.rb",
      "test/teststrap.rb"
   ]
 

data/test/assertion_macros/assigns_test.rb

@@ -0,0 +1,24 @@
+require 'teststrap'
+
+context "An assigns assertion macro" do
+  setup do
+    item = Object.new
+    item.instance_eval { @foo = 1; @bar; @nil_val = nil }
+    Riot::Assertion.new("test") { item }
+  end
+
+  assertion_test_passes("when foo is defined") { topic.assigns(:foo) }
+  assertion_test_passes("when foo is defined with expected value") { topic.assigns(:foo, 1) }
+
+  assertion_test_fails("when foo does not match expectation", "expected @foo to be equal to 2, not 1") do
+    topic.assigns(:foo, 2)
+  end
+
+  assertion_test_fails("when bar is not define", "expected @bar to be assigned a value") do
+    topic.assigns(:bar)
+  end
+
+  assertion_test_fails("when var assigned nil value", "expected @nil_val to be assigned a value") do
+    topic.assigns(:nil_val)
+  end
+end # An assigns assertion macro

data/test/assertion_macros/equals_test.rb

@@ -0,0 +1,18 @@
+require 'teststrap'
+
+context "An equals assertion macro" do
+  setup do
+    Riot::Assertion.new("blue") { "foo" }
+  end
+
+  asserts(":pass when expectation met") do
+    topic.equals("foo").run(Riot::Situation.new) == [:pass]
+  end
+
+  context "that is failing" do
+    setup { topic.equals("bar").run(Riot::Situation.new) }
+
+    asserts(":fail") { topic.first == :fail }
+    asserts("message") { topic.last == %Q{expected "foo" to equal "bar"} }
+  end # that is failing
+end # An equals assertion macro

data/test/assertion_macros/exists_test.rb

@@ -0,0 +1,17 @@
+require 'teststrap'
+
+context "An exists assertion macro" do
+  setup { Riot::Situation.new }
+
+  asserts(":pass when result has a value") do
+    Riot::Assertion.new("foo") { "foo" }.exists.run(topic)
+  end.equals([:pass])
+
+  asserts(":pass because empty string is considered a value") do
+    Riot::Assertion.new("foo") { "" }.exists.run(topic)
+  end.equals([:pass])
+
+  asserts(":fail with message when value is nil") do
+    Riot::Assertion.new("foo") { nil }.exists.run(topic)
+  end.equals([:fail, "expected a non-nil value"])
+end # An exists assertion macro

data/test/assertion_macros/kind_of_test.rb

@@ -0,0 +1,17 @@
+require 'teststrap'
+
+context "A kind_of assertion macro" do
+  setup { Riot::Situation.new }
+
+  asserts ":pass when specific result is a kind of String" do
+    Riot::Assertion.new("foo") { "a" }.kind_of(String).run(topic)
+  end.equals([:pass])
+
+  asserts ":fail when not a kind of String" do
+    Riot::Assertion.new("foo") { 0 }.kind_of(String).run(topic)
+  end.equals([:fail, %Q{expected kind of String, not 0}])
+  
+  asserts ":fail when nil" do
+    Riot::Assertion.new("foo") { }.kind_of(String).run(topic)
+  end.equals([:fail, %Q{expected kind of String, not nil}])
+end # A kind_of assertion macro

data/test/assertion_macros/matching_test.rb

@@ -0,0 +1,12 @@
+require 'teststrap'
+
+context "A matching assertion macro" do
+  setup { Riot::Assertion.new("foo") { "abc" } }
+
+  assertion_test_passes("when expression matches actual") { topic.matches(/abc/) }
+
+  assertion_test_fails("when expression fails to match", "expected /abcd/ to match \"abc\"") do
+    topic.matches(/abcd/)
+  end
+
+end # A matching assertion macro

data/test/assertion_macros/nil_test.rb

@@ -0,0 +1,13 @@
+require 'teststrap'
+
+context "A nil assertion macro" do
+  setup { Riot::Situation.new }
+
+  asserts(":pass when result is nil") do
+    Riot::Assertion.new("foo") { nil }.nil.run(topic)
+  end.equals([:pass])
+
+  asserts(":fail with message") do
+    Riot::Assertion.new("foo") { "a" }.nil.run(topic)
+  end.equals([:fail, %Q{expected nil, not "a"}])
+end # A nil assertion macro

data/test/assertion_macros/raises_test.rb

@@ -0,0 +1,33 @@
+require 'teststrap'
+
+class Whoops < Exception; end
+
+context "A raises assertion macro" do
+  assertion_test_passes("when expected exception is raised") do
+    Riot::Assertion.new("foo") { raise Whoops }.raises(Whoops)
+  end
+
+  assertion_test_fails("when unexpected exception is raised", "should have raised Exception, not Whoops") do
+    Riot::Assertion.new("foo") { raise Whoops }.raises(Exception)
+  end
+
+  assertion_test_fails("when nothing was raised", "should have raised Whoops, but raised nothing") do
+    assertion = Riot::Assertion.new("foo") { "barf" }.raises(Whoops)
+  end
+  
+  assertion_test_passes("when provided message equals expected message") do
+    Riot::Assertion.new("foo") { raise Whoops, "Mom" }.raises(Whoops, "Mom")
+  end
+
+  assertion_test_fails("when messages aren't equal", %Q{expected "Mom" for message, not "Dad"}) do
+    Riot::Assertion.new("foo") { raise Whoops, "Dad" }.raises(Whoops, "Mom")
+  end
+
+  assertion_test_passes("when provided message matches expected message") do
+    Riot::Assertion.new("foo") { raise Whoops, "Mom" }.raises(Whoops, /Mom/)
+  end
+
+  assertion_test_fails("when messages don't match", %Q{expected /Mom/ for message, not "Dad"}) do
+    Riot::Assertion.new("foo") { raise Whoops, "Dad" }.raises(Whoops, /Mom/)
+  end
+end # A raises assertion macro

data/test/assertion_macros/respond_to_test.rb

@@ -0,0 +1,12 @@
+require 'teststrap'
+
+context "A respond_to assertion macro" do
+  setup { Riot::Assertion.new("foo") { "bar" } }
+
+  assertion_test_passes("when method is defined") { topic.respond_to(:each_byte) }
+
+  assertion_test_fails("when method not defined", "expected method :goofballs is not defined") do
+    topic.respond_to(:goofballs)
+  end
+
+end # A respond_to assertion macro

data/test/assertion_macros/same_elements_test.rb

@@ -0,0 +1,17 @@
+require 'teststrap'
+
+context "A same_elements assertion macro" do
+  setup { Riot::Assertion.new("test") { ["foo", "bar", 69] } }
+
+  assertion_test_passes(%Q{when [69, "foo", "bar"] are returned}) do
+    topic.same_elements([69, "foo", "bar"])
+  end
+
+  assertion_test_passes(%Q{when [69, "foo", "bar"] are returned in any order}) do
+    topic.same_elements(["foo", "bar", 69])
+  end
+
+  assertion_test_fails("when elements do not match", %Q{expected elements ["foo", "bar", 96] to match ["foo", "bar", 69]}) do
+    topic.same_elements(["foo", "bar", 96])
+  end
+end # A same_elements assertion macro

data/test/assertion_test.rb

@@ -1,31 +1,34 @@
 require 'teststrap'
 
-context "basic assertion" do
-  setup { Riot::Situation.new }
+context "An assertion block" do
+  context "that is passing" do
+    setup { Riot::Assertion.new("foo") { true } }
+    asserts("to_s") { topic.to_s == "foo" }
 
-  should "have a description" do
-    Riot::Assertion.new("i will pass", topic).to_s
-  end.equals("i will pass")
-
-  asserts "pass? is true when assertion passed" do
-    Riot::Assertion.new("i will pass", topic) { true }.passed?
-  end
+    asserts(":pass is returned when evaluated") do
+      topic.run(Riot::Situation.new) == [:pass]
+    end
+  end # that is passing
 
-  asserts "failure? is true when assertion does not pass" do
-    Riot::Assertion.new("i will pass", topic) { false }.failed?
-  end
+  context "that is failing" do
+    setup { Riot::Assertion.new("foo") { nil } }
+    asserts("to_s") { topic.to_s == "foo" }
 
-  asserts "error? is true when an unexpected Exception is raised" do
-    Riot::Assertion.new("error", topic) { raise Exception, "blah" }.errored?
-  end
+    asserts(":fail and message are evaluated") do
+      topic.run(Riot::Situation.new) == [:fail, "Expected non-false but got nil instead"]
+    end
+  end # that is failing
 
-  context "that fails while executing a test" do
+  context "that is erroring" do
     setup do
-      fake_situation = Riot::Situation.new
-      Riot::Assertion.new("error", fake_situation) { fail("I'm a bum") }
+      @exception = exception = Exception.new("blah")
+      Riot::Assertion.new("baz") { raise exception }
     end
 
-    should("be considered a failing assertion") { topic.failed? }
-    should("use failed message in description") { topic.result.message }.matches(/I'm a bum/)
-  end # that fails while executing test
-end # basic assertion
+    asserts("to_s") { topic.to_s == "baz" }
+
+    asserts(":error and exception are evaluated") do
+      topic.run(Riot::Situation.new) == [:error, @exception]
+    end
+  end # that is erroring
+end # An assertion block