ephemeral_response 0.1.0 → 0.2.0

data/History.markdown

@@ -0,0 +1,18 @@
+History
+=======
+
+0.2.0 / master
+--------------
+
+#### Enhancements
+
+* Fixtures now have use .yml extension instead of .fixture.
+* Varying POST data and query strings create new fixtures. Previously, GET /
+  and GET /?foo=bar resulted in the same fixture.
+* Ability to reset configuration with EphemeralResponse::Configuration.reset
+* Ability to white list certain hosts. Responses will not be saved for Requests
+  made to hosts in the white list.
+  Use EphemeralResponse::Configuration.white_list = "localhost"
+* Ephemeral response prints to the Net/HTTP debugger when establishing a
+  connection. Just set http.set_debug_output = $stdout to see when Ephemeral
+  Response connects to a host.

data/README.markdown

@@ -3,50 +3,87 @@ Ephemeral Response
 
 _Save HTTP responses to give your tests a hint of reality._
 
-This is pretty much NetRecorder without the fakeweb dependency.
-
 ## Premise
 
-1. run tests
+Web responses are volatile. Servers go down, API's change, responses change and
+everytime something changes, your tests should fail. Mocking out web responses
+may speed up your test suite but the tests essentially become lies. Ephemeral
+Response encourages you to run your tests against real web services while
+keeping your test suite snappy by caching the responses and reusing them until
+they expire.
+
+1. run test suite
 2. all responses are saved to fixtures
-3. run tests
-4.  Return the cached response if it exists and isn't out of date.
+3. disconnect from the network
+4. run test suite
+
+## Example
+
+    require 'benchmark'
+    require 'ephemeral_response'
 
-    If a cached response exists but is out of date, update it with the real response
+    EphemeralResponse.activate
 
-    Cache the response if it doesn't exist
+    5.times do
+      puts Benchmark.realtime { Net::HTTP.get "example.com", "/" }
+    end
 
-## Usage
+    1.44242906570435     # First request caches the response as a fixture
+    0.000689029693603516
+    0.000646829605102539
+    0.00064396858215332
+    0.000645875930786133
 
-`$ vi spec/spec_helper.rb`
+## With Rspec
 
     require 'ephemeral_response'
 
     Spec::Runner.configure do |config|
+
       config.before(:suite) do
         EphemeralResponse.activate
       end
+
       config.after(:suite) do
         EphemeralResponse.deactivate
       end
+
     end
 
+All responses are cached in yaml files within spec/fixtures/ephemeral\_response.
+
+I'd recommend git ignoring this directory to ensure your tests always hit the
+remote service at least once and to prevent credentials (like API keys) from
+being stored in your repo.
+
 ### Configuration
-You can change the fixture directory which defaults to "spec/fixtures/ephemeral_response"
+
+Change the fixture directory; defaults to "spec/fixtures/ephemeral\_response"
 
     EphemeralResponse::Configuration.fixture_directory = "test/fixtures/ephemeral_response"
 
-You can change the elapsed time for when a fixture will expire; defaults to 24 hours
+Change the elapsed time for when a fixture will expire; defaults to 24 hours
 
     EphemeralResponse::Configuration.expiration = 86400 # 24 hours in seconds
 
-You can also pass a block when setting expiration which gets instance_eval'd
-giving you access to the awesome helper method `one_day`
+Pass a block when setting expiration to gain access to the awesome helper
+method `one_day`
 
-    EphemeralResponse::Configuration.expiration do
-      one_day * 30 # 60 * 60 * 24 * 30
+    EphemeralResponse::Configuration.expiration = lambda do
+      one_day * 30 # Expire in thirty days: 60 * 60 * 24 * 30
     end
 
