contrast-exceptional 0.0.1 → 0.0.6

data/spec/bootstrap_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe Exceptional::Bootstrap do
+
+
+  describe "setup" do
+
+    TEST_ENVIRONMENT= "development"
+
+    it "should initialize the config and log" do
+      Exceptional.should_receive(:setup_config)
+      Exceptional.should_receive(:setup_log)
+
+      Exceptional.bootstrap(TEST_ENVIRONMENT, File.dirname(__FILE__))
+    end
+
+    it "should authenticate if enabled" do
+      Exceptional.should_receive(:setup_config)
+      Exceptional.should_receive(:setup_log)
+      Exceptional.should_receive(:enabled?).and_return(true)
+      Exceptional.should_receive(:authenticate).and_return(true)
+      STDERR.should_not_receive(:puts) #Should be no errors to report
+
+      Exceptional.bootstrap(TEST_ENVIRONMENT, File.dirname(__FILE__))
+    end
+
+    it "should not authenticate if not enabled" do
+      Exceptional.should_receive(:setup_config)
+      Exceptional.should_receive(:setup_log)
+      Exceptional.should_receive(:enabled?).and_return(false)
+      Exceptional.should_not_receive(:authenticate)
+      STDERR.should_not_receive(:puts) # Will silently not enable itself
+
+
+      Exceptional.bootstrap(TEST_ENVIRONMENT, File.dirname(__FILE__))
+    end
+
+    it "should report to STDERR if authentication fails" do
+      Exceptional.should_receive(:setup_config)
+      Exceptional.should_receive(:setup_log)
+      Exceptional.should_receive(:enabled?).and_return(true)
+      Exceptional.should_receive(:authenticate).and_return(false)
+      STDERR.should_receive(:puts) #Should be no errors to report
+
+      Exceptional.bootstrap(TEST_ENVIRONMENT, File.dirname(__FILE__))
+    end
+
+    it "should report to STDERR if error during config initialization" do
+      Exceptional.should_receive(:setup_config).and_raise(Exceptional::Config::ConfigurationException)
+      Exceptional.should_not_receive(:setup_log)
+      Exceptional.should_not_receive(:authenticate).and_return(false)
+      STDERR.should_receive(:puts).twice() #Should be no errors to report
+
+      Exceptional.bootstrap(TEST_ENVIRONMENT, File.dirname(__FILE__))
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,110 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe Exceptional::Config do
+  
+  before(:all) do
+
+    def Exceptional.reset_state
+      @api_key = nil
+      @ssl_enabled = nil
+      @log_level = nil
+      @enabled = nil
+      @remote_port = nil
+      @remote_host = nil
+      @applicaton_root = nil
+    end
+    
+  end
+
+  after(:each) do
+    Exceptional.reset_state
+  end
+  
+  before(:each) do
+    Exceptional.stub!(:log!) # Don't even attempt to log
+    Exceptional.stub!(:to_log)  
+  end
+  
+  describe "default configuration" do
+    
+    it "should use port 80 by default if ssl not enabled" do
+      Exceptional.ssl_enabled?.should be_false
+      Exceptional.remote_port.should == 80
+    end
+
+    it "should use port 443 if ssl enabled" do
+      Exceptional.ssl_enabled= true
+      Exceptional.remote_port.should == 443
+      Exceptional.ssl_enabled= false
+    end
+
+    it "should use log level of info by default" do
+      Exceptional.log_level.should == "info"
+    end
+
+    it "should not be enabled by default" do
+      Exceptional.enabled?.should be_false
+    end
+
+    it "should overwrite default host" do
+      Exceptional.remote_host.should == "getexceptional.com"
+      Exceptional.remote_host = "localhost"
+      Exceptional.remote_host.should == "localhost"
+    end
+
+    it "should overwrite default port" do
+      Exceptional.remote_port.should == 80
+
+      Exceptional.remote_port = 3000
+      Exceptional.remote_port.should == 3000
+      Exceptional.remote_port = nil
+    end
+    
+    it "api_key should by default be in-valid" do
+      Exceptional.valid_api_key?.should be_false
+    end    
+  end
+
+  describe "load config" do
+
+    it "error during config file loading raises configuration exception" do
+      File.should_receive(:open).once.and_raise(IOError)
+      
+      lambda{Exceptional.setup_config("development", File.dirname(__FILE__))}.should raise_error(Exceptional::Config::ConfigurationException)
+    end
+
+    it "is enabled for production environment" do
+      Exceptional.enabled?.should be_false
+
+      Exceptional.setup_config "production", File.join(File.dirname(__FILE__), "/../exceptional.yml")
+      Exceptional.enabled?.should be_true
+    end
+
+    it "is enabled by default for production and staging environments" do
+      Exceptional.enabled?.should be_false
+
+      Exceptional.setup_config "production", File.join(File.dirname(__FILE__), "/../exceptional.yml")
+      Exceptional.enabled?.should be_true
+
+      Exceptional.reset_state
+      Exceptional.enabled?.should be_false
+
+      Exceptional.setup_config "staging", File.join(File.dirname(__FILE__), "/../exceptional.yml")
+      Exceptional.enabled?.should be_true
+    end
+
+    it "is disabled by default for development & test environments" do
+      Exceptional.enabled?.should be_false
+
+      Exceptional.setup_config "development", File.join(File.dirname(__FILE__), "/../exceptional.yml")
+      Exceptional.enabled?.should be_false
+
+      Exceptional.reset_state
+      Exceptional.enabled?.should be_false
+
+      Exceptional.setup_config "test", File.join(File.dirname(__FILE__), "/../exceptional.yml")
+      Exceptional.enabled?.should be_false
+    end            
+  end
+end

