riot 0.9.1 → 0.9.2

data/README.markdown

@@ -131,6 +131,28 @@ When you want to test that an expression returns an object of an expected type:
       asserts("its balance") { @user.balance }.kind_of(Currency)
     end
 
+#### Example: Assigns
+
+Sometimes you want to check and see if an instance variable is defined.
+
+    context "a new user" do
+      setup do
+        User.new(:email => "foo@bar.baz", :first_name => nil)
+      end
+      asserts("has an email address") { topic }.assigns(:email)
+      asserts("has a first name") { topic }.assigns(:first_name) # This will fail
+    end
+
+While other times you also want to make sure the value of the instance variable is what you expect it to be.
+
+    context "a new user" do
+      setup do
+        User.new(:email => "foo@bar.baz", :first_name => "John")
+      end
+      asserts("has an email address") { topic }.assigns(:email, "foo@bar.baz")
+      asserts("has a first name") { topic }.assigns(:first_name, "Joe") # This will fail
+    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).

data/lib/riot.rb

@@ -39,8 +39,8 @@ module Riot
   # Exception
 
   class Failure < Exception
-    attr_reader :assertion, :context
-    def initialize(message, assertion)
+    attr_accessor :assertion, :context
+    def initialize(message, assertion=nil)
       super(message)
       @assertion = assertion
     end

data/lib/riot/assertion.rb

@@ -1,9 +1,10 @@
 module Riot
 
   class Assertion
-    attr_reader :raised, :to_s, :description
+    attr_reader :raised, :to_s, :description, :situation
     def initialize(description, situation, &block)
       @description = @to_s = description
+      @situation = situation
       actualize(situation, &block)
     end
 
@@ -24,6 +25,9 @@ module Riot
     def actualize(situation, &block)
       @actual = situation.instance_eval(&block)
       @default_failure = fail("expected true, not #{@actual.inspect}") unless @actual == true
+    rescue Failure => e
+      @failure = e
+      @failure.assertion = self
     rescue Exception => e
       @raised = e
     end

data/lib/riot/context.rb

@@ -1,5 +1,9 @@
 module Riot
-  class Situation; end
+  class Situation
+    def fail(message)
+      raise Failure.new(message)
+    end
+  end
 
   class Context
     # The protein

data/lib/riot/macros.rb

@@ -44,6 +44,24 @@ module Riot
     def kind_of(expected)
       actual.kind_of?(expected) || fail("expected kind of #{expected}, not #{actual.inspect}")
     end
