rack_direct 0.1.2

data/README

@@ -0,0 +1 @@
+TBD

data/lib/rack_direct.rb

@@ -0,0 +1,6 @@
+require 'rack_direct/service'
+
+# TODO: 
+# when required, run an initializer that plugs into ActiveResource
+# support option to nuke/not nuke the testdb
+# auto-generate name as last element of path if it's not specified?

data/lib/rack_direct/active_resource.rb

@@ -0,0 +1,51 @@
+require 'active_resource'
+require 'rack_direct/service'
+require 'rack_direct/direct_response'
+
+module RackDirect
+
+  class ActiveResource::Connection
+
+    def request_with_filtering_rack_direct(method, path, *arguments)
+
+      # passthrough anything we don't understand
+      return request_without_filtering_rack_direct(method, path, *arguments) unless site.scheme.match(/^rack-direct/)
+
+      # puts "#{method.to_s.upcase} #{site.scheme}://#{site.host}:#{site.port}#{path}" if logger
+      result = nil
+
+      headers = arguments.last
+      body = arguments.first if arguments.length > 1
+
+      payload = {
+        # Note: We can't pass through a site.scheme of 'rack-direct'
+        # because the Rack instance on the receiving end will freak
+        # out. So we use http in the URI here.
+        "uri" => "http://#{site.host}:#{site.port}#{path}",
+        "method" => method.to_s.upcase,
+        "body" => body.to_s,
+        "CONTENT_TYPE" => headers["Content-Type"] || "text/plain;charset=utf-8",
+      }
+
+      result = JSON.parse(Service.send_request(site.host, payload))
+
+      result = DirectResponse.new result["status"], result["headers"], result["body"]
+
+      if Service.verbose_logging
+        puts "***** #{result.code} #{result.message}"
+        result.each_header { |k,v| puts "***** #{k}: #{v}" }
+        puts "***** START BODY"
+        puts result.body
+        puts "***** END BODY"
+      end
+
+      handle_response(result)
+    end
+
+    # TODO: requiring this more than once will not do the right thing
+    alias_method :request_without_filtering_rack_direct, :request
+    alias_method :request, :request_with_filtering_rack_direct
+
+  end
+
+end

data/lib/rack_direct/direct_handler.rb

@@ -0,0 +1,100 @@
+require 'json'
+require 'pp'
+
+module RackDirect
+  class DirectHandler
+    def self.run(app, options=nil)
+      @@verbose = options[:verbose]
+      request = []
+      while true
+        line = STDIN.gets
+        if line.blank?
+          begin
+            break if request[0] == "EXIT" || request[0].blank?
+            payload = JSON.parse request[0]
+            uri = payload["uri"]
+
+            #
+            # Fix up names in the hash to match what MockRequest is looking for
+            payload[:input] = payload["body"]
+            payload[:method] = payload["method"]
+            payload[:params] = payload["params"]
+
+            rack_env = Rack::MockRequest.env_for(uri, payload)
+            rack_env["rack.errors"] = STDERR
+
+            self.serve app, rack_env
+
+          rescue => e
+            STDERR.puts "Exception: #{e}"
+            e.backtrace.each { |x| STDERR.puts x }
+          ensure
+            request = []
+          end
+        else
+          request << line.strip
+        end
+      end
+    end
+
+    def self.serve(app, env)
+      if @@verbose
+        STDERR.puts "Calling serve"
+        STDERR.puts("Rack env:")
+        $> = STDERR
+        pp rack_env
+        $> = STDOUT
+        STDERR.puts("Body: #{rack_env["rack.input"].string}")
+      end
+
+      status, headers, body = app.call(env)
+
+      begin
+        body_string = ""
+        body.each { |part| body_string += part }
+        result = {
+          "status" => status,
+          "headers" => headers,
+          "body" => body_string
+        }
+
+        if @@verbose
+          STDERR.puts "Sending result (#{status})"
+          STDERR.puts result.to_json
+        end
+
+        unique_id = env["direct_request.unique_id"]
+
+        STDOUT.puts "BEGIN #{unique_id}"
+        STDOUT.puts result.to_json
+        STDOUT.puts "END #{unique_id}"
+        STDOUT.flush
+
+        if @@verbose
+          send_headers status, headers, STDERR
+          send_body body, STDERR
+        end
+      ensure
+        body.close  if body.respond_to? :close
+      end
+    end
+
+    def self.send_headers(status, headers, file = STDOUT)
+      file.print "Status: #{status}\r\n"
+      headers.each { |k, vs|
+        vs.each { |v|
+          file.print "#{k}: #{v}\r\n"
+        }
+      }
+      file.print "\r\n"
+      file.flush
+    end
+
+    def self.send_body(body, file = STDOUT)
+      body.each { |part|
+        file.print part
+        file.flush
+      }
+    end
+  end
+end

