hyperion_http 0.1.9 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7d9226a915406ce7fd02411a0d43d091de54dbb
-  data.tar.gz: ff9b70e966564c62dcfb54c49e39430b8480d77a
+  metadata.gz: 960780555d961a067c45dd406b4a77c222d3b870
+  data.tar.gz: a9ccdfa4d464305cd35d4d79bc392760bd393327
 SHA512:
-  metadata.gz: bf64df0e49481f580f66f65c7100fff0fe44784f56148fc828e64a235ac754cb3d328bf3134a47cf277055efe44112b38d3062cfb0158b96f9f3a8604acec585
-  data.tar.gz: f4db46cdf9980be0695142c9a88749e80919574265b49db3375b2398f24b29362ad8c1e2a503c33fb778e98e4e432962b6ddaf9376b6ef4208fcf0ec78e3f6e0
+  metadata.gz: f67e72757677c9f6c10f088d9c6965436a6442ffe93dc65e42a5654ac525f1545551693aaefd34c9f157881cbb25331caba370fe9eccae671d21332123f01b12
+  data.tar.gz: 1389a2fd6cc8d60fbfa0269eeb087aed6edc86790cd6ecdab6475ff9cd530aae489833ee08156571e2ecc7605d0a4abc6f33943c514e4320510e597f6fa3fcfc

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
-  - 2.0.0-p247
+  - 2.2.2
 branches:
   only:
     - master

data/CHANGES.md

@@ -1,3 +1,7 @@
+## [0.2.0](https://github.com/indigobio/hyperion/compare/v0.1.9...indigobio:v0.2.0) (2016-9-15)
+
+- eliminate Mimic dependency to resolve conflicts in code that uses hyperion
+
 ## [0.1.7](https://github.com/indigobio/hyperion/compare/v0.1.6...indigobio:v0.1.7) (2015-12-14)
 
 - fake_route now works with multipart body
@@ -390,4 +394,4 @@
   it's shutting down, resulting in a timeout.
 
 ### 0.1.2
-- Fixed broken gemspec version for abstractivator
+- Fixed broken gemspec version for abstractivator

data/hyperion.gemspec

@@ -0,0 +1 @@
+hyperion_http.gemspec

data/hyperion_http.gemspec

@@ -1,11 +1,10 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'hyperion/aux/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'hyperion_http'
-  spec.version       = Hyperion::VERSION
+  spec.version       = '0.2.1'
   spec.authors       = ['Indigo BioAutomation, Inc.']
   spec.email         = ['pwinton@indigobio.com']
   spec.summary       = 'Ruby REST client'
@@ -30,6 +29,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'immutable_struct', '~> 1.1'
   spec.add_runtime_dependency 'oj', '~> 2.12'
   spec.add_runtime_dependency 'typhoeus', '~> 0.7'
-  spec.add_runtime_dependency 'mimic', '0.4.3' # pin because 0.4.4 breaks tests
+  spec.add_runtime_dependency 'rack'
   spec.add_runtime_dependency 'logatron'
 end

data/lib/hyperion/aux/logger.rb

@@ -19,8 +19,7 @@ class Hyperion
     end
 
     def log_stub(rule)
-      mr = rule.mimic_route
-      logger.debug "Stubbed #{mr.method.to_s.upcase} #{mr.path}"
+      logger.debug "Stubbed #{rule.method.to_s.upcase} #{rule.path}"
       log_headers(rule.headers, logger)
     end
 

data/lib/hyperion_test/fake.rb

@@ -1,5 +1,4 @@
 require 'immutable_struct'
-require 'mimic'
 require 'hyperion/headers'
 require 'hyperion/formats'
 require 'uri'
@@ -7,27 +6,37 @@ require 'hyperion_test/fake_server'
 
 class Hyperion
   class << self
-    # maintains a collection of fake servers, one for each base_uri.
-    # manages rspec integration for automatic teardown after each test.
+    # Maintains a collection of fake servers, one for each base_uri.
+    # Manages rspec integration for automatic teardown after each test.
 
     include Formats
     include Headers
     include TestFrameworkHooks
     include Logger
 
+    # Configure routes on the server for the given base_uri
     def fake(base_uri, &routes)
       base_uri = normalized_base(base_uri)
-      if !@running
-        hook_teardown if can_hook_teardown? && !teardown_registered?
-        @running = true
+      unless @configured
+        hook_reset if can_hook_reset? && !reset_registered?
+        @configured = true
       end
       servers[base_uri].configure(&routes)
     end
 
-    def teardown
+    # Clear routes but don't stop servers. Meant to be called between tests.
+    # Starting/stopping servers is relatively slow. They can be reused.
+    def reset
+      servers.values.each(&:clear_routes)
+      @configured = false
+    end
+
+    # Stop all servers. This should only need to be called by tests that use
+    # Kim directly (like kim_spec.rb).
+    def teardown_cached_servers
       servers.values.each(&:teardown)
       servers.clear
-      @running = false
+      @configured = false
     end
 
     private

data/lib/hyperion_test/fake_server.rb

@@ -1,54 +1,86 @@
 require 'hyperion_test/test_framework_hooks'
 require 'hyperion/aux/hash_ext'
-require 'hyperion_test/fake_server/dispatcher'
+require 'hyperion/headers'
+require 'hyperion/formats'
 require 'hyperion_test/fake_server/types'
 require 'hyperion_test/fake_server/config'
+require 'hyperion_test/kim'
+require 'hyperion_test/kim/matchers'
 
 class Hyperion
   class FakeServer
-    # Runs a Mimic server configured per the specified routing rules.
-    # Restarts the server when the rules change.
-    # The server must be restarted because it runs in a forked process
-    # and it is easier to kill it than try to communicate with it.
+    # Runs a Kim server configured per the specified routing rules.
+    include Kim::Matchers
+    include Headers
+    include Formats
 
