lhc 12.0.0

data/spec/interceptors/response_competition_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'interceptor response competition' do
+    before(:each) do
+      # rubocop:disable Style/ClassVars
+      class LocalCacheInterceptor < LHC::Interceptor
+        @@cached = false
+        cattr_accessor :cached
+
+        def before_request
+          if @@cached
+            return LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from local cache'), nil)
+          end
+        end
+      end
+      # rubocop:enable Style/ClassVars
+
+      class RemoteCacheInterceptor < LHC::Interceptor
+
+        def before_request
+          if request.response.nil?
+            return LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from remote cache'), nil)
+          end
+        end
+      end
+
+      LHC.configure { |c| c.interceptors = [LocalCacheInterceptor, RemoteCacheInterceptor] }
+    end
+
+    it 'can handle multiple interceptors that compete for returning the response' do
+      response = LHC.get('http://local.ch')
+      expect(response.body).to eq 'Im served from remote cache'
+      LocalCacheInterceptor.cached = true
+      response = LHC.get('http://local.ch')
+      expect(response.body).to eq 'Im served from local cache'
+    end
+  end
+end

data/spec/interceptors/retry/main_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Rollbar do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Retry]
+  end
+
+  let(:status) { 500 }
+
+  let(:request_stub) do
+    @retry_count = 0
+    stub_request(:get, 'http://local.ch').to_return do |_|
+      if @retry_count == max_retry_count
+        { status: 200 }
+      else
+        @retry_count += 1
+        { status: status }
+      end
+    end
+  end
+
+  let(:max_retry_count) { 3 }
+
+  it 'retries a request up to 3 times (default)' do
+    request_stub
+    response = LHC.get('http://local.ch', retry: true)
+    expect(response.success?).to eq true
+    expect(response.code).to eq 200
+    expect(request_stub).to have_been_requested.times(4)
+  end
+
+  context 'retry only once' do
+    let(:retry_options) { { max: 1 } }
+    let(:max_retry_count) { 1 }
+
+    it 'retries only once' do
+      request_stub
+      response = LHC.get('http://local.ch', retry: { max: 1 })
+      expect(response.success?).to eq true
+      expect(response.code).to eq 200
+      expect(request_stub).to have_been_requested.times(2)
+    end
+  end
+
+  context 'retry all' do
+    let(:max_retry_count) { 2 }
+
+    before do
+      expect(LHC::Retry).to receive(:max).at_least(:once).and_return(2)
+      expect(LHC::Retry).to receive(:all).at_least(:once).and_return(true)
+    end
+
+    it 'retries if configured globally' do
+      request_stub
+      response = LHC.get('http://local.ch')
+      expect(response.success?).to eq true
+      expect(response.code).to eq 200
+      expect(request_stub).to have_been_requested.times(3)
+    end
+  end
+
+  context 'ignore error' do
+    let(:status) { 404 }
+
+    it 'does not retry if the error is explicitly ignored' do
+      request_stub
+      LHC.get('http://local.ch', retry: { max: 1 }, ignore: [LHC::NotFound])
+      expect(request_stub).to have_been_requested.times(1)
+    end
+  end
+end

data/spec/interceptors/return_response_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'interceptor' do
+    before(:each) do
+      class CacheInterceptor < LHC::Interceptor
+
+        def before_request
+          LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from cache'), nil)
+        end
+      end
+      LHC.configure { |c| c.interceptors = [CacheInterceptor] }
+    end
+
+    it 'can return a response rather then doing a real request' do
+      response = LHC.get('http://local.ch')
+      expect(response.body).to eq 'Im served from cache'
+    end
+
+    context 'misusage' do
+      before(:each) do
+        class AnotherInterceptor < LHC::Interceptor
+          def before_request
+            LHC::Response.new(Typhoeus::Response.new({}), nil)
+          end
+        end
+      end
+
+      it 'raises an exception when two interceptors try to return a response' do
+        expect(lambda {
+          LHC.get('http://local.ch', interceptors: [CacheInterceptor, AnotherInterceptor])
+        }).to raise_error 'Response already set from another interceptor'
+      end
+    end
+  end
+end

