puffing-billy 2.4.0 → 3.0.2

data/spec/features/examples/intercept_request_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-require 'timeout'
-
-describe 'intercept request example', type: :feature, js: true do
-  before do
-    Billy.config.record_stub_requests = true
-  end
-
-  it 'should intercept a GET request directly' do
-    stub = proxy.stub('http://example.com/').and_return(
-      headers: { 'Access-Control-Allow-Origin' => '*' },
-      code: 200
-    )
-    visit 'http://example.com/'
-    expect(stub.has_requests?).to be true
-    expect(stub.requests).not_to be_empty
-  end
-
-  it 'should intercept a POST request through an intermediary page' do
-    stub = proxy.stub('http://example.com/', method: 'post').and_return(
-      headers: { 'Access-Control-Allow-Origin' => '*' },
-      code: 200
-    )
-    visit '/intercept_request.html'
-    Timeout::timeout(5) do
-      sleep(0.1) until stub.has_requests?
-    end
-    request = stub.requests.shift
-    expect(request[:body]).to eql 'foo=bar'
-  end
-end

data/spec/features/examples/post_api_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe 'jQuery POST API example', type: :feature, js: true do
-  before do
-    proxy.stub('http://example.com/api', method: 'post').and_return(
-      headers: { 'Access-Control-Allow-Origin' => '*' },
-      code: 201
-    )
-  end
-
-  it 'posts to an API' do
-    visit '/post_api.html'
-    expect(page.find('#result')).to have_content 'Success!'
-  end
-end

data/spec/features/examples/preflight_request_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe 'jQuery preflight request example', type: :feature, js: true do
-  let(:url) { 'http://example.com/api' }
-
-  before do
-    proxy.stub(url, method: 'get').and_return(
-      headers: { 'Access-Control-Allow-Origin' => '*' },
-      code: 201
-    )
-  end
-
-  it 'stubs out the OPTIONS request' do
-    visit '/preflight_request.html'
-    expect(page.find('#result')).to have_content 'Fail!'
-
-    proxy.stub(url, method: 'options').and_return(
-      headers: {
-        'Access-Control-Allow-Methods' => 'GET, OPTIONS',
-        'Access-Control-Allow-Headers' => 'Content-Type',
-        'Access-Control-Allow-Origin' => '*'
-      },
-      code: 200
-    )
-
-    visit '/preflight_request.html'
-    expect(page.find('#result')).to have_content 'Success!'
-  end
-end

data/spec/features/examples/tumblr_api_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples 'tumblr/expectations' do
-  it 'should show news stories' do
-    visit '/tumblr_api.html'
-    expect(page).to have_link('News Item 1', href: 'http://example.com/news/1')
-    expect(page).to have_content('News item 1 content here')
-    expect(page).to have_link('News Item 2', href: 'http://example.com/news/2')
-    expect(page).to have_content('News item 2 content here')
-  end
-end
-
-describe 'Tumblr API example', type: :feature, js: true do
-  context 'without scope external references' do
-    before do
-      proxy.stub('http://blog.howmanyleft.co.uk/api/read/json').and_return(
-        jsonp: {
-          posts: [
-            {
-              'regular-title' => 'News Item 1',
-              'url-with-slug' => 'http://example.com/news/1',
-              'regular-body' => 'News item 1 content here'
-            },
-            {
-              'regular-title' => 'News Item 2',
-              'url-with-slug' => 'http://example.com/news/2',
-              'regular-body' => 'News item 2 content here'
-            }
-          ]
-        })
-    end
-
-    include_examples 'tumblr/expectations'
-  end
-
-  context 'with scope external references' do
-    let(:posts) do
-      [
-        {
-          'regular-title' => 'News Item 1',
-          'url-with-slug' => 'http://example.com/news/1',
-          'regular-body' => 'News item 1 content here'
-        },
-        {
-          'regular-title' => 'News Item 2',
-          'url-with-slug' => 'http://example.com/news/2',
-          'regular-body' => 'News item 2 content here'
-        }
-      ]
-    end
-
-    before do
-      proxy.stub('http://blog.howmanyleft.co.uk/api/read/json')
-           .and_return(proc { { jsonp: { posts: posts } } })
-    end
-
-    include_examples 'tumblr/expectations'
-  end
-end

data/spec/lib/billy/browsers/capybara_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe 'Capybara drivers', type: :feature, js: true do
-  it 'allows HTTPS calls' do
-    proxy.stub('https://blog.howmanyleft.co.uk:443/api/read/json').and_return(
-      jsonp: {
-        posts: [
-          {
-            'regular-title' => 'News Item 1',
-            'url-with-slug' => 'http://example.com/news/1',
-            'regular-body' => 'News item 1 content here'
-          },
-          {
-            'regular-title' => 'News Item 2',
-            'url-with-slug' => 'http://example.com/news/2',
-            'regular-body' => 'News item 2 content here'
-          }
-        ]
-      })
-
-    visit '/tumblr_api_https.html'
-
-    expect(page).to have_link('News Item 1', href: 'http://example.com/news/1')
-    expect(page).to have_content('News item 1 content here')
-    expect(page).to have_link('News Item 2', href: 'http://example.com/news/2')
-    expect(page).to have_content('News item 2 content here')
-  end
-end

