health-reporter 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 811d4fe0c539b271a1af0b24f9b05a1acebcfb72807adb210a7afb83d2dbb578
-  data.tar.gz: cabfb77b2c8718cb89d70127f41d4f28811919addb1ea04113a98404e0069fdb
+  metadata.gz: 0becc469072443dc5e1b63ec1ab05d9ef71fec7cffbb9a5213c7dbfde6ce5a89
+  data.tar.gz: de579186d0b529f2b2128536b73eacd6e8b21ae5ea9fe9198b77605808fca931
 SHA512:
-  metadata.gz: 34e3355c2f7d47fc46e519686fbbc8f0a5e7a72950406bccdbcf452004ac44407f04734f00baf98e9e29c857871c574636d6e09faf0868e0abcf5c171780ddd2
-  data.tar.gz: 052ae27769b5ce9d475e52e8bf11f2d851a09e50f81063773a87aff117881725e7bb4af2c91fe5b5d07f9f854f7feae02a4ece85fc7418ba0c3e11b53a102181
+  metadata.gz: cd59fcf68ab839f83ece80d0a734488a055dbc757d71273258328b0908f1af0716ea9a520ab155f31af07dc58cdb9f86d7dd63ea6897aef1930f2503c1d8e57f
+  data.tar.gz: 011b07b0351210e19ba04c8376614cbc30f4f899143662c822907d364b986c4a4587ae0685b5d20f6197d896f7654e7adfa9262ebd605682787ad4284cf19e07

data/Dockerfile

@@ -1,4 +1,4 @@
-FROM ruby:2.5.0
+FROM ruby:2.5
 
 WORKDIR /usr/local/src/
 ADD . /usr/local/src/

data/lib/health_reporter/reporter.rb

@@ -46,11 +46,22 @@ class HealthReporter
     @@dependencies = {}
   end
 
+  def self.register_dependencies(provided_dependencies = [])
+    provided_dependencies.map{ |dependency|
+      symbolized_dependency = Hash[dependency.map{|(k,v)| [k.to_sym,v]}]
+      raise 'url not defined for dependency' unless symbolized_dependency[:url]
+      add_defaults(symbolized_dependency)
+      dependencies[symbolized_dependency[:url]] = symbolized_dependency
+      dependencies[symbolized_dependency[:url]].delete(:url)
+    }
+  end
+
   def self.dependencies
     @@dependencies
   end
 
   def self.register_dependency(url:, code: 200, timeout: 2)
+    $stderr.puts "The HealthReporter method register_dependency is depreciated. Use fully featured register_dependencies method instead"
     raise "Configured URL #{url} is invalid" unless url =~ URI::regexp
     dependencies[url] = { :code => code, :timeout => timeout }
   end
@@ -64,6 +75,11 @@ class HealthReporter
 
   private
 
+  def self.add_defaults(dependency)
+    dependency[:code] |= 200
+    dependency[:timeout] |= 2
+  end
+
   def self.perform_health_check
     @@last_check_time = Time.now
     @@healthy = sanitize(@@self_test.call)
@@ -81,12 +97,17 @@ class HealthReporter
   end
 
   def self.check_dependency(url:, configuration:)
-    conn = Faraday.new(:url => url)
-    response = conn.get do |request|
-      request.options.timeout = configuration[:timeout]
-      request.options.open_timeout = configuration[:timeout]
+    connection ||= Faraday.new(:url => url) do |faraday|
+      faraday.options[:open_timeout] = configuration[:timeout]
+      faraday.options[:timeout] = configuration[:timeout]
+      faraday.request(:url_encoded)
+      faraday.adapter Faraday.default_adapter
+      puts configuration
+      faraday.basic_auth(configuration[:username], configuration[:password]) if configuration[:username]
     end
 
+    response = connection.get
+
     unless response.status == configuration[:code]
       raise "Response expected to be #{configuration[:code]} but is #{response.status}"
     end

