hyperion_http 0.1.2

data/lib/hyperion/types/hyperion_uri.rb

@@ -0,0 +1,97 @@
+require 'uri'
+require 'delegate'
+require 'active_support/core_ext/hash/keys'
+require 'rack/utils'
+require 'abstractivator/array_ext'
+
+class HyperionUri < SimpleDelegator
+  # An enhanced version of URI. Namely,
+  # - the base uri is a first class citizen,
+  # - it accepts a hash containing query key/values, and
+  # - it form-encodes query values that are arrays.
+
+  attr_accessor :query_hash
+
+  def initialize(uri, query_hash={})
+    @uri = make_ruby_uri(uri)
+    query_from_uri = parse_query(@uri.query)
+    additional_query_params = validate_query(query_hash)
+    @query_hash = query_from_uri.merge(additional_query_params)
+    __setobj__(@uri)
+  end
+
+  def query
+    query_string(@query_hash)
+  end
+
+  def query=(query)
+    @query_hash = parse_query(query)
+  end
+
+  def to_s
+    fixed = @uri.dup
+    fixed.query = query
+    make_ruby_uri(fixed).to_s
+  end
+
+  def inspect
+    "#<HyperionUri:0x#{(object_id << 1).to_s(16)} #{to_s}>"
+  end
+
+  # @return [String] the URI base e.g., "h\ttp://somehost:80"
+  def base
+    "#{scheme}://#{host}:#{port}"
+  end
+
+  def base=(uri)
+    uri = uri.is_a?(HyperionUri) ? uri : HyperionUri.new(uri)
+    self.scheme = uri.scheme
+    self.host = uri.host
+    self.port = uri.port
+  end
+
+  private
+
+  def validate_query(query)
+    query ||= {}
+    query.is_a?(Hash) or fail 'query must be a hash'
+    query.values.all?(&method(:simple_value?)) or fail 'query values must be simple'
+    query.stringify_keys
+  end
+
+  def simple_value?(x)
+    case x
+      when Array; x.all?(&method(:primitive_value?))
+      else; primitive_value?(x)
+    end
+  end
+
+  def primitive_value?(x)
+    x.is_a?(String) || x.is_a?(Numeric) || x.is_a?(Symbol)
+  end
+
+  def parse_query(query)
+    query ||= ''
+    Rack::Utils.parse_nested_query(query)
+  end
+
+  def query_string(query_hash)
+    return nil if query_hash == {}
+    sorted = query_hash.map{|(k, v)| [k.to_s, stringify(v)]}.sort_by(&:key).to_h
+    Rack::Utils.build_nested_query(sorted)
+  end
+
+  def stringify(x)
+    x.is_a?(Array) ? x.map(&:to_s) : x.to_s
+  end
+
+  def make_ruby_uri(x)
+    input = x.is_a?(HyperionUri) ? x.to_s : x
+
+    # URI is an oddball. It's a module but also a method on Kernel.
+    # Since this class is a SimpleDelegator and SimpleDelegator is
+    # a BasicObject, we need to pick the method off of Kernel.
+    # We don't want to include Kernel because that would mess up delegation.
+    Kernel.instance_method(:URI).bind(self).call(input)
+  end
+end

data/lib/hyperion/types/payload_descriptor.rb

@@ -0,0 +1,9 @@
+class PayloadDescriptor
+  # describes the payload sent in POST/PUT/PATCH
+
+  attr_reader :format
+
+  def initialize(format)
+    @format = format
+  end
+end

data/lib/hyperion/types/response_descriptor.rb

@@ -0,0 +1,21 @@
+require 'hyperion/headers'
+
+class ResponseDescriptor
+  # Describes properties of an acceptable response
+
+  include Hyperion::Headers
+
+  attr_reader :type, :version, :format
+
+  # @param type [String]
+  # @param version [Integer]
+  # @param format [Symbol] :json
+  def initialize(type, version, format)
+    @type, @version, @format = type, version, format
+  end
+
+  def to_s
+    short_mimetype(self)
+  end
+end
+

data/lib/hyperion/types/rest_route.rb

@@ -0,0 +1,20 @@
+require 'hyperion/types/hyperion_uri'
+
+class RestRoute
+  attr_reader :method, :uri, :response_descriptor, :payload_descriptor
+
+  # @param method [Symbol] the HTTP method
+  # @param uri [String, URI]
+  # @param response_descriptor [ResponseDescriptor]
+  # @param payload_descriptor [PayloadDescriptor]
+  def initialize(method, uri, response_descriptor=nil, payload_descriptor=nil)
+    @method = method
+    @uri = HyperionUri.new(uri)
+    @response_descriptor = response_descriptor
+    @payload_descriptor = payload_descriptor
+  end
+
+  def to_s
+    "#{method.to_s.upcase} #{uri}"
+  end
+end