+Always allow requests to be made to a host by adding it to the white list.
+Helpful when running ephemeral response with selenium which makes requests to
+the local server.
+
+    EphemeralResponse::Configuration.white_list = "localhost", "smackaho.st"
+
+## Similar Projects
+* [Net Recorder](http://github.com/chrisyoung/netrecorder)
+* [Stalefish](http://github.com/jsmestad/stale_fish)
+* [VCR](http://github.com/myronmarston/vcr)
+
 ## Note on Patches/Pull Requests
 
 * Fork the project.
@@ -59,4 +96,4 @@ giving you access to the awesome helper method `one_day`
 
 ## Copyright
 
-Copyright (c) 2010 Sandro Turriate. See LICENSE for details.
+Copyright (c) 2010 Sandro Turriate. See MIT_LICENSE for details.

data/Rakefile

@@ -14,8 +14,9 @@ begin
     gem.homepage = "http://github.com/sandro/ephemeral_response"
     gem.authors = ["Sandro Turriate"]
     gem.add_development_dependency "rspec", ">= 1.2.9"
-    gem.add_development_dependency "yard", ">= 0"
+    gem.add_development_dependency "yard", ">= 0.5.0"
     gem.add_development_dependency "fakefs", ">= 0.2.1"
+    gem.add_development_dependency "unicorn", ">= 1.0.0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/examples/simple_benchmark.rb

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift("lib")
+require 'rubygems'
+require 'lib/ephemeral_response'
+require 'benchmark'
+
+EphemeralResponse::Configuration.expiration = 5
+EphemeralResponse.activate
+
+# Run benchmarks against thefuckingweather.com
+# The first request takes much longer than the rest
+def benchmark_request(number=1)
+  uri = URI.parse('http://thefuckingweather.com/?RANDLOC=')
+  time = Benchmark.realtime do
+    Net::HTTP.get(uri)
+  end
+  puts "Request #{number} took #{time} secs"
+end
+
+5.times {|n| benchmark_request n + 1 }

data/examples/white_list.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift("lib")
+require 'rubygems'
+require 'lib/ephemeral_response'
+
+# Don't create fixtures for the localhost domain
+EphemeralResponse::Configuration.white_list = 'localhost'
+
+EphemeralResponse::Configuration.expiration = 5
+EphemeralResponse.activate
+
+# Start an HTTP server on port 19876 using netcat
+process = IO.popen %(echo "HTTP/1.1 200 OK\n\n" | nc -l 19876)
+at_exit { Process.kill :KILL, process.pid }
+sleep 1
+
+# Make a request to the server started above
+# No new fixtures are created in spec/fixtures/ephemeral_response/
+uri = URI.parse('http://localhost:19876/')
+Net::HTTP.get(uri)
+
+# Fixtures are still created for Google
+uri = URI.parse('http://www.google.com/')
+Net::HTTP.get(uri)
+
+puts "The following directory should only contain a fixture for google"
+puts
+listing_cmd = %(ls #{File.expand_path(EphemeralResponse::Configuration.fixture_directory)})
+puts listing_cmd
+puts %x(#{listing_cmd})

data/lib/ephemeral_response/configuration.rb

@@ -19,6 +19,20 @@ module EphemeralResponse
       @expiration || one_day
     end
 
+    def reset
+      @expiration = nil
+      @fixture_directory = nil
+      @white_list = nil
+    end
+
+    def white_list
+      @white_list ||= []
+    end
+
+    def white_list=(*hosts)
+      @white_list = hosts.flatten
+    end
+
     protected
 
     def one_day

data/lib/ephemeral_response/fixture.rb

@@ -1,7 +1,7 @@
 module EphemeralResponse
   class Fixture
     attr_accessor :response
-    attr_reader :method, :uri, :created_at
+    attr_reader :request, :uri, :created_at
 
     def self.fixtures
       @fixtures ||= {}
@@ -11,20 +11,27 @@ module EphemeralResponse
       @fixtures = {}
     end
 
-    def self.find(uri, method)
-      fixtures[Fixture.new(uri, method).identifier]
+    def self.find(uri, request)
+      fixtures[Fixture.new(uri, request).identifier]
     end
 
     def self.load_all
       clear
       if File.directory?(Configuration.fixture_directory)
-        Dir.glob("#{Configuration.fixture_directory}/*.fixture", &method(:load_fixture))
+        Dir.glob("#{Configuration.fixture_directory}/*.yml", &method(:load_fixture))
       end
       fixtures
     end
 
     def self.load_fixture(file_name)
-      fixture = YAML.load_file file_name
+      register YAML.load_file(file_name)
+    end
+
+    def self.find_or_initialize(uri, request, &block)
+      find(uri, request) || new(uri, request, &block)
+    end
+
+    def self.register(fixture)
       if fixture.expired?
         FileUtils.rm fixture.path
       else
@@ -32,26 +39,22 @@ module EphemeralResponse
       end
     end
 
-    def self.respond_to(uri, method)
-      fixture = Fixture.new(uri, method)
-      unless fixtures[fixture.identifier]
+    def self.respond_to(uri, request)
+      find_or_initialize(uri, request) do |fixture|
         fixture.response = yield
-        fixture.save
-        fixtures[fixture.identifier] = fixture
-      end
-      fixtures[fixture.identifier].response
+        fixture.register
+      end.response
     end
 
-    def initialize(uri, method)
-      @method = method
-      @uri = uri
-      @uri.normalize!
+    def initialize(uri, request)
+      @uri = uri.normalize
+      @request = deep_dup request
       @created_at = Time.now
       yield self if block_given?
     end
 
     def ==(other)
-      %w(method uri created_at response).all? do |attribute|
+      %w(request_identifier uri_identifier created_at response).all? do |attribute|
         send(attribute) == other.send(attribute)
       end
     end
@@ -65,12 +68,19 @@ module EphemeralResponse
     end
 
     def identifier
-      Digest::SHA1.hexdigest(normalized_name)[0..6]
+      Digest::SHA1.hexdigest("#{uri_identifier}#{request_identifier}")
+    end
+
+    def method
+      request.method
     end
 
     def normalized_name
-      normalized_path = uri.path.gsub(/\/$/, '').gsub('/', '-')
-      [uri.host, method, normalized_path].join("_")
+      [uri.host, method, fs_path].compact.join("_").gsub(/[\/.]/, '-')
+    end
+
+    def fs_path
+      uri.path.dup.sub!(/^\/(.+)$/, '\1')
     end
 
     def path
@@ -78,7 +88,14 @@ module EphemeralResponse
     end
 
     def register
-      FakeWeb.register_uri(method, uri, :response => response)
+      unless Configuration.white_list.include? uri.host
+        save
+        self.class.register self
+      end
+    end
+
+    def request_identifier
+      request.to_yaml.split(//).sort
     end
 
     def save
@@ -88,10 +105,24 @@ module EphemeralResponse
       end
     end
 
+    def uri_identifier
+      if uri.query
+        parts = uri.to_s.split("?", 2)
+        parts[1] = parts[1].split('&').sort
+        parts
+      else
+        uri.to_s
+      end
+    end
+
     protected
 
+    def deep_dup(object)
+      Marshal.load(Marshal.dump(object))
+    end
+
     def generate_file_name
-      "#{normalized_name}_#{identifier}.fixture"
+      "#{normalized_name}_#{identifier[0..6]}.yml"
     end
   end
 end

data/lib/ephemeral_response/net_http.rb

@@ -3,18 +3,28 @@ module Net
     alias request_without_ephemeral_response request
     alias connect_without_ephemeral_response connect
 
+    attr_reader :uri
+
     def connect
     end
     private :connect
 
+    def do_start_without_ephemeral_response
+      D "EphemeralResponse: establishing connection to #{uri}"
+      connect_without_ephemeral_response
+      @started = true
+    end
+    private :do_start_without_ephemeral_response
+
     def generate_uri(request)
       scheme = use_ssl? ? "https" : "http"
-      URI.parse("#{scheme}://#{conn_address}:#{conn_port}#{request.path}")
+      @uri = URI.parse("#{scheme}://#{conn_address}:#{conn_port}#{request.path}")
     end
 
     def request(request, body = nil, &block)
-      EphemeralResponse::Fixture.respond_to(generate_uri(request), request.method) do
-        connect_without_ephemeral_response
+      generate_uri(request)
+      EphemeralResponse::Fixture.respond_to(uri, request) do
+        do_start_without_ephemeral_response
         request_without_ephemeral_response(request, body, &block)
       end
     end

data/lib/ephemeral_response.rb

@@ -7,7 +7,7 @@ require 'ephemeral_response/configuration'
 require 'ephemeral_response/fixture'
 
 module EphemeralResponse
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 
   def self.activate
     deactivate
@@ -18,6 +18,7 @@ module EphemeralResponse
   def self.deactivate
     Net::HTTP.class_eval do
       remove_method(:generate_uri) if method_defined?(:generate_uri)
+      remove_method(:uri) if method_defined?(:uri)
       alias_method(:connect, :connect_without_ephemeral_response) if private_method_defined?(:connect_without_ephemeral_response)
       alias_method(:request, :request_without_ephemeral_response) if method_defined?(:request_without_ephemeral_response)
     end

data/spec/ephemeral_response/configuration_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe EphemeralResponse::Configuration do
   subject { EphemeralResponse::Configuration }
+
   describe "#fixture_directory" do
     it "has a default" do
       subject.fixture_directory.should == "spec/fixtures/ephemeral_response"
@@ -36,4 +37,51 @@ describe EphemeralResponse::Configuration do
       end
     end
   end
+
+  describe "#reset" do
+    it "resets expiration, fixture directory, and white list to the defaults" do
+      subject.fixture_directory = "test/fixtures/ephemeral_response"
+      subject.expiration = 1
+      subject.white_list = 'localhost'
+      subject.fixture_directory.should == "test/fixtures/ephemeral_response"
+      subject.expiration.should == 1
+      subject.white_list.should == ['localhost']
+
+      subject.reset
+
+      subject.fixture_directory.should == "spec/fixtures/ephemeral_response"
+      subject.expiration.should == 86400
+      subject.white_list.should == []
+    end
+
+    it "resets white list after the default has been modified" do
+      subject.white_list << "localhost"
+      subject.reset
+      subject.white_list.should be_empty
+    end
+  end
+
+  describe "#white_list" do
+    it "defaults to an empty array" do
+      subject.white_list.should == []
+    end
+
+    it "allows hosts to be pushed onto the white list" do
+      subject.white_list << 'localhost'
+      subject.white_list << 'smackaho.st'
+      subject.white_list.should == %w(localhost smackaho.st)
+    end
+  end
+
+  describe "#white_list=" do
+    it "sets a single host" do
+      subject.white_list = 'localhost'
+      subject.white_list.should == ['localhost']
+    end
+
+    it "sets multiple hosts" do
+      subject.white_list = 'localhost', 'smackaho.st'
+      subject.white_list.should == ['localhost', 'smackaho.st']
+    end
+  end
 end