tribune-is_it_working 1.0.9

data/spec/handler_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe IsItWorking::Handler do
+  
+  it "should lookup filters from the pre-defined checks" do
+    handler = IsItWorking::Handler.new do |h|
+      h.check :directory, :path => ".", :permissions => :read
+    end
+    response = handler.call({})
+    response.first.should == 200
+    response.last.flatten.join("").should include("OK")
+    response.last.flatten.join("").should include("directory")
+  end
+  
+  it "should use blocks as filters" do
+    handler = IsItWorking::Handler.new do |h|
+      h.check :block do |status|
+        status.ok("Okey dokey")
+      end
+    end
+    response = handler.call({})
+    response.first.should == 200
+    response.last.flatten.join("").should include("OK")
+    response.last.flatten.join("").should include("block - Okey dokey")
+  end
+  
+  it "should use object as filters" do
+    handler = IsItWorking::Handler.new do |h|
+      h.check :lambda, lambda{|status| status.ok("A-okay")}
+    end
+    response = handler.call({})
+    response.first.should == 200
+    response.last.flatten.join("").should include("OK")
+    response.last.flatten.join("").should include("lambda - A-okay")
+  end
+  
+  it "should create asynchronous filters by default" do
+    handler = IsItWorking::Handler.new do |h|
+      h.check :block do |status|
+        status.ok("Okey dokey")
+      end
+    end
+    runner = IsItWorking::Filter::AsyncRunner.new{}
+    IsItWorking::Filter::AsyncRunner.should_receive(:new).and_return(runner)
+    response = handler.call({})
+  end
+  
+  it "should be able to create synchronous filters" do
+    handler = IsItWorking::Handler.new do |h|
+      h.check :block, :async => false do |status|
+        status.ok("Okey dokey")
+      end
+    end
+    runner = IsItWorking::Filter::SyncRunner.new{}
+    IsItWorking::Filter::SyncRunner.should_receive(:new).and_return(runner)
+    response = handler.call({})
+  end
+  
+  it "should work with synchronous checks" do
+    handler = IsItWorking::Handler.new do |h|
+      h.check :block, :async => false do |status|
+        status.ok("Okey dokey")
+      end
+    end
+    response = handler.call({})
+    response.first.should == 200
+    response.last.flatten.join("").should include("OK")
+    response.last.flatten.join("").should include("block - Okey dokey")
+  end
+  
+  it "should return a success response if all checks pass" do
+    handler = IsItWorking::Handler.new do |h|
+      h.check :block do |status|
+        status.ok("success")
+      end
+      h.check :block do |status|
+        status.ok("worked")
+      end
+    end
+    response = handler.call({})
+    response.first.should == 200
+    response.last.flatten.join("").should include("block - success")
+    response.last.flatten.join("").should include("block - worked")
+  end
+  
+  it "should return an error response if any check fails" do
+    handler = IsItWorking::Handler.new do |h|
+      h.check :block do |status|
+        status.ok("success")
+      end
+      h.check :block do |status|
+        status.fail("down")
+      end
+    end
+    response = handler.call({})
+    response.first.should == 500
+    response.last.flatten.join("").should include("block - success")
+    response.last.flatten.join("").should include("block - down")
+  end
+  
+  it "should be able to be used in a middleware stack with the route /is_it_working" do
+    app_response = [200, {"Content-Type" => "text/plain"}, ["OK"]]
+    app = lambda{|env| app_response}
+    check_called = false
+    stack = IsItWorking::Handler.new(app) do |h|
+      h.check(:test){|status| check_called = true; status.ok("Woot!")}
+    end
+    
+    stack.call("PATH_INFO" => "/").should == app_response
+    check_called.should == false
+    stack.call("PATH_INFO" => "/is_it_working").last.flatten.join("").should include("Woot!")
+    check_called.should == true
+  end
+  
+  it "should be able to be used in a middleware stack with a custom route" do
+    app_response = [200, {"Content-Type" => "text/plain"}, ["OK"]]
+    app = lambda{|env| app_response}
+    check_called = false
+    stack = IsItWorking::Handler.new(app, "/woot") do |h|
+      h.check(:test){|status| check_called = true; status.ok("Woot!")}
+    end
+    
+    stack.call("PATH_INFO" => "/is_it_working").should == app_response
+    check_called.should == false
+    stack.call("PATH_INFO" => "/woot").last.flatten.join("").should include("Woot!")
+    check_called.should == true
+  end
+  
+  it "should be able to synchronize access to a block" do
+    handler = IsItWorking::Handler.new
+    handler.synchronize{1}.should == 1
+    handler.synchronize{2}.should == 2
+  end
+  
+  it "should be able to set the host name reported in the output" do
+    handler = IsItWorking::Handler.new
+    handler.hostname = "woot"
+    handler.call("PATH_INFO" => "/is_it_working").last.join("").should include("woot")
+  end
+end

