beaker-http 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 126ad20369072bad14cd0f1c540ebf2c5c09c8c8
+  data.tar.gz: 627779ca603f73a147d893dd8fef723b48082d28
+SHA512:
+  metadata.gz: 149ac40c2ad28e4dd28d96cd27dfa0661b94018f1735139712ed655c969c179a8e0589339d7dc13f1c3ce137949eba67e98fe304185b829e356487fd291ccb85
+  data.tar.gz: da4fac3b62401bbabe3400c336701e76329dc2bb700fb5f802d1be66f38bdcdc93dd41839b2919a4eb37a429b403ebac4d4fec74ce0db9c7ef1cec76c7f65272

data/Gemfile

@@ -0,0 +1,3 @@
+source ENV['GEM_SOURCE'] || "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,17 @@
+# beaker-http
+
+This library is designed to assist in test scenarios where http requests to a Beaker::Host
+are required. It utilizes the Faraday library to generate requests, and the [Http](lib/beaker-http/http.rb)
+class is designed to be subclassed into objects that are more targeted to specific http
+services running on beaker hosts.
+
+## spec testing
+
+Spec tests all live under the `spec` folder.  These are the default rake task, &
+so can be run with a simple `bundle exec rake`, as well as being fully specified
+by running `bundle exec rake test:spec:run` or using the `test:spec` task.
+
+## acceptance testing
+
+Acceptance testing will be added once the first few releases have been released.
+

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rspec/core/rake_task'
+
+namespace :test do
+
+  namespace :spec do
+
+    desc "Run spec tests"
+    RSpec::Core::RakeTask.new(:run) do |t|
+      t.rspec_opts = ['--color']
+      t.pattern = 'spec/'
+    end
+  end
+end
+
+task 'test:spec' => 'test:spec:run'
+task :test => 'test:spec'
+task :default => :test

data/acceptance/tests/puppetserver_requests.rb

@@ -0,0 +1,33 @@
+require 'beaker-http'
+
+test_name 'Ensure that requests can be built out to the puppetserver' do
+
+  step 'install latest released puppet agent' do
+    install_puppet_agent_on(hosts)
+  end
+
+  step 'install the latest puppet-server on the master' do
+    install_package(master, 'puppetserver')
+    on master, 'service puppetserver start'
+  end
+
+  step 'generate a new beaker http connection object'
+  http_connection = generate_new_http_connection(master)
+
+  step 'configure the connection to connect to the master port' do
+    http_connection.url_prefix.port = 8140
+  end
+
+  step 'call the environments endpoint on the puppetserver' do
+    response = http_connection.get('/puppet/v3/environments')
+    assert_equal(200, response.status)
+  end
+
+  step 'call the environments endpoint with the #https_request method' do
+    response = http_request("https://#{master.hostname}:8140/puppet/v3/environments",
+      :get,
+      http_connection.ssl['client_cert'],
+      http_connection.ssl['client_key'])
+    assert_equal(200, response.status)
+  end
+end

data/beaker-http.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'beaker-http/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "beaker-http"
+  spec.version       = Beaker::Http::Version::STRING
+  spec.authors       = ["Puppet"]
+  spec.email         = ["qe@puppet.com"]
+  spec.summary       = %q{Puppet testing tool}
+  spec.description   = %q{Puppet testing tool coupled with Beaker}
+  spec.homepage      = "https://github.com/puppetlabs/beaker-http"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  #Development dependencies
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'pry', '~> 0.9.12'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 3.0.0'
+
+  #Documentation dependencies
+  spec.add_development_dependency 'yard', '~> 0'
+  spec.add_development_dependency 'markdown', '~> 0'
+  spec.add_development_dependency 'activesupport', '4.2.6'
+
+  #Run time dependencies
+  spec.add_runtime_dependency 'json', '~> 1.8'
+  spec.add_runtime_dependency 'beaker', '~> 3.0'
+  spec.add_runtime_dependency 'faraday', '~> 0.9', '>= 0.9.1'
+  spec.add_runtime_dependency 'faraday_middleware', '~> 0.9'
+end