data/lib/hyperion.rb

@@ -0,0 +1,15 @@
+# hyperion's dependencies
+require 'immutable_struct'
+require 'typhoeus'
+require 'oj'
+require 'continuation'
+require 'abstractivator/proc_ext'
+require 'abstractivator/enumerable_ext'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/module/attribute_accessors'
+
+# ensure the requirer gets everything (except hyperion_test)
+require 'hyperion/hyperion'
+require 'hyperion/requestor'
+Dir.glob(File.join(File.dirname(__FILE__), 'hyperion/types/**/*.rb')).each { |path| require_relative(path) }

data/lib/hyperion_test/fake.rb

@@ -0,0 +1,64 @@
+require 'immutable_struct'
+require 'mimic'
+require 'hyperion/headers'
+require 'hyperion/formats'
+require 'uri'
+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.
+
+    include Formats
+    include Headers
+    include TestFrameworkHooks
+    include Logger
+
+    def fake(base_uri, &routes)
+      base_uri = normalized_base(base_uri)
+      if !@running
+        hook_teardown if can_hook_teardown? && !teardown_registered?
+        @running = true
+      end
+      servers[base_uri].configure(&routes)
+    end
+
+    def teardown
+      servers.values.each(&:teardown)
+      servers.clear
+      @running = false
+    end
+
+    private
+
+    def servers
+      @servers ||= Hash.new{|hash, key| hash[key] = FakeServer.new(next_port)}
+    end
+
+    def next_port
+      @last_port ||= 9000
+      @last_port += 1
+    end
+
+    private
+
+    def normalized_base(uri)
+      HyperionUri.new(uri).base
+    end
+
+    # hook into the production code so we can redirect requests to the appropriate fake server
+    def transform_uri(uri)
+      server_uri = servers.keys.detect{|server_uri| normalized_base(server_uri) == uri.base}
+      if server_uri
+        new_uri = HyperionUri.new(uri)
+        new_uri.base = "http://localhost:#{servers[server_uri].port}"
+        logger.debug "Hyperion is redirecting #{uri}  ==>  #{new_uri}"
+        new_uri
+      else
+        uri
+      end
+    end
+
+  end
+end

data/lib/hyperion_test/fake_server/config.rb

@@ -0,0 +1,36 @@
+class Hyperion
+  class FakeServer
+    class Config
+      # this is passed to the block to allow the caller to configure the fake server
+
+      include Hyperion::Headers
+      include Hyperion::Logger
+
+      def rules
+        @rules ||= []
+      end
+
+      # allow(route)
+      # allow(method, path, headers={})
+      def allow(*args, &handler)
+        rule = allowed_rule(args, handler)
+        rules << rule
+        log_stub(rule)
+      end
+
+      private
+
+      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)
+        else
+          # TODO: deprecate this
+          method, path, headers = args
+          headers ||= {}
+          Rule.new(MimicRoute.new(method, path), headers, handler, nil)
+        end
+      end
+    end
+  end
+end

data/lib/hyperion_test/fake_server/dispatcher.rb

@@ -0,0 +1,74 @@
+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

data/lib/hyperion_test/fake_server/types.rb

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

data/lib/hyperion_test/fake_server.rb

@@ -0,0 +1,54 @@
+require 'hyperion_test/test_framework_hooks'
+require 'hyperion/aux/hash_ext'
+require 'hyperion_test/fake_server/dispatcher'
+require 'hyperion_test/fake_server/types'
+require 'hyperion_test/fake_server/config'
+
+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.
+
+    attr_accessor :port, :rules
+
+    def initialize(port)
+      @port = port
+      @rules = []
+    end
+
+    def configure(&configure_routes)
+      config = Config.new
+      configure_routes.call(config)
+      rules.concat(config.rules)
+      restart_server
+    end
+
+    def teardown
+      rules.clear
+      @mimic_running = true
+      Mimic.cleanup!
+    end
+
+    def restart_server
+      server = self
+      dispatcher = Dispatcher.new(rules)
+      if @mimic_running
+        Mimic.cleanup!
+        Mimic::Server.instance.instance_variable_get(:@thread).join
+      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
+      end
+      @mimic_running = true
+    end
+  end
+end

