ephemeral_response 0.1.0 → 0.2.0

data/spec/ephemeral_response/fixture_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
 describe EphemeralResponse::Fixture do
-  let(:fixture_directory) { File.expand_path EphemeralResponse::Configuration.fixture_directory }
-  let(:uri) { URI.parse("http://example.com") }
-  let(:fixture) { EphemeralResponse::Fixture.new(uri, 'GET') { |f| f.response = "hello world"} }
+  include FakeFS::SpecHelpers
 
-  before do
-    clear_fixtures
-  end
+  let(:fixture_directory) { File.expand_path EphemeralResponse::Configuration.fixture_directory }
+  let(:request) { Net::HTTP::Get.new '/' }
+  let(:uri) { URI.parse("http://example.com/") }
+  let(:fixture) { EphemeralResponse::Fixture.new(uri, request) { |f| f.response = "hello world"} }
 
   describe ".load_all" do
     it "returns the empty fixtures hash when the fixture directory doesn't exist" do
@@ -24,72 +23,273 @@ describe EphemeralResponse::Fixture do
       before do
         FileUtils.mkdir_p fixture_directory
         Dir.chdir(fixture_directory) do
-          FileUtils.touch %w(1.fixture 2.fixture)
+          FileUtils.touch %w(1.yml 2.yml)
         end
       end
 
       it "calls #load_fixture for each fixture file" do
-        EphemeralResponse::Fixture.should_receive(:load_fixture).with("#{fixture_directory}/1.fixture")
-        EphemeralResponse::Fixture.should_receive(:load_fixture).with("#{fixture_directory}/2.fixture")
+        EphemeralResponse::Fixture.should_receive(:load_fixture).with("#{fixture_directory}/1.yml")
+        EphemeralResponse::Fixture.should_receive(:load_fixture).with("#{fixture_directory}/2.yml")
         EphemeralResponse::Fixture.load_all
       end
     end
   end
 
   describe ".load_fixture" do
+    it "loads the yamlized fixture into the fixtures hash" do
+      fixture.save
+      EphemeralResponse::Fixture.load_fixture(fixture.path)
+      EphemeralResponse::Fixture.fixtures.should have_key(fixture.identifier)
+    end
+  end
+
+  describe ".register" do
     context "fixture expired" do
       before do
         fixture.instance_variable_set(:@created_at, Time.new - (EphemeralResponse::Configuration.expiration * 2))
-        fixture.save
+        fixture.register
       end
 
-      it "removes the fixture" do
-        EphemeralResponse::Fixture.load_all
+      it "removes the fixture file" do
         File.exists?(fixture.path).should be_false
       end
 
-      it "does not add the fixture in the fixtures hash" do
-        EphemeralResponse::Fixture.load_all
+      it "does not add the fixture to the fixtures hash" do
         EphemeralResponse::Fixture.fixtures.should_not have_key(fixture.identifier)
       end
     end
 
     context "fixture not expired" do
       before do
-        fixture.save
+        fixture.register
       end
 
       it "adds the the fixture to the fixtures hash" do
-        EphemeralResponse::Fixture.load_all
         EphemeralResponse::Fixture.fixtures[fixture.identifier].should == fixture
       end
     end
   end
 
+  describe ".find" do
+    context "when fixture registered" do
+      it "returns the fixture" do
+        fixture.register
+        EphemeralResponse::Fixture.find(uri, request).should == fixture
+      end
+    end
+
+    context "when fixture not registered" do
+      it "returns nil" do
+        EphemeralResponse::Fixture.find(uri, request).should be_nil
+      end
+    end
+  end
+
+  describe ".find_or_initialize" do
+    context "when the fixture is registered" do
+      it "returns the registered fixture" do
+        fixture.register
+        EphemeralResponse::Fixture.find_or_initialize(uri, request).should == fixture
+      end
+    end
+
+    context "when the fixture doesn't exist" do
+      it "processes the block" do
+        EphemeralResponse::Fixture.find_or_initialize(uri, request) do |fixture|
+          fixture.response = "bah"
+        end.response.should == "bah"
+      end
+
+      it "returns the new fixture" do
+        fixture = EphemeralResponse::Fixture.find_or_initialize(uri, request)
+        EphemeralResponse::Fixture.fixtures[fixture.identifier].should be_nil
+      end
+    end
+  end
+
   describe ".respond_to" do
+    context "host included in white list" do
+      before do
+        EphemeralResponse::Configuration.white_list = uri.host
+      end
+
+      it "returns flow back to net/http" do
+        2.times do
+          EphemeralResponse::Fixture.respond_to(fixture.uri, request) {}
+          EphemeralResponse::Fixture.fixtures[fixture.identifier].should be_nil
+        end
+      end
+
+      context "uri not normalized" do
+        let(:uri) { URI.parse("HtTP://ExaMplE.Com/") }
+        let(:fixture) { EphemeralResponse::Fixture.new(uri, request) }
+
+        before do
+          EphemeralResponse::Configuration.white_list = "example.com"
+        end
+
+        it "returns flow to net/http when host is not normalized" do
+          EphemeralResponse::Fixture.respond_to(uri, request) {}
+          EphemeralResponse::Fixture.fixtures[fixture.identifier].should be_nil
+        end
+      end
+
+    end
+
     context "fixture loaded" do
       it "returns the fixture response" do
-        fixture.save
-        EphemeralResponse::Fixture.load_all
-        response = EphemeralResponse::Fixture.respond_to(fixture.uri, fixture.method)
+        fixture.register
+        response = EphemeralResponse::Fixture.respond_to(fixture.uri, request)
         response.should == "hello world"
       end
     end
 
     context "fixture not loaded" do
       it "sets the response to the block" do
-        EphemeralResponse::Fixture.respond_to(fixture.uri, fixture.method) do
+        EphemeralResponse::Fixture.respond_to(fixture.uri, request) do
           "new response"
         end
         EphemeralResponse::Fixture.fixtures[fixture.identifier].response.should == "new response"
       end
 
       it "saves the fixture" do
-        EphemeralResponse::Fixture.respond_to(fixture.uri, fixture.method) do
+        EphemeralResponse::Fixture.respond_to(fixture.uri, request) do
           "new response"
         end
         File.exists?(fixture.path).should be_true
       end
     end
   end
+
+  describe "#initialize" do
+    let(:uri) { URI.parse("HtTP://ExaMplE.Com/") }
+    subject { EphemeralResponse::Fixture }
+
+    it "normalizes the given uri" do
+      fixture = subject.new(uri, request)
+      fixture.uri.should == uri.normalize
+    end
+
+    it "duplicates the request" do
+      fixture = subject.new(uri, request)
+      request['something'] = "anything"
+      fixture.request['something'].should be_nil
+      request['something'].should == "anything"
+    end
+
+    it "sets created_at to the current time" do
+      Time.travel "2010-01-15 10:11:12" do
+        fixture = subject.new(uri, request)
+        fixture.created_at.should == Time.parse("2010-01-15 10:11:12")
+      end
+    end
+
+    it "yields itself" do
+      fixture = subject.new(uri, request) do |f|
+        f.response = "yielded self"
+      end
+      fixture.response.should == "yielded self"
+    end
+  end
+
+  describe "#identifier" do
+    let(:request) { Net::HTTP::Get.new '/?foo=bar' }
+    let(:uri) { URI.parse "http://example.com/" }
+    subject { EphemeralResponse::Fixture.new uri, request }
+
+    it "hashes the uri_identifier with request_identifier" do
+      Digest::SHA1.should_receive(:hexdigest).with("#{subject.uri_identifier}#{subject.request_identifier}")
+      subject.identifier
+    end
+  end
+
+  describe "#uri_identifier" do
+
+    it "returns an array containing the host when there is no query string" do
+      request = Net::HTTP::Get.new '/'
+      host = URI.parse("http://example.com/")
+      fixture = EphemeralResponse::Fixture.new(host, request)
+      fixture.uri_identifier.should == "http://example.com/"
+    end
+
+    it "does not incorrectly hash different hosts which sort identically" do
+      request = Net::HTTP::Get.new '/?foo=bar'
+      host1 = URI.parse("http://a.com/?f=b")
+      host2 = URI.parse("http://f.com/?b=a")
+      fixture1 = EphemeralResponse::Fixture.new(host1, request)
+      fixture2 = EphemeralResponse::Fixture.new(host2, request)
+      fixture1.uri_identifier.should_not == fixture2.uri_identifier
+    end
+
+    it "sorts the query strings" do
+      uri1 = URI.parse("http://example.com/?foo=bar&baz=qux&f")
+      uri2 = URI.parse("http://example.com/?baz=qux&foo=bar&f")
+      request1 = Net::HTTP::Get.new uri1.request_uri
+      request2 = Net::HTTP::Get.new uri2.request_uri
+      fixture1 = EphemeralResponse::Fixture.new(uri1, request1)
+      fixture2 = EphemeralResponse::Fixture.new(uri2, request2)
+      fixture1.uri_identifier.should == fixture2.uri_identifier
+    end
+
+    it "doesn't mix up the query string key pairs" do
+      uri1 = URI.parse("http://example.com/?foo=bar&baz=qux")
+      uri2 = URI.parse("http://example.com/?bar=foo&qux=baz")
+      request1 = Net::HTTP::Get.new uri1.request_uri
+      request2 = Net::HTTP::Get.new uri2.request_uri
+      fixture1 = EphemeralResponse::Fixture.new(uri1, request1)
+      fixture2 = EphemeralResponse::Fixture.new(uri2, request2)
+      fixture1.uri_identifier.should_not == fixture2.uri_identifier
+    end
+  end
+
+  describe "#register" do
+    context "uri not white listed" do
+      it "saves the fixture" do
+        fixture.register
+        File.exists?(fixture.path).should be_true
+      end
+
+      it "registers the fixture" do
+        fixture.register
+        EphemeralResponse::Fixture.fixtures.should have_key(fixture.identifier)
+      end
+    end
+
+    context "uri is white listed" do
+      before do
+        EphemeralResponse::Configuration.white_list << uri.host
+      end
+
+      it "doesn't save the fixture" do
+        fixture.register
+        File.exists?(fixture.path).should be_false
+      end
+
+      it "doesn't register the fixture" do
+        fixture.register
+        EphemeralResponse::Fixture.fixtures.should_not have_key(fixture.identifier)
+      end
+    end
+  end
+
+  describe "#file_name" do
+    it "chops off the starting slash when accessing '/'" do
+      uri = URI.parse("http://example.com/")
+      fixture = EphemeralResponse::Fixture.new(uri, request)
+      fixture.file_name.should =~ /example-com_GET_[\w]{7}.yml/
+    end
+
+    it "chops off the starting slash when accessing '/index.html'" do
+      uri = URI.parse("http://example.com/index.html")
+      fixture = EphemeralResponse::Fixture.new(uri, request)
+      fixture.file_name.should =~ /example-com_GET_index-html_[\w]{7}.yml/
+    end
+
+    it "looks like on longer paths" do
+      uri = URI.parse("http://example.com/users/1/photos/1.html")
+      fixture = EphemeralResponse::Fixture.new(uri, request)
+      fixture.file_name.should =~ /example-com_GET_users-1-photos-1-html_[\w]{7}.yml/
+    end
+
+  end
 end

data/spec/ephemeral_response/net_http_spec.rb

@@ -20,9 +20,15 @@ describe Net::HTTP do
   describe "#generate_uri" do
     context "when HTTP" do
       subject { Net::HTTP.new('example.com') }
+
       it "returns the proper http uri object" do
         subject.generate_uri(request).should == URI.parse("http://example.com/foo?q=1")
       end
+
+      it "sets the uri instance variable" do
+        subject.generate_uri(request)
+        subject.uri.should == URI.parse("http://example.com/foo?q=1")
+      end
     end
 
     context "when HTTPS" do
@@ -31,6 +37,7 @@ describe Net::HTTP do
         https.use_ssl = true
         https
       end
+
       it "returns the proper http uri object" do
         subject.generate_uri(request).should == URI.parse("https://example.com/foo?q=1")
       end
@@ -69,5 +76,13 @@ describe Net::HTTP do
         subject.request(request)
       end
     end
+
+    context "connection not started" do
+      it "starts the connection" do
+        subject.should_not be_started
+        subject.request(request)
+        subject.should be_started
+      end
+    end
   end
 end

data/spec/ephemeral_response_spec.rb

@@ -24,9 +24,15 @@ describe EphemeralResponse do
     end
 
     it "removes #generate_uri" do
-      Net::HTTP.instance_methods.sort.should include('generate_uri')
+      Net::HTTP.instance_methods.should include('generate_uri')
       EphemeralResponse.deactivate
       Net::HTTP.instance_methods.should_not include('generate_uri')
     end
+
+    it "removes #uri" do
+      Net::HTTP.instance_methods.should include('uri')
+      EphemeralResponse.deactivate
+      Net::HTTP.instance_methods.should_not include('uri')
+    end
   end
 end

data/spec/integration/{net_spec.rb → normal_flow_spec.rb}

@@ -1,36 +1,48 @@
 require 'spec_helper'
 
-describe "Integrating with the net" do
-  before do
+describe "Normal flow" do
+  include FakeFS::SpecHelpers
+
+  after do
     clear_fixtures
   end
 
   context "example.com" do
-    let(:uri) { URI.parse('http://example.com') }
+    let(:uri) { URI.parse('http://example.com/') }
+    let(:http) { Net::HTTP.new uri.host, uri.port }
+
+    def get
+      Net::HTTP::Get.new '/'
+    end
+
+    def send_request(req)
+      http.start {|h| h.request(req) }
+    end
+
     it "generates a fixture, then uses the fixture" do
-      real_response = Net::HTTP.get(uri)
-      fixture = EphemeralResponse::Fixture.new(uri, 'GET')
+      real_response = send_request(get)
+      fixture = EphemeralResponse::Fixture.new(uri, get)
       File.exists?(fixture.path).should be_true
       Net::HTTP.should_not_receive(:connect_without_ephemeral_response)
       Net::HTTP.should_not_receive(:request_without_ephemeral_response)
-      fixture_response = Net::HTTP.get(uri)
+      fixture_response = send_request(get)
       real_response.should == fixture_response
     end
 
     it "generates a new fixture when the initial fixture expires" do
-      Net::HTTP.get(uri)
-      old_fixture = EphemeralResponse::Fixture.find(uri, 'GET')
+      send_request(get)
+      old_fixture = EphemeralResponse::Fixture.find(uri, get)
       Time.travel((Time.now + EphemeralResponse::Configuration.expiration * 2).to_s) do
         EphemeralResponse::Fixture.load_all
-        Net::HTTP.get(uri)
+        send_request(get)
       end
-      new_fixture = EphemeralResponse::Fixture.find(uri, 'GET')
+      new_fixture = EphemeralResponse::Fixture.find(uri, get)
       old_fixture.created_at.should < new_fixture.created_at
 
       # use the new fixture
       Net::HTTP.should_not_receive(:connect_without_ephemeral_response)
       Net::HTTP.should_not_receive(:request_without_ephemeral_response)
-      Net::HTTP.get(uri)
+      send_request(get)
     end
 
     context "Deactivation" do

data/spec/integration/unique_fixtures_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+module UniqueRequests
+  VARIATIONS = %w(
+    simple_get
+    get_with_query_string
+    get_with_query_string_and_basic_auth
+    get_with_multiple_headers
+    simple_post
+    post_with_data
+    post_with_body
+    post_with_data_and_query_string
+    post_with_data_and_query_string_and_basic_auth
+  )
+
+  def uri
+    @uri ||= URI.parse "http://localhost:#{EphemeralResponse::RackReflector.port}"
+  end
+
+  def responses
+    @responses ||= {}
+  end
+
+  def set_up_responses
+    VARIATIONS.each do |request|
+      responses[request] = send(request)
+    end
+  end
+
+  def perform(request)
+    http = Net::HTTP.new uri.host, uri.port
+    # http.set_debug_output $stdout
+    http.start do |http|
+      http.request(request)
+    end
+  end
+
+  def simple_get
+    perform Net::HTTP::Get.new('/foo')
+  end
+
+  def get_with_query_string
+    perform Net::HTTP::Get.new('/?foo=bar&baz=qux')
+  end
+
+  def get_with_query_string_and_basic_auth
+    request = Net::HTTP::Get.new('/?foo=bar')
+    request.basic_auth 'user', 'password'
+    perform request
+  end
+
+  def get_with_multiple_headers
+    request = Net::HTTP::Get.new('/')
+    request['Accept'] = "application/json, text/html"
+    request['Accept-Encoding'] = "deflate, gzip"
+    perform request
+  end
+
+  def simple_post
+    perform Net::HTTP::Post.new('/')
+  end
+
+  def post_with_data
+    request = Net::HTTP::Post.new('/')
+    request.set_form_data 'hi' => 'there'
+    perform request
+  end
+
+  def post_with_body
+    request = Net::HTTP::Post.new('/')
+    request.body = 'hi=there'
+    perform request
+  end
+
+  def post_with_data_and_query_string
+    request = Net::HTTP::Post.new('/?foo=bar')
+    request.set_form_data 'hi' => 'there'
+    perform request
+  end
+
+  def post_with_data_and_query_string_and_basic_auth
+    request = Net::HTTP::Post.new('/?foo=bar')
+    request.basic_auth 'user', 'password'
+    request.set_form_data 'hi' => 'there'
+    perform request
+  end
+
+end
+
+describe "Unique fixtures generated for the following requests" do
+  include UniqueRequests
+
+  before :all do
+    EphemeralResponse.activate
+    clear_fixtures
+    EphemeralResponse::RackReflector.while_running do
+      set_up_responses
+    end
+  end
+
+  after :all do
+    EphemeralResponse::RackReflector.stop
+  end
+
+  UniqueRequests::VARIATIONS.each do |request|
+    it "restores the correct response from the fixture" do
+      send(request).body.should == responses[request].body
+    end
+  end
+
+  context "when querystring has different order" do
+    it "restores the correct response" do
+      new_response = perform Net::HTTP::Get.new('/?baz=qux&foo=bar')
+      new_response.body.should == responses['get_with_query_string'].body
+    end
+  end
+
+  context "when headers have different order" do
+    it "restores the correct response when the headers are exactly reversed" do
+      request = Net::HTTP::Get.new('/')
+      request['Accept'] = "text/html, application/json"
+      request['Accept-Encoding'] = "gzip, deflate"
+      new_response = perform request
+      new_response.body.should == responses['get_with_multiple_headers'].body
+    end
+
+    it "restores the correct response when some headers are reversed" do
+      request = Net::HTTP::Get.new('/')
+      request['Accept'] = "text/html, application/json"
+      request['Accept-Encoding'] = "deflate, gzip"
+      new_response = perform request
+      new_response.body.should == responses['get_with_multiple_headers'].body
+    end
+  end
+
+  context "when the http service has not been started" do
+    def get
+      Net::HTTP::Get.new('/foo/bar/baz')
+    end
+
+    it "restores the correct fixture" do
+      clear_fixtures
+      http = Net::HTTP.new uri.host, uri.port
+
+
+      EphemeralResponse::RackReflector.while_running do
+        http.request(get)
+      end
+
+      http.request(get).body.should == EphemeralResponse::Fixture.find(http.uri, get).response.body
+    end
+  end
+end

data/spec/integration/white_list_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "White Lists" do
+  before do
+    clear_fixtures
+  end
+
+  context "localhost added to white list" do
+    let(:uri) { URI.parse('http://localhost:9876/') }
+    let(:http) { Net::HTTP.new uri.host, uri.port }
+    let(:get) { Net::HTTP::Get.new '/' }
+
+    before do
+      EphemeralResponse::Configuration.white_list = "localhost"
+    end
+
+    it "doesn't save a fixture" do
+      EphemeralResponse::RackReflector.while_running do
+        http.start {|h| h.request(get) }
+        EphemeralResponse::Fixture.load_all.should be_empty
+        Dir.glob("#{EphemeralResponse::Configuration.fixture_directory}/*").should be_empty
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -7,12 +7,13 @@ require 'spec/autorun'
 Dir.glob("spec/support/*.rb") {|f| require f}
 
 Spec::Runner.configure do |config|
-  config.include FakeFS::SpecHelpers
   config.include ClearFixtures
   config.before(:each) do
+    EphemeralResponse::Configuration.reset
     EphemeralResponse.activate
   end
   config.after(:suite) do
     EphemeralResponse.deactivate
+    ClearFixtures.clear_fixtures
   end
 end

data/spec/support/clear_fixtures.rb

@@ -1,4 +1,5 @@
 module ClearFixtures
+  module_function
   def clear_fixtures
     FileUtils.rm_rf EphemeralResponse::Configuration.fixture_directory
     EphemeralResponse::Fixture.clear

data/spec/support/rack_reflector.rb

@@ -0,0 +1,63 @@
+require 'unicorn'
+
+module EphemeralResponse::RackReflector
+  class Response
+    attr_reader :ordered_headers, :rack_input
+    def initialize(env={})
+      @ordered_headers = []
+      set_ordered_headers(env)
+      set_rack_input(env)
+    end
+
+    def set_ordered_headers(env)
+      env.each do |key, value|
+        @ordered_headers << [key, value] if key == key.upcase
+      end
+    end
+
+    def headers
+      Hash[ordered_headers]
+    end
+
+    def set_rack_input(env)
+      @rack_input = env['rack.input'].read
+    end
+  end
+
+  extend self
+
+  def app
+    lambda do |env|
+      [ 200, {"Content-Type" => "application/x-yaml"}, [ Response.new(env).to_yaml ] ]
+    end
+  end
+
+  def new_server
+    http_server = Unicorn::HttpServer.new(app, :listeners => ["0.0.0.0:#{port}"])
+    http_server.logger.level = Logger::ERROR
+    http_server
+  end
+
+  def port
+    9876 || ENV['UNICORN_PORT']
+  end
+
+  def server
+    @server ||= new_server
+  end
+
+  def start
+    server.start
+  end
+
+  def stop
+    server.stop(false)
+  end
+
+  def while_running
+    start
+    yield
+  ensure
+    stop
+  end
+end