lhc 12.3.0 → 13.4.0.pre.pro1766.1

data/spec/error/to_s_spec.rb

@@ -45,17 +45,17 @@ describe LHC::Error do
 
     context 'some mocked response' do
       let(:request) do
-        double('request',
+        double('LHC::Request',
                method: 'GET',
                url: 'http://example.com/sessions',
-               headers: { 'Bearer Token' => "aaaaaaaa-bbbb-cccc-dddd-eeee" },
-               options: { followlocation: true,
-                          auth: { bearer: "aaaaaaaa-bbbb-cccc-dddd-eeee" },
-                          params: { limit: 20 }, url: "http://example.com/sessions" })
+               scrubbed_headers: { 'Bearer Token' => LHC::Scrubber::SCRUB_DISPLAY },
+               scrubbed_options: { followlocation: true,
+                                   auth: { bearer: LHC::Scrubber::SCRUB_DISPLAY },
+                                   params: { limit: 20 }, url: "http://example.com/sessions" })
       end
 
       let(:response) do
-        double('response',
+        double('LHC::Response',
                request: request,
                code: 500,
                options: { return_code: :internal_error, response_headers: "" },
@@ -64,11 +64,16 @@ describe LHC::Error do
 
       subject { LHC::Error.new('The error message', response) }
 
+      before do
+        allow(request).to receive(:is_a?).with(LHC::Request).and_return(true)
+        allow(response).to receive(:is_a?).with(LHC::Response).and_return(true)
+      end
+
       it 'produces correct debug output' do
         expect(subject.to_s.split("\n")).to eq(<<-MSG.strip_heredoc.split("\n"))
           GET http://example.com/sessions
-          Options: {:followlocation=>true, :auth=>{:bearer=>"aaaaaaaa-bbbb-cccc-dddd-eeee"}, :params=>{:limit=>20}, :url=>"http://example.com/sessions"}
-          Headers: {"Bearer Token"=>"aaaaaaaa-bbbb-cccc-dddd-eeee"}
+          Options: {:followlocation=>true, :auth=>{:bearer=>"#{LHC::Scrubber::SCRUB_DISPLAY}"}, :params=>{:limit=>20}, :url=>"http://example.com/sessions"}
+          Headers: {"Bearer Token"=>"#{LHC::Scrubber::SCRUB_DISPLAY}"}
           Response Code: 500 (internal_error)
           Response Options: {:return_code=>:internal_error, :response_headers=>""}
           {"status":500,"message":"undefined"}

data/spec/formats/multipart_spec.rb

@@ -6,14 +6,14 @@ describe LHC do
   include ActionDispatch::TestProcess
 
   context 'multipart' do
-    let(:file) { fixture_file_upload(Tempfile.new, 'image/jpeg') }
+    let(:file) { Rack::Test::UploadedFile.new(Tempfile.new) }
     let(:body) { { size: 2231 }.to_json }
     let(:location) { 'http://local.ch/uploads/image.jpg' }
 
     it 'formats requests to be multipart/form-data' do
       stub_request(:post, 'http://local.ch/') do |request|
         raise 'Content-Type header wrong' unless request.headers['Content-Type'] == 'multipart/form-data'
-        raise 'Body wrongly formatted' unless request.body.match(/file=%23%3CActionDispatch%3A%3AHttp%3A%3AUploadedFile%3A.*%3E&type=Image/)
+        raise 'Body wrongly formatted' unless request.body.match?(/file=%23%3CActionDispatch%3A%3AHttp%3A%3AUploadedFile%3A.*%3E&type=Image/)
       end.to_return(status: 200, body: body, headers: { 'Location' => location })
       response = LHC.multipart.post(
         'http://local.ch',

data/spec/formats/plain_spec.rb

@@ -6,7 +6,7 @@ describe LHC do
   include ActionDispatch::TestProcess
 
   context 'plain' do
-    let(:file) { fixture_file_upload(Tempfile.new, 'image/jpeg') }
+    let(:file) { Rack::Test::UploadedFile.new(Tempfile.new) }
 
     it 'leaves plains requests unformatted' do
       stub_request(:post, 'http://local.ch/')

data/spec/interceptors/after_response_spec.rb

@@ -14,7 +14,7 @@ describe LHC do
           uri = URI.parse(response.request.url)
           path = [
             'web',
-            Rails.application.class.parent_name,
+            ((ActiveSupport.gem_version >= Gem::Version.new('6.0.0')) ? Rails.application.class.module_parent_name : Rails.application.class.parent_name).underscore,
             Rails.env,
             response.request.method,
             uri.scheme,

data/spec/interceptors/caching/main_spec.rb

@@ -47,7 +47,7 @@ describe LHC::Caching do
 
   it 'lets you configure the cache key that will be used' do
     LHC.config.endpoint(:local, 'http://local.ch', cache: { key: 'STATICKEY' })
-    expect(Rails.cache).to receive(:fetch).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY").and_call_original
+    expect(Rails.cache).to receive(:fetch).at_least(:once).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY").and_call_original
     expect(Rails.cache).to receive(:write).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY", anything, anything).and_call_original
     stub
     LHC.get(:local)
@@ -66,8 +66,8 @@ describe LHC::Caching do
     stub
     LHC.config.endpoint(:local, 'http://local.ch', cache: true)
     original_response = LHC.get(:local)
-    cached_response = LHC.get(:local)
     expect(original_response.from_cache?).to eq false
+    cached_response = LHC.get(:local)
     expect(cached_response.from_cache?).to eq true
   end
 end

data/spec/interceptors/caching/multilevel_cache_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Caching do
+  let(:redis_url) { 'redis://localhost:6379/0' }
+  let(:redis_cache) do
+    spy('ActiveSupport::Cache::RedisCacheStore')
+  end
+
+  before do
+    Rails.cache.clear
+    LHC.config.interceptors = [LHC::Caching]
+    ActiveSupport::Cache::RedisCacheStore.new(url: redis_url).clear
+    allow(ActiveSupport::Cache::RedisCacheStore).to receive(:new).and_return(redis_cache)
+    allow(redis_cache).to receive(:present?).and_return(true)
+  end
+
+  let!(:request_stub) do
+    stub_request(:get, "http://local.ch/")
+      .to_return(body: '<h1>Hi there</h1>')
+  end
+
+  def request
+    LHC.get('http://local.ch', cache: true)
+  end
+
+  def response_has_been_cached_and_served_from_cache!
+    original_response = request
+    cached_response = request
+
+    expect(original_response.body).to eq cached_response.body
+    expect(original_response.code).to eq cached_response.code
+    expect(original_response.headers).to eq cached_response.headers
+    expect(original_response.options[:return_code]).to eq cached_response.options[:return_code]
+    expect(original_response.mock).to eq cached_response.mock
+
+    assert_requested request_stub, times: 1
+  end
+
+  context 'only local cache has been configured' do
+    before do
+      LHC::Caching.cache = Rails.cache
+    end
+
+    it 'serves a response from local cache without trying the central cache' do
+      expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
+      expect(Rails.cache).to receive(:write).and_call_original
+      expect(-> { response_has_been_cached_and_served_from_cache! })
+        .to output(%Q{[LHC] served from local cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+    end
+  end
+
+  context 'local and central cache have been configured' do
+    before do
+      LHC::Caching.cache = Rails.cache
+      LHC::Caching.central = {
+        read: redis_url,
+        write: redis_url
+      }
+    end
+
+    context 'found in central cache' do
+      it 'serves it from central cache if found there' do
+        expect(redis_cache).to receive(:fetch).and_return(nil,
+                                                          body: '<h1>Hi there</h1>', code: 200, headers: nil, return_code: nil, mock: :webmock)
+        expect(redis_cache).to receive(:write).and_return(true)
+        expect(Rails.cache).to receive(:fetch).and_call_original
+        expect(Rails.cache).to receive(:write).and_call_original
+        expect(-> { response_has_been_cached_and_served_from_cache! })
+          .to output(%Q{[LHC] served from central cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+      end
+    end
+
+    context 'not found in central cache' do
+      it 'serves it from local cache if found there' do
+        expect(redis_cache).to receive(:fetch).and_return(nil, nil)
+        expect(redis_cache).to receive(:write).and_return(true)
+        expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
+        expect(Rails.cache).to receive(:write).and_call_original
+        expect(-> { response_has_been_cached_and_served_from_cache! })
+          .to output(%Q{[LHC] served from local cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+      end
+    end
+  end
+
+  context 'only central read configured' do
+    before do
+      LHC::Caching.cache = Rails.cache
+      LHC::Caching.central = {
+        read: redis_url
+      }
+    end
+
+    it 'still serves responses from cache, but does not write them back' do
+      expect(redis_cache).to receive(:fetch).and_return(nil, body: '<h1>Hi there</h1>', code: 200, headers: nil, return_code: nil, mock: :webmock)
+      expect(redis_cache).not_to receive(:write)
+      expect(Rails.cache).to receive(:fetch).and_call_original
+      expect(Rails.cache).to receive(:write).and_call_original
+      expect(-> { response_has_been_cached_and_served_from_cache! })
+        .to output(%Q{[LHC] served from central cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+    end
+  end
+
+  context 'only central write configured' do
+    before do
+      LHC::Caching.cache = Rails.cache
+      LHC::Caching.central = {
+        write: redis_url
+      }
+    end
+
+    it 'still writes responses to cache, but does not retrieve them from there' do
+      expect(redis_cache).not_to receive(:fetch)
+      expect(redis_cache).to receive(:write).and_return(true)
+      expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
+      expect(Rails.cache).to receive(:write).and_call_original
+      expect(-> { response_has_been_cached_and_served_from_cache! })
+        .to output(%Q{[LHC] served from local cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+    end
+  end
+
+  context 'central cache configured only' do
+    before do
+      LHC::Caching.cache = nil
+      LHC::Caching.central = {
+        read: redis_url,
+        write: redis_url
+      }
+    end
+
+    it 'does not inquire the local cache for information neither to write them' do
+      expect(redis_cache).to receive(:fetch).and_return(nil, body: '<h1>Hi there</h1>', code: 200, headers: nil, return_code: nil, mock: :webmock)
+      expect(redis_cache).to receive(:write).and_return(true)
+      expect(-> { response_has_been_cached_and_served_from_cache! })
+        .to output(%Q{[LHC] served from central cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+    end
+  end
+end

data/spec/interceptors/caching/options_spec.rb

@@ -20,17 +20,6 @@ describe LHC::Caching do
     default_cache.clear
   end
 
-  it 'maps deprecated cache options' do
-    expected_options = { expires_in: 5.minutes, race_condition_ttl: 15.seconds }
-    expected_key = "LHC_CACHE(v1): key"
-    expect(default_cache).to receive(:write).with(expected_key, anything, expected_options)
-    expect(lambda {
-      LHC.get('http://local.ch', cache: true, cache_expires_in: 5.minutes, cache_key: 'key', cache_race_condition_ttl: 15.seconds)
-    }).to output(
-      /Cache options have changed! cache_expires_in, cache_key, cache_race_condition_ttl are deprecated and will be removed in future versions./
-    ).to_stderr
-  end
-
   it 'does cache' do
     expect(default_cache).to receive(:fetch)
     expect(default_cache).to receive(:write)

data/spec/interceptors/define_spec.rb

@@ -7,6 +7,7 @@ describe LHC do
     before(:each) do
       class SomeInterceptor < LHC::Interceptor
       end
+
       class AnotherInterceptor < LHC::Interceptor
       end
     end

data/spec/interceptors/logging/main_spec.rb

@@ -8,7 +8,7 @@ describe LHC::Logging do
   before(:each) do
     LHC.config.interceptors = [LHC::Logging]
     LHC::Logging.logger = logger
-    stub_request(:get, 'http://local.ch').to_return(status: 200)
+    stub_request(:get, /http:\/\/local.ch.*/).to_return(status: 200)
   end
 
   it 'does log information before and after every request made with LHC' do
@@ -34,4 +34,24 @@ describe LHC::Logging do
       )
     end
   end
+
+  context 'sensitive data' do
+    before :each do
+      LHC.config.scrubs[:params] << 'api_key'
+      LHC.config.scrubs[:headers] << 'private_key'
+      LHC.get('http://local.ch', params: { api_key: '123-abc' }, headers: { private_key: 'abc-123' })
+    end
+
+    it 'does log not log sensitive params information before every request made with LHC' do
+      expect(logger).to have_received(:info).once.with(
+        a_string_including("Params={:api_key=>\"#{LHC::Scrubber::SCRUB_DISPLAY}\"}")
+      )
+    end
+
+    it 'does log not log sensitive headers information before every request made with LHC' do
+      expect(logger).to have_received(:info).once.with(
+        a_string_including(":private_key=>\"#{LHC::Scrubber::SCRUB_DISPLAY}\"")
+      )
+    end
+  end
 end

data/spec/interceptors/monitoring/caching_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Monitoring do
+  let(:stub) do
+    stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website')
+  end
+
+  module Statsd
+    def self.count(_path, _value); end
+
+    def self.timing(_path, _value); end
+  end
+
+  before(:each) do
+    LHC::Monitoring.statsd = Statsd
+    Rails.cache.clear
+    allow(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+    allow(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+    allow(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+    allow(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.200', 1)
+  end
+
+  context 'interceptors configured correctly' do
+    before do
+      LHC.config.interceptors = [LHC::Caching, LHC::Monitoring]
+    end
+
+    context 'requesting with cache option' do
+      it 'monitors miss/hit for caching' do
+        stub
+        expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.cache.miss', 1)
+        expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.cache.hit', 1)
+        LHC.get('http://local.ch', cache: true)
+        LHC.get('http://local.ch', cache: true)
+      end
+    end
+
+    context 'request uncached' do
+      it 'requesting without cache option' do
+        stub
+        expect(Statsd).not_to receive(:count).with('lhc.dummy.test.local_ch.get.cache.miss', 1)
+        expect(Statsd).not_to receive(:count).with('lhc.dummy.test.local_ch.get.cache.hit', 1)
+        LHC.get('http://local.ch')
+        LHC.get('http://local.ch')
+      end
+    end
+  end
+
+  context 'wrong interceptor order' do
+    before(:each) do
+      LHC.config.interceptors = [LHC::Monitoring, LHC::Caching] # monitoring needs to be after Caching
+    end
+
+    it 'does monitors miss/hit for caching and warns about wrong order of interceptors' do
+      stub
+      expect(Statsd).not_to receive(:count).with('lhc.dummy.test.local_ch.get.cache.miss', 1)
+      expect(Statsd).not_to receive(:count).with('lhc.dummy.test.local_ch.get.cache.hit', 1)
+      expect(-> {
+        LHC.get('http://local.ch', cache: true)
+        LHC.get('http://local.ch', cache: true)
+      }).to output("[WARNING] Your interceptors must include LHC::Caching and LHC::Monitoring and also in that order.\n[WARNING] Your interceptors must include LHC::Caching and LHC::Monitoring and also in that order.\n").to_stderr
+    end
+  end
+end

data/spec/interceptors/response_competition_spec.rb

@@ -12,7 +12,7 @@ describe LHC do
 
         def before_request
           if @@cached
-            return LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from local cache'), nil)
+            return LHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from local cache'), nil)
           end
         end
       end
@@ -22,7 +22,7 @@ describe LHC do
 
         def before_request
           if request.response.nil?
-            return LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from remote cache'), nil)
+            return LHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from remote cache'), nil)
           end
         end
       end

data/spec/interceptors/return_response_spec.rb

@@ -8,7 +8,7 @@ describe LHC do
       class CacheInterceptor < LHC::Interceptor
 
         def before_request
-          LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from cache'), nil)
+          LHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from cache'), nil)
         end
       end
       LHC.configure { |c| c.interceptors = [CacheInterceptor] }
@@ -23,7 +23,7 @@ describe LHC do
       before(:each) do
         class AnotherInterceptor < LHC::Interceptor
           def before_request
-            LHC::Response.new(Typhoeus::Response.new({}), nil)
+            LHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok), nil)
           end
         end
       end

data/spec/interceptors/rollbar/main_spec.rb

@@ -36,22 +36,34 @@ describe LHC::Rollbar do
         )
     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'
-            )
+    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
+
+    it 'scrubs sensitive data' do
+      LHC.config.scrubs[:params] << 'api_key'
+      LHC.config.scrubs[:headers] << 'private_key'
+      stub_request(:get, 'http://local.ch?api_key=123-abc').to_return(status: 400)
+      expect(-> { LHC.get('http://local.ch', params: { api_key: '123-abc' }, headers: { private_key: 'abc-123' }) })
+        .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: hash_including(private_key: LHC::Scrubber::SCRUB_DISPLAY), params: { api_key: LHC::Scrubber::SCRUB_DISPLAY })
+        )
     end
   end
 end