status_lib 0.0.2

data/spec/lib/status_lib/status_api_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe StatusLib::StatusApi do
+  let(:api)  { StatusLib::StatusApi.new }
+
+  before do
+    StatusLib.configure(server: "http://status.example.com")
+  end
+
+  context "HTTP requests when the service is crashing" do
+    shared_examples_for "an unavailable API" do
+      it "raises an ApiDownError for #get_status_list" do
+        expect {
+          api.get_status_list
+        }.to raise_exception StatusLib::ApiDownError
+      end
+
+      it "raises an ApiDownError for #send_status_update" do
+        expect {
+          api.send_status_update('test', :down, 20)
+        }.to raise_exception StatusLib::ApiDownError
+      end
+    end
+
+    context "when the API has errors" do
+      before do
+        stub_request(:get, "status.example.com/api/status").
+          to_return(status: 500)
+        stub_request(:put, "status.example.com/api/status/test").
+          to_return(status: 500)
+      end
+
+      it_behaves_like "an unavailable API"
+    end
+
+    context "when the API is timing out" do
+      before do
+        stub_request(:get, "status.example.com/api/status").to_return do
+          raise Timeout::Error
+        end
+        stub_request(:put, "status.example.com/api/status/test").to_return do
+          raise Timeout::Error
+        end
+      end
+
+      it_behaves_like "an unavailable API"
+    end
+
+    context "when we crash trying to call the API" do
+      before do
+        stub_request(:get, "status.example.com/api/status").to_return do
+          raise RuntimeError
+        end
+        stub_request(:put, "status.example.com/api/status/test").to_return do
+          raise RuntimeError
+        end
+      end
+
+      it_behaves_like "an unavailable API"
+    end
+  end
+
+  context "HTTP requests" do
+    context "#get_status_list" do
+      before do
+        body = { one: "up", two: "down" }.to_json
+        stub_request(:get, "status.example.com/api/status").
+          to_return(body: body)
+      end
+
+      let!(:result) { api.get_status_list }
+
+      it "calls the service" do
+        expect(WebMock).to have_requested(:get, "status.example.com/api/status")
+      end
+
+      it "returns the status of each service" do
+        expect(result[:one]).to eq(:up)
+        expect(result[:two]).to eq(:down)
+      end
+    end
+
+    context "#send_status_update" do
+      before do
+        stub_request(:put, "status.example.com/api/status/test")
+      end
+
+      context "on a valid service" do
+        it "calls the service" do
+          api.send_status_update('test', :down, 20)
+
+          expect(WebMock).
+            to have_requested(:put, "status.example.com/api/status/test").
+            with(body: { status: 'down', expires: 20 }.to_json)
+        end
+      end
+
+      context "when passing a Time instance" do
+        it "calls the service with an epoch time in UTC" do
+          api.send_status_update('test', :down, Time.utc(1972, 1, 22, 17, 30))
+
+          expect(WebMock).
+            to have_requested(:put, "status.example.com/api/status/test").
+            with(body: { status: 'down', expires: 64949400 }.to_json)
+        end
+      end
+
+      context "on an unknown service" do
+        before do
+          stub_request(:put, "status.example.com/api/status/test").
+            to_return(status: 404)
+        end
+
+        it "raises an ArgumentError" do
+          expect {
+            api.send_status_update('test', :down, 20)
+          }.to raise_exception ArgumentError
+        end
+      end
+    end
+  end
+end

data/spec/lib/status_lib/status_info_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe StatusLib::StatusInfo do
+  let(:info)  { StatusLib::StatusInfo.new(api) }
+  let(:api)   { api_stub.new }
+
+  before do
+    StatusLib::Cache.clear!
+    StatusLib.configure(server: "http://status.example.com")
+  end
+
+  context "calling the API" do
+    let(:api_stub) { double(:api_stub, new: double(:api)) }
+
+    before do
+      allow(api).to receive(:send_status_update)
+
+      Timecop.freeze
+    end
+
+    it "passes the :for duration as an expiry time" do
+      info.switch(:one, :down, for: 99)
+
+      expect(api).to have_received(:send_status_update).
+        with(:one, :down, Time.now + 99)
+    end
+
+    it "passes a nil :for duration as a nil expiry time" do
+      info.switch(:one, :down, for: nil)
+
+      expect(api).to have_received(:send_status_update).
+        with(:one, :down, nil)
+    end
+
+    it "passes a default expiry time if no :for duration supplied" do
+      info.switch(:one, :down)
+
+      expect(api).to have_received(:send_status_update).
+        with(:one, :down, Time.now + StatusLib.config.down_duration)
+    end
+  end
+
+  shared_examples_for "a circuit breaker" do
+    it "disables and enables services" do
+      info.switch(:one, :down, for: 30)
+      expect(info.up?(:one)).to be_false
+
+      info.switch(:one, :up)
+      expect(info.up?(:one)).to be_true
+    end
+
+    it "caches the results from the API" do
+      allow(api).to receive(:get_status_list).and_call_original
+
+      5.times do
+        expect(info.up?(:one)).to be_true
+      end
+
+      expect(api).to have_received(:get_status_list).once
+    end
+
+    it "can switch items down for an interval of time" do
+      Timecop.freeze 0
+      info.switch(:one, :down, for: 30)
+
+      expect(info.up?(:one)).to be_false
+
+      Timecop.freeze(15)
+      expect(info.up?(:one)).to be_false
+
+      Timecop.freeze(60)
+      expect(info.up?(:one)).to be_true
+    end
+
+    it "records a change of status in the configured Stats object" do
+      allow(StatusLib.config.stats_handler).to receive(:increment)
+
+      info.switch(:one, :down)
+
+      expect(StatusLib.config.stats_handler).to have_received(:increment).
+        with('status.change.one.down')
+    end
+  end
+
+  context "when the status API is up" do
+    let(:api_stub) do
+      Class.new do
+        def initialize
+          @statuses = { one: :up, two: :down }
+        end
+
+        def get_status_list
+          return @statuses
+        end
+
+        def send_status_update(name, status, duration)
+          @statuses[name] = status
+        end
+      end
+    end
+
+    it_behaves_like "a circuit breaker"
+  end
+
+  context "when the status API is broken" do
+    let(:api_stub) do
+      Class.new do
+        def get_status_list
+          raise StatusLib::ApiDownError
+        end
+
+        def send_status_update(name, status, duration)
+          raise StatusLib::ApiDownError
+        end
+      end
+    end
+
+    it_behaves_like "a circuit breaker"
+
+    context "after the API comes back" do
+      it "sends the last update that happened while it was down" do
+        Timecop.freeze
+
+        info.switch(:one, :up)
+        info.switch(:one, :down, for: 30)
+        info.switch(:one, :up)
+        info.switch(:one, :down, for: 45)
+
+        allow(api).to receive(:get_status_list).and_return({})
+        allow(api).to receive(:send_status_update)
+
+        info.up?(:one)
+
+        expect(api).to have_received(:send_status_update).
+          with(:one, :down, Time.now + 45).
+          once
+      end
+    end
+  end
+
+  context "when there is a null status API configured" do
+    let(:api_stub) { StatusLib::NullStatusApi }
+
+    it_behaves_like "a circuit breaker"
+  end
+end

data/spec/lib/status_lib_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe StatusLib::ServiceDownError do
+  it "provides access to an original exception" do
+    original  = ArgumentError.new
+    error     = StatusLib::ServiceDownError.new(original)
+
+    expect(error.original_exception).to eq(original)
+  end
+
+  it "has no original exception by default" do
+    error     = StatusLib::ServiceDownError.new
+
+    expect(error.original_exception).to be_nil
+  end
+end
+
+describe StatusLib do
+  let(:status_info) { StatusLib.send(:status_info) }
+
+  it 'should have a version number' do
+    expect(StatusLib::VERSION).to_not be_nil
+  end
+
+  context "#up?" do
+    it "calls the StatusInfo method" do
+      expect(status_info).to receive(:up?).with(:test)
+
+      StatusLib.up?(:test)
+    end
+  end
+
+  context "#switch" do
+    it "calls the StatusInfo method" do
+      expect(status_info).to receive(:switch).with(:test, :down, for: 30)
+
+      StatusLib.switch(:test, :down, for: 30)
+    end
+  end
+
+  context "#with_circuit_breaker" do
+    before do
+      StatusLib::Cache.clear!
+      StatusLib.configure(server: "http://status.example.com")
+    end
+
+    class TestException < RuntimeError; end
+
+    def invoke_test(should_fail)
+      StatusLib.with_circuit_breaker(:test, for: 20) do
+        raise TestException if should_fail
+      end
+    end
+
+    def invoke_test_and_handle_exception(should_fail)
+      invoke_test(should_fail)
+    rescue StatusLib::ServiceDownError
+    end
+
+    context "when the service is up" do
+      before do
+        allow(status_info).to receive(:up?).with(:test).and_return(true)
+        allow(status_info).to receive(:switch)
+      end
+
+      context "when the block works" do
+        it "does not mark the service down" do
+          expect(status_info).to_not receive(:switch)
+          invoke_test(false)
+        end
+
+        it "does not raise an exception" do
+          expect { invoke_test(false) }.to_not raise_exception
+        end
+      end
+
+      context "when the block crashes" do
+        it "marks the service as down" do
+          invoke_test_and_handle_exception(true)
+
+          expect(status_info).to have_received(:switch).
+            with(:test, :down, for: 20)
+        end
+
+        it "raises a ServiceDownError" do
+          expect {
+            invoke_test(true)
+          }.to raise_exception StatusLib::ServiceDownError
+        end
+
+        it "provides access to the original exception" do
+          begin
+            invoke_test(true)
+          rescue StatusLib::ServiceDownError => ex
+            expect(ex.original_exception).to be_an_instance_of(TestException)
+          end
+        end
+
+        context "when the block times out" do
+          it "marks the service as down" do
+            begin
+              StatusLib.with_circuit_breaker(:test, for: 20, timeout: 0.25) do
+                sleep 0.5
+              end
+            rescue Timeout::Error
+            end
+
+            expect(status_info).to have_received(:switch).
+              with(:test, :down, for: 20)
+          end
+
+          it "raises a Timeout::Error" do
+            expect {
+              StatusLib.with_circuit_breaker(:test, timeout: 0.25) do
+                sleep 0.5
+              end
+            }.to raise_exception Timeout::Error
+          end
+
+          it "raises a ServiceDownError" do
+            expect {
+              StatusLib.with_circuit_breaker(:test, timeout: 0.25) do
+                raise StandardError.new
+              end
+            }.to raise_exception StatusLib::ServiceDownError
+          end
+        end
+
+        context "when an exception handler has been configured" do
+          let(:mock_handler) { double(:handler, call: nil) }
+
+          before do
+            allow(StatusLib.config).to receive(:exception_handler).
+              and_return(mock_handler)
+
+            invoke_test_and_handle_exception(true)
+          end
+
+          it "invokes the supplied exception handler on failure" do
+            expect(mock_handler).to have_received(:call).
+              with(an_instance_of(TestException))
+          end
+        end
+      end
+
+      context "when the block crashes but we have a zero downtime" do
+        before do
+          begin
+            StatusLib.with_circuit_breaker(:test, for: 0) do
+              raise TestException
+            end
+          rescue StatusLib::ServiceDownError
+          end
+        end
+
+        it "does not mark the service down" do
+          expect(status_info).to_not have_received(:switch)
+        end
+      end
+
+      context "when the block crashes but we have a nil downtime" do
+        before do
+          begin
+            StatusLib.with_circuit_breaker(:test, for: nil) do
+              raise TestException
+            end
+          rescue StatusLib::ServiceDownError
+          end
+        end
+
+        it "does not mark the service down" do
+          expect(status_info).to_not have_received(:switch)
+        end
+      end
+    end
+
+    context "when the service is down" do
+      before do
+        allow(status_info).to receive(:up?).with(:test).and_return(false)
+      end
+
+      it "raises a ServiceDownError" do
+        expect {
+          invoke_test(false)
+        }.to raise_exception StatusLib::ServiceDownError
+      end
+
+      it "does not execute the block" do
+        expect { |b|
+          invoke_test_and_handle_exception(true, &b)
+        }.to_not yield_control
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'status_lib'
+require 'rspec'
+require 'webmock/rspec'
+require 'timecop'
+require 'json'
+
+RSpec.configure do |config|
+  # Only use the newer-style syntax
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+

data/status_lib.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'status_lib/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "status_lib"
+  spec.version       = StatusLib::VERSION
+  spec.authors       = ["Kevin McConnell"]
+  spec.email         = ["kevin.mcconnell@livingsocial.com"]
+  spec.description   = "Wrapper library for access to service status service"
+  spec.summary       = ""
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "ls-gem_tasks"
+  spec.add_development_dependency "rb-fsevent"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "webmock"
+end