data/spec/memecache_check_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe IsItWorking::MemcacheCheck do
+
+  let(:status){ IsItWorking::Status.new(:memcache) }
+  let(:memcache){ MemCache.new(['cache-1.example.com', 'cache-2.example.com']) }
+  let(:servers){ memcache.servers }
+  
+  it "should succeed if all servers are responding" do
+    check = IsItWorking::MemcacheCheck.new(:cache => memcache)
+    servers.first.should_receive(:socket).and_return(mock(:socket))
+    servers.last.should_receive(:socket).and_return(mock(:socket))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "cache-1.example.com:11211 is available"
+    status.messages.last.message.should == "cache-2.example.com:11211 is available"
+  end
+
+  it "should fail if any server is not responding" do
+    check = IsItWorking::MemcacheCheck.new(:cache => memcache)
+    servers.first.should_receive(:socket).and_return(mock(:socket))
+    servers.last.should_receive(:socket).and_return(nil)
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "cache-1.example.com:11211 is available"
+    status.messages.last.message.should == "cache-2.example.com:11211 is not available"
+  end
+
+  it "should be able to get the MemCache object from an ActiveSupport::Cache" do
+    require 'active_support/cache'
+    rails_cache = ActiveSupport::Cache::MemCacheStore.new(memcache)
+    check = IsItWorking::MemcacheCheck.new(:cache => rails_cache)
+    servers.first.should_receive(:socket).and_return(mock(:socket))
+    servers.last.should_receive(:socket).and_return(mock(:socket))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "cache-1.example.com:11211 is available"
+    status.messages.last.message.should == "cache-2.example.com:11211 is available"
+  end
+
+  it "should be able to alias the memcache host names in the output" do
+    check = IsItWorking::MemcacheCheck.new(:cache => memcache, :alias => "memcache")
+    servers.first.should_receive(:socket).and_return(mock(:socket))
+    servers.last.should_receive(:socket).and_return(mock(:socket))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "memcache 1 is available"
+    status.messages.last.message.should == "memcache 2 is available"
+  end
+  
+end

data/spec/ping_check_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe IsItWorking::PingCheck do
+
+  let(:status){ IsItWorking::Status.new(:ping) }
+
+  it "should succeed if the host is accepting connections on the specified port" do
+    server = TCPServer.new(51123)
+    begin
+      check = IsItWorking::PingCheck.new(:host => "localhost", :port => 51123)
+      check.call(status)
+      status.should be_success
+      status.messages.first.message.should == "localhost is accepting connections on port 51123"
+    ensure
+      server.close
+    end
+  end
+
+  it "should fail if the host is not accepting connections on the specified port" do
+    check = IsItWorking::PingCheck.new(:host => "localhost", :port => 51123)
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "localhost is not accepting connections on port 51123"
+  end
+
+  it "should fail if the host cannot be found" do
+    check = IsItWorking::PingCheck.new(:host => "127.0.0.256", :port => 51123)
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("failed")
+  end
+  
+  it "should fail if the server takes too long to respond" do
+    check = IsItWorking::PingCheck.new(:host => "127.0.0.255", :port => 51123, :timeout => 0.01)
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "127.0.0.255 did not respond on port 51123 within 0.01 seconds"
+  end
+
+  it "should be able to alias the host name in the output" do
+    check = IsItWorking::PingCheck.new(:host => "localhost", :port => 51123, :alias => "secret server")
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "secret server is not accepting connections on port 51123"
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+rescue LoadError
+  # simplecov not installed
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'is_it_working'))

