puffing-billy 2.3.1 → 3.0.1

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

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe Billy::RequestLog do
-  let(:request_log) { Billy::RequestLog.new }
-
-  describe '#record' do
-    it 'returns the request details if record_requests is enabled' do
-      allow(Billy::config).to receive(:record_requests).and_return(true)
-      expected_request = {
-        status: :inflight,
-        handler: nil,
-        method: :method,
-        url: :url,
-        headers: :headers,
-        body: :body
-      }
-      expect(request_log.record(:method, :url, :headers, :body)).to eql(expected_request)
-    end
-
-    it 'returns nil if record_requests is disabled' do
-      allow(Billy::config).to receive(:record_requests).and_return(false)
-      expect(request_log.record(:method, :url, :headers, :body)).to be_nil
-    end
-  end
-
-  describe '#complete' do
-    it 'marks the request as complete if record_requests is enabled' do
-      allow(Billy::config).to receive(:record_requests).and_return(true)
-
-      request = request_log.record(:method, :url, :headers, :body)
-      expected_request = {
-        status: :complete,
-        handler: :handler,
-        method: :method,
-        url: :url,
-        headers: :headers,
-        body: :body
-      }
-      expect(request_log.complete(request, :handler)).to eql(expected_request)
-    end
-
-    it 'marks the request as complete if record_requests is disabled' do
-      allow(Billy::config).to receive(:record_requests).and_return(false)
-      expect(request_log.complete(nil, :handler)).to be_nil
-    end
-  end
-
-  describe '#requests' do
-    it 'returns an empty array when there are no requests' do
-      expect(request_log.requests).to be_empty
-    end
-
-    it 'returns the currently known requests' do
-      allow(Billy::config).to receive(:record_requests).and_return(true)
-
-      request1 = request_log.record(:method, :url, :headers, :body)
-      request2 = request_log.record(:method, :url, :headers, :body)
-      expect(request_log.requests).to eql([request1, request2])
-    end
-  end
-
-  describe '#reset' do
-    it 'resets known requests' do
-      allow(Billy::config).to receive(:record_requests).and_return(true)
-
-      request1 = request_log.record(:method, :url, :headers, :body)
-      request2 = request_log.record(:method, :url, :headers, :body)
-      expect(request_log.requests).to eql([request1, request2])
-
-      request_log.reset
-      expect(request_log.requests).to be_empty
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-describe Billy::StubHandler do
-  let(:handler) { Billy::StubHandler.new }
-  let(:request) do
-    {
-      method:   'GET',
-      url:      'http://example.test:8080/index?some=param',
-      headers:  { 'Accept-Encoding'  => 'gzip',
-                  'Cache-Control'    => 'no-cache' },
-      body:     'Some body'
-    }
-  end
-
-  describe '#handles_request?' do
-    it 'handles the request if it is stubbed' do
-      expect(handler).to receive(:find_stub).and_return('a stub')
-      expect(handler.handles_request?(nil, nil, nil, nil)).to be true
-    end
-
-    it 'does not handle the request if it is not stubbed' do
-      expect(handler).to receive(:find_stub).and_return(nil)
-      expect(handler.handles_request?(nil, nil, nil, nil)).to be false
-    end
-  end
-
-  describe '#handle_request' do
-    it 'returns nil if the request is not stubbed' do
-      expect(handler).to receive(:handles_request?).and_return(false)
-      expect(handler.handle_request(nil, nil, nil, nil)).to be nil
-    end
-
-    it 'returns a response hash if the request is stubbed' do
-      stub = double('stub', call: [200, { 'Content-Type' => 'application/json' }, 'Some content'])
-      expect(handler).to receive(:handles_request?).and_return(true)
-      expect(handler).to receive(:find_stub).and_return(stub)
-      expect(handler.handle_request('GET',
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to eql(status: 200,
-                                                            headers: { 'Content-Type' => 'application/json' },
-                                                            content: 'Some content')
-    end
-  end
-
-  describe '#reset' do
-    it 'resets the stubs' do
-      # Can't use request params when creating the stub.
-      # See https://github.com/oesmith/puffing-billy/issues/21
-      stub = handler.stub('http://example.test:8080/index')
-
-      expect(handler.stubs).to eql([stub])
-      expect(handler.handles_request?('GET',
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to be true
-      handler.reset
-      expect(handler.stubs).to be_empty
-      expect(handler.handles_request?('GET',
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to be false
-    end
-  end
-
-  describe '#unstub' do
-    let!(:get_stub) { handler.stub('http://example.get/') }
-    let!(:post_stub) { handler.stub('http://example.post/', method: :post) }
-
-    it 'removes a single stub' do
-      expect(handler.handles_request?('GET',
-                                      'http://example.get/',
-                                      request[:headers],
-                                      request[:body])).to be true
-      expect(handler.handles_request?('POST',
-                                      'http://example.post/',
-                                      request[:headers],
-                                      request[:body])).to be true
-
-      handler.unstub get_stub
-
-      expect(handler.handles_request?('GET',
-                                      'http://example.get/',
-                                      request[:headers],
-                                      request[:body])).to be false
-      expect(handler.handles_request?('POST',
-                                      'http://example.post/',
-                                      request[:headers],
-                                      request[:body])).to be true
-    end
-
-    it 'does not raise errors for not existing stub' do
-      expect { handler.unstub 'http://example.option/' }.not_to raise_error
-    end
-  end
-
-  it '#stubs requests' do
-    handler.stub('http://example.test:8080/index')
-    expect(handler.handles_request?('GET',
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to be true
-  end
-
-  describe '#stubs' do
-    it 'is empty by default' do
-      expect(handler.stubs).to be_empty
-    end
-
-    it 'keeps track of created stubs' do
-      stub1 = handler.stub('http://example.test:8080/index')
-      stub2 = handler.stub('http://example.test:8080/index')
-
-      expect(handler.stubs).to eql([stub2, stub1])
-    end
-  end
-end

data/spec/lib/billy/proxy_connection_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Billy::ProxyConnection do
-  context '#prepare_response_headers_for_evma_httpserver' do
-    let(:subject) { Billy::ProxyConnection.new('') }
-    
-    it 'should remove duplicated headers fields' do
-        provided_headers = {
-            'transfer-encoding' => '',
-            'content-length' => '',
-            'content-encoding' => '',
-            'key' => 'value'
-        }
-        expected_headers = { 'key' => 'value' }
-        headers = subject.send(:prepare_response_headers_for_evma_httpserver, provided_headers)
-
-        expect(headers).to eql expected_headers
-    end
-  end
-end

data/spec/lib/billy/proxy_request_stub_spec.rb

@@ -1,252 +0,0 @@
-require 'spec_helper'
-
-describe Billy::ProxyRequestStub do
-  context '#matches?' do
-    it 'should match urls and methods' do
-      expect(Billy::ProxyRequestStub.new('http://example.com')
-        .matches?('GET', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://example.com')
-        .matches?('POST', 'http://example.com')).to_not be
-
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :get)
-        .matches?('GET', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :post)
-        .matches?('GET', 'http://example.com')).to_not be
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :options)
-        .matches?('GET', 'http://example.com')).to_not be
-
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :post)
-        .matches?('POST', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://fooxample.com', method: :post)
-        .matches?('POST', 'http://example.com')).to_not be
-        expect(Billy::ProxyRequestStub.new('http://fooxample.com', method: :options)
-          .matches?('POST', 'http://example.com')).to_not be
-
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :options)
-        .matches?('OPTIONS', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :options)
-        .matches?('OPTIONS', 'http://zzzzzexample.com')).to_not be
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :post)
-        .matches?('OPTIONS', 'http://example.com')).to_not be
-    end
-
-    it 'should match regexps' do
-      expect(Billy::ProxyRequestStub.new(/http:\/\/.+\.com/, method: :post)
-        .matches?('POST', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new(/http:\/\/.+\.co\.uk/, method: :get)
-        .matches?('GET', 'http://example.com')).to_not be
-    end
-
-    it 'should match up to but not including query strings' do
-      stub = Billy::ProxyRequestStub.new('http://example.com/foo/bar/')
-      expect(stub.matches?('GET', 'http://example.com/foo/')).to_not be
-      expect(stub.matches?('GET', 'http://example.com/foo/bar/')).to be
-      expect(stub.matches?('GET', 'http://example.com/foo/bar/?baz=bap')).to be
-    end
-
-    it 'should match all methods' do
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :all)
-        .matches?('GET', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :all)
-        .matches?('POST', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :all)
-        .matches?('OPTIONS', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://example.com', method: :all)
-        .matches?('HEAD', 'http://example.com')).to be
-    end
-  end
-
-  context "#matches? (with strip_query_params false in config)" do
-    before do
-      Billy.config.strip_query_params = false
-    end
-
-    it 'should not match up to request with query strings' do
-      stub = Billy::ProxyRequestStub.new('http://example.com/foo/bar/')
-      expect(stub.matches?('GET', 'http://example.com/foo/')).to_not be
-      expect(stub.matches?('GET', 'http://example.com/foo/bar/')).to be
-      expect(stub.matches?('GET', 'http://example.com/foo/bar/?baz=bap')).to_not be
-    end
-  end
-
-  context '#call (without #and_return)' do
-    let(:subject) { Billy::ProxyRequestStub.new('url') }
-
-    it 'returns a 204 empty response' do
-      expect(subject.call('', '', {}, {}, nil)).to eql [204, { 'Content-Type' => 'text/plain' }, '']
-    end
-  end
-
-  context '#and_return + #call' do
-    let(:subject) { Billy::ProxyRequestStub.new('url') }
-
-    it 'should generate bare responses' do
-      subject.and_return body: 'baz foo bar'
-      expect(subject.call('', '', {}, {}, nil)).to eql [
-        200,
-        {},
-        'baz foo bar'
-      ]
-    end
-
-    it 'should generate text responses' do
-      subject.and_return text: 'foo bar baz'
-      expect(subject.call('', '', {}, {}, nil)).to eql [
-        200,
-        { 'Content-Type' => 'text/plain' },
-        'foo bar baz'
-      ]
-    end
-
-    it 'should generate JSON responses' do
-      subject.and_return json: { foo: 'bar' }
-      expect(subject.call('', '', {}, {}, nil)).to eql [
-        200,
-        { 'Content-Type' => 'application/json' },
-        '{"foo":"bar"}'
-      ]
-    end
-
-    context 'JSONP' do
-      it 'should generate JSONP responses' do
-        subject.and_return jsonp: { foo: 'bar' }
-        expect(subject.call('', '', { 'callback' => ['baz'] }, {}, nil)).to eql [
-          200,
-          { 'Content-Type' => 'application/javascript' },
-          'baz({"foo":"bar"})'
-        ]
-      end
-
-      it 'should generate JSONP responses with custom callback parameter' do
-        subject.and_return jsonp: { foo: 'bar' }, callback_param: 'cb'
-        expect(subject.call('', '', { 'cb' => ['bap'] }, {}, nil)).to eql [
-          200,
-          { 'Content-Type' => 'application/javascript' },
-          'bap({"foo":"bar"})'
-        ]
-      end
-
-      it 'should generate JSONP responses with custom callback name' do
-        subject.and_return jsonp: { foo: 'bar' }, callback: 'cb'
-        expect(subject.call('', '', {}, {}, nil)).to eql [
-          200,
-          { 'Content-Type' => 'application/javascript' },
-          'cb({"foo":"bar"})'
-        ]
-      end
-    end
-
-    it 'should generate redirection responses' do
-      subject.and_return redirect_to: 'http://example.com'
-      expect(subject.call('', '', {}, {}, nil)).to eql [
-        302,
-        { 'Location' => 'http://example.com' },
-        nil
-      ]
-    end
-
-    it 'should set headers' do
-      subject.and_return text: 'foo', headers: { 'HTTP-X-Foo' => 'bar' }
-      expect(subject.call('', '', {}, {}, nil)).to eql [
-        200,
-        { 'Content-Type' => 'text/plain', 'HTTP-X-Foo' => 'bar' },
-        'foo'
-      ]
-    end
-
-    it 'should set status codes' do
-      subject.and_return text: 'baz', code: 410
-      expect(subject.call('', '', {}, {}, nil)).to eql [
-        410,
-        { 'Content-Type' => 'text/plain' },
-        'baz'
-      ]
-    end
-
-    it 'should use a callable' do
-      expected_params = { 'param1' => ['one'], 'param2' => ['two'] }
-      expected_headers = { 'header1' => 'three', 'header2' => 'four' }
-      expected_body = 'body text'
-
-      subject.and_return(proc do |params, headers, body, url, method|
-        expect(params).to eql expected_params
-        expect(headers).to eql expected_headers
-        expect(body).to eql 'body text'
-        expect(url).to eql 'url'
-        expect(method).to eql 'GET'
-        { code: 418, text: 'success' }
-      end)
-      expect(subject.call('GET', 'url', expected_params, expected_headers, expected_body)).to eql [
-        418,
-        { 'Content-Type' => 'text/plain' },
-        'success'
-      ]
-    end
-
-    it 'should use a callable with Billy.pass_request' do
-      # Add the missing em-synchrony call which is done by
-      # ProxyConnection#handle_request instead.
-      EM.synchrony do
-        subject.and_return(proc do |*args|
-          response = Billy.pass_request(*args)
-          response[:body] = 'modified'
-          response[:code] = 205
-          response
-        end)
-
-        # The test server can't be used at this scenario due to the limitations
-        # of the Ruby GIL. We cannot use fibers (via eventmachine) and ask
-        # ourself on a different thread to serve a HTTP request. This results
-        # in +fiber called across threads (FiberError)+ errors. Unfortunately
-        # we have to ask an external resource.
-        url = 'http://google.com'
-
-        expect(subject.call('GET', url, {}, {}, 'original')).to eql [
-          205,
-          'modified'
-        ]
-      end
-    end
-  end
-
-  context '#stub_requests' do
-    let(:subject) { Billy::ProxyRequestStub.new('url') }
-
-    before :each do
-      Billy.config.record_stub_requests = true
-    end
-
-    it 'should record requests' do
-      subject.call('', '', {}, {}, nil)
-      expect(subject.has_requests?).to be true
-    end
-
-    it 'should record multiple requests' do
-      expected_amount = 3
-      expected_amount.times do
-        subject.call('', '', {}, {}, nil)
-      end
-
-      expect(subject.requests.length).to eql expected_amount
-    end
-
-    it 'should set a request' do
-      expected_request = {
-        method: 'POST',
-        url: 'test-url',
-        params: { 'param1' => ['one'], 'param2' => ['two'] },
-        headers: { 'header1' => 'three', 'header2' => 'four' },
-        body: 'body text'
-      }
-
-      subject.call(
-        expected_request[:method],
-        expected_request[:url],
-        expected_request[:params],
-        expected_request[:headers],
-        expected_request[:body]
-      )
-      expect(subject.requests[0]).to eql expected_request
-    end
-  end
-end