data/lib/health_reporter/version.rb

@@ -1,3 +1,3 @@
 class HealthReporter
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/spec/reporter.rb

@@ -18,7 +18,7 @@ describe HealthReporter do
     reset_lambda_runner_spy
   end
 
-  context 'when configuring' do
+  describe '#self_test' do
     it 'remembers the self-test lambda passed to it' do
       test_lambda = lambda{ 'ab' == 'cd' }
       subject.self_test = test_lambda
@@ -32,29 +32,35 @@ describe HealthReporter do
       expect(subject.healthy?).to be false
       expect(spy_lambda_was_run?).to eq true
     end
+  end
 
+  describe '#healthy_cache_ttl' do
     it 'remembers the cache ttl when healthy' do
       subject.healthy_cache_ttl = 10
       expect(subject.healthy_cache_ttl).to eq 10
     end
+  end
 
+  describe '#unhealthy_cache_ttl' do
     it 'remembers the cache ttl when not healthy' do
       subject.unhealthy_cache_ttl = 5
       expect(subject.unhealthy_cache_ttl).to eq 5
     end
+  end
 
-    it 'remembers when you add a dependencies' do
+  describe '#register_dependency' do
+    it 'remembers when you add a dependency' do
       subject.register_dependency(url: 'https://hardware-store/status', code: 123, timeout: 1)
       expect(subject.dependencies).to eq({
         'https://hardware-store/status' => { :code => 123, :timeout => 1 }
       })
     end
 
-    it 'validates the urls of the dependencies during registration' do
+    it 'validates the urls of the dependency during registration' do
       expect{subject.register_dependency(url: 'no-valid-url')}.to raise_error RuntimeError, "Configured URL no-valid-url is invalid"
     end
 
-    it 'adds dependencies without removing the dependencies already registered' do
+    it 'adds dependency without removing the dependencies already registered' do
       subject.register_dependency(url: 'https://hardware-store/status', code: 123, timeout: 1)
       subject.register_dependency(url: 'https://grocery-store/status', code: 123, timeout: 1)
       expect(subject.dependencies).to eq({
@@ -74,214 +80,388 @@ describe HealthReporter do
         'https://grocery-store/status' => { :code => 123, :timeout => 1 }
       })
     end
-
-    it 'clears the cache when requested' do
-      subject.healthy?
-      expect(subject.class_variable_get('@@healthy')).to be true
-      expect(subject.class_variable_get('@@last_check_time')).to_not be nil
-      subject.clear_cache
-      expect(subject.class_variable_get('@@healthy')).to be nil
-      expect(subject.class_variable_get('@@last_check_time')).to be nil
-    end
   end
 
-  context 'when exercising self-test lambda' do
-    it 'allows true to be returned by self-test lambda' do
-      test_lambda = lambda{ true }
-      subject.self_test = test_lambda
-      expect(subject.healthy?).to be true
-    end
-
-    it 'allows false to be returned by self-test lambda' do
-      test_lambda = lambda{ false }
-      subject.self_test = test_lambda
-      expect(subject.healthy?).to be false
-    end
 
-    it 'raises an exception when non-boolean values are returned by self-test lambda' do
-      test_lambda = lambda{ "I don't feel well..." }
-      subject.self_test = test_lambda
-      expect{subject.healthy?}.to raise_error RuntimeError, "Invalid non-boolean response from registered self-check lambda: I don't feel well..."
-    end
+  def self.register_dependencies(provided_dependencies = [])
+    provided_dependencies.map{ |dependency|
+      @@dependencies[url] = dependency.delete(:url)
+    }
   end
 
-  context 'when initialized without any parameters' do
-    it 'sets the default self-test lambda to { true }' do
-      expect(subject.healthy?).to eq true
-    end
 