data/lib/hyperion_test/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'hyperion_test'
+
+# A simple wrapper around Hyperion::fake for the typical
+# use case of one faked route. The return value can either be specified
+# as an argument or as a function of the request (using the block).
+#
+# @param [RestRoute] route The route to handle
+# @param [Hash, String] return_value The data to return in response to a request
+# @yield [Hyperion::FakeServer::Request] Yields a request object containing the deserialized request body
+# @yieldreturn [Hash, String, rack_response] The data to return in response to a request
+def fake_route(route, return_value=nil, &block)
+  if return_value && block
+    fail 'cannot provide both a return_value and block'
+  end
+  block = block || proc{return_value}
+  Hyperion.fake(route.uri.base) do |svr|
+    svr.allow(route, &block)
+  end
+end

data/lib/hyperion_test/test_framework_hooks.rb

@@ -0,0 +1,34 @@
+require 'hyperion'
+require 'rspec/core'
+
+module TestFrameworkHooks
+  def teardown_registered?
+    rspec_after_example_hooks.any? do |hook_proc|
+      hook_proc.source_location == method(:teardown).to_proc.source_location
+    end
+  end
+
+  def can_hook_teardown?
+    RSpec.current_example
+  end
+
+  def hook_teardown
+    hyperion = self
+    rspec_hooks.register(:prepend, :after, :each) { hyperion.teardown }
+  end
+
+  def rspec_after_example_hooks
+    if rspec_hooks.respond_to?(:[]) # approximately rspec 3.1.0
+      rspec_hooks[:after][:example].to_a.map(&:block)
+    else # approximately rspec 3.3.0
+      default_if_no_hooks = nil
+      hook_collection = rspec_hooks.send(:hooks_for, :after, :example) {default_if_no_hooks}
+      return [] unless hook_collection
+      hook_collection.items_and_filters.map(&:first).map(&:block)
+    end
+  end
+
+  def rspec_hooks
+    RSpec.current_example.example_group.hooks
+  end
+end

data/lib/hyperion_test.rb

@@ -0,0 +1,2 @@
+require 'hyperion'
+Dir.glob(File.join(File.dirname(__FILE__), 'hyperion_test/**/*.rb')).each{|path| require_relative(path)}

data/spec/lib/hyperion/aux/util_spec.rb

@@ -0,0 +1,29 @@
+require 'rspec'
+require 'hyperion/aux/util'
+
+class Hyperion
+  describe Util do
+
+    describe '::nil_if_error' do
+      it 'catches StandardErrors in the block' do
+        expect(Util.nil_if_error { raise 'oops' }).to be_nil
+      end
+      it 'does not catch Exceptions in the block' do
+        expect{Util.nil_if_error { raise Exception }}.to raise_error Exception
+      end
+    end
+
+    describe '::guard' do
+      it 'raises a BugException if the value is invalid' do
+        expect{Util.guard_param(7, 'a string', String)}.to report 'You passed me 7, which is not a string'
+        expect{Util.guard_param('foo', 'any old number', Numeric)}.to report 'You passed me "foo", which is not any old number'
+        expect{Util.guard_param(:zero, 'callable') { |x| x.respond_to?(:call) }}.to report 'You passed me :zero, which is not callable'
+      end
+
+      def report(msg)
+        raise_error BugError, msg
+      end
+    end
+
+  end
+end

