lib/exceptional/handler.rb spec/handler_spec.rb @@ -1,20 +1,2 @@ require 'exceptional' - - -def to_stderr(s) - STDERR.puts "** [Exceptional] " + s -end - -config_file = File.join(RAILS_ROOT,"/config/exceptional.yml") - -begin - Exceptional::Config.load_config(config_file, RAILS_ENV, RAILS_ROOT) - - if Exceptional::Config.enabled? - Exceptional.startup - end - -rescue Exception => e - to_stderr e - to_stderr "Plugin disabled." -end +Exceptional.setup(RAILS_ENV, RAILS_ROOT) \ No newline at end of file init.rb @@ -1,126 +1,39 @@ $:.unshift File.dirname(__FILE__) -require 'json' unless defined? Rails require 'exceptional/exception_data' require 'exceptional/version' require 'exceptional/log' require 'exceptional/config' require 'exceptional/remote' +require 'exceptional/handler' module Exceptional class << self - + include Exceptional::Config + include Exceptional::ExceptionalHandler + include Exceptional::Remote + include Exceptional::Log + # called from init.rb - def startup - Log.setup # need the log in place in case the authentication fails - - if Remote.authenticate - require File.join('exceptional', 'integration', 'rails') - Config.log_config_info - else - Log.log! "Exceptional plugin not authenticated, check your API Key" - Log.log! "Disabling Exceptional Plugin." - end - end - - # rescue any exceptions within the given block, - # send it to exceptional, - # then raise - def rescue(&block) + def setup(environment, application_root) begin - block.call + setup_config(environment, File.join(application_root,"config", "exceptional.yml")) + setup_log(File.join(application_root, "log"), log_level) + + if enabled? + if authenticate + require File.join('exceptional', 'integration', 'rails') + else + STDERR.puts "Exceptional plugin not authenticated, check your API Key" + end + end rescue Exception => e - self.catch(e) - raise(e) - end - end - - # parse an exception into an ExceptionData object - def parse(exception) - exception_data = ExceptionData.new - exception_data.exception_backtrace = exception.backtrace - exception_data.exception_message = exception.message - exception_data.exception_class = exception.class.to_s - exception_data - end - - # post the given exception data to getexceptional.com - def post(exception_data) - hash = exception_data.to_hash - if hash[:session] - hash[:session].delete("initialization_options") - hash[:session].delete("request") - end - - Remote.post_exception(hash.to_json) - end - - # given a regular ruby Exception class, will parse into an ExceptionData - # object and post to getexceptional.com - def catch(exception) - exception_data = parse(exception) - exception_data.controller_name = File.basename($0) - post(exception_data) - end - - # used with Rails, takes an exception, controller, request and parameters - # creates an ExceptionData object - # if Exceptional is running in :direct mode, will post to getexceptional.com - def handle(exception, controller, request, params) - Log.log! "Handling #{exception.message}", 'info' - begin - e = parse(exception) - # Additional data for Rails Exceptions - e.framework = "rails" - e.controller_name = controller.controller_name - e.action_name = controller.action_name - e.application_root = Config.application_root - e.occurred_at = Time.now.strftime("%Y%m%d %H:%M:%S %Z") - e.environment = request.env.to_hash - e.url = "#{request.protocol}#{request.host}#{request.request_uri}" - e.environment = safe_environment(request) - e.session = safe_session(request.session) - e.parameters = params.to_hash - - post(e) - rescue Exception => exception - Log.log! "Error preparing exception data." - Log.log! exception.message - Log.log! exception.backtrace.join("\n"), 'debug' + STDERR.puts e + STDERR.puts "Exceptional Plugin disabled." end end - - protected - - def safe_environment(request) - safe_environment = request.env.to_hash - # From Rails 2.3 these objects that cause a circular reference error on .to_json need removed - # TODO potentially remove this case, should be covered by sanitize_hash - safe_environment.delete_if { |k,v| k =~ /rack/ || k =~ /action_controller/ || k == "_" } - # needed to add a filter for the hash for "_", causing invalid xml. - sanitize_hash(safe_environment) - end - - def safe_session(session) - result = {} - session.instance_variables.each do |v| - next if v =~ /cgi/ || v =~ /db/ || v =~ /env/ - var = v.sub("@","") # remove prepended @'s - result[var] = session.instance_variable_get(v) - end - sanitize_hash(result) - end - - private - - # This (ironic) method sanitizes a hash by removing un-json-able objects from the passed in hash. - # needed as active_support's fails in some cases with a cyclical reference error. - def sanitize_hash(hash) - return {} if hash.nil? - Hash.from_xml(hash.to_xml)['hash'] - end end end \ No newline at end of file lib/exceptional.rb @@ -13,64 +13,62 @@ module Exceptional class ConfigurationException < StandardError; end - class << self - - attr_accessor :api_key, :application_root - attr_writer :remote_host, :remote_port, :ssl_enabled - - def load_config(file, environment, application_root) - begin - config = YAML::load(File.open(file))[environment] - @api_key = config['api-key'] unless config['api-key'].nil? - @ssl_enabled = config['ssl'] unless config['ssl'].nil? - @log_level = config['log-level'] unless config['log-level'].nil? - @enabled = config['enabled'] unless config['enabled'].nil? - @remote_port = config['remote-port'].to_i unless config['remote-port'].nil? - @remote_host = config['remote-host'] unless config['remote-host'].nil? - @applicaton_root = application_root - rescue Exception => e - raise ConfigurationException.new("Unable to load configuration file:#{file} for environment:#{environment}") - end - end - - def application_root - @applicaton_root || (File.dirname(__FILE__) + '/../..') + attr_reader :api_key + attr_writer :ssl_enabled, :remote_host, :remote_port, :api_key + + def setup_config(environment, config_file) + begin + config = YAML::load(File.open(config_file))[environment] + @api_key = config['api-key'] unless config['api-key'].nil? + @ssl_enabled = config['ssl'] unless config['ssl'].nil? + @log_level = config['log-level'] unless config['log-level'].nil? + @enabled = config['enabled'] unless config['enabled'].nil? + @remote_port = config['remote-port'].to_i unless config['remote-port'].nil? + @remote_host = config['remote-host'] unless config['remote-host'].nil? + @applicaton_root = application_root + + log_config_info + rescue Exception => e + raise ConfigurationException.new("Unable to load configuration #{config_file} for environment #{environment} : #{e.message}") end + end - def remote_host - @remote_host || REMOTE_HOST - end + def application_root + @applicaton_root || (File.dirname(__FILE__) + '/../..') + end - def remote_port - @remote_port || default_port - end + def remote_host + @remote_host || REMOTE_HOST + end - def log_level - @log_level || LOG_LEVEL - end + def remote_port + @remote_port || default_port + end - def default_port - ssl_enabled? ? REMOTE_SSL_PORT : REMOTE_PORT - end + def log_level + @log_level || LOG_LEVEL + end - def ssl_enabled? - @ssl_enabled || SSL - end + def default_port + ssl_enabled? ? REMOTE_SSL_PORT : REMOTE_PORT + end - def enabled? - @enabled || false - end + def ssl_enabled? + @ssl_enabled || SSL + end - def valid_api_key? - @api_key && @api_key.length == 40 ? true : false - end + def enabled? + @enabled || false + end - def log_config_info - Log.to_log('debug', "API Key: #{api_key}") - Log.to_log('debug', "Remote Host: #{remote_host}:#{remote_port}") - Log.to_log('debug', "Log level: #{log_level}") - end + def valid_api_key? + @api_key && @api_key.length == 40 ? true : false + end + def log_config_info + Exceptional.to_log('debug', "API Key: #{api_key}") + Exceptional.to_log('debug', "Remote Host: #{remote_host}:#{remote_port}") + Exceptional.to_log('debug', "Log level: #{log_level}") end end -end +end \ No newline at end of file lib/exceptional/config.rb @@ -32,15 +32,13 @@ module Exceptional hash = {} ::ATTRS.each do |attribute| value = send(attribute) - hash[attribute] = value unless (value.nil? || value.empty? || attribute.is_a?(TCPSocket) || attribute.is_a?(TCPServer)) + hash[attribute] = value unless (value.nil? || value.empty? || attribute.is_a?(TCPSocket) || attribute.is_a?(TCPServer)) end hash end def to_json self.to_hash.to_json - end - + end end - -end +end \ No newline at end of file lib/exceptional/exception_data.rb @@ -3,47 +3,45 @@ require 'logger' module Exceptional module Log - class <<self - attr_accessor :log, :log_path, :log_level - - def setup - begin - log_dir = File.join(Config.application_root, "log") - Dir.mkdir(log_dir) unless File.directory?(log_dir) - self.log_path = File.join(log_dir, "/exceptional.log") - - log = Logger.new log_path - log.level = Logger::INFO - - allowed_log_levels = ['debug', 'info', 'warn', 'error', 'fatal'] - if log_level && allowed_log_levels.include?(log_level) - log.level = eval("Logger::#{log_level.upcase}") - end - - self.log = log - rescue Exception => e - raise Config::ConfigurationException.new("Unable to create log file #{log_path}") + attr_reader :log + + def setup_log(log_dir, log_level = Logger::INFO) + begin + Dir.mkdir(log_dir) unless File.directory?(log_dir) + + log = Logger.new File.join(log_dir, "/exceptional.log") + log.level = log_level + + allowed_log_levels = ['debug', 'info', 'warn', 'error', 'fatal'] + if log_level && allowed_log_levels.include?(log_level) + log.level = eval("Logger::#{log_level.upcase}") end + @log = log + rescue Exception => e + raise Exceptional::Config::ConfigurationException.new("Unable to create log file #{log_path} ", e) end - - def format_log_message(msg) - "** [Exceptional] " + msg - end + end - def to_stderr(msg) - STDERR.puts format_log_message(msg) - end + def log!(msg, level = 'info') + to_log level, msg + to_stderr msg + end - def log!(msg, level = 'info') - to_stderr msg - to_log level, msg - end + def to_stderr(msg) + STDERR.puts format_log_message(msg) + end - def to_log(level, msg) - log.send level, msg if log - end + protected + + def to_log(level, msg) + @log.send level, msg if @log + end + + private + def format_log_message(msg) + "** [Exceptional] " + msg end end -end +end \ No newline at end of file lib/exceptional/log.rb @@ -9,69 +9,67 @@ module Exceptional ::PROTOCOL_VERSION = 3 - class << self + # authenticate with getexceptional.com + # returns true if the configured api_key is registered and can send data + # otherwise false + def authenticate - # authenticate with getexceptional.com - # returns true if the configured api_key is registered and can send data - # otherwise false - def authenticate - return @authenticated if @authenticated - - if Config.api_key.nil? - raise Exceptional::Config::ConfigurationException.new("API Key must be configured") - end + return @authenticated if @authenticated - begin - # TODO No data required to authenticate, send a nil string? hacky - # TODO should retry if a http connection failed - authenticated = call_remote(:authenticate, "") - @authenticated = authenticated =~ /true/ ? true : false - rescue - @authenticated = false - ensure - return @authenticated - end + if Exceptional.api_key.nil? + raise Exceptional::Config::ConfigurationException.new("API Key must be configured") end - def authenticated? - @authenticated || false + begin + # TODO No data required to authenticate, send a nil string? hacky + # TODO should retry if a http connection failed + authenticated = call_remote(:authenticate, "") + + @authenticated = authenticated =~ /true/ ? true : false + rescue + @authenticated = false + ensure + return @authenticated end + end - def post_exception(data) - if !authenticated? - raise RemoteException.new("Not Authenticated") - end + def authenticated? + @authenticated || false + end - call_remote(:errors, data) + def post_exception(data) + if !authenticated? + authenticate end - protected - - def call_remote(method, data) + call_remote(:errors, data) + end - begin - http = Net::HTTP.new(Config.remote_host, Config.remote_port) - http.use_ssl = true if Config.ssl_enabled? - uri = "/#{method.to_s}?&api_key=#{Config.api_key}&protocol_version=#{::PROTOCOL_VERSION}" - headers = method.to_s == 'errors' ? { 'Content-Type' => 'application/x-gzip', 'Accept' => 'application/x-gzip' } : {} + protected - compressed_data = CGI::escape(Zlib::Deflate.deflate(data, Zlib::BEST_SPEED)) - response = http.start do |http| - http.post(uri, compressed_data, headers) - end + def call_remote(method, data) + begin + http = Net::HTTP.new(Exceptional.remote_host, Exceptional.remote_port) + http.use_ssl = true if Exceptional.ssl_enabled? + uri = "/#{method.to_s}?&api_key=#{Exceptional.api_key}&protocol_version=#{::PROTOCOL_VERSION}" + headers = method.to_s == 'errors' ? { 'Content-Type' => 'application/x-gzip', 'Accept' => 'application/x-gzip' } : {} - if response.kind_of? Net::HTTPSuccess - return response.body - else - raise RemoteException.new("#{response.code}: #{response.message}") - end + compressed_data = CGI::escape(Zlib::Deflate.deflate(data, Zlib::BEST_SPEED)) + response = http.start do |http| + http.post(uri, compressed_data, headers) + end - rescue Exception => e - Exceptional::Log.log! "Error contacting Exceptional: #{e}", 'info' - Exceptional::Log.log! e.backtrace.join("\n"), 'debug' - raise e + if response.kind_of? Net::HTTPSuccess + return response.body + else + raise RemoteException.new("#{response.code}: #{response.message}") end + + rescue Exception => e + Exceptional.log! "Error contacting Exceptional: #{e}", 'info' + Exceptional.log! e.backtrace.join("\n"), 'debug' + raise e end end end -end +end \ No newline at end of file lib/exceptional/remote.rb @@ -4,9 +4,8 @@ require File.dirname(__FILE__) + '/spec_helper' describe Exceptional::Config do before(:all) do - config = Exceptional::Config - def config.reset_state + def Exceptional.reset_state @api_key = nil @ssl_enabled = nil @log_level = nil @@ -18,95 +17,87 @@ describe Exceptional::Config do end after(:each) do - Exceptional::Config.reset_state + Exceptional.reset_state end describe "default configuration" do it "should use port 80 by default if ssl not enabled" do - Exceptional::Config.ssl_enabled?.should be_false - Exceptional::Config.remote_port.should == 80 + Exceptional.ssl_enabled?.should be_false + Exceptional.remote_port.should == 80 end it "should use port 443 if ssl enabled" do - Exceptional::Config.ssl_enabled= true - Exceptional::Config.remote_port.should == 443 - Exceptional::Config.ssl_enabled= false + 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::Config.log_level.should == "info" + Exceptional.log_level.should == "info" end it "should not be enabled by default" do - Exceptional::Config.enabled?.should be_false + Exceptional.enabled?.should be_false end it "should overwrite default host" do - Exceptional::Config.remote_host.should == "getexceptional.com" - Exceptional::Config.remote_host = "localhost" - Exceptional::Config.remote_host.should == "localhost" + Exceptional.remote_host.should == "getexceptional.com" + Exceptional.remote_host = "localhost" + Exceptional.remote_host.should == "localhost" end it "should overwrite default port" do - Exceptional::Config.remote_port.should == 80 + Exceptional.remote_port.should == 80 - Exceptional::Config.remote_port = 3000 - Exceptional::Config.remote_port.should == 3000 - Exceptional::Config.remote_port = nil + 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::Config.valid_api_key?.should be_false - end - + 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) - - config_file = File.expand_path("exceptional.yml") - lambda{Exceptional::Config.load_config(config_file, "development", File.dirname(__FILE__))}.should raise_error(Exceptional::Config::ConfigurationException) + + lambda{Exceptional.setup_config("development", File.dirname(__FILE__))}.should raise_error(Exceptional::Config::ConfigurationException) end it "is enabled for production environment" do - Exceptional::Config.enabled?.should be_false + Exceptional.enabled?.should be_false - config_file = File.join(File.dirname(__FILE__),"../exceptional.yml") - Exceptional::Config.load_config config_file, "production", File.dirname(__FILE__) - Exceptional::Config.enabled?.should be_true + 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::Config.enabled?.should be_false - - config_file = File.join(File.dirname(__FILE__),"../exceptional.yml") + Exceptional.enabled?.should be_false - Exceptional::Config.load_config config_file, "production", File.dirname(__FILE__) - Exceptional::Config.enabled?.should be_true + Exceptional.setup_config "production", File.join(File.dirname(__FILE__), "/../exceptional.yml") + Exceptional.enabled?.should be_true - Exceptional::Config.reset_state - Exceptional::Config.enabled?.should be_false + Exceptional.reset_state + Exceptional.enabled?.should be_false - config_file = File.join(File.dirname(__FILE__),"../exceptional.yml") - Exceptional::Config.load_config config_file, "staging", File.dirname(__FILE__) - Exceptional::Config.enabled?.should be_true + 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::Config.enabled?.should be_false + Exceptional.enabled?.should be_false - config_file = File.join(File.dirname(__FILE__),"../exceptional.yml") - Exceptional::Config.load_config config_file, "development", File.dirname(__FILE__) - Exceptional::Config.enabled?.should be_false + Exceptional.setup_config "development", File.join(File.dirname(__FILE__), "/../exceptional.yml") + Exceptional.enabled?.should be_false - Exceptional::Config.reset_state - Exceptional::Config.enabled?.should be_false + Exceptional.reset_state + Exceptional.enabled?.should be_false - config_file = File.join(File.dirname(__FILE__),"../exceptional.yml") - Exceptional::Config.load_config config_file, "test", File.dirname(__FILE__) - Exceptional::Config.enabled?.should be_false + Exceptional.setup_config "test", File.join(File.dirname(__FILE__), "/../exceptional.yml") + Exceptional.enabled?.should be_false end end -end +end \ No newline at end of file spec/config_spec.rb @@ -1,44 +1,11 @@ require File.dirname(__FILE__) + '/spec_helper' + describe Exceptional do describe "with no configuration" do 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, :to_hash => { :message => "Something bad has happened" }) - Exceptional::Remote.should_receive(:authenticated?).once.and_return(true) - Exceptional::Remote.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, :to_hash => { :message => "Something bad has happened" }) - exception_data.should_receive(:controller_name=).with(File.basename($0)) - Exceptional.should_receive(:parse, :with => [exception]).and_return(exception_data) - Exceptional.should_receive(:post, :with => [exception_data]) - Exceptional.catch(exception) + Exceptional.stub!(:to_stderr) # Don't print error when testing end it "should raise a remoting exception if not authenticated" do @@ -48,93 +15,62 @@ describe Exceptional do :class => Exception, :to_hash => { :message => "Something bad has happened" }) - Exceptional::Config.api_key.should == nil - Exceptional::Remote.should_receive(:authenticated?).once.and_return(false) + Exceptional.api_key.should == nil + Exceptional.should_receive(:authenticated?).once.and_return(false) - lambda { Exceptional.post(exception_data) }.should raise_error(Exceptional::Remote::RemoteException) + lambda { Exceptional.post_exception(exception_data) }.should raise_error(Exceptional::Config::ConfigurationException) end - end - - describe "with helper methods" do - - it "safe_environment() should delete all rack related stuff from environment" do - request = mock(request, :env => { 'rack_var' => 'value', 'non_ack' => 'value2' }) - Exceptional.send(:safe_environment, request).should == { 'non_ack' => 'value2' } + + 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.setup(TEST_ENVIRONMENT, File.dirname(__FILE__)) end - - it "safe_session() should filter all /db/, /cgi/ variables and sub @ for blank" do - class SessionHelper - def initialize - @some_var = 1 - @cgi_var = 2 - @x_db = 3 - end - end - - session = SessionHelper.new - Exceptional.send(:safe_session, session).should == { 'some_var' => 1 } + + 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.setup(TEST_ENVIRONMENT, File.dirname(__FILE__)) end - - it "sanitize_hash() should sanitize cyclic problem for to_json" do - class MyClass - def initialize - @test = self - end - - def to_hash - { :test => self } - end - end - my_class = MyClass.new - - lambda { my_class.to_json }.should raise_error(ActiveSupport::JSON::CircularReferenceError) - Exceptional.send(:sanitize_hash, my_class.to_hash).to_json.should be_kind_of(String) + + 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.setup(TEST_ENVIRONMENT, File.dirname(__FILE__)) end - - end - - - describe "rescue" do - - it "should send exception data onto catch" do - Exceptional.should_receive(:catch) - lambda{ Exceptional.rescue do - raise IOError - end}.should raise_error(IOError) - + + 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.setup(TEST_ENVIRONMENT, File.dirname(__FILE__)) end - end - - describe "startup" do - - before(:all) do - log = Exceptional::Log - - def log.reset_state - @log = nil - 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.setup(TEST_ENVIRONMENT, File.dirname(__FILE__)) end - - after(:each) do - Exceptional::Log.reset_state - end - - it "should authenticate and initialize log" do - - Exceptional::Log.should_receive(:setup) - Exceptional::Remote.should_receive(:authenticate).once.and_return(true) - - Exceptional.startup - end - - it "should initialize log if authentication fails" do - - Exceptional::Log.should_receive(:setup) - Exceptional::Remote.should_receive(:authenticate).once.and_return(false) - - Exceptional.startup - end - end -end +end \ No newline at end of file spec/exceptional_spec.rb @@ -4,51 +4,20 @@ describe Exceptional::Log do TEST_LOG_MESSAGE = "Test-log-message" - before(:all) do - log = Exceptional::Log - - def log.reset_state - @log = nil - end - end - - after(:each) do - Exceptional::Log.reset_state - end - - - it "setup should initialize the log " do - Exceptional::Log.log.should be_nil - Exceptional::Log.setup - Exceptional::Log.log.should_not be_nil - end - - it "setup should raise Configuration Exception if unable to initialize the log" do - Exceptional::Log.log.should be_nil - - File.should_receive(:join).once.and_raise(IOError) - - lambda{Exceptional::Log.setup}.should raise_error(Exceptional::Config::ConfigurationException) - - Exceptional::Log.log.should be_nil - end - - it "should default to logging to 'info'" do - Exceptional::Log.setup - Exceptional::Log.log.should_not be_nil - - Exceptional::Log.log.should_receive(:send).with("info", TEST_LOG_MESSAGE) - Exceptional::Log.log! 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 "should log to both STDERR and log file" do - Exceptional::Log.setup - Exceptional::Log.log.should_not be_nil - - Exceptional::Log.log.should_receive(:send).with("info", TEST_LOG_MESSAGE) + it "initialized should log to both STDERR and log file" do + + 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.log! TEST_LOG_MESSAGE + Exceptional.log! TEST_LOG_MESSAGE end - end spec/log_spec.rb @@ -6,9 +6,7 @@ describe Exceptional::Remote do TEST_API_KEY = "TEST_API_KEY" before(:all) do - config = Exceptional::Config - - def config.reset_state + def Exceptional.reset_state @api_key = nil @ssl_enabled = nil @log_level = nil @@ -18,57 +16,55 @@ describe Exceptional::Remote do @applicaton_root = nil end - remoting = Exceptional::Remote - - def remoting.reset_authentication + def Exceptional.reset_authentication @authenticated = false end end after(:each) do - Exceptional::Config.reset_state - Exceptional::Remote.reset_authentication + Exceptional.reset_state + Exceptional.reset_authentication end describe "authentication" do it "should not be authenticated if API authentication unsuccessful" do - Exceptional::Config.api_key = TEST_API_KEY + Exceptional.api_key = TEST_API_KEY - Exceptional::Remote.authenticated?.should be_false - Exceptional::Remote.should_receive(:call_remote, {:method => "authenticate", :data => ""}).once.and_return("false") - Exceptional::Remote.authenticate.should be_false - Exceptional::Remote.authenticated?.should be_false + 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::Config.api_key = TEST_API_KEY + Exceptional.api_key = TEST_API_KEY - Exceptional::Remote.authenticated?.should be_false - Exceptional::Remote.should_receive(:call_remote, {:method => "authenticate", :data => ""}).once.and_raise(IOError) + Exceptional.authenticated?.should be_false + Exceptional.should_receive(:call_remote, {:method => "authenticate", :data => ""}).once.and_raise(IOError) - Exceptional::Remote.authenticate.should be_false - Exceptional::Remote.authenticated?.should be_false + Exceptional.authenticate.should be_false + Exceptional.authenticated?.should be_false end - it "should not re-authenticate subsequently if authenitcation successful " do - Exceptional::Config.api_key = TEST_API_KEY + it "should not re-authenticate subsequently if 1 successful " do + Exceptional.api_key = TEST_API_KEY - Exceptional::Remote.authenticated?.should be_false - Exceptional::Remote.should_receive(:call_remote, {:method => "authenticate", :data => ""}).once.and_return("true") + 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::Remote.authenticate.should be_true - Exceptional::Remote.authenticated?.should be_true + Exceptional.authenticate.should be_true + Exceptional.authenticated?.should be_true - Exceptional::Remote.authenticate.should be_true - Exceptional::Remote.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::Remote.authenticated?.should be_false + Exceptional.authenticated?.should be_false - lambda {Exceptional::Remote.authenticate}.should raise_error(Exceptional::Config::ConfigurationException) + lambda {Exceptional.authenticate}.should raise_error(Exceptional::Config::ConfigurationException) end end @@ -78,10 +74,10 @@ describe Exceptional::Remote do OK_RESPONSE_BODY = "OK-RESP-BODY" - Exceptional::Config.api_key = TEST_API_KEY - Exceptional::Remote.authenticated?.should be_false + Exceptional.api_key = TEST_API_KEY + Exceptional.authenticated?.should be_false - Exceptional::Remote.should_receive(:authenticated?).once.and_return(true) + 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) @@ -92,15 +88,15 @@ describe Exceptional::Remote do mock_http.should_receive(:start).once.and_return(mock_http_response) - Exceptional::Remote.post_exception("data").should == OK_RESPONSE_BODY + Exceptional.post_exception("data").should == OK_RESPONSE_BODY end it "should raise error if network problem during sending exception" do - Exceptional::Config.api_key = TEST_API_KEY - Exceptional::Remote.authenticated?.should be_false + Exceptional.api_key = TEST_API_KEY + Exceptional.authenticated?.should be_false - Exceptional::Remote.should_receive(:authenticated?).once.and_return(true) + 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) @@ -110,17 +106,17 @@ describe Exceptional::Remote do mock_http.should_receive(:start).once.and_raise(IOError) #surpress the logging of the exception - Exceptional::Log.should_receive(:log!).twice + Exceptional.should_receive(:log!).twice - lambda{Exceptional::Remote.post_exception("data")}.should raise_error(IOError) + lambda{Exceptional.post_exception("data")}.should raise_error(IOError) end it "should raise Exception if sending exception unsuccessful" do - Exceptional::Config.api_key = TEST_API_KEY - Exceptional::Remote.authenticated?.should be_false + Exceptional.api_key = TEST_API_KEY + Exceptional.authenticated?.should be_false - Exceptional::Remote.should_receive(:authenticated?).once.and_return(true) + 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) @@ -133,9 +129,9 @@ describe Exceptional::Remote do mock_http.should_receive(:start).once.and_return(mock_http_response) #surpress the logging of the exception - Exceptional::Log.should_receive(:log!).twice + Exceptional.should_receive(:log!).twice - lambda{Exceptional::Remote.post_exception("data")}.should raise_error(Exceptional::Remote::RemoteException) + lambda{Exceptional.post_exception("data")}.should raise_error(Exceptional::Remote::RemoteException) end end end spec/remote_spec.rb @@ -7,7 +7,7 @@ else end # TODO couple of different ways to test parts of exceptional with Rails (or a mock), reconcile them. -# require 'active_support' +#require 'active_support' # module Rails; end # Rails faker require File.dirname(__FILE__) + '/../lib/exceptional' spec/spec_helper.rb 51c601e4fc5ba36d7178b94cdcb97a0fc3c31dc2 wal walter.mcconnell@gmail.com http://github.com/contrast/exceptional/commit/ad37322f8d8c7a4b7fc2ef0dbfa2c5ec8fdee33c ad37322f8d8c7a4b7fc2ef0dbfa2c5ec8fdee33c 2009-03-22T07:15:00-07:00 2009-03-22T07:15:00-07:00 second phase plugin refactor dbc01a1db26ce16e71c12980da238f600e8e6c7c wal walter.mcconnell@gmail.com