-    it 'sets the default healthy state cache ttl to 60 seconds' do
-      expect(subject.healthy_cache_ttl).to eq 60
+  describe '#register_dependencies' do
+    let(:provided_test_dependencies_with_string_keys) {
+      [
+        {
+          "url" => "https://cake-place/health",
+          "code" => 200,
+          "timeout" => 3
+        },
+        {
+          "url" => "https://coffee-place/status",
+          "code" => 200,
+          "timeout" => 3
+        },
+        {
+          "url" => "http://postoffice/status",
+          "code" => 200,
+          "timeout" => 3
+        },
+        {
+          "url" => "http://postoffice/status",
+          "code" => 200,
+          "timeout" => 3,
+          "authorization_token" => "api_token"
+        },
+        {
+          "url" => "http://duplicated/status",
+          "code" => 200,
+          "timeout" => 3,
+          "authorization_token" => "api_token"
+        },
+        {
+          "url" => "http://duplicated/status",
+          "code" => 200,
+          "timeout" => 3,
+          "authorization_token" => "api_token"
+        },
+        {
+          "url" => "https://pizza-place/health",
+          "code" => 204,
+          "timeout" => 2,
+          "username" => "checker",
+          "password" => "checking"
+        }
+      ]
+    }
+    let(:provided_test_dependencies_with_symbol_keys) {
+      [
+        {
+          url: "https://cake-place/health",
+          code: 200,
+          timeout: 3
+        },
+        {
+          url: "https://coffee-place/status",
+          code: 200,
+          timeout: 3
+        },
+        {
+          url: "http://postoffice/status",
+          code: 200,
+          timeout: 3
+        },
+        {
+          url: "http://postoffice/status",
+          code: 200,
+          timeout: 3,
+          authorization_token: "api_token"
+        },
+        {
+          url: "http://duplicated/status",
+          code: 200,
+          timeout: 3,
+          authorization_token: "api_token"
+        },
+        {
+          url: "http://duplicated/status",
+          code: 200,
+          timeout: 3,
+          authorization_token: "api_token"
+        },
+        {
+          url: "https://pizza-place/health",
+          code: 204,
+          timeout: 2,
+          username: "checker",
+          password: "checking"
+        }
+      ]
+    }
+    let(:expected_dependencies) {
+      {
+        "https://cake-place/health" => {
+          code: 200,
+          timeout: 3
+        },
+        "https://coffee-place/status" => {
+          code: 200,
+          timeout: 3
+        },
+        "http://postoffice/status" => {
+          code: 200,
+          timeout: 3,
+          authorization_token: "api_token"
+        },
+        "http://duplicated/status" => {
+          code: 200,
+          timeout: 3,
+          authorization_token: "api_token"
+        },
+        "https://pizza-place/health" => {
+          code: 204,
+          timeout: 2,
+          username: "checker",
+          password: "checking"
+        }
+      }
+    }
+    it 'remembers when you add the dependencies with string keys' do
+      subject.register_dependencies(provided_test_dependencies_with_string_keys)
+      expect(subject.dependencies).to eq(expected_dependencies)
     end
-
-    it 'sets the default unhealthy state cache ttl to 30 seconds' do
-      expect(subject.unhealthy_cache_ttl).to eq 30
+    it 'remembers when you add the dependencies with symbol keys' do
+      subject.register_dependencies(provided_test_dependencies_with_symbol_keys)
+      expect(subject.dependencies).to eq(expected_dependencies)
     end
-  end
 
-  context 'when calling health check for first time (no cached health state)' do
-    it 'calls the configured self-test lambda and returns health' do
-      subject.self_test = spy_lambda_returning_false
-      expect(subject.healthy?).to be false
-      expect(spy_lambda_was_run?).to eq true
-    end
+
   end
 
