riot 0.9.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 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

@@ -0,0 +1,315 @@
+# Riot
+
+An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.
+
+### Note on speed
+
+I have done a really simple benchmarking, but right now, Riot is running about **10-times** faster than Test::unit and thusly Shoulda:
+
+    $ ruby test/benchmark/simple_context_and_assertions.rb
+
+    Rehearsal ----------------------------------------------
+    Riot         0.140000   0.010000   0.150000 (  0.156170)
+    Test::Unit   1.460000   0.000000   1.460000 (  1.495990)
+    Shoulda      1.490000   0.010000   1.500000 (  1.514745)
+    ------------------------------------- total: 3.110000sec
+
+                     user     system      total        real
+    Riot         0.130000   0.000000   0.130000 (  0.139770)
+    Test::Unit   1.600000   0.010000   1.610000 (  1.627493)
+    Shoulda      1.610000   0.010000   1.620000 (  1.655394)
+
+    Loaded suite test/benchmark/simple_context_and_assertions
+
+"Is it valid?", you ask. *I* think it is. I ain't no cheater, but I might be delusional.
+
+#### Example: Basic booleans
+
+**NOTE:** For no specific reason, I'm going to use an ActiveRecord model in the following examples.
+
+At it's very basic, Riot simply tries to assert that an expression is true or false. Riot does this through its `asserts` or `should` tests. An `asserts` test will pass if the result of running the test is neither `nil` or `false`. A `should` test does the exact same thing - they are in fact aliases. The only difference is in the way you write the assertion. 
+
+For instance, given a test file named `foo_test.rb`, you might have the following code in it:
+
+    require 'riot'
+    
+    context "a new user" do
+      setup { @user = User.new }
+      asserts("that it is not yet created") { @user.new_record? }
+    end
+
+Notice that you do not define a class anywhere. That would be the entire contents of that test file. If you wanted to use a `should` instead, you could say this:
+
+    require 'riot'
+
+    context "a new user" do
+      setup { @user = User.new }
+      should("not be created") { @user.new_record? }
+    end
+
+Sometimes it's more clear to say "this **should** be that" and sometimes it's better to say "**asserts** this is that". I promise you that Riot will get no more redundant than this, but also that besides speed, Riot will aim at being expressive with a minimal amount of syntax.
+
+I'm going to use `asserts` for the rest of this introduction, but you should know that you can replace any instance of `asserts` with `should` and nothing would change.
+
+#### Example: Equality
+
+One of the most common assertions you will (or do already) utilize is that of equality; is this equal to that? Riot supports this in a slightly different manner than most other frameworks. With Riot, you add the expectation to the assertion itself.
+
+For example:
+
+    context "a new user" do
+      setup { @user = User.new(:email => 'foo@bar.com') }
+      asserts("email address") { @user.email }.equals('foo@bar.com')
+    end
+
+Here, you should begin to notice that tests themselves return the actual value. You do not write assertions into the test. Assertions are "aspected" onto the test. If the test above did not return 'foo@bar.com' for `@user.email`, the assertion would have failed.
+
+The `equals` modifier works with any type of value, including nil's. However, if you wanted to test for nil explicitly, you could simply do this:
+
+    context "a new user" do
+      setup { @user = User.new }
+      asserts("email address") { @user.email }.nil
+    end
+
+Notice the `nil` modifier added to asserts. Also notice how the test almost reads as "a new user asserts email address *is* nil". With Test::Unit, you would have probably written:
+
+    class UserTest < Test::Unit::TestCase
+      def setup
+        @user = User.new
+      end
+      
+      def test_email_address_is_nil
+        assert_nil @user.email
+      end
+    end
+
+Which, to me, seems like a redundancy. The test already says it's nil! Maybe Shoulda woulda helped:
+
+    class UserTest < Test::Unit::TestCase
+      def setup
+        @user = User.new
+      end
+  
+      should "have nil email" { assert_nil @user.email }
+    end
+
+In my opinion, the same redundancy exists. Sure, I could write a macro like `should_be_nil {@user.email}`, but the redundancy exists in the framework itself.
+
+#### Example: Matches
+
+If you need to assert that a test result matches a regular expression, use the `matches` modifier like so:
+
+    context "a new user" do
+      setup { @user = User.new }
+
+      # I'm a contrived example
+      asserts("random phone number") { @user.random_phone_number }.matches(/^\d{3}-\d{3}-\d{4}$/)
+    end
+
+#### Example: Raises
+
+Sometimes, your test raises an exception that you actually expected.
+
+    context "a new user" do
+      setup { @user = User.new }
+      asserts("invalid data") { @user.save! }.raises(ActiveRecord::RecordInvalid)
+    end
+
+#### Example: Kind Of
+
+When you want to test that an expression returns an object of an expected type:
+
+    context "a new user" do
+      setup { @user = User.new }
+      asserts("its balance") { @user.balance }.kind_of(Currency)
+    end
+
+#### Example: Nested contexts
+
+Oh yeah, Riot does those, too. The `setup` from each parent is "loaded" into the context and then the context is executed as normal. Test naming is a composite of the parent contexts' names. Here, we'll do a little Sinatra testing (see below for instructions on how to make it Riot work seamlessly with Sinatra tests).
+
+    context "My App:" do
+      setup { @app = MyApp }
+
+      context "get /" do
+        setup { get '/' }
+        # ...
+        # assertions
+
+        context "renders a body" do
+          setup { @body = last_response.body }
+          # ...
+          # assertions 
+        end
+      end
+      
+      context "get /books/1" do
+        setup { get '/books/1' }
+        # ...
+        # assertions
+      end
+    end
+
+#### More examples/documentation
+
+There are many more basic assertion modifiers to come. See below for writing Riot extensions if you want to help out.
+
+See the TODO section for everything that's missing.
+
+Also, see [the wiki](http://wiki.github.com/thumblemonks/riot) for more examples and documentation.
+
+## You say, "OMG! Why did you write this?"
+
+### Some background, I guess
+
+You start a new project. You get all excited. You're adding tests. You're adding factories. You're fixturating your setups. You're adding more tests. Your tests start slowing down, but you need to keep pushing because your backlog has a lot of new, nifty features in it. You've got 3000+ lines of test code, 2000+ assertions. Your tests are annoyingly slow. Your tests have become a burden.
+
+I hate this and it happens a lot, even when I'm conscience that it's happening. Even when I'm not hitting the database and I'm mocking the crap out my code.
+
+I really, really hate slow test suites.
+
+#### Did ... you look at Shoulda
+
+I should say that I love Shoulda in theory and in practice. It changed the way I coded. I added macros all over the place. I built macros into the gems I wrote for the gem itself. But, alas, Shoulda is slow. Shoulda is based on Test::Unit. Shoulda reruns setups for every should. Shoulda could make my life even easier with even more expressiveness.
+
+#### Did ... you look at RSpec
+
+:| yes, no, I don't care. It's slow, too. Anyways, I was at [ObjectMentor](http://objectmentor.com) many, many moons ago when Dave Astels (accompanied by David Chelimsky) were explaining this brand new approach to testing called BDD. Mr. Astels explained to us that we if we already understood TDD, then BDD wouldn't help a bunch. Why argue with him?
+
+### How Riot is the same
+
+1. It defines a context
+1. It prints .'s, F's, and E's when tests pass, fail, or error
+1. It tells you how long it took to run just the tests
+1. Contexts can be nested and setups inherited
+
+### How Riot is different
+
+Riot differs primarily in that it does not rerun setup for each test in a context. I know this is going to shock and awe a lot of folks. However, over the past several years of my doing TDD in some capacity or another, there are certain habits I have tried to pick up on any many others I have tried to drop.
+
+For instance, I believe that no assertion should mangle the context of the test data it is running in. Following this allows me to require setup be run only once for a collection of related assertions. Even in a nested context where setups are inherited, the setup's are called only once per the specific context.
+
+Following all of this allows me to have very fast tests (so far).
+
+...
+
+Riot is also different in that assertions are not added to the test block. Each test block is it's own assertion (and assertion block). Whatever the result is of processing an assertion block will be used to determine if an assertion passed or failed. Each assertion block can have a specific validator tied to it for asserting any number of things, like: the result of the test **equals** some expected value, the result of the test **matches** some expected expression, or the result of the test **raises** some exception.
+
+I like this approach because I only want to test one thing, but that one thing may require some work on my behalf to get the value. Riot does not let me cheat in this regard. There is no way for me to add more than one assertion to an assertion block.
+
+...
+
+I imagine this approach will persuade many of you to avoid Riot altogether. I don't blame you. A few years ago I would have avoided it, too. As of this writing though, I have ported Chicago and Slvu (which were previously written in Test::Unit + Shoulda) to Riot, cut the number of lines of code in almost half, definitely more than halved the amount of time the tests took to run, and did so in less than half a day (I was building Riot while porting them :).
+
+## Running tests
+
+Create or modify your existing Rakefile to define a test task like so:
+
+    desc 'Default task: run all tests'
+    task :default => [:test]
+    
+    desc "Run all tests"
+    task :test do
+      require 'riot'
+      $:.concat ['./lib', './test']
+      Dir.glob("./test/*_test.rb").each { |test| require test }
+      Riot.report
+    end
+
+Then, from the command line, you only need to run `rake` or `rake test`. Please make sure to remove all references to any other testing frameworks before running tests. For instance, do not require `test/unit`, `shoulda`, `minitest`, or anything else like it.
+
+### With Sinatra
+
+Riot definitely works with the latest Sinatra. I personally use it to run tests for [Chicago](http://github.com/thumblemonks/chicago) and [Slvu](http://github.com/jaknowlden/slvu). Setup is pretty easy and very much like getting your tests to run with Test::Unit. In a test helper file that gets loaded into all of your tests (that need it), enter the following:
+
+    require 'riot'
+    class Riot::Context
+      include Rack::Test::Methods
+      def app; @app; end
+    end
+
+And then define a context (or many) for testing your Sinatra app. For instance:
+
+    require 'test_helper'
+    
+    context 'Some App' do
+      setup { @app = SomeApp }
+      
+      context "/index" do
+        setup { get '/' }
+        # ...
+      end
+    end
+
+Make sure to check out the Riot + Sinatra testing macros in Chicago.
+
+### With Rails
+    
+It's doubtful that Riot works with Rails very easily as Riot completely replaces Test::Unit. I haven't tried it yet, but intend to with my next new Rails project. Porting would probably take some time unless you only have a few test cases. Porting is made somewhat easier if you're already using Shoulda; you can replace the `TestCase` definition with a `context` of the same name as the class under test I suppose.
+
+## Extending Riot with Macros
+
+To extend Riot, similar to how you would with Shoulda, you simply need to include your methods into the `Riot::Context` class. For example, let's say you wanted to add a helpful macro for asserting the response status of some HTTP result in Sinatra. You could do this easily by defining your macro like so:
+
+    module Custom
+      module Macros
+        def asserts_response_status(expected)
+          asserts("response status is #{expected}") do
+            last_response.status
+          end.equals(expected)
+        end
+      end # Macros
+    end # Custom
+    Riot::Context.instance_eval { include Custom::Macros }
+
+And then in your actual test, you might do the following:
+
+    context 'Some App' do
+      setup { @app = SomeApp }
+  
+      context "/index" do
+        setup { get '/' }
+        asserts_response_status 200
+      end
+    end
+
+**COMING SOON:** Riot will look into test/riot\_macros, but not today.
+
+#### Assertion macros
+
+If you want to add special macros to an Assertion, this is as easy as adding them to a Context. Similar to Context macros, Assertion macros are included into the Assertion class.
+
+For instance, let's say you wanted to add a macro for verifying that the result of an assertion is the same kind\_of object as you would expect. You would define the macro like so:
+
+    module Custom
+      module AssertionMacros
+        def kind_of(expected_class)
+          actual.kind_of?(expected) || failure("expected kind of #{expected}, not #{actual.inspect}")
+        end
+      end # AssertionMacros
+    end # Custom
+    Riot::Assertion.instance_eval { include Custom::AssertionMacros }
+
+And in your context, you would use it like so:
+
+    context "example" do
+      asserts("a hash is defined") { {:foo => 'bar'} }.kind_of(Hash)
+    end
+
+Notice in the new macro we defined the use of the magical **actual** variable. `actual` is evaluated when the assertion is defined and made available to any Assertion macro. If you think you might want to chain assertions checks together, know that only the last failure will get recorded.
+
+## TODO
+
+TONS OF STUFF
+
+1. Documentation about the `topic` method
+1. Better documentation for everything
+1. Refactor reporting; some abstracting is needed for recording a result (for instance)
+1. Need to know where in backtrace a test failed (line number, etc.); i.e. backtrace filtering for clarity
+1. More assertion macros: throws, etc.
+1. Aliases for context "with, without, when, ..."; add those words to test description
+1. Optimization and simplification (ex. flog is complaining print\_result\_stack)
+1. Better error messages?
+1. Perhaps: Multiple setup blocks in one context
+1. Perhaps: association macro chaining
+1. Perhaps: Uhhhhh ... a teardown method (only maybe. not sold :)

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'rake'
+
+task :default => [:test]
+
+desc "Run tests"
+task :test do
+  $:.concat ['./test', './lib']
+  Dir.glob("./test/*_test.rb").each { |test| require test }
+  Riot.report
+end
+
+desc "Run Flog against library (except tests)"
+task :flog do
+  puts %x[find ./lib -name *.rb | xargs flog]
+end
+
+desc "Run Flay against library (except tests)"
+task :flay do
+  puts %x[find ./lib -name *.rb | xargs flay]
+end
+
+desc "Run Roodi against library (except tests)"
+task :roodi do
+  puts %x[find ./lib -name *.rb | xargs roodi]
+end

data/lib/riot.rb

@@ -0,0 +1,68 @@
+require 'riot/report'
+require 'riot/context'
+require 'riot/assertion'
+require 'riot/macros'
+
+module Riot
+  #
+  # Initializing logic
+  def self.contexts
+    @contexts ||= []
+  end
+
+  def self.context(description, reporter = nil, parent = nil, &block)
+    reporter ||= self.reporter
+    context = Context.new(description, reporter, parent)
+    reporter.time { context.instance_eval(&block) }
+    context.report # Results get buffered this way, not necessarily the best
+    (contexts << context).last
+  end
+
+  def self.dequeue_context(context)
+    contexts.delete(context)
+  end
+
+  def self.report
+    reporter.results
+    at_exit { exit false unless reporter.passed? }
+  end
+
+  #
+  # Reporter
+
+  def self.reporter; @reporter ||= TextReport.new; end
+  def self.reporter=(report); @reporter = report; end
+  def self.silently!; @silently = true; end
+  def self.silently?; @silently || false; end
+
+  #
+  # Exception
+
+  class Failure < Exception
+    attr_reader :assertion, :context
+    def initialize(message, assertion)
+      super(message)
+      @assertion = assertion
+    end
+
+    def contextualize(ctx)
+      @context = ctx
+      self
+    end
+    
+    def print_stacktrace?; false; end
+  end
+  class Error < Failure
+    def initialize(message, assertion, error)
+      super(message, assertion)
+      set_backtrace(error.backtrace)
+    end
+    def print_stacktrace?; true; end
+  end
+end # Riot
+
+module Kernel
+  def context(*args, &block)
+    Riot.context(*args, &block)
+  end
+end # Kernel

data/lib/riot/assertion.rb

@@ -0,0 +1,35 @@
+module Riot
+
+  class Assertion
+    attr_reader :raised, :to_s, :description
+    def initialize(description, situation, &block)
+      @description = @to_s = description
+      actualize(situation, &block)
+    end
+
+    def actual
+      @default_failure = @failure = nil if @default_failure
+      @actual
+    end
+
+    def fail(message)
+      @failure = Failure.new(message, self) unless errored?
+    end
+
+    def failed?; !@failure.nil?; end
+    def errored?; !@raised.nil?; end
+    def passed?; !(failed? || errored?); end
+    def result; @failure || error; end
+  private
+    def actualize(situation, &block)
+      @actual = situation.instance_eval(&block)
+      @default_failure = fail("expected true, not #{@actual.inspect}") unless @actual
+    rescue Exception => e
+      @raised = e
+    end
+
+    def error
+      Error.new("errored with #{@raised}", self, @raised) if errored?
+    end
+  end # Assertion
+end # Riot

data/lib/riot/context.rb

@@ -0,0 +1,59 @@
+module Riot
+  class Situation; end
+
+  class Context
+    # The protein
+    attr_reader :description, :assertions, :situation
+    def initialize(description, reporter, parent=nil)
+      @description, @reporter = description, reporter
+      @assertions = []
+      @parent = parent
+      @situation = Situation.new
+      bootstrap(@situation)
+    end
+
+    def bootstrap(a_situation)
+      @parent.bootstrap(a_situation) if @parent # Walk it out
+      induce_local_setup(a_situation)
+    end
+
+    # something smelly between setup() and bootstrap()
+    def setup(&block)
+      @setup = block
+      make_situation_topical(induce_local_setup(situation))
+    end
+
+    # DSLee stuff
+    def context(description, &block) Riot.context(description, @reporter, self, &block); end
+    def asserts(description, &block) new_assertion("asserts #{description}", &block); end
+    def should(description, &block) new_assertion("should #{description}", &block); end
+
+    # In conclusion
+    def report
+       # we should just be passing assertions to the reporter and building better descriptions earlier
+      assertions.each do |assertion|
+        if assertion.passed?
+          @reporter.passed
+        else
+          result = assertion.result.contextualize(self)
+          @reporter.send( (assertion.errored? ? :errored : :failed), result)
+        end
+      end
+    end
+
+    def to_s; @to_s ||= [@parent.to_s, @description].join(' ').strip; end
+  private
+    def new_assertion(description, &block)
+      (assertions << Assertion.new(description, @situation, &block)).last
+    end
+
+    def induce_local_setup(a_situation)
+      a_situation.instance_eval(&@setup) if @setup
+    end
+
+    def make_situation_topical(topic)
+      situation.instance_variable_set(:@topic, topic)
+      situation.instance_eval { def topic; @topic; end }
+    end
+  end # Context
+end # Riot

data/lib/riot/macros.rb

@@ -0,0 +1,43 @@
+module Riot
+  module AssertionMacros
+    # Asserts that the result of the test equals the expected value
+    #   asserts("test") { "foo" }.equals("foo")
+    #   should("test") { "foo" }.equals("foo")
+    def equals(expected)
+      expected == actual || fail("expected #{expected.inspect}, not #{actual.inspect}")
+    end
+
+    # Asserts that the result of the test is nil
+    #   asserts("test") { nil }.nil
+    #   should("test") { nil }.nil
+    def nil
+      actual.nil? || fail("expected nil, not #{actual.inspect}")
+    end
+
+    # Asserts that the test raises the expected Exception
+    #   asserts("test") { raise My::Exception }.raises(My::Exception)
+    #   should("test") { raise My::Exception }.raises(My::Exception)
+    def raises(expected)
+      fail("should have raised #{expected}, but raised nothing") unless raised
+      fail("should have raised #{expected}, not #{error.class}") unless expected == raised.class
+      @raised = nil
+    end
+
+    # Asserts that the result of the test equals matches against the proved expression
+    #   asserts("test") { "12345" }.matches(/\d+/)
+    #   should("test") { "12345" }.matches(/\d+/)
+    def matches(expected)
+      expected = %r[#{Regexp.escape(expected)}] if expected.kind_of?(String)
+      actual =~ expected || fail("expected #{expected.inspect} to match #{actual.inspect}")
+    end
+
+    # 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)
+    def kind_of(expected)
+      actual.kind_of?(expected) || fail("expected kind of #{expected}, not #{actual.inspect}")
+    end
+  end # AssertionMacros
+end # Riot
+
+Riot::Assertion.instance_eval { include Riot::AssertionMacros }

data/lib/riot/report.rb

@@ -0,0 +1,79 @@
+require 'stringio'
+
+module Riot
+  class Report
+    attr_reader :bad_results, :passes, :failures, :errors, :time_taken
+    def initialize
+      @bad_results = []
+      @passes, @failures, @errors, @time_taken = 0, 0, 0, 0.0
+    end
+
+    def passed?; failures + errors == 0; end
+    def assertions; passes + failures + errors; end
+
+    def time(&block)
+      @start = Time.now
+      yield
+      @time_taken += (Time.now - @start).to_f
+    end
+
+    def passed; @passes += 1; end
+    
+    def failed(failure)
+      @failures += 1
+      @bad_results << failure
+    end
+
+    def errored(error)
+      @errors += 1
+      @bad_results << error
+    end
+  end # Report
+
+  class TextReport < Report
+    def initialize(writer=nil)
+      super()
+      @writer ||= (Riot.silently? ? StringIO.new : STDOUT)
+    end
+
+    def passed
+      super
+      @writer.print('.')
+    end
+
+    def failed(failure)
+      super
+      @writer.print('F')
+    end
+
+    def errored(error)
+      super
+      @writer.print('E')
+    end
+
+    def results
+      @writer.puts "\n\n"
+      print_result_stack
+      format = "%d assertions, %d failures, %d errors in %s seconds"
+      @writer.puts format % [assertions, failures, errors, ("%0.6f" % time_taken)]
+    end
+  private
+    def print_result_stack
+      bad_results.each_with_index do |result, idx|
+        @writer.puts render_result(idx + 1, result)
+        @writer.puts "  " + result.backtrace.join("\n  ") if result.print_stacktrace?
+        @writer.puts "\n\n"
+      end
+    end
+
+    def render_result(idx, result)
+      format_args = [idx, result.context.to_s, result.assertion.to_s, result.to_s]
+      "#%d - %s %s: %s" % format_args
+    end
+  end # TextReport
+
+  class NilReport < Report
+    def results; end
+    def time(&block); yield; end
+  end # NilReport
+end # Riot

data/riot.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.name     = "riot"
+  s.version  = "0.9.0"
+  s.date     = "2009-10-03"
+  s.summary  = "An extremely fast, expressive, and context-driven unit-testing framework"
+  s.email    = %w[gus@gusg.us]
+  s.homepage = "http://github.com/thumblemonks/protest"
+  s.description = "An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks"
+  s.authors  = %w[Justin\ Knowlden]
+
+  s.has_rdoc = false
+  s.rdoc_options = ["--main", "README.markdown"]
+  s.extra_rdoc_files = ["README.markdown"]
+
+  # run git ls-files to get an updated list
+  s.files = %w[
+    MIT-LICENSE
+    README.markdown
+    lib/riot.rb
+    lib/riot/assertion.rb
+    lib/riot/context.rb
+    lib/riot/macros.rb
+    lib/riot/report.rb
+    riot.gemspec
+  ]
+  
+  s.test_files = %w[
+    Rakefile
+    test/assertion_test.rb
+    test/benchmark/simple_context_and_assertions.rb
+    test/context_test.rb
+  ]
+end

data/test/assertion_test.rb

@@ -0,0 +1,66 @@
+require 'riot'
+
+fake_context = Object.new # It works ... so, why not?
+
+context "basic assertion:" do
+  should "have a description" do
+    Riot::Assertion.new("i will pass", fake_context).to_s
+  end.equals("i will pass")
+
+  asserts "pass? is true when assertion passed" do
+    Riot::Assertion.new("i will pass", fake_context) { true }.passed?
+  end
+
+  asserts "failure? is true when assertion does not pass" do
+    Riot::Assertion.new("i will pass", fake_context) { false }.failed?
+  end
+
+  asserts "error? is true when an unexpected Exception is raised" do
+    Riot::Assertion.new("error", fake_context) { raise Exception, "blah" }.errored?
+  end
+end
+
+context "equals assertion:" do
+  asserts "result equals expectation" do
+    Riot::Assertion.new("i will pass", fake_context) { "foo bar" }.equals("foo bar")
+  end
+
+  should "raise a Failure if results don't equal each other" do
+    Riot::Assertion.new("failure", fake_context) { "bar" }.equals("foo")
+  end.kind_of(Riot::Failure)
+end # equals assertion
+
+context "nil assertion:" do
+  asserts("result is nil") { Riot::Assertion.new("foo", fake_context) { nil }.nil }
+  should "raise a Failure if not nil" do
+    Riot::Assertion.new("foo", fake_context) { "a" }.nil
+  end.kind_of(Riot::Failure)
+end # nil assertion
+
+context "raises assertion:" do
+  should("raise an Exception") { raise Exception }.raises(Exception)
+end # raises assertion
+
+context "matching assertion:" do
+  asserts "result matches expression" do
+    Riot::Assertion.new("foo", fake_context) { "a" }.matches(%r[.])
+  end.equals(0)
+
+  should "raise a Failure if result does not match" do
+    Riot::Assertion.new("foo", fake_context) { "" }.matches(%r[.])
+  end.kind_of(Riot::Failure)
+
+  should "return the result of a matching operation" do
+    Riot::Assertion.new("foo", fake_context) { "a" }.matches("a")
+  end.equals(0)
+end # maching assertion
+
+context "kind_of assertion:" do
+  asserts "specific result is a kind of String" do
+    Riot::Assertion.new("foo", fake_context) { "a" }.kind_of(String)
+  end
+
+  should "raise a Failure if not a kind of String" do
+    Riot::Assertion.new("foo", fake_context) { 0 }.kind_of(String)
+  end.kind_of(Riot::Failure)
+end # kind_of assertion

data/test/benchmark/simple_context_and_assertions.rb

@@ -0,0 +1,76 @@
+$:.concat ['./lib']
+require 'benchmark'
+
+#
+# Model
+
+class Room
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+end
+
+#
+# Riot
+
+require 'riot'
+Riot.silently! # Do this before any contexts are defined
+
+context "a room" do
+  setup { @room = Room.new("bed") }
+
+  asserts("name") { @room.name }.equals("bed")
+end # a room
+ 
+#
+# Test::Unit
+
+require 'test/unit'
+Test::Unit.run = false
+
+require 'test/unit/ui/console/testrunner'
+
+class RoomTest < Test::Unit::TestCase
+  def setup
+    @room = Room.new("bed")
+  end
+
+  def test_room_should_be_named_bed
+    assert_equal "bed", @room.name
+  end
+end
+
+#
+# Shoulda
+
+require 'rubygems'
+require 'shoulda'
+
+class ShouldaRoomTest < Test::Unit::TestCase
+  def setup
+    @room = Room.new("bed")
+  end
+
+  should("be named 'bed'") { assert_equal "bed", @room.name }
+end
+
+#
+# Benchmarking
+
+n = 100 * 100
+
+Benchmark.bmbm do |x|
+  x.report("Riot") do
+    n.times { Riot.report }
+  end
+
+  x.report("Test::Unit") do
+    n.times { Test::Unit::UI::Console::TestRunner.new(RoomTest, Test::Unit::UI::SILENT) }
+  end
+
+  x.report("Shoulda") do
+    n.times { Test::Unit::UI::Console::TestRunner.new(ShouldaRoomTest, Test::Unit::UI::SILENT) }
+  end
+end
+

data/test/context_test.rb

@@ -0,0 +1,85 @@
+require 'riot'
+require 'stringio'
+
+context "any context" do
+  setup do
+    @reporter = Riot::NilReport.new
+    @context = Riot::Context.new("a", @reporter)
+  end
+
+  context "that doesn't have passing tests" do
+    setup do
+      @context.should("a") { true }
+      @context.should("b") { false }
+      @context.should("c") { raise Exception, "blah" }
+      @context.report
+    end
+
+    asserts("passed test count") { @reporter.passes }.equals(1)
+    asserts("failure count") { @reporter.failures }.equals(1)
+    asserts("unexpected errors count") { @reporter.errors }.equals(1)
+  end # that doesn't have passing tests
+
+  context "when running setup:" do
+    setup { @context.setup { "foo" } }
+
+    asserts "topic becomes available to test as result of setup" do
+      @context.should("bar") { topic }.actual
+    end.equals("foo")
+  end # when running setup
+end # any context
+
+# 
+# Test Context
+
+test_context = context("foo", Riot::NilReport.new) do
+  setup { @test_counter = 0 }
+  asserts("truthiness") { @test_counter += 1; true }
+  asserts("more truthiness") { @test_counter += 1; true }
+end # A CONTEXT THAT IS DEQUEUED
+
+context "test context" do
+  setup { Riot.dequeue_context(test_context) }
+  should("confirm context description") { test_context.to_s }.equals("foo")
+  should("confirm assertion count") { test_context.assertions.length }.equals(2)
+
+  should("call setup once per context") do
+    test_context.situation.instance_variable_get(:@test_counter) # yuck
+  end.equals(2)
+end # test context
+
+# 
+# Nested Context
+
+inner_nested_context, other_nested_context = nil, nil
+nested_context = context("foo", Riot::NilReport.new) do
+  setup do
+    @test_counter = 0
+    @foo = "bar"
+  end
+  asserts("truthiness") { @test_counter += 1; true }
+  
+  inner_nested_context = context("baz") do
+    setup { @test_counter += 10 }
+  end # A CONTEXT THAT IS DEQUEUED
+
+  other_nested_context = context("bum") {} # A CONTEXT THAT IS DEQUEUED
+end # A CONTEXT THAT IS DEQUEUED
+
+context "nested context" do
+  setup do
+    [nested_context, inner_nested_context, other_nested_context].each do |c|
+      Riot.dequeue_context(c)
+    end
+  end
+  
+  should("inherit parent context") do
+    inner_nested_context.situation.instance_variable_get(:@test_counter)
+  end.equals(10)
+
+  should("chain context names") { inner_nested_context.to_s }.equals("foo baz")
+
+  asserts "parent setup is called even if setup not defined for self" do
+    other_nested_context.situation.instance_variable_get(:@foo)
+  end.equals("bar")
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: riot
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- Justin Knowlden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-03 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks
+email: 
+- gus@gusg.us
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- MIT-LICENSE
+- README.markdown
+- lib/riot.rb
+- lib/riot/assertion.rb
+- lib/riot/context.rb
+- lib/riot/macros.rb
+- lib/riot/report.rb
+- riot.gemspec
+has_rdoc: true
+homepage: http://github.com/thumblemonks/protest
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An extremely fast, expressive, and context-driven unit-testing framework
+test_files: 
+- Rakefile
+- test/assertion_test.rb
+- test/benchmark/simple_context_and_assertions.rb
+- test/context_test.rb