data/lib/beaker-http/dsl/web_helpers.rb

@@ -0,0 +1,62 @@
+module Beaker::DSL::Helpers::WebHelpers
+
+  # Generates a new http connection object, using the ever-present options hash to
+  # configure the connection.
+  #
+  # @param host [Beaker::Host optional] supply a SUT host object; will use puppet on host
+  #    to configure certs, and use the options in the host object instead of the global.
+  # @return [Beaker::Http::Connection] an object wrapping the Faraday::Connection object.
+  def generate_new_http_connection(host = nil)
+    if host
+      raise ArgumentError.new "host must be Beaker::Host, not #{host.class}" if !host.is_a?(Beaker::Host)
+      connection = Beaker::Http::Connection.new(host.options)
+      connection.configure_private_key_and_cert_with_puppet(host)
+      connection
+    else
+      Beaker::Http::Connection.new(options)
+    end
+  end
+
+  # Make a single http request and discard the http connection object. Returns a Faraday::Response
+  # object that can be introspected for all response information.
+  #
+  # @param url [String] String that will be parsed into a URI object.
+  # @param request_method [Symbol] Represents any valid http verb.
+  # @param cert [OpenSSL::X509::Certificate] Certifcate for authentication.
+  # @param key [OpenSSL::PKey::RSA] Private Key for authentication.
+  # @param body [String, Hash] For requests that can send a body. Strings are sent unformatted and
+  #    Hashes are JSON.parsed by the Faraday Middleware.
+  # @param [Hash] options Hash of options extra options for the request
+  # @option options [Boolean] :read_timeout How long to wait before closing the connection.
+  # @return [Faraday::Response]
+  def http_request(url, request_method, cert=nil, key=nil, body=nil, options={})
+    connection = generate_new_http_connection
+
+
+    connection.url_prefix = URI.parse(url)
+
+    if cert
+      if cert.is_a?(OpenSSL::X509::Certificate)
+        connection.ssl['client_cert'] = cert
+      else
+        raise TypeError, "cert must be an OpenSSL::X509::Certificate object, not #{cert.class}"
+      end
+    end
+
+    if key
+      if key.is_a?(OpenSSL::PKey::RSA)
+        connection.ssl['client_key'] = key
+      else
+        raise TypeError, "key must be an OpenSSL::PKey:RSA object, not #{key.class}"
+      end
+    end
+
+    # ewwww
+    connection.ssl[:verify] = false
+
+    connection.connection.options.timeout = options[:read_timeout] if options[:read_timeout]
+
+    response = connection.send(request_method) { |conn| conn.body = body }
+    response
+  end
+end

data/lib/beaker-http/helpers/puppet_helpers.rb

@@ -0,0 +1,49 @@
+module Beaker
+  module Http
+    module Helpers
+
+      # Given a Beaker::Host object, introspect the host for the CA cert and save it to
+      # the coordinator's filesystem.
+      # @param host[Beaker::Host] host to ssh into and find the CA cert
+      # @return [String] File path to the CA cert saved on the coordinator
+      def get_host_cacert(host)
+        cacert_on_host= host.puppet['localcacert']
+        # puppet may not have laid down the cacert yet, so check to make sure
+        # the file exists
+        host.execute("test -f #{cacert_on_host}")
+        ca_cert = host.execute("cat #{cacert_on_host}", :silent => true)
+        cert_dir = Dir.mktmpdir("pe_certs")
+        ca_cert_file = File.join(cert_dir, "cacert.pem")
+        File.open(ca_cert_file, "w+") do |f|
+          f.write(ca_cert)
+        end
+        ca_cert_file
+      end
+
+      # Given a Beaker::Host object, introspect the host for the private key and save it to
+      # the coordinator's filesystem.
+      # @param host[Beaker::Host] host to ssh into and find the private key
+      # @return [String] A String of the private key
+      def get_host_private_key(host)
+        private_key = host.puppet['hostprivkey']
+        # puppet may not have laid down the private_key yet, so check to make sure
+        # the file exists
+        host.execute("test -f #{private_key}")
+        host.execute("cat #{private_key}", :silent => true)
+      end
+
+      # Given a Beaker::Host object, introspect the host for the host cert and save it to
+      # the coordinator's filesystem.
+      # @param host[Beaker::Host] host to ssh into and find the host cert
+      # @return [String] A String of the host cert
+      def get_host_cert(host)
+        hostcert = host.puppet['hostcert']
+        # puppet may not have laid down the hostcert yet, so check to make sure
+        # the file exists
+        host.execute("test -f #{hostcert}")
+        host.execute("cat #{hostcert}", :silent => true)
+      end
+
+    end
+  end
+end

