hyperion_http 0.1.2

data/spec/lib/hyperion/logger_spec.rb

@@ -0,0 +1,60 @@
+require 'rspec'
+require 'hyperion'
+require 'stringio'
+
+describe Hyperion::Logger do
+  include Hyperion::Logger
+
+  it 'logs to $stdout by default' do
+    output = StringIO.new
+    with_stdout(output) do
+      logger.debug 'xyzzy'
+      logger.debug 'qwerty'
+    end
+    output_str = output.string
+    expect(output_str).to include 'xyzzy'
+    expect(output_str).to include 'qwerty'
+  end
+
+  it 'logs to Rails.logger if present' do
+    rails, logger = double, double
+    allow(rails).to receive(:logger).and_return(logger)
+    expect(logger).to receive(:debug).with('xyzzy')
+
+    with_rails(rails) do
+      logger.debug 'xyzzy'
+    end
+  end
+
+  it 'respects the log level' do
+    output = StringIO.new
+    with_stdout(output) do
+      Hyperion::Logger.level = Logger::ERROR
+      logger.debug 'xyzzy'
+      logger.error 'qwerty'
+      Hyperion::Logger.level = Logger::DEBUG
+    end
+    output_str = output.string
+    expect(output_str).to include 'qwert'
+    expect(output_str).to_not include 'xyzzy'
+  end
+
+  def with_stdout(tmp_stdout)
+    old = $stdout
+    $stdout = tmp_stdout
+    begin
+      yield
+    ensure
+      $stdout = old
+    end
+  end
+
+  def with_rails(rails)
+    Kernel.const_set(:Rails, rails)
+    begin
+      yield
+    ensure
+      Kernel.send(:remove_const, :Rails)
+    end
+  end
+end

