riot 0.10.13 → 0.11.0

data/CHANGELOG

@@ -1,3 +1,58 @@
+*0.11.0*
+
+* Added option to Context#setup which puts the specific setup block at the beginning of the setups to be called for a context. Also useful for middlewares. [jaknowlden]
+
+    context "Foo" do
+      setup { puts "called second" }
+      setup { puts "called third" }
+      setup(true) { puts "called first" }
+    end # Foo
+
+* Added idea of options for a context. This is another feature picked up from riot-rails work. [jaknowlden]
+
+Essentially, these are useful for middlewares. For instance, if you wanted to tell a middleware that was looking for a "transactional" option before running code in a transaction block, you might do this:
+
+    context User do
+      set :transactional, true
+    end # User
+
+The middleware might do something with it:
+
+    class TransactionalMiddleware < Riot::ContextMiddleware
+      register
+
+      def handle?(context) context.option(:transactional) == true; end
+
+      def prepare(context)
+        # transactional stuff
+      end
+    end # TransactionalMiddleware
+
+You can call set as many times as you like
+
+    context User do
+      set :transactional, true
+      set :foo, :bar
+    end
+
+* ContextMiddleware: a construction pattern that allows for custom code to be applied to any context given that the middleware chooses to. This is something I started building into riot-rails and decided it was useful enough to just put it into riot itself. [jaknowlden]
+
+If, for instance, you wanted to add a setup with some stuff only if the context description was equal to "Your Mom":
+
+    class YourMomMiddleware < Riot::ContextMiddleware
+      register
+
+      def handle?(context)
+        context.description == "Your Mom"
+      end
+
+      def prepare(context)
+        context.setup do
+          "your mom is the topic"
+        end
+      end
+    end # YourMomMiddleware
+
 *0.10.13*
 
 * Helpers are now run with other setups, not separately. Which means you could use a helper in a setup. [jaknowlden]

data/VERSION

@@ -1 +1 @@
-0.10.13
+0.11.0

data/lib/riot/context.rb

@@ -1,15 +1,62 @@
 module Riot
   RootContext = Struct.new(:setups, :teardowns, :detailed_description)
 
-  module ContextHelpers
+  class ContextMiddleware
+    # Registers the current middleware class with Riot so that it may be included in the set of middlewares
+    # Riot will poke before executing a Context.
+    #
+    #   class MyContextMiddleware < Riot::ContextMiddleware
+    #     register
+    #     def handle?(context); ...; end
+    #     def prepare(context); ...; end
+    #   end
+    def self.register; Context.middlewares << self.new; end
+
+    # Called prior to a Context being executed. If this method returns true, +call+ will be called. This
+    # methods expects to receive an instance of the Context to be executed. Generally, you will inspect
+    # various aspects of the Context to determine if this middleware is meant to be used.
+    def handle?(context); false; end
+
+    # The meat of the middleware. Because you have access to the Context, you can add your own setups,
+    # hookups, etc. +call+ will be called before any tests are run, but after the Context is configured.
+    def call(context); end
+  end
+
+  module ContextClassOverrides
     def assertion_class; Assertion; end
     def situation_class; Situation; end
   end
 
-  # You make your assertions within a Context. The context stores setup and
-  # teardown blocks, and allows for nesting and refactoring into helpers.
+  module ContextOptions
+    # Set options for the specific context. These options will generally be used for context middleware.
+    # Riot::Context does not currently look at any options.
+    #
+    #   context "Foo" do
+    #     set :transactional, true
+    #   end
+    def set(key, value) options[key] = value; end
+
+    # Returns the value of a set option. The key must match exactly, symbols and strings are not
+    # interchangeable.
+    #
+    # @return [Object]
+    def option(key) options[key]; end
+  private
+    def options; @options ||= {}; end
+  end
+
+  # You make your assertions within a Context. The context stores setup and teardown blocks, and allows for
+  # nesting and refactoring into helpers. Extension developers may also configure ContextMiddleware objects
+  # in order to extend the functionality of a Context.
   class Context
-    include ContextHelpers
+    include ContextClassOverrides
+    include ContextOptions
+
+    # The set of middleware helpers configured for the current test space.
+    #
+    # @return [Array]
+    def self.middlewares; @middlewares ||= []; end
+
     # The description of the context.
     #
     # @return [String]
@@ -25,6 +72,7 @@ module Riot
       @description = description
       @contexts, @setups, @assertions, @teardowns = [], [], [], []
       self.instance_eval(&definition)
+      prepare_middleware
     end
 
     # Create a new test context.