data/spec/exceptional_rescue_from_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'action_controller'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'exceptional', 'integration', 'rails')
+
+class MyException < Exception; end
+class SpecialException < Exception; end
+class RescueFromController < ActionController::Base
+  rescue_from MyException, :with => :my_handler 
+  
+  def my_handler
+    return 'test'
+  end
+  
+  def my_action
+    raise MyException
+  end
+  
+end
+
+describe "Exceptional with rescue_from() support" do
+  before(:each) do
+    @controller = RescueFromController.new
+  end
+
+  it "should not call Exceptional" do
+    @controller.should_receive(:rescue_action_without_exceptional).and_return(true)
+    if Gem::Requirement.create(">=2.2.0").satisfied_by?(Gem.loaded_specs['rails'].version)
+      Exceptional.should_not_receive(:handle)
+    else
+      Exceptional.should_receive(:handle)
+    end
+    @controller.send(:rescue_action, MyException.new("test")).should == true
+  end
+  
+  it "should call Exceptional" do
+    Exceptional.should_receive(:handle)
+    @controller.should_receive(:rescue_action_without_exceptional).and_return(true)
+    @controller.send(:rescue_action, SpecialException.new("test")).should == true
+  end
+  
+end

data/spec/exceptional_spec.rb

@@ -1,67 +1,25 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
+
 describe Exceptional do
-  
+
   describe "with no configuration" do
-    it "should connect to getexceptional.com by default" do
-      Exceptional.remote_host.should == "getexceptional.com"
-    end
-    
-    it "should connect to port 80 by default" do
-      Exceptional.remote_port.should == 80
+    before(:each) do
+      Exceptional.stub!(:to_stderr) # Don't print error when testing
     end
