puffing-billy 0.2.1 → 0.2.3

data/spec/lib/billy/resource_utils_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Billy::JSONUtils do
+  describe 'sorting' do
+    describe '#sort_hash_keys' do
+      it 'sorts simple Hashes' do
+        data     = {c: 'three',a: 'one',b: 'two'}
+        expected = {a: 'one',b: 'two',c: 'three'}
+        expect(Billy::JSONUtils::sort_hash_keys(data)).to eq expected
+      end
+
+      it 'does not sort simple Arrays' do
+        data     = [3,1,2,'two','three','one']
+        expect(Billy::JSONUtils::sort_hash_keys(data)).to eq data
+      end
+
+      it 'does not sort multi-dimensional Arrays' do
+        data     = [[3,2,1],[5,4,6],['b','c','a']]
+        expect(Billy::JSONUtils::sort_hash_keys(data)).to eq data
+      end
+
+      it 'sorts multi-dimensional Hashes' do
+        data     = {c: {l: 2,m: 3,k: 1},a: {f: 3,e: 2,d: 1},b: {i: 2,h: 1,j: 3}}
+        expected = {a: {d: 1,e: 2,f: 3},b: {h: 1,i: 2,j: 3},c: {k: 1,l: 2,m: 3}}
+        expect(Billy::JSONUtils::sort_hash_keys(data)).to eq expected
+      end
+
+      it 'sorts abnormal data structures' do
+        data     = {b: [['b','c','a'],{ab: 5,aa: 4, ac: 6},[3,2,1],{ba: true,bc: false, bb: nil}],a: {f: 3,e: 2,d: 1}}
+        expected = {a: {d: 1,e: 2,f: 3},b: [['b','c','a'],{aa: 4,ab: 5,ac: 6},[3,2,1],{ba: true, bb: nil,bc: false}]}
+        expect(Billy::JSONUtils::sort_hash_keys(data)).to eq expected
+      end
+    end
+
+    describe 'sort_json' do
+      it 'sorts JSON' do
+        data     = '{"c":"three","a":"one","b":"two"}'
+        expected = '{"a":"one","b":"two","c":"three"}'
+        expect(Billy::JSONUtils::sort_json(data)).to eq expected
+      end
+    end
+  end
+
+  describe 'json?' do
+    let(:json) { {a: '1'}.to_json }
+    let(:non_json) { 'Not JSON.' }
+
+    it 'identifies JSON' do
+      expect(Billy::JSONUtils::json?(json)).to be_true
+    end
+    it 'identifies non-JSON' do
+      expect(Billy::JSONUtils::json?(non_json)).to be_false
+    end
+  end
+end

data/spec/lib/proxy_spec.rb

@@ -4,23 +4,23 @@ require 'resolv'
 
 shared_examples_for 'a proxy server' do
   it 'should proxy GET requests' do
-    http.get('/echo').body.should == 'GET /echo'
+    expect(http.get('/echo').body).to eql 'GET /echo'
   end
 
   it 'should proxy POST requests' do
-    http.post('/echo', :foo => 'bar').body.should == "POST /echo\nfoo=bar"
+    expect(http.post('/echo', :foo => 'bar').body).to eql "POST /echo\nfoo=bar"
   end
 
   it 'should proxy PUT requests' do
-    http.post('/echo', :foo => 'bar').body.should == "POST /echo\nfoo=bar"
+    expect(http.post('/echo', :foo => 'bar').body).to eql "POST /echo\nfoo=bar"
   end
 
   it 'should proxy HEAD requests' do
-    http.head('/echo').headers['HTTP-X-EchoServer'].should == 'HEAD /echo'
+    expect(http.head('/echo').headers['HTTP-X-EchoServer']).to eql 'HEAD /echo'
   end
 
   it 'should proxy DELETE requests' do
-    http.delete('/echo').body.should == 'DELETE /echo'
+    expect(http.delete('/echo').body).to eql 'DELETE /echo'
   end
 end
 
@@ -28,31 +28,37 @@ shared_examples_for 'a request stub' do
   it 'should stub GET requests' do
     proxy.stub("#{url}/foo").
       and_return(:text => 'hello, GET!')