-    attr_accessor :port, :rules
+    attr_accessor :port
 
     def initialize(port)
       @port = port
-      @rules = []
+      @kim = Kim.new(port: port)
+      @kim.start
     end
 
     def configure(&configure_routes)
       config = Config.new
       configure_routes.call(config)
-      rules.concat(config.rules)
-      restart_server
+      config.rules.each do |rule|
+        matcher = Kim::Matcher.and(verb(rule.verb),
+                                   res(rule.path),
+                                   req_headers(rule.headers))
+        handler = wrap(rule.handler, rule.rest_route)
+        @kim.add_handler(matcher, &handler)
+      end
+    end
+
+    def clear_routes
+      @kim.clear_handlers
     end
 
     def teardown
-      rules.clear
-      @mimic_running = true
-      Mimic.cleanup!
+      @kim.stop
+    end
+
+    private
+
+    # Make it easier to write handlers by massaging input and output
+    def wrap(handler, rest_route)
+      proc do |req|
+        massage_request!(req)
+        resp = handler.call(req)
+        massage_response(resp, rest_route)
+      end
     end
 
-    def restart_server
-      server = self
-      dispatcher = Dispatcher.new(rules)
-      if @mimic_running
-        Mimic.cleanup!
-        Mimic::Server.instance.instance_variable_get(:@thread).join
+    def massage_request!(req)
+      if req.body && !req.body.empty?
+        req.body = read(req.body, :json)
       end
-      Mimic.mimic(port: @port) do
-        # this block executes in a strange context, which is why we
-        # have to close over server and dispatcher
-        server.rules.map(&:mimic_route).uniq.each do |mimic_route|
-          # register the route handlers. this is basically Sinatra.
-          send(mimic_route.method, mimic_route.path) do
-            dispatcher.dispatch(mimic_route, request)
-          end
+    end
+
+    def massage_response(resp, rest_route)
+      if rack_response?(resp)
+        code, headers, body = resp
+        unless body.is_a?(String)
+          body = write(body, :json)
         end
+        [code, headers, body]
+      else
+        if rest_route
+          rd = rest_route.response_descriptor
+          content_type = content_type_for(rd)
+          format = rd
+        else
+          content_type = 'application/json'
+          format = :json
+        end
+        ['200', {'Content-Type' => content_type}, write(resp, format)]
       end
-      @mimic_running = true
+    end
+
+    def rack_response?(resp)
+      resp.is_a?(Array) && resp.size == 3
     end
   end
 end

data/lib/hyperion_test/fake_server/config.rb

@@ -23,12 +23,11 @@ class Hyperion
       def allowed_rule(args, handler)
         if args.size == 1 && args.first.is_a?(RestRoute)
           route = args.first
-          Rule.new(MimicRoute.new(route.method, route.uri.path), route_headers(route), handler, route)
+          Rule.new(route.method, route.uri.path, route_headers(route), handler, route)
         else
-          # TODO: deprecate this
           method, path, headers = args
           headers ||= {}
-          Rule.new(MimicRoute.new(method, path), headers, handler, nil)
+          Rule.new(method, path, headers, handler, nil)
         end
       end
     end

data/lib/hyperion_test/fake_server/types.rb

@@ -1,7 +1,9 @@
 class Hyperion
   class FakeServer
-    MimicRoute = ImmutableStruct.new(:method, :path)
-    Rule = ImmutableStruct.new(:mimic_route, :headers, :handler, :rest_route)
+    Rule = ImmutableStruct.new(:method, :path, :headers, :handler, :rest_route)
+    class Rule
+      alias_method :verb, :method
+    end
     Request = ImmutableStruct.new(:body)
   end
 end

data/lib/hyperion_test/kim.rb

