riot 0.11.4 → 0.12.0.pre

data/test.watchr

@@ -0,0 +1,70 @@
+ENV["WATCHR"] = "1"
+system 'clear'
+
+def growl(message)
+  growlnotify = `which growlnotify`.chomp
+  title = "Watchr Test Results"
+  image = message.include?('0 failures, 0 errors') ? "~/.watchr_images/passed.png" : "~/.watchr_images/failed.png"
+  options = "-w -n Watchr --image '#{File.expand_path(image)}' -m '#{message}' '#{title}'"
+  system %(#{growlnotify} #{options} &)
+end
+
+def run(cmd)
+  puts(cmd)
+  `#{cmd}`
+end
+
+def run_test_file(file)
+  system('clear')
+  result = run(%Q(ruby -I"lib:test" -rubygems #{file}))
+  growl result.split("\n").last rescue nil
+  puts result
+end
+
+def run_all_tests
+  system('clear')
+  result = run "rake test:all"
+  growl result.split("\n").last rescue nil
+  puts result
+end
+
+def run_all_features
+  system('clear')
+  run "cucumber"
+end
+
+def related_test_files(path)
+  Dir['test/**/*.rb'].select { |file| file =~ /#{File.basename(path).split(".").first}_test.rb/ }
+end
+
+def run_suite
+  run_all_tests
+  # run_all_features
+end
+
+watch('test/teststrap\.rb') { run_all_tests }
+watch('test/(.*).*_test\.rb') { |m| run_test_file(m[0]) }
+watch('lib/.*/.*\.rb') { |m| related_test_files(m[0]).map {|tf| run_test_file(tf) } }
+# watch('features/.*/.*\.feature') { run_all_features }
+
+# Ctrl-\
+Signal.trap 'QUIT' do
+  puts " --- Running all tests ---\n\n"
+  run_all_tests
+end
+
+@interrupted = false
+
+# Ctrl-C
+Signal.trap 'INT' do
+  if @interrupted then
+    @wants_to_quit = true
+    abort("\n")
+  else
+    puts "Interrupt a second time to quit"
+    @interrupted = true
+    Kernel.sleep 1.5
+    # raise Interrupt, nil # let the run loop catch it
+    run_suite
+  end
+end

data/test/core/assertion_macros/any_test.rb

@@ -1,10 +1,8 @@
 require 'teststrap'
 
 context "An any assertion macro" do
-  setup do
-    def assert_any(string)
-      Riot::Assertion.new("test") { string }.any
-    end
+  helper(:assert_any) do |o|
+    Riot::Assertion.new("test") { o }.any
   end
 
   assertion_test_passes("when an array has items", "is not empty") { assert_any([1]) }
@@ -17,3 +15,37 @@ context "An any assertion macro" do
     assert_any({})
   end
 end
+
+context "A negative, any assertion macro" do
+  helper(:any) do |o|
+    Riot::Assertion.new("test", true) { o }.any
+  end
+
+  asserts(":error when value is nil") do
+    any(nil).run(Riot::Situation.new)[0] # No method any? on nil
+  end.equals(:error)
+
+  asserts(":pass when string is empty") do
+    any("").run(Riot::Situation.new)
+  end.equals([:pass, "has elements"])
+
+  asserts(":pass when array is empty") do
+    any([]).run(Riot::Situation.new)
+  end.equals([:pass, "has elements"])
+
+  asserts(":pass when hash is empty") do
+    any({}).run(Riot::Situation.new)
+  end.equals([:pass, "has elements"])
+
+  asserts(":fail when string is empty") do
+    any("foo").run(Riot::Situation.new)[0..1]
+  end.equals([:fail, %Q{expected "foo" not to have elements}])
+
+  asserts(":fail when array has elements") do
+    any([1,2]).run(Riot::Situation.new)[0..1]
+  end.equals([:fail, %Q{expected [1, 2] not to have elements}])
+
+  asserts(":fail when hash has elements") do
+    any({"bar" => "baz"}).run(Riot::Situation.new)[0..1]
+  end.equals([:fail, %Q{expected {"bar"=>"baz"} not to have elements}])
+end

data/test/core/assertion_macros/assigns_test.rb

@@ -22,3 +22,31 @@ context "An assigns assertion macro" do
     topic.assigns(:nil_val)
   end
 end # An assigns assertion macro
+
+context "A negative assigns assertion macro" do
+  setup do
+    item = Object.new
+    item.instance_eval { @foo = 1; @nil_val = nil }
+    Riot::Assertion.new("test", true) { item }
+  end
+
+  asserts(":pass when @bar is not defined") do
+    topic.assigns(:bar).run(Riot::Situation.new)
+  end.equals([:pass, ""])
+
+  asserts(":pass when @nil_val is actually nil") do
+    topic.assigns(:nil_val).run(Riot::Situation.new)
+  end.equals([:pass, ""])
+
+  asserts(":pass when @foo does not equal 2") do
+    topic.assigns(:foo, 2).run(Riot::Situation.new)
+  end.equals([:pass, ""])
+
+  asserts(":fail when @foo is defined") do
+    topic.assigns(:foo).run(Riot::Situation.new)[0..1]
+  end.equals([:fail, "expected :foo to not be assigned a value"])
+
+  asserts(":fail when @foo does equal 1") do
+    topic.assigns(:foo, 1).run(Riot::Situation.new)[0..1]
+  end.equals([:fail, "expected :foo to not be equal to 1"])
+end # A negative assigns assertion macro

data/test/core/assertion_macros/empty_test.rb

@@ -1,24 +1,52 @@
 require 'teststrap'
 
 context "An empty assertion macro" do
-  setup do
-    def assert_empty(string)
-      Riot::Assertion.new("test") { string }.empty
-    end
+  helper(:assert_empty) do |o|
+    Riot::Assertion.new("test") { o }.empty
   end
 
-  assertion_test_passes("when string is empty") { assert_empty("") }
+  assertion_test_passes("when string is empty", "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_passes("when an array is empty", "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_passes("when a hash is empty", "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
+
+context "A negative empty assertion macro" do
+  helper(:assert_empty) do |o|
+    Riot::Assertion.new("test", true) { o }.empty.run(Riot::Situation.new)
+  end
+
+  asserts("when string is not empty") do
+    assert_empty("foo")
+  end.equals([:pass, "is empty"])
+
+  asserts("when string is empty") do
+    assert_empty("")[0..1]
+  end.equals([:fail, "expected \"\" to not be empty"])
+
+  asserts("when array is not empty") do
+    assert_empty([1])
+  end.equals([:pass, "is empty"])
+
+  asserts("when array is empty") do
+    assert_empty([])[0..1]
+  end.equals([:fail, "expected [] to not be empty"])
+
+  asserts("when hash is not empty") do
+    assert_empty({:boo => "blux"})
+  end.equals([:pass, "is empty"])
+
+  asserts("when hash is empty") do
+    assert_empty({})[0..1]
+  end.equals([:fail, "expected {} to not be empty"])
+end # A negative empty assertion macro

data/test/core/assertion_macros/equals_test.rb

@@ -40,3 +40,32 @@ context "An equals assertion macro" do
   end # with block as the expectation
 
 end # An equals assertion macro
+
+context "A negative equals assertion macro" do
+  setup do
+    Riot::Assertion.new("that flirgy", true) { "foo" }
+  end
+
+  asserts(":pass when values do not match") do
+    topic.equals("bar").run(Riot::Situation.new) == [:pass, %Q{is equal to "bar" when it is "foo"}]
+  end
+
+  asserts(":fail when values do match") do
+    topic.equals("foo").run(Riot::Situation.new)[0..1] == [:fail, %Q{did not expect "foo"}]
+  end
+  
+  asserts("result of evaluating when number outside of range") do
+    Riot::Assertion.new("blue", true) { 31415 }.equals(30000..32000).run(Riot::Situation.new)
+  end.equals([:pass, "is equal to 30000..32000 when it is 31415"])
+  
+  context "with block as the expectation" do
+    asserts(":pass when block expectation values do not equal") do
+      topic.equals { "bazzle" }.run(Riot::Situation.new)
+    end.equals([:pass, %Q{is equal to "bazzle" when it is "foo"}])
+  
+    asserts(":fail with message when block expectation values do equal") do
+      topic.equals { "foo" }.run(Riot::Situation.new)[0..1]
+    end.equals([:fail, %Q{did not expect "foo"}])
+  end # with block as the expectation
+
+end # A negative assertion macro

data/test/core/assertion_macros/equivalent_to_test.rb

@@ -4,33 +4,52 @@ require 'teststrap'
 # and assertion_test_fails for testing other macros.
 
 context "An equivalent_to assertion macro" do
-  setup do
-    Riot::Assertion.new("red") { "what" }
-  end
+  setup { Riot::Assertion.new("red") { "what" } }
 
   asserts("String is equivalent to 'what'") do
-    topic.equivalent_to(String).run(Riot::Situation.new) == [:pass, %Q{is equivalent to String}]
-  end
+    topic.equivalent_to(String).run(Riot::Situation.new)
+  end.equals([:pass, "is equivalent to String"])
 
   asserts("an array is not equivalent to 'what'") do
-    topic.equivalent_to([]).run(Riot::Situation.new)[0..1] == [:fail, %Q{expected "what" to be equivalent to []}]
-  end
+    topic.equivalent_to([]).run(Riot::Situation.new)[0..1]
+  end.equals([:fail, 'expected "what" to be equivalent to []'])
 
   context "with numeric topic" do
-    setup do
-      Riot::Assertion.new("blue") { 31413 }
-    end
+    setup { Riot::Assertion.new("blue") { 31413 } }
 
     asserts(":pass when in expected range") do
-      topic.equivalent_to(30000..32000).run(Riot::Situation.new) == [:pass, "is equivalent to 30000..32000"]
-    end
+      topic.equivalent_to(30000..32000).run(Riot::Situation.new)
+    end.equals([:pass, "is equivalent to 30000..32000"])
 
-    context "when not in expected range" do
-      setup { topic.equivalent_to(32000..33000).run(Riot::Situation.new) }
+    asserts ":fail when not in expected range" do 
+      topic.equivalent_to(32000..33000).run(Riot::Situation.new)[0..1]
+    end.equals([:fail, 'expected 31413 to be equivalent to 32000..33000'])
 
-      asserts(":fail") { topic.first == :fail }
-      asserts("message") { topic[1] == %Q{expected 31413 to be equivalent to 32000..33000} }
-    end
   end # with numeric topic
 
 end # An equivalent_to assertion macro
+
+context "A negative equivalent_to assertion macro" do
+  setup { Riot::Assertion.new("red", true) { "what" } }
+  
+  asserts("String is not equivalent to 'what'") do
+    topic.equivalent_to(String).run(Riot::Situation.new)[0..1]
+  end.equals([:fail, 'expected "what" not to be equivalent to String'])
+
+  asserts("an array is not equivalent to 'what'") do
+    topic.equivalent_to([]).run(Riot::Situation.new)
+  end.equals([:pass, "is not equivalent to []"])
+
+  context "with numeric topic" do
+    setup { Riot::Assertion.new("blue", true) { 31413 } }
+
+    asserts(":fail when not in expected range") do
+      topic.equivalent_to(30000..32000).run(Riot::Situation.new)[0..1]
+    end.equals([:fail, "expected 31413 not to be equivalent to 30000..32000"])
+
+    asserts ":pass when in expected range" do 
+      topic.equivalent_to(32000..33000).run(Riot::Situation.new)
+    end.equals([:pass, "is not equivalent to 32000..33000"])
+    
+  end # with numeric topic
+end # A negative equivalent_to assertion macro

data/test/core/assertion_macros/exists_test.rb

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

data/test/core/assertion_macros/includes_test.rb

@@ -11,3 +11,15 @@ context "An includes assertion macro" do
     topic.includes(99)
   end
 end # An includes assertion macro
+
+context "A negative includes assertion macro" do
+  setup do
+    Riot::Assertion.new("an array", true) { [1, 6, 42, 7] }
+  end
+  
+  assertion_test_passes("when array doesn't include 69", "does not include 69") { topic.includes(69) }
+  
+  assertion_test_fails("when 42 is included in array", "expected [1, 6, 42, 7] to not include 42") do
+    topic.includes(42)
+  end
+end

data/test/core/assertion_macros/kind_of_test.rb

@@ -13,3 +13,18 @@ context "A kind_of assertion macro" do
     Riot::Assertion.new("foo") { }.kind_of(String)
   end
 end # A kind_of assertion macro
+
+context "A negative kind_of assertion macro" do
+  assertion_test_passes(":pass when specific result is not a kind of String", "is not a kind of String") do
+    Riot::Assertion.new("foo", true) { 1 }.kind_of(String)
+  end
+  
+  assertion_test_fails(":fail when a kind of String", "expected not kind of String, not String") do
+    Riot::Assertion.new("foo", true) { "a" }.kind_of(String)
+  end
+
+  assertion_test_passes(":pass when nil", "is not a kind of String") do
+    Riot::Assertion.new("foo", true) { }.kind_of(String)
+  end
+  
+end # A negative kind_of assert macro

data/test/core/assertion_macros/matches_test.rb

@@ -0,0 +1,49 @@
+require 'teststrap'
+
+context "A matching assertion macro" do
+  setup { Riot::Assertion.new("foo") { "abc" } }
+
+  assertion_test_passes("when expression matches actual", %Q{matches /abc/}) { topic.matches(/abc/) }
+
+  assertion_test_fails("when expression fails to match", "expected /abcd/ to match \"abc\"") do
+    topic.matches(/abcd/)
+  end
+
+  context "with integer based topic" do
+    setup { Riot::Assertion.new("foo") { 42 } }
+
+    assertion_test_passes("actual value converted to string", %Q{matches /^42$/}) do
+      topic.matches(/^42$/)
+    end
+
+    assertion_test_fails("actual value converted to string", %Q{expected /^52$/ to match 42}) do
+      topic.matches(/^52$/)
+    end
+  end
+
+end # A matching assertion macro
+
+context "A negative matching assertion macro" do
+  setup { Riot::Assertion.new("foo", true) { "abc" } }
+
+  assertion_test_fails("when expression matches actual", 'expected /abc/ not to match "abc"') do
+    topic.matches(/abc/)
+  end
+
+  assertion_test_passes("when expression does not match", 'does not match /abcd/') do
+    topic.matches(/abcd/)
+  end
+
+  context "with integer based topic" do
+    setup { Riot::Assertion.new("foo", true) { 42 } }
+
+    assertion_test_fails("actual value converted to string", 'expected /^42$/ not to match 42') do
+      topic.matches(/^42$/)
+    end
+
+    assertion_test_passes("actual value converted to string", 'does not match /^52$/') do
+      topic.matches(/^52$/)
+    end
+  end
+
+end # A negative matching assertion macro