lilypad 0.2.4 → 0.3.0

data/spec/fixtures/sinatra.rb

@@ -1,6 +1,10 @@
+Sinatra::Base.set :raise_errors, false
+
 class SinatraApp < Sinatra::Base
   
-  use Rack::Lilypad, 'xxx'
+  use Rack::Lilypad, '' do
+    sinatra
+  end
   use TestExceptionMiddleware
   
   get "/nothing" do

data/spec/lilypad/adapters/rails_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path("#{File.dirname __FILE__}/../../spec_helper")
+
+describe Lilypad::Rails do
+
+  include Rack::Test::Methods
+  
+  def app
+    ActionController::Dispatcher.new
+  end
+  
+  describe :post do
+  
+    after(:each) do
+      ENV['RACK_ENV'] = 'production'
+    end
+    
+    before(:each) do
+      stub_net_http
+    end
+  
+    it "should post an error to Hoptoad" do
+      @http.should_receive(:post)
+      get "/test" rescue nil
+    end
+  
+    it "should post middleware exceptions" do
+      @http.should_receive(:post)
+      get "/nothing?test_exception=1" rescue nil
+    end
+  
+    it "should not post anything if non-production environment" do
+      ENV['RACK_ENV'] = 'development'
+      @http.should_not_receive(:post)
+      get "/test" rescue nil
+    end
+  end
+  
+  describe :RACK_ENV do
+    
+    before(:each) do
+      ENV['RACK_ENV'] = nil
+      ENV['RAILS_ENV'] = 'production'
+      ActionController::Base.send :include, Lilypad::Rails
+    end
+    
+    it "should set ENV['RACK_ENV']" do
+      ENV['RACK_ENV'].should == 'production'
+    end
+  end
+  
+  describe :rescue_action_without_handler do
+    
+    it "should set Config::Request.action" do
+      Lilypad::Config::Request.should_receive(:action).with('test')
+      get "/test" rescue nil
+    end
+    
+    it "should set Config::Request.component" do
+      Lilypad::Config::Request.should_receive(:component).with('application')
+      get "/test" rescue nil
+    end
+    
+    it "should re-raise the exception (ActionController::Failsafe disabled)" do
+      lambda { get "/test" }.should raise_error(TestError)
+    end
+  end
+end

data/spec/lilypad/adapters/sinatra_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path("#{File.dirname __FILE__}/../../spec_helper")
+
+describe Lilypad::Sinatra do
+  
+  include Rack::Test::Methods
+  
+  def app
+    SinatraApp.new
+  end
+  
+  describe :post do
+    
+    after(:each) do
+      ENV['RACK_ENV'] = 'production'
+    end
+  
+    before(:each) do
+      stub_net_http
+    end
+  
+    it "should post an error to Hoptoad" do
+      @http.should_receive(:post)
+      get "/test" rescue nil
+    end
+  
+    it "should post middleware exceptions" do
+      @http.should_receive(:post)
+      get "/nothing?test_exception=1" rescue nil
+    end
+  
+    it "should not post anything if non-production environment" do
+      ENV['RACK_ENV'] = 'development'
+      @http.should_not_receive(:post)
+      get "/test" rescue nil
+    end
+  end
+  
+  describe :raise_errors do
+    
+    it "should set raise_errors to true" do
+      get "/nothing"
+      Sinatra::Base.raise_errors?.should == true
+    end
+    
+    it "should re-raise the exception" do
+      lambda { get "/test" }.should raise_error(TestError)
+    end
+  end
+end

data/spec/lilypad/config/request_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path("#{File.dirname __FILE__}/../../spec_helper")
+
+describe Lilypad::Config::Request do
+
+  before(:each) do
+    Lilypad::Config::Request.action 'action'
+    Lilypad::Config::Request.component 'component'
+  end
+
+  after(:each) do
+    Lilypad::Config::Request.class_eval do
+      @action = nil
+      @component = nil
+    end
+  end
+
+  it "should set options" do
+    Lilypad::Config::Request.action.should == 'action'
+    Lilypad::Config::Request.component.should == 'component'
+  end
+
+  it "should provide a method to reset all options" do
+    Lilypad::Config::Request.reset!
+    Lilypad::Config::Request.action.should == nil
+    Lilypad::Config::Request.component.should == nil
+  end
+end