+
+    # 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") }
+    #   asserts("foo") { 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
+    #   setup { User.new(:emmail => "foo@bar.baz") }
+    #   asserts("foo") { topic }.assigns(:email, "foo@bar.baz")
+    def assigns(variable, expected_value=nil)
+      actual_value = actual.instance_variable_get("@#{variable}")
+      return fail("expected @#{variable} to be assigned a value") if actual_value.nil?
+      unless expected_value.nil? || expected_value == actual_value
+        return fail(%Q[expected @#{variable} to be equal to '#{expected_value}', not '#{actual_value}'])
+      end
+      true
+    end
   end # AssertionMacros
 end # Riot
 

data/riot.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "riot"
-  s.version  = "0.9.1"
-  s.date     = "2009-10-03"
+  s.version  = "0.9.2"
+  s.date     = "2009-10-05"
   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"
@@ -29,5 +29,6 @@ Gem::Specification.new do |s|
     test/assertion_test.rb
     test/benchmark/simple_context_and_assertions.rb
     test/context_test.rb
+    test/teststrap.rb
   ]
 end

data/test/assertion_test.rb

@@ -1,39 +1,49 @@
-require 'riot'
+require 'teststrap'
 
-fake_context = Object.new # It works ... so, why not?
+fake_situation = Riot::Situation.new
 
 context "basic assertion:" do
   should "have a description" do
-    Riot::Assertion.new("i will pass", fake_context).to_s
+    Riot::Assertion.new("i will pass", fake_situation).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?
+    Riot::Assertion.new("i will pass", fake_situation) { true }.passed?
   end
 
   asserts "failure? is true when assertion does not pass" do
-    Riot::Assertion.new("i will pass", fake_context) { false }.failed?
+    Riot::Assertion.new("i will pass", fake_situation) { false }.failed?
   end
 
   asserts "error? is true when an unexpected Exception is raised" do
-    Riot::Assertion.new("error", fake_context) { raise Exception, "blah" }.errored?
+    Riot::Assertion.new("error", fake_situation) { raise Exception, "blah" }.errored?
   end
-end
+
+  context "that fails while executing test" do
+    setup do
+      Riot::Assertion.new("error", fake_situation) { fail("I'm a bum") }
+    end
+
+    should("be considered a failing assertion") { topic.failed? }
+    should("use failed message in description") { topic.result.message }.matches(/I'm a bum/)
+    should("assign assertion to failure") { topic.result }.assigns(:assertion)
+  end # that fails while executing test
+end # basic assertion
 
 context "equals assertion:" do
   asserts "result equals expectation" do
-    Riot::Assertion.new("i will pass", fake_context) { "foo bar" }.equals("foo bar")
+    Riot::Assertion.new("i will pass", fake_situation) { "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")
+    Riot::Assertion.new("failure", fake_situation) { "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 }
+  asserts("result is nil") { Riot::Assertion.new("foo", fake_situation) { nil }.nil }
   should "raise a Failure if not nil" do
-    Riot::Assertion.new("foo", fake_context) { "a" }.nil
+    Riot::Assertion.new("foo", fake_situation) { "a" }.nil
   end.kind_of(Riot::Failure)
 end # nil assertion
 
@@ -41,25 +51,25 @@ context "raises assertion:" do
   should("raise an Exception") { raise Exception }.raises(Exception)
 
   should "pass if provided message equals expectation" do
-    Riot::Assertion.new("foo", fake_context) do
+    Riot::Assertion.new("foo", fake_situation) do
       raise Exception, "I'm a nerd"
     end.raises(Exception, "I'm a nerd")
   end.equals(true)
 
   should "fail if provided message does not equal expectation" do
-    Riot::Assertion.new("foo", fake_context) do
+    Riot::Assertion.new("foo", fake_situation) do
       raise(Exception, "I'm a nerd")
     end.raises(Exception, "But I'm not")
   end.kind_of(Riot::Failure)
 
   should "pass if provided message matches expectation" do
-    Riot::Assertion.new("foo", fake_context) do
+    Riot::Assertion.new("foo", fake_situation) do
       raise(Exception, "I'm a nerd")
     end.raises(Exception, %r[nerd])
   end.equals(true)
 
   should "fail if provided message does not match expectation" do
-    Riot::Assertion.new("foo", fake_context) do
+    Riot::Assertion.new("foo", fake_situation) do
       raise(Exception, "I'm a nerd")
     end.raises(Exception, %r[foo])
   end.kind_of(Riot::Failure)
@@ -67,24 +77,62 @@ end # raises assertion
 
 context "matching assertion:" do
   asserts "result matches expression" do
-    Riot::Assertion.new("foo", fake_context) { "a" }.matches(%r[.])
+    Riot::Assertion.new("foo", fake_situation) { "a" }.matches(%r[.])
   end.equals(0)
 
   should "raise a Failure if result does not match" do
-    Riot::Assertion.new("foo", fake_context) { "" }.matches(%r[.])
+    Riot::Assertion.new("foo", fake_situation) { "" }.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")
+    Riot::Assertion.new("foo", fake_situation) { "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)
+    Riot::Assertion.new("foo", fake_situation) { "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)
+    Riot::Assertion.new("foo", fake_situation) { 0 }.kind_of(String)
   end.kind_of(Riot::Failure)
 end # kind_of assertion
+
+context "assigns assertion:" do
+  setup do
+    situation = Riot::Situation.new
+    situation.instance_eval { @foo = "bar"; @bar = nil}
+    situation
+  end
+
+  asserts("an instance variable was assigned") do
+    test_object = topic
+    Riot::Assertion.new("duh", fake_situation) { test_object }.assigns(:foo)
+  end
+
+  asserts("an instance variable was never assigned") do
+    test_object = topic
+    Riot::Assertion.new("foo", fake_situation) { test_object }.assigns(:baz)
+  end.kind_of(Riot::Failure)
+  
+  asserts "an instance variable was defined with nil value" do
+    test_object = topic
+    Riot::Assertion.new("foo", fake_situation) { test_object }.assigns(:bar).message
+  end.equals("expected @bar to be assigned a value")
+
+  asserts("an instance variable was assigned a specific value") do
+    test_object = topic
+    Riot::Assertion.new("duh", fake_situation) { test_object }.assigns(:foo, "bar")
+  end
+
+  asserts("failure when instance never assigned even when a value is expected") do
+    test_object = topic
+    Riot::Assertion.new("duh", fake_situation) { test_object }.assigns(:bar, "bar").message
+  end.equals("expected @bar to be assigned a value")
+
+  asserts("failure when expected value is not assigned to variable with a value") do
+    test_object = topic
+    Riot::Assertion.new("duh", fake_situation) { test_object }.assigns(:foo, "baz").message
+  end.equals("expected @foo to be equal to 'baz', not 'bar'")
+end # assigns assertion

data/test/context_test.rb

@@ -1,4 +1,4 @@
-require 'riot'
+require 'teststrap'
 require 'stringio'
 
 context "any context" do

data/test/teststrap.rb

@@ -0,0 +1,3 @@
+require 'riot'
+
+at_exit { Riot.report }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: riot
 version: !ruby/object:Gem::Version 
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors: 
 - Justin Knowlden
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-03 00:00:00 -05:00
+date: 2009-10-05 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -65,3 +65,4 @@ test_files:
 - test/assertion_test.rb
 - test/benchmark/simple_context_and_assertions.rb
 - test/context_test.rb
+- test/teststrap.rb