bwapi 9.0.0.pre.349 → 9.0.0.pre.364

data/lib/bwapi/default.rb

@@ -0,0 +1,91 @@
+require 'bwapi/version'
+require 'bwapi/configuration'
+
+require 'allotment'
+require 'faraday'
+
+module BWAPI
+  # Default module
+  module Default
+    ADAPTER      = Faraday.default_adapter
+
+    API_ENDPOINT = 'https://newapi.brandwatch.com/'
+
+    CLIENT_ID    = 'brandwatch-api-client'
+
+    USER_AGENT   = "BWAPI Ruby Gem #{BWAPI::VERSION}".freeze
+
+    class << self
+      def options
+        Hash[BWAPI::Configuration.keys.map { |key| [key, send(key)] }]
+      end
+
+      def access_token
+        ENV['BWAPI_ACCESS_TOKEN']
+      end
+
+      def adapter
+        ENV['BWAPI_ADAPTER'] || ADAPTER
+      end
+
+      def api_endpoint
+        ENV['BWAPI_API_ENDPOINT'] || API_ENDPOINT
+      end
+
+      def client_id
+        ENV['BWAPI_CLIENT_ID'] || CLIENT_ID
+      end
+
+      def client_secret
+        ENV['BWAPI_CLIENT_SECRET']
+      end
+
+      def connection_options
+        {
+          headers: {
+            user_agent: user_agent
+          },
+          request: {
+            params_encoder: Faraday::FlatParamsEncoder
+          }
+        }
+      end
+
+      def debug
+        false
+      end
+
+      def grant_type
+        ENV['BWAPI_GRANT_TYPE']
+      end
+
+      def logger
+        nil
+      end
+
+      def password
+        ENV['BWAPI_PASSWORD']
+      end
+
+      def performance
+        Allotment.results
+      end
+
+      def refresh_token
+        ENV['BWAPI_REFRESH_TOKEN']
+      end
+
+      def user_agent
+        ENV['BWAPI_USER_AGENT'] || USER_AGENT
+      end
+
+      def username
+        ENV['BWAPI_USERNAME']
+      end
+
+      def verify_ssl
+        ENV['BWAPI_VERIFY_SSL']
+      end
+    end
+  end
+end

data/lib/bwapi/error.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module BWAPI
   # BW error class to capture BWAPI error responses
   class BWError < StandardError
@@ -91,7 +89,7 @@ module BWAPI
   # Raised when Brandwatch returns a 422 HTTP status code
   class UnprocessableEntity < BWError; end
 
-   # Raised when Brandwatch returns a 429 HTTP status code
+  # Raised when Brandwatch returns a 429 HTTP status code
   class TooManyRequests < BWError; end
 
   # Raised when Brandwatch returns a 500 HTTP status code

data/lib/bwapi/performance.rb

@@ -0,0 +1,39 @@
+require 'allotment'
+require 'hashie'
+
+module BWAPI
+  # Helper methods for performance
+  module Performance
+    def average_response_time
+      averages = []
+      performance.each_key { |key| averages << Allotment.results[key].average }
+      averages.average
+    end
+
+    def average_response_time_breakdown
+      results = []
+      performance.each do |key, value|
+        results << Hashie::Mash.new(path: key, average: Allotment.results[key].average, count: value.size)
+      end
+      results
+    end
+
+    def fastest_response
+      average_response_time_breakdown.sort_by { |result| result[:average] }.first
+    end
+
+    def response_paths
+      performance.keys
+    end
+
+    def slowest_response
+      average_response_time_breakdown.sort_by { |result| result[:average] }.reverse.first
+    end
+
+    def total_responses
+      responses = 0
+      performance.each_value { |value| responses += value.size }
+      responses
+    end
+  end
+end

data/lib/bwapi/request.rb

@@ -1,10 +1,10 @@
-# encoding: utf-8
-
 require 'faraday'
 
 module BWAPI
-  # Request module to handle all requests to API
+  # Client class to create BWAPI instances
   module Request
+    RACK_BUILDER_CLASS = defined?(Faraday::RackBuilder) ? Faraday::RackBuilder : Faraday::Builder
+
     # Perform a get request
     #
     # @param path [String] URL path to send request
@@ -52,33 +52,16 @@ module BWAPI
 
     private
 
-    # Sets connection options
-    def connection_options
-      {
-        headers: {
-          authorization: access_token ? "bearer #{access_token}" : '',
-          user_agent: user_agent
-        },
-        request: {
-          params_encoder: Faraday::FlatParamsEncoder
-        },
-        url: api_endpoint,
-        ssl: { verify: verify_ssl }
-      }
-    end
-
     # Perform a request
     #
-    # @param method [String] Type of request path
+    # @param method [String] Type of request
     # @param path [String] URL path to send request
     # @param opts [Hash] Request parameters
     # @return [Hashie::Mash] Response
     def request(method, path, opts = {})