data/spec/lib/hyperion/test_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+require 'hyperion_test'
+
+describe Hyperion do
+  include Hyperion::Formats
+
+  before :each do
+    Hyperion.configure do |config|
+      config.vendor_string = 'indigobio-ascent'
+    end
+  end
+
+  let(:user_response_params) { ResponseDescriptor.new('user', 1, :json) }
+
+  context 'given some routes' do
+    let!(:get_user_route){RestRoute.new(:get, 'http://somesite.org/users/0', user_response_params)}
+    let!(:post_greeting_route){RestRoute.new(:post, 'http://somesite.org/say_hello',
+                                             ResponseDescriptor.new('greeting', 1, :json),
+                                             PayloadDescriptor.new(:json))}
+    before :each do
+      Hyperion.fake('http://somesite.org') do |svr|
+        svr.allow(get_user_route) do
+          {'name' => 'freddy'}
+        end
+        svr.allow(post_greeting_route) do |req|
+          {'greeting' => "hello, #{req.body['name']}"}
+        end
+      end
+    end
+    it 'implements specific routes' do
+      result = Hyperion.request(get_user_route)
+      expect_success(result, {'name' => 'freddy'})
+
+      result = Hyperion.request(post_greeting_route, write({'name' => 'freddy'}, :json))
+      expect_success(result, {'greeting' => 'hello, freddy'})
+    end
+    it 'returns 404 if a requested route is not stubbed' do
+      bad_path = RestRoute.new(:get, 'http://somesite.org/abc', user_response_params)
+      bad_headers = RestRoute.new(:get, 'http://somesite.org/users/0', ResponseDescriptor.new('abc', 1, :json))
+
+      result = Hyperion.request(bad_path)
+      expect(result.code).to eql 404
+
+      result = Hyperion.request(bad_headers)
+      expect(result.code).to eql 404
+    end
+
+    context 'when a rack result is provided for the response' do
+
+      it 'allows rack results to be returned' do
+        arrange([400, {}, nil])
+        act
+        expect(@result.code).to eql 400
+        expect(@result.body).to be_nil
+      end
+
+      it 'serializes the body as json if it is not a string' do
+        arrange([200, {}, {'foo' => 'bar'}])
+        act
+        expect(@result.body).to eql({'foo' => 'bar'})
+      end
+
+      def arrange(response)
+        Hyperion.fake(get_user_route.uri.base) do |svr|
+          svr.allow(get_user_route) { response }
+        end
+      end
+
+      def act
+        @result = Hyperion.request(get_user_route)
+      end
+    end
+  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)
+    Hyperion.fake(route1.uri.base) do |svr|
+      svr.allow(route1) {{}}
+    end
+    Hyperion.request(route2)
+  end
+
+  it 'considers the HTTP method to be part of the route' do
+    Hyperion.fake('http://somesite.org') do |svr|
+      svr.allow(:get, '/users/0') do
+        success_response({'name' => 'freddy'})
+      end
+      svr.allow(:post, '/users/0') do |req|
+        success_response({'updated' => {'name' => req.body['name']}})
+      end
+    end
+
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/users/0', user_response_params))
+    expect(result.body).to eql({'name' => 'freddy'})
+
+    result = Hyperion.request(RestRoute.new(:post, 'http://somesite.org/users/0',
+                                            user_response_params, PayloadDescriptor.new(:json)),
+                              write({'name' => 'annie'}, :json))
+    expect(result.body).to eql({'updated' => {'name' => 'annie'}})
+  end
+
+  it 'considers the path to be part of the route' do
+    Hyperion.fake('http://somesite.org') do |svr|
+      svr.allow(:get, '/users/0') do
+        success_response({'name' => 'freddy'})
+      end
+      svr.allow(:get, '/users/1') do
+        success_response({'name' => 'annie'})
+      end
+    end
+
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/users/0', user_response_params))
+    expect(result.body).to eql({'name' => 'freddy'})
+
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/users/1', user_response_params))
+    expect(result.body).to eql({'name' => 'annie'})
+  end
+
+  it 'considers the headers to be part of the route' do
+    Hyperion.fake('http://somesite.org') do |svr|
+      svr.allow(:get, '/users/0', {'Accept' => 'application/vnd.indigobio-ascent.user-v1+json'}) do
+        success_response({'name' => 'freddy'})
+      end
+      svr.allow(:get, '/users/0', {'Accept' => 'application/vnd.indigobio-ascent.full_user-v1+json'}) do
+        success_response({'first_name' => 'freddy', 'last_name' => 'kruger', 'address' => 'Elm Street'})
+      end
+    end
+
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/users/0', user_response_params))
+    expect(result.body).to eql({'name' => 'freddy'})
+
+    full_user_response_params = ResponseDescriptor.new('full_user', 1, :json)
+    result = Hyperion.request(RestRoute.new(:get, 'http://somesite.org/users/0', full_user_response_params))
+    expect(result.body).to eql({'first_name' => 'freddy', 'last_name' => 'kruger', 'address' => 'Elm Street'})
+  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'}) }
+    end
+
+    Hyperion.fake('http://indigo.com:3000') do |svr|
+      svr.allow(:get, '/welcome') { success_response({'text' => 'hello from indigo@3000'}) }
+    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://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:4000/welcome', user_response_params))
+    expect(result.body).to eql({'text' => 'hello from indigo@4000'})
+  end
+
+  it 'defaults the base port to port 80' do
+    Hyperion.fake('http://indigo.com') do |svr|
+      svr.allow(:get, '/welcome') { success_response({'text' => 'old handler'}) }
+    end
+
+    # override the previous one
+    Hyperion.fake('http://indigo.com:80') do |svr|
+      svr.allow(:get, '/welcome') { success_response({'text' => 'new handler'}) }
+    end
+
+    result = Hyperion.request(RestRoute.new(:get, 'http://indigo.com/welcome', user_response_params))
+    expect(result.body).to eql({'text' => 'new handler'})
+
+    result = Hyperion.request(RestRoute.new(:get, 'http://indigo.com:80/welcome', user_response_params))
+    expect(result.body).to eql({'text' => 'new handler'})
+  end
+
+  it 'allows routes to be augmented' do
+    Hyperion.fake('http://google.com') 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))
+    expect(result.body).to eql({'text' => 'hello'})
+
+    # augment the routes
+    Hyperion.fake('http://google.com') 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))
+    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))
+    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))
+    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))
+    expect(result.body).to eql({'user' => 'new user'})
+  end
+
+  def success_response(body)
+    [200, {'Content-Type' => 'application/json'}, write(body, :json)]
+  end
+
+  def expect_success(result, body)
+    expect(result.status).to eql HyperionStatus::SUCCESS
+    expect(result.code).to eql 200
+    expect(result.body).to eql body
+  end
+end

data/spec/lib/hyperion/types/client_error_response_spec.rb

@@ -0,0 +1,52 @@
+require 'hyperion'
+
+describe ClientErrorResponse do
+  describe '::from_attrs' do
+    it 'creates a ClientErrorResponse from a hash' do
+      hash = {
+          'message' => 'oops',
+          'code' => 'missing',
+          'errors' => [ make_error_attrs('assay') ],
+          'content' => 'stuff'
+      }
+      result = ClientErrorResponse.from_attrs(hash)
+      expect(result.message).to eql 'oops'
+      expect(result.code).to eql ClientErrorCode::MISSING
+      expect(result.content).to eql 'stuff'
+      expect(result.errors.size).to eql 1
+      error = result.errors.first
+      expect(error.code).to eql ClientErrorCode::MISSING
+      expect(error.resource).to eql 'assay'
+      expect(error.field).to eql 'name'
+      expect(error.value).to eql 'foo'
+      expect(error.reason).to eql 'because'
+    end
+  end
+
+  describe '::as_json' do
+    it 'converts to a hash' do
+      errors = [ ClientErrorDetail.new(ClientErrorCode::MISSING, 'x'),
+                 ClientErrorDetail.new(ClientErrorCode::INVALID, 'x') ]
+      err = ClientErrorResponse.new('oops', errors, ClientErrorCode::INVALID, 'the_content')
+      result = err.as_json
+      expect(result['message']).to eql 'oops'
+      expect(result['code']).to eql 'invalid'
+      expect(result['content']).to eql 'the_content'
+      expect(result['errors'].map(&['code'])).to eql %w(missing invalid)
+    end
+  end
+
+  def make_error(resource)
+    ClientErrorDetail.from_attrs(make_error_attrs(resource))
+  end
+
+  def make_error_attrs(resource)
+    {
+        'code' => 'missing',
+        'resource' => resource,
+        'field' => 'name',
+        'value' => 'foo',
+        'reason' => 'because'
+    }
+  end
+end

data/spec/lib/hyperion/types/hyperion_result_spec.rb

@@ -0,0 +1,17 @@
+require 'rspec'
+require 'hyperion'
+
+describe HyperionResult do
+  describe '#to_s' do
+    let!(:route) { RestRoute.new(:get, 'http://site.com/things') }
+    it 'returns something reasonable' do
+      verify_to_s(HyperionStatus::TIMED_OUT, nil, "Timed out: #{route.to_s}")
+      verify_to_s(HyperionStatus::CLIENT_ERROR, 400, "Client error: #{route.to_s}")
+      verify_to_s(HyperionStatus::CHECK_CODE, 321, "HTTP 321: #{route.to_s}")
+    end
+
+    def verify_to_s(status, code, expected)
+      expect(HyperionResult.new(route, status, code).to_s).to eql expected
+    end
+  end
+end

data/spec/lib/hyperion/types/hyperion_uri_spec.rb

