is_it_working-cbeer 1.0.11

data/lib/is_it_working/status.rb

@@ -0,0 +1,62 @@
+module IsItWorking
+  # This class is used to pass the status of a monitoring check. Each status can have multiple
+  # messages added to it by calling the +ok+ or +fail+ methods. The status check will only be
+  # considered a success if all messages are ok.
+  class Status
+    # This class is used to contain individual status messages. Eache method can represent either
+    # and +ok+ message or a +fail+ message.
+    class Message
+      class <<self
+        attr_accessor :ok_states
+      end
+
+      self.ok_states = [:ok, :info]
+
+      attr_reader :message
+      attr_reader :state
+
+
+      def initialize(message, state)
+        @message = message
+        @state = state
+      end
+
+      def ok?
+        self.class.ok_states.include? state
+      end
+    end
+
+    # The name of the status check for display purposes.
+    attr_reader :name
+
+    # The messages set on the status check.
+    attr_reader :messages
+
+    # The amount of time it takes to complete the status check.
+    attr_accessor :time
+
+    def initialize(name)
+      @name = name
+      @messages = []
+    end
+
+    # Add a message indicating that the check passed.
+    def ok(message)
+      @messages << Message.new(message, :ok)
+    end
+
+    def info(message)
+      @messages << Message.new(message, :info)
+    end
+
+    # Add a message indicating that the check failed.
+    def fail(message)
+      @messages << Message.new(message, :fail)
+    end
+
+    # Returns +true+ only if all checks were OK.
+    def success?
+      @messages.all?{|m| m.ok?}
+    end
+  end
+end

data/lib/is_it_working.rb

@@ -0,0 +1,18 @@
+require 'time'
+require 'thread'
+
+module IsItWorking
+  autoload :Check, File.expand_path("../is_it_working/check.rb", __FILE__)
+  autoload :Filter, File.expand_path("../is_it_working/filter.rb", __FILE__)
+  autoload :Handler, File.expand_path("../is_it_working/handler.rb", __FILE__)
+  autoload :Status, File.expand_path("../is_it_working/status.rb", __FILE__)
+  
+  # Predefined checks
+  autoload :ActionMailerCheck, File.expand_path("../is_it_working/checks/action_mailer_check.rb", __FILE__)
+  autoload :ActiveRecordCheck, File.expand_path("../is_it_working/checks/active_record_check.rb", __FILE__)
+  autoload :DalliCheck, File.expand_path("../is_it_working/checks/dalli_check.rb", __FILE__)
+  autoload :DirectoryCheck, File.expand_path("../is_it_working/checks/directory_check.rb", __FILE__)
+  autoload :MemcacheCheck, File.expand_path("../is_it_working/checks/memcache_check.rb", __FILE__)
+  autoload :PingCheck, File.expand_path("../is_it_working/checks/ping_check.rb", __FILE__)
+  autoload :UrlCheck, File.expand_path("../is_it_working/checks/url_check.rb", __FILE__)
+end

data/spec/action_mailer_check_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe IsItWorking::ActionMailerCheck do
+
+  let(:status){ IsItWorking::Status.new(:ping) }
+  
+  it "should succeed if the default mail host is accepting connections" do
+    ActionMailer::Base.smtp_settings[:address] = 'localhost'
+    ActionMailer::Base.smtp_settings[:port] = 25
+    TCPSocket.should_receive(:new).with('localhost', 25).and_return(mock(:socket, :close => true))
+    check = IsItWorking::ActionMailerCheck.new
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "ActionMailer::Base is accepting connections on port 25"
+  end
+  
+  it "should succeed if the default mail host is not accepting connections" do
+    ActionMailer::Base.smtp_settings[:address] = 'localhost'
+    ActionMailer::Base.smtp_settings[:port] = 25
+    TCPSocket.should_receive(:new).with('localhost', 25).and_raise(Errno::ECONNREFUSED)
+    check = IsItWorking::ActionMailerCheck.new
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "ActionMailer::Base is not accepting connections on port 25"
+  end
+  
+  it "should get the smtp configuration from a specified ActionMailer class" do
+    class IsItWorking::ActionMailerCheck::Tester < ActionMailer::Base
+    end
+    
+    IsItWorking::ActionMailerCheck::Tester.smtp_settings[:address] = 'mail.example.com'
+    IsItWorking::ActionMailerCheck::Tester.smtp_settings[:port] = 'smtp'
+    TCPSocket.should_receive(:new).with('mail.example.com', 'smtp').and_return(mock(:socket, :close => true))
+    check = IsItWorking::ActionMailerCheck.new(:class => IsItWorking::ActionMailerCheck::Tester)
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "IsItWorking::ActionMailerCheck::Tester is accepting connections on port \"smtp\""
+  end
+  
+  it "should allow aliasing the ActionMailer host alias" do
+    ActionMailer::Base.smtp_settings[:address] = 'localhost'
+    ActionMailer::Base.smtp_settings[:port] = 25
+    TCPSocket.should_receive(:new).with('localhost', 25).and_return(mock(:socket, :close => true))
+    check = IsItWorking::ActionMailerCheck.new(:alias => "smtp host")
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "smtp host is accepting connections on port 25"
+  end
+  
+  
+end

