is_it_working 1.0.10

data/spec/filter_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe IsItWorking::Filter do
+  
+  it "should have a name" do
+    filter = IsItWorking::Filter.new(:test, lambda{})
+    filter.name.should == :test
+  end
+  
+  it "should run a check and return a thread" do
+    check = lambda do |status|
+      status.ok("success")
+    end
+    
+    filter = IsItWorking::Filter.new(:test, check)
+    runner = filter.run
+    status = runner.filter_status
+    runner.join
+    status.should be_success
+    status.messages.first.message.should == "success"
+    status.time.should_not be_nil
+  end
+  
+  it "should run a check and recue an errors" do
+    check = lambda do |status|
+      raise "boom!"
+    end
+    
+    filter = IsItWorking::Filter.new(:test, check)
+    runner = filter.run
+    status = runner.filter_status
+    runner.join
+    status.should_not be_success
+    status.messages.first.message.should include("boom")
+    status.time.should_not be_nil
+  end
+  
+  it "should run multiple filters and return their statuses" do
+    filter_1 = IsItWorking::Filter.new(:test, lambda{|status| status.ok("OK")})
+    filter_2 = IsItWorking::Filter.new(:test, lambda{|status| status.fail("FAIL")})
+    statuses = IsItWorking::Filter.run_filters([filter_1, filter_2])
+    statuses.first.should be_success
+    statuses.last.should_not be_success
+  end
+  
+end

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