-  context 'when current state is healty' do
-    before(:each) do
-      subject.self_test = spy_lambda_returning_true
-      subject.healthy? #force the self-test
-      reset_lambda_runner_spy #reset the spy so that we can see if it was run or not
+  describe '#clear_cache' do
+    it 'clears the cache when requested' do
+      subject.healthy?
+      expect(subject.class_variable_get('@@healthy')).to be true
+      expect(subject.class_variable_get('@@last_check_time')).to_not be nil
+      subject.clear_cache
+      expect(subject.class_variable_get('@@healthy')).to be nil
+      expect(subject.class_variable_get('@@last_check_time')).to be nil
     end
+  end
 
-    context 'when neither healty-cache-ttl nor unhealty-cache-ttl has expired' do
-      before(:each) do
-        subject.unhealthy_cache_ttl = 10
-        subject.healthy_cache_ttl   = 10
-        Timecop.freeze(Time.now + 5)
-      end
-
-      it 'does not call the registered self-test lambda' do
-        subject.healthy? #request here and test if it was run in expect below
-        expect(spy_lambda_was_run?).to eq false
-      end
-      it 'returns the current healthy state' do
+  describe '#healthy?' do
+    context 'when exercising self-test lambda' do
+      it 'allows true to be returned by self-test lambda' do
+        test_lambda = lambda{ true }
+        subject.self_test = test_lambda
         expect(subject.healthy?).to be true
       end
-    end
-
-    context 'when healty-cache-ttl has expired' do
-      before do
-        subject.unhealthy_cache_ttl = 10
-        subject.healthy_cache_ttl   =  3
-        Timecop.freeze(Time.now + 5)
+  
+      it 'allows false to be returned by self-test lambda' do
+        test_lambda = lambda{ false }
+        subject.self_test = test_lambda
+        expect(subject.healthy?).to be false
       end
-
-      it 'calls the registered self-test lambda' do
-        subject.healthy? #request here and test if it was run in expect below
-        expect(spy_lambda_was_run?).to eq true
-      end
-      it 'returns the current healthy state' do
-        expect(subject.healthy?).to be true
+  
+      it 'raises an exception when non-boolean values are returned by self-test lambda' do
+        test_lambda = lambda{ "I don't feel well..." }
+        subject.self_test = test_lambda
+        expect{subject.healthy?}.to raise_error RuntimeError, "Invalid non-boolean response from registered self-check lambda: I don't feel well..."
       end
     end
-
-    context 'when unhealty-cache-ttl has expired' do
-      before(:each) do
-        subject.unhealthy_cache_ttl =  3
-        subject.healthy_cache_ttl   = 10
-        Timecop.freeze(Time.now + 5)
+  
+    context 'when initialized without any parameters' do
+      it 'sets the default self-test lambda to { true }' do
+        expect(subject.healthy?).to eq true
       end
-
-      it 'does not call the registered self-test lambda' do
-        subject.healthy? #request here and test if it was run in expect below
-        expect(spy_lambda_was_run?).to eq false
+  
+      it 'sets the default healthy state cache ttl to 60 seconds' do
+        expect(subject.healthy_cache_ttl).to eq 60
       end
-      it 'returns the current healthy state' do
-        expect(subject.healthy?).to be true
+  
+      it 'sets the default unhealthy state cache ttl to 30 seconds' do
+        expect(subject.unhealthy_cache_ttl).to eq 30
       end
     end
-  end
-
-  context 'when current state is unhealty' do
-    before(:each) do
-      subject.self_test = spy_lambda_returning_false
-      subject.healthy? #force the self-test
-      reset_lambda_runner_spy #reset the spy so that we can see if it was run or not
-    end
-
-    context 'when neither healty-cache-ttl nor unhealty-cache-ttl has expired' do
-      before(:each) do
-        subject.unhealthy_cache_ttl = 10
-        subject.healthy_cache_ttl   = 10
-        Timecop.freeze(Time.now + 5)
-      end
-
-      it 'does not call the registered self-test lambda' do
-        subject.healthy? #request here and test if it was run in expect below
-        expect(spy_lambda_was_run?).to eq false
-      end
-      it 'returns the current unhealthy state' do
+  
+    context 'when calling health check for first time (no cached health state)' do
+      it 'calls the configured self-test lambda and returns health' do
+        subject.self_test = spy_lambda_returning_false
         expect(subject.healthy?).to be false