@@ -33,7 +81,7 @@ module Riot
     def context(description, &definition)
       new_context(description, self.class, &definition)
     end
-    
+
     # Returns an ordered list of the setup blocks for the context.
     #
     # @return [Array[Riot::RunnableBlock]]
@@ -58,8 +106,13 @@ module Riot
     #     setup { topic * 2 }
     #     asserts(:length).equals(6)
     #   end
-    def setup(&definition)
-      (@setups << Setup.new(&definition)).last
+    #
+    # If you provide +true+ as the first argument, the setup will be unshifted onto the list of setups,
+    # ensuring it will be run before any other setups. This is really only useful for context middlewares.
+    def setup(premium=false, &definition)
+      setup = Setup.new(&definition)
+      premium ? @setups.unshift(setup) : @setups.push(setup)
+      setup
     end
 
     # Helpers are essentially methods accessible within a situation.
@@ -90,7 +143,9 @@ module Riot
       setup { self.instance_eval(&definition); topic }
     end
 
-    # Add a teardown block.
+    # Add a teardown block. You may define multiple of these as well.
+    #
+    #  teardown { Bombs.drop! }
     def teardown(&definition)
       (@teardowns << Setup.new(&definition)).last
     end
@@ -113,11 +168,17 @@ module Riot
     # Passing a Symbol to +asserts+ enables this behaviour. For more information on
     # assertion macros, see {Riot::AssertionMacro}.
     #
-    # @param [String, Symbol] what the property being tested
+    # @param [String, Symbol] the property being tested
     def asserts(what, &definition)
       new_assertion("asserts", what, &definition)
     end
 
+    # Same as #asserts, except it uses the phrase "should" in the report output. Sometimes you feel like a
+    # nut, sometimes you don't.
+    #
+    #   should("ensure expected") { "bar" }.equals("bar")
+    #
+    # @param [String, Symbol] the property being tested
     def should(what, &definition)
       new_assertion("should", what, &definition)
     end
@@ -146,6 +207,10 @@ module Riot
 
   private
 
+    def prepare_middleware
+      Context.middlewares.each { |middleware| middleware.call(self) if middleware.handle?(self) }
+    end
+
     def runnables
       setups + @assertions + teardowns
     end