data/spec/lib/billy/cache_spec.rb

@@ -1,158 +0,0 @@
-require 'spec_helper'
-
-describe Billy::Cache do
-  let(:cache) { Billy::Cache.instance }
-  let(:params) { '?foo=bar' }
-  let(:callback) { '&callback=quux' }
-  let(:fragment) { '#baz' }
-  let(:base_url) { 'http://example.com' }
-  let(:pipe_url) { 'https://fonts.googleapis.com:443/css?family=Cabin+Sketch:400,700|Love+Ya+Like+A+Sister' }
-  let(:fragment_url) { "#{base_url}/#{fragment}" }
-  let(:params_url) { "#{base_url}#{params}" }
-  let(:params_url_with_callback) { "#{base_url}#{params}#{callback}" }
-  let(:params_fragment_url) { "#{base_url}#{params}#{fragment}" }
-
-  describe 'format_url' do
-    context 'with ignore_params set to false' do
-      it 'is a no-op if there are no params' do
-        expect(cache.format_url(base_url)).to eq base_url
-      end
-      it 'appends params if there are params' do
-        expect(cache.format_url(params_url)).to eq params_url
-      end
-      it 'appends params and fragment if both are present' do
-        expect(cache.format_url(params_fragment_url)).to eq params_fragment_url
-      end
-      it 'does not raise error for URLs with pipes' do
-        expect { cache.format_url(pipe_url) }.not_to raise_error
-      end
-
-      context 'when dynamic_jsonp is true' do
-        it 'omits the callback param by default' do
-          expect(cache.format_url(params_url_with_callback, false, true)).to eq params_url
-        end
-
-        it 'omits the params listed in Billy.config.dynamic_jsonp_keys' do
-          allow(Billy.config).to receive(:dynamic_jsonp_keys) { ['foo'] }
-
-          expect(cache.format_url(params_url_with_callback, false, true)).to eq "#{base_url}?callback=quux"
-        end
-      end
-
-      it 'retains the callback param is dynamic_jsonp is false' do
-        expect(cache.format_url(params_url_with_callback)).to eq params_url_with_callback
-      end
-    end
-
-    context 'with ignore_params set to true' do
-      it 'is a no-op if there are no params' do
-        expect(cache.format_url(base_url, true)).to eq base_url
-      end
-      it 'omits params if there are params' do
-        expect(cache.format_url(params_url, true)).to eq base_url
-      end
-      it 'omits params and fragment if both are present' do
-        expect(cache.format_url(params_fragment_url, true)).to eq base_url
-      end
-    end
-
-    context 'with merge_cached_responses_whitelist set' do
-      let(:analytics_url1) { 'http://www.example-analytics.com/user/SDF879932/' }
-      let(:analytics_url2) { 'http://www.example-analytics.com/user/OIWEMLW39/' }
-      let(:regular_url) { 'http://www.example-analytics.com/user.js' }
-
-      let(:regex_to_match_analytics_urls_only) do
-        # Note that it matches the forward slash at the end of the URL, which doesn't match regular_url:
-        /www\.example\-analytics\.com\/user\//
-      end
-
-      before do
-        allow(Billy.config).to receive(:merge_cached_responses_whitelist) {
-          [regex_to_match_analytics_urls_only]
-        }
-      end
-
-      it "has one cache key for the two analytics urls that match, and a separate one for the other that doesn't" do
-        expect(cache.key('post', analytics_url1, 'body')).to eq cache.key('post', analytics_url2, 'body')
-        expect(cache.key('post', analytics_url1, 'body')).not_to eq cache.key('post', regular_url, 'body')
-      end
-
-      it 'More specifically, the cache keys should be identical for the 2 analytics urls' do
-        identical_cache_key = 'post_5fcb7a450e4cd54dcffcb526212757ee0ca9dc17'
-        distinct_cache_key = 'post_www.example-analytics.com_81f097654a523bd7ddb10fd4aee781723e076a1a_02083f4579e08a612425c0c1a17ee47add783b94'
-
-        expect(cache.key('post', analytics_url1, 'body')).to eq identical_cache_key
-        expect(cache.key('post', regular_url, 'body')).to eq distinct_cache_key
-        expect(cache.key('post', analytics_url2, 'body')).to eq identical_cache_key
-      end
-    end
-
-    context 'with cache_request_body_methods set' do
-      before do
-        allow(Billy.config).to receive(:cache_request_body_methods) {
-          ['patch']
-        }
-      end
-
-      context "for requests with methods specified in cache_request_body_methods" do
-        it "should have a different cache key for requests with different bodies" do
-          key1 = cache.key('patch', "http://example.com", "body1")
-          key2 = cache.key('patch', "http://example.com", "body2")
-          expect(key1).not_to eq key2
-        end
-
-        it "should have the same cache key for requests with the same bodies" do
-          key1 = cache.key('patch', "http://example.com", "body1")
-          key2 = cache.key('patch', "http://example.com", "body1")
-          expect(key1).to eq key2
-        end
-      end
-
-      it "should have the same cache key for request with different bodies if their methods are not included in cache_request_body_methods" do
-          key1 = cache.key('put', "http://example.com", "body1")
-          key2 = cache.key('put', "http://example.com", "body2")
-          expect(key1).to eq key2
-      end
-    end
-  end
-
-  describe 'key' do
-    context 'with use_ignore_params set to false' do
-      before do
-        allow(Billy.config).to receive(:use_ignore_params) { false }
-      end
-
-      it "should use the same cache key if the base url IS NOT whitelisted in allow_params" do
-        key1 = cache.key('put', params_url, 'body')
-        key2 = cache.key('put', params_url, 'body')
-        expect(key1).to eq key2
-      end
-
-      it "should have the same cache key if the base IS whitelisted in allow_params" do
-        allow(Billy.config).to receive(:allow_params) { [base_url] }
-        key1 = cache.key('put', params_url, 'body')
-        key2 = cache.key('put', params_url, 'body')
-        expect(key1).to eq key2
-      end
-
-      it "should have different cache keys if the base url is added in between two requests" do
-        key1 = cache.key('put', params_url, 'body')
-        allow(Billy.config).to receive(:allow_params) { [base_url] }
-        key2 = cache.key('put', params_url, 'body')
-        expect(key1).not_to eq key2
-      end
-
-      it "should not use ignore_params when whitelisted" do
-        allow(Billy.config).to receive(:allow_params) { [base_url] }
-        expect(cache).to receive(:format_url).once.with(params_url, true).and_call_original
-        expect(cache).to receive(:format_url).once.with(params_url, false).and_call_original
-        key1 = cache.key('put', params_url, 'body')
-      end
-
-      it "should use ignore_params when not whitelisted" do
-        expect(cache).to receive(:format_url).twice.with(params_url, true).and_call_original
-        cache.key('put', params_url, 'body')
-      end
-    end
-  end
-end