data/spec/lib/billy/resource_utils_spec.rb

@@ -1,55 +0,0 @@
-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], %w(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: [%w(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: [%w(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/billy/ssl/authority_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Billy::Authority do
-  let(:auth1) { Billy::Authority.new }
-  let(:auth2) { Billy::Authority.new }
-
-  context('#key') do
-    it 'generates a new key each time' do
-      expect(auth1.key).not_to be(auth2.key)
-    end
-
-    it 'generates 2048 bit keys' do
-      expect(auth1.key.n.num_bytes * 8).to be(2048)
-    end
-  end
-
-  context('#cert') do
-    it 'generates a new certificate each time' do
-      expect(auth1.cert).not_to be(auth2.cert)
-    end
-
-    it 'generates unique serials' do
-      expect(auth1.cert.serial).not_to be(auth2.cert.serial)
-    end
-
-    it 'configures a start date some days ago' do
-      expect(auth1.cert.not_before).to \
-        be_between((Date.today - 3).to_time, Date.today.to_time)
-    end
-
-    it 'configures an end date in some days' do
-      expect(auth1.cert.not_after).to \
-        be_between(Date.today.to_time, (Date.today + 3).to_time)
-    end
-
-    it 'configures the subject' do
-      expect(auth1.cert.subject.to_s).to \
-        be_eql('/CN=Puffing Billy/O=Puffing Billy')
-    end
-
-    it 'configures the certificate authority constrain' do
-      expect(auth1.cert.extensions.first.to_s).to \
-        be_eql('basicConstraints = critical, CA:TRUE')
-    end
-
-    it 'configures SSLv3' do
-      # Zero-index version numbers. Yay.
-      expect(auth1.cert.version).to be(2)
-    end
-  end
-
-  context('#key_file') do
-    it 'pass back the path' do
-      expect(auth1.key_file).to match(/ca.key$/)
-    end
-
-    it 'creates a temporary file' do
-      expect(File.exist?(auth1.key_file)).to be(true)
-    end
-
-    it 'creates a PEM formatted certificate' do
-      expect(File.read(auth1.key_file)).to match(/^[A-Za-z0-9\-\+\/\=]+$/)
-    end
-
-    it 'writes out a private key' do
-      key = OpenSSL::PKey::RSA.new(File.read(auth1.key_file))
-      expect(key.private?).to be(true)
-    end
-  end
-
-  context('#cert_file') do
-    it 'pass back the path' do
-      expect(auth1.cert_file).to match(/ca.crt$/)
-    end
-
-    it 'creates a temporary file' do
-      expect(File.exist?(auth1.cert_file)).to be(true)
-    end
-
-    it 'creates a PEM formatted certificate' do
-      expect(File.read(auth1.cert_file)).to match(/^[A-Za-z0-9\-\+\/\=]+$/)
-    end
-  end
-end

data/spec/lib/billy/ssl/certificate_chain_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Billy::CertificateChain do
-  let(:cert1) { Billy::Certificate.new('localhost') }
-  let(:cert2) { Billy::Certificate.new('localhost.localdomain') }
-  let(:chain) do
-    Billy::CertificateChain.new('localhost', cert1.cert, cert2.cert)
-  end
-
-  context('#initialize') do
-    it 'holds all certificates in order' do
-      expect(chain.certificates).to be_eql([cert1.cert, cert2.cert])
-    end
-
-    it 'holds the domain' do
-      expect(chain.domain).to be_eql('localhost')
-    end
-  end
-
-  context('#file') do
-    it 'pass back the path' do
-      expect(chain.file).to match(/chain-localhost.pem/)
-    end
-
-    it 'writes out all certificates' do
-      chain.certificates.each do |cert|
-        expect(File.read(chain.file)).to include(cert.to_pem)
-      end
-    end
-
-    it 'creates a temporary file' do
-      expect(File.exist?(chain.file)).to be(true)
-    end
-
-    it 'creates a PEM formatted certificate chain' do
-      expect(File.read(chain.file)).to match(/^[A-Za-z0-9\-\+\/\=]+$/)
-    end
-  end
-end