@@ -0,0 +1,223 @@
+require 'rack'
+require 'securerandom'
+require 'thread'
+require 'ostruct'
+require 'active_support/core_ext/string/inflections'
+require 'hyperion_test/kim/matcher'
+
+class Hyperion
+  class Kim
+    # A dumb fake web server.
+    # This is minimal object wrapper around Rack/WEBrick. WEBrick was chosen
+    # because it comes with ruby and we're not doing rocket science here.
+    # Kim runs Rack/WEBrick in a separate thread and keeps an array of
+    # handlers. A handler is simply a predicate on a request object
+    # and a function to handle the request should the predicate return truthy.
+    # When rack notifies us of a request, we dispatch it to the first handler
+    # with a truthy predicate.
+    #
+    # Again, what we're trying to do is very simple. Most of the existing complexity
+    # is due to
+    # - thread synchronization
+    # - unmangling WEBrick's header renaming
+    # - loosening the requirements on what a handler function must return
+    #
+    # To support path parameters (e.g., /people/:name), a predicate may return
+    # a Request object as a truthy value, augmented with additional params.
+    # When the predicate returns a Request, the augmented request object is
+    # passed to the handler function in place of the original request.
+
+    Handler = Struct.new(:pred, :func)
+    Request = Struct.new(:verb,     # 'GET' | 'POST' | ...
+                         :path,     # String
+                         :params,   # OpenStruct
+                         :headers,  # Hash[String => String]
+                         :body)     # String
+    class Request
+      alias_method :method, :verb
+      def merge(other)
+        merge_params(other.params)
+      end
+      def merge_params(other_params)
+        params = OpenStruct.new(self.params.to_h.merge(other_params.to_h))
+        Request.new(verb, path, params, headers, body)
+      end
+    end
+
+    def initialize(port:)
+      @port = port
+      @handlers = []
+      @lock = Mutex.new # controls access to this instance of Kim (via public methods and callbacks)
+    end
+
+    def self.webrick_mutex
+      @webrick_mutex ||= Mutex.new # controls access to the Rack::Handler::WEBrick singleton
+    end
+
+    def start
+      # Notes on synchronization:
+      #
+      # The only way to start a handler is with static method ::run
+      # which touches singleton instance variables. webrick_mutex
+      # ensures only one thread is in the singleton at a time.
+      #
+      # A threadsafe queue is used to notify the calling thread
+      # that the server thread has started. The caller needs to
+      # wait so it can obtain the webrick instance.
+
+      @lock.synchronize do
+        raise 'Cannot restart' if @stopped
+        Kim.webrick_mutex.synchronize do
+          q = Queue.new
+          @thread = Thread.start do
+            begin
+              opts = {Port: @port, Logger: ::Logger.new('/dev/null'), AccessLog: []} # hide output
+              Rack::Handler::WEBrick.run(method(:handle_request), opts) do |webrick|
+                q.push(webrick)
+              end
+            ensure
+              $stderr.puts "Hyperion fake server on port #{@port} exited unexpectedly!" unless @stopped
+            end
+          end
+          @webrick = q.pop
+        end
+      end
+    end
+
+    def stop
+      @lock.synchronize do
+        return if @stopped
+        @stopped = true
+        @webrick.shutdown
+        @thread.join
+        @webrick = nil
+        @thread = nil
+      end
+    end
+
+    # Add a handler. Returns a proc that removes the handler.
+    def add_handler(matcher_or_pred, &handler_proc)
+      @lock.synchronize do
+        handler = Handler.new(Matcher.wrap(matcher_or_pred), handler_proc)
+        @handlers.unshift(handler)
+        remover = proc { @lock.synchronize { @handlers.delete(handler) } }
+        remover
+      end
+    end
+
+    def clear_handlers
+      @lock.synchronize do
+        @handlers = []
+      end
+    end
+
+    private
+    def handle_request(env)
+      @lock.synchronize do
+        req = request_for(env)
+        x = handle(req)
+        x = massage_response(x)
+        x = validate_response(x)
+        x
+      end
+    end
+
+    def request_for(env)
+      verb = env['REQUEST_METHOD']
+      path = env['PATH_INFO']
+      params = OpenStruct.new(read_query_params(env['QUERY_STRING']))
+      headers = read_headers(env)
+      body = env['rack.input'].gets
+      Request.new(verb, path, params, headers, body)
+    end
+
+    def read_query_params(query_string)
+      query_string
+        .split('&')
+        .map { |kv| kv.split('=') }
+        .to_h
+    end
+
+    def read_headers(env)
+      # similar to https://github.com/ruby/ruby/blob/32674b167bddc0d737c38f84722986b0f228b44b/lib/webrick/cgi.rb#L217-L226
+      env.each_pair
+        .select { |k, _| mangled_header?(k) }
+        .map { |k, v| [unmangle_header_key(k), v] }
+        .to_h
+    end
+
+    def mangled_header?(h)
+      h.start_with?('HTTP_') || %w(CONTENT_TYPE CONTENT_LENGTH).include?(h)
+    end
+
+    def unmangle_header_key(k)
+      k.gsub(/^HTTP_/, '')
+        .split('_')
+        .map(&:titlecase)
+        .join('-')
+    end
+
+    def handle(req)
+      pred_value, func = @handlers.lazy
+        .map { |h| [h.pred.call(req), h.func] }
+        .select { |(pv, _)| pv }
+        .first || [nil, no_route_matched_func]
+      func.call(pred_value.is_a?(Request) ? pred_value : req)
+    end
+
+    def massage_response(r)
+      if triplet?(r)
+        r[0] = r[0].to_s   # code
+        r[1] = r[1] || {}  # headers
+        r[2] = *r[2]       # body/bodies (coerce to array)
+        r[2].map!(&:to_s)
+        r
+      elsif r.is_a?(String)
+        ['200', {}, [r]]
+      else
+        r
+      end
+    end
+
+    def validate_response(r)
+      triplet?(r) or return server_error("Invalid response, not a size-3 array: #{r.inspect}.")
+      http_code?(r[0]) or return server_error("Invalid response, invalid http code: #{r[0].inspect}")
+      headers?(r[1]) or return server_error("Invalid response, invalid header hash: #{r[1].inspect}")
+      bodies?(r[2]) or return server_error("Invalid response, invalid bodies array: #{r[2].inspect}")
+      r
+    end
+
+    def no_route_matched_func
+      proc do
+        ['404', error_headers, ['Request matched no routes.']]
+      end
+    end
+
+    def triplet?(x)
+      x.is_a?(Array) && x.size == 3
+    end
+
+    def http_code?(x)
+      return false unless x.respond_to?(:to_i)
+      v = x.to_i
+      100 <= v && v < 600
+    end
+
+    def headers?(x)
+      # TODO: check for valid keys and values
+      x.is_a?(Hash)
+    end
+
+    def bodies?(x)
+      x.is_a?(Array) && x.all? { |v| v.is_a?(String) }
+    end
+
+    def server_error(msg)
+      ['500', error_headers, [msg]]
+    end
+
+    def error_headers
+      {'Content-Type' => 'text/plain'}
+    end
+  end
+end

data/lib/hyperion_test/kim/matcher.rb

@@ -0,0 +1,86 @@
+class Hyperion
+  class Kim
+    class Matcher
+      # Fancy predicates for HTTP requests.
+      # Features:
+      # - and/or/not combinators
+      # - If a predicate raises an error, it is caught and treated as falsey. simplifies predicates.
+      #   For example: headers['Allow'].starts_with?('application/')
+      #   will raise if no Allow header was sent, however we really just want to treat that as
+      #   a non-match.
+      # - Parameter extraction. A matcher can return an augmented Request as the truthy value.
+
+      attr_reader :func
+
+      def initialize(func=nil, &block)
+        @func = Matcher.wrap(block || func)
+      end
+
+      def call(req)
+        @func.call(req)
+      end
+
+      def and(other)
+        Matcher.new do |req|
+          (req2 = @func.call(req)) && other.call(req2)
+        end
+      end
+
+      def or(other)
+        Matcher.new do |req|
+          @func.call(req) || other.call(req)
+        end
+      end
+
+      def not
+        Matcher.new do |req|
+          @func.call(req) ? nil : req
+        end
+      end
+
+      def self.and(*ms)
+        m, *rest = ms
+        if rest.empty?
+          m
+        else
+          m.and(Matcher.and(*rest))
+        end
+      end
+
+      private
+
+      # Coerce the return value of the function to nil/hash in case
+      # it returns a simple true/false.
+      # Update (mutate) the request params with any addition values
+      # gleaned by a successful match.
+      def self.wrap(f)
+        if f.is_a?(Matcher)
+          f
+        else
+          proc do |req|
+            v = coerce(f, req)
+            # Update the request parameters. respond_to?(:merge) is a
+            # compromise between outright depending on Kim::Request
+            # and threading a totally generic 'update' function
+            # through all the matcher code.
+            if v && req.respond_to?(:merge)
+              req.merge(v)
+            else
+              v
+            end
+          end
+        end
+      end
+
+      def self.coerce(f, req)
+        case v = f.call(req)
+        when TrueClass then req
+        when FalseClass then nil
+        else v
+        end
+      rescue
+        nil # treat predicate errors as falsey
+      end
+    end
+  end
+end

data/lib/hyperion_test/kim/matchers.rb

@@ -0,0 +1,48 @@
+require 'active_support/hash_with_indifferent_access'
+require 'hyperion_test/kim/matcher'
+
+class Hyperion
+  class Kim
+    module Matchers
+      # Some useful matchers to include in your code
+
+      def res(resource_pattern)
+        regex = resource_pattern.gsub(/:([^\/]+)/, "(?<\\1>[^\\/]+)")
+        Matcher.new do |req|
+          m = req.path.match(regex)
+          m && req.merge_params(m.names.zip(m.captures).to_h)
+        end
+      end
+
+      def verb(verb_to_match)
+        Matcher.new do |req|
+          req.verb.to_s.upcase == verb_to_match.to_s.upcase
+        end
+      end
+
+      def req_headers(required_headers)
+        Matcher.new do |req|
+          required_headers.each_pair.all? do |(k, v)|
+            hash_includes?(req.headers.to_h, k, v)
+          end
+        end
+      end
+
+      def req_params(required_params)
+        Matcher.new do |req|
+          required_params.each_pair.all? do |(k, v)|
+            hash_includes?(req.params.to_h, k, v)
+          end
+        end
+      end
+
+      private
+
+      def hash_includes?(h, k, v)
+        (h.keys.include?(k.to_s) || h.keys.include?(k.to_sym)) && (v.nil? || (h[k.to_s] || h[k.to_sym]) == v)
+      end
+
+      extend self
+    end
+  end
+end

data/lib/hyperion_test/test_framework_hooks.rb

@@ -2,19 +2,19 @@ require 'hyperion'
 require 'rspec/core'
 
 module TestFrameworkHooks
-  def teardown_registered?
+  def reset_registered?
     rspec_after_example_hooks.any? do |hook_proc|
-      hook_proc.source_location == method(:teardown).to_proc.source_location
+      hook_proc.source_location == method(:reset).to_proc.source_location
     end
   end
 
-  def can_hook_teardown?
-    RSpec.current_example
+  def can_hook_reset?
+    !!RSpec.current_example
   end
 
-  def hook_teardown
+  def hook_reset
     hyperion = self
-    rspec_hooks.register(:prepend, :after, :each) { hyperion.teardown }
+    rspec_hooks.register(:prepend, :after, :each) { hyperion.reset }
   end
 
   def rspec_after_example_hooks

data/spec/lib/hyperion/requestor_spec.rb

@@ -110,12 +110,11 @@ describe Hyperion::Requestor do
     context 'on a 400-level response' do
 
       def example(opts)
-        arrange(:get, [(400..499).to_a.sample, {}, opts[:response]])
+        code = ((400..499).to_a - [404]).sample
+        arrange(:get, [code, {}, opts[:response]])
         expect{request(@route)}.to raise_error HyperionError, opts[:error]
       end
 
-
-
       context 'when the response is a properly-formed error message' do
         it 'raises an error with the response message' do
           example response: '{"message":"oops"}',

data/spec/lib/hyperion/test_spec.rb

@@ -73,8 +73,8 @@ describe Hyperion do
   end
 
   it 'logs requests for unstubbed routes' do
-    route1 = RestRoute.new(:get, 'http://site.org/stuff', user_response_params)
-    route2 = RestRoute.new(:get, 'http://site.org/things', user_response_params)
+    route1 = RestRoute.new(:get, 'http://somesite.org/stuff', user_response_params)
+    route2 = RestRoute.new(:get, 'http://somesite.org/things', user_response_params)
     Hyperion.fake(route1.uri.base) do |svr|
       svr.allow(route1) {{}}
     end
@@ -136,23 +136,23 @@ describe Hyperion do
   end
 
   it 'allows multiple fake servers to be created' do
-    Hyperion.fake('http://google.com') do |svr|
-      svr.allow(:get, '/welcome') { success_response({'text' => 'hello from google'}) }
+    Hyperion.fake('http://somesite.org') do |svr|
+      svr.allow(:get, '/welcome') { success_response({'text' => 'hello from somesite'}) }
     end
 
-    Hyperion.fake('http://indigo.com:3000') do |svr|
-      svr.allow(:get, '/welcome') { success_response({'text' => 'hello from indigo@3000'}) }
+    Hyperion.fake('http://indigo.com:80') do |svr|
+      svr.allow(:get, '/welcome') { success_response({'text' => 'hello from indigo@80'}) }
     end
 
     Hyperion.fake('http://indigo.com:4000') do |svr|
       svr.allow(:get, '/welcome') { success_response({'text' => 'hello from indigo@4000'}) }
     end
 
-    result = Hyperion.request(RestRoute.new(:get, 'http://google.com/welcome', user_response_params))
-    expect(result.body).to eql({'text' => 'hello from google'})
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/welcome', user_response_params))
+    expect(result.body).to eql({'text' => 'hello from somesite'})
 
-    result = Hyperion.request(RestRoute.new(:get, 'http://indigo.com:3000/welcome', user_response_params))
-    expect(result.body).to eql({'text' => 'hello from indigo@3000'})
+    result = Hyperion.request(RestRoute.new(:get, 'http://indigo.com:80/welcome', user_response_params))
+    expect(result.body).to eql({'text' => 'hello from indigo@80'})
 
     result = Hyperion.request(RestRoute.new(:get, 'http://indigo.com:4000/welcome', user_response_params))
     expect(result.body).to eql({'text' => 'hello from indigo@4000'})
@@ -176,37 +176,37 @@ describe Hyperion do
   end
 
   it 'allows routes to be augmented' do
-    Hyperion.fake('http://google.com') do |svr|
+    Hyperion.fake('http://somesite.org') do |svr|
       svr.allow(:get, '/old') { success_response({'text' => 'old'}) }
       svr.allow(:get, '/hello') { success_response({'text' => 'hello'}) }
       svr.allow(RestRoute.new(:get, '/users/0', user_response_params)) { success_response({'user' => 'old user'}) }
     end
 
     # smoke test that the server is up and running
-    result = Hyperion.request(RestRoute.new(:get, 'http://google.com/hello', user_response_params))
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/hello', user_response_params))
     expect(result.body).to eql({'text' => 'hello'})
 
     # augment the routes
-    Hyperion.fake('http://google.com') do |svr|
+    Hyperion.fake('http://somesite.org') do |svr|
       svr.allow(:get, '/hello') { success_response({'text' => 'aloha'}) }
       svr.allow(:get, '/goodbye') { success_response({'text' => 'goodbye'}) }
       svr.allow(RestRoute.new(:get, '/users/0', user_response_params)) { success_response({'user' => 'new user'}) }
     end
 
     # untouched routes are left alone
-    result = Hyperion.request(RestRoute.new(:get, 'http://google.com/old', user_response_params))
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/old', user_response_params))
     expect(result.body).to eql({'text' => 'old'})
 
     # restating the route replaces it (last one wins)
-    result = Hyperion.request(RestRoute.new(:get, 'http://google.com/hello', user_response_params))
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/hello', user_response_params))
     expect(result.body).to eql({'text' => 'aloha'})
 
     # new routes can be added
-    result = Hyperion.request(RestRoute.new(:get, 'http://google.com/goodbye', user_response_params))
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/goodbye', user_response_params))
     expect(result.body).to eql({'text' => 'goodbye'})
 
     # restating a route routes that uses headers to differentiate replaces it (last one wins)
-    result = Hyperion.request(RestRoute.new(:get, 'http://google.com/users/0', user_response_params))
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/users/0', user_response_params))
     expect(result.body).to eql({'user' => 'new user'})
   end
 

data/spec/lib/hyperion_test/kim/matcher_spec.rb

@@ -0,0 +1,126 @@
+require 'rspec'
+require 'hyperion_test/kim'
+require 'hyperion_test/kim/matcher'
+require 'hyperion_test/kim/matchers'
+
+describe Hyperion::Kim::Matcher do
+  Matcher = Hyperion::Kim::Matcher
+  Request = Hyperion::Kim::Request
+  include Hyperion::Kim::Matchers
+
+  describe '::new' do
+    it 'creates a matcher' do
+      m = Matcher.new(proc { |x| x >= 0 })
+      expect(m.call(1)).to be_truthy
+      expect(m.call(-1)).to be_falsey
+    end
+    it 'accepts a block' do
+      m = Matcher.new { |x| x >= 0 }
+      expect(m.call(1)).to be_truthy
+      expect(m.call(-1)).to be_falsey
+    end
+    it 'can return a request' do
+      m = res('/greet/:name')
+      r = m.call(req('/greet/kim'))
+      expect(r.params.name).to eql 'kim'
+      expect(m.call(req('/text/kim'))).to be_falsey
+    end
+    it 'treats errors as falsey' do
+      m = Matcher.new { raise 'oops' }
+      expect(m.call(:anything)).to be_falsey
+    end
+  end
+  describe '#call' do
+    it 'invokes the predicate' do
+      m = Matcher.new { |x| x >= 0 }
+      expect(m.call(1)).to be_truthy
+      expect(m.call(-1)).to be_falsey
+    end
+  end
+  describe '#and' do
+    it 'combines predicates with boolean AND' do
+      positive = Matcher.new { |x| x > 0 }
+      even = Matcher.new(&:even?)
+      m = positive.and(even)
+      expect(m.call(2)).to be_truthy
+      expect(m.call(-2)).to be_falsey
+      expect(m.call(1)).to be_falsey
+      expect(m.call(-1)).to be_falsey
+    end
+    it 'merges result hash' do
+      matcher = res('/greet/:name').and(res('/:action/kim'))
+      verify_path_match matcher, '/greet/kim', yields_params: {name: 'kim', action: 'greet'}
+      verify_path_does_not_match matcher, '/greet/bob'
+      verify_path_does_not_match matcher, '/text/kim'
+      verify_path_does_not_match matcher, '/text/bob'
+    end
+  end
+  describe '#or' do
+    it 'combines predicates with boolean OR' do
+      positive = Matcher.new { |x| x > 0 }
+      even = Matcher.new(&:even?)
+      m = positive.or(even)
+      expect(m.call(2)).to be_truthy
+      expect(m.call(-2)).to be_truthy
+      expect(m.call(1)).to be_truthy
+      expect(m.call(-1)).to be_falsey
+    end
+    it 'returns result hash of first matching predicate' do
+      matcher = res('/greet/:name').or(res('/:action/kim'))
+      verify_path_match matcher, '/greet/kim', yields_params: {name: 'kim'}
+      verify_path_match matcher, '/text/kim', yields_params: {action: 'text'}
+      verify_path_does_not_match matcher, '/text/bob'
+    end
+  end
+  describe '#not' do
+    it 'returns a negated predicate' do
+      even = Matcher.new(&:even?)
+      odd = even.not
+      expect(odd.call(1)).to be_truthy
+      expect(odd.call(2)).to be_falsey
+    end
+  end
+  describe '::and' do
+    it 'combines predicates with boolean AND' do
+      positive = Matcher.new { |x| x > 0 }
+      even = Matcher.new(&:even?)
+      mult10 = Matcher.new { |x| x % 10 == 0 }
+      m = Matcher.and(positive, even, mult10)
+      expect(m.call(10)).to be_truthy
+      expect(m.call(-10)).to be_falsey
+    end
+  end
+  context 'when the request is augmented with params' do
+    let(:matcher) do
+      match_people = res('/people/:name')
+      name_starts_with_k = Matcher.new { |r| r.params.name.start_with?('k') }
+      match_people.and(name_starts_with_k)
+    end
+    it 'the params are updated as the predicate executes' do
+      verify_path_match matcher, '/people/kim'
+      verify_path_does_not_match matcher, '/people/kim'
+      verify_path_does_not_match matcher, '/people/bob'
+      verify_path_does_not_match matcher, '/idiots/kanye'
+    end
+    it 'the original request is unchanged' do
+      original_request = req('/people/kim')
+      augmented_request = matcher.call(original_request)
+      expect(augmented_request.params.name).to eql 'kim'
+      expect(original_request.params.name).to be nil
+    end
+  end
+
+  def req(path)
+    Request.new('GET', path, OpenStruct.new, {}, nil)
+  end
+
+  def verify_path_match(matcher, path, yields_params: nil)
+    result = matcher.call(req(path))
+    expect(result).to be_truthy
+    expect(result.params.to_h).to eql(yields_params) if yields_params
+  end
+
+  def verify_path_does_not_match(matcher, path)
+    expect(matcher.call(res(path))).to be_falsey
+  end
+end

data/spec/lib/hyperion_test/kim/matchers_spec.rb

@@ -0,0 +1,58 @@
+require 'rspec'
+require 'hyperion_test/kim'
+require 'hyperion_test/kim/matchers'
+
+describe Hyperion::Kim::Matchers do
+  include Hyperion::Kim::Matchers
+  describe '#res' do
+    it 'matches resource paths' do
+      m = res('/people/:name/birthplace/:city')
+      r = m.call(req(path: '/people/kim/birthplace/la'))
+      expect(r.params.name).to eql 'kim'
+      expect(r.params.city).to eql 'la'
+      expect(m.call(req(path: '/people/kim/home/la'))).to be_falsey
+    end
+  end
+  describe '#verb' do
+    it 'matches the HTTP verb' do
+      expect(verb('GET').call(req(verb: 'GET'))).to be_truthy
+      expect(verb('PUT').call(req(verb: 'put'))).to be_truthy
+      expect(verb(:post).call(req(verb: 'POST'))).to be_truthy
+      expect(verb('GET').call(req(verb: 'PUT'))).to be_falsey
+    end
+  end
+  describe '#req_headers' do
+    it 'matches headers' do
+      m = req_headers('Allow' => 'application/json')
+      expect(m.call(req(headers: {'Allow' => 'application/json'}))).to be_truthy
+      expect(m.call(req(headers: {'Allow' => 'text/html'}))).to be_falsey
+      expect(m.call(req(headers: {}))).to be_falsey
+    end
+    it 'only checks for presence if value is nil' do
+      m = req_headers('Allow' => nil)
+      expect(m.call(req(headers: {'Allow' => 'application/json'}))).to be_truthy
+      expect(m.call(req(headers: {'Allow' => 'text/html'}))).to be_truthy
+      expect(m.call(req(headers: {}))).to be_falsey
+    end
+  end
+  describe '#req_params' do
+    it 'matches params' do
+      m = req_params(a: 1, 'b' => 2)
+      expect(m.call(req(params: params(a: 1, b: 2)))).to be_truthy
+    end
+    it 'only checks for presence if value is nil' do
+      m = req_params(c: nil)
+      expect(m.call(req(params: params(c: 1)))).to be_truthy
+      expect(m.call(req(params: params(c: 2)))).to be_truthy
+      expect(m.call(req(params: params(z: 2)))).to be_falsey
+    end
+  end
+
+  def req(attrs)
+    Hyperion::Kim::Request.new(*attrs.values_at(*Hyperion::Kim::Request.members))
+  end
+
+  def params(*args)
+    OpenStruct.new(*args)
+  end
+end

data/spec/lib/hyperion_test/kim_spec.rb

