em-http-monitor 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in em-http-monitor.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,31 @@
+= Eventmachine HTTP monitor
+
+This does four things.
+
+== Print out debug info 
+
+  EM::Http::Monitor.debug(STDOUT)
+  # ...
+  EM::Http::Monitor.disconnect
+
+And you'll get useful debug info
+
+== Dump requests to disk
+
+  EM::Http::Monitor.dump("/path/to/directory")
+  # ...
+  EM::Http::Monitor.disconnect
+
+This will dump requests to disk.
+
+== Defer to disk or dump new
+
+  EM::Http::Monitor.use_and_dump("/path/to/directory")
+
+This will use fixtures if found, or, dump new requests to the file.
+
+== Only use dumped requests
+
+  EM::Http::Monitor.use("/path/to/directory")
+
+This will only use fixtures if found, or, errback.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+end

data/em-http-monitor.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/em-http-monitor/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "em-http-monitor"
+  s.version     = EM::Http::MonitorFactory::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = []
+  s.email       = []
+  s.homepage    = "http://rubygems.org/gems/em-http-monitor"
+  s.summary     = "Monitor, request recording and playback for em-http-request"
+  s.description = "Monitor, request recording and playback for em-http-request"
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "em-http-monitor"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/lib/em-http-monitor.rb

