hoodoo 1.0.2

data/spec/services/services/session_spec.rb

@@ -0,0 +1,432 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Session do
+
+  before :each do
+    Hoodoo::Services::Session::MockDalliClient.reset()
+  end
+
+  it 'initialises with default options' do
+    s = described_class.new()
+    expect( s.created_at ).to be_a( Time )
+    expect( Hoodoo::UUID.valid?( s.session_id ) ).to eq( true )
+    expect( s.memcached_host ).to be_nil
+    expect( s.caller_id ).to be_nil
+    expect( s.caller_version ).to eq( 0 )
+  end
+
+  it 'initialises with given options' do
+    s = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 2
+    )
+    expect( s.created_at ).to be_a( Time )
+    expect( s.session_id ).to eq( '1234' )
+    expect( s.memcached_host ).to eq( 'abcd' )
+    expect( s.caller_id ).to eq( '0987' )
+    expect( s.caller_version ).to eq( 2 )
+  end
+
+  it 'reports not expired when it has no expiry' do
+    s = described_class.new
+    expect( s.expired? ).to eq( false )
+  end
+
+  it 'knows if expired' do
+    s = described_class.new
+    s.instance_variable_set( '@expires_at', Time.now - 1 )
+    expect( s.expired? ).to eq( true )
+  end
+
+  it 'converts to a Hash' do
+    s = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 2
+    )
+    p = Hoodoo::Services::Permissions.new
+
+    s.permissions = p
+    s.identity = { 'foo' => 'foo', 'bar' => 'bar' }
+    s.scoping = { 'baz' => [ 'foo', 'bar', 'baz' ] }
+
+    h = s.to_h
+
+    expect( h ).to eq( {
+      'session_id'     => '1234',
+      'caller_id'      => '0987',
+      'caller_version' => 2,
+
+      'created_at'     => s.created_at.iso8601,
+
+      'identity'       => { 'foo' => 'foo', 'bar' => 'bar' },
+      'scoping'        => { 'baz' => [ 'foo', 'bar', 'baz' ] },
+      'permissions'    => p.to_h()
+    } )
+  end
+
+  it 'reads from a Hash' do
+    s = described_class.new
+    p = Hoodoo::Services::Permissions.new
+    c = Time.now.utc
+    e = Time.now.utc + 10
+    h = {
+      'session_id'     => '1234',
+      'caller_id'      => '0987',
+      'caller_version' => 2,
+
+      'created_at'     => c.iso8601,
+      'expires_at'     => e.iso8601,
+
+      'identity'       => { 'foo' => 'foo', 'bar' => 'bar' },
+      'scoping'        => { 'baz' => [ 'foo', 'bar', 'baz' ] },
+      'permissions'    => p.to_h()
+    }
+
+    s.from_h!( h )
+
+    expect( s.session_id ).to eq( '1234' )
+    expect( s.caller_id ).to eq( '0987' )
+    expect( s.caller_version ).to eq( 2 )
+    expect( s.created_at ).to eq( Time.parse( c.iso8601 ) )
+    expect( s.expires_at ).to eq( Time.parse( e.iso8601 ) )
+    expect( s.identity.foo ).to eq( 'foo' )
+    expect( s.identity.bar ).to eq( 'bar' )
+    expect( s.scoping.baz ).to eq( [ 'foo', 'bar', 'baz' ] )
+    expect( s.permissions.to_h ).to eq( p.to_h )
+  end
+
+  it 'saves/loads to/from Memcached' do
+    s1 = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 2
+    )
+
+    expect( s1.save_to_memcached ).to eq( :ok )
+
+    store = Hoodoo::Services::Session::MockDalliClient.store()
+    expect( store[ '1234' ] ).to_not be_nil
+    expect( store[ '0987' ] ).to eq( { :expires_at => nil, :value => { 'version' => 2 } } )
+
+    # Check that session gains an expiry time when saved.
+    #
+    expect( s1.expires_at ).to be_a( Time )
+
+    # Ensure "created_at" is significantly different in the next session.
+    # This is important to reliably detect session load failures in testing
+    # given "#iso8601()" time resolution limits and so-on.
+    #
+    sleep( 0.2 )
+
+    s2 = described_class.new
+    expect( s2.load_from_memcached!( s1.session_id ) ).to eq( :ok )
+
+    expect( s2.created_at ).to eq( Time.parse( s1.created_at.iso8601 ) )
+    expect( s2.expires_at ).to eq( Time.parse( s1.expires_at.iso8601 ) )
+    expect( s2.session_id ).to eq( s1.session_id )
+    expect( s2.memcached_host ).to be_nil
+    expect( s2.caller_id ).to eq( s1.caller_id )
+    expect( s2.caller_version ).to eq( s1.caller_version )
+  end
+
+  it 'refuses to save if a newer caller version is present' do
+    expect( described_class ).to receive( :connect_to_memcached ).twice.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+
+    # Save a session with a high caller version
+
+    s1 = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 4
+    )
+
+    expect( s1.save_to_memcached ).to eq( :ok )
+
+    # Save another with, initially, a lower caller version. The idea here
+    # is that session creation is underway when a caller gets updated.
+
+    s2 = described_class.new(
+      :session_id => '2345',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 3
+    )
+
+    expect( s2.save_to_memcached ).to eq( :outdated )
+  end
+
+  it 'invalidates a session if the client ID advances during its lifetime' do
+    expect( described_class ).to receive( :connect_to_memcached ).exactly( 4 ).times.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    loader = described_class.new
+
+    # Save a session with a low caller version.
+
+    s1 = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    expect( s1.save_to_memcached ).to eq( :ok )
+
+    # Save another with a higher caller version.
+
+    s2 = described_class.new(
+      :session_id => '2345',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 2
+    )
+
+    expect( s2.save_to_memcached ).to eq( :ok )
+
+    # Should not be able to load the first one anymore.
+
+    expect( loader.load_from_memcached!( '1234' ) ).to eq( :outdated )
+    expect( loader.load_from_memcached!( '2345' ) ).to eq( :ok       )
+  end
+
+  it 'refuses to load if the caller version is outdated' do
+    expect( described_class ).to receive( :connect_to_memcached ).exactly( 5 ).times.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    loader = described_class.new
+
+    # Save a session with a low caller version
+
+    s1 = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    expect( s1.save_to_memcached ).to eq( :ok )
+
+    # Should be able to load it back.
+
+    expect( loader.load_from_memcached!( '1234' ) ).to eq( :ok )
+
+    # Save another with a higher caller version.
+
+    s2 = described_class.new(
+      :session_id => '2345',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 2
+    )
+
+    expect( s2.save_to_memcached ).to eq( :ok )
+
+    # Try to load the first one again; should fail.
+
+    expect( loader.load_from_memcached!( '1234' ) ).to eq( :outdated )
+
+    # The newer one should load OK.
+
+    expect( loader.load_from_memcached!( '2345' ) ).to eq( :ok )
+  end
+
+  it 'refuses to load if expired' do
+    expect( described_class ).to receive( :connect_to_memcached ).twice.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    loader = described_class.new
+
+    # Save a session with a high caller version
+
+    s = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    expect( s ).to receive( :to_h ).and_wrap_original do | obj, args |
+      h = obj.call( *args )
+      h[ 'expires_at' ] = ( Time.now - 1 ).utc.iso8601
+      h
+    end
+
+    expect( s.save_to_memcached ).to eq( :ok )
+    expect( loader.load_from_memcached!( '1234' ) ).to eq( :outdated )
+  end
+
+  it 'can explicitly update a caller' do
+    s = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    expect( described_class ).to receive( :connect_to_memcached ).once.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+
+    expect( s.update_caller_version_in_memcached( '9944', 23                                                 ) ).to eq( :ok )
+    expect( s.update_caller_version_in_memcached( 'abcd', 2,  Hoodoo::Services::Session::MockDalliClient.new ) ).to eq( :ok )
+
+    store = Hoodoo::Services::Session::MockDalliClient.store()
+    expect( store[ '9944' ] ).to eq( { :expires_at => nil, :value => { 'version' => 23 } } )
+    expect( store[ 'abcd' ] ).to eq( { :expires_at => nil, :value => { 'version' => 2  } } )
+  end
+
+  it 'handles invalid session IDs when loading' do
+    expect( described_class ).to receive( :connect_to_memcached ).once.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    loader = described_class.new
+    expect( loader.load_from_memcached!( '1234' ) ).to eq( :not_found )
+  end
+
+  it 'complains if there is no caller ID' do
+    s = described_class.new
+    expect {
+      s.save_to_memcached()
+    }.to raise_error RuntimeError
+  end
+
+  it 'logs Memcached exceptions when loading' do
+    loader = described_class.new
+
+    expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :get ).once do
+      raise 'Mock Memcached connection failure'
+    end
+
+    expect( Hoodoo::Services::Middleware.logger ).to receive( :warn ).once.and_call_original
+    expect( loader.load_from_memcached!( '1234' ) ).to eq( :fail )
+  end
+
+  it 'logs Memcached exceptions when updating caller version during session saving' do
+    s = described_class.new(
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :set ).once do
+      raise 'Mock Memcached connection failure'
+    end
+
+    expect( Hoodoo::Services::Middleware.logger ).to receive( :warn ).once.and_call_original
+    expect( s.save_to_memcached() ).to eq( :fail )
+  end
+
+  it 'logs Memcached exceptions when saving session' do
+    s = described_class.new(
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :set ).once.and_call_original
+    expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :set ).once do
+      raise 'Mock Memcached connection failure'
+    end
+
+    expect( Hoodoo::Services::Middleware.logger ).to receive( :warn ).once.and_call_original
+    expect( s.save_to_memcached() ).to eq( :fail )
+  end
+
+  it 'can be deleted' do
+    s = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    s.save_to_memcached
+
+    expect{ s.delete_from_memcached }.to change{ s.load_from_memcached!( s.session_id ) }.from( :ok ).to( :not_found )
+  end
+
+  it 'handles attempts to delete not-found things' do
+    s = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    expect( s.delete_from_memcached ).to eq( :not_found )
+  end
+
+  it 'logs and reports deletion exceptions' do
+    fdc = Hoodoo::Services::Session::MockDalliClient.new
+    s = described_class.new(
+      :session_id => '1234',
+      :memcached_host => 'abcd',
+      :caller_id => '0987',
+      :caller_version => 1
+    )
+
+    s.save_to_memcached
+
+    allow( described_class ).to receive( :connect_to_memcached ) {
+      raise 'Intentional exception'
+    }
+
+    expect( Hoodoo::Services::Middleware.logger ).to receive( :warn )
+    expect( s.delete_from_memcached ).to eq( :fail )
+  end
+
+  # We really can't do this without insisting on testers having a
+  # Memcached instance; instead, assume Dalli works (!) and mock it.
+  #
+  context 'real Memcached connection code test coverage' do
+    before :example do
+      # Clear the connection cache for each test
+      Hoodoo::Services::Session.class_variable_set( '@@dalli_clients', nil ) # Hack for test!
+      Hoodoo::Services::Session::MockDalliClient.bypass( true )
+    end
+
+    after :example do
+      Hoodoo::Services::Session::MockDalliClient.bypass( false )
+    end
+
+    it 'complains about a missing host' do
+      expect {
+        described_class.connect_to_memcached( nil )
+      }.to raise_error RuntimeError
+
+      expect {
+        described_class.connect_to_memcached( '' )
+      }.to raise_error RuntimeError
+    end
+
+    it 'tries to connect' do
+      expect_any_instance_of( Dalli::Client ).to receive( :stats ).and_return( {} )
+      expect( described_class.connect_to_memcached( '256.2.3.4:0' ) ).to be_a( Dalli::Client )
+    end
+
+    it 'handles connection failures' do
+      expect_any_instance_of( Dalli::Client ).to receive( :stats ).and_return( nil )
+      expect {
+        described_class.connect_to_memcached( '256.2.3.4:0' )
+      }.to raise_error RuntimeError
+    end
+
+    it 'handles connection exceptions' do
+      expect_any_instance_of( Dalli::Client ).to receive( :initialize ) do
+        raise 'Mock Memcached connection failure'
+      end
+
+      expect {
+        described_class.connect_to_memcached( '256.2.3.4:0' )
+      }.to raise_error RuntimeError
+    end
+
+    it 'only initialises once for one given host' do
+      expect( Dalli::Client ).to receive( :new ).once.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+
+      1.upto( 3 ) do
+        described_class.connect_to_memcached( 'one' )
+      end
+
+      expect( Dalli::Client ).to receive( :new ).once.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+
+      1.upto( 3 ) do
+        described_class.connect_to_memcached( 'two' )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,298 @@
+require 'webrick'
+require 'webrick/https'
+
+# Set the correct environment for testing.
+
+ENV[ 'RACK_ENV' ] = 'test'
+
+# Configure the code coverage analyser.
+
+require 'simplecov'
+require 'simplecov-rcov'
+
+SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+# Debugging support.
+
+require 'byebug'
+
+# The ActiveRecord extensions need testing in the context of a database. I
+# did consider NullDB - https://github.com/nulldb/nulldb - but this was too
+# far from 'the real thing' for my liking. Instead, we use SQLite in memory
+# and DatabaseCleaner to reset state between tests.
+#
+# http://stackoverflow.com/questions/7586813/fake-an-active-record-model-without-db
+
+require 'database_cleaner'
+require 'active_record'
+require 'logger'
+
+# Include AlchemyAMQ for testing only.
+
+# TODO: See spec/alchemy/alchemy-amq.rb. Remove this once 'real' Alchemy
+#       is opened.
+#
+$LOAD_PATH.unshift File.join( File.dirname( __FILE__ ), 'alchemy' )
+
+begin
+  require 'alchemy-amq'
+rescue LoadError
+  raise 'Cannot load alchemy-amq; did you run me with "bundle exec..." ?'
+end
+
+# Now it's safe to require Rack test code and Hoodoo itself.
+
+require 'rack/test'
+require 'hoodoo'
+
+RSpec.configure do | config |
+
+  # Provides familiar-ish 'get'/'post' etc. DSL for simulated URL fetch tests.
+
+  config.include Rack::Test::Methods
+
+  # http://stackoverflow.com/questions/1819614/how-do-i-globally-configure-rspec-to-keep-the-color-and-format-specdoc-o
+  #
+  # Use color in STDOUT,
+  # use color not only in STDOUT but also in pagers and files.
+
+  config.color = true
+  config.tty   = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+
+  Kernel.srand config.seed
+
+  # Wake up Database Cleaner.
+
+  DatabaseCleaner.strategy = :transaction # MUST NOT be changed
+
+  database_name = 'hoodoo_test'
+
+  config.before( :suite ) do
+
+    # Redirect $stderr before each test so a test log gets written without
+    # disturbing the RSpec terminal output; make sure the session system is
+    # in "test mode"; make sure we get a unique DRb daemon instance for the
+    # tests, which we can shut down afterwards.
+
+    base_path = File.join( File.dirname( __FILE__ ), '..', 'log' )
+    log       = File.new( File.join( base_path, 'test.log' ), 'a+' )
+
+    $stderr.reopen(log)
+
+    $stderr << "\n" << "*"*80 << "\n"
+    $stderr << Time.now.to_s << "\n"
+    $stderr << "*"*80 << "\n\n"
+
+    Hoodoo::Services::Middleware.set_log_folder( base_path )
+
+    ENV[ 'HOODOO_DISCOVERY_BY_DRB_PORT_OVERRIDE' ] = Hoodoo::Utilities.spare_port().to_s()
+
+    # Connect to PostgreSQL before tests start.
+
+    spec_helper_connect_to_postgres()
+
+    # Sometimes if a user force quits the spec suite, the hoodoo_test database
+    # will not be deleted. The following makes sure it is removed now.
+
+    database_exists = ActiveRecord::Base.connection.execute(
+      "SELECT COUNT(*) FROM pg_database WHERE datname = '#{ database_name }'"
+    ).any?
+
+    if database_exists
+      ActiveRecord::Base.connection.drop_database( database_name )
+    end
+
+    # Create the test database (hiding output) and connect to it.
+
+    ActiveRecord::Base.logger = Logger.new( nil )
+    ActiveRecord::Base.connection.create_database( database_name )
+    ActiveRecord::Base.logger = Logger.new( STDERR )
+
+    spec_helper_connect_to_postgres( database_name )
+
+  end
+
+  config.after( :suite ) do
+
+    # Delete the test database afterwards. Must disconnect from it
+    # first, going back to the default 'postgresql' database instead.
+
+    begin
+      spec_helper_connect_to_postgres()
+      ActiveRecord::Base.connection.drop_database( database_name )
+    rescue
+      # Ignore exceptions. Any failures to delete the database will
+      # be picked up by the at-test-startup precautionary delete
+      # anyway.
+    end
+
+    # Shut down the DRb discoverer.
+
+    begin
+      drb_uri = Hoodoo::Services::Discovery::ByDRb::DRbServer.uri()
+      drb_service = DRbObject.new_with_uri( drb_uri )
+      drb_service.stop()
+    rescue
+      # Ignore exceptions. For test subsets or depending on test order,
+      # there might not be a DRb service to shut down.
+    end
+
+  end
+
+  # Make sure DatabaseCleaner runs between each test.
+
+  config.before( :each ) do
+    DatabaseCleaner.start
+  end
+
+  config.after( :each ) do
+    DatabaseCleaner.clean
+  end
+end
+
+# Connect to PostgreSQL for test purposes. Generally only used within
+# the "spec_helper.rb" file for environment setup and teardown.
+#
+# +database_name+:: Name of database to which a connection should be
+#                   established. If omitted, connects to engine default
+#                   of 'postgres'.
+#
+def spec_helper_connect_to_postgres( database_name = 'postgres' )
+  ActiveRecord::Base.establish_connection(
+    :adapter  => 'postgresql',
+    :username => ENV[ 'DATABASE_USER' ],
+    :database => database_name
+  )
+end
+
+# For things like ActiveRecord::Migrations used during database-orientated
+# tests, or for certain logger tests, have to silence +STDOUT+ chatter to
+# avoid messing up RSpec's output, but we need to be sure it's restored.
+#
+# &block:: Block of code to call while +STDOUT+ is disabled.
+#
+def spec_helper_silence_stdout( &block )
+  Kernel.silence_stream( STDOUT, &block )
+end
+
+# Start up a service application under WEBrick via Rack on localhost, using
+# any available free port. The server is run in a Ruby Thread and *cannot be
+# killed* once started. It will only exit when the entire calling process shuts
+# down.
+#
+# Only returns once the server is running and accepting connections. Returns
+# the port number upon which the server is listening.
+#
+# +app_class+:: Hoodoo::Services::Service subclass for the service to start.
+#
+# +use_ssl+::   If +true+, SSL self-signed certificates in +spec/files+ are
+#               used to support SSL testing, provided certificate chain
+#               verification is bypassed. Optional; default is +false+, which
+#               uses normal HTTP.
+#
+def spec_helper_start_svc_app_in_thread_for( app_class, use_ssl = false, app_options = {} )
+
+  port = Hoodoo::Utilities.spare_port()
+
+  Thread.start do
+    app = Rack::Builder.new do
+      use Hoodoo::Services::Middleware unless app_options[:skip_hoodoo_middleware]
+      run app_class.new
+    end
+
+    options = {
+      :app    => app,
+      :Port   => port,
+      :Host   => '127.0.0.1',
+      :server => :webrick
+    }
+
+    if ( use_ssl )
+      pem = File.join( File.dirname( __FILE__ ), 'files', 'ssl.pem' )
+      key = File.join( File.dirname( __FILE__ ), 'files', 'ssl.key' )
+
+      options.merge!( {
+        :SSLEnable      => true,
+        :SSLCertificate => OpenSSL::X509::Certificate.new( File.open( pem ).read ),
+        :SSLPrivateKey  => OpenSSL::PKey::RSA.new( File.open( key ).read ),
+        :SSLCertName    => [ [ "CN", WEBrick::Utils::getservername() ] ]
+      } )
+    end
+
+    # This command never returns. Since this server usually brings up the
+    # service application before anything else happens (dependent upon the
+    # exact call order of a test, but it's always true at the time of writing),
+    # this is the application which will also run a local DRb server.
+
+    begin
+      Rack::Server.start( options )
+    rescue => e
+      puts "TEST SERVER FAILURE: #{e.inspect}"
+      puts e.backtrace
+    end
+  end
+
+  # Wait for the server to come up. I tried many approaches. In the end,
+  # only this hacky polling-talk-to-server code worked reliably.
+
+  repeat = true
+
+  while repeat
+    begin
+      spec_helper_http( path: '/', port: port, ssl: use_ssl )
+      repeat = false
+    rescue Errno::ECONNREFUSED
+      sleep 0.1
+    end
+  end
+
+  return port
+end
+
+# Run an HTTP request on localhost and return the result as a
+# +Net::HTTP::Response+ instance.
+#
+# +path+::    URI path _including_ leading "/".
+# +port+::    Port number (String or Integer)
+# +ssl+::     (Optional) +true+ to use HTTPS, else HTTP
+# +klass+::   (Optional) Class to use for request, default +Net::HTTP::Get+
+# +body+::    (Optional) Body for request (POST/PATCH only), default +nil+
+# +headers+:: (Optional) Header name/value Hash, default empty.
+#
+def spec_helper_http( path:,
+                      port:,
+                      ssl:     false,
+                      klass:   Net::HTTP::Get,
+                      body:    nil,
+                      headers: {} )
+
+  headers    = { 'Content-Type' => 'application/json; charset=utf-8' }.merge( headers )
+  remote_uri = URI.parse( "http://127.0.0.1:#{ port }#{ path }" )
+  http       = Net::HTTP.new( remote_uri.host, remote_uri.port )
+  request    = klass.new( remote_uri.request_uri() )
+
+  if ( ssl )
+    http.use_ssl     = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+  end
+
+  request.initialize_http_header( headers )
+  request.body = body unless body.nil?
+
+  return http.request( request )
+end