riot 0.11.4 → 0.12.0.pre

data/test/core/assertion_macros/nil_test.rb

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

data/test/core/assertion_macros/not_borat_test.rb

@@ -1,15 +1,21 @@
 require 'teststrap'
 
 context "A not! assertion macro" do
-  setup do
-    def assert_not(value)
-      Riot::Assertion.new("test") { value }.not!
-    end
-  end
+  helper(:assert_not!) { |o| Riot::Assertion.new("foo") { o }.not! }
 
-  assertion_test_passes("when value is false", "does exist ... not!") { assert_not(false) }
-  assertion_test_passes("when value is nil", "does exist ... not!") { assert_not(nil) }
+  assertion_test_passes("when value is false", "does exist ... not!") { assert_not!(false) }
+  assertion_test_passes("when value is nil", "does exist ... not!")   { assert_not!(nil)   }
   assertion_test_fails("when value is not nil or false", "expected to exist ... not!") do
-    assert_not("funny")
+    assert_not!("funny")
   end
 end # A not! assertion macro
+
+context "A negative not! assertion macro" do
+  helper(:assert_not_not!) { |o| Riot::Assertion.new("foo", true) { o }.not! }
+  
+  assertion_test_fails("when value is false", "expected to not exist ... not!") { assert_not_not!(false)   }
+  assertion_test_fails("when value is nil", "expected to not exist ... not!")   { assert_not_not!(nil)     }
+  assertion_test_passes("when value is not nil or false", "does not exist ... not!") do 
+    assert_not_not!('borat')
+  end
+end # A negative not! assertion macro

data/test/core/assertion_macros/raises_test.rb

@@ -3,12 +3,13 @@ require 'teststrap'
 class Whoops < Exception; end
 
 context "A raises assertion macro" do
+  helper(:asserts_raises) { |o| Riot::Assertion.new("foo") { raise Whoops, o } }
   assertion_test_passes("when expected exception is raised", "raises Whoops") do
-    Riot::Assertion.new("foo") { raise Whoops }.raises(Whoops)
+    asserts_raises(nil).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)
+    asserts_raises(nil).raises(Exception)
   end
 
   assertion_test_fails("when nothing was raised", "should have raised Whoops, but raised nothing") do
@@ -16,18 +17,50 @@ context "A raises assertion macro" do
   end
   
   assertion_test_passes("when provided message equals expected message", %Q{raises Whoops with message "Mom"}) do