@@ -0,0 +1,244 @@
+require 'eventmachine'
+require 'em-http'
+require 'json'
+require 'ftools'
+
+module EventMachine
+  module Http
+    class MonitorFactory
+      
+      MockNotFoundError = Class.new(RuntimeError)
+      
+      OriginalHttpRequest = EM::HttpRequest unless const_defined?(:OriginalHttpRequest)
+      MockHttpRequest = EM::MockHttpRequest unless const_defined?(:MockHttpRequest)
+
+      class FakeHttpClient < EM::HttpClient
+        attr_writer :response
+        attr_reader :data
+        def setup(response, uri)
+          @uri = uri
+          if response == :fail
+            fail(self)
+          else
+            original_receive_data(response)
+            succeed(self)
+          end
+        end
+
+        def unbind
+        end
+        
+        def close_connection
+        end
+      end
+      
+      def debug(out = STDERR)
+        activate
+        install StreamOutputter.new(out)
+      end
+      
+      def dump(path)
+        activate
+        install FileOutputter.new(path)
+      end
+      
+      def clean_and_dump(path)
+        activate
+        outputter = FileOutputter.new(path)
+        outputter.reset
+        install outputter
+      end
+      
+      def use_and_dump(path)
+        activate
+        install MockingFileOutputter.new(path)
+      end
+      
+      def use(path)
+        activate
+        install FailingMockingFileOutputter.new(path)
+      end
+      
+      def deactivate
+        decativate_mocks
+        deactivate_methods
+      end
+      
+      def inform_receive(client, data)
+        @app.receive(client, data)
+      end
+      
+      def inform_send(client, data)
+        @app.send(client, data)
+      end
+      
+      def install(app)
+        @app = app
+      end
+      
+      def installed
+        @app
+      end
+      
+      protected
+      
+      def decativate_mocks
+      end
+      
+      def activate
+        EM::HttpClient.send(:class_eval, "
+unless method_defined?(:original_receive_data)
+  alias_method :original_receive_data, :receive_data
+  alias_method :original_send_data, :send_data
+
+  def receive_data(data)
+    EM::Http::Monitor.inform_receive(self, data) and original_receive_data(data)
+  end
+
+  def send_data(data)
+    EM::Http::Monitor.inform_send(self, data) and original_send_data(data)
+  end
+end
+        ", __FILE__, __LINE__)
+        
+        EM::HttpRequest.send(:class_eval, <<-HERE_DOC, __FILE__, __LINE__)
+unless method_defined?(:original_send_request)
+  include HttpEncoding
+  
+  alias_method :original_send_request, :send_request
+  def send_request(&blk)
+    uri = encode_query(@req.uri, @req.options[:query])
+    verb = @req.method
+    host = @req.uri.host
+    if EM::Http::Monitor.installed.respond_to?(:find_mock) and data = EM::Http::Monitor.installed.find_mock(verb, uri, host)
+      client = FakeHttpClient.new(nil)
+      client.setup(data, @req.uri)
+      client
+    else
+      original_send_request(&blk)
+    end
+  rescue MockNotFoundError
+    client = FakeHttpClient.new(nil)
+    client.setup(:fail, @req.uri)
+    client
+  end
+end
+        HERE_DOC
+        
+      end
+      
+      def deactivate_methods
+        EM::HttpClient.send(:class_eval, "
+if method_defined?(:original_receive_data)
+  alias_method :receive_data, :original_receive_data
+  alias_method :send_data, :original_send_data
+  undef_method :original_receive_data
+  undef_method :original_send_data
+end  
+        ", __FILE__, __LINE__)
+        EM::HttpRequest.send(:class_eval, "
+if method_defined?(:original_send_request)
+  alias_method :send_request, :original_send_request
+  undef_method :original_send_request
+end  
+        ", __FILE__, __LINE__)
+      end
+      
+      class StreamOutputter
+        def initialize(stream)
+          @stream = stream
+          @stream.sync = true
+        end
+
+        def send(client, data)
+          @stream << "#{client.object_id} >> #{data}"
+          @stream << "\n" unless data[-1] == 13 or data[-1] == 10
+          true
+        end
+
+        def receive(client, data)
+          @stream << "#{client.object_id} << #{data}"
+          @stream << "\n" unless data[-1] == 13 or data[-1] == 10
+          true
+        end
+      end
+
+      class FileOutputter
+        def initialize(file)
+          @file = file
+          @fh = File.new(file, 'a')
+          @fh.sync = true
+        end
+
+        def reset
+          File.truncate(@file, 0)
+        end
+
+        def send(client, data)
+          @fh.puts({:mode => 'send', :id => client.object_id, :data => data}.to_json)
+          @fh.fsync
+          true
+        end
+
+        def receive(client, data)
+          @fh.puts({:mode => 'receive', :id => client.object_id, :data => data}.to_json)
+          @fh.fsync
+          true
+        end
+      end
+      
+      class MockingFileOutputter < FileOutputter
+        
+        attr_reader :file
+        
+        class MockingData
+          attr_reader :sent, :received
+          
+          def initialize
+            @sent, @received = '', ''
+          end
+        end
+        
+        
+        def initialize(file)
+          @file = file
+          if File.exist?(file)
+            @mock_data = File.read(file).each_line.inject([]) do |hash, line|
+              data = JSON.parse(line)
+              if entry = hash.assoc(data['id'])
+                entry = entry.last
+              else
+                entry = MockingData.new
+                hash << [data['id'], entry]
+              end
+              case data['mode']
+              when 'send'
+                entry.sent << data['data']
+              when 'receive'
+                entry.received << data['data']
+              else
+                raise
+              end
+              hash
+            end
+          end
+          super
+        end
+
+        def find_mock(verb, uri, host)
+          if @mock_data and matching_data = @mock_data.find{ |d| d.last.sent[/^#{Regexp.quote(verb.to_s.upcase)} #{Regexp.quote(uri)} HTTP\/1\.[01][\r\n]/] and d.last.sent[/(Host:\s*#{Regexp.quote(host)})[\r\n]/] }
+            @mock_data.delete(matching_data).last.received
+          end
+        end
+      end
+      
+      class FailingMockingFileOutputter < MockingFileOutputter
+        def find_mock(verb, uri, host)
+          super or raise(MockNotFoundError, "Cannot find mock for #{verb} #{uri} #{host} in #{file}")
+        end
+      end
+    end
+  end
+end
+
+EM::Http::Monitor = EM::Http::MonitorFactory.new

data/lib/em-http-monitor/version.rb

@@ -0,0 +1,7 @@
+module EM
+  module Http
+    class MonitorFactory
+      VERSION = "0.0.1"
+    end
+  end
+end

data/spec/em_http_monitor_spec.rb

@@ -0,0 +1,97 @@
+$: << "#{File.dirname(__FILE__)}/../lib"
+
+require 'rubygems'
+require 'eventmachine'
+require 'em-http-monitor'
+require 'fileutils'
+
+DUMP_FILE = '/tmp/monitor_dump'
+
+describe "em-http-monitor" do
+  after(:each) do
+    EM::Http::Monitor.deactivate
+    FileUtils.rm_rf(DUMP_FILE)
+  end
+
+  it "should print debug info to the stream" do
+    io = StringIO.new
+    EM::Http::Monitor.debug(io)
+    EM.run do
+      http = EventMachine::HttpRequest.new("http://www.google.ca/").get :timeout => 2
+  
+      http.callback {
+        io.rewind
+        data = io.read
+        data.should match(/>> GET \/ HTTP\/1\.1\r\n/)
+        data.should match(/<< HTTP\/1\.1 200 OK\r\n/)
+        EM.stop
+      }
+    end
+  end
+  
+  it "should leave methods behind when it cleans up" do
+    EM::Http::Monitor.debug(STDOUT)
+    EM::HttpClient.instance_methods.should include('original_receive_data')
+    EM::Http::Monitor.deactivate
+    EM::HttpClient.instance_methods.should_not include('original_receive_data')
+  end
+  
+  it "should dump requests to disk" do
+    EM::Http::Monitor.dump(DUMP_FILE)
+    EM.run do
+      http = EventMachine::HttpRequest.new("http://www.google.ca/").get :timeout => 2
+  
+      http.callback {
+        lines = File.read(DUMP_FILE).split("\n").map{|line| JSON.parse(line)}
+        received_line = lines.shift
+        received_line['mode'].should == 'send'
+        received_line['data'].should match(/GET \/ HTTP\/1\.1\r\n/)
+        lines.size.should >= 1
+        lines.each {|line| line['mode'].should == 'receive' }
+        lines.first['data'].should match(/HTTP\/1\.1 200 OK\r\n/)
+        EM.stop
+      }
+    end
+  end
+
+  it "should use dumps to mock requests" do
+    EM::Http::Monitor.use_and_dump("#{File.dirname(__FILE__)}/fixtures/monitor_dump")
+    EM.run do
+      http = EventMachine::HttpRequest.new("http://news.google.com/").get :timeout => 10
+      http.callback {
+        http.response.should == 'yupyupyup'
+        http2 = EventMachine::HttpRequest.new("http://www.google.ca/").get :timeout => 10
+        http2.callback {
+          http2.response.should == 'heyheyhey'
+          EM.stop
+        }
+        http2.errback { |err|
+          p err
+          fail
+          EM.stop
+        }
+      }
+      http.errback { |err|
+        p err
+        fail
+        EM.stop
+      }
+    end
+  end
+
+  it "should only use dumps to mock requests" do
+    EM::Http::Monitor.use("#{File.dirname(__FILE__)}/fixtures/monitor_dump")
+    EM.run do
+      http = EventMachine::HttpRequest.new("http://www.slashdot.org/").get :timeout => 10
+      http.callback {
+        fail
+        EM.stop
+      }
+      http.errback { |err|
+        1.should == 1
+        EM.stop
+      }
+    end
+  end
+
+end

data/spec/fixtures/monitor_dump

@@ -0,0 +1,4 @@
+{"mode":"send","data":"GET / HTTP/1.1\r\nUser-Agent: EventMachine HttpClient\r\nHost: www.google.ca\r\n\r\n","id":2156920860}
+{"mode":"receive","data":"HTTP/1.1 200 OK\r\nDate: Wed, 22 Sep 2010 06:43:25 GMT\r\nContent-length: 9\r\n\r\nheyheyhey","id":2156920860}
+{"mode":"send","data":"GET / HTTP/1.1\r\nUser-Agent: EventMachine HttpClient\r\nHost: news.google.com\r\n\r\n","id":2150286760}
+{"mode":"receive","data":"HTTP/1.1 200 OK\r\nDate: Wed, 22 Sep 2010 06:43:25 GMT\r\nContent-length: 9\r\n\r\nyupyupyup","id":2150286760}

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: em-http-monitor
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+description: Monitor, request recording and playback for em-http-request
+email: []
+
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- em-http-monitor.gemspec
+- lib/em-http-monitor.rb
+- lib/em-http-monitor/version.rb
+- spec/em_http_monitor_spec.rb
+- spec/fixtures/monitor_dump
+has_rdoc: true
+homepage: http://rubygems.org/gems/em-http-monitor
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: em-http-monitor
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Monitor, request recording and playback for em-http-request
+test_files: []
+