data/spec/interceptors/rollbar/invalid_encoding_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Rollbar do
+  context 'invalid encoding in rollbar payload' do
+    before(:each) do
+      LHC.config.interceptors = [LHC::Rollbar]
+      stub_request(:get, 'http://local.ch').to_return(status: 400)
+
+      allow(described_class).to receive(:fix_invalid_encoding).and_call_original
+      # a stub that will throw a error on first call and suceed on subsequent calls
+      call_counter = 0
+      class Rollbar; end
+      ::Rollbar.stub(:warning) do
+        call_counter += 1
+        raise Encoding::UndefinedConversionError if call_counter == 1
+      end
+
+      # the response for the caller is still LHC::BadRequest
+      expect(-> { LHC.get('http://local.ch', rollbar: { additional: invalid }) }).to raise_error LHC::BadRequest
+    end
+
+    let(:invalid) { (+"in\xc3lid").force_encoding('ASCII-8BIT') }
+    let(:valid) { described_class.fix_invalid_encoding(invalid) }
+
+    it 'calls fix_invalid_encoding incase a Encoding::UndefinedConversionError was encountered' do
+      expect(described_class).to have_received(:fix_invalid_encoding).with(invalid)
+    end
+
+    it 'calls Rollbar.warn with the fixed data' do
+      expect(::Rollbar).to have_received(:warning)
+        .with(
+          'Status: 400 URL: http://local.ch',
+          hash_including(
+            response: anything,
+            request: anything,
+            additional: valid
+          )
+        )
+    end
+  end
+end

data/spec/interceptors/rollbar/main_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Rollbar do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Rollbar]
+  end
+
+  context 'Rollbar is undefined' do
+    before(:each) do
+      Object.send(:remove_const, 'Rollbar') if Object.const_defined?('Rollbar')
+    end
+    it 'does not report' do
+      stub_request(:get, 'http://local.ch').to_return(status: 400)
+      expect(-> { LHC.get('http://local.ch') })
+        .to raise_error LHC::BadRequest
+    end
+  end
+
+  context 'Rollbar is defined' do
+    before(:each) do
+      class Rollbar; end
+      ::Rollbar.stub(:warning)
+    end
+
+    it 'does report errors to rollbar' do
+      stub_request(:get, 'http://local.ch').to_return(status: 400)
+      expect(-> { LHC.get('http://local.ch') })
+        .to raise_error LHC::BadRequest
+      expect(::Rollbar).to have_received(:warning)
+        .with(
+          'Status: 400 URL: http://local.ch',
+          response: hash_including(body: anything, code: anything, headers: anything, time: anything, timeout?: anything),
+          request: hash_including(url: anything, method: anything, headers: anything, params: anything)
+        )
+    end
+
+    context 'additional params' do
+      it 'does report errors to rollbar with additional data' do
+        stub_request(:get, 'http://local.ch')
+          .to_return(status: 400)
+        expect(-> { LHC.get('http://local.ch', rollbar: { additional: 'data' }) })
+          .to raise_error LHC::BadRequest
+        expect(::Rollbar).to have_received(:warning)
+          .with(
+            'Status: 400 URL: http://local.ch',
+            hash_including(
+              response: anything,
+              request: anything,
+              additional: 'data'
+            )
+          )
+      end
+    end
+  end
+end

