lhc 12.0.0

data/spec/interceptors/caching/options_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+# due to the fact that options passed into LHC get dup'ed
+# we need a class where we can setup method expectations
+# with `expect_any_instance`
+class CacheMock
+  def fetch(*_); end
+
+  def write(*_); end
+end
+
+describe LHC::Caching do
+  let(:default_cache) { LHC::Caching.cache }
+
+  before(:each) do
+    stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website')
+    LHC.config.interceptors = [LHC::Caching]
+    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)
+    LHC.get('http://local.ch', cache: true)
+  end
+
+  it 'does not cache' do
+    expect(default_cache).not_to receive(:fetch)
+    expect(default_cache).not_to receive(:write)
+    LHC.get('http://local.ch')
+  end
+
+  context 'options - directly via LHC.get' do
+    it 'uses the default cache' do
+      expect(default_cache).to receive(:fetch)
+      expect(default_cache).to receive(:write)
+      LHC.get('http://local.ch', cache: true)
+    end
+
+    it 'uses the provided cache' do
+      expect_any_instance_of(CacheMock).to receive(:fetch)
+      expect_any_instance_of(CacheMock).to receive(:write)
+      LHC.get('http://local.ch', cache: { use: CacheMock.new })
+    end
+
+    it 'cache options are properly forwarded to the cache' do
+      cache_options = { expires_in: 5.minutes, race_condition_ttl: 15.seconds }
+      expect(default_cache).to receive(:write).with(anything, anything, cache_options)
+      LHC.get('http://local.ch', cache: cache_options)
+    end
+  end
+
+  context 'options - via endpoint configuration' do
+    it 'uses the default cache' do
+      LHC.config.endpoint(:local, 'http://local.ch', cache: true)
+      expect(default_cache).to receive(:fetch)
+      expect(default_cache).to receive(:write)
+      LHC.get(:local)
+    end
+
+    it 'uses the provided cache' do
+      options = { cache: { use: CacheMock.new } }
+      LHC.config.endpoint(:local, 'http://local.ch', options)
+      expect_any_instance_of(CacheMock).to receive(:fetch)
+      expect_any_instance_of(CacheMock).to receive(:write)
+      LHC.get(:local)
+    end
+
+    it 'cache options are properly forwarded to the cache' do
+      cache_options = { expires_in: 5.minutes, race_condition_ttl: 15.seconds }
+      LHC.config.endpoint(:local, 'http://local.ch', cache: cache_options)
+      expect(default_cache).to receive(:write).with(anything, anything, cache_options)
+      LHC.get(:local)
+    end
+  end
+end

data/spec/interceptors/caching/parameters_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Caching do
+  context 'parameters' do
+    before(:each) do
+      LHC.config.interceptors = [LHC::Caching]
+      Rails.cache.clear
+    end
+
+    it 'considers parameters when writing/reading from cache' do
+      LHC.config.endpoint(:local, 'http://local.ch', cache: true)
+      stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website')
+      stub_request(:get, 'http://local.ch?location=zuerich').to_return(status: 200, body: 'The Website for Zuerich')
+      expect(
+        LHC.get(:local).body
+      ).to eq 'The Website'
+      expect(
+        LHC.get(:local, params: { location: 'zuerich' }).body
+      ).to eq 'The Website for Zuerich'
+    end
+  end
+end