data/lib/beaker-http/http.rb

@@ -0,0 +1,93 @@
+module Beaker
+  module Http
+
+    # == Beaker::Http::Connection object instantiation examples
+    # These examples are for using the Connection object directly. If you are trying to use
+    # this from within a test, consider using the
+    # {Beaker::DSL::Helpers::WebHelpers DSL constructors} instead.
+    # @see Beaker::DSL::Helpers::WebHelpers
+    class Connection
+      include Beaker::Http::Helpers
+      extend Forwardable
+
+      attr_reader :connection
+
+      # Beaker::Http::Connection objects can be instantiated with object that
+      # utilizes a  object for easier setup during testing.
+      #
+      # @param [Hash] options Typically the global options provided by Beaker.
+      # @option options [Beaker::Logger] :logger
+      # @option options [Boolean] :log_http_bodies
+      def initialize(options)
+        @connection = create_default_connection(options)
+      end
+
+      def_delegators :connection, :get, :post, :put, :delete, :head, :patch, :url_prefix, :url_prefix=, :ssl
+
+      def create_default_connection(options)
+        Faraday.new do |conn|
+          conn.request :json
+
+          conn.response :follow_redirects
+          conn.response :raise_error
+          conn.response :json, :content_type => /\bjson$/
+
+          # We can supply a third argument, a Hash with key of :bodies set to true or false,
+          # to configure whether or not to log http bodies in requests and responses.
+          # However, to uncomplicate things, we will just use the default
+          # set in the middleware and not allow the http log level to be set
+          # independently of the beaker log level. If we find that we should allow setting
+          # of http bodies independent of the beaker log level, we should expose that setting
+          # here.
+          conn.response :faraday_beaker_logger, options[:logger]
+
+          conn.adapter :net_http
+        end
+      end
+
+      # If you would like to run tests that expect 400 or even 500 responses,
+      # apply this method to remove the <tt>:raise_error</tt> middleware.
+      def remove_error_checking
+        connection.builder.delete(Faraday::Response::RaiseError)
+        nil
+      end
+
+      def set_cacert(ca_file)
+        ssl['ca_file'] = ca_file
+        url_prefix.scheme = 'https'
+      end
+
+      def set_client_key(client_key)
+        ssl['client_key'] = client_key
+      end
+
+      def set_client_cert(client_cert)
+        ssl['client_cert'] = client_cert
+      end
+
+      # Use this method if you are connecting as a user to the system; it will
+      # provide the correct SSL context but not provide authentication.
+      def configure_cacert_with_puppet(host)
+        set_cacert(get_host_cacert(host))
+        connection.host = host.hostname
+        nil
+      end
+
+      # Use this method if you want to connect to the system using certificate
+      # based authentication. This method will provide the ssl context and use
+      # the private key and cert from the host provided for authentication.
+      def configure_private_key_and_cert_with_puppet(host)
+        configure_cacert_with_puppet(host)
+
+        client_key_raw = get_host_private_key(host)
+        client_cert_raw = get_host_cert(host)
+
+        ssl['client_key'] = OpenSSL::PKey.read(client_key_raw)
+        ssl['client_cert'] = OpenSSL::X509::Certificate.new(client_cert_raw)
+
+        nil
+      end
+
+    end
+  end
+end

data/lib/beaker-http/middleware/response/faraday_beaker_logger.rb