data/spec/interceptors/throttle/main_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Throttle do
+  let(:provider) { 'local.ch' }
+  let(:limit) { 10000 }
+  let(:remaining) { 1900 }
+  let(:options) do
+    {
+      throttle: {
+        provider: provider,
+        track: true,
+        limit: limit_options,
+        remaining: { header: 'Rate-Limit-Remaining' },
+        expires: { header: 'Rate-Limit-Reset' },
+        break: break_option
+      }
+    }
+  end
+  let(:limit_options) { { header: 'Rate-Limit-Limit' } }
+  let(:break_option) { false }
+  let(:expires_in) { (Time.zone.now + 1.hour).to_i }
+
+  before(:each) do
+    LHC::Throttle.track = nil
+    LHC.config.interceptors = [LHC::Throttle]
+
+    stub_request(:get, 'http://local.ch')
+      .to_return(
+        headers: {
+          'Rate-Limit-Limit' => limit,
+          'Rate-Limit-Remaining' => remaining,
+          'Rate-Limit-Reset' => expires_in
+        }
+      )
+  end
+
+  it 'tracks the request limits based on response data' do
+    LHC.get('http://local.ch', options)
+    expect(LHC::Throttle.track[provider][:limit]).to eq limit
+    expect(LHC::Throttle.track[provider][:remaining]).to eq remaining
+  end
+
+  context 'fix predefined integer for limit' do
+    let(:limit_options) { 1000 }
+
+    it 'tracks the limit based on initialy provided data' do
+      LHC.get('http://local.ch', options)
+      expect(LHC::Throttle.track[provider][:limit]).to eq limit_options
+    end
+  end
+
+  context 'breaks' do
+    let(:break_option) { '80%' }
+
+    it 'hit the breaks if throttling quota is reached' do
+      LHC.get('http://local.ch', options)
+      expect(-> {
+        LHC.get('http://local.ch', options)
+      }).to raise_error(LHC::Throttle::OutOfQuota, 'Reached predefined quota for local.ch')
+    end
+
+    context 'still within quota' do
+      let(:break_option) { '90%' }
+
+      it 'does not hit the breaks' do
+        LHC.get('http://local.ch', options)
+        LHC.get('http://local.ch', options)
+      end
+    end
+  end
+
+  context 'no response headers' do
+    before do
+      stub_request(:get, 'http://local.ch')
+        .to_return(status: 200)
+    end
+
+    it 'does not raise an exception' do
+      LHC.get('http://local.ch', options)
+    end
+
+    context 'no remaining tracked, but break enabled' do
+      let(:break_option) { '90%' }
+
+      it 'does not fail if a remaining was not tracked yet' do
+        LHC.get('http://local.ch', options)
+        LHC.get('http://local.ch', options)
+      end
+    end
+  end
+
+  context 'expires' do
+    let(:break_option) { '80%' }
+
+    it 'attempts another request if the quota expired' do
+      LHC.get('http://local.ch', options)
+      expect(-> {
+        LHC.get('http://local.ch', options)
+      }).to raise_error(LHC::Throttle::OutOfQuota, 'Reached predefined quota for local.ch')
+      Timecop.travel(Time.zone.now + 2.hours)
+      LHC.get('http://local.ch', options)
+    end
+  end
+end

data/spec/interceptors/throttle/reset_track_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Throttle do
+  let(:provider) { 'local.ch' }
+  let(:limit) { 10000 }
+  let(:remaining) { 1900 }
+  let(:options) do
+    {
+      throttle: {
+        provider: provider,
+        track: true,
+        limit: limit_options,
+        remaining: { header: 'Rate-Limit-Remaining' },
+        expires: { header: 'Rate-Limit-Reset' },
+        break: '80%'
+      }
+    }
+  end
+  let(:limit_options) { { header: 'Rate-Limit-Limit' } }
+  let(:break_option) { false }
+  let(:expires_in) { (Time.zone.now + 1.hour).to_i }
+
+  before(:each) do
+    LHC::Throttle.track = nil
+    LHC.config.interceptors = [LHC::Throttle]
+
+    stub_request(:get, 'http://local.ch')
+      .to_return(
+        headers: {
+          'Rate-Limit-Limit' => limit,
+          'Rate-Limit-Remaining' => remaining,
+          'Rate-Limit-Reset' => expires_in
+        }
+      )
+  end
+
+  # If LHC::Trottle.track would be kept accross multiple tests,
+  # at least 2/3 of the following would fail
+
+  it 'resets track accross multiple tests 1/3' do
+    LHC.get('http://local.ch', options)
+  end
+
+  it 'resets track accross multiple tests 2/3' do
+    LHC.get('http://local.ch', options)
+  end
+
+  it 'resets track accross multiple tests 3/3' do
+    LHC.get('http://local.ch', options)
+  end
+end