data/spec/lib/billy/handlers/cache_handler_spec.rb

@@ -1,191 +0,0 @@
-require 'spec_helper'
-
-describe Billy::CacheHandler do
-  let(:handler) { Billy::CacheHandler.new }
-  let(:request_url) { 'http://example.test:8080/index?some=param&callback=dynamicCallback5678' }
-  let(:request) do
-    {
-      method:   'post',
-      url:      request_url,
-      headers:  { 'Accept-Encoding'  => 'gzip',
-                  'Cache-Control'    => 'no-cache' },
-      body:     'Some body'
-    }
-  end
-
-  it 'delegates #reset to the cache' do
-    expect(Billy::Cache.instance).to receive(:reset).at_least(:once)
-    handler.reset
-  end
-
-  it 'delegates #cached? to the cache' do
-    expect(Billy::Cache.instance).to receive :cached?
-    handler.cached?
-  end
-
-  describe '#handles_request?' do
-    it 'handles the request if it is cached' do
-      expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-      expect(handler.handles_request?(nil, nil, nil, nil)).to be true
-    end
-
-    it 'does not handle the request if it is not cached' do
-      expect(Billy::Cache.instance).to receive(:cached?).and_return(false)
-      expect(handler.handles_request?(nil, nil, nil, nil)).to be false
-    end
-  end
-
-  describe '#handle_request' do
-    it 'returns nil if the request cannot be handled' do
-      expect(Billy::Cache.instance).to receive(:cached?).and_return(false)
-      expect(handler.handle_request(request[:method],
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to be nil
-    end
-
-    it 'returns a cached response if the request can be handled' do
-      expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-      expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'The response body')
-      expect(handler.handle_request(request[:method],
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'The response body')
-    end
-
-    context 'updating jsonp callback names enabled' do
-      before do
-        Billy.config.dynamic_jsonp = true
-      end
-
-      it 'updates the cached response if the callback is dynamic' do
-        expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
-        expect(handler.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback5678({"yolo":"kitten"})')
-      end
-
-      it 'is flexible about the format of the response body' do
-        expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: "/**/ dynamicCallback1234(\n{\"yolo\":\"kitten\"})")
-        expect(handler.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: "/**/ dynamicCallback5678(\n{\"yolo\":\"kitten\"})")
-      end
-
-      it 'does not interfere with non-jsonp requests' do
-        jsonp_request = request
-        other_request = {
-          method:  'get',
-          url:     'http://example.test:8080/index?hanukkah=latkes',
-          headers: { 'Accept-Encoding' => 'gzip', 'Cache-Control' => 'no-cache' },
-          body:    'no jsonp'
-        }
-
-        allow(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        allow(Billy::Cache.instance).to receive(:fetch).with(jsonp_request[:method], jsonp_request[:url], jsonp_request[:body]).and_return(status: 200,
-                                                                                                                                           headers: { 'Connection' => 'close' },
-                                                                                                                                           content: 'dynamicCallback1234({"yolo":"kitten"})')
-        allow(Billy::Cache.instance).to receive(:fetch).with(other_request[:method], other_request[:url], other_request[:body]).and_return(status: 200,
-                                                                                                                                           headers: { 'Connection' => 'close' },
-                                                                                                                                           content: 'no jsonp but has parentheses()')
-
-        expect(handler.handle_request(other_request[:method],
-                                      other_request[:url],
-                                      other_request[:headers],
-                                      other_request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'no jsonp but has parentheses()')
-      end
-
-      context 'when after_cache_handles_request is set' do
-        it "should call the callback with the request and response" do
-          allow(Billy.config).to receive(:after_cache_handles_request) do
-            proc do |request, response|
-              response[:headers]['Access-Control-Allow-Origin'] = "*"
-              response[:content] = request[:body]
-            end
-          end
-          expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-          expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'The response body')
-          expect(handler.handle_request(request[:method],
-                                        request[:url],
-                                        request[:headers],
-                                        request[:body])).to eql(status: 200, headers: { 'Connection' => 'close', 'Access-Control-Allow-Origin' => "*" }, content: 'Some body')
-        end
-      end
-
-      context 'when dynamic_jsonp_callback_name is set' do
-        let(:dynamic_jsonp_callback_name) { 'customCallback' }
-        let(:request_url) { "http://example.test:8080/index?some=param&#{dynamic_jsonp_callback_name}=dynamicCallback5678" }
-
-        before do
-          allow(Billy.config).to receive(:dynamic_jsonp_callback_name) do
-            dynamic_jsonp_callback_name
-          end
-        end
-
-        it 'should call the callback with the specified name' do
-          expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-          expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
-          expect(handler.handle_request(request[:method],
-                                        request[:url],
-                                        request[:headers],
-                                        request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback5678({"yolo":"kitten"})')
-        end
-      end
-    end
-
-    context 'updating jsonp callback names disabled' do
-      before do
-        Billy.config.dynamic_jsonp = false
-      end
-
-      it 'does not change the response' do
-        expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        expect(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
-        expect(handler.handle_request(request[:method],
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
-      end
-    end
-
-    it 'returns nil if the Cache fails to handle the response for some reason' do
-      expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
-      expect(Billy::Cache.instance).to receive(:fetch).and_return(nil)
-      expect(handler.handle_request(request[:method],
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to be nil
-    end
-
-    context 'network delay simulation' do
-      before do
-        allow(Billy::Cache.instance).to receive(:cached?).and_return(true)
-        allow(Billy::Cache.instance).to receive(:fetch).and_return(status: 200, headers: { 'Connection' => 'close' }, content: 'dynamicCallback1234({"yolo":"kitten"})')
-      end
-
-      context 'when cache_simulates_network_delays is disabled' do
-        it 'does not sleep for default delay before responding' do
-          expect(Kernel).not_to receive(:sleep)
-          handler.handle_request(request[:method], request[:url], request[:headers], request[:body])
-        end
-      end
-
-      context 'when cache_simulates_network_delays is enabled' do
-        around do |example|
-          Billy.config.cache_simulates_network_delays = true
-          example.call
-          Billy.config.cache_simulates_network_delays = false
-        end
-
-        it 'sleeps for default delay before responding' do
-          expect(Kernel).to receive(:sleep).with(Billy.config.cache_simulates_network_delay_time)
-          handler.handle_request(request[:method], request[:url], request[:headers], request[:body])
-        end
-      end
-    end
-  end
-end

data/spec/lib/billy/handlers/handler_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Billy::Handler do
-  let(:handler) { Class.new { include Billy::Handler }.new }
-  it '#handle_request raises an error if not overridden' do
-    expect(handler.handle_request(nil, nil, nil, nil)).to eql(error: 'The handler has not overridden the handle_request method!')
-  end
-
-  it '#handles_request returns false by default' do
-    expect(handler.handles_request?(nil, nil, nil, nil)).to be false
-  end
-
-  it 'responds to #reset' do
-    expect(handler).to respond_to :reset
-  end
-end