+        expect(spy_lambda_was_run?).to eq true
       end
     end
-
-    context 'when healty-cache-ttl has expired' do
+  
+    context 'when current state is healty' do
       before(:each) do
-        subject.unhealthy_cache_ttl = 10
-        subject.healthy_cache_ttl   =  3
-        Timecop.freeze(Time.now + 5)
+        subject.self_test = spy_lambda_returning_true
+        subject.healthy? #force the self-test
+        reset_lambda_runner_spy #reset the spy so that we can see if it was run or not
       end
-
-      it 'does not call the registered self-test lambda' do
-        subject.healthy? #request here and test if it was run in expect below
-        expect(spy_lambda_was_run?).to eq false
+  
+      context 'when neither healty-cache-ttl nor unhealty-cache-ttl has expired' do
+        before(:each) do
+          subject.unhealthy_cache_ttl = 10
+          subject.healthy_cache_ttl   = 10
+          Timecop.freeze(Time.now + 5)
+        end
+  
+        it 'does not call the registered self-test lambda' do
+          subject.healthy? #request here and test if it was run in expect below
+          expect(spy_lambda_was_run?).to eq false
+        end
+        it 'returns the current healthy state' do
+          expect(subject.healthy?).to be true
+        end
       end
-      it 'returns the current unhealthy state' do
-        expect(subject.healthy?).to be false
+  
+      context 'when healty-cache-ttl has expired' do
+        before do
+          subject.unhealthy_cache_ttl = 10
+          subject.healthy_cache_ttl   =  3
+          Timecop.freeze(Time.now + 5)
+        end
+  
+        it 'calls the registered self-test lambda' do
+          subject.healthy? #request here and test if it was run in expect below
+          expect(spy_lambda_was_run?).to eq true
+        end
+        it 'returns the current healthy state' do
+          expect(subject.healthy?).to be true
+        end
+      end
+  
+      context 'when unhealty-cache-ttl has expired' do
+        before(:each) do
+          subject.unhealthy_cache_ttl =  3
+          subject.healthy_cache_ttl   = 10
+          Timecop.freeze(Time.now + 5)
+        end
+  
+        it 'does not call the registered self-test lambda' do
+          subject.healthy? #request here and test if it was run in expect below
+          expect(spy_lambda_was_run?).to eq false
+        end
+        it 'returns the current healthy state' do
+          expect(subject.healthy?).to be true
+        end
       end
     end
-
-    context 'when unhealty-cache-ttl has expired' do
+  
+    context 'when current state is unhealty' do
       before(:each) do
-        subject.unhealthy_cache_ttl =  3
-        subject.healthy_cache_ttl   = 10
-        Timecop.freeze(Time.now + 5)
+        subject.self_test = spy_lambda_returning_false
+        subject.healthy? #force the self-test
+        reset_lambda_runner_spy #reset the spy so that we can see if it was run or not
       end
-
-      it 'calls the registered self-test lambda' do
-        subject.healthy? #request here and test if it was run in expect below
-        expect(spy_lambda_was_run?).to eq true
+  
+      context 'when neither healty-cache-ttl nor unhealty-cache-ttl has expired' do
+        before(:each) do
+          subject.unhealthy_cache_ttl = 10
+          subject.healthy_cache_ttl   = 10
+          Timecop.freeze(Time.now + 5)
+        end
+  
+        it 'does not call the registered self-test lambda' do
+          subject.healthy? #request here and test if it was run in expect below
+          expect(spy_lambda_was_run?).to eq false
+        end
+        it 'returns the current unhealthy state' do
+          expect(subject.healthy?).to be false
+        end
       end