data/spec/lilypad/config_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path("#{File.dirname __FILE__}/../spec_helper")
+
+describe Lilypad::Config do
+
+  before(:each) do
+    Lilypad::Config.api_key 'api_key'
+    Lilypad::Config.deploy_url 'deploy_url'
+    Lilypad::Config.environments 'environments'
+    Lilypad::Config.filters 'filters'
+    Lilypad::Config.log 'log'
+    Lilypad::Config.notify_url 'notify_url'
+  end
+
+  after(:each) do
+    Lilypad::Config.class_eval do
+      @api_key = nil
+      @deploy_url = nil
+      @environments = nil
+      @filters = nil
+      @log = nil
+      @notify_url = nil
+    end
+  end
+
+  it "should set options" do
+    Lilypad::Config.api_key.should == 'api_key'
+    Lilypad::Config.deploy_url.should == 'deploy_url'
+    Lilypad::Config.environments.should == 'environments'
+    Lilypad::Config.filters.should == 'filters'
+    Lilypad::Config.log.should == 'log'
+    Lilypad::Config.notify_url.should == 'notify_url'
+  end
+  
+  it "should require the rails adapter when the rails method is called" do
+    adapter = File.expand_path "#{SPEC}/../lib/lilypad/adapters/rails"
+    Lilypad::Config.should_receive(:require).with(adapter)
+    Lilypad::Config.rails
+  end
+  
+  it "should require the rails adapter when the sinatra method is called" do
+    adapter = File.expand_path "#{SPEC}/../lib/lilypad/adapters/sinatra"
+    Lilypad::Config.should_receive(:require).with(adapter)
+    Lilypad::Config.sinatra
+  end
+  
+  describe :Methods do
+    
+    include Lilypad::Config::Methods
+    
+    it "should provide an api_key method" do
+      Lilypad::Config.api_key 'api_key'
+      api_key.should == 'api_key'
+      Lilypad::Config.api_key { |env, e| [ env, e ].join '_' }
+      api_key.should == 'api_key' # api string takes precedence even when block configured
+      Lilypad::Config.class_eval { @api_key = nil }
+      api_key('api_key', 'block').should == 'api_key_block' # string is nil, now use the block
+    end
+  end
+end

data/spec/lilypad/hoptoad/deploy_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path("#{File.dirname __FILE__}/../../spec_helper")
+
+describe Lilypad::Hoptoad::Deploy do
+  
+  before(:each) do
+    stub_net_http
+    @options = {
+      :username => 'username',
+      :environment => 'environment',
+      :revision => 'revision',
+      :repository => 'repository'
+    }
+    @instance = Lilypad::Hoptoad::Deploy.new(@options)
+  end
+  
+  describe :initialize do
+    
+    after(:each) do
+      @instance.send(:initialize, @options)
+    end
+    
+    it "should call the post method" do
+      @instance.should_receive(:post)
+    end
+    
+    it "should log the event" do
+      @instance.should_receive(:log).with(:deploy, @http_ok)
+    end
+    
+    it "should return the success status" do
+      @instance.should_receive(:success?)
+    end
+  end
+  
+  describe :params do
+    
+    before(:each) do
+      Lilypad { api_key '' }
+    end
+    
+    it "should return parameters for the Hoptoad request" do
+      @instance.send(:params).should == {
+        'api_key' => '',
+        'deploy[local_username]' => @options[:username],
+        'deploy[rails_env]' => @options[:environment],
+        'deploy[scm_revision]' => @options[:revision],
+        'deploy[scm_repository]' => @options[:repository]
+      }
+    end
+  end
+  
+  describe :post do
+    
+    before(:each) do
+      URI.stub!(:parse).and_return('uri')
+      @instance.stub!(:params).and_return('params')
+    end
+    
+    after(:each) do
+      @instance.send(:post)
+    end
+    
+    it "should parse the URI" do
+      URI.should_receive(:parse).with(Lilypad::Config.deploy_url)
+    end
+    
+    it "should post the form using the URI and params method" do
+      @instance.should_receive(:params)
+      Net::HTTP.should_receive(:post_form).with('uri', 'params')
+    end
+  end
+  
+  describe :success? do
+    
+    it "should make sure the response's superclass equals Net::HTTPSuccess" do
+      Net::HTTP.stub!(:post_form).and_return(nil)
+      @instance.send(:initialize, @options)
+      @instance.send(:success?).should == false
+      
+      Net::HTTP.stub!(:post_form).and_return(@http_ok)
+      @instance.send(:initialize, @options)
+      @instance.send(:success?).should == true
+    end
+  end
+end