-    Riot::Assertion.new("foo") { raise Whoops, "Mom" }.raises(Whoops, "Mom")
+    asserts_raises('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")
+    asserts_raises('Dad').raises(Whoops, 'Mom')
   end
 
   assertion_test_passes("when provided message matches expected message", %Q{raises Whoops with message /Mom/}) do
-    Riot::Assertion.new("foo") { raise Whoops, "Mom" }.raises(Whoops, /Mom/)
+    asserts_raises('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/)
+    asserts_raises('Dad').raises(Whoops, /Mom/)
+  end
+end # A raises assertion macro
+
+context "A negative raises assertion macro" do
+  helper(:deny_raises) { |o| Riot::Assertion.new("foo", true) { raise Whoops, o } }
+
+  assertion_test_fails("when expected exception is raised", "should have not raised Whoops, but raised Whoops") do
+    deny_raises(nil).raises(Whoops)
+  end
+
+  assertion_test_passes("when unexpected exception is raised", "not raised Exception") do
+    deny_raises(nil).raises(Exception)
+  end
+
+  assertion_test_passes("when nothing was raised", "raised nothing") do
+    Riot::Assertion.new("foo", true) { "barf" }.raises(Whoops)
+  end
+  
+  assertion_test_fails("when provided message equals expected message", 'should have not raised Whoops with message "Mom", but raised Whoops with message "Mom"') do
+    deny_raises('Mom').raises(Whoops, 'Mom')
+  end
+
+  assertion_test_passes("when messages and exception aren't equal", 'not raised Exception with message "Dad"') do
+    deny_raises('Mom').raises(Exception, 'Dad')
+  end
+
+  assertion_test_fails("when provided message matches expected message", 'should have not raised Whoops with message /Mom/, but raised Whoops with message "Mom"') do
+    deny_raises('Mom').raises(Whoops, /Mom/)
+  end
+
+  assertion_test_fails("when messages don't match", "should have not raised Whoops with message /Mom/, but raised Whoops with message \"Dad\"") do
+    deny_raises('Dad').raises(Whoops,/Mom/)
   end
 end # A raises assertion macro

data/test/core/assertion_macros/respond_to_test.rb

@@ -4,10 +4,27 @@ context "A respond_to assertion macro" do
   setup { Riot::Assertion.new("foo") { "bar" } }
 
   assertion_test_passes("when method is defined", "responds to :each_byte") { topic.respond_to(:each_byte) }
-  assertion_test_passes("using responds_to alias", "responds to :length") { topic.responds_to(:length) }
+  assertion_test_passes("using responds_to alias", "responds to :length")   { topic.responds_to(:length)   }
 
   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
+
+context "A negative respond_to assertion macro" do
+  setup { Riot::Assertion.new("foo", true) { "bar" } }
+  
+  assertion_test_fails("when method is defined", "expected method :each_byte is defined") do
+    topic.respond_to(:each_byte)
+  end
+  
+  assertion_test_fails("using responds_to alias", "expected method :length is defined") do
+    topic.responds_to(:length)
+  end
+  
+  assertion_test_passes("when method is not defined", "does not respond to :goofballs") do
+    topic.respond_to(:goofballs)
+  end
+  
+end

data/test/core/assertion_macros/same_elements_test.rb

@@ -15,3 +15,20 @@ context "A same_elements assertion macro" do
     topic.same_elements(["foo", "bar", 96])
   end
 end # A same_elements assertion macro
+
+context "A negative same_elements assertion macro" do
+  setup { Riot::Assertion.new("test", true) { ["foo","bar", 69] } }
+  
+  assertion_test_fails("when elements match", %Q{expected elements [69, "foo", "bar"] not to match ["foo", "bar", 69]}) do
+    topic.same_elements([69, "foo", "bar"])
+  end
+
+  assertion_test_fails("when any elements match", %Q{expected elements ["foo", "bar", 69] not to match ["foo", "bar", 69]}) do
+    topic.same_elements(["foo", "bar", 69])
+  end
+
+  assertion_test_passes("when elements do not match") do
+    topic.same_elements(["foo", "bar", 96])
+  end
+  
+end # A negative same_elements macro

data/test/core/assertion_macros/size_test.rb

@@ -1,11 +1,7 @@
 require 'teststrap'
 
 context "A size assertion macro" do
-  setup do
-    def assert_size(sizable, expected_size)
-      Riot::Assertion.new("test") { sizable }.size(expected_size)
-    end
-  end
+  helper(:assert_size) { |sizable, expected_size| Riot::Assertion.new("test") { sizable }.size(expected_size) }
 
   assertion_test_passes("when string's size is as expected", "is of size 10") do
     assert_size("washington", 10)
@@ -45,3 +41,47 @@ context "A size assertion macro" do
     assert_size({}, 2...4)
   end
 end
+
+context "A negative size assertion macro" do
+  helper(:deny_size) { |sizable, expected_size| Riot::Assertion.new("test", true) { sizable }.size(expected_size) }
+
+  assertion_test_fails("when string's size is as expected", 'expected size of "washington" to not be 10, not 10') do
+    deny_size("washington", 10)
+  end
+  assertion_test_fails("when string's size is in given range", 'expected size of "washington" to not be 9..12, not 10') do
+    deny_size("washington", 9..12)
+  end
+
+  assertion_test_passes("when string's size is not as expected", 'is not size 11') do
+    deny_size("washington", 11)
+  end
+  assertion_test_passes("when string's size is out of range", 'is not size 11..13') do
+    deny_size("washington", 11..13)
+  end
+
+  assertion_test_fails("when an array's size is as expected", 'expected size of [1, 2, 3] to not be 3, not 3') do
+    deny_size([1, 2, 3], 3)
+  end
+  assertion_test_fails("when an array's size is in given range", 'expected size of [1, 2, 3] to not be 3..4, not 3') do
+    deny_size([1, 2, 3], 3..4)
+  end
+  assertion_test_passes("when an array's size is not as expected", "is not size 2") do
+    deny_size([1, 2, 3], 2)
+  end
+  assertion_test_passes("when an array's size is out of range", "is not size 4..6") do
+    deny_size([1, 2, 3], 4..6)
+  end
+
+  assertion_test_fails("when a hash size is as expected", 'expected size of {:a=>"b"} to not be 1, not 1') do
+    deny_size({:a => 'b'}, 1)
+  end
+  assertion_test_fails("when a hash size is in range", 'expected size of {:a=>"b"} to not be 1...3, not 1') do
+    deny_size({:a => 'b'}, 1...3)
+  end
+  assertion_test_passes("when a hash size is not as expected", "is not size 2") do
+    deny_size({}, 2)
+  end
+  assertion_test_passes("when a hash size is out of range", "is not size 2...4") do
+    deny_size({}, 2...4)
+  end
+end

data/test/core/context/asserts_topic_test.rb

@@ -0,0 +1,21 @@
+require 'teststrap'
+
+context "The asserts_topic shortcut" do
+  setup do
+    Riot::Context.new("foo") {}.asserts_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("bar").run(situation)
+  end.equals([:pass, %Q{is equal to "bar"}])
+
+  asserts(:to_s).equals("asserts that it")
+
+  context "with an explicit description" do
+    setup { Riot::Context.new("foo") {}.asserts_topic("get some") }
+    asserts(:to_s).equals("asserts get some")
+  end
+end # The asserts_topic shortcut

data/test/core/context/context_test.rb

@@ -0,0 +1,35 @@
+require 'teststrap'
+
+context "Reporting a context" do
+  setup do
+    a_context = Riot::Context.new("foobar") do
+      asserts("passing") { true }
+      asserts("failing") { false }
+      asserts("erroring") { raise Exception }
+    end
+    a_context.run(MockReporter.new)
+  end
+
+  asserts("one passed test") { topic.passes == 1 }
+  asserts("one failed test") { topic.failures == 1 }
+  asserts("one errored test") { topic.errors == 1 }
+end # Reporting a context
+
+context "Defining a context with multiple setups" do
+  setup do
+    @a_context = Riot::Context.new("foobar") do
+      setup { "foo" }
+      setup { topic + "bar" }
+      asserts("blah") { topic == "foobar" }
+    end
+    @a_context.run(MockReporter.new)
+  end
+  asserts("has setups") { @a_context.setups.size }.equals(2)
+  asserts("all tests pass") { topic.passes == 1 }
+end # Defining a context with multiple setups
+
+context "Making a new context" do
+  asserts("RootContext is used if nil parent is provided") do
+    Riot::Context.new("hello", nil) {}.parent
+  end.kind_of(Riot::RootContext)
+end # Making a context

data/test/core/context/deny_test.rb

@@ -0,0 +1,25 @@
+require 'teststrap'
+
+context "Using denies" do
+
+  helper(:denial_context) do |&assertion_block|
+    report = Riot::Context.new("Apple Jackie") do
+      denies("with false", &assertion_block)
+    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
+    denial_context { raise Exception }
+  end.equals([0,0,1])
+
+end # Using denies

data/test/core/context/helper_test.rb

@@ -0,0 +1,11 @@
+require 'teststrap'
+
+context "A context with a helper" do
+  setup { "foo" }
+
+  helper(:upcase) { topic.upcase }
+  helper(:append) {|str| topic + str }
+
+  asserts("executing the helper") { upcase }.equals("FOO")
+  asserts("calling a helper with an argument") { append("bar") }.equals("foobar")
+end

data/test/core/context/hookup_test.rb

@@ -0,0 +1,13 @@
+require 'teststrap'
+
+context "Using a hookup" do
+  setup do
+    situation = Riot::Situation.new
+    a_context = Riot::Context.new("foobar") {}
+    a_context.setup { "I'm a string" }.run(situation)
+    a_context.hookup { topic.size }.run(situation)
+    situation.topic
+  end
+  
+  asserts_topic.equals("I'm a string")
+end # Using a hookup

data/test/core/context/nested_contexts_test.rb

@@ -0,0 +1,40 @@
+require 'teststrap'
+
+context "Nesting a context" do
+  setup do
+    a_context = Riot::Context.new("foobar") do
+      asserts("passing") { true }
+      context "bazboo" do
+        asserts("passing") { true }
+        asserts("failing") { false }
+        asserts("erroring") { raise Exception }
+      end
+    end
+    a_context.run(MockReporter.new)
+  end
+
+  asserts("one passed test") { topic.passes == 2 }
+  asserts("one failed test") { topic.failures == 1 }
+  asserts("one errored test") { topic.errors == 1 }
+
+  context "with setups" do
+    setup do
+      a_context = Riot::Context.new("foobar") do
+        setup { "foo" }
+        context "bazboo" do
+          setup { topic + "bar" }
+          asserts("passing") { topic == "foobar" }
+        end
+      end
+      a_context.run(MockReporter.new)
+    end
+
+    asserts("parent setups are called") { topic.passes == 1 }
+  end # with setups
+end # Nesting a context
+
+context "A context with nested descriptions as classes" do
+  setup { Riot::Context.new(String) {}.context(Hash) {} }
+  asserts(:description).equals { Hash }
+  asserts(:detailed_description).equals("String Hash")
+end # A context with nested descriptions as classes

data/test/core/context/premium_setup_test.rb

@@ -0,0 +1,19 @@
+require 'teststrap'
+
+class SingletonArray
+  def self.<<(value); values << value; end
+  def self.values; @@values ||= []; end
+end
+
+context "A context with premium_setup" do
+  setup do
+    Riot::Context.new("Foo") do
+      setup { SingletonArray << "baz" }
+      setup(true) { SingletonArray << "bar" }
+      setup(true) { SingletonArray << "foo" }
+    end.run(MockReporter.new)
+  end
+
+  asserts("order of setups ensures topic") { SingletonArray.values }.equals(%w[foo bar baz])
+end
+

data/test/core/context/should_test.rb

@@ -0,0 +1,17 @@
+require 'teststrap'
+
+context "Using should" do
+  setup do
+    a_context = Riot::Context.new("foobar") do
+      should("pass") { true }
+      should("fail") { false }
+      should("error") { raise Exception }
+    end
+    a_context.run(MockReporter.new)
+  end
+
+  asserts("one passed test") { topic.passes == 1 }
+  asserts("one failed test") { topic.failures == 1 }
+  asserts("one errored test") { topic.errors == 1 }
+end # Using should
+

data/test/core/{using_describe_in_a_test.rb → context/using_describe_in_a_test.rb}

@@ -1,5 +1,14 @@
 require 'teststrap'
 
+context "The describe alias" do
+  setup do
+    Riot::Context.new("Foo") {}
+  end
+
+  asserts("any ol' object") { Object.new }.responds_to(:describe)
+  asserts_topic.responds_to :describe
+end # The describe alias
+
 describe "This describe context" do
   setup { "another thing is my" }
   asserts_topic.kind_of(String)