data/spec/active_record_check_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe IsItWorking::ActiveRecordCheck do
+
+  let(:status){ IsItWorking::Status.new(:active_record) }
+
+  class IsItWorking::TestActiveRecord < ActiveRecord::Base
+  end
+  
+  it "should succeed if the ActiveRecord connection is active" do
+    connection = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(mock(:connection))
+    connection.reconnect!
+    ActiveRecord::Base.stub!(:connection).and_return(connection)
+    check = IsItWorking::ActiveRecordCheck.new
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "ActiveRecord::Base.connection is active"
+  end
+  
+  it "should allow specifying the class to check the connection for" do
+    connection = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(mock(:connection))
+    connection.reconnect!
+    IsItWorking::TestActiveRecord.stub!(:connection).and_return(connection)
+    check = IsItWorking::ActiveRecordCheck.new(:class => IsItWorking::TestActiveRecord)
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "IsItWorking::TestActiveRecord.connection is active"
+  end
+
+  it "should succeed if the ActiveRecord connection can be reconnected" do
+    connection = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(mock(:connection))
+    connection.disconnect!
+    ActiveRecord::Base.stub!(:connection).and_return(connection)
+    check = IsItWorking::ActiveRecordCheck.new
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "ActiveRecord::Base.connection is active"
+  end
+
+  it "should fail if the ActiveRecord connection is not active" do
+    connection = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(mock(:connection))
+    connection.disconnect!
+    connection.stub!(:verify!)
+    ActiveRecord::Base.stub!(:connection).and_return(connection)
+    check = IsItWorking::ActiveRecordCheck.new
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "ActiveRecord::Base.connection is not active"
+  end
+  
+end

data/spec/dalli_check_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe IsItWorking::DalliCheck do
+
+  let(:status){ IsItWorking::Status.new(:memcache) }
+  let(:memcache){ Dalli::Client.new(['cache-1.example.com', 'cache-2.example.com']) }
+  let(:servers){ memcache.send(:ring).servers }
+
+  it "should succeed if all servers are responding" do
+    check = IsItWorking::DalliCheck.new(:cache => memcache)
+    servers.first.should_receive(:alive?).and_return(true)
+    servers.last.should_receive(:alive?).and_return(true)
+    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::DalliCheck.new(:cache => memcache)
+    servers.first.should_receive(:alive?).and_return(true)
+    servers.last.should_receive(:alive?).and_return(false)
+    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'
+    require 'active_support/cache/dalli_store'
+    ActiveSupport::Cache::DalliStore.should_receive(:new).with('cache-1.example.com', 'cache-2.example.com').and_return(memcache)
+    rails_cache = ActiveSupport::Cache::DalliStore.new('cache-1.example.com', 'cache-2.example.com')
+    check = IsItWorking::DalliCheck.new(:cache => rails_cache)
+    servers.first.should_receive(:alive?).and_return(true)
+    servers.last.should_receive(:alive?).and_return(true)
+    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::DalliCheck.new(:cache => memcache, :alias => "memcache")
+    servers.first.should_receive(:alive?).and_return(true)
+    servers.last.should_receive(:alive?).and_return(true)
+    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/directory_check_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe IsItWorking::DirectoryCheck do
+  
+  let(:status){ IsItWorking::Status.new(:directory) }
+  let(:directory_path){ File.expand_path(".") }
+  
+  it "should fail if a directory can't be found" do
+    check = IsItWorking::DirectoryCheck.new(:path => File.expand_path("../no_such_thing", __FILE__))
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("does not exist")
+  end
+  
+  it "should fail if a path isn't a directory" do
+    check = IsItWorking::DirectoryCheck.new(:path => __FILE__)
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("is not a directory")
+  end
+  
+  it "should succeed if a directory exists" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => false, :writable? => false))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should include("exists")
+  end
+  
+  it "should fail if a directory is not readable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => :read)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => false, :writable? => true))
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("is not readable")
+  end
+  
+  it "should fail if a directory is not writable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => :write)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => true, :writable? => false))
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("is not writable")
+  end
+  
+  it "should succeed if a directory exists and is readable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => :read)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => true, :writable? => false))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should include("exists with")
+  end
+  
+  it "should succeed if a directory exists and is writable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => :write)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => false, :writable? => true))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should include("exists with")
+  end
+  
+  it "should succeed if a directory exists and is readable and writable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => [:read, :write])
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => true, :writable? => true))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should include("exists with")
+  end
+  
+end

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,54 @@
+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.state.should == :fail
+    status.messages.first.message.should == "boom"
+  end
+  
+  it "should have successes" do
+    status.ok("wow")
+    status.should be_success
+    status.messages.first.state.should == :ok
+    status.messages.size.should == 1
+    status.messages.first.should be_ok
+    status.messages.first.message.should == "wow"
+  end
+
+  it "should have successes and infos" do
+    status.ok("wow")
+    status.info("fyi")
+    status.should be_success
+    status.messages.each { |x| x.should be_ok }
+    status.messages.last.state.should == :info
+  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