-      response = connection(connection_options).send(method) do |r|
+      response = connection.send(method) do |r|
         case method
-        when :get
-          r.url path, opts
-        when :delete
+        when :get, :delete
           r.url path, opts
         when :patch, :post, :put
           if opts.is_a?(Hash) && opts.key?(:force_urlencoded)
@@ -90,16 +73,6 @@ module BWAPI
           end
         end
       end
-
-      if debug
-        log.info "Connection options: #{connection_options}"
-        log.info "Sending request type: #{method}"
-        log.info "Request path: #{path}"
-        log.info "Request url: #{api_endpoint}/#{path}"
-        log.info "Request parameters: #{opts.to_json}" unless opts.nil?
-        log.info "Response body: #{response.env[:body].to_json}" unless response.env[:body].nil?
-      end
-
       response
     end
   end

data/lib/bwapi/response/error.rb

@@ -0,0 +1,28 @@
+require 'bwapi/error'
+require 'faraday'
+
+module BWAPI
+  module Response
+    # Brandwatch response middleware to handle errors
+    class Error < Faraday::Response::Middleware
+      ERROR_MAP = {
+        400 => BWAPI::BadRequest,
+        401 => BWAPI::Unauthorized,
+        403 => BWAPI::Forbidden,
+        404 => BWAPI::NotFound,
+        406 => BWAPI::NotAcceptable,
+        422 => BWAPI::UnprocessableEntity,
+        429 => BWAPI::TooManyRequests,
+        500 => BWAPI::InternalServerError,
+        501 => BWAPI::NotImplemented,
+        502 => BWAPI::BadGateway,
+        503 => BWAPI::ServiceUnavailable
+      }
+
+      def on_complete(response)
+        key = response[:status].to_i
+        fail ERROR_MAP[key].new(response) if ERROR_MAP.key? key
+      end
+    end
+  end
+end

data/lib/bwapi/response/logger.rb

@@ -0,0 +1,35 @@
+require 'faraday'
+
+module BWAPI
+  module Response
+    # Brandwatch response middleware to handle logging
+    class Logger < Faraday::Response::Middleware
+      def initialize(app, client)
+        super(app)
+        @client = client
+      end
+
+      def logger
+        @logger = @client.logger || begin
+          require 'logger'
+          ::Logger.new(STDOUT)
+        end
+      end
+
+      def call(env)
+        logger.info('Request') { "#{env.method.upcase} - #{env.url}" }
+        logger.debug('Request headers') { dump_output(env.request_headers) }
+        super
+      end
+
+      def on_complete(env)
+        logger.info('Response Status') { "#{env.status}" }
+        logger.debug('Response headers') { dump_output(env.response_headers) }
+      end
+
+      def dump_output(object)
+        object.map { |key, value| "#{key}: #{value.inspect}" }.join(', ')
+      end
+    end
+  end
+end

data/lib/bwapi/response/performance.rb

@@ -0,0 +1,31 @@
+require 'faraday'
+require 'allotment'
+
+module BWAPI
+  module Response
+    # Brandwatch response middleware to monitor performance
+    class Performance < Faraday::Response::Middleware
+      def initialize(app, client)
+        super(app)
+        @client = client
+      end
+
+      def logger
+        @logger = @client.logger || begin
+          require 'logger'
+          ::Logger.new(STDOUT)
+        end
+      end
+
+      def call(env)
+        @recording = ("#{env.method}#{env.url.path}").gsub!('/', '_')
+        Allotment.start(@recording)
+        super
+      end
+
+      def on_complete(_env)
+        logger.info "Response time: #{Allotment.stop(@recording)} seconds"
+      end
+    end
+  end
+end

data/lib/bwapi/version.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 # BWAPI Version
 module BWAPI
   VERSION = '9.0.0'

data/spec/bwapi/client_spec.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'helper'
 
 describe BWAPI::Client do
@@ -9,7 +7,41 @@ describe BWAPI::Client do
 
   describe 'when called' do
     it 'should be a client class instance' do
-      BWAPI::Client.new.should be_an_instance_of BWAPI::Client
+      expect(BWAPI::Client.new).to be_an_instance_of BWAPI::Client
+    end
+  end
+
+  describe '.authenticated?' do
+    it 'returns true when authenticated' do
+      expect(BWAPI::Client.new.authenticated?).to eql(false)
+    end
+
+    it 'returns false when not authenticated' do
+      bw = BWAPI::Client.new access_token: 'abcdef-ghijkl-123456-789012'
+      expect(bw.authenticated?).to eql(true)
+    end
+  end
+
+  describe '.application_client?' do
+    it 'returns true when client is a brandwatch-application-client' do
+      bw = BWAPI::Client.new client_id: 'brandwatch-application-client'
+      expect(bw.application_client?).to eql(true)
+    end
+
+    it 'returns false when a client is not a brandwatch-application-client' do
+      expect(BWAPI::Client.new.application_client?).to eql(false)
+    end
+  end
+
+  describe '.api_client?' do
+    it 'returns true when client is a brandwatch-api-client' do
+      bw = BWAPI::Client.new client_id: 'brandwatch-api-client'
+      expect(bw.api_client?).to eql(true)
+    end
+
+    it 'returns false when a client is not a brandwatch-api-client' do
+      bw = BWAPI::Client.new client_id: 'brandwatch-application-client'
+      expect(bw.api_client?).to eql(false)
     end
   end
 
@@ -31,8 +63,8 @@ describe BWAPI::Client do
         expect(BWAPI::Client.new.respond_to?(:username)).to eq(true)
       end
 
-      it 'should create a password instance variable' do
-        expect(BWAPI::Client.new.respond_to?(:password)).to eq(true)
+      it 'should create a password instance variable which cannot be accessed' do
+        expect(BWAPI::Client.new.respond_to?(:password)).to eq(false)
       end
 
       it 'should create a grant_type instance variable' do
@@ -47,24 +79,16 @@ describe BWAPI::Client do
         expect(BWAPI::Client.new.respond_to?(:refresh_token)).to eq(true)
       end
 
-      it 'should create a expires_in instance variable' do
-        expect(BWAPI::Client.new.respond_to?(:expires_in)).to eq(true)
-      end
-
       it 'should create a client_id instance variable' do
         expect(BWAPI::Client.new.respond_to?(:client_id)).to eq(true)
       end
 
-      it 'should create a client_secret instance variable' do
-        expect(BWAPI::Client.new.respond_to?(:client_secret)).to eq(true)
-      end
-
-      it 'should create a netrc instance variable' do
-        expect(BWAPI::Client.new.respond_to?(:netrc)).to eq(true)
+      it 'should create a client_secret instance variable which cannot accessed' do
+        expect(BWAPI::Client.new.respond_to?(:client_secret)).to eq(false)
       end
 
-      it 'should create a netrc_file instance variable' do
-        expect(BWAPI::Client.new.respond_to?(:netrc_file)).to eq(true)
+      it 'should create a logger instance variable' do
+        expect(BWAPI::Client.new.respond_to?(:logger)).to eq(true)
       end
     end
 
@@ -113,28 +137,6 @@ describe BWAPI::Client do
         end
       end
 
-      describe 'netrc' do
-        it 'should have a default netrc value' do
-          expect(BWAPI::Client.new.netrc).to eql(false)
-        end
-
-        it 'should allow a user to set true for the netrc value' do
-          bw = BWAPI::Client.new netrc: true, netrc_file: File.join(fixture_path, '.netrc')
-          expect(bw.netrc).to eql(true)
-        end
-      end
-
-      describe 'netrc_file' do
-        it 'should have a default netrc value' do
-          expect(BWAPI::Client.new.netrc_file).to eql("#{ENV['HOME'] + '/' + '.netrc'}")
-        end
-
-        it 'should allow a user to set a netrc_file value' do
-          bw = BWAPI::Client.new netrc_file: 'example/.netrc'
-          expect(bw.netrc_file).to eql('example/.netrc')
-        end
-      end
-
       describe 'username' do
         it 'should have a default value of nil for username' do
           expect(BWAPI::Client.new.username).to eql(nil)
@@ -147,13 +149,9 @@ describe BWAPI::Client do
       end
 
       describe 'password' do
-        it 'should have a default value of nil for password' do
-          expect(BWAPI::Client.new.password).to eql(nil)
-        end
-
         it 'should allow a user to set a password value' do
           bw = BWAPI::Client.new password: 'pa55w0rd'
-          expect(bw.password).to eql('pa55w0rd')
+          expect(bw.instance_eval { @password }).to eql('pa55w0rd')
         end
       end
 
@@ -191,13 +189,21 @@ describe BWAPI::Client do
       end
 
       describe 'client_secret' do
-        it 'should have a default value of nil for client_secret' do
-          expect(BWAPI::Client.new.client_secret).to eql(nil)
-        end
-
         it 'should allow a user to set a client_secret value' do
           bw = BWAPI::Client.new client_secret: 'custom_client_secret'
-          expect(bw.client_secret).to eql('custom_client_secret')
+          expect(bw.instance_eval { @client_secret }).to eql('custom_client_secret')
+        end
+      end
+
+      describe 'logger' do
+        it 'should have a default value of nil for logger' do
+          expect(BWAPI::Client.new.logger).to eql(nil)
+        end
+
+        it 'should allow a user to set a logger value' do
+          logger = Object.new
+          bw = BWAPI::Client.new logger: logger
+          expect(bw.logger).to eql(logger)
         end
       end
     end