data/spec/interceptors/zipkin/distributed_tracing_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Zipkin do
+  before(:each) do
+    LHC.config.interceptors = [described_class]
+    LHC.config.endpoint(:local, 'http://local.ch')
+    stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website')
+  end
+
+  context 'with zipkin tracer integration' do
+    before(:all) do
+      ::ZipkinTracer::TraceContainer.setup_mock(
+        trace_id: 'trace_id',
+        parent_id: 'parent_id',
+        span_id: 'span_id',
+        sampled: true,
+        flags: 'flags'
+      )
+    end
+
+    it 'adds the proper X-B3 headers and trace the request' do
+      expect(::ZipkinTracer::TraceContainer).to receive(:with_trace_id).and_call_original
+      headers = LHC.get(:local).request.headers
+      expect(headers['X-B3-TraceId']).to eq('trace_id')
+      expect(headers['X-B3-ParentSpanId']).to eq('parent_id')
+      expect(headers['X-B3-SpanId']).to eq('span_id')
+      expect(headers['X-B3-Sampled']).to eq('true')
+      expect(headers['X-B3-Flags']).to eq('flags')
+    end
+  end
+
+  describe 'creating new spans' do
+    context 'sampled? is false' do
+      before(:all) do
+        ::ZipkinTracer::TraceContainer.setup_mock(
+          trace_id: 'trace_id',
+          parent_id: 'parent_id',
+          span_id: 'span_id',
+          sampled: false,
+          flags: 'flags'
+        )
+      end
+
+      it 'adds the proper X-B3 headers' do
+        headers = LHC.get(:local).request.headers
+        expect(headers['X-B3-TraceId']).to eq('trace_id')
+        expect(headers['X-B3-ParentSpanId']).to eq('parent_id')
+        expect(headers['X-B3-SpanId']).to eq('span_id')
+        expect(headers['X-B3-Sampled']).to eq('false')
+        expect(headers['X-B3-Flags']).to eq('flags')
+      end
+
+      it 'does not register a new span' do
+        # ensure no span was registered, by checking no call on span
+        expect_any_instance_of(described_class).not_to receive(:span).and_call_original
+        LHC.get(:local)
+      end
+    end
+
+    context 'sampled? is true' do
+      before(:all) do
+        ::ZipkinTracer::TraceContainer.setup_mock(
+          trace_id: 'trace_id',
+          parent_id: 'parent_id',
+          span_id: 'span_id',
+          sampled: true,
+          flags: 'flags'
+        )
+      end
+
+      it 'adds the proper X-B3 headers' do
+        headers = LHC.get(:local).request.headers
+        expect(headers['X-B3-TraceId']).to eq('trace_id')
+        expect(headers['X-B3-ParentSpanId']).to eq('parent_id')
+        expect(headers['X-B3-SpanId']).to eq('span_id')
+        expect(headers['X-B3-Sampled']).to eq('true')
+        expect(headers['X-B3-Flags']).to eq('flags')
+      end
+
+      it 'does register a new span' do
+        # ensure a span was registered, by checking call on span
+        expect_any_instance_of(described_class).to receive(:span).at_least(:once).and_call_original
+        LHC.get(:local)
+      end
+    end
+  end
+
+  %w(ZipkinTracer Trace).each do |klass|
+    context "without #{klass}" do
+      before(:all) do
+        TemporaryClass = Object.send(:const_get, klass)
+        Object.send(:remove_const, klass)
+      end
+
+      after(:all) do
+        Object.send(:const_set, klass, TemporaryClass)
+      end
+
+      it 'does not trace the request' do
+        headers = nil
+        expect { headers = LHC.get(:local).request.headers }.not_to raise_error
+        expect(headers['X-B3-TraceId']).to be_nil
+        expect(headers['X-B3-ParentSpanId']).to be_nil
+        expect(headers['X-B3-SpanId']).to be_nil
+        expect(headers['X-B3-Sampled']).to be_nil
+        expect(headers['X-B3-Flags']).to be_nil
+      end
+    end
+  end
+
+  %w(Annotation BinaryAnnotation Endpoint).each do |klass|
+    context "without Trace::#{klass}" do
+      before(:all) do
+        TemporaryClass = Trace.send(:const_get, klass)
+        Trace.send(:remove_const, klass)
+      end
+
+      after(:all) do
+        Trace.send(:const_set, klass, TemporaryClass)
+      end
+
+      it 'does not trace the request' do
+        headers = nil
+        expect { headers = LHC.get(:local).request.headers }.not_to raise_error
+        expect(headers['X-B3-TraceId']).to be_nil
+        expect(headers['X-B3-ParentSpanId']).to be_nil
+        expect(headers['X-B3-SpanId']).to be_nil
+        expect(headers['X-B3-Sampled']).to be_nil
+        expect(headers['X-B3-Flags']).to be_nil
+      end
+    end
+  end
+end