riot-gear 0.0.9 → 0.0.10

data/.gitignore

@@ -7,4 +7,5 @@ pkg/*
 .watchr
 .yardoc
 Gemfile.lock
+*.gem
 

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+before_install:
+  - gem update --system
+  - gem --version
+bundler_args: --without development
+rvm:
+  - 1.9.3
+  - 2.0.0
+

data/CHANGELOG

@@ -1,5 +1,27 @@
 # @markup markdown
 
+# 0.0.10
+
+* Defines a new setup block called `once`. Useful for running a single block before assertions, but only inside the context it was defined in [jaknowlden]
+
+```ruby
+context ThingsMaker do
+  once do
+    topic.post "/things/make", :query => { :name => "Jacques" }
+  end
+
+  format :json
+  get "/things/1"
+
+  asserts_json("name").equals("Jacques")
+
+  context "makes no more things" do
+    get "/things/2"
+    asserts_status(404) # becuase the post didn't run again ... see ... yeah
+  end
+end
+```
+
 # 0.0.9
 
 * get, post, put, delete can have responses saved for use in other requests within the same (or nested) context [jaknowlden]

data/Gemfile

@@ -4,6 +4,6 @@ gemspec
 
 group "test" do
   gem "rake", ">=0.8.7"
-  gem "webmock", ">=1.6.1"
+  gem "webmock", ">=1.15.0"
 end
 

data/lib/riot/gear/context/once.rb

@@ -0,0 +1,42 @@
+class Riot::Gear::OnceRunnable < Riot::RunnableBlock
+  def initialize(description, &definition)
+    super("[once] #{description}", &definition)
+    @ran = false
+  end
+
+  # Applies the provided +&definition+ to the +situation+. But, it only
+  # does so once.
+  #
+  # @param [Riot::Situation] situation An instance of a {Riot::Situation}
+  # @return [Array<Symbol>]
+  def run(situation)
+    if @ran
+      [:once_ignored]
+    else
+      @ran = true
+      situation.evaluate(&definition)
+      [:once]
+    end
+  end
+end
+
+module Riot::Gear::OnceContextHelper
+  # A setup helper that will only run once and only in the context it
+  # was defined in. This will not be run in any of its sub-contexts
+  # and it will run before any assertions ... the same as any other
+  # setup block.
+  #
+  #   once "doing this one thing" do
+  #     topic.post "/user/things", :query => {"name" => "x"}
+  #   end
+  #
+  # @param [String] description A description of what the block is for
+  # @param [lambda] &definition The block that will be executed once
+  # @return [Riot::Gear::OnceRunnable]
+  def once(description="", &definition)
+    @setups << Riot::Gear::OnceRunnable.new(description, &definition)
+  end
+end
+
+Riot::Context.instance_eval { include Riot::Gear::OnceContextHelper }
+

data/lib/riot/gear/context.rb

@@ -1,3 +1,4 @@
+require 'riot/gear/context/once'
 require 'riot/gear/context/persist_cookie'
 require 'riot/gear/context/asserts_status'
 require 'riot/gear/context/asserts_header'

data/lib/riot/gear/middleware/riotparty.rb

@@ -1,173 +1,172 @@
 require 'httparty'
 
-module Riot
-  module Gear
-    # Here we prepare a {Riot::Context} to have HTTParty bound to it. Basically, this means that you can
-    # use HTTParty within a context the same way you would inside any class or you would normally use it in.
-    # Anything you can do with HTTParty, you can do within a context ... and then you can test it :)
-    #
-    # Great pains are made to ensure that the HTTParty setup bound to one context does not interfere setup 
-    # bound to another context.
-    class RiotPartyMiddleware < ::Riot::ContextMiddleware
-      register
+# Here we prepare a {Riot::Context} to have HTTParty bound to it. Basically, this means that you can
+# use HTTParty within a context the same way you would inside any class or you would normally use it in.
+# Anything you can do with HTTParty, you can do within a context ... and then you can test it :)
+#
+# Great pains are made to ensure that the HTTParty setup bound to one context does not interfere setup 
+# bound to another context.
+class Riot::Gear::RiotPartyMiddleware < ::Riot::ContextMiddleware
+  register
 
-      # Prepares the context for HTTParty support.
-      #
-      # @param [Riot::Context] context the context to prepare
-      def call(context)
-        setup_faux_class(context)
-        setup_helpers(context)
-        proxy_action_methods(context)
-        proxy_httparty_hookups(context)
-        middleware.call(context)
-      end
-
-    private
+  # Prepares the context for HTTParty support.
+  #
+  # @param [Riot::Context] context the context to prepare
+  def call(context)
+    setup_faux_class(context)
+    setup_helpers(context)
+    proxy_action_methods(context)
+    proxy_httparty_hookups(context)
+    middleware.call(context)
+  end
 
-      # Only cluttering anonymous classes with HTTParty stuff. Keeps each context safe from collision ... in
-      # theory.
-      #
-      # @param [Riot::Context] context the context to create the setup for
-      # @todo Fix this so that settings like +base_uri+ can be inherited
-      def setup_faux_class(context)
-        context.setup(true) do
-          @saved_responses = {}
+private
 
-          Class.new do
-            include HTTParty
-            # debug_output $stderr
-          end
-        end
+  # Only cluttering anonymous classes with HTTParty stuff. Keeps each context safe from collision ... in
+  # theory.
+  #
+  # @param [Riot::Context] context the context to create the setup for
+  # @todo Fix this so that settings like +base_uri+ can be inherited
+  def setup_faux_class(context)
+    context.setup(true) do
+      if topic
+        topic
+      else
+        @saved_responses = {}
+        Class.new { include HTTParty }
+      end
+    end
 
-        context.helper(:response) do |name=nil|
-          @saved_responses[name] || @smoke_response
-        end
-      end # setup_faux_class
+    context.helper(:response) do |name=nil|
+      @saved_responses[name] || @smoke_response
+    end
+  end # setup_faux_class
 
-      # Returns the list of methods that do something; like make a network call.
-      #
-      # @return [Array<Symbol>]
-      def actionable_methods; [:get, :post, :put, :delete, :head]; end
+  # Returns the list of methods that do something; like make a network call.
+  #
+  # @return [Array<Symbol>]
+  def actionable_methods; [:get, :post, :put, :delete, :head]; end
 
-      # Returns the list of methods that configure actionable HTTParty methods. The {HTTParty.options} and
-      # {HTTParty.default_options} methods are explicitly excluded from this list
-      #
-      # @return [Array<Symbol>]
-      def proxiable_methods
-        methods = HTTParty::ClassMethods.instance_methods.map { |m| m.to_s.to_sym }
-        methods - actionable_methods - [:options, :default_options]
-      end
+  # Returns the list of methods that configure actionable HTTParty methods. The {HTTParty.options} and
+  # {HTTParty.default_options} methods are explicitly excluded from this list
+  #
+  # @return [Array<Symbol>]
+  def proxiable_methods
+    methods = HTTParty::ClassMethods.instance_methods.map { |m| m.to_s.to_sym }
+    methods - actionable_methods - [:options, :default_options]
+  end
 
-      # Bind the set of actionable methods to a given context.
-      #
-      # Basically, we're just passing standard HTTParty setup methods onto situation via hookups. These
-      # hookups - so long as the topic hasn't changed yet - are bound to an anonymous class that has
-      # HTTParty included to it. Meaning, this is how you call get, post, put, delete from within a
-      # test.
-      #
-      # There are couple of different forms for these actions. As you would expect, there's:
-      #
-      #   get "/path", :query => {...}, ...
-      #
-      # But you can also record the response for use later in the test:
-      #
-      #   post(:new_thing) do
-      #     { :path => "/things", :body => ... }
-      #   end
-      #
-      #   get do # this response will be used for assertions since it's last
-      #     { :path => "/things/#{response(:new_thing).id}/settings" }
-      #   end
-      #
-      # @param [Riot::Context] context the context to add the helper to
-      def proxy_action_methods(context)
-        context_eigen = (class << context; self; end)
-        actionable_methods.each do |method_name|
-          context_eigen.__send__(:define_method, method_name) do |*args, &settings_block|
-            hookup do
-              if settings_block
-                name = args.first
-                options = instance_eval(&settings_block)
-                path = options.delete(:path) || "/"
-              else
-                name = nil
-                path, options = *args
-              end
-              result = topic.__send__(method_name, path, options || {})
-              @saved_responses[name] = result
-              @smoke_response = result # TODO remove this after it's certain no usages in the wild
-            end
+  # Bind the set of actionable methods to a given context.
+  #
+  # Basically, we're just passing standard HTTParty setup methods onto situation via hookups. These
+  # hookups - so long as the topic hasn't changed yet - are bound to an anonymous class that has
+  # HTTParty included to it. Meaning, this is how you call get, post, put, delete from within a
+  # test.
+  #
+  # There are couple of different forms for these actions. As you would expect, there's:
+  #
+  #   get "/path", :query => {...}, ...
+  #
+  # But you can also record the response for use later in the test:
+  #
+  #   post(:new_thing) do
+  #     { :path => "/things", :body => ... }
+  #   end
+  #
+  #   get do # this response will be used for assertions since it's last
+  #     { :path => "/things/#{response(:new_thing).id}/settings" }
+  #   end
+  #
+  # @param [Riot::Context] context the context to add the helper to
+  def proxy_action_methods(context)
+    context_eigen = (class << context; self; end)
+    actionable_methods.each do |method_name|
+      context_eigen.__send__(:define_method, method_name) do |*args, &settings_block|
+        hookup do
+          if settings_block
+            name = args.first
+            options = instance_eval(&settings_block)
+            path = options.delete(:path) || "/"
+          else
+            name = nil
+            path, options = *args
           end
-        end # methods.each
+          #debug_start = Time.now
+          result = topic.__send__(method_name, path, options || {})
+          #puts "TIME #{(Time.now - debug_start) * 1000.0}ms #{topic.base_uri}#{path}"
+          @saved_responses[name] = result
+          @smoke_response = result # TODO remove this after it's certain no usages in the wild
+        end
       end
+    end # methods.each
+  end
 
-      # Bind the set of proxiable (non-action) methods to a given context.
-      #
-      # @param [Riot::Context] context the context to add the helper to
-      def proxy_httparty_hookups(context)
-        context_eigen = (class << context; self; end)
-        proxiable_methods.each do |method_name|
-          context_eigen.__send__(:define_method, method_name) do |*args|
-            hookup { topic.__send__(method_name, *args) }
-          end
-        end # methods.each
+  # Bind the set of proxiable (non-action) methods to a given context.
+  #
+  # @param [Riot::Context] context the context to add the helper to
+  def proxy_httparty_hookups(context)
+    context_eigen = (class << context; self; end)
+    proxiable_methods.each do |method_name|
+      context_eigen.__send__(:define_method, method_name) do |*args|
+        hookup { topic.__send__(method_name, *args) }
       end
+    end # methods.each
+  end
 
-      #
-      # Helpful helpers
+  #
+  # Helpful helpers
 
-      def setup_helpers(context)
-        helper_json_path(context)
-        helper_cookie_value(context)
-      end
+  def setup_helpers(context)
+    helper_json_path(context)
+    helper_cookie_value(context)
+  end
 
-      # Maps a JSON string to a Hash tree. For instance, give this hash:
-      #
-      #     json_object = {"a" => {"b" => {"c" => {"d" => "foo"}}}}
-      #
-      # You could retrieve the value of 'd' via JSON notation in any of the following ways:
-      #
-      #     json_path(json_object, "a.b.c.d")
-      #     => "foo"
-      #     json_path(json_object, "a['b'].c['d']")
-      #     => "foo"
-      #
-      # You can even work with array indexes
-      #
-      #     json_object = {"a" => {"b" => "c" => ["foo", {"d" => "bar"}]}}
-      #     json_path(json_object, "a[b].c[1].d")
-      #     => "bar"
-      #
-      # @param [Riot::Context] context the context to add the helper to
-      def helper_json_path(context)
-        context.helper(:json_path) do |dictionary, path|
-          return nil if path.to_s.empty?
-          path.scan(/[^\[\].'"]+/).inject(dictionary) do |dict,key|
-            dict[key =~ /^\d+$/ ? key.to_i : key.strip]
-          end
-        end
+  # Maps a JSON string to a Hash tree. For instance, give this hash:
+  #
+  #     json_object = {"a" => {"b" => {"c" => {"d" => "foo"}}}}
+  #
+  # You could retrieve the value of 'd' via JSON notation in any of the following ways:
+  #
+  #     json_path(json_object, "a.b.c.d")
+  #     => "foo"
+  #     json_path(json_object, "a['b'].c['d']")
+  #     => "foo"
+  #
+  # You can even work with array indexes
+  #
+  #     json_object = {"a" => {"b" => "c" => ["foo", {"d" => "bar"}]}}
+  #     json_path(json_object, "a[b].c[1].d")
+  #     => "bar"
+  #
+  # @param [Riot::Context] context the context to add the helper to
+  def helper_json_path(context)
+    context.helper(:json_path) do |dictionary, path|
+      return nil if path.to_s.empty?
+      path.scan(/[^\[\].'"]+/).inject(dictionary) do |dict,key|
+        dict[key =~ /^\d+$/ ? key.to_i : key.strip]
       end
+    end
+  end
 
-      # Splits up the cookies found in the Set-Cookie header. I'm sure I could use HTTParty for this somehow,
-      # but this seemed just as straightforward. You will get back a hash of the
-      # {cookie-name => cookie-bits} pairs
-      #
-      #     {
-      #       "session_cookie" => {"value => "fooberries", "path" => "/", ...},
-      #       "stupid_marketing_tricks" => {"value" => "personal-information", ...},
-      #       ...
-      #     }
-      #
-      # @param [Riot::Context] context the context to add the helper to
-      def helper_cookie_value(context)
-        context.helper(:cookie_values) do
-          response.header["set-cookie"].split("\n").inject({}) do |jar, cookie_str|
-            (name, value), *bits = cookie_str.split(/; ?/).map { |bit| bit.split('=') }
-            jar.merge!(name => bits.inject({"value" => value}) { |h, (k,v)| h.merge!(k => v) })
-          end
-        end
+  # Splits up the cookies found in the Set-Cookie header. I'm sure I could use HTTParty for this somehow,
+  # but this seemed just as straightforward. You will get back a hash of the
+  # {cookie-name => cookie-bits} pairs
+  #
+  #     {
+  #       "session_cookie" => {"value => "fooberries", "path" => "/", ...},
+  #       "stupid_marketing_tricks" => {"value" => "personal-information", ...},
+  #       ...
+  #     }
+  #
+  # @param [Riot::Context] context the context to add the helper to
+  def helper_cookie_value(context)
+    context.helper(:cookie_values) do
+      response.header["set-cookie"].split("\n").inject({}) do |jar, cookie_str|
+        (name, value), *bits = cookie_str.split(/; ?/).map { |bit| bit.split('=') }
+        jar.merge!(name => bits.inject({"value" => value}) { |h, (k,v)| h.merge!(k => v) })
       end
+    end
+  end
+
+end # Riot::Gear::RiotPartyMiddleware
 
-    end # Middleware
-  end # Gear
-end # Riot

data/lib/riot/gear/middleware.rb

@@ -1 +1,2 @@
-require 'riot/gear/middleware/riotparty'
+require 'riot/gear/middleware/riotparty'
+

data/lib/riot/gear/version.rb

@@ -1,6 +1,6 @@
 module Riot
   module Gear
-    VERSION = "0.0.9"
+    VERSION = "0.0.10"
   end
 end
 

data/lib/riot/gear.rb

@@ -1,3 +1,8 @@
 require 'riot'
+
+module Riot
+  module Gear; end
+end
+
 require 'riot/gear/context'
 require 'riot/gear/middleware'

data/riot-gear.gemspec

@@ -13,9 +13,9 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n") 
   s.homepage      = %q{http://github.com/thumblemonks/riot-gear}
   s.require_paths = ["lib"]
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
 
-  s.add_dependency 'riot', '>=0.12.5'
-  s.add_dependency 'httparty', '>=0.6.0'
+  s.add_dependency 'riot', '>=0.12.6'
+  s.add_dependency 'httparty', '>=0.12.0'
 end
 

data/test/once_block_test.rb

@@ -0,0 +1,21 @@
+require 'teststrap'
+
+context "[Context] A once block:" do
+  once do
+    @instance_var_x = "foo"
+  end
+
+  asserts("var x defined in same context as once block") { @instance_var_x }.equals("foo")
+
+  context "inner-context A" do
+    asserts("var x defined in out context") { @instance_var_x }.nil
+    asserts("var y defined in once block from this context") { @instance_var_y }.equals("bar")
+
+    # defining this below the asserts just for fun, to make sure it
+    # is eval'ed before the asserts are run
+    once do
+      @instance_var_y = "bar"
+    end
+  end
+end
+

data/test/riotparty_proxy_methods_test.rb

@@ -74,10 +74,13 @@ context "A Riot Gear context" do
   end.raises(HTTParty::UnsupportedFormat, "':json' Must be one of: nothing")
 
   context "with a custom parser that supports a provided format" do
-    parser(OpenStruct.new(:supports_format? => true))
+    HappyPartyParser = Class.new do
+      def supports_format?(fmt) true; end
+    end
 
+    parser(HappyPartyParser.new)
     setup { topic.default_options[:parser] }
-    asserts_topic.kind_of(OpenStruct)
+    asserts_topic.kind_of(HappyPartyParser)
   end # with a custom parser that supports a provided format
 
   default_timeout 100000

data/test/teststrap.rb

@@ -3,6 +3,7 @@ require 'pathname'
 $:.unshift((Pathname(__FILE__).dirname + ".." + "lib").to_s)
 
 require 'rubygems'
+require 'bundler/setup'
 require 'json'
 require 'riot'
 require 'webmock'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riot-gear
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-17 00:00:00.000000000 Z
+date: 2013-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: riot
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.5
+        version: 0.12.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.5
+        version: 0.12.6
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.12.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.12.0
 description: Riot + HTTParty smoke testing framework. You'd use it for integration
   testing with real HTTP requests and responses
 email: gus@gusg.us
@@ -51,6 +51,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - .yardopts
 - CHANGELOG
 - Gemfile
@@ -62,6 +63,7 @@ files:
 - lib/riot/gear/context/asserts_header.rb
 - lib/riot/gear/context/asserts_json.rb
 - lib/riot/gear/context/asserts_status.rb
+- lib/riot/gear/context/once.rb
 - lib/riot/gear/context/persist_cookie.rb
 - lib/riot/gear/middleware.rb
 - lib/riot/gear/middleware/riotparty.rb
@@ -74,6 +76,7 @@ files:
 - test/assertions/asserts_json_test.rb
 - test/helpers/cookie_values_test.rb
 - test/helpers/json_path_test.rb
+- test/once_block_test.rb
 - test/riotparty_proxy_methods_test.rb
 - test/setting_up_gear_context_test.rb
 - test/teststrap.rb
@@ -109,6 +112,7 @@ test_files:
 - test/assertions/asserts_json_test.rb
 - test/helpers/cookie_values_test.rb
 - test/helpers/json_path_test.rb
+- test/once_block_test.rb
 - test/riotparty_proxy_methods_test.rb
 - test/setting_up_gear_context_test.rb
 - test/teststrap.rb