data/spec/lib/hyperion/formats_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'time'
+require 'hyperion'
+
+class Hyperion
+  describe Formats do
+    include Formats
+
+    describe '#write' do
+      it 'returns the input if the input is a string or nil' do
+        expect(write('hello', :json)).to eql 'hello'
+        expect(write(nil, :json)).to be_nil
+      end
+      it 'returns the input if format is nil' do
+        expect(write('hello', nil)).to eql 'hello'
+      end
+      it 'accepts format as a symbol' do
+        expect(write({'a' => 1}, :json)).to eql '{"a":1}'
+      end
+      it 'accepts format as a descriptor' do
+        descriptor = double(format: :json)
+        expect(write({'a' => 1}, descriptor)).to eql '{"a":1}'
+      end
+
+      context 'formats' do
+        context 'when writing json' do
+          it 'writes hashes with string keys' do
+            expect(write({'a' => 1}, :json)).to be_json_eql '{"a":1}'
+          end
+          it 'writes hashes with symbol keys' do
+            expect(write({a: 1}, :json)).to be_json_eql '{"a":1}'
+          end
+          context 'when writing times' do
+            let!(:time) { Time.parse('2015-02-13 08:40:20.321 +1200').localtime('+12:00') }
+            it 'writes Time objects in UTC ISO 8601 format using the timezone that was passed in with milliseconds precision' do
+              expect(write({'a' => time}, :json)).to be_json_eql '{"a":"' + time.localtime('+12:00').iso8601(3) + '"}'
+            end
+            it 'preserves default behavior for non-hyperion code' do
+              expect(Oj.dump({'a' => time})).to start_with '{"a":{"^t":' # be non-specific, since this changes based on something outside the control of bundler
+            end
+          end
+        end
+        it 'allows protobuf format but just passes it through' do
+          expect(write('x', :protobuf)).to eql 'x'
+        end
+      end
+    end
+
+    describe '#read' do
+      it 'returns nil if input is nil' do
+        expect(read(nil, :json)).to be_nil
+      end
+      it 'returns the input if format is nil' do
+        expect(read('abc', nil)).to eql 'abc'
+      end
+      it 'returns the input if the input is not parseable' do
+        expect(read('abc', :json)).to eql 'abc'
+      end
+      context 'when reading json' do
+        it 'accepts format as a symbol' do
+          expect(read('{"a":1}', :json)).to eql({'a' => 1})
+        end
+        it 'reads times as strings' do
+          # sadly, Oj does not appear to support reading real Time objects, even when using
+          # its own representation ({"^t":1423834820.321})
+          expect(read('{"a":"2015-02-13T13:40:20.321Z"}', :json)['a']).to eql '2015-02-13T13:40:20.321Z'
+        end
+      end
+      it 'accepts format as a descriptor' do
+        descriptor = double(format: :json)
+        expect(read('{"a":1}', descriptor)).to eql({'a' => 1})
+      end
+
+      context 'formats' do
+        it 'read json' do
+          expect(read('{"a":1}', :json)).to eql({'a' => 1})
+        end
+        it 'allows protobuf format but just passes it through' do
+          expect(read('x', :protobuf)).to eql 'x'
+        end
+      end
+    end
+  end
+end

data/spec/lib/hyperion/headers_spec.rb

@@ -0,0 +1,61 @@
+require 'hyperion'
+require 'hyperion/headers'
+
+class Hyperion
+  describe Headers do
+    include Headers
+
+    before :each do
+      Hyperion.configure do |config|
+        config.vendor_string = 'schmindigo-descent'
+      end
+    end
+
+    let!(:uri){'http://somesite.org'}
+
+    describe '#route_headers' do
+      it 'creates an accept header for the response descriptor' do
+        headers = route_headers(RestRoute.new(:get, uri, ResponseDescriptor.new('ttt', 999, :json)))
+        expect(headers['Accept']).to eql 'application/vnd.schmindigo-descent.ttt-v999+json'
+      end
+      it 'creates a content-type header for the payload descriptor' do
+        headers = route_headers(RestRoute.new(:get, uri, ResponseDescriptor.new('ttt', 999, :json), PayloadDescriptor.new(:json)))
+        expect(headers['Content-Type']).to eql 'application/json'
+      end
+    end
+
+    describe '#content_type_for' do
+      it 'accepts format as a symbol' do
+        expect(content_type_for(:json)).to eql 'application/json'
+      end
+      it 'accepts format as a descriptor' do
+        descriptor = double(format: :json)
+        expect(content_type_for(descriptor)).to eql 'application/json'
+      end
+      it 'returns the content type for the given format' do
+        expect(content_type_for(:json)).to eql 'application/json'
+        expect(content_type_for(:protobuf)).to eql 'application/x-protobuf'
+      end
+      it 'returns application/octet-stream if the format is unknown' do
+        expect(content_type_for(:aaa)).to eql 'application/octet-stream'
+      end
+    end
+
+    describe '#format_for' do
+      it 'returns the format for the given content type' do
+        expect(format_for('application/json')).to eql :json
+        expect(format_for('application/x-protobuf')).to eql :protobuf
+      end
+      it 'raises an error if the content type is unknown' do
+        expect{format_for('aaa/bbb')}.to raise_error
+      end
+    end
+
+    describe '#short_mimetype' do
+      it 'returns the short mime type' do
+        expect(short_mimetype(ResponseDescriptor.new('ttt', 999, :json))).to eql 'ttt-v999+json'
+      end
+    end
+
+  end
+end