liquid-proxy 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,9 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+script: "bundle exec rspec --color spec && bundle exec cucumber --format progress"
+branches:
+  only:
+    - master
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in liquid-proxy.gemspec
+gemspec
+
+gem 'rspec'
+gem 'cucumber'
+gem 'awesome_print'
+gem 'thin'
+gem 'rake'

data/README.markdown

@@ -0,0 +1,80 @@
+# Liquid Proxy
+
+[![Build status](https://secure.travis-ci.org/artemave/liquid-proxy.png)](https://secure.travis-ci.org/artemave/liquid-proxy)
+
+## Overview
+
+Start http proxy that you can control via api in order to inject http headers into requests passing through.
+
+Why? I needed it to recreate parts of infrustructure in test environment (namely, the app under test was behind the proxy that takes care of authenticating users and passes on its checks in the form of http header).
+
+## Usage
+
+This is a ruby gem and it requires ruby >= 1.9.2.
+
+```ruby
+# Gemfile
+gem 'liquid-proxy'
+```
+    
+The following example shows usage with cucumber/capybara/selenium:
+
+```ruby
+# env.rb
+require 'capybara'
+require 'selenium-webdriver'
+require 'liquid-proxy'
+    
+LiquidProxy.start(:port => 9889)
+    
+Capybara.configure do |config|
+  config.default_driver = :selenium
+  config.run_server = false
+  config.app_host = "http://test.example.com"
+end
+        
+Capybara.register_driver :selenium do |app|
+  profile = Selenium::WebDriver::Firefox::Profile.new
+  profile.proxy = Selenium::WebDriver::Proxy.new(http: 'localhost:9889', type: :manual)
+
+  Capybara::Selenium::Driver.new(app, profile: profile)
+end
+    
+Before do
+  LiquidProxy.clear
+end
+```
+
+Then in step definitions you can:
+
+```ruby
+# set headers to inject
+LiquidProxy.headers_to_inject = {'Foo' => 'Bar', 'Accept' => 'Cash'}
+    
+# add to headers to inject
+LiquidProxy.headers_to_inject['X_HACKERY'] = 'BOOM'
+    
+# clear headers to inject
+LiquidProxy.clear
+```
+
+## Standalone usage
+
+If you are not using ruby, it is possible to run liquid-proxy as a standalone process and controll it via REST api:
+
+    # install
+    bash$ gem install liquid-proxy
+    
+    # start
+    bash$ liquid-proxy 8998
+    
+    # add headers
+    bash$ curl --data-binary '{"Foo":"Bar","Accept":"Cash"}' http://localhost:8998
+    
+    # clear headers
+    bash$ curl -X DELETE http://localhost:8998
+    
+
+## Author
+
+[Artem Avetisyan](https://github.com/artemave)

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+Bundler::GemHelper.install_tasks

data/bin/liquid-proxy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'em-proxy'
+require 'liquid-proxy/connection'
+
+LIQUID_PROXY_PORT = ARGV[0] || 8998
+HEADERS_TO_INJECT = {}
+
+Proxy.start(:host => 'localhost', :port => LIQUID_PROXY_PORT) do |conn|
+  LiquidProxy::Connection.setup(conn)
+end

data/features/change_headers.feature

@@ -0,0 +1,18 @@
+Feature: change HTTP headers
+  In order to create test scenarios that involve changing HTTP headers
+  As developer in test
+  I want to run the app under test via API controllable proxy
+  that can change headers of requests passing through
+
+  Background:
+    Given liquid-proxy is running
+    When I instruct liquid-proxy to add header "BOOM" with value "KABOOM"
+    And an http client makes request to a server via liquid-proxy
+
+  Scenario: add HTTP header
+    Then that server should see header "BOOM" with value "KABOOM" in incoming requests
+
+  Scenario: clear custom headers
+    When I instruct liquid-proxy to clear custom headers
+    And an http client makes request to a server via liquid-proxy
+    Then that server should not see header "BOOM" in incoming requests

data/features/step_definition/proxy_steps.rb

@@ -0,0 +1,27 @@
+Given /^liquid-proxy is running$/ do
+  LiquidProxy.start(:port => 9889)
+end
+
+When /^I instruct liquid\-proxy to add header "([^"]*)" with value "([^"]*)"$/ do |header, value|
+  LiquidProxy.headers_to_inject[header] = value
+end
+
+When /^an http client makes request to a server via liquid-proxy$/ do
+  proxy_class = Net::HTTP::Proxy('localhost', LiquidProxy.port)
+  res = proxy_class.start("localhost", TEST_APP_SERVER_PORT) do |http|
+    http.get "/something"
+  end
+  @request = JSON.parse(res.body)
+end
+
+Then /^that server should see header "([^"]*)" with value "([^"]*)" in incoming requests$/ do |header, value|
+  @request["HTTP_#{header}"].should == value
+end
+
+When /^I instruct liquid\-proxy to clear custom headers$/ do
+  LiquidProxy.headers_to_inject.clear
+end
+
+Then /^that server should not see header "([^"]*)" in incoming requests$/ do |header|
+  @request.should_not have_key("HTTP_#{header}")
+end

data/features/support/bin/appserver

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require "rack"
+require 'json'
+
+app = Proc.new do |env|
+  resp = env.select do |k,v|
+    v.respond_to?(:to_s)
+  end
+
+  [200, {"Content-Type" => "application/json"}, [resp.to_json]]
+end
+
+Rack::Handler::Thin.run(app, {:Host => "0.0.0.0", :Port => ARGV[0]})

data/features/support/env.rb

@@ -0,0 +1,35 @@
+$: << File.expand_path("../../../lib", __FILE__)
+require 'liquid-proxy'
+require 'net/http'
+require 'childprocess'
+require 'awesome_print'
+require 'json'
+
+TEST_APP_SERVER_PORT=8999
+
+def start_test_appserver
+  appserver = ChildProcess.build(File.expand_path("../bin/appserver", __FILE__), TEST_APP_SERVER_PORT.to_s)
+  appserver.io.inherit!
+  appserver.start
+
+  while true
+    begin
+      Net::HTTP.get "localhost", '/', TEST_APP_SERVER_PORT
+      break
+    rescue Errno::ECONNREFUSED
+      puts "Waiting for test appserver to start..."
+      sleep 0.5
+    end
+  end
+
+  def self.up?
+    RestClient.get server_address
+  rescue => e
+    !e.is_a?(Errno::ECONNREFUSED)
+  end
+  at_exit do
+    appserver.stop
+  end
+end
+
+start_test_appserver

data/lib/liquid-proxy.rb

@@ -0,0 +1,55 @@
+require 'singleton'
+require 'liquid-proxy/service'
+require 'json'
+require 'net/http'
+
+class LiquidProxy
+  include Singleton
+
+  class HeadersToInject
+    def []=(key, value)
+      http.post '/', {key => value}.to_json
+    end
+
+    def set_hash(hash = {})
+      clear
+      http.post '/', hash.to_json unless hash.empty?
+    end
+
+    def clear
+      http.delete '/'
+    end
+
+    private
+
+      def http
+        @http ||= Net::HTTP.new('127.0.0.1', LiquidProxy.port)
+      end
+  end
+
+  attr_reader :port
+
+  def headers_to_inject
+    @headers_to_inject ||= HeadersToInject.new
+  end
+
+  def headers_to_inject=(hash = {})
+    headers_to_inject.set_hash(hash)
+  end
+
+  def start(opts = {:port => 8998})
+    @port = opts[:port]
+
+    Service.start(opts)
+
+    Kernel.sleep 0.5
+    while not Service.up?
+      puts "Waiting for LiquidProxy to start..."
+      Kernel.sleep 0.5
+    end
+  end
+
+  def self.method_missing(*args)
+    instance.send(*args)
+  end
+end

data/lib/liquid-proxy/api_controller.rb

@@ -0,0 +1,23 @@
+require 'json'
+require 'http_tools'
+
+class LiquidProxy
+  module ApiController
+    def process_api_call
+      if parser.http_method =~ /delete/i
+        headers_to_inject.clear
+      else
+        new_headers = JSON.parse(body) rescue {}
+        headers_to_inject.merge!(new_headers)
+      end
+
+      send_data HTTPTools::Builder.response(:ok)
+      close_connection_after_writing
+    end
+
+    def api_call?
+      host, port = parser.headers['Host'].split(':')
+      host =~ /^(localhost|127.0.0.1)$/ && port == ::LIQUID_PROXY_PORT.to_s
+    end
+  end
+end

data/lib/liquid-proxy/connection.rb

@@ -0,0 +1,13 @@
+require 'liquid-proxy/connection_processor'
+
+class LiquidProxy
+  class Connection
+    def self.setup(conn)
+      conn.extend(ConnectionProcessor)
+
+      conn.on_data do |data|
+        conn.process_data(data)
+      end
+    end
+  end
+end

data/lib/liquid-proxy/connection_processor.rb

@@ -0,0 +1,47 @@
+require 'http/parser'
+require 'liquid-proxy/server_relay'
+require 'liquid-proxy/request_builder'
+require 'liquid-proxy/api_controller'
+
+class LiquidProxy
+  module ConnectionProcessor
+    include ServerRelay
+    include ApiController
+
+    def process_data(data)
+      parser << data
+    end
+
+    def parser
+      @parser ||= Http::Parser.new(self)
+    end
+
+    def body
+      @body ||= ''
+    end
+
+    def on_body(chunk)
+      body << chunk
+    end
+
+    def request_builder
+      @request_builder ||= RequestBuilder.new
+    end
+
+    def on_message_complete
+      if api_call?
+        process_api_call
+      else
+        parser.headers.merge!(headers_to_inject)
+
+        new_request = request_builder.build(parser, body)
+        body.clear
+        pass_to_server new_request
+      end
+    end
+
+    def headers_to_inject
+      @headers_to_inject ||= HEADERS_TO_INJECT
+    end
+  end
+end

data/lib/liquid-proxy/request_builder.rb

@@ -0,0 +1,15 @@
+require 'http_tools'
+
+class LiquidProxy
+  class RequestBuilder
+    def build(parser, body = '')
+      new_request = HTTPTools::Builder.request(
+        parser.http_method,
+        parser.headers['Host'],
+        parser.request_url,
+        parser.headers
+      )
+      new_request+= body
+    end
+  end
+end

data/lib/liquid-proxy/server_relay.rb

@@ -0,0 +1,9 @@
+class LiquidProxy
+  module ServerRelay
+    def pass_to_server request
+      host, port = parser.headers['Host'].split(':')
+      server :test, :host => host, :port => (port || 80).to_i
+      relay_to_servers request
+    end
+  end
+end

data/lib/liquid-proxy/service.rb

@@ -0,0 +1,27 @@
+require 'singleton'
+require 'liquid-proxy/subprocess'
+require 'utils/port_explorer'
+
+class LiquidProxy
+  class Service
+    include Singleton
+
+    def start(opts = {})
+      if @child and @child.alive?
+        return
+      end
+
+      @port = opts[:port]
+
+      @child = Subprocess.new(opts)
+    end
+
+    def up?
+      !!(@child && @child.alive? && Utils::PortExplorer.port_occupied?(@port))
+    end
+
+    def self.method_missing(*args)
+      instance.send(*args)
+    end
+  end
+end

data/lib/liquid-proxy/subprocess.rb

@@ -0,0 +1,19 @@
+require 'childprocess'
+
+class LiquidProxy
+  class Subprocess
+    def initialize(opts = {})
+      @child = ChildProcess.build(File.expand_path("../../../bin/liquid-proxy", __FILE__), opts[:port].to_s || "8998")
+      @child.io.inherit!
+      @child.start
+
+      at_exit do
+        @child.stop
+      end
+    end
+
+    def alive?
+      @child.alive?
+    end
+  end
+end

data/lib/liquid-proxy/version.rb

@@ -0,0 +1,3 @@
+class LiquidProxy
+  VERSION = "0.0.1"
+end

data/lib/utils/port_explorer.rb

@@ -0,0 +1,13 @@
+require 'socket'
+
+module Utils
+  class PortExplorer
+    def self.port_occupied?(port)
+      !!Net::HTTP.get('127.0.0.1', '/', port)
+    rescue => e
+      !e.is_a?(Errno::ECONNREFUSED)
+    else
+      true
+    end
+  end
+end

data/liquid-proxy.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "liquid-proxy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "liquid-proxy"
+  s.version     = LiquidProxy::VERSION
+  s.authors     = ["artemave"]
+  s.email       = ["artemave@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{http proxy with api for modifying requests passing through}
+  #s.description = %q{http proxy with api for modifying requests passing through}
+
+  s.rubyforge_project = "liquid-proxy"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_runtime_dependency "em-proxy"
+  s.add_runtime_dependency "http_tools"
+  s.add_runtime_dependency "http_parser.rb"
+  s.add_runtime_dependency 'childprocess'
+end

data/spec/api_controller_spec.rb

@@ -0,0 +1,51 @@
+require_relative "spec_helper"
+require 'liquid-proxy/api_controller'
+
+describe LiquidProxy::ApiController do
+  let :conn do
+    o = Object.new
+    o.extend(LiquidProxy::ApiController)
+    o
+  end
+
+  it 'knows when request is an api call' do
+    LIQUID_PROXY_PORT = 9876 unless defined?(LIQUID_PROXY_PORT)
+
+    conn.stub_chain('parser.headers').and_return('Host' => "localhost:#{LIQUID_PROXY_PORT}")
+    conn.api_call?.should == true
+  end
+
+  it 'knows when request is NOT an api call' do
+    conn.stub_chain('parser.headers').and_return('Host' => "localhost:1111")
+    conn.api_call?.should == false
+  end
+
+  it 'adds headers to inject' do
+    new_headers = {'X_HACK' => 'Boom'}
+    conn.stub(:send_data => nil, :close_connection_after_writing => nil, :parser => stub.as_null_object)
+    conn.stub(:body => new_headers.to_json)
+    conn.stub(:headers_to_inject => (headers_to_inject = mock))
+
+    headers_to_inject.should_receive(:merge!).with(new_headers)
+    conn.process_api_call
+  end
+
+  it 'clears off headers to inject if api request method is DELETE' do
+    conn.stub(:send_data => nil, :close_connection_after_writing => nil)
+    conn.stub_chain('parser.http_method').and_return('DELETE')
+    conn.stub(:headers_to_inject => (headers_to_inject = mock))
+    headers_to_inject.should_receive(:clear)
+    conn.process_api_call
+  end
+
+  it 'relays back to client' do
+    response = "response_#{Time.now}"
+    HTTPTools::Builder.stub(:response).with(:ok).and_return(response)
+    conn.stub(:headers_to_inject => stub.as_null_object, :parser => stub.as_null_object)
+
+    conn.should_receive(:send_data).with(response).ordered
+    conn.should_receive(:close_connection_after_writing).ordered
+
+    conn.process_api_call
+  end
+end

data/spec/connection_processor_spec.rb

@@ -0,0 +1,60 @@
+require_relative "spec_helper"
+require 'liquid-proxy/connection_processor'
+require 'liquid-proxy/server_relay'
+require 'liquid-proxy/api_controller'
+
+describe LiquidProxy::ConnectionProcessor do
+  let :conn do
+    o = Object.new
+    o.extend(LiquidProxy::ConnectionProcessor)
+    o.extend(LiquidProxy::ServerRelay)
+    o.extend(LiquidProxy::ApiController)
+    o
+  end
+
+  it 'feeds connection data to parser' do
+    data = 'data'
+    Http::Parser.stub(:new).and_return(parser = mock)
+    parser.should_receive(:<<).with(data)
+    conn.process_data(data)
+  end
+
+  it 'passes request through' do
+    HEADERS_TO_INJECT = {} unless defined?(HEADERS_TO_INJECT)
+    new_request = "new_request#{Time.now}"
+    parser = stub(:headers => {'Host' => 'localhost'})
+    conn.stub(
+      :body => (body = mock),
+      :parser => parser,
+      :request_builder => (request_builder = stub),
+      :api_call? => false
+    )
+    request_builder.stub(:build).with(conn.parser, conn.body).and_return(new_request)
+
+    body.should_receive(:clear)
+    conn.should_receive(:pass_to_server).with(new_request)
+
+    conn.on_message_complete
+  end
+
+  it 'adds custom headers to requests passing through' do
+    headers_to_inject = {'blah' => 'val1', 'boom' => 'val2'}
+
+    conn.stub(:server => nil, :relay_to_servers => nil, :api_call? => false)
+    conn.stub(:headers_to_inject => headers_to_inject)
+    conn.parser.stub(:headers).and_return(headers = mock.as_null_object)
+
+    headers.should_receive(:merge!).with(headers_to_inject)
+
+    conn.on_message_complete
+  end
+
+  it 'treats requests to itself as API calls' do
+    conn.stub(:server => nil, :relay_to_servers => nil)
+    conn.stub(:api_call? => true)
+
+    conn.should_receive(:process_api_call)
+    conn.should_not_receive(:pass_to_server)
+    conn.on_message_complete
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,17 @@
+require_relative "spec_helper"
+require 'liquid-proxy/connection'
+require 'liquid-proxy/connection_processor'
+
+describe LiquidProxy::Connection do
+  context "em-proxy connection setup" do
+    it 'feeds data to connection processor' do
+      conn = mock
+      conn.should_receive(:extend).with(LiquidProxy::ConnectionProcessor) # this assert stinks?
+      conn.should_receive(:on_data) do |&block|
+        conn.should_receive(:process_data).with("data")
+        block.call("data")
+      end
+      LiquidProxy::Connection.setup(conn)
+    end
+  end
+end

data/spec/liquid-proxy_spec.rb

@@ -0,0 +1,59 @@
+require_relative "spec_helper"
+require 'liquid-proxy'
+
+describe LiquidProxy do
+  before do
+    LiquidProxy::Service.reset_instance
+    LiquidProxy.reset_instance
+  end
+
+  it 'starts' do
+    LiquidProxy::Service.stub(:up?).and_return(true)
+    LiquidProxy::Service.should_receive(:start).with(:port => 1234)
+
+    LiquidProxy.start(:port => 1234)
+  end
+
+  it 'knows its port' do
+    LiquidProxy::Service.stub(:up?).and_return(true)
+    LiquidProxy::Service.stub(:start)
+
+    LiquidProxy.start(:port => 1234)
+    LiquidProxy.port.should == 1234
+  end
+
+  context 'when starting' do
+    it 'waits for proxy service to come up' do
+      LiquidProxy::Service.stub(:start)
+      LiquidProxy::Service.stub(:up?).and_return(false, false, true)
+      Kernel.should_receive(:sleep).with(0.5).exactly(3).times
+
+      LiquidProxy.start
+    end
+  end
+
+  context 'header injection' do
+    let :headers_to_inject do
+      mock('headers_to_inject')
+    end
+
+    before do
+      LiquidProxy::HeadersToInject.stub(:new).and_return(headers_to_inject)
+    end
+
+    it 'allows specify header as hash key' do
+      headers_to_inject.should_receive(:[]=).with('X_HACK', 'KABOOM')
+      LiquidProxy.headers_to_inject['X_HACK'] = 'KABOOM'
+    end
+
+    it 'allows specify headers by assigning hash' do
+      headers_to_inject.should_receive(:set_hash).with('X_HACK' => 'KABOOM')
+      LiquidProxy.headers_to_inject = {'X_HACK' => 'KABOOM'}
+    end
+
+    it 'clears off list headers to inject' do
+      headers_to_inject.should_receive(:clear)
+      LiquidProxy.headers_to_inject.clear
+    end
+  end
+end

data/spec/request_builder_spec.rb

@@ -0,0 +1,12 @@
+require_relative "spec_helper"
+require 'liquid-proxy/request_builder'
+
+describe LiquidProxy::RequestBuilder do
+  it 'builds HTTP request' do
+    body = '_with_body'
+    parser = stub(:http_method => 'method', :headers => {'Host' => 'host'}, :request_url => 'url')
+    HTTPTools::Builder.stub(:request).with('method', 'host', 'url', {'Host' => 'host'}).and_return('new_request')
+
+    LiquidProxy::RequestBuilder.new.build(parser, body).should == 'new_request_with_body'
+  end
+end

data/spec/server_relay_spec.rb

@@ -0,0 +1,26 @@
+require_relative "spec_helper"
+require 'liquid-proxy/server_relay'
+
+describe LiquidProxy::ServerRelay do
+  let :conn do
+    Object.new.extend(LiquidProxy::ServerRelay)
+  end
+
+  it 'relays to server usging host and port from incoming request' do
+    host, port = 'remotehost', 9876
+    conn.stub(:parser => stub(:headers => {'Host' => "#{host}:#{port}"}))
+
+    conn.should_receive(:server).with(anything, :host => host, :port => port).ordered
+    conn.should_receive(:relay_to_servers).with('new_request').ordered
+
+    conn.pass_to_server('new_request')
+  end
+
+  it 'uses port 80 by default' do
+    conn.stub(:relay_to_servers => nil, :parser => stub(:headers => {'Host' => "localhost"}))
+
+    conn.should_receive(:server).with(anything, :host => 'localhost', :port => 80)
+
+    conn.pass_to_server('new_request')
+  end
+end

data/spec/service_spec.rb

@@ -0,0 +1,62 @@
+require_relative 'spec_helper'
+require 'utils/port_explorer'
+require 'liquid-proxy/service'
+
+describe LiquidProxy::Service do
+  before do
+    LiquidProxy::Service.reset_instance
+  end
+
+  context 'when started' do
+    it 'starts subprocess' do
+      opts = {:host => 'localhost'}
+
+      LiquidProxy::Subprocess.should_receive(:new).with(opts)
+      LiquidProxy::Service.start(opts)
+    end
+
+    it 'does nothing if subprocess already running' do
+      LiquidProxy::Subprocess.should_receive(:new).once.and_return(stub(:alive? => true))
+      
+      LiquidProxy::Service.start
+      LiquidProxy::Service.start
+    end
+  end
+
+  it 'knows when it is up if subprocess is alive and service port is occupied' do
+    port = 1234
+    LiquidProxy::Subprocess.stub(:new).and_return(sp = stub(:alive? => true))
+
+    sp.should_receive(:alive?)
+    Utils::PortExplorer.should_receive(:port_occupied?).with(port).and_return(true)
+
+    LiquidProxy::Service.start(:port => port)
+    LiquidProxy::Service.up?.should == true
+  end
+
+  context 'it knows that it is NOT up' do
+    it 'if it has not been started' do
+      LiquidProxy::Service.up?.should == false
+    end
+
+    it 'if subprocess is not alive' do
+      LiquidProxy::Subprocess.stub(:new).and_return(sp = stub(:alive? => false))
+
+      sp.should_receive(:alive?)
+      LiquidProxy::Service.start
+      LiquidProxy::Service.up?.should == false
+    end
+
+    it 'if service port is not occupied' do
+      port = 1234
+      LiquidProxy::Subprocess.stub(:new).and_return(sp = stub(:alive? => true))
+
+      sp.should_receive(:alive?)
+      Utils::PortExplorer.should_receive(:port_occupied?).with(port).and_return(false)
+      
+      LiquidProxy::Service.start(:port => port)
+      LiquidProxy::Service.up?.should == false
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+
+$: << File.expand_path("../../../lib", __FILE__)
+
+require_relative 'support/reset-singleton'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

data/spec/subprocess_spec.rb

@@ -0,0 +1,49 @@
+require 'tempfile'
+require_relative 'spec_helper'
+require 'liquid-proxy/subprocess'
+
+describe LiquidProxy::Subprocess do
+  let :child do
+    double.as_null_object
+  end
+
+  before do
+    ChildProcess.stub(:build).and_return(child)
+  end
+
+  context 'ChildProcess start' do
+    it 'builds ChildProcess with cmd args from opts' do
+      opts = {:port => 1234}
+      ChildProcess.should_receive(:build) do |cmd, *params|
+        cmd.should =~ %r{bin/liquid-proxy}
+        params.should == ["1234"]
+      end
+      LiquidProxy::Subprocess.new(opts)
+    end
+    it 'inherits io and then starts child' do
+      child.should_receive(:io).ordered.and_return(io = mock)
+      io.should_receive(:inherit!)
+      child.should_receive(:start).ordered
+      LiquidProxy::Subprocess.new
+    end
+  end
+
+  it 'knows if it is alive' do
+    child.stub(:alive? => true)
+    p = LiquidProxy::Subprocess.new
+    p.alive?.should == true
+  end
+
+  it 'makes sure ChildProcess does not outlive parent' do
+    res_file = Tempfile.new('res')
+    child.stub(:stop) do
+      res_file.write "stopped"
+      res_file.rewind
+    end
+    fork do
+      LiquidProxy::Subprocess.new
+    end
+    Process.wait
+    res_file.read.should == 'stopped'
+  end
+end

data/spec/support/reset-singleton.rb

@@ -0,0 +1,15 @@
+require 'singleton'
+
+class <<Singleton
+  def included_with_reset(klass)
+    included_without_reset(klass)
+    class <<klass
+      def reset_instance
+        Singleton.send :__init__, self
+        self
+      end
+    end
+  end
+  alias_method :included_without_reset, :included
+  alias_method :included, :included_with_reset
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: liquid-proxy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- artemave
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-07 00:00:00.000000000 +00:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-proxy
+  requirement: &2161476040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161476040
+- !ruby/object:Gem::Dependency
+  name: http_tools
+  requirement: &2161475620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161475620
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: &2161475200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161475200
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: &2161474780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161474780
+description: 
+email:
+- artemave@gmail.com
+executables:
+- liquid-proxy
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- README.markdown
+- Rakefile
+- bin/liquid-proxy
+- features/change_headers.feature
+- features/step_definition/proxy_steps.rb
+- features/support/bin/appserver
+- features/support/env.rb
+- lib/liquid-proxy.rb
+- lib/liquid-proxy/api_controller.rb
+- lib/liquid-proxy/connection.rb
+- lib/liquid-proxy/connection_processor.rb
+- lib/liquid-proxy/request_builder.rb
+- lib/liquid-proxy/server_relay.rb
+- lib/liquid-proxy/service.rb
+- lib/liquid-proxy/subprocess.rb
+- lib/liquid-proxy/version.rb
+- lib/utils/port_explorer.rb
+- liquid-proxy.gemspec
+- spec/api_controller_spec.rb
+- spec/connection_processor_spec.rb
+- spec/connection_spec.rb
+- spec/liquid-proxy_spec.rb
+- spec/request_builder_spec.rb
+- spec/server_relay_spec.rb
+- spec/service_spec.rb
+- spec/spec_helper.rb
+- spec/subprocess_spec.rb
+- spec/support/reset-singleton.rb
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: liquid-proxy
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: http proxy with api for modifying requests passing through
+test_files:
+- features/change_headers.feature
+- features/step_definition/proxy_steps.rb
+- features/support/bin/appserver
+- features/support/env.rb
+- spec/api_controller_spec.rb
+- spec/connection_processor_spec.rb
+- spec/connection_spec.rb
+- spec/liquid-proxy_spec.rb
+- spec/request_builder_spec.rb
+- spec/server_relay_spec.rb
+- spec/service_spec.rb
+- spec/spec_helper.rb
+- spec/subprocess_spec.rb
+- spec/support/reset-singleton.rb