puffing-billy 3.0.0 → 3.0.1

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

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

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe Billy::Certificate do
-  let(:cert1) { Billy::Certificate.new('localhost') }
-  let(:cert2) { Billy::Certificate.new('localhost.localdomain') }
-
-  context('#domain') do
-    it 'holds the domain' do
-      expect(Billy::Certificate.new('test.tld').domain).to be_eql('test.tld')
-    end
-  end
-
-  context('#key') do
-    it 'generates a new key each time' do
-      expect(cert1.key).not_to be(cert2.key)
-    end
-
-    it 'generates 2048 bit keys' do
-      expect(cert1.key.n.num_bytes * 8).to be(2048)
-    end
-  end
-
-  context('#cert') do
-    it 'generates a new certificate each time' do
-      expect(cert1.cert).not_to be(cert2.cert)
-    end
-
-    it 'generates unique serials' do
-      expect(cert1.cert.serial).not_to be(cert2.cert.serial)
-    end
-
-    it 'configures a start date some days ago' do
-      expect(cert1.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(cert1.cert.not_after).to \
-        be_between(Date.today.to_time, (Date.today + 3).to_time)
-    end
-
-    it 'configures the correct subject' do
-      expect(cert1.cert.subject.to_s).to be_eql('/CN=localhost')
-    end
-
-    it 'configures the subject alternative names' do
-      expect(cert1.cert.extensions.first.to_s).to \
-        be_eql('subjectAltName = DNS:localhost')
-    end
-
-    it 'configures SSLv3' do
-      # Zero-index version numbers. Yay.
-      expect(cert1.cert.version).to be(2)
-    end
-  end
-
-  context('#key_file') do
-    it 'pass back the path' do
-      expect(cert1.key_file).to match(/request-localhost.key$/)
-    end
-
-    it 'creates a temporary file' do
-      expect(File.exist?(cert1.key_file)).to be(true)
-    end
-
-    it 'creates a PEM formatted certificate' do
-      expect(File.read(cert1.key_file)).to match(/^[A-Za-z0-9\-\+\/\=]+$/)
-    end
-
-    it 'writes out a private key' do
-      key = OpenSSL::PKey::RSA.new(File.read(cert1.key_file))
-      expect(key.private?).to be(true)
-    end
-  end
-
-  context('#cert_file') do
-    it 'pass back the path' do
-      expect(cert1.cert_file).to match(/request-localhost.crt$/)
-    end
-
-    it 'creates a temporary file' do
-      expect(File.exist?(cert1.cert_file)).to be(true)
-    end
-
-    it 'creates a PEM formatted certificate' do
-      expect(File.read(cert1.cert_file)).to match(/^[A-Za-z0-9\-\+\/\=]+$/)
-    end
-  end
-end

data/spec/lib/billy/watir/watir_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe 'Watir-specific tests', type: :feature, js: true do
-  before do
-    proxy.stub('http://www.example.com/get').and_return(
-      text: 'Success!'
-    )
-  end
-
-  it 'should raise a NameError if an invalid browser driver is specified' do
-    expect{Billy::Browsers::Watir.new :invalid}.to raise_error(NameError)
-  end
-
-  it 'should respond to a stubbed GET request' do
-    @browser.goto 'http://www.example.com/get'
-    expect(@browser.text).to eq 'Success!'
-  end
-end