-      it 'returns the current unhealthy state' do
-        expect(subject.healthy?).to be false
+  
+      context 'when healty-cache-ttl has expired' do
+        before(:each) do
+          subject.unhealthy_cache_ttl = 10
+          subject.healthy_cache_ttl   =  3
+          Timecop.freeze(Time.now + 5)
+        end
+  
+        it 'does not call the registered self-test lambda' do
+          subject.healthy? #request here and test if it was run in expect below
+          expect(spy_lambda_was_run?).to eq false
+        end
+        it 'returns the current unhealthy state' do
+          expect(subject.healthy?).to be false
+        end
       end
-    end
-  end
-
-  context 'when checking dependencies' do
-    context 'when there are no dependencies registered' do
-      it 'only performs the self-test' do
-        subject.self_test = spy_lambda_returning_false
-        expect(subject.healthy?).to be false
-        expect(spy_lambda_was_run?).to eq true
+  
+      context 'when unhealty-cache-ttl has expired' do
+        before(:each) do
+          subject.unhealthy_cache_ttl =  3
+          subject.healthy_cache_ttl   = 10
+          Timecop.freeze(Time.now + 5)
+        end
+  
+        it 'calls the registered self-test lambda' do
+          subject.healthy? #request here and test if it was run in expect below
+          expect(spy_lambda_was_run?).to eq true
+        end
+        it 'returns the current unhealthy state' do
+          expect(subject.healthy?).to be false
+        end
       end
     end
-
-    context 'when there are multiple dependencies registered' do
-      before(:each) do
-        subject.register_dependency(url: 'https://hardware-store/status')
-        subject.register_dependency(url: 'https://grocery-store/status')
-        subject.self_test = spy_lambda_returning_true
+  
+    context 'when checking dependencies' do
+      context 'when there are no dependencies registered' do
+        it 'only performs the self-test' do
+          subject.self_test = spy_lambda_returning_false
+          expect(subject.healthy?).to be false
+          expect(spy_lambda_was_run?).to eq true
+        end
       end
-
-      it 'performs the self-test and checks all dependencies' do
-        stub_request(:get, "https://hardware-store/status").to_return(:status => 200, :body => "", :headers => {})
-        stub_request(:get, "https://grocery-store/status").to_return(:status => 200, :body => "", :headers => {})
-        expect(subject.healthy?).to be true
-        expect(spy_lambda_was_run?).to eq true
+  
+      context 'when there are multiple dependencies registered' do
+        before(:each) do
+          subject.register_dependency(url: 'https://hardware-store/status')
+          subject.register_dependency(url: 'https://grocery-store/status')
+          subject.self_test = spy_lambda_returning_true
+        end
+  
+        it 'performs the self-test and checks all dependencies' do
+          stub_request(:get, "https://hardware-store/status").to_return(:status => 200, :body => "", :headers => {})
+          stub_request(:get, "https://grocery-store/status").to_return(:status => 200, :body => "", :headers => {})
+          expect(subject.healthy?).to be true
+          expect(spy_lambda_was_run?).to eq true
+        end
+  
+        it 'indicates healthy if all of the dependencies are healthy' do
+          stub_request(:get, "https://hardware-store/status").to_return(:status => 200, :body => "", :headers => {})
+          stub_request(:get, "https://grocery-store/status").to_return(:status => 200, :body => "", :headers => {})
+          expect(subject.healthy?).to be true
+          expect(spy_lambda_was_run?).to eq true
+        end
+  
+        it 'raises a detailed exception indicating why a dependency was determined to be unhealthy state was uncached' do
+          stub_request(:get, "https://hardware-store/status").to_return(:status => 500, :body => "", :headers => {})
+          stub_request(:get, "https://grocery-store/status").to_return(:status => 200, :body => "", :headers => {})
+          expect{subject.healthy?}.to raise_error RuntimeError, "Dependency <https://hardware-store/status> failed check due to RuntimeError: Response expected to be 200 but is 500"
+        end
+  
+        it 'indicates cached unhealthy state if it is unhealthy because a dependency was unhealthy' do
+          stub_request(:get, "https://hardware-store/status").to_return(:status => 500, :body => "", :headers => {})
+          stub_request(:get, "https://grocery-store/status").to_return(:status => 200, :body => "", :headers => {})
+          expect{subject.healthy?}.to raise_error RuntimeError, "Dependency <https://hardware-store/status> failed check due to RuntimeError: Response expected to be 200 but is 500"
+          reset_lambda_runner_spy
+          expect(subject.healthy?).to be false
+          expect(spy_lambda_was_run?).to eq false
+        end
       end
 
-      it 'indicates healthy if all of the dependencies are healthy' do
-        stub_request(:get, "https://hardware-store/status").to_return(:status => 200, :body => "", :headers => {})
-        stub_request(:get, "https://grocery-store/status").to_return(:status => 200, :body => "", :headers => {})
-        expect(subject.healthy?).to be true
-        expect(spy_lambda_was_run?).to eq true
-      end
-
-      it 'raises a detailed exception indicating why a dependency was determined to be unhealthy state was uncached' do
-        stub_request(:get, "https://hardware-store/status").to_return(:status => 500, :body => "", :headers => {})
-        stub_request(:get, "https://grocery-store/status").to_return(:status => 200, :body => "", :headers => {})
-        expect{subject.healthy?}.to raise_error RuntimeError, "Dependency <https://hardware-store/status> failed check due to RuntimeError: Response expected to be 200 but is 500"
-      end
-
-      it 'indicates cached unhealthy state if it is unhealthy because a dependency was unhealthy' do
-        stub_request(:get, "https://hardware-store/status").to_return(:status => 500, :body => "", :headers => {})
-        stub_request(:get, "https://grocery-store/status").to_return(:status => 200, :body => "", :headers => {})
-        expect{subject.healthy?}.to raise_error RuntimeError, "Dependency <https://hardware-store/status> failed check due to RuntimeError: Response expected to be 200 but is 500"
-        reset_lambda_runner_spy
-        expect(subject.healthy?).to be false
-        expect(spy_lambda_was_run?).to eq false
+      context 'when a dependency requires basic auth' do
+        let(:test_dependencies_with_basic_auth) {
+          [
+            {
+              url: "https://pizza-place/health",
+              code: 204,
+              timeout: 2,
+              username: "check_user",
+              password: "check_password"
+            }
+          ]
+        }
+
+        before(:each) do
+          subject.register_dependencies(test_dependencies_with_basic_auth)
+        end
+
+        it 'reaches out to the dependency using a basic auth and dependency have good health' do
+          stub_request(:get, "https://pizza-place/health").
+            with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Authorization'=>'Basic Y2hlY2tfdXNlcjpjaGVja19wYXNzd29yZA==', 'User-Agent'=>'Faraday v0.15.2'}).
+            to_return(:status => 204, :body => "", :headers => {})
+          expect(subject.healthy?).to be true
+        end
+
+        it 'reaches out to the dependency using a basic auth and dependency does not have good health' do
+          stub_request(:get, "https://pizza-place/health").
+            with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Authorization'=>'Basic Y2hlY2tfdXNlcjpjaGVja19wYXNzd29yZA==', 'User-Agent'=>'Faraday v0.15.2'}).
+            to_return(:status => 500, :body => "", :headers => {})
+          expect{subject.healthy?}.to raise_error RuntimeError, "Dependency <https://pizza-place/health> failed check due to RuntimeError: Response expected to be 204 but is 500"
+          expect(subject.healthy?).to be false
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: health-reporter
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Barney de Villiers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-03 00:00:00.000000000 Z
+date: 2018-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday