riot 0.12.4 → 0.12.5

data/.gitignore

@@ -7,4 +7,4 @@ doc
 _site
 *.watchr
 .DS_Store
-
+Gemfile.lock

data/CHANGELOG

@@ -1,3 +1,21 @@
+== 0.12.5
+
+==== Remove doc for some deprecated macros: not, exists, any [charlietanskley]
+
+==== Deprecate two more macros [charlietanskley]
+
+==== make riot run -w clean. None of those pesky warnings [achiu]
+
+==== Use #inspect for printing arguments in error results [Mon-Ouie]
+
+==== Move BlankSlate into Riot namespace [Mon-Ouie]
+
+==== Setting options in a sub-context don't leak back into the parent context [skade]
+
+==== Remove deprecated `not!` macro [charlietanksley]
+
+==== Fix all warnings so riot runs `-w` clean
+
 == 0.12.4
 
 ==== Adding Riot.plain! option for not printing output in color [c00lryguy,

data/README.markdown

@@ -12,16 +12,19 @@ In contrast to other popular Ruby testing frameworks such as Test::Unit, [Should
 
 In Riot, tests reside in `contexts`. Within these, a `topic` object is defined through a `setup` block. The actual assertions are then made with an `asserts` or `denies` block.
 
+```ruby
     context "An empty Array" do
       setup { Array.new }
       asserts("it is empty") { topic.empty? }
       denies("it has any elements") { topic.any? }
     end # An Array
+```
 
 As you can see, the setup block doesn't use any instance variables to save the object under test — rather, the return value of the block is used as the `topic`. This object can then be accessed in the assertions using the `topic` attribute. Furthermore, at their very basic level, assertions need only return a boolean. When using `asserts`, `true` indicates a pass while `false` indicates a fail; subsequently, when using `denies`, `true` indicates a failure whereas `false` indicates success.
 
 Of course, you can nest contexts as well; the `setup` blocks are executed outside-in; as in, the parents' setups are run before the current context allowing for a setup hierarchy. `teardown` blocks are run inside out; the current context's teardowns are run before any of its parents'. This is what you would expect from other frameworks as well.
 
+```ruby
     context "An Array" do
       setup { Array.new }
 
@@ -33,6 +36,7 @@ Of course, you can nest contexts as well; the `setup` blocks are executed outsid
         asserts("returns the element on #first") { topic.first == "foo" }
       end
     end # An Array
+```
 
 By the way, you can put any kind of ruby object in your context description. Riot will call `to_s` on the actual value before it is used in a reporting context. This fact will become [useful later](http://thumblemonks.github.com/riot/hacking.html#context-middleware) ;)
 
@@ -44,37 +48,45 @@ We can do this with assertion macros. You can think of these as special assertio
 
 Let's take this little for instance:
 
+```ruby
     context "Yummy things" do
       setup { ["cookies", "donuts"] }
 
       asserts("#first") { topic.first }.equals("cookies")
     end # Yummy things
+```
 
 First, how's that for a readable test? Second, you should notice that the assertion block will return the `first` item from the `topic` (which is assumed to be `Enumerable` in this case); if it isn't `Enumerable`, then you have other problems. Since the first element in the array is "cookies", the assertion will pass. Yay!
 
 But wait, there's more. Riot is about helping you write faster and more readable tests. Notice any duplication in the example above (besides the value "cookies")? I do. How about that `first` notation in the assertion name and reference in the assertion block. Riot provides a shortcut which allows you to reference methods on the topic through the assertion name. Here's another way to write the same test:
 
+```ruby
     context "Yummy things" do
       setup { ["cookies", "donuts"] }
 
       asserts(:first).equals("cookies")
     end # Yummy things
+```
 
 Now that's real yummy. Want some more? Perhaps you just want to test the topic itself — not a method or attribute of it. You could do this:
 
+```ruby
     context "Yummy things" do
       setup { ["cookies", "donuts"] }
 
       asserts("topic") { topic }.size(2)
     end # Yummy things
+```
 
 But, as you can probably already guess, that's gross and redundant. To solve this, Riot provides the `asserts_topic` shortcut which is a helper that pretty much just does `asserts("topic") { topic }` for you.
 
+```ruby
     context "Yummy things" do
       setup { ["cookies", "donuts"] }
 
       asserts_topic.size(2)
     end # Yummy things
+```
 
 Yep, more readable.
 
@@ -82,6 +94,7 @@ Yep, more readable.
 
 Way back in the first code example we saw a reference to `denies`; this is what is called the negative assertion. You could probably also call it a counter assertion, but I don't. You can use `denies` with any assertion macro that you can use `asserts` with; it's just that `denies` expects the assertion to fail for the test to pass. For instance:
 
+```ruby
     context "My wallet" do
       setup do
         Wallet.new(1000) # That's 1000 cents, or $10USD yo
@@ -90,6 +103,7 @@ Way back in the first code example we saw a reference to `denies`; this is what
       asserts(:enough_for_lunch?)
       denies(:enough_for_lunch?)
     end # My wallet
+```
 
 One of those will pass and the other will fail. If $10 is not enough for lunch the `denies` statement will pass; and then you should move to Chicago where it is enough (if only barely).
 
@@ -126,10 +140,6 @@ The advantage of using the block is that its innards are evaluated against the s
   * `asserts.nil`
   * `denies.nil`
 
-* **Exists**: pretty much the opposite of the `nil` assertion macro. Expects no arguments.
-  * `asserts.exists`
-  * `denies.exists`
-
 * **Matches**: compares the actual value to a provided regular expression
   * `asserts.matches(%r{Regex})`
   * `denies.matches(%r{Regex})`
@@ -180,10 +190,6 @@ The advantage of using the block is that its innards are evaluated against the s
   * `asserts.size { Numeric }`
   * `denies.size { Numeric }`
 
-* **Any**: checks the result of calling `any?` on the actual value. Expects no arguments.
-  * `asserts.any`
-  * `denies.any`
-
 * **Empty**: checks the result of calling `empty?` on the actual value. Expects no arguments.
   * `asserts.empty`
   * `denies.empty`
@@ -194,10 +200,6 @@ The advantage of using the block is that its innards are evaluated against the s
   * `asserts.same_elements { Array }`
   * `denies.same_elements { Array }`
 
-* **Not!**: Expects no arguments and simply checks that the actual value is non-truthy. This is different than `exists` which only checks that the actual value is not nil. This assertion was added at the inception of Riot to deal with the fact that Riot didn't yet have negative assertions. I am hereby declaring this macro `@deprecated`. Please stop using it (note to self) because it will be removed someday.
-  * `asserts("i'm confused") { false }.not!`
-  * `denies("i'm not confused?") { true }.not!`
-
 ### Setups, Hookups, and Helpers {#setups-hookups}
 
 We're not even close to done yet; there's a lot more cool stuff for you to know about. You know about `setup` already; but you may not know that you can call `setup` multiple times within a Context. Well, you can. They run in the order you write them (top-down) and the result of a prior `setup` will be the `topic` for the next setup. In this way you **could** chain together some partitioned setup criteria without ever explicitly setting a variable (instance or local).
@@ -213,6 +215,7 @@ This notion about a prior `setup` being the `topic` for a latter `setup` is true
 
 More than likely, however, you'll want to modify something about the topic without changing what the topic for the context is. To do this, Riot provides the `hookup` block, which is just like a `setup` block except that `hookup` will always return the `topic` that was provided to it. It's kind of like calling `Object#tap`. Here's a for-instance:
 
+```ruby
     context "A Person" do
       setup { Person.new(:name => "Master Blasterr") }
 
@@ -223,6 +226,7 @@ More than likely, however, you'll want to modify something about the topic witho
         asserts(:valid?) # Yay!
       end # with valid email
     end # A complex thing
+```
 
 If the point didn't smack you in the face there, think about using `setup` instead of `hookup` in the sub-context. Had you written that as a `setup` block, you'd have to return `topic` after setting the email address, or else the new topic would be the actual email address; and you probably don't want to actually be calling `"master@blast.err".valid?` in the assertion.
 
@@ -232,6 +236,7 @@ You can also call `hookup` as many times as you like; the great part is that the
 
 You remember how you used to — or currently do — create instance variables to hold some data that you're going to use in your tests? Well, Riot allows you to still do that yucky stuff, but would rather you use a helper to encapsulate it. For instance, you could do this:
 
+```ruby
     context "A greedy monkey" do
       setup do
         @a_ripe_banana = Banana.new(:ripe => true)
@@ -242,9 +247,11 @@ You remember how you used to — or currently do — create instance var
 
       asserts(:bananas).size(1)
     end # A greedy monkey
+```
 
 Or, you could do this
 
+```ruby
     context "A greedy monkey" do
       helper(:a_ripe_banana) { Banana.new(:ripe => true) }
       setup { Monkey.new }
@@ -253,6 +260,7 @@ Or, you could do this
 
       asserts(:bananas).size(1)
     end # A greedy monkey
+```
 
 "So! What's the difference?", you ask. Nothing really. It's all aesthetic; but, it's a better aesthetic for a couple of reasons. Let me tell you why:
 
@@ -263,6 +271,7 @@ Or, you could do this
 
 What's that about (4)? Yes, helpers are really just over-glorified methods, which means you can pass arguments to them. Which means you can build factories with them. Which means those factories can go away when the context is no longer used and they're no longer cluttering up your object space. You want another for instance, eh?
 
+```ruby
     context "A greedy monkey" do
       helper(:make_a_banana) do |color|
         Banana.new(:color => color)
@@ -279,6 +288,7 @@ What's that about (4)? Yes, helpers are really just over-glorified methods, whic
       asserts("green bananas") { topic.bananas.green }.size(1)
       asserts("blue bananas") { topic.bananas.blue }.size(1)
     end # A greedy monkey
+```
 
 Or you could `make_many_bananas` or whatever. There are also lots of clever ways to get helpers included into a context which you will hopefully see when you read up on Context Middleware and look through the Recipes. Riot Rails makes liberal use of helpers when [setting up a context](http://github.com/thumblemonks/riot-rails/master/lib/riot/action_controller/context_middleware.rb) to test controllers.
 
@@ -295,12 +305,15 @@ Running your Riot tests is pretty simple. You can put your test files wherever y
 
 I like the latter and use it often. It means the test directory is loaded into the load path, which means I  don't have to be explicit about where to find my `teststrap.rb` file (which you might have named `test_helper.rb` in other projects even though it's a silly name). In your teststrap file you'll put all your common setup; maybe even including your Riot hacks. An out-of-the-box teststrap might look like this:
 
+```ruby
     require 'rubygems'
     require '<my-library>'
     require 'riot'
+```
 
 Of course, you probably want to use rake to run your tests. Here's a basic Rakefile that will find our tests in the test directory or its subdirectories if the filename ends in `_test.rb`:
 
+```ruby
     require 'rubygems'
 
     require 'rake'
@@ -316,6 +329,7 @@ Of course, you probably want to use rake to run your tests. Here's a basic Rakef
     end
 
     task :default => :test
+```
 
 And then on the command line you simply run:
 
@@ -341,13 +355,16 @@ However, there are a number of things you expect from a test framework when mock
 
 But enough of this hemming and hawing. What's it look like?! In your `teststrap.rb` you need to require in `riot/rr`:
 
+```ruby
     # I'm teststrap.rb
 
     require 'rubygems'
     require 'riot/rr'
+```
 
 Then, in your tests, you use standard RR syntax for all of your mocking needs:
 
+```ruby
     require 'teststrap.rb'
 
     context "A nice Person" do
@@ -361,6 +378,7 @@ Then, in your tests, you use standard RR syntax for all of your mocking needs:
       end.equals("Nice haircut")
 
     end # A nice Person
+```
 
 So, if `#say_something_nice` never calls `#make_network_request`, that assertion will fail for that reason first. If it does call `#make_network_request`, but for some reason "Nice haircut" is not returned, the tests will fail for that reason instead. It's like catching two birds with one test.
 

data/lib/riot/assertion_macro.rb

@@ -134,7 +134,6 @@ require 'riot/assertion_macros/includes'
 require 'riot/assertion_macros/kind_of'
 require 'riot/assertion_macros/matches'
 require 'riot/assertion_macros/nil'
-require 'riot/assertion_macros/not_borat'
 require 'riot/assertion_macros/raises'
 require 'riot/assertion_macros/raises_kind_of'
 require 'riot/assertion_macros/respond_to'

data/lib/riot/assertion_macros/any.rb

@@ -8,16 +8,20 @@ module Riot
   #
   #   denies("an empty array") { [] }.any
   #   denies("an empty hash") { {} }.any
+  #
+  # @deprecated Please use +asserts.empty+ or +denies.empty+ instead.
   class AnyMacro < AssertionMacro
     register :any
 
     # (see Riot::AssertionMacro#evaluate)
     def evaluate(actual)
+      warn "any is deprecated; please use asserts.empty or denies.empty instead"
       any?(actual) ? pass("has items") : fail(expected_message(actual).to_have_items)
     end
 
     # (see Riot::AssertionMacro#devaluate)
     def devaluate(actual)
+      warn "any is deprecated; please use asserts.empty or denies.empty instead"
       any?(actual) ? fail(expected_message(actual).not_to_have_items) : pass("has items")
     end
   private

data/lib/riot/assertion_macros/assigns.rb

@@ -61,7 +61,9 @@ module Riot
 
     def prepare(actual, *expectings, &block)
       variable, expected_value = expectings
-      yield(variable, expected_value, actual.instance_variable_get("@#{variable}"))
+      var_name  = "@#{variable}"
+      var_value = actual.instance_variable_defined?(var_name) ? actual.instance_variable_get(var_name) : nil
+      yield(variable, expected_value, var_value)
     end
   end # AssignsMacro
 end # Riot

data/lib/riot/assertion_macros/exists.rb

@@ -13,16 +13,20 @@ module Riot
   #   asserts("test") { nil }.nil   # same thing
   #
   #   denies("test") { "foo" }.exists # would fail
+  #
+  # @deprecated Please use +denies.nil+ instead of +asserts.exists+.
   class ExistsMacro < AssertionMacro
     register :exists
 
     # (see Riot::AssertionMacro#evaluate)
     def evaluate(actual)
+      warn "exists is deprecated; please use denies.nil instead of asserts.exists"
       actual.nil? ? fail("expected a non-nil value") : pass("does exist")
     end
     
     # (see Riot::AssertionMacro#devaluate)
     def devaluate(actual)
+      warn "exists is deprecated; please use denies.nil instead of asserts.exists"
       actual.nil? ? pass("does exist") : fail("expected a nil value")
     end
   end

data/lib/riot/context.rb

@@ -2,7 +2,7 @@ require 'riot/context_options'
 require 'riot/context_helpers'
 
 module Riot
-  RootContext = Struct.new(:setups, :teardowns, :detailed_description, :options)
+  RootContext = Struct.new(:setups, :teardowns, :detailed_description, :option_set)
 
   # Defines the classes {Riot::Context} will use when creating new assertions and situations.
   module ContextClassOverrides
@@ -51,7 +51,7 @@ module Riot
       @parent = parent || RootContext.new([],[], "", {})
       @description = description
       @contexts, @setups, @assertions, @teardowns = [], [], [], []
-      @options = @parent.options
+      @options = @parent.option_set.dup
       prepare_middleware(&definition)
     end
 
@@ -115,8 +115,8 @@ module Riot
     # choose. {Riot::AllImportantMiddleware} will always be the last in the chain.
     def prepare_middleware(&context_definition)
       last_middleware = AllImportantMiddleware.new(&context_definition)
-      Context.middlewares.inject(last_middleware) do |last_middleware, middleware|
-        middleware.new(last_middleware)
+      Context.middlewares.inject(last_middleware) do |previous_middleware, middleware|
+        middleware.new(previous_middleware)
       end.call(self)
     end
 

data/lib/riot/context_helpers.rb

@@ -81,7 +81,7 @@ module Riot
     #   asserts(:size).equals(2)
     #
     # Or with arguments:
-    # 
+    #
     #   asserts(:foo,1,2).equals(3)
     #
     # Passing a Symbol to +asserts+ enables this behaviour. For more information on
@@ -178,12 +178,12 @@ module Riot
       denies(what) { topic }
     end
   private
-    
+
     def new_assertion(scope, *args, &definition)
       options = args.extract_options!
       definition ||= proc { topic.send(*args) }
       description = "#{scope} #{args.first}"
-      description << " with arguments(s): #{args.slice(1, args.length)}" if args.size > 1
+      description << " with arguments(s): #{args.slice(1, args.length).inspect}" if args.size > 1
       (@assertions << assertion_class.new(description, options[:negative], &definition)).last
     end
 

data/lib/riot/context_options.rb

@@ -11,7 +11,7 @@ module Riot
     # @param [Object] key the key used to look up the option value later
     # @param [Object] value the option value to store
     def set(key, value)
-      options[key] = value
+      option_set[key] = value
     end
 
     # Returns the value of a set option. The key must match exactly, symbols and strings are not
@@ -20,13 +20,13 @@ module Riot
     # @param [Object] key the key used to look up the option value
     # @return [Object]
     def option(key)
-      options[key]
+      option_set[key]
     end
 
     # Returns the hash of defined options.
     #
     # @return [Hash]
-    def options
+    def option_set
       @options ||= {}
     end
 

data/lib/riot/message.rb

@@ -1,8 +1,10 @@
-class BlankSlate
-  instance_methods.each { |meth| undef_method(meth) unless meth.to_s =~ /^(__|object_id)/ }
-end
-
 module Riot
+  class BlankSlate
+    instance_methods.each do |meth|
+      undef_method(meth) unless meth.to_s =~ /^(__|object_id)/
+    end
+  end
+
   # A Message is similar in nature (but not implementation) to a string buffer; you put some strings in and
   # calling {#to_s} will generate a single new string. What's special abnout Message is how you get strings
   # into it. By convention, any method called on a Message that isn't defined will have its name turned into
@@ -12,7 +14,7 @@ module Riot
   #   message = Riot::Message.new
   #   message.hello_world.to_s
   #    => "hello world"
-  #   
+  #
   #   message.whats_the_news.to_s
   #    => "hello world whats the news"
   #
@@ -101,4 +103,4 @@ module Riot
       self
     end
   end # Message
-end # Riot
+end # Riot

data/lib/riot/situation.rb

@@ -31,7 +31,7 @@ module Riot
     #
     # @return [Object] whatever the topic is currently set to
     def topic
-      @_topic
+      @_topic ||= nil
     end
 
     # This is where a setup block is actually evaluated and the +topic+ tracked.

data/lib/riot/version.rb

@@ -1,4 +1,4 @@
 module Riot
-  VERSION = "0.12.4"
+  VERSION = "0.12.5"
 end
 

data/test/core/context/context_with_options_test.rb

@@ -29,5 +29,8 @@ context "Context with options" do
 
     asserts("option :goo") { topic.option(:goo) }.equals("car")
     asserts("option \"car\"") { topic.option("car") }.equals(3)
+    asserts("option :goo on parent") do
+      topic.parent.option(:goo)
+    end.equals(nil)
   end # and with a nested context
 end # Context with options

data/test/core/reports/dot_matrix_reporter_test.rb

@@ -16,7 +16,7 @@ context "DotMatrixReporter" do
     end
     asserts_topic('puts a dot').matches('.')
   end
-  
+
   context 'with a failing test' do
     setup do
       Riot::Context.new('whatever') do
@@ -25,12 +25,12 @@ context "DotMatrixReporter" do
       topic.results(100)
       @out.string
     end
-    
+
     asserts_topic('puts an F').matches('F')
     asserts_topic("puts the full context + assertion name").matches('whatever asserts nope!')
     asserts_topic("puts the failure reason").matches(/Expected .* but got false instead/)
   end
-  
+
   context 'with an error test' do
     setup do
       Riot::Context.new('whatever') do
@@ -39,7 +39,7 @@ context "DotMatrixReporter" do
       topic.results(100)
       @out.string
     end
-    
+
     asserts_topic('puts an E').matches('E')
     asserts_topic('puts the full context + assertion name').matches('whatever asserts bang')
     asserts_topic('puts the exception message').matches('BOOM')

data/test/teststrap.rb

@@ -2,7 +2,7 @@ $:.unshift(File.dirname(__FILE__) + "/../lib/")
 require 'riot'
 Riot.verbose
 
-Riot.dots if ENV["TM_MODE"]
+Riot.pretty_dots if ENV["TM_MODE"]
 
 module Riot
   module AssertionTestContextMacros

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: riot
 version: !ruby/object:Gem::Version 
-  hash: 39
   prerelease: 
-  segments: 
-  - 0
-  - 12
-  - 4
-  version: 0.12.4
+  version: 0.12.5
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -15,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-28 00:00:00 -05:00
+date: 2011-09-13 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,9 +21,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :runtime
   version_requirements: *id001
@@ -61,7 +53,6 @@ files:
 - lib/riot/assertion_macros/kind_of.rb
 - lib/riot/assertion_macros/matches.rb
 - lib/riot/assertion_macros/nil.rb
-- lib/riot/assertion_macros/not_borat.rb
 - lib/riot/assertion_macros/raises.rb
 - lib/riot/assertion_macros/raises_kind_of.rb
 - lib/riot/assertion_macros/respond_to.rb
@@ -97,7 +88,6 @@ files:
 - test/core/assertion_macros/kind_of_test.rb
 - test/core/assertion_macros/matches_test.rb
 - test/core/assertion_macros/nil_test.rb
-- test/core/assertion_macros/not_borat_test.rb
 - test/core/assertion_macros/raises_kind_of_test.rb
 - test/core/assertion_macros/raises_test.rb
 - test/core/assertion_macros/respond_to_test.rb
@@ -143,18 +133,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
@@ -178,7 +162,6 @@ test_files:
 - test/core/assertion_macros/kind_of_test.rb
 - test/core/assertion_macros/matches_test.rb
 - test/core/assertion_macros/nil_test.rb
-- test/core/assertion_macros/not_borat_test.rb
 - test/core/assertion_macros/raises_kind_of_test.rb
 - test/core/assertion_macros/raises_test.rb
 - test/core/assertion_macros/respond_to_test.rb

data/lib/riot/assertion_macros/not_borat.rb

@@ -1,32 +0,0 @@
-module Riot
-  # Asserts the result of the test is a non-truthy value. Read the following assertions in the way Borat
-  # learned about humor:
-  #
-  #   asserts("you are funny") { false }.not!
-  #   should("be funny") { nil }.not!
-  #
-  # Thusly, Borat would say "You are funny ... not!" The above two assertions would pass because the values
-  # are non-truthy.
-  #
-  # You can also apply not to the negative assertion (denies), but I'm not sure how much sense it would make.
-  # It would be kind of like a double negative:
-  #
-  #   denies("you are funny") { true }.not!
-  #
-  # @deprecated Please use the denies assertion instead
-  class NotMacro < AssertionMacro
-    register :not!
-
-    # (see Riot::AssertionMacro#evaluate)
-    def evaluate(actual)
-      warn "not! is deprecated; please use the denies assertion instead"
-      actual ? fail("expected to exist ... not!") : pass("does exist ... not!")
-    end
-    
-    # (see Riot::AssertionMacro#devaluate)
-    def devaluate(actual)
-      warn "not! is deprecated; please use the denies assertion instead"
-      actual ? pass("does not exist ... not!") : fail("expected to not exist ... not!")
-    end
-  end
-end

data/test/core/assertion_macros/not_borat_test.rb

@@ -1,21 +0,0 @@
-require 'teststrap'
-
-context "A not! assertion macro" do
-  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_fails("when value is not nil or false", "expected to exist ... not!") do
-    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