-    
-    it "should parse exception into exception data object" do
-     exception = mock(Exception, :message => "Something bad has happened", :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"])
-     exception_data = Exceptional.parse(exception)
-     exception_data.kind_of?(Exceptional::ExceptionData).should be_true
-     exception_data.exception_message.should == exception.message
-     exception_data.exception_backtrace.should == exception.backtrace
-     exception_data.exception_class.should == exception.class.to_s 
-    end
-    
-    it "should post exception" do
-      exception_data = mock(Exceptional::ExceptionData, :message => "Something bad has happened", :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"], :class => Exception)
-      Exceptional.should_receive(:call_remote, :with => [:errors, exception_data])
-      Exceptional.post(exception_data)
-    end
-    
-    it "should catch exception" do
-      exception = mock(Exception, :message => "Something bad has happened", :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"])
-      exception_data = mock(Exceptional::ExceptionData, :message => "Something bad has happened", :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"], :class => Exception)
-      Exceptional.should_receive(:parse, :with => [exception]).and_return(exception_data)
-      Exceptional.should_receive(:post, :with => [exception_data])
-      Exceptional.catch(exception)
-    end
-    
-    it "should raise a license exception if api key is not set" do
-      exception_data = mock(Exceptional::ExceptionData, :message => "Something bad has happened", :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"], :class => Exception)
+
+    it "should raise a remoting exception if not authenticated" do
+      exception_data = mock(Exceptional::ExceptionData,
+      :message => "Something bad has happened",
+      :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"],
+      :class => Exception,
+      :to_hash => { :message => "Something bad has happened" })
+
       Exceptional.api_key.should == nil
-      lambda { Exceptional.post(exception_data) }.should raise_error(Exceptional::LicenseException)    
-    end
-    
-  end
-  
-  describe "with a custom host" do
-    
-    it "should overwrite default host" do
-      Exceptional.remote_host = "localhost"
-      Exceptional.remote_host.should == "localhost"
-    end
-    
-    it "should overwrite default port" do
-      Exceptional.remote_port = 3000
-      Exceptional.remote_port.should == 3000
-      Exceptional.remote_port = nil
+      Exceptional.should_receive(:authenticated?).once.and_return(false)
+
+      lambda { Exceptional.post_exception(exception_data) }.should raise_error(Exceptional::Config::ConfigurationException)
     end
   end
   
-  describe "with ssl enabled" do
-    
-    it "should connect to port 443" do
-      Exceptional.ssl_enabled = true
-      Exceptional.remote_port.should == 443
-    end
-    
-  end
-end
+end

data/spec/log_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Exceptional::Log do
+
+  TEST_LOG_MESSAGE = "Test-log-message"
+
+  it "uninitialized should only log to STDERR" do
+    
+    STDERR.should_receive(:puts)
+    Logger.should_not_receive(:send)
+    Exceptional.log! TEST_LOG_MESSAGE
+  end
+
+  it "initialized should log to both STDERR and log file" do
+    
+    mock_log = mock("log")
+    mock_log.should_receive(:level=)
+    
+    Logger.should_receive(:new).and_return(mock_log)
+
+    Exceptional.setup_log File.dirname(File.join(File.dirname(__FILE__), ".."))
+    
+    Exceptional.log.should_receive(:send).with("info", TEST_LOG_MESSAGE)
+    STDERR.should_receive(:puts)
+
+    Exceptional.log! TEST_LOG_MESSAGE
+  end
+end

data/spec/remote_spec.rb

@@ -0,0 +1,137 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'net/http'
+
+describe Exceptional::Remote do
+
+  TEST_API_KEY = "TEST_API_KEY"
+
+  before(:all) do
+    def Exceptional.reset_state
+      @api_key = nil
+      @ssl_enabled = nil
+      @log_level = nil
+      @enabled = nil
+      @remote_port = nil
+      @remote_host = nil
+      @applicaton_root = nil
+    end
+
+    def Exceptional.reset_authentication
+      @authenticated = false
+    end
+  end
+
+  after(:each) do
+    Exceptional.reset_state
+    Exceptional.reset_authentication
+  end
+
+  describe "authentication" do
+
+    it "should not be authenticated if API authentication unsuccessful" do
+      Exceptional.api_key = TEST_API_KEY
+
+      Exceptional.authenticated?.should be_false
+      Exceptional.should_receive(:call_remote, {:method => "authenticate", :data => ""}).once.and_return("false")
+      Exceptional.authenticate.should be_false
+      Exceptional.authenticated?.should be_false
+    end
+
+    it "should not be authenticated if error during API authenticate" do
+      Exceptional.api_key = TEST_API_KEY
+
+      Exceptional.authenticated?.should be_false
+      Exceptional.should_receive(:call_remote, {:method => "authenticate", :data => ""}).once.and_raise(IOError)
+
+      Exceptional.authenticate.should be_false
+      Exceptional.authenticated?.should be_false
+    end
+
+    it "should not re-authenticate subsequently if 1 successful " do
+      Exceptional.api_key = TEST_API_KEY
+
+      Exceptional.authenticated?.should be_false
+      Exceptional.should_receive(:call_remote, {:method => "authenticate", :data => ""}).once.and_return("true")
+      # If authentication is successful, authenticate called only once
+
+      Exceptional.authenticate.should be_true
+      Exceptional.authenticated?.should be_true
+
+      Exceptional.authenticate.should be_true
+      Exceptional.authenticated?.should be_true
+    end
+
+    it "with no API Key set throws Configuration Exception" do
+      Exceptional.authenticated?.should be_false
+
+      lambda {Exceptional.authenticate}.should raise_error(Exceptional::Config::ConfigurationException)
+    end
+  end
+
+  describe "sending data " do
+
+    it "should return response body if successful" do
+
+      OK_RESPONSE_BODY = "OK-RESP-BODY"
+      
+      Exceptional.api_key = TEST_API_KEY
+      Exceptional.authenticated?.should be_false
+
+      Exceptional.should_receive(:authenticated?).once.and_return(true)
+
+      mock_http = mock(Net::HTTP)
+      Net::HTTP.should_receive(:new).with("getexceptional.com", 80).once.and_return(mock_http)
+
+      mock_http_response= mock(Net::HTTPSuccess)
+      mock_http_response.should_receive(:kind_of?).with(Net::HTTPSuccess).once.and_return(true)
+      mock_http_response.should_receive(:body).once.and_return(OK_RESPONSE_BODY)
+
+      mock_http.should_receive(:start).once.and_return(mock_http_response)
+
+      Exceptional.post_exception("data").should == OK_RESPONSE_BODY
+    end
+    
+    it "should raise error if network problem during sending exception" do
+
+      Exceptional.api_key = TEST_API_KEY
+      Exceptional.authenticated?.should be_false
+
+      Exceptional.should_receive(:authenticated?).once.and_return(true)
+
+      mock_http = mock(Net::HTTP)
+      Net::HTTP.should_receive(:new).with("getexceptional.com", 80).once.and_return(mock_http)
+
+      mock_http_response= mock(Net::HTTPSuccess)
+
+      mock_http.should_receive(:start).once.and_raise(IOError)
+
+      #surpress the logging of the exception
+      Exceptional.should_receive(:log!).twice
+
+      lambda{Exceptional.post_exception("data")}.should raise_error(IOError) 
+    end
+
+    it "should raise Exception if sending exception unsuccessful" do
+
+      Exceptional.api_key = TEST_API_KEY
+      Exceptional.authenticated?.should be_false
+
+      Exceptional.should_receive(:authenticated?).once.and_return(true)
+
+      mock_http = mock(Net::HTTP)
+      Net::HTTP.should_receive(:new).with("getexceptional.com", 80).once.and_return(mock_http)
+
+      mock_http_response= mock(Net::HTTPInternalServerError)
+      mock_http_response.should_receive(:kind_of?).with(Net::HTTPSuccess).once.and_return(false)
+      mock_http_response.should_receive(:code).once.and_return(501)
+      mock_http_response.should_receive(:message).once.and_return("Internal Server Error")
+
+      mock_http.should_receive(:start).once.and_return(mock_http_response)
+
+      #surpress the logging of the exception
+      Exceptional.should_receive(:log!).twice
+
+      lambda{Exceptional.post_exception("data")}.should raise_error(Exceptional::Remote::RemoteException) 
+    end    
+  end
+end