data/riot.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot}
-  s.version = "0.10.13"
+  s.version = "0.11.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2010-03-01}
+  s.date = %q{2010-05-17}
   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 = [
@@ -70,7 +70,9 @@ Gem::Specification.new do |s|
      "test/core/assertion_macros/same_elements_test.rb",
      "test/core/assertion_macros/size_test.rb",
      "test/core/assertion_test.rb",
+     "test/core/context_middleware_test.rb",
      "test/core/context_test.rb",
+     "test/core/context_with_options_test.rb",
      "test/core/message_test.rb",
      "test/core/report_test.rb",
      "test/core/setup_test.rb",
@@ -82,7 +84,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/thumblemonks/riot}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.}
   s.test_files = [
     "test/benchmark/colorize.rb",
@@ -107,7 +109,9 @@ Gem::Specification.new do |s|
      "test/core/assertion_macros/same_elements_test.rb",
      "test/core/assertion_macros/size_test.rb",
      "test/core/assertion_test.rb",
+     "test/core/context_middleware_test.rb",
      "test/core/context_test.rb",
+     "test/core/context_with_options_test.rb",
      "test/core/message_test.rb",
      "test/core/report_test.rb",
      "test/core/setup_test.rb",

data/test/core/context_middleware_test.rb

@@ -0,0 +1,90 @@
+require 'teststrap'
+
+context "ContextMiddleware" do
+  setup { Riot::ContextMiddleware.new }
+  teardown { Riot::Context.middlewares.clear }
+
+  asserts("handle? with context") { topic.handle?("Foo") }.equals(false)
+  asserts("call with context") { topic.call("Foo") }.nil
+
+  context "registration" do
+    setup { Class.new(Riot::ContextMiddleware) { register } }
+    asserts("registered middlewares list") { Riot::Context.middlewares }.size(1)
+    asserts("registered middleware") { Riot::Context.middlewares.first }.kind_of(Riot::ContextMiddleware)
+  end # registration
+
+  context "that is not meant to be used" do
+    hookup do
+      Class.new(Riot::ContextMiddleware) do
+        register
+        def handle?(context) context.description == "Bar"; end
+        def call(context) context.setup { "fooberries" }; end
+      end
+    end
+
+    setup do
+      Riot::Context.new("Foo") { asserts_topic.nil }.run(MockReporter.new)
+    end
+
+    asserts("tests passed") { topic.passes }.equals(1)
+  end # that is not meant to be used
+
+  context "that is meant to be used" do
+    hookup do
+      Class.new(Riot::ContextMiddleware) do
+        register
+        def handle?(context); true; end
+        def call(context) context.setup { "fooberries" }; end
+      end
+    end
+
+    setup do
+      Riot::Context.new("Foo") { asserts_topic.equals("fooberries") }.run(MockReporter.new)
+    end
+
+    asserts("tests passed") { topic.passes }.equals(1)
+  end # that is meant to be used
+
+  context "applied in multiples" do
+    hookup do
+      Class.new(Riot::ContextMiddleware) do
+        register
+        def handle?(context); true; end
+        def call(context) context.setup { "foo" }; end
+      end
+    end
+
+    hookup do
+      Class.new(Riot::ContextMiddleware) do
+        register
+        def handle?(context); true; end
+        def call(context) context.setup { topic + "berries" }; end
+      end
+    end
+
+    setup do
+      Riot::Context.new("Foo") { asserts_topic.equals("fooberries") }.run(MockReporter.new)
+    end
+
+    asserts("tests passed") { topic.passes }.equals(1)
+  end # that are not exclusive
+
+  context "has access to options" do
+    hookup do
+      Class.new(Riot::ContextMiddleware) do
+        register
+        def handle?(context); context.option(:foo) == "bar"; end
+        def call(context) context.setup { "fooberries" }; end
+      end
+    end
+
+    setup do
+      Riot::Context.new("Foo") do
+        set :foo, "bar"
+        asserts_topic.equals("fooberries")
+      end.run(MockReporter.new)
+    end
+
+    asserts("tests passed") { topic.passes }.equals(1)
+  end # has access to options
+end # ContextMiddleware

data/test/core/context_test.rb

@@ -124,13 +124,25 @@ context "A context with a helper" do
   asserts("calling a helper with an argument") { append("bar") }.equals("foobar")
 end
 
+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
+
+class SingletonArray
+  def self.<<(value); values << value; end
+  def self.values; @@values ||= []; end
+end
 
-context "A context with a description" do
-  Foo, Bar = Class.new {}, Class.new {}
+context "A context with premium_setup" do
   setup do
-    Riot::Context.new(Foo) {}.context(Bar) {}
+    Riot::Context.new("Foo") do
+      setup { SingletonArray << "baz" }
+      setup(true) { SingletonArray << "bar" }
+      setup(true) { SingletonArray << "foo" }
+    end.run(MockReporter.new)
   end
 
-  asserts(:description).equals(Bar)
-  asserts(:detailed_description).equals("Foo Bar")
+  asserts("order of setups ensures topic") { SingletonArray.values }.equals(%w[foo bar baz])
 end

data/test/core/context_with_options_test.rb

@@ -0,0 +1,16 @@
+require 'teststrap'
+
+context "Context with options" do
+  setup do
+    Riot::Context.new("Foo") do
+      set :foo, "bar"
+      set "bar", 2
+    end
+  end
+
+  asserts_topic.responds_to(:option)
+
+  asserts("option :foo") { topic.option(:foo) }.equals("bar")
+  asserts("option \"foo\"") { topic.option("foo") }.nil
+  asserts("option \"bar\"") { topic.option("bar") }.equals(2)
+end # Context with options

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: riot
 version: !ruby/object:Gem::Version 
-  version: 0.10.13
+  prerelease: false
+  segments: 
+  - 0
+  - 11
+  - 0
+  version: 0.11.0
 platform: ruby
 authors: 
 - Justin 'Gus' Knowlden
@@ -9,29 +14,33 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-01 00:00:00 -06:00
+date: 2010-05-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rr
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: term-ansicolor
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks. Protest the slow test.
 email: gus@gusg.us
 executables: []
@@ -95,7 +104,9 @@ files:
 - test/core/assertion_macros/same_elements_test.rb
 - test/core/assertion_macros/size_test.rb
 - test/core/assertion_test.rb
+- test/core/context_middleware_test.rb
 - test/core/context_test.rb
+- test/core/context_with_options_test.rb
 - test/core/message_test.rb
 - test/core/report_test.rb
 - test/core/setup_test.rb
@@ -116,18 +127,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.
@@ -154,7 +167,9 @@ test_files:
 - test/core/assertion_macros/same_elements_test.rb
 - test/core/assertion_macros/size_test.rb
 - test/core/assertion_test.rb
+- test/core/context_middleware_test.rb
 - test/core/context_test.rb
+- test/core/context_with_options_test.rb
 - test/core/message_test.rb
 - test/core/report_test.rb
 - test/core/setup_test.rb