-    http.get('/foo').body.should == 'hello, GET!'
+    expect(http.get('/foo').body).to eql 'hello, GET!'
+  end
+
+  it 'should stub GET response statuses' do
+    proxy.stub("#{url}/foo").
+      and_return(:code => 200)
+    expect(http.get('/foo').status).to eql 200
   end
 
   it 'should stub POST requests' do
     proxy.stub("#{url}/bar", :method => :post).
       and_return(:text => 'hello, POST!')
-    http.post('/bar', :foo => :bar).body.should == 'hello, POST!'
+    expect(http.post('/bar', :foo => :bar).body).to eql 'hello, POST!'
   end
 
   it 'should stub PUT requests' do
     proxy.stub("#{url}/baz", :method => :put).
       and_return(:text => 'hello, PUT!')
-    http.put('/baz', :foo => :bar).body.should == 'hello, PUT!'
+    expect(http.put('/baz', :foo => :bar).body).to eql 'hello, PUT!'
   end
 
   it 'should stub HEAD requests' do
     proxy.stub("#{url}/bap", :method => :head).
       and_return(:headers => {'HTTP-X-Hello' => 'hello, HEAD!'})
-    http.head('/bap').headers['http_x_hello'] == 'hello, HEAD!'
+    expect(http.head('/bap').headers['http-x-hello']).to eql 'hello, HEAD!'
   end
 
   it 'should stub DELETE requests' do
     proxy.stub("#{url}/bam", :method => :delete).
       and_return(:text => 'hello, DELETE!')
-    http.delete('/bam').body.should == 'hello, DELETE!'
+    expect(http.delete('/bam').body).to eql 'hello, DELETE!'
   end
 end
 
@@ -60,29 +66,39 @@ shared_examples_for 'a cache' do
 
   context 'whitelisted GET requests' do
     it 'should not be cached' do
-      r = http.get('/foo')
-      r.body.should == 'GET /foo'
-      expect {
-        expect {
-          r = http.get('/foo')
-        }.to change { r.headers['HTTP-X-EchoCount'].to_i }.by(1)
-      }.to_not change { r.body }
+      assert_noncached_url
+    end
+
+    context 'with ports' do
+      before do
+        rack_app_url = URI(http.url_prefix)
+        Billy.config.whitelist = ["#{rack_app_url.host}:#{rack_app_url.port}"]
+      end
+
+      it 'should not be cached ' do
+        assert_noncached_url
+      end
     end
   end
 
-  context 'other GET requests' do
+  context 'non-whitelisted GET requests' do
     before do
       Billy.config.whitelist = []
     end
 
     it 'should be cached' do
-      r = http.get('/foo')
-      r.body.should == 'GET /foo'
-      expect {
-        expect {
-          r = http.get('/foo')
-        }.to_not change { r.headers['HTTP-X-EchoCount'] }
-      }.to_not change { r.body }
+      assert_cached_url
+    end
+
+    context 'with ports' do
+      before do
+        rack_app_url = URI(http.url_prefix)
+        Billy.config.whitelist = ["#{rack_app_url.host}:#{rack_app_url.port+1}"]
+      end
+
+      it 'should be cached' do
+        assert_cached_url
+      end
     end
   end
 
@@ -93,7 +109,7 @@ shared_examples_for 'a cache' do
 
     it 'should be cached' do
       r = http.get('/analytics?some_param=5')