data/spec/lilypad/hoptoad/notify_spec.rb

@@ -0,0 +1,138 @@
+require File.expand_path("#{File.dirname __FILE__}/../../spec_helper")
+
+describe Lilypad::Hoptoad::Notify do
+  
+  before(:each) do
+    uri = mock(:uri)
+    uri.stub!(:host)
+    uri.stub!(:port)
+    uri.stub!(:path).and_return('uri')
+    URI.stub!(:parse).and_return(uri)
+    stub_net_http
+    begin; raise 'Test'; rescue Exception => e; @e = e; end
+    @instance = Lilypad::Hoptoad::Notify.new(nil, @e)
+  end
+  
+  describe :initialize do
+    
+    before(:each) do
+      Lilypad::Hoptoad::XML.stub!(:build).and_return('xml')
+      @instance.stub!(:headers).and_return 'headers'
+      @instance.stub!(:parse).and_return ['parse']
+    end
+    
+    after(:each) do
+      @instance.send(:initialize, nil, @e)
+    end
+    
+    it "should build XML from parse method" do
+      Lilypad::Hoptoad::XML.should_receive(:build).with('parse')
+    end
+    
+    it "should post the XML" do
+      @http.should_receive(:post).with('uri', 'xml', 'headers')
+    end
+    
+    it "should log the event" do
+      @instance.should_receive(:log).with(:notify, @http_ok)
+    end
+    
+    it "should reset the request config" do
+      Lilypad::Config::Request.should_receive(:reset!)
+    end
+    
+    it "should return the success status" do
+      @instance.should_receive(:success?)
+    end
+  end
+  
+  describe :backtrace do
+    
+    it "should return an array of backtrace information" do
+      backtrace = @instance.send(:backtrace)
+      backtrace.first.file.should =~ /notify_spec/
+      backtrace.first.respond_to?(:number).should == true
+      backtrace.first.respond_to?(:method).should == true
+      backtrace.length.should > 1
+    end
+  end
+  
+  describe :filter do
+    
+    after(:each) do
+      Lilypad { filters [] }
+    end
+    
+    it "should remove elements of a hash for keys that match an element Config.filters" do
+      Lilypad { filters [ 't1' ] }
+      filtered = @instance.send(:filter, { :t1 => 't1', :t2 => 't2' })
+      filtered.should == { :t1 => '[FILTERED]', :t2 => 't2' }
+    end
+  end
+  
+  describe :http_start do
+    
+    after(:each) do
+      @instance.send(:http_start) {}
+    end
+    
+    it "should get a URI instance for the notify URL" do
+      URI.should_receive(:parse).with(Lilypad::Config.notify_url)
+    end
+    
+    it "should call start on Net::HTTP" do
+      Net::HTTP.should_receive(:start)
+    end
+    
+    it "should yield to the block" do
+      yielded = false
+      @instance.send(:http_start) { yielded = true }
+      yielded.should == true
+    end
+  end
+  
+  describe :parse do
+    
+    before(:each) do
+      @env = mock(:env)
+      @env.stub!(:merge).and_return('env')
+      ENV.stub!(:to_hash).and_return(@env)
+      @instance.stub!(:filter).and_return('env')
+      @instance.stub!(:backtrace).and_return('backtrace')
+    end
+    
+    it "should filter the environment" do
+      @instance.should_receive(:filter).with('env')
+      ENV.should_receive(:to_hash)
+      @env.should_receive(:merge)
+      @instance.send(:parse)
+    end
+    
+    it "should return the correct parameters without an environment" do
+      @instance.send(:parse).should == [ "backtrace", "env", @e, {}, "Internal" ]
+    end
+    
+    it "should return the correct parameters with an environment" do
+      request = mock(:request)
+      request.stub!(:params)
+      request.stub!(:script_name).and_return 'request_'
+      request.stub!(:path_info).and_return 'path'
+      Rack::Request.stub!(:new).and_return(request)
+      @instance.send(:initialize, {}, @e)
+      @instance.send(:parse).should == ["backtrace", "env", @e, "env", "request_path"]
+    end
+  end
+  
+  describe :success? do
+    
+    it "should make sure the response's superclass equals Net::HTTPSuccess" do
+      @http.stub!(:post).and_return(nil)
+      @instance.send(:initialize, nil, @e)
+      @instance.send(:success?).should == false
+      
+      @http.stub!(:post).and_return(@http_ok)
+      @instance.send(:initialize, nil, @e)
+      @instance.send(:success?).should == true
+    end
+  end
+end