data/lib/rack_direct/direct_response.rb

@@ -0,0 +1,41 @@
+require 'rack'
+
+module RackDirect
+
+  class DirectResponse < Rack::MockResponse
+
+    include Net::HTTPHeader
+
+    def initialize(status, headers, body, errors=StringIO.new(""))
+      super(status, headers, body, errors)
+      # Set up @header to make methods in Net::HTTPHeader work
+      @header = {}
+      @headers.each do |k,v|
+        @header[k.downcase] = [v]
+      end
+    end
+
+    def code
+      self.status.to_s
+    end
+
+    def message
+      if Net::HTTPResponse::CODE_TO_OBJ[self.code]
+        Net::HTTPResponse::CODE_TO_OBJ[self.code].to_s.match(/Net::HTTP(.*)/).captures[0].underscore.humanize.titleize
+      else
+        case self.code
+        when /^2/
+          'OK'
+        when /^4/
+          'Not Found'
+        when /^3/
+          'Redirect'
+        else
+          'Error'
+        end
+      end
+    end
+
+  end
+
+end

data/lib/rack_direct/guid.rb

@@ -0,0 +1,237 @@
+#
+# Guid - Ruby library for portable GUID/UUID generation.
+#
+# Copyright (c) 2004 David Garamond <davegaramond at icqmail com>
+# 
+# This library is free software; you can redistribute it and/or modify it
+# under the same terms as Ruby itself.
+#
+
+if RUBY_PLATFORM =~ /mswin32|mingw|cygwin|bccwin32/i
+  module Guid_Win32_
+    require 'Win32API'
+          
+    PROV_RSA_FULL       = 1
+    CRYPT_VERIFYCONTEXT = 0xF0000000
+    FORMAT_MESSAGE_IGNORE_INSERTS  = 0x00000200
+    FORMAT_MESSAGE_FROM_SYSTEM     = 0x00001000
+  
+    CryptAcquireContext = Win32API.new("advapi32", "CryptAcquireContext",
+                                       'PPPII', 'L')
+    CryptGenRandom = Win32API.new("advapi32", "CryptGenRandom", 
+                                  'LIP', 'L')
+    CryptReleaseContext = Win32API.new("advapi32", "CryptReleaseContext",
+                                       'LI', 'L')
+    GetLastError = Win32API.new("kernel32", "GetLastError", '', 'L')
+    FormatMessageA = Win32API.new("kernel32", "FormatMessageA",
+                                  'LPLLPLPPPPPPPP', 'L')
+  
+    def lastErrorMessage
+      code = GetLastError.call
+      msg = "\0" * 1024
+      len = FormatMessageA.call(FORMAT_MESSAGE_IGNORE_INSERTS +
+                                FORMAT_MESSAGE_FROM_SYSTEM, 0,
+                                code, 0, msg, 1024, nil, nil,
+                                nil, nil, nil, nil, nil, nil)
+      msg[0, len].tr("\r", '').chomp
+    end
+  
+    def initialize
+      hProvStr = " " * 4
+      if CryptAcquireContext.call(hProvStr, nil, nil, PROV_RSA_FULL,
+                                  CRYPT_VERIFYCONTEXT) == 0
+        raise SystemCallError, "CryptAcquireContext failed: #{lastErrorMessage}"
+      end
+      hProv, = hProvStr.unpack('L')
+      @bytes = " " * 16
+      if CryptGenRandom.call(hProv, 16, @bytes) == 0
+        raise SystemCallError, "CryptGenRandom failed: #{lastErrorMessage}"
+      end
+      if CryptReleaseContext.call(hProv, 0) == 0
+        raise SystemCallError, "CryptReleaseContext failed: #{lastErrorMessage}"
+      end
+    end
+  end
+end
+
+module Guid_Unix_
+  @@random_device = nil
+  
+  def initialize
+    if !@@random_device
+      if File.exists? "/dev/urandom"
+        @@random_device = File.open "/dev/urandom", "r"
+      elsif File.exists? "/dev/random"
+        @@random_device = File.open "/dev/random", "r"
+      else
+        raise RuntimeError, "Can't find random device"
+      end
+    end
+
+    @bytes = @@random_device.read(16)
+  end
+end
+  
+class Guid
+  if RUBY_PLATFORM =~ /mswin32|mingw|cygwin|bccwin32/
+    include Guid_Win32_
+  else
+    include Guid_Unix_
+  end
+
+  def hexdigest
+    @bytes.unpack("h*")[0]
+  end
+
+  alias_method :to_hex , :hexdigest
+  
+  def to_s
+    @bytes.unpack("h8 h4 h4 h4 h12").join "-"
+  end
+  
+  def inspect
+    to_s
+  end
+  
+  def raw
+    @bytes
+  end
+  
+  def self.from_s(s)
+    raise ArgumentError, "Invalid GUID hexstring" unless
+      s =~ /\A[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\z/i
+    guid = Guid.allocate
+    guid.instance_eval { @bytes = [s.gsub(/[^0-9a-f]+/i, '')].pack "h*" }
+    guid
+  end
+
+  def self.from_raw(bytes)
+    raise ArgumentError, "Invalid GUID raw bytes, length must be 16 bytes" unless
+      bytes.length == 16
+    guid = Guid.allocate
+    guid.instance_eval { @bytes = bytes }
+    guid
+  end
+  
+  def ==(other)
+    @bytes == other.raw
+  end
+
+  # ------------------------------------------------------------------------
+  # jambool updates from:
+  # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/124607
+  @@d36 = ('a'..'z').to_a + ('0'..'9').to_a
+  @@rd36 = {}
+  @@d36.each_with_index {|d, i| @@rd36[d[0]] = i}
+
+  def Guid.from_base36(val)
+    val = val.downcase
+    raise ArgumentError unless val =~ /\A[a-z][a-z0-9]{24}\z/
+    n = 0
+    mult = 1
+    val.reverse.each_byte {|c|
+      n += @@rd36[c] * mult
+      mult *= 36
+    }
+    Guid.from_i(n)
+  end
+
+  def Guid.from_hex(s)
+    raise ArgumentError, "Invalid GUID hexstring" unless
+      s =~ /\A[0-9a-f]{32}\z/i
+    guid = Guid.allocate
+    guid.instance_eval { @bytes = [s.gsub(/[^0-9a-f]+/i, '')].pack "h*" }
+    guid
+  end
+
+
+  def Guid.from_i(val)
+    bytes = [
+        (val & 0xffffffff000000000000000000000000) >> 96,
+        (val & 0x00000000ffffffff0000000000000000) >> 64,
+        (val & 0x0000000000000000ffffffff00000000) >> 32,
+        (val & 0x000000000000000000000000ffffffff)
+      ].pack('NNNN')
+    guid = Guid.allocate
+    guid.instance_eval { @bytes = bytes }
+    guid
+  end
+
+  def to_i
+     (@bytes[ 0 ..  3].unpack('N')[0] << 96) +
+     (@bytes[ 4 ..  7].unpack('N')[0] << 64) +
+     (@bytes[ 8 .. 11].unpack('N')[0] << 32) +
+     (@bytes[12 .. 15].unpack('N')[0])
+  end
+
+  def to_base36
+    self.to_i.to_s(36).tr('0-9a-z', 'a-z0-9').rjust(25, 'a')
+    # self.to_s.tr('0-9a-z', 'a-z0-9').rjust(25, 'a')
+  end
+  # ------------------------------------------------------------------------
+end
+
+if __FILE__ == $0
+  require 'test/unit'
+  
+  class GuidTest < Test::Unit::TestCase
+    def test_new
+      g = Guid.new
+      
+      # different representations of guid: hexdigest, hex+dashes, raw bytes
+      assert_equal(0, g.to_s =~ /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
+      assert_equal(16, g.raw.length)
+      assert_equal(0, g.hexdigest =~ /\A[0-9a-f]{32}\z/)
+      assert_equal(g.hexdigest, g.to_s.gsub(/-/, ''))
+
+      # must be different each time we produce (this is just a simple test)
+      g2 = Guid.new
+      assert_equal(true, g != g2)
+      assert_equal(true, g.to_s != g2.to_s)
+      assert_equal(true, g.raw != g2.raw)
+      assert_equal(true, g.hexdigest != g2.hexdigest)
+      assert_equal(1000, (1..1000).select { |i| g != Guid.new }.length)
+    end
+    
+    def test_from_s
+      g = Guid.new
+      g2 = Guid.from_s(g.to_s)
+      assert_equal(g, g2)
+    end
+    
+    def test_from_raw
+      g = Guid.new
+      g2 = Guid.from_raw(g.raw)
+      assert_equal(g, g2)
+    end
+
+    def test_from_i
+      g = Guid.new
+      g2 = Guid.from_i(g.to_i)
+      assert_equal(g, g2)
+    end
+    
+    def test_from_base36
+      g = Guid.new
+      g2 = Guid.from_base36(g.to_base36)
+      assert_equal(g, g2)
+    end
+
+    def test_from_hex
+      g = Guid.new
+      g2 = Guid.from_hex(g.to_hex)
+      assert_equal(g, g2)
+    end
+
+    def test_harder
+      g1 = Guid.new
+      g2 = g1
+      assert_equal(g1, g2)
+      g1a = Guid.from_hex(Guid.from_s(Guid.from_i(g1.to_i).to_s).to_hex)
+      assert_equal(g1, g1a)
+      g2a = Guid.from_base36(Guid.from_i(g1.to_i).to_base36)
+      assert_equal(g2, g2a)
+      assert_equal(g1a, g2a)
+    end
+  end
+end

data/lib/rack_direct/service.rb

@@ -0,0 +1,103 @@
+require 'rack_direct/guid'
+require 'open3'
+require 'tmpdir'
+require 'rack_direct/active_resource'
+
+RACK_DIRECT_ALIAS = 'rack-direct'
+
+module RackDirect
+
+  class Service
+
+    class << self
+      attr_accessor :verbose_logging
+    end
+
+    @@services = {}
+    def self.start name, path
+      unless @@services[name]
+
+        tmppath = generate_rackup_file
+
+        # TODO: check path to make sure a Rails app exists there
+        print "Starting service rack-direct://#{name}..."
+        cmd = "cd #{path} && rake db:test:prepare && rackup --server #{RACK_DIRECT_ALIAS} #{tmppath} 2>&1"
+        # puts cmd
+        @@services[name] = IO.popen cmd, "w+"
+        puts "done."
+
+        at_exit do
+          RackDirect::Service.stop name
+          File.unlink tmppath
+        end
+      end
+      "rack-direct://#{name}"
+    end
+
+    def self.send_request name, rack_request_env
+
+      if @@services[name]
+
+        rack_request_env["direct_request.unique_id"] = Guid.new.to_s
+
+        @@services[name].puts rack_request_env.to_json
+        @@services[name].puts ""
+
+        response = ""
+        in_response = false
+        while true
+          line = @@services[name].gets
+          if line.strip == "BEGIN #{rack_request_env["direct_request.unique_id"]}"
+            in_response = true
+            next
+          elsif line.strip == "END #{rack_request_env["direct_request.unique_id"]}"
+            break
+          elsif in_response
+            response += line
+          else
+            puts "rack-direct://#{name}: #{line.strip}" if self.verbose_logging
+          end
+        end
+        # puts "Final response: #{response}"
+        response
+      end
+
+    end
+
+    def self.stop name
+      if @@services[name]
+        print "Stopping service rack-direct://#{name}..."
+        @@services[name].puts "EXIT"
+        @@services[name].puts ""
+        @@services[name] = nil
+        Process.waitall
+        puts "done."
+      end
+    end
+
+    private
+
+    def self.generate_rackup_file
+      rackup_file_contents = <<-EOF
+$: << '~/src/rack-direct/lib'
+require 'rack_direct/direct_handler'
+Rack::Handler.register('#{RACK_DIRECT_ALIAS}', 'RackDirect::DirectHandler')
+# puts "RackDirect::DirectHandler registered"
+
+require "config/environment"
+use Rails::Rack::LogTailer
+use Rails::Rack::Static
+run ActionController::Dispatcher.new
+EOF
+      tmppath = nil
+      Tempfile.open("rack_direct") { |x| tmppath = x.path + ".ru" }
+      tmpfile = File.open tmppath, "w+"
+      tmpfile.write rackup_file_contents
+      tmpfile.close
+
+      tmppath
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: rack_direct
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Brian Sharon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |
+  RackDirect allows you to easily perform integration tests between multiple Rails websites, by launching your ActiveResource services in a standalone process and communicating with them via stdio instead of over a socket.
+
+email: brian@floatplane.us
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/rack_direct/active_resource.rb
+- lib/rack_direct/direct_handler.rb
+- lib/rack_direct/direct_response.rb
+- lib/rack_direct/guid.rb
+- lib/rack_direct/service.rb
+- lib/rack_direct.rb
+has_rdoc: true
+homepage: http://floatplane.us/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: RackDirect allows you to easily perform integration tests between multiple Rails websites, by launching your ActiveResource services in a standalone process and communicating with them via stdio instead of over a socket.
+test_files: []
+