@@ -0,0 +1,113 @@
+require 'rspec'
+require 'hyperion'
+
+describe HyperionUri do
+
+  it 'behaves like a normal URI' do
+    u = HyperionUri.new('http://yum.com:44/res?id=1&name=foo')
+    expect(u.scheme).to eql 'http'
+    expect(u.host).to eql 'yum.com'
+    expect(u.port).to eql 44
+    expect(u.path).to eql '/res'
+    expect(u.query).to eql 'id=1&name=foo'
+    expect(u.to_s).to eql 'http://yum.com:44/res?id=1&name=foo'
+    expect(u.inspect).to include 'http://yum.com:44/res?id=1&name=foo'
+  end
+
+  it 'accepts additional query parameters as a hash' do
+    u = HyperionUri.new('http://yum.com:44/res?id=1&name=foo', site: 'box')
+    expect(u.query).to eql 'id=1&name=foo&site=box'
+    expect(u.to_s).to eql 'http://yum.com:44/res?id=1&name=foo&site=box'
+    expect(u.inspect).to match %r{#<HyperionUri:0x[0-9a-f]+ http://yum\.com:44/res\?id=1&name=foo&site=box>}
+  end
+
+  it 'hash parameters override parameters in the uri' do
+    u = HyperionUri.new('http://yum.com:44/res?id=1&name=foo', name: 'bar')
+    expect(u.query).to eql 'id=1&name=bar'
+  end
+
+  it 'escapes query param values' do
+    u = HyperionUri.new('http://yum.com:44/res', name: 'foo bar', title: 'x&y')
+    expect(u.query).to eql 'name=foo+bar&title=x%26y'
+  end
+
+  it 'allows the query hash to be modified after construction' do
+    u = HyperionUri.new('http://yum.com:44/res')
+    u.query_hash[:name] = 'foo bar'
+    expect(u.query).to eql 'name=foo+bar'
+  end
+
+  it 'allows both string or symbol keys' do
+    u = HyperionUri.new('http://yum.com:44/res')
+    u.query_hash[:name] = 'foo bar'
+    u.query_hash['id'] = '123'
+    expect(u.query).to eql 'id=123&name=foo+bar'
+  end
+
+  it 'setting a query string replaces the query hash' do
+    u = HyperionUri.new('http://yum.com:44/res', name: 'foo bar')
+    u.query = 'a=1'
+    expect(u.query).to eql 'a=1'
+    expect(u.query_hash).to eql({'a' => '1'})
+  end
+
+  it 'orders query params by name' do
+    u = HyperionUri.new('http://yum.com:44/res', {b: 1, a: 2})
+    expect(u.query).to eql 'a=2&b=1'
+  end
+
+  it 'supports query params with array values' do
+    u = HyperionUri.new('http://yum.com:44/res?c[]=6&c[]=7', {a: 5, b: [1, '2', :three]})
+    expect(u.query).to eql 'a=5&b[]=1&b[]=2&b[]=three&c[]=6&c[]=7'
+  end
+
+  it 'raises an error when an invalid query is provided' do
+    not_a_hash = 'query must be a hash'
+    not_simple = 'query values must be simple'
+    expect_query_error(1, not_a_hash)
+    expect_query_error([], not_a_hash)
+    expect_query_error({a: {b: 1}}, not_simple)
+    expect_query_error({a: [1, [2, 3]]}, not_simple)
+    expect_query_error({a: [{b: 1}, {b: 2}]}, not_simple)
+    expect{HyperionUri.new('http://yum.com:44/res', nil)}.to_not raise_error
+  end
+
+  def expect_query_error(query, expected_error)
+    expect{HyperionUri.new('http://yum.com:44/res', query)}.to raise_error expected_error
+  end
+
+  describe '#initialize' do
+    it 'accepts strings' do
+      u = HyperionUri.new('http://yum.com')
+      expect(u.to_s).to eql 'http://yum.com'
+    end
+    it 'accepts HTTP URIs' do
+      u = HyperionUri.new(URI('http://yum.com'))
+      expect(u.to_s).to eql 'http://yum.com'
+    end
+    it 'accepts HTTPS URIs' do
+      u = HyperionUri.new(URI('https://yum.com'))
+      expect(u.to_s).to eql 'https://yum.com'
+    end
+    it 'accepts HyperionUris' do
+      a = HyperionUri.new('http://yum.com', name: 'foo bar')
+      u = HyperionUri.new(a)
+      expect(u.to_s).to eql 'http://yum.com?name=foo+bar'
+    end
+  end
+
+  describe '#base' do
+    it 'returns the base uri' do
+      u = HyperionUri.new('http://yum.com:44/res')
+      expect(u.base).to eql 'http://yum.com:44'
+    end
+  end
+
+  describe '#base=' do
+    it 'sets the base uri' do
+      u = HyperionUri.new('http://yum.com:44/res/123')
+      u.base = 'https://hello.com:55'
+      expect(u.to_s).to eql 'https://hello.com:55/res/123'
+    end
+  end
+end

data/spec/lib/hyperion_spec.rb

@@ -0,0 +1,187 @@
+require 'rspec'
+require 'hyperion'
+require 'stringio'
+
+describe Hyperion do
+  describe '::request' do
+    include Hyperion::Formats
+
+    it 'delegates to Typhoeus' do
+      method = :post
+      uri = 'http://somesite.org:5000/path/to/resource'
+      rd = ResponseDescriptor.new('data_type', 1, :json)
+      pd = PayloadDescriptor.new(:protobuf)
+      route = RestRoute.new(method, uri, rd, pd)
+      body = 'Ventura'
+      additional_headers = {'From' => 'dev@indigobio.com'}
+
+      expected_headers = {
+          'Accept' => "application/vnd.indigobio-ascent.#{rd.type}-v#{rd.version}+#{rd.format}",
+          'Content-Type' => 'application/x-protobuf',
+          'From' => 'dev@indigobio.com',
+          'Expect' => 'x'
+      }
+
+      expect(Hyperion::Typho).to receive(:request).
+                                     with(uri, {method: method, headers: expected_headers, body: 'Ventura'}).
+                                     and_return(make_typho_response(200, write({'foo' => 'bar'}, :json)))
+
+      result = Hyperion.request(route, body, additional_headers)
+      expect(result).to be_a HyperionResult
+      expect(result.status).to eql HyperionStatus::SUCCESS
+      expect(result.code).to eql 200
+      expect(result.body).to eql({'foo' => 'bar'})
+      expect(result.route).to eql route
+    end
+
+    context 'serialization' do
+      let!(:method){:post}
+      let!(:uri){'http://somesite.org:5000/path/to/resource'}
+      let!(:rd){ResponseDescriptor.new('data_type', 1, :json)}
+      let!(:pd){PayloadDescriptor.new(:json)}
+      let!(:route){RestRoute.new(method, uri, rd, pd)}
+      let!(:expected_headers){{
+          'Accept' => "application/vnd.indigobio-ascent.#{rd.type}-v#{rd.version}+#{rd.format}",
+          'Content-Type' => 'application/json',
+          'Expect' => 'x'
+      }}
+      it 'deserializes the response' do
+        allow(Hyperion::Typho).to receive(:request).and_return(make_typho_response(200, '{"a":"b"}'))
+        result = Hyperion.request(route)
+        expect(result.body).to eql({'a' => 'b'})
+      end
+      it 'serializes the payload' do
+        expect(Hyperion::Typho).to receive(:request).
+                                       with(uri, {method: method, headers: expected_headers, body: '{"c":"d"}'}).
+                                       and_return(make_typho_response(200, write({}, :json)))
+        Hyperion.request(route, {'c' => 'd'})
+      end
+      it 'deserializes 400-level errors to ClientErrorResponse' do
+        client_error = ClientErrorResponse.new('oops', [], ClientErrorCode::MISSING)
+        allow(Hyperion::Typho).to receive(:request).
+                                      with(uri, {method: method, headers: expected_headers, body: '{"c":"d"}'}).
+                                      and_return(make_typho_response(400, write(client_error.as_json, :json)))
+        result = Hyperion.request(route, {'c' => 'd'})
+        expect(result.body).to be_a ClientErrorResponse
+        expect(result.body.message).to eql 'oops'
+        expect(result.body.code).to eql ClientErrorCode::MISSING
+      end
+    end
+
+    context 'when a block is provided' do
+      let!(:route){RestRoute.new(:get, 'http://yum.com', ResponseDescriptor.new('x', 1, :json))}
+      it 'calls the block with the result' do
+        stub_typho_response(200)
+        yielded = nil
+        Hyperion.request(route) do |r|
+          yielded = r
+        end
+        expect(yielded).to be_a HyperionResult
+      end
+      it 'returns the return value of the block' do
+        stub_typho_response(200)
+        request_and_expect(123) do |_r|
+          123
+        end
+      end
+      context 'when switching on result properties' do
+        it 'returns the value of the matched block' do
+          stub_typho_response(200)
+          request_and_expect(456) do |r|
+            r.when(200) { 456 }
+            123
+          end
+        end
+        it 'returns the value of the request block if nothing matched' do
+          stub_typho_response(999)
+          request_and_expect(123) do |r|
+            r.when(200) { 456 }
+            123
+          end
+          request_and_expect(nil) do |r|
+            r.when(200) { 456 }
+          end
+        end
+        it 'matches return codes' do
+          stub_typho_response(200)
+          request_and_expect(true) do |r|
+            r.when(200) { true }
+          end
+        end
+        it 'matches return code ranges' do
+          stub_typho_response(404)
+          request_and_expect(true) do |r|
+            r.when(400..499) { true }
+          end
+        end
+        it 'matches result states' do
+          stub_typho_response(999, true)
+          request_and_expect(true) do |r|
+            r.when(HyperionStatus::TIMED_OUT) { true }
+          end
+        end
+        it 'matches client error codes' do
+          response = ClientErrorResponse.new('oops', [ClientErrorDetail.new(ClientErrorCode::MISSING, 'thing')])
+          stub_typho_response(400, false, response)
+          request_and_expect(true) do |r|
+            r.when(ClientErrorCode::MISSING) { true }
+          end
+        end
+        it 'matches arbitrary predicates' do
+          stub_typho_response(999)
+          request_and_expect(true) do |r|
+            r.when(->r{r.code == 999 && r.status == HyperionStatus::CHECK_CODE}) { true }
+          end
+        end
+        it 'the predicate can be arity 0' do
+          stub_typho_response(999)
+          request_and_expect(123) do |r|
+            r.when(->{true}) { 123 }
+          end
+        end
+        it 'when a predicate raises an error, it is caught and the predicate does not match' do
+          stub_typho_response(400)
+          request_and_expect(true) do |r|
+            r.when(->r{raise 'oops'}) { false }
+            r.when(400) { true }
+          end
+        end
+        it 'when the action raises an error, it is not caught' do
+          stub_typho_response(400)
+          expect do
+            request_and_expect(true) do |r|
+              r.when(400) { raise 'oops' }
+            end
+          end.to raise_error 'oops'
+        end
+        it 'stops after the first match' do
+          stub_typho_response(404)
+          request_and_expect('got 404') do |r|
+            r.when(HyperionStatus::TIMED_OUT) { 'timed out' }
+            r.when(300) { 'got 400-level' }
+            r.when(404) { 'got 404' }
+            r.when(400..499) { 'got 400-level' }
+          end
+        end
+      end
+
+      def request_and_expect(return_value, &block)
+        expect(Hyperion.request(route, &block)).to eql return_value
+      end
+    end
+
+    def stub_typho_response(code, timed_out=false, response={})
+      allow(Hyperion::Typho).to receive(:request).and_return(make_typho_response(code, write(response, :json), timed_out))
+    end
+
+    def make_typho_response(code, body, timed_out=false)
+      r = double
+      allow(r).to receive(:success?) { 200 <= code && code < 300 }
+      allow(r).to receive(:code) { code }
+      allow(r).to receive(:body) { body }
+      allow(r).to receive(:timed_out?) { timed_out }
+      r
+    end
+
+  end
+end