@@ -0,0 +1,55 @@
+module Beaker
+  module Http
+    class FaradayBeakerLogger < Faraday::Response::Middleware
+      extend Forwardable
+
+      DEFAULT_OPTIONS = { :bodies => true }
+
+      def initialize(app, logger, options = {} )
+        super(app)
+        @logger = logger
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      def_delegators :@logger, :trace, :debug, :info, :notify, :warn
+
+      def call(env)
+        @start_time = Time.now
+        info "#{env.method.upcase}: #{env.url.to_s}"
+        debug "REQUEST HEADERS:\n#{dump_headers env.request_headers}"
+        debug "REQUEST BODY:\n#{dump_body env[:body]}" if env[:body] && log_body?(:request)
+        super
+      end
+
+      def on_complete(env)
+        info "RESPONSE CODE: #{env.status.to_s}"
+        debug "ELAPSED TIME: #{Time.now - @start_time}"
+        debug "RESPONSE HEADERS:\n#{dump_headers env.response_headers}"
+        debug "RESPONSE BODY:\n#{dump_body env[:body]}" if env[:body] && log_body?(:response)
+      end
+      private
+
+      def dump_headers(headers)
+        headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
+      end
+
+      def dump_body(body)
+        if body.respond_to?(:to_str)
+          body.to_str
+        else
+          pretty_inspect(body)
+        end
+      end
+
+      def log_body?(type)
+        case @options[:bodies]
+        when Hash then @options[:bodies][type]
+        else @options[:bodies]
+      end
+    end
+
+    end
+  end
+end
+
+Faraday::Response.register_middleware :faraday_beaker_logger => lambda { Beaker::Http::FaradayBeakerLogger }

data/lib/beaker-http/version.rb

@@ -0,0 +1,7 @@
+module Beaker
+  module Http
+    module Version
+      STRING = '0.0.1'
+    end
+  end
+end

data/lib/beaker-http.rb

@@ -0,0 +1,10 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'forwardable'
+
+require 'beaker'
+
+require 'beaker-http/helpers/puppet_helpers'
+require 'beaker-http/dsl/web_helpers'
+require "beaker-http/http"
+require 'beaker-http/middleware/response/faraday_beaker_logger'