data/spec/status_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe IsItWorking::Status do
+  
+  let(:status){ IsItWorking::Status.new(:test) }
+  
+  it "should have a name" do
+    status.name.should == :test
+  end
+  
+  it "should have errors" do
+    status.fail("boom")
+    status.should_not be_success
+    status.messages.size.should == 1
+    status.messages.first.should_not be_ok
+    status.messages.first.message.should == "boom"
+  end
+  
+  it "should have successes" do
+    status.ok("wow")
+    status.should be_success
+    status.messages.size.should == 1
+    status.messages.first.should be_ok
+    status.messages.first.message.should == "wow"
+  end
+  
+  it "should have both errors and successes" do
+    status.fail("boom")
+    status.ok("wow")
+    status.should_not be_success
+    status.messages.size.should == 2
+    status.messages.first.should_not be_ok
+    status.messages.first.message.should == "boom"
+    status.messages.last.should be_ok
+    status.messages.last.message.should == "wow"
+  end
+  
+  it "should have a time" do
+    status.time.should == nil
+    status.time = 0.1
+    status.time.should == 0.1
+  end
+  
+end

data/spec/url_check_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+require 'webmock/rspec'
+
+describe IsItWorking::UrlCheck do
+
+  before :all do
+    WebMock.disable_net_connect!
+  end
+
+  after :all do
+    WebMock.allow_net_connect!
+  end
+
+  after :each do
+    WebMock.reset!
+  end
+
+  let(:status){ IsItWorking::Status.new(:url) }
+
+  it "should succeed if the URL returns a 2xx response" do
+    stub_request(:get, "example.com/test?a=1").to_return(:status => [200, "Success"])
+    check = IsItWorking::UrlCheck.new(:get => "http://example.com/test?a=1")
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "GET http://example.com/test?a=1 responded with response '200 Success'"
+  end
+
+  it "should fail if the URL returns a 1xx response" do
+    stub_request(:get, "example.com/test?a=1").to_return(:status => [150, "Continue"])
+    check = IsItWorking::UrlCheck.new(:get => "http://example.com/test?a=1")
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "GET http://example.com/test?a=1 failed with response '150 Continue'"
+  end
+
+  it "should fail if the URL returns a 3xx response" do
+    stub_request(:get, "example.com/test?a=1").to_return(:status => [302, "Found"])
+    check = IsItWorking::UrlCheck.new(:get => "http://example.com/test?a=1")
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "GET http://example.com/test?a=1 failed with response '302 Found'"
+  end
+
+  it "should fail if the URL returns a 4xx response" do
+    stub_request(:get, "example.com/test?a=1").to_return(:status => [404, "Not Found"])
+    check = IsItWorking::UrlCheck.new(:get => "http://example.com/test?a=1")
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "GET http://example.com/test?a=1 failed with response '404 Not Found'"
+  end
+
+  it "should fail if the URL returns a 5xx response" do
+    stub_request(:get, "example.com/test?a=1").to_return(:status => [503, "Service Unavailable"])
+    check = IsItWorking::UrlCheck.new(:get => "http://example.com/test?a=1")
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "GET http://example.com/test?a=1 failed with response '503 Service Unavailable'"
+  end
+
+  it "should send basic authentication" do
+    stub_request(:get, "user:passwd@example.com/test?a=1").to_return(:status => [200, "Success"])
+    check = IsItWorking::UrlCheck.new(:get => "http://example.com/test?a=1", :username => "user", :password => "passwd")
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "GET http://example.com/test?a=1 responded with response '200 Success'"
+  end
+
+  it "should send headers with the request" do
+    stub_request(:get, "example.com/test?a=1").to_return(:status => [200, "Success"])
+    check = IsItWorking::UrlCheck.new(:get => "http://example.com/test?a=1", :headers => {"Accept-Encoding" => "gzip"})
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "GET http://example.com/test?a=1 responded with response '200 Success'"
+    WebMock.should have_requested(:get, "example.com/test?a=1").with(:headers => {"Accept-Encoding" => "gzip"})
+  end
+
+  it "should use SSL connection if URL is HTTPS" do
+    http = Net::HTTP.new('localhost')
+    Net::HTTP.should_receive(:new).with('localhost', 443).and_return(http)
+    request = Net::HTTP::Get.new("/test?a=1")
+    Net::HTTP::Get.should_receive(:new).with("/test?a=1", {}).and_return(request)
+    http.should_receive(:start).and_yield
+    http.should_receive(:request).with(request).and_return(Net::HTTPSuccess.new(nil, "200", "Success"))
+
+    check = IsItWorking::UrlCheck.new(:get => "https://localhost/test?a=1")
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "GET https://localhost/test?a=1 responded with response '200 Success'"
+    http.use_ssl?.should == true
+    http.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+  end
+
+  it "should be able to alias the URL in the output" do
+    stub_request(:get, "example.com/test").to_return(:status => [200, "Success"])
+    check = IsItWorking::UrlCheck.new(:get => "http://example.com/test", :alias => "service ping URL")
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "GET service ping URL responded with response '200 Success'"
+  end
+
+  it "should try to get the URL through a proxy" do
+    http = Net::HTTP.new('localhost')
+    Net::HTTP.should_receive(:Proxy).with('localhost', 8080, "user", "passwd").and_return(Net::HTTP)
+    Net::HTTP.should_receive(:new).with('localhost', 80).and_return(http)
+    request = Net::HTTP::Get.new("/test?a=1")
+    Net::HTTP::Get.should_receive(:new).with("/test?a=1", {}).and_return(request)
+    http.should_receive(:start).and_yield
+    http.should_receive(:request).with(request).and_return(Net::HTTPSuccess.new(nil, "200", "Success"))
+
+    check = IsItWorking::UrlCheck.new(:get => "http://localhost/test?a=1", :proxy => {:host => "localhost", :port => 8080, :username => "user", :password => "passwd"})
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "GET http://localhost/test?a=1 responded with response '200 Success'"
+  end
+
+  it "should set open and read timeouts" do
+    http = Net::HTTP.new('localhost')
+    Net::HTTP.should_receive(:new).with('localhost', 80).and_return(http)
+    request = Net::HTTP::Get.new("/test?a=1")
+    Net::HTTP::Get.should_receive(:new).with("/test?a=1", {}).and_return(request)
+    http.should_receive(:start).and_yield
+    http.should_receive(:request).with(request).and_return(Net::HTTPSuccess.new(nil, "200", "Success"))
+
+    check = IsItWorking::UrlCheck.new(:get => "http://localhost/test?a=1", :open_timeout => 1, :read_timeout => 2)
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "GET http://localhost/test?a=1 responded with response '200 Success'"
+    http.open_timeout.should == 1
+    http.read_timeout.should == 2
+  end
+
+  it "should fail on a timeout" do
+    http = Net::HTTP.new('localhost')
+    Net::HTTP.should_receive(:new).with('localhost', 80).and_return(http)
+    request = Net::HTTP::Get.new("/test?a=1")
+    Net::HTTP::Get.should_receive(:new).with("/test?a=1", {}).and_return(request)
+    http.should_receive(:start).and_raise(TimeoutError)
+
+    check = IsItWorking::UrlCheck.new(:get => "http://localhost/test?a=1", :open_timeout => 1, :read_timeout => 2)
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should match(/GET http:\/\/localhost\/test\?a=1 timed out after .* seconds/)
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: tribune-is_it_working
+version: !ruby/object:Gem::Version
+  version: 1.0.9
+platform: ruby
+authors:
+- Brian Durand
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: memcache-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dalli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tribune_gems
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rack handler for monitoring several parts of a web application so one
+  request can determine which system or dependencies are down.
+email:
+- bdurand@tribune.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- Rakefile
+- TRIBUNE_CODE
+- lib/is_it_working.rb
+- lib/is_it_working/checks/action_mailer_check.rb
+- lib/is_it_working/checks/active_record_check.rb
+- lib/is_it_working/checks/dalli_check.rb
+- lib/is_it_working/checks/directory_check.rb
+- lib/is_it_working/checks/memcache_check.rb
+- lib/is_it_working/checks/ping_check.rb
+- lib/is_it_working/checks/url_check.rb
+- lib/is_it_working/filter.rb
+- lib/is_it_working/handler.rb
+- lib/is_it_working/status.rb
+- spec/action_mailer_check_spec.rb
+- spec/active_record_check_spec.rb
+- spec/dalli_check_spec.rb
+- spec/directory_check_spec.rb
+- spec/filter_spec.rb
+- spec/handler_spec.rb
+- spec/memecache_check_spec.rb
+- spec/ping_check_spec.rb
+- spec/spec_helper.rb
+- spec/status_spec.rb
+- spec/url_check_spec.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--line-numbers"
+- "--inline-source"
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 3
+summary: Rack handler for monitoring several parts of a web application.
+test_files: []