@@ -0,0 +1,157 @@
+require 'rspec'
+require 'hyperion_test/kim'
+require 'typhoeus'
+require 'hyperion_test'
+
+describe Hyperion::Kim do
+  before(:all) do
+    Hyperion.teardown_cached_servers
+    @port = 9001
+    @kim = Hyperion::Kim.new(port: @port)
+    @kim.start
+  end
+  before(:each) { @kim.clear_handlers }
+  after(:all) { @kim.stop }
+  attr_accessor :kim
+
+  let!(:always) { proc { true } }
+
+  context 'normal operation' do
+    it 'routes to a block' do
+      kim.add_handler(always) { 'Hello, World!' }
+      expect(get_body('/')).to eql 'Hello, World!'
+    end
+    it 'routes to the most recently added handler with a true predicate' do
+      kim.add_handler(proc{false}) { 'a' }
+      kim.add_handler(proc{true}) { 'b' }
+      kim.add_handler(proc{true}) { 'c' }
+      kim.add_handler(proc{false}) { 'd' }
+      expect(get_body('/')).to eql 'c'
+    end
+    it 'allows multiple servers running in parallel' do
+      kim2 = Hyperion::Kim.new(port: 9002)
+      begin
+        kim2.start
+        kim.add_handler(always) { '1' }
+        kim2.add_handler(always) { '2' }
+        expect(Typhoeus.get('http://localhost:9001').body).to eql '1'
+        expect(Typhoeus.get('http://localhost:9002').body).to eql '2'
+        kim2.stop
+        expect(Typhoeus.get('http://localhost:9001').body).to eql '1'
+        expect(Typhoeus.get('http://localhost:9002').success?).to be false
+      ensure
+        kim2.stop
+      end
+    end
+    it 'continues working after a handler error' do
+      crash_command = proc { |r| r.path.include?('crash') }
+      greet_command = proc { |r| r.path.include?('greet') }
+      kim.add_handler(crash_command) { raise 'oops' }
+      kim.add_handler(greet_command) { 'hello' }
+      expect(get_code('/crash')).to eql 500
+      expect(get_code('/greet')).to eql 200
+    end
+  end
+
+  describe '#add_handler' do
+    it 'returns a remover proc' do
+      remover = kim.add_handler(always) { 'foo' }
+      expect(get_body('/')).to eql 'foo'
+      remover.call
+      expect(get_code('/')).to eql 404
+    end
+  end
+
+  describe '#clear_handlers' do
+    it 'clears all handlers' do
+      kim.add_handler(always) { 'foo' }
+      expect(get_body('/')).to eql 'foo'
+      kim.clear_handlers
+      expect(get_code('/')).to eql 404
+    end
+  end
+
+  describe 'a handler' do
+    it 'receives the HTTP verb' do
+      verb = nil
+      method = nil
+      kim.add_handler(always) do |r|
+        verb = r.verb
+        method = r.method
+      end
+      post('/')
+      expect(verb).to eql 'POST'
+      expect(method).to eql 'POST'
+    end
+    it 'receives the resource path' do
+      path = nil
+      kim.add_handler(always) { |r| path = r.path; '' }
+      get('/foo/bar')
+      expect(path).to eql '/foo/bar'
+    end
+    it 'receives the params' do
+      params = nil
+      kim.add_handler(proc{ |req| req.merge_params(d: '4', e: '5') }) { |r| params = r.params; '' }
+      get('/foo/bar?a=1&b=2&c=3')
+      expect(params.a).to eql '1'
+      expect(params[:b]).to eql '2'
+      expect(params['c']).to eql '3'
+      expect(params.d).to eql '4'
+      expect(params.e).to eql '5'
+    end
+    it 'receives the request headers' do
+      headers = nil
+      kim.add_handler(always) { |r| headers = r.headers; '' }
+      get('/', headers: {'Accept' => 'application/json', 'Content-Type' => 'text/html'})
+      expect(headers['Accept']).to eql 'application/json'
+      expect(headers['Content-Type']).to eql 'text/html'
+    end
+    it 'receives the request body' do
+      body = nil
+      kim.add_handler(always) { |r| body = r.body; '' }
+      post('/', body: 'please do something')
+      expect(body).to eql 'please do something'
+    end
+    it 'can return a string' do
+      kim.add_handler(always) { 'hello' }
+      r = get('/')
+      expect(r.code).to eql 200
+      expect(r.body).to eql 'hello'
+    end
+    it 'can return a rack response' do
+      kim.add_handler(always) { ['400', {'Content-Type' => 'application/greeting'}, ['oops']] }
+      r = get('/')
+      expect(r.body).to eql 'oops'
+      expect(r.code).to eql 400
+      expect(r.headers['Content-Type']).to eql 'application/greeting'
+    end
+    it 'rack response requirements are somewhat loosened' do
+      kim.add_handler(always) { [400, nil, 'oops'] }
+      r = get('/')
+      expect(r.body).to eql 'oops'
+      expect(r.code).to eql 400
+    end
+  end
+
+  def get_body(path)
+    response = get(path)
+    expect(response.success?).to be true
+    response.body
+  end
+
+  def base_uri
+    "http://localhost:#{@port}"
+  end
+
+  def get_code(path)
+    get(path).code
+  end
+
+  def get(path, headers: {})
+    Typhoeus.get(File.join(base_uri, path), headers: headers)
+  end
+
+  def post(path, headers: {}, body: nil)
+    Typhoeus.post(File.join(base_uri, path), headers: headers, body: body)
+  end
+end

data/update_version.sh

@@ -0,0 +1,52 @@
+#!/bin/bash -e
+
+#This script is used during the release process. It is not intended to be ran manually.
+
+VERSION="$1"
+VERSION="${VERSION:?"must provide version as first parameter"}"
+SCRIPT_DIR="$(cd "$(dirname "$0")"; pwd)"
+
+updateVersion(){
+    updateGemspec
+    commitStagedFiles "Update version to ${VERSION}"
+}
+
+updateGemspec(){
+    echo -e "\nUpdating gemspec version"
+    local gemspecPath="${SCRIPT_DIR}/hyperion_http.gemspec"
+    sed -i 's/\(\.version\s*=\s*\).*/\1'"'${VERSION}'/" "${gemspecPath}"
+    stageFiles "${gemspecPath}"
+}
+
+stageAndCommit(){
+    local msg="$1"
+    shift
+    local files=( "$@" )
+    stageFiles "${files[@]}"
+    commitStagedFiles "${msg}"
+}
+
+stageFiles(){
+    local files=( "$@" )
+    git add "${files[@]}"
+}
+
+commitStagedFiles(){
+    local msg="$1"
+    if thereAreStagedFiles; then
+        git commit -m "${msg}"
+    else
+        echo "No changes to commit"
+    fi
+}
+
+thereAreStagedFiles(){
+    git update-index -q --ignore-submodules --refresh
+    if git diff-index --cached --quiet HEAD --ignore-submodules -- ; then
+        return 1;
+    else
+        return 0;
+    fi
+}
+
+updateVersion

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hyperion_http
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.1
 platform: ruby
 authors:
 - Indigo BioAutomation, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-17 00:00:00.000000000 Z