data/spec/lilypad_spec.rb

@@ -0,0 +1,76 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe Rack::Lilypad do
+
+  include Rack::Test::Methods
+  
+  before(:each) do
+    @app = lambda { |env| raise TestError, 'Test' }
+    @env = Rack::MockRequest.env_for("/test")
+    stub_net_http
+  end
+  
+  it "should yield a configuration object to the block when created" do
+    Rack::Lilypad.new(@app, '') do
+      filters %w(T1 T2)
+      log 'T3'
+    end
+    Lilypad::Config.filters.include?('T1').should == true
+    Lilypad::Config.filters.include?('T2').should == true
+    Lilypad::Config.log.should == 'T3'
+    
+    Lilypad::Config.filters []
+    Lilypad::Config.log false
+  end
+  
+  it "should write to a log file on success and failure" do
+    log_path = "#{SPEC}/fixtures/hoptoad.log"
+    notifier = Rack::Lilypad.new(@app, '') do |app|
+      log log_path
+    end
+    
+    notifier.call(@env) rescue nil
+    
+    File.exists?(log_path).should == true
+    File.read(log_path).should =~ /Notify Success/
+    File.delete(log_path)
+    
+    @http.stub!(:post).and_return false
+    notifier.call(@env) rescue nil
+    
+    File.exists?(log_path).should == true
+    File.read(log_path).should =~ /Notify Failure/
+    File.delete(log_path)
+    
+    Lilypad::Config.log false
+  end
+  
+  it "should transfer valid XML to Hoptoad" do
+    # Test complex environment variables
+    @env['rack.hash_test'] = { :test => true }
+    @env['rack.object_test'] = Object.new
+    
+    notifier = Rack::Lilypad.new(@app, '')
+    notifier.call(@env) rescue nil
+    validate_xml
+  end
+  
+  it "should provide a notify method" do
+    @http.should_receive(:post)
+    begin
+      raise TestError, 'Test'
+    rescue Exception => e
+      Lilypad.notify(e)
+    end
+  end
+  
+  it "should provide a deploy method" do
+    Net::HTTP.should_receive(:post_form)
+    Lilypad.deploy(
+      :username => 't1',
+      :environment => 't2',
+      :revision => 't3',
+      :repository => 't4'
+    )
+  end
+end