data/spec/interceptors/caching/response_status_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Caching do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Caching]
+    LHC.config.endpoint(:local, 'http://local.ch', cache: true)
+    Rails.cache.clear
+    # leverage the Typhoeus internal mock attribute in order to get Typhoeus evaluate the return_code
+    # lib/typhoeus/response/status.rb:48
+    allow_any_instance_of(Typhoeus::Response).to receive(:mock).and_return(false)
+  end
+
+  let!(:stub) { stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website') }
+
+  it 'provides the correct response status for responses from cache' do
+    stub
+    # the real request provides the return_code
+    allow_any_instance_of(Typhoeus::Response).to receive(:options)
+      .and_return(code: 200, status_message: '', body: 'The Website', headers: nil, return_code: :ok)
+    response = LHC.get(:local)
+    expect(response.success?).to eq true
+    # the cached response should get it from the cache
+    allow_any_instance_of(Typhoeus::Response).to receive(:options).and_call_original
+    cached_response = LHC.get(:local)
+    expect(cached_response.success?).to eq true
+  end
+end

data/spec/interceptors/caching/to_cache_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Caching do
+  context 'to_cache' do
+    it 'returns a marshalable object to store in the cache' do
+      expect do
+        response = Typhoeus::Response.new(headers: { 'Accept' => 'application/json' })
+        Marshal.dump(
+          LHC::Caching.new(response).send(:to_cache, response)
+        )
+      end.not_to raise_error
+    end
+  end
+end

data/spec/interceptors/default_interceptors_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'default interceptors' do
+    before(:each) do
+      LHC.configure {}
+    end
+
+    it 'alwayses return a list for default interceptors' do
+      expect(LHC.config.interceptors).to eq []
+    end
+  end
+end

data/spec/interceptors/default_timeout/main_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::DefaultTimeout do
+  before(:each) do
+    LHC.config.interceptors = [LHC::DefaultTimeout]
+    LHC::DefaultTimeout.timeout = nil
+    LHC::DefaultTimeout.connecttimeout = nil
+  end
+
+  let(:stub) { stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website') }
+
+  it 'applies default timeouts to all requests made' do
+    stub
+    expect_any_instance_of(Ethon::Easy).to receive(:http_request)
+      .with(anything, anything, hash_including(timeout: 15, connecttimeout: 2)).and_call_original
+    LHC.get('http://local.ch')
+  end
+
+  context 'with changed default timesouts' do
+    before(:each) do
+      LHC::DefaultTimeout.timeout = 10
+      LHC::DefaultTimeout.connecttimeout = 3
+    end
+
+    it 'applies custom default timeouts to all requests made' do
+      stub
+      expect_any_instance_of(Ethon::Easy).to receive(:http_request)
+        .with(anything, anything, hash_including(timeout: 10, connecttimeout: 3)).and_call_original
+      LHC.get('http://local.ch')
+    end
+  end
+end

data/spec/interceptors/define_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'interceptor' do
+    before(:each) do
+      class SomeInterceptor < LHC::Interceptor
+      end
+      class AnotherInterceptor < LHC::Interceptor
+      end
+    end
+
+    it 'performs interceptor when they are set globally' do
+      LHC.configure { |c| c.interceptors = [SomeInterceptor] }
+      expect_any_instance_of(SomeInterceptor).to receive(:before_request)
+      stub_request(:get, 'http://local.ch')
+      LHC.get('http://local.ch')
+    end
+
+    it 'overrides interceptors on request level' do
+      LHC.configure { |c| c.interceptors = [SomeInterceptor] }
+      expect_any_instance_of(AnotherInterceptor).to receive(:before_request)
+      expect_any_instance_of(SomeInterceptor).not_to receive(:before_request)
+      stub_request(:get, 'http://local.ch')
+      LHC.get('http://local.ch', interceptors: [AnotherInterceptor])
+    end
+  end
+end

data/spec/interceptors/dup_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC do
+  context 'interceptor' do
+    before(:each) do
+      class SomeInterceptor < LHC::Interceptor
+      end
+    end
+
+    it 'does not dup' do
+      options = { interceptors: [SomeInterceptor] }
+      expect(
+        options.deep_dup[:interceptors].include?(SomeInterceptor)
+      ).to eq true
+    end
+  end
+end

data/spec/interceptors/logging/main_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Logging do
+  let(:logger) { spy('logger') }
+
+  before(:each) do
+    LHC.config.interceptors = [LHC::Logging]
+    LHC::Logging.logger = logger
+    stub_request(:get, 'http://local.ch').to_return(status: 200)
+  end
+
+  it 'does log information before and after every request made with LHC' do
+    LHC.get('http://local.ch')
+    expect(logger).to have_received(:info).once.with(
+      %r{Before LHC request <\d+> GET http://local.ch at \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2} Params={} Headers={.*?}}
+    )
+    expect(logger).to have_received(:info).once.with(
+      %r{After LHC response for request <\d+> GET http://local.ch at \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2} Time=0ms URL=http://local.ch:80/}
+    )
+  end
+
+  context 'source' do
+    let(:source) { '/Users/Sebastian/LHC/test.rb' }
+
+    it 'does log the source if provided as option' do
+      LHC.get('http://local.ch', source: source)
+      expect(logger).to have_received(:info).once.with(
+        %r{Before LHC request <\d+> GET http://local.ch at \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2} Params={} Headers={.*?} \nCalled from #{source}}
+      )
+      expect(logger).to have_received(:info).once.with(
+        %r{After LHC response for request <\d+> GET http://local.ch at \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2} Time=0ms URL=http://local.ch:80/ \nCalled from #{source}}
+      )
+    end
+  end
+end

data/spec/interceptors/monitoring/main_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Monitoring do
+  let(:stub) { stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website') }
+  let(:endpoint_configuration) { LHC.config.endpoint(:local, 'http://local.ch') }
+
+  module Statsd
+    def self.count(_path, _value); end
+
+    def self.timing(_path, _value); end
+  end
+
+  before(:each) do
+    LHC.config.interceptors = [LHC::Monitoring]
+    LHC::Monitoring.statsd = Statsd
+    Rails.cache.clear
+    endpoint_configuration
+  end
+
+  it 'does not report anything if no statsd is configured' do
+    stub
+    LHC.get(:local) # and also does not crash ;)
+  end
+
+  context 'statsd configured' do
+    it 'reports trial, response and timing by default ' do
+      stub
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.200', 1)
+      expect(Statsd).to receive(:timing).with('lhc.dummy.test.local_ch.get.time', anything)
+      LHC.get(:local)
+    end
+
+    it 'does not report timing when response failed' do
+      stub_request(:get, 'http://local.ch').to_return(status: 500)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.500', 1)
+      expect(Statsd).not_to receive(:timing)
+      expect { LHC.get(:local) }.to raise_error LHC::ServerError
+    end
+
+    it 'reports timeout instead of status code if response timed out' do
+      stub_request(:get, 'http://local.ch').to_timeout
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.timeout', 1)
+      expect(Statsd).not_to receive(:timing)
+      expect { LHC.get(:local) }.to raise_error LHC::Timeout
+    end
+
+    it 'allows to set the stats key for request' do
+      stub
+      expect(Statsd).to receive(:count).with('defined_key.before_request', 1)
+      expect(Statsd).to receive(:count).with('defined_key.after_request', 1)
+      expect(Statsd).to receive(:count).with('defined_key.count', 1)
+      expect(Statsd).to receive(:count).with('defined_key.200', 1)
+      expect(Statsd).to receive(:timing).with('defined_key.time', anything)
+      LHC.get(:local, monitoring_key: 'defined_key')
+    end
+  end
+
+  context 'without protocol' do
+    let(:endpoint_configuration) { LHC.config.endpoint(:local, 'local.ch') }
+
+    it 'reports trial, response and timing by default ' do
+      stub
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.200', 1)
+      expect(Statsd).to receive(:timing).with('lhc.dummy.test.local_ch.get.time', anything)
+      LHC.get(:local)
+    end
+  end
+
+  context 'with configured environment' do
+    before do
+      LHC::Monitoring.env = 'beta'
+    end
+
+    it 'uses the configured env' do
+      stub
+      expect(Statsd).to receive(:count).with('lhc.dummy.beta.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.beta.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.beta.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.beta.local_ch.get.200', 1)
+      LHC.get(:local)
+    end
+  end
+end

data/spec/interceptors/prometheus_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'prometheus/client'
+
+describe LHC::Prometheus do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Prometheus]
+    LHC::Prometheus.client = Prometheus::Client
+    LHC::Prometheus.namespace = 'test_app'
+    stub_request(:get, 'http://local.ch')
+    expect(Prometheus::Client).to receive(:registry).and_call_original.at_least(:once)
+  end
+
+  let(:client) { double("prometheus/client") }
+
+  context 'registering' do
+    it 'creates a counter and histogram registry in the prometheus client' do
+      expect(Prometheus::Client.registry).to receive(:counter).and_call_original.once
+        .with(:lhc_requests, 'Counter of all LHC requests.')
+      expect(Prometheus::Client.registry).to receive(:histogram).and_call_original.once
+        .with(:lhc_request_seconds, 'Request timings for all LHC requests in seconds.')
+
+      LHC.get('http://local.ch')
+      LHC.get('http://local.ch') # second request, registration should happen only once
+    end
+  end
+
+  context 'logging' do
+    let(:requests_registry_double) { double('requests_registry_double') }
+    let(:times_registry_double) { double('times_registry_double') }
+
+    it 'logs monitoring information to the created registries' do
+      expect(Prometheus::Client.registry).to receive(:get).and_return(requests_registry_double).once
+        .with(:lhc_requests)
+      expect(Prometheus::Client.registry).to receive(:get).and_return(times_registry_double).once
+        .with(:lhc_request_seconds)
+
+      expect(requests_registry_double).to receive(:increment).once
+        .with(
+          code: 200,
+          success: true,
+          timeout: false,
+          app: 'test_app',
+          host: 'local.ch'
+        )
+
+      expect(times_registry_double).to receive(:observe).once
+        .with({ host: 'local.ch', app: 'test_app' }, 0)
+
+      LHC.get('http://local.ch')
+    end
+  end
+end