+date: 2016-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -165,19 +165,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.7'
 - !ruby/object:Gem::Dependency
-  name: mimic
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: logatron
   requirement: !ruby/object:Gem::Requirement
@@ -208,6 +208,7 @@ files:
 - README.md
 - Rakefile
 - build.yml
+- hyperion.gemspec
 - hyperion_http.gemspec
 - lib/hyperion.rb
 - lib/hyperion/aux/bug_error.rb
@@ -215,7 +216,6 @@ files:
 - lib/hyperion/aux/logger.rb
 - lib/hyperion/aux/typho.rb
 - lib/hyperion/aux/util.rb
-- lib/hyperion/aux/version.rb
 - lib/hyperion/formats.rb
 - lib/hyperion/headers.rb
 - lib/hyperion/hyperion.rb
@@ -238,8 +238,10 @@ files:
 - lib/hyperion_test/fake.rb
 - lib/hyperion_test/fake_server.rb
 - lib/hyperion_test/fake_server/config.rb
-- lib/hyperion_test/fake_server/dispatcher.rb
 - lib/hyperion_test/fake_server/types.rb
+- lib/hyperion_test/kim.rb
+- lib/hyperion_test/kim/matcher.rb
+- lib/hyperion_test/kim/matchers.rb
 - lib/hyperion_test/spec_helper.rb
 - lib/hyperion_test/test_framework_hooks.rb
 - spec/fixtures/test
@@ -254,9 +256,13 @@ files:
 - spec/lib/hyperion/types/hyperion_uri_spec.rb
 - spec/lib/hyperion_spec.rb
 - spec/lib/hyperion_test/fake_route_spec.rb
+- spec/lib/hyperion_test/kim/matcher_spec.rb
+- spec/lib/hyperion_test/kim/matchers_spec.rb
+- spec/lib/hyperion_test/kim_spec.rb
 - spec/lib/types_spec.rb
 - spec/spec_helper.rb
 - spec/support/core_helpers.rb
+- update_version.sh
 homepage: ''
 licenses:
 - MIT
@@ -277,7 +283,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.2
 signing_key: 
 specification_version: 4
 summary: Ruby REST client
@@ -294,7 +300,9 @@ test_files:
 - spec/lib/hyperion/types/hyperion_uri_spec.rb
 - spec/lib/hyperion_spec.rb
 - spec/lib/hyperion_test/fake_route_spec.rb
+- spec/lib/hyperion_test/kim/matcher_spec.rb
+- spec/lib/hyperion_test/kim/matchers_spec.rb
+- spec/lib/hyperion_test/kim_spec.rb
 - spec/lib/types_spec.rb
 - spec/spec_helper.rb
 - spec/support/core_helpers.rb
-has_rdoc: 

data/lib/hyperion/aux/version.rb

@@ -1,3 +0,0 @@
-class Hyperion
-  VERSION = '0.1.9'
-end

data/lib/hyperion_test/fake_server/dispatcher.rb

@@ -1,74 +0,0 @@
-require 'hyperion/headers'
-
-class Hyperion
-  class FakeServer
-    class Dispatcher
-      # Directs an incoming request to the correct handler
-
-      include Hyperion::Formats
-      include Hyperion::Headers
-
-      def initialize(rules)
-        @rules = rules
-      end
-
-      def dispatch(mimic_route, request)
-        rule = find_matching_rule(mimic_route, request)
-        rule or return [404, {}, "Not stubbed: #{mimic_route.inspect} #{request.env}"]
-        request = make_req_obj(request.body.read, request.env['CONTENT_TYPE'])
-        response = rule.handler.call(request)
-        if rack_response?(response)
-          code, headers, body = *response
-          [code, headers, write(body, :json)]
-        else
-          if rule.rest_route
-            rd = rule.rest_route.response_descriptor
-            [200, {'Content-Type' => content_type_for(rd)}, write(response, rd)]
-          else
-            # better to return a 500 than raise an error, since we're executing in the forked server.
-            [500, {}, "An 'allow' block must return a rack-style response if it was not passed a RestRoute"]
-          end
-        end
-      end
-
-      private
-
-      attr_reader :rules
-
-      def rack_response?(x)
-        x.is_a?(Array) && x.size == 3 && x.first.is_a?(Integer) && x.drop(1).any?{|y| !y.is_a?(Integer)}
-      end
-
-      def find_matching_rule(mimic_route, request)
-        matching_rules = rules.select{|rule| rule.mimic_route == mimic_route}
-        matching_rules.reverse.detect{|rule| headers_match?(rule.headers, request.env)}
-        # reverse so that if there are duplicates, the last one wins
-      end
-
-      def make_req_obj(raw_body, content_type)
-        body = raw_body.empty? ? '' : read(raw_body, format_for(content_type))
-        Request.new(body)
-      end
-
-      def headers_match?(rule_headers, actual_headers)
-        sinatrize_headers(rule_headers).subhash?(actual_headers)
-      end
-
-      def sinatrize_headers(headers)
-        headers.map{|k, v| [sinatra_header(k), v]}.to_h
-      end
-
-      def sinatra_header(header)
-        # TODO: there should be a function in Sinatra that does this already
-        cased_header = header.upcase.gsub('-', '_')
-        case cased_header
-        when 'ACCEPT'     then 'HTTP_ACCEPT'
-        when 'EXPECT'     then 'HTTP_EXPECT'
-        when 'HOST'       then 'HTTP_HOST'
-        when 'USER_AGENT' then 'HTTP_USER_AGENT'
-        else cased_header
-        end
-      end
-    end
-  end
-end