data/spec/beaker-http/dsl/web_helpers_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLWebHelpers
+  include Beaker::DSL::Helpers
+
+  attr_accessor :options
+
+  def initialize
+    @options = { logger: Beaker::Logger.new }
+  end
+end
+
+describe ClassMixedWithDSLWebHelpers do
+
+  describe '#generate_new_http_connection' do
+
+    it 'raises an argument error if a non Beaker::Host is supplied' do
+      expect{subject.generate_new_http_connection(Object.new)}.to raise_error(ArgumentError)
+    end
+
+    it 'raises no errors when no argument is supplied' do
+      expect{subject.generate_new_http_connection}.to_not raise_error
+    end
+
+    context 'when passed a beaker host' do
+      unixhost = { roles:     ['test_role'],
+                   'platform' => 'debian-7-x86_64' }
+      let(:host) { Beaker::Host.create('test.com', unixhost, {}) }
+      let(:mock_options) { {:logger => Beaker::Logger.new} }
+      let(:mock_connection) {double('connection')}
+
+      it 'configures the connection object' do
+        expect(mock_connection).to receive(:configure_private_key_and_cert_with_puppet).with(host)
+        expect(Beaker::Http::Connection).to receive(:new).with(mock_options).and_return(mock_connection)
+        allow(host).to receive(:options).and_return(mock_options)
+        expect{subject.generate_new_http_connection(host)}.to_not raise_error
+      end
+    end
+
+  end
+
+  describe '#http_request' do
+    let (:url) {"http://wwww.test.com"}
+    let (:request_method) { :get }
+    let (:mock_response) {double('reponse')}
+    let (:mock_connection) { subject.generate_new_http_connection }
+    let (:read_timeout) {double('read_timeout')}
+
+    it 'sends a GET request to the url with the minimum required params' do
+      expect(mock_connection).to receive(:get).and_return(mock_response)
+      expect(URI).to receive(:parse).with(url).and_call_original
+      expect(mock_connection).to receive(:url_prefix=).and_call_original
+      expect(subject).to receive(:generate_new_http_connection).and_return(mock_connection)
+      expect(subject.http_request(url, request_method)).to eq(mock_response)
+    end
+
+    context 'send a DELETE request to the url with the minimum required params' do
+      let (:request_method) { :delete }
+      it 'sends a DELETE request to the url with the minimum required params' do
+        expect(mock_connection).to receive(:delete).and_return(mock_response)
+        expect(URI).to receive(:parse).with(url).and_call_original
+        expect(mock_connection).to receive(:url_prefix=).and_call_original
+        expect(subject).to receive(:generate_new_http_connection).and_return(mock_connection)
+        expect(subject.http_request(url, request_method)).to eq(mock_response)
+      end
+    end
+
+    context 'when the request_method is POST' do
+      let (:request_method) { :post }
+      let (:body) {double('body')}
+      let (:conn) { double('conn') }
+
+      it 'sends a body along in the request' do
+        expect(conn).to receive(:body=).with(body)
+        expect(mock_connection).to receive(:post).and_yield(conn).and_return(mock_response)
+        expect(URI).to receive(:parse).with(url).and_call_original
+        expect(mock_connection).to receive(:url_prefix=).and_call_original
+        expect(subject).to receive(:generate_new_http_connection).and_return(mock_connection)
+        expect(subject.http_request(url, request_method, nil, nil, body, {})).to eq(mock_response)
+      end
+    end
+
+
+    context 'when the request_method is PUT' do
+      let (:request_method) { :put }
+      let (:body) {double('body')}
+      let (:conn) { double('conn') }
+
+      it 'sends a body along in the request' do
+        expect(conn).to receive(:body=).with(body)
+        expect(mock_connection).to receive(:put).and_yield(conn).and_return(mock_response)
+        expect(URI).to receive(:parse).with(url).and_call_original
+        expect(mock_connection).to receive(:url_prefix=).and_call_original
+        expect(subject).to receive(:generate_new_http_connection).and_return(mock_connection)
+        expect(subject.http_request(url, request_method, nil, nil, body, {})).to eq(mock_response)
+      end
+
+    end
+
+    it 'can set the timeout from the options hash passed in' do
+      expect(mock_connection).to receive(:get).and_return(mock_response)
+      expect(URI).to receive(:parse).with(url).and_call_original
+      expect(mock_connection).to receive(:url_prefix=).and_call_original
+      expect(subject).to receive(:generate_new_http_connection).and_return(mock_connection)
+      expect(subject.http_request(url, request_method, nil, nil, nil, :read_timeout => read_timeout)).to eq(mock_response)
+      expect(mock_connection.connection.options.timeout).to eq(read_timeout)
+    end
+
+    context 'with a key and cert provided' do
+      let (:key) {'key'}
+      let (:cert) {'cert'}
+      it 'checks to ensure they are valid types and then adds them to the request' do
+
+        expect(mock_connection).to receive(:get).and_return(mock_response)
+        expect(key).to receive(:is_a?).with(OpenSSL::PKey::RSA).and_return(true)
+        expect(cert).to receive(:is_a?).with(OpenSSL::X509::Certificate).and_return(true)
+        expect(URI).to receive(:parse).with(url).and_call_original
+        expect(mock_connection).to receive(:url_prefix=).and_call_original
+
+        expect(subject).to receive(:generate_new_http_connection).and_return(mock_connection)
+
+        expect(subject.http_request(url, request_method, cert, key)).to eq(mock_response)
+        expect(mock_connection.ssl['client_key']).to eq(key)
+        expect(mock_connection.ssl['client_cert']).to eq(cert)
+      end
+
+      it 'errors when an invalid key is provided' do
+        expect(mock_connection).to_not receive(:get)
+        expect(key).to receive(:is_a?).with(OpenSSL::PKey::RSA).and_call_original
+        expect(cert).to receive(:is_a?).with(OpenSSL::X509::Certificate).and_return(true)
+        expect(URI).to receive(:parse).with(url).and_call_original
+        expect(mock_connection).to receive(:url_prefix=).and_call_original
+        expect(subject).to receive(:generate_new_http_connection).and_return(mock_connection)
+        expect{subject.http_request(url, request_method, cert, key)}.to raise_error(TypeError)
+      end
+
+      it 'errors when an invalid cert is provided' do
+        expect(mock_connection).to_not receive(:get)
+        expect(key).to_not receive(:is_a?).with(OpenSSL::PKey::RSA)
+        expect(cert).to receive(:is_a?).with(OpenSSL::X509::Certificate).and_call_original
+        expect(URI).to receive(:parse).with(url).and_call_original
+        expect(mock_connection).to receive(:url_prefix=).and_call_original
+        expect(subject).to receive(:generate_new_http_connection).and_return(mock_connection)
+        expect{subject.http_request(url, request_method, cert, key)}.to raise_error(TypeError)
+      end
+
+    end
+
+  end
+
+end