-      r.body.should == 'GET /analytics'
+      expect(r.body).to eql 'GET /analytics'
       expect {
         expect {
           r = http.get('/analytics?some_param=20')
@@ -102,9 +118,20 @@ shared_examples_for 'a cache' do
     end
   end
 
+  context 'path_blacklist GET requests' do
+    before do
+      Billy.config.path_blacklist = ['/api']
+    end
+
+    it 'should be cached' do
+      assert_cached_url('/api')
+    end
+  end
+
   context "cache persistence" do
+    let(:cached_key) { proxy.cache.key('get',"#{url}/foo","") }
     let(:cached_file) do
-      f = "GET_localhost_#{Digest::SHA1.hexdigest("#{url}/foo")}.yml"
+      f = cached_key + ".yml"
       File.join(Billy.config.cache_path, f)
     end
 
@@ -119,8 +146,99 @@ shared_examples_for 'a cache' do
 
       it 'should persist' do
         r = http.get('/foo')
-        File.exists?(cached_file).should be_true
+        expect(File.exists?(cached_file)).to be_true
       end
+
+      it 'should be read initially from persistent cache' do
+        File.open(cached_file, 'w') do |f|
+          cached = {
+            :headers => {},
+            :content => "GET /foo cached"
+          }
+          f.write(cached.to_yaml(:Encoding => :Utf8))
+        end
+
+        r = http.get('/foo')
+        expect(r.body).to eql 'GET /foo cached'
+      end
+
+      context 'cache_request_headers requests' do
+        it 'should not be cached by default' do
+          r = http.get('/foo')
+          saved_cache = Billy.proxy.cache.fetch_from_persistence(cached_key)
+          expect(saved_cache.keys).not_to include :request_headers
+        end
+
+        context 'when enabled' do
+          before do
+            Billy.config.cache_request_headers = true
+          end
+
+          it 'should be cached' do
+            r = http.get('/foo')
+            saved_cache = Billy.proxy.cache.fetch_from_persistence(cached_key)
+            expect(saved_cache.keys).to include :request_headers
+          end
+        end
+      end
+
+      context 'ignore_cache_port requests' do
+        it 'should be cached without port' do
+          r   = http.get('/foo')
+          url = URI(r.env[:url])
+          saved_cache = Billy.proxy.cache.fetch_from_persistence(cached_key)
+
+          expect(saved_cache[:url]).to_not eql(url.to_s)
+          expect(saved_cache[:url]).to eql(url.to_s.gsub(":#{url.port}", ''))
+        end
+      end
+
+      context 'non_whitelisted_requests_disabled requests' do
+        before { Billy.config.non_whitelisted_requests_disabled = true }
+
+        it 'should raise error when disabled' do
+          #TODO: Suppress stderr output: https://gist.github.com/adamstegman/926858
+          expect{http.get('/foo')}.to raise_error(Faraday::Error::ConnectionFailed, "end of file reached")
+        end
+      end
+
+      context 'non_successful_cache_disabled requests' do
+        before do
+          rack_app_url = URI(http_error.url_prefix)
+          Billy.config.whitelist = ["#{rack_app_url.host}:#{rack_app_url.port}"]
+          Billy.config.non_successful_cache_disabled = true
+        end
+
+        it 'should not cache non-successful response when enabled' do
+          http_error.get('/foo')
+          expect(File.exists?(cached_file)).to be_false
+        end
+
+        it 'should cache successful response when enabled' do
+          assert_cached_url
+        end
+      end
+
+      context 'non_successful_error_level requests' do
+        before do
+          rack_app_url = URI(http_error.url_prefix)
+          Billy.config.whitelist = ["#{rack_app_url.host}:#{rack_app_url.port}"]
+          Billy.config.non_successful_error_level = :error
+        end
+
+        it 'should raise error for non-successful responses when :error' do
+          # When this config setting is set, the EventMachine running the test servers is killed upon error raising
+          # The `raise` is required to bubble up the error to the test running it
+          # The Faraday error is raised upon `close_connection` so this can be non-pending if we can do one of the following:
+          # 1) Remove the `raise error_message` conditionally for this test
+          # 2) Restart the test servers if they aren't running
+          # 3) Change the test servers to start/stop for each test instead of before all
+          # 4) Remove the test server completely and rely on the server instantiated by the app
+          pending "Unable to test this without affecting the running test servers"
+          expect{http_error.get('/foo')}.to raise_error(Faraday::Error::ConnectionFailed)
+        end
+      end
+
     end
 
     context "disabled" do
@@ -128,24 +246,45 @@ shared_examples_for 'a cache' do
 
       it 'shouldnt persist' do
         r = http.get('/foo')
-        File.exists?(cached_file).should be_false
+        expect(File.exists?(cached_file)).to be_false
       end
     end
   end
+
+  def assert_noncached_url(url = '/foo')
+    r = http.get(url)
+    expect(r.body).to eql "GET #{url}"
+    expect {
+      expect {
+        r = http.get(url)
+      }.to change { r.headers['HTTP-X-EchoCount'].to_i }.by(1)
+    }.to_not change { r.body }
+  end
+
+  def assert_cached_url(url = '/foo')
+    r = http.get(url)
+    expect(r.body).to eql "GET #{url}"
+    expect {
+      expect {
+        r = http.get(url)
+      }.to_not change { r.headers['HTTP-X-EchoCount'] }
+    }.to_not change { r.body }
+  end
 end
 
 describe Billy::Proxy do
 
   before do
-    @http = Faraday.new @http_url,
-      :proxy => { :uri => proxy.url },
-      :keepalive => false,
-      :timeout => 0.5
-    @https = Faraday.new @https_url,
-      :ssl => { :verify => false },
-      :proxy => { :uri => proxy.url },
-      :keepalive => false,
-      :timeout => 0.5
+    # Adding non-valid Faraday options throw an error: https://github.com/arsduo/koala/pull/311
+    # Valid options: :request, :proxy, :ssl, :builder, :url, :parallel_manager, :params, :headers, :builder_class
+    faraday_options = {
+      :proxy   => { :uri => proxy.url },
+      :request => { :timeout => 0.5 }
+    }
+
+    @http       = Faraday.new @http_url,  faraday_options
+    @https      = Faraday.new @https_url, faraday_options.merge(:ssl => { :verify => false })
+    @http_error = Faraday.new @error_url, faraday_options
   end
 
   context 'proxying' do
@@ -165,13 +304,13 @@ describe Billy::Proxy do
   context 'stubbing' do
 
     context 'HTTP' do
-      let!(:url) { @http_url }
+      let!(:url)  { @http_url }
       let!(:http) { @http }
       it_should_behave_like 'a request stub'
     end
 
     context 'HTTPS' do
-      let!(:url) { @https_url }
+      let!(:url)  { @https_url }
       let!(:http) { @https }
       it_should_behave_like 'a request stub'
     end
@@ -180,18 +319,67 @@ describe Billy::Proxy do
 
   context 'caching' do
 
+    it 'defaults to nil scope' do
+      expect(proxy.cache.scope).to be_nil
+    end
+
     context 'HTTP' do
-      let!(:url) { @http_url }
-      let!(:http) { @http }
+      let!(:url)        { @http_url }
+      let!(:http)       { @http }
+      let!(:http_error) { @http_error }
       it_should_behave_like 'a cache'
     end
 
     context 'HTTPS' do
-      let!(:url) { @https_url }
-      let!(:http) { @https }
+      let!(:url)        { @https_url }
+      let!(:http)       { @https }
+      let!(:http_error) { @http_error }
       it_should_behave_like 'a cache'
     end
 
-  end
+    context 'with a cache scope' do
+      let!(:url)        { @http_url }
+      let!(:http)       { @http }
+      let!(:http_error) { @http_error }
+
+      before do
+        proxy.cache.scope_to "my_cache"
+      end
+
+      after do
+        proxy.cache.use_default_scope
+      end
+
+      it_should_behave_like 'a cache'
+
+      it 'uses the cache scope' do
+        expect(proxy.cache.scope).to eq("my_cache")
+      end
 
+      it 'can be reset to the default scope' do
+        proxy.cache.use_default_scope
+        expect(proxy.cache.scope).to be_nil
+      end
+
+      it 'can execute a block against a cache scope' do
+        expect(proxy.cache.scope).to eq "my_cache"
+        proxy.cache.with_scope "another_cache" do
+          expect(proxy.cache.scope).to eq "another_cache"
+        end
+        expect(proxy.cache.scope).to eq "my_cache"
+      end
+
+      it 'requires a block to be passed to with_scope' do
+        expect {proxy.cache.with_scope "some_scope"}.to raise_error ArgumentError
+      end
+
+      it 'should have different keys for the same request under a different scope' do
+        args = ['get',"#{url}/foo",""]
+        key = proxy.cache.key(*args)
+        proxy.cache.with_scope "another_cache" do
+          expect(proxy.cache.key(*args)).to_not eq key
+        end
+      end
+    end
+  end
 end