riot 0.10.1 → 0.10.2

data/README.markdown

@@ -2,12 +2,35 @@
 
 An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.
 
+## Contents
+
+- [Installation](#installation)
+- [Note on speed](#speed)
+- [Examples](#examples)
+  - [Boolean](#examples-boolean)
+  - [Shortcuts](#examples-shortcut)
+  - [Equality](#examples-equality)
+  - [Matches](#examples-matches)
+  - [Raises](#examples-raises)
+  - [Kind Of](#examples-kind-of)
+  - [Empty](#examples-empty)
+  - [Respond To](#examples-respond-to)
+  - [Assigns](#examples-assigns)
+  - [Nested contexts](#examples-nested)
+- [OMG! Why did you write this](#omg)
+- [Running tests](#running)
+- [With Sinatra](#sinatra)
+- [With Rails](#rails)
+- [Extending Riot with Macros](#extending)
+  - [Assertion macros](#assertion-macros)
+
 When you're done reading here, take a gander at:
 
 * [Riot Rails](http://github.com/thumblemonks/riot_rails): Rails support for Riot testing. A definite work in progress (help welcomed). See [evoke-app](http://github.com/thumblemonks/evoke-app) for live examples.
 * [Riot.js](http://github.com/alexyoung/riotjs): for you JavaScript people, a version of Riot just for you. Both implementations will be informing the other. Lots of stuff to learn.
 
-#### Installation
+<a name="installation"></a>
+#### Installation 
 
 The Riot gem is hosted on gemcutter.org. It used to be hosted on GitHub, but they turned off gem support while moving to Rackspace, so we moved to gemcutter. If you have not already done so, add gemcutter.org to your list of gem sources like so:
 
@@ -17,6 +40,7 @@ Then, simply install the Riot gem like so:
 
     sudo gem install riot
 
+<a name="speed"></a>
 #### Note on speed
 
 I have done a really simple benchmarking (10,000 runs), but right now, Riot is running about **2 times** faster than Test::unit and thusly Shoulda:
@@ -51,8 +75,10 @@ All tests ran with `ruby 1.8.7 (2009-06-12 patchlevel 174) [i686-darwin9.8.0], M
 
 Riot also works very well with Ruby 1.9. The same benchmarks from above run through ruby-1.9 show Riot to be twice as fast as it is already. See our [benchmarks gist](http://gist.github.com/240353) for more details.
 
+<a name="examples"></a>
 ## Examples
 
+<a name="examples-boolean"></a>
 #### Example: Basic booleans
 
 **NOTE:** For no specific reason, I'm going to use an ActiveRecord model in the following examples.
@@ -83,6 +109,7 @@ The other important thing to note in the examples above is the use of the `topic
 
 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.
 
+<a name="examples-shortcut"></a>
 #### Example: Shortcut - Asserting the topic itself
 
 Over the course of developing Riot it became somewhat obvious to some of us that we were creating assertions that returned the `topic` just so we could assert things about the topic itself. For instance, were doing this:
@@ -110,6 +137,7 @@ together as follows:
       asserts("is a trazillionaire").kind_of(Trazillionaire)
     end
 
+<a name="examples-equality"></a>
 #### 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.
@@ -154,6 +182,7 @@ Which, to me, seems like a redundancy. The test already says it's nil! Maybe Sho
 
 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.
 
+<a name="examples-matches"></a>
 #### Example: Matches
 
 If you need to assert that a test result matches a regular expression, use the `matches` modifier like so:
@@ -165,6 +194,7 @@ If you need to assert that a test result matches a regular expression, use the `
       asserts("random phone number") { topic.random_phone_number }.matches(/^\d{3}-\d{3}-\d{4}$/)
     end
 
+<a name="examples-raises"></a>
 #### Example: Raises
 
 Sometimes, your test raises an exception that you actually expected.
@@ -181,6 +211,7 @@ And if you wanted to check that the exception and message match what you expect:
       asserts("invalid data") { topic.save! }.raises(ActiveRecord::RecordInvalid, /has errors/)
     end
 
+<a name="examples-kind-of"></a>
 #### Example: Kind Of
 
 When you want to test that an expression returns an object of an expected type:
@@ -190,6 +221,23 @@ When you want to test that an expression returns an object of an expected type:
       asserts("its balance") { topic.balance }.kind_of(Currency)
     end
 
+<a name="examples-empty"></a>
+#### Example: Empty
+
+When you want to assert a test result is empty (length == 0):
+
+     context "a new user" do
+       setup { User.new }
+       should("have no first name") { topic.first_name }.empty
+         
+       #let's imagine phone numbers is an array
+       should("have no phone numbers") { topic.phone_numbers }.empty
+         
+       #let's imagine attributes is a hash
+       should("have no attributes") { topic.attributes }.empty
+     end
+
+<a name="examples-respond-to"></a>
 #### Example: Respond To
 
 When you want to test that an object responds to a specific method:
@@ -199,6 +247,7 @@ When you want to test that an object responds to a specific method:
       asserts("email is defined") { topic }.respond_to(:email)
     end
 
+<a name="examples-assigns"></a>
 #### Example: Assigns
 
 Sometimes you want to check and see if an instance variable is defined.
@@ -221,6 +270,7 @@ While other times you also want to make sure the value of the instance variable
       asserts("has a first name") { topic }.assigns(:first_name, "Joe") # This will fail
     end
 
+<a name="examples-nested"></a>
 #### 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).
@@ -255,6 +305,7 @@ See the TODO section for everything that's missing.
 
 Also, see [the wiki](http://wiki.github.com/thumblemonks/riot) for more examples and documentation.
 
+<a name="omg"></a>
 ## You say, "OMG! Why did you write this?"
 
 ### Some background, I guess
@@ -298,6 +349,7 @@ I like this approach because I only want to test one thing, but that one thing m
 
 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 :).
 
+<a name="running"></a>
 ## Running tests
 
 Create or modify your existing Rakefile to define a test task like so:
@@ -314,6 +366,7 @@ Create or modify your existing Rakefile to define a test task like so:
 
 Basically, it's like setting up any other test runner. 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.
 
+<a name="sinatra"></a>
 ### 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:
@@ -339,10 +392,12 @@ And then define a context (or many) for testing your Sinatra app. For instance:
 
 Make sure to check out the Riot + Sinatra testing macros in Chicago.
 
+<a name="rails"></a>
 ### 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.
 
+<a name="extending"></a>
 ## 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:
@@ -371,6 +426,7 @@ And then in your actual test, you might do the following:
 
 **COMING SOON:** Riot will look into test/riot\_macros, but not today.
 
+<a name="assertion-macros"></a>
 #### Assertion macros
 
 If you want to add special macros to an Assertion, this is as easy as adding them to a Context. Assertion macros, however, have a special mechanism for adding themselves onto an assertion. Thus, you will want to open the Riot::Assertion class and then define your assertion macro.

data/TODO.markdown

@@ -0,0 +1,11 @@
+- Documentation
+  - Introduction
+    - overall example
+  - Assertion 
+    - scope
+    - extensions (e.g. rack/test)
+- Assertion Macros
+  - include/any/contains (array,hash, maybe string?)
+    - perhaps able to take an enumerable and compare...
+      { [1,2,3] }.contains(2,3) 
+      { "the song that never ends" }.contains("never","ends")

data/VERSION

@@ -1 +1 @@
-0.10.1
+0.10.2

data/lib/riot.rb

@@ -25,6 +25,8 @@ module Riot
     Riot.silently? ? Riot::SilentReporter : (@reporter_class || Riot::StoryReporter)
   end
   def self.reporter=(reporter_class) @reporter_class = reporter_class; end
+  # TODO: make this a flag that DotMatrix and Story respect and cause them to print errors/failures
+  def self.verbose; Riot.reporter = Riot::VerboseReporter; end
   def self.dots; Riot.reporter = Riot::DotMatrixReporter; end
 
   at_exit { run unless Riot.silently? }

data/lib/riot/assertion_macros.rb

@@ -1,10 +1,12 @@
 module Riot
   class Assertion
-    # Asserts that the result of the test equals the expected value
+    # 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" }
     assertion(:equals) do |actual, expected|
-      expected == actual ? pass : fail("expected #{actual.inspect} to equal #{expected.inspect}")
+      expected === actual ? pass : fail("expected #{expected.inspect}, not #{actual.inspect}")
     end
 
     # Asserts that the result of the test is nil
@@ -28,7 +30,7 @@ module Riot
     #   asserts("test") { "foo" }.kind_of(String)
     #   should("test") { "foo" }.kind_of(String)
     assertion(:kind_of) do |actual, expected|
-      actual.kind_of?(expected) ? pass : fail("expected kind of #{expected}, not #{actual.inspect}")
+      actual.kind_of?(expected) ? pass : fail("expected kind of #{expected}, not #{actual.class.inspect}")
     end
 
     # Asserts that an instance variable is defined for the result of the assertion. Value of instance
@@ -97,5 +99,21 @@ module Riot
       end
     end
 
+    # Asserts the result is empty
+    #   asserts("a string") { "" }.empty
+    #   asserts("an array") { [] }.empty
+    #   asserts("a hash") { Hash.new }.empty
+    assertion(:empty) do |actual|
+      actual.length == 0 ? pass : fail("expected #{actual.inspect} to be empty")
+    end
+
+    # 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)
+    assertion(:includes) do |actual, expected|
+      actual.include?(expected) ? pass : fail("expected #{actual.inspect} to include #{expected.inspect}")
+    end
+
   end # Assertion
 end # Riot

data/lib/riot/reporter.rb

@@ -50,10 +50,19 @@ module Riot
     def error(description, e) say "  ! " + "#{description}: #{e.message}".red; end
   end
 
+  class VerboseReporter < StoryReporter
+    def error(description, e)
+      super(description, e)
+      say "    #{e.class.name} occured".red
+      e.backtrace.each { |line| say "      at #{line}".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
+    # TODO: Print the failures and errors at the end. Sorry :|
   end
 
   class SilentReporter < Reporter

data/lib/riot/runnable.rb

@@ -32,8 +32,9 @@ module Riot
     end
 
     def self.assertion(name, expect_exception=false, &assertion_block)
-      define_method(name) do |*expectings|
+      define_method(name) do |*expectings, &expectation_block|
         (class << self; self; end).send(:define_method, :run) do |situation|
+          expectings << situation.evaluate(&expectation_block) if expectation_block
           process_macro(situation, expect_exception) { |actual| assertion_block.call(actual, *expectings) }
         end # redefine run method when the assertion is called
         self

data/riot.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot}
-  s.version = "0.10.1"
+  s.version = "0.10.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2009-11-23}
+  s.date = %q{2009-11-27}
   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 = [
@@ -30,8 +30,10 @@ Gem::Specification.new do |s|
      "lib/riot/situation.rb",
      "riot.gemspec",
      "test/assertion_macros/assigns_test.rb",
+     "test/assertion_macros/empty_test.rb",
      "test/assertion_macros/equals_test.rb",
      "test/assertion_macros/exists_test.rb",
+     "test/assertion_macros/includes_test.rb",
      "test/assertion_macros/kind_of_test.rb",
      "test/assertion_macros/matching_test.rb",
      "test/assertion_macros/nil_test.rb",
@@ -55,8 +57,10 @@ Gem::Specification.new do |s|
   s.summary = %q{An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.}
   s.test_files = [
     "test/assertion_macros/assigns_test.rb",
+     "test/assertion_macros/empty_test.rb",
      "test/assertion_macros/equals_test.rb",
      "test/assertion_macros/exists_test.rb",
+     "test/assertion_macros/includes_test.rb",
      "test/assertion_macros/kind_of_test.rb",
      "test/assertion_macros/matching_test.rb",
      "test/assertion_macros/nil_test.rb",

data/test/assertion_macros/empty_test.rb

@@ -0,0 +1,24 @@
+require 'teststrap'
+
+context "An empty assertion macro" do
+  setup do
+    def assert_empty(string)
+      Riot::Assertion.new("test") { string }.empty
+    end
+  end
+
+  assertion_test_passes("when string is empty") { assert_empty("") }
+  assertion_test_fails("when string has content", "expected \" \" to be empty") do
+    assert_empty(" ")
+  end
+
+  assertion_test_passes("when an array is empty") { assert_empty([]) }
+  assertion_test_fails("when an array has items", "expected [1] to be empty") do
+    assert_empty([1])
+  end
+
+  assertion_test_passes("when a hash is empty") { assert_empty({}) }
+  assertion_test_fails("when a hash has items", "expected {:name=>\"washington\"} to be empty") do
+    assert_empty({:name => 'washington'})
+  end
+end

data/test/assertion_macros/equals_test.rb

@@ -1,5 +1,8 @@
 require 'teststrap'
 
+# Using == to verify the tes because this is the test for :equals itself. Look at assertion_test_passes
+# and assertion_test_fails for testing other macros.
+
 context "An equals assertion macro" do
   setup do
     Riot::Assertion.new("blue") { "foo" }
@@ -13,6 +16,34 @@ context "An equals assertion macro" do
     setup { topic.equals("bar").run(Riot::Situation.new) }
 
     asserts(":fail") { topic.first == :fail }
-    asserts("message") { topic.last == %Q{expected "foo" to equal "bar"} }
+    asserts("message") { topic.last == %Q{expected "bar", not "foo"} }
   end # that is failing
+
+  context "with numeric topic" do
+    setup do
+      Riot::Assertion.new("blue") { 31415 }
+    end
+
+    asserts(":pass when in expected range") do
+      topic.equals(30000..32000).run(Riot::Situation.new) == [:pass]
+    end
+
+    context "when not in expected range" do
+      setup { topic.equals(32000..33000).run(Riot::Situation.new) }
+
+      asserts(":fail") { topic.first == :fail }
+      asserts("message") { topic.last == %Q{expected 32000..33000, not 31415} }
+    end
+  end # with numeric topic
+
+  context "with block as the expectation" do
+    asserts(":pass when block expectation met") do
+      topic.equals { "foo" }.run(Riot::Situation.new)
+    end.equals([:pass])
+
+    asserts(":fail with message when block expectation not met") do
+      topic.equals { "bar" }.run(Riot::Situation.new)
+    end.equals([:fail, %Q{expected "bar", not "foo"}])
+  end # with block as the expectation
+
 end # An equals assertion macro

data/test/assertion_macros/includes_test.rb

@@ -0,0 +1,13 @@
+require 'teststrap'
+
+context "An includes assertion macro" do
+  setup do
+    Riot::Assertion.new("an array") { [1, 6, 42, 7] }
+  end
+
+  assertion_test_passes("when array includes 42") { topic.includes(42) }
+
+  assertion_test_fails("when 99 not included in array", "expected [1, 6, 42, 7] to include 99") do
+    topic.includes(99)
+  end
+end # An includes assertion macro

data/test/assertion_macros/kind_of_test.rb

@@ -9,9 +9,9 @@ context "A kind_of assertion macro" do
 
   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}])
+  end.equals([:fail, %Q{expected kind of String, not Fixnum}])
   
   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.equals([:fail, %Q{expected kind of String, not NilClass}])
 end # A kind_of assertion macro

data/test/assertion_test.rb

@@ -43,4 +43,16 @@ context "An assertion" do
       result = topic.run(@situation)
     end.equals([:pass])
   end
+
+  context "with block expectation" do
+    setup do
+      @situation = Riot::Situation.new
+      @situation.topic = "hello"
+      Riot::Assertion.new("test")
+    end
+    should("use block returning topic as default") do
+      topic.equals { "hello" }
+      result = topic.run(@situation)
+    end.equals([:pass])
+  end
 end # An assertion block

data/test/report_test.rb

@@ -42,3 +42,35 @@ context "A reporter" do
     topic.report("break it down", [:error, "error time"])
   end.equals("errored(break it down, error time)")
 end # A reporter
+
+require 'stringio'
+context "StoryReporter" do
+  setup {
+    @out = StringIO.new
+    Riot::StoryReporter.new(@out)
+  }
+
+  context 'reporting on an empty context' do
+    setup do
+      context = Riot::Context.new('empty context') do
+        context "a nested empty context" do
+        end
+      end
+      context.run(topic)
+    end
+    should("not output context name") { @out.string }.empty
+  end
+  
+  context "reporting on a non-empty context" do
+    setup do
+      context = Riot::Context.new('supercontext') do
+        asserts("truth") { true }
+      end
+      context.run(topic)
+    end
+    
+    should('output context name') { @out.string }.matches(/supercontext/)
+    should('output name of passed assertion') { @out.string }.matches(/truth/)
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: riot
 version: !ruby/object:Gem::Version 
-  version: 0.10.1
+  version: 0.10.2
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-23 00:00:00 -06:00
+date: 2009-11-27 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,8 +45,10 @@ files:
 - lib/riot/situation.rb
 - riot.gemspec
 - test/assertion_macros/assigns_test.rb
+- test/assertion_macros/empty_test.rb
 - test/assertion_macros/equals_test.rb
 - test/assertion_macros/exists_test.rb
+- test/assertion_macros/includes_test.rb
 - test/assertion_macros/kind_of_test.rb
 - test/assertion_macros/matching_test.rb
 - test/assertion_macros/nil_test.rb
@@ -92,8 +94,10 @@ specification_version: 3
 summary: An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.
 test_files: 
 - test/assertion_macros/assigns_test.rb
+- test/assertion_macros/empty_test.rb
 - test/assertion_macros/equals_test.rb
 - test/assertion_macros/exists_test.rb
+- test/assertion_macros/includes_test.rb
 - test/assertion_macros/kind_of_test.rb
 - test/assertion_macros/matching_test.rb
 - test/assertion_macros/nil_test.rb