data/spec/beaker-http/http_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Beaker
+  module Http
+    describe Connection do
+
+      let(:options) {{ :logger => Beaker::Logger.new}}
+
+      subject { Connection.new( options ) }
+
+      context 'with a beaker logger in the options passed in ' do
+
+        it 'does not raise errors' do
+          expect {subject}.to_not raise_error
+        end
+
+        it 'sets a Faraday object as the instance connection object' do
+          expect(subject.connection).to be_instance_of(Faraday::Connection)
+        end
+
+        it 'sets the middleware stack' do
+          expect(subject.connection.builder.handlers).to eq(HttpHelpers::DEFAULT_MIDDLEWARE_STACK)
+        end
+
+        it 'routes all http verbs to the connection object' do
+          http_verbs = [:get, :post, :put, :delete, :head, :patch]
+
+          http_verbs.each do |verb|
+            expect(subject.connection).to receive(verb)
+            subject.send(verb)
+          end
+        end
+
+        it 'routes other useful methods to the connection object' do
+          useful_methods = [:url_prefix, :url_prefix=, :ssl]
+
+          useful_methods.each do |method|
+            expect(subject.connection).to receive(method)
+            subject.send(method)
+          end
+        end
+
+        describe '#remove_error_checking' do
+          it 'removes the faraday middleware raising errors on 4xx and 5xx requests' do
+            subject.remove_error_checking
+            expect(subject.connection.builder.handlers).not_to include(Faraday::Response::RaiseError)
+          end
+        end
+
+        context 'with a beaker host passed in' do
+        unixhost = { roles:     ['test_role'],
+                     'platform' => 'debian-7-x86_64' }
+        let(:host) { Beaker::Host.create('test.com', unixhost, {}) }
+
+          describe '#configure_cacert_with_puppet'
+          it 'adds a ca_cert to the connection and changes the scheme to https' do
+            allow(subject).to receive(:get_host_cacert).with(host).and_return('ca_file')
+            subject.configure_cacert_with_puppet(host)
+            expect(subject.connection.ssl['ca_file']).to eq('ca_file')
+            expect(subject.connection.scheme).to eq('https')
+          end
+
+          describe '#configure_private_key_and_cert_with_puppet'
+          it 'calls #configure_cacert_only_with_puppet and adds the host private key and cert' do
+            allow(subject).to receive(:configure_cacert_with_puppet)
+            allow(subject).to receive(:get_host_private_key).with(host).and_return('private_key')
+            allow(subject).to receive(:get_host_cert).with(host).and_return('host_cert')
+
+            allow(OpenSSL::PKey).to receive(:read).with('private_key').and_return('ssl_private_key')
+            allow(OpenSSL::X509::Certificate).to receive(:new).with('host_cert').and_return('ssl_host_cert')
+
+            subject.configure_private_key_and_cert_with_puppet(host)
+            expect(subject.connection.ssl['client_key']).to eq('ssl_private_key')
+            expect(subject.connection.ssl['client_cert']).to eq('ssl_host_cert')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/beaker-http/middleware/response/faraday_beaker_logger_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Beaker::Http::FaradayBeakerLogger do
+
+  let(:conn) { Faraday.new(:url => 'http://test.com/path') }
+  let (:logger) { Beaker::Logger.new }
+
+  context 'with log bodies turned off' do
+
+    before do
+      conn.builder.insert(0, Beaker::Http::FaradayBeakerLogger, logger, :bodies => false)
+      conn.adapter :test do |stub|
+        stub.get('/path') {[200, {}, 'success']}
+      end
+    end
+
+    it 'sends info and debug requests to the logger' do
+      expect(logger).to receive(:info).with('GET: http://test.com/path').once
+      expect(logger).to receive(:info).with(/RESPONSE CODE: 200/).once
+      expect(logger).to receive(:debug).with(/ELAPSED TIME:/).once
+      expect(logger).to receive(:debug).with(/REQUEST HEADERS:/).once
+      expect(logger).to receive(:debug).with(/RESPONSE HEADERS:/).once
+      expect(logger).to_not receive(:debug).with(/RESPONSE BODY:/)
+      expect(logger).to_not receive(:debug).with(/REQUEST BODY:/)
+      conn.get
+    end
+  end
+
+  context 'with log bodies turned on' do
+
+    before do
+      conn.builder.insert(0, Beaker::Http::FaradayBeakerLogger, logger, :bodies => true)
+      conn.adapter :test do |stub|
+        stub.post('/path') {[201, {}, 'success']}
+      end
+    end
+
+    it 'sends extra debug requests to the logger' do
+      expect(logger).to receive(:info).with('POST: http://test.com/path').once
+      expect(logger).to receive(:info).with(/RESPONSE CODE: 201/).once
+      expect(logger).to receive(:debug).with(/ELAPSED TIME:/).once
+      expect(logger).to receive(:debug).with(/RESPONSE BODY:\nsuccess/).once
+      expect(logger).to receive(:debug).with(/REQUEST BODY:\nBODY MOVIN'/).once
+      expect(logger).to receive(:debug).with(/REQUEST HEADERS:/).once
+      expect(logger).to receive(:debug).with(/RESPONSE HEADERS:/).once
+      conn.post() { |connection| connection.body = "BODY MOVIN'" }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'beaker-http'
+
+module HttpHelpers
+  DEFAULT_MIDDLEWARE_STACK = [FaradayMiddleware::EncodeJson,
+                              FaradayMiddleware::FollowRedirects,
+                              Faraday::Response::RaiseError,
+                              FaradayMiddleware::ParseJson,
+                              Beaker::Http::FaradayBeakerLogger,
+                              Faraday::Adapter::NetHttp]
+end

metadata

@@ -0,0 +1,223 @@
+--- !ruby/object:Gem::Specification
+name: beaker-http
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Puppet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: markdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: beaker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Puppet testing tool coupled with Beaker
+email:
+- qe@puppet.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- acceptance/tests/puppetserver_requests.rb
+- beaker-http.gemspec
+- lib/beaker-http.rb
+- lib/beaker-http/dsl/web_helpers.rb
+- lib/beaker-http/helpers/puppet_helpers.rb
+- lib/beaker-http/http.rb
+- lib/beaker-http/middleware/response/faraday_beaker_logger.rb
+- lib/beaker-http/version.rb
+- spec/beaker-http/dsl/web_helpers_spec.rb
+- spec/beaker-http/http_spec.rb
+- spec/beaker-http/middleware/response/faraday_beaker_logger_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/puppetlabs/beaker-http
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Puppet testing tool
+test_files:
+- spec/beaker-http/dsl/web_helpers_spec.rb
+- spec/beaker-http/http_spec.rb
+- spec/beaker-http/middleware/response/faraday_beaker_logger_spec.rb
+- spec/spec_helper.rb
+has_rdoc: