rack-ecg 0.0.5 → 0.1.0

data/.travis.yml

@@ -1,28 +0,0 @@
-language: ruby
-sudo: false
-cache: bundler
-
-rvm:
-  - 1.9.3
-  - 2.0
-  - 2.1
-  - 2.2.5
-  - 2.3.1
-  - ruby-head
-  - jruby
-
-gemfile:
-  - Gemfile
-  - gemfiles/rack_v1.gemfile
-
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby
-  exclude:
-    - rvm: 1.9.3
-      gemfile: Gemfile
-    - rvm: 2.0
-      gemfile: Gemfile
-    - rvm: 2.1
-      gemfile: Gemfile

data/gemfiles/rack_v1.gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'rack', '< 2'
-gemspec path: '../'

data/spec/check_factory_spec.rb

@@ -1,59 +0,0 @@
-RSpec.describe Rack::ECG::CheckFactory do
-  class MyCheckClass; end
-  class MyOtherCheckClass; def initialize(params); end; end
-
-  let(:definitions) { [] }
-  let(:default_checks) { [] }
-  subject(:check_factory) { Rack::ECG::CheckFactory.new(definitions, default_checks) }
-
-  describe "#build" do
-    context "with a class that does not take params" do
-      let(:check_class) { spy(MyCheckClass) }
-
-      it "builds the specified class" do
-        expect { check_factory.build(check_class) }.not_to raise_error
-        expect(check_class).to have_received(:new).with(no_args)
-      end
-    end
-
-    context "with a class that does not take params" do
-      let(:check_class) { spy(MyOtherCheckClass) }
-      let(:check_parameters) { double }
-      it "builds the specified class" do
-        expect { check_factory.build(check_class, check_parameters) }.not_to raise_error
-        expect(check_class).to have_received(:new).with(check_parameters)
-      end
-    end
-  end
-
-  describe "#build_all" do
-    context "with defined checks" do
-      let(:definitions) { [:my_check, [:my_other_check, {foo: 'bar'}]] }
-      let(:check_class) { spy(MyCheckClass) }
-      let(:other_check_class) { spy(MyOtherCheckClass) }
-      before do
-        allow(Rack::ECG::CheckRegistry).to receive(:lookup).with(:my_check).and_return(check_class)
-        allow(Rack::ECG::CheckRegistry).to receive(:lookup).with(:my_other_check).and_return(other_check_class)
-      end
-
-      it "builds all registered checks" do
-        check_factory.build_all
-        expect(check_class).to have_received(:new).with(no_args)
-        expect(other_check_class).to have_received(:new).with(foo: 'bar')
-      end
-    end
-
-    context "with defined default checks" do
-      let(:default_checks) { [:http] }
-      let(:http_class) { spy(Rack::ECG::Check::Http) }
-      before do
-        allow(Rack::ECG::CheckRegistry).to receive(:lookup).with(:http).and_return(http_class)
-      end
-
-      it "builds registered default checks" do
-        check_factory.build_all
-        expect(http_class).to have_received(:new).with(no_args)
-      end
-    end
-  end
-end

data/spec/check_registry_spec.rb

@@ -1,23 +0,0 @@
-
-RSpec.describe Rack::ECG::CheckRegistry do
-  class MyCheckClass; end
-  subject(:check_registry) { described_class }
-
-  before do
-    check_registry.register(:my_check, MyCheckClass)
-  end
-
-  describe ".lookup" do
-    context "with a registered class" do
-      it "returns the registered class" do
-        expect(check_registry.lookup(:my_check)).to eq(MyCheckClass)
-      end
-    end
-
-    context "when the class is not registered" do
-      it "raises an error" do
-        expect { check_registry.lookup(:my_other_check) }.to raise_error(Rack::ECG::CheckRegistry::CheckNotRegistered)
-      end
-    end
-  end
-end

data/spec/rack_middleware_spec.rb

@@ -1,246 +0,0 @@
-require "open3"
-require "stringio"
-
-RSpec.describe "when used as middleware" do
-  let(:app) {
-    opts = options
-    Rack::Builder.new do
-      use Rack::ECG, opts
-      run lambda {|env|
-        if env["PATH_INFO"] == "/hello/world"
-          [200, {}, ["Hello, World"]]
-        else
-          [404, {}, ["Goodbye, World"]]
-        end
-      }
-    end
-  }
-  let(:options) {
-    {} # empty default
-  }
-
-  context "main app" do
-    it "responds OK for normal requests" do
-      get "/hello/world"
-      expect(last_response).to be_ok
-    end
-
-    it "doesn't include an X-Rack-ECG-Version custom header" do
-      get "/hello/world"
-      expect(last_response.header["X-Rack-ECG-Version"]).to be_nil
-    end
-  end
-
-  context "ecg app" do
-    it "responds " do
-      get "/_ecg"
-      expect(last_response).to be_ok
-    end
-
-    it "includes an X-Rack-ECG-Version custom header" do
-      get "/_ecg"
-      expect(last_response.header["X-Rack-ECG-Version"]).to eq(Rack::ECG::VERSION)
-    end
-
-    context "when `at` config option is set" do
-      let(:options) {
-        {at: "/health_check"}
-      }
-
-      it "responds from that path" do
-        get "/health_check"
-        expect(last_response.header["X-Rack-ECG-Version"]).to eq(Rack::ECG::VERSION)
-      end
-    end
-
-    context "when all checks pass" do
-      it "has a success error code" do
-        get "_ecg"
-        expect(last_response.status).to eq(200)
-      end
-    end
-
-    context "when a checks errors" do
-      let(:options) {
-        { checks: [:error] }
-      }
-      it "has a success error code" do
-        get "_ecg"
-        expect(last_response.status).to eq(500)
-      end
-    end
-
-    context "when hook config option is set" do
-      let(:hook_proc) { instance_double(Proc) }
-      let(:options) {
-        { hook: hook_proc, checks: :error }
-      }
-
-      it "executes the hook proc with success status and check results as params" do
-        expect(hook_proc).to receive(:call) do |success, check_results|
-          expect(success).to be_falsey
-          expect(check_results).to have_key(:error)
-        end
-        get "_ecg"
-        expect(last_response.status).to eq(500)
-      end
-    end
-
-    context "git revision" do
-      let(:options) {
-        { checks: [:git_revision] }
-      }
-      context "when available" do
-        let(:sha) { "cafe1234" }
-        it "is reported" do
-          expect(Open3).to receive(:popen3).
-            with("git rev-parse HEAD").
-            and_return([
-              nil,                                                    # stdin
-              StringIO.new(sha + "\n"),                               # stdout
-              StringIO.new(),                                         # stderr
-              double(value: double(Process::Status, success?: true))  # wait thread & process status
-            ])
-          get "/_ecg"
-          expect(json_body["git_revision"]["status"]).to eq("ok")
-          expect(json_body["git_revision"]["value"]).to eq(sha)
-        end
-      end
-
-      context "when not available" do
-        let(:error_message) { "git had a sad" }
-        it "is reported" do
-          expect(Open3).to receive(:popen3).
-            with("git rev-parse HEAD").
-            and_return([
-              nil,                                                    # stdin
-              StringIO.new(),                                         # stdout
-              StringIO.new(error_message + "\n"),                     # stderr
-              double(value: double(Process::Status, success?: false)) # wait thread & process status
-            ])
-          get "/_ecg"
-          expect(json_body["git_revision"]["status"]).to eq("error")
-          expect(json_body["git_revision"]["value"]).to eq("git had a sad")
-        end
-      end
-    end
-
-    context "migration version" do
-      let(:options) {
-        { checks: [:migration_version] }
-      }
-      let(:connection) { double("connection") }
-      let(:version) { "123456" }
-
-      context "when available" do
-        it "is reported" do
-          class ActiveRecord
-            class Base
-              def self.connection
-              end
-            end
-          end
-          expect(ActiveRecord::Base).to receive(:connection).and_return(connection)
-          expect(connection).to receive(:select_value).
-            with("select max(version) from schema_migrations").
-            and_return(version)
-          get "/_ecg"
-          expect(json_body["migration_version"]["status"]).to eq("ok")
-          expect(json_body["migration_version"]["value"]).to eq(version)
-        end
-      end
-
-      context "when not available" do
-        it "is reported" do
-          Object.send(:remove_const, :ActiveRecord) if defined?(ActiveRecord)
-          get "/_ecg"
-          expect(json_body["migration_version"]["status"]).to eq("error")
-          expect(json_body["migration_version"]["value"]).to eq("ActiveRecord not found")
-        end
-      end
-    end
-
-    context "active_record" do
-      let(:options) {
-        { checks: [:active_record] }
-      }
-      context "when available" do
-        let(:active) { true }
-        let(:connection) { double("connection") }
-        it "is reported" do
-          class ActiveRecord
-            class Base
-              def self.connection
-              end
-            end
-          end
-          expect(ActiveRecord::Base).to receive(:connection).and_return(connection)
-          expect(connection).to receive(:active?).and_return(active)
-          get "/_ecg"
-          expect(json_body["active_record"]["status"]).to eq("ok")
-          expect(json_body["active_record"]["value"]).to eq(active.to_s)
-        end
-      end
-
-      context "when not available" do
-        it "is reported" do
-          Object.send(:remove_const, :ActiveRecord) if defined?(ActiveRecord)
-          get "/_ecg"
-          expect(json_body["active_record"]["status"]).to eq("error")
-          expect(json_body["active_record"]["value"]).to eq("ActiveRecord not found")
-        end
-      end
-    end
-
-    context "redis" do
-      let(:options) {
-        { checks: [:redis] }
-      }
-      context "when available" do
-        let(:instance) { double("current") }
-        let(:connected) { true }
-        it "is reported" do
-          class Redis
-            def self.current
-            end
-          end
-          expect(Redis).to receive(:current).and_return(instance)
-          expect(instance).to receive(:connected?).and_return(connected)
-          get "/_ecg"
-          expect(json_body["redis"]["status"]).to eq("ok")
-          expect(json_body["redis"]["value"]).to eq(connected.to_s)
-        end
-      end
-
-      context "when not available" do
-        it "is reported" do
-          Object.send(:remove_const, :Redis) if defined?(Redis)
-          get "/_ecg"
-          expect(json_body["redis"]["status"]).to eq("error")
-          expect(json_body["redis"]["value"]).to eq("Redis not found")
-        end
-      end
-    end
-
-    context "sequel" do
-      let(:options) {
-        { checks: [[:sequel, {name: 'My Awesome DB', connection: 'sqlite://'}]] }
-      }
-      let(:instance) { double("sequel_db") }
-
-      context "when available" do
-        it "is reported" do
-          class Sequel
-            def self.connect(_)
-            end
-          end
-          expect(Sequel).to receive(:connect).with('sqlite://').and_yield(instance)
-          expect(instance).to receive(:test_connection).and_return(true)
-          get "/_ecg"
-          expect(json_body["sequel_my_awesome_db"]["status"]).to eq("ok")
-          expect(json_body["sequel_my_awesome_db"]["value"]).to eq("true")
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,23 +0,0 @@
-require 'rspec'
-require 'rack/test'
-require 'rack/ecg'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.disable_monkey_patching!
-
-  config.warnings = true
-
-  config.include Rack::Test::Methods
-
-  def json_body
-    @json_body ||= JSON.parse(last_response.body)
-  end
-end