honeybadger 1.8.1 → 1.9.0.beta1

data/test/unit/honeybadger_tasks_test.rb

@@ -1,167 +0,0 @@
-require 'test_helper'
-require 'rubygems'
-
-require File.expand_path('../../../lib/honeybadger_tasks', __FILE__)
-require 'fakeweb'
-
-FakeWeb.allow_net_connect = false
-
-class HoneybadgerTasksTest < Test::Unit::TestCase
-  def successful_response(body = "")
-    response = Net::HTTPSuccess.new('1.2', '200', 'OK')
-    response.stubs(:body).returns(body)
-    return response
-  end
-
-  def unsuccessful_response(body = "")
-    response = Net::HTTPClientError.new('1.2', '200', 'OK')
-    response.stubs(:body).returns(body)
-    return response
-  end
-
-  context "being quiet" do
-    setup { HoneybadgerTasks.stubs(:puts) }
-
-    context "in a configured project" do
-      setup { Honeybadger.configure { |config| config.api_key = "1234123412341234" } }
-
-      context "on deploy({})" do
-        setup { @output = HoneybadgerTasks.deploy({}) }
-
-        before_should "complain about missing rails env" do
-          HoneybadgerTasks.expects(:puts).with(regexp_matches(/which environment/i))
-        end
-
-        should "return false" do
-          assert !@output
-        end
-      end
-
-      context "given an optional HTTP proxy and valid options" do
-        setup do
-          @response         = stub("response",    :body => "stub body")
-          @http_proxy       = stub("proxy",       :request => @response,
-                                                  :use_ssl= => nil,
-                                                  :ca_file= => nil,
-                                                  :verify_mode= => nil)
-          @http_proxy_class = stub("proxy_class", :new => @http_proxy)
-          @post             = stub("post",        :set_form_data => nil)
-
-          @post.stubs(:[]=).with('X-API-Key', '1234123412341234').returns(true)
-
-          Net::HTTP.expects(:Proxy).
-            with(Honeybadger.configuration.proxy_host,
-                 Honeybadger.configuration.proxy_port,
-                 Honeybadger.configuration.proxy_user,
-                 Honeybadger.configuration.proxy_pass).
-                 returns(@http_proxy_class)
-          Net::HTTP::Post.expects(:new).with("/v1/deploys").returns(@post)
-
-          @options    = { :environment => "staging", :dry_run => false }
-        end
-
-        context "performing a dry run" do
-          setup { @output = HoneybadgerTasks.deploy(@options.merge(:dry_run => true)) }
-
-          should "return true without performing any actual request" do
-            assert_equal true, @output
-            assert_received(@http_proxy, :request) do |expects|
-              expects.never
-            end
-          end
-        end
-
-        context "on deploy(options)" do
-          setup do
-            @output = HoneybadgerTasks.deploy(@options)
-          end
-
-          before_should "post to https://api.honeybadger.io:443/v1/deploys" do
-            @http_proxy_class.expects(:new).with("api.honeybadger.io", 443).returns(@http_proxy)
-            @post.expects(:set_form_data).with(kind_of(Hash))
-            @http_proxy.expects(:request).with(any_parameters).returns(successful_response)
-          end
-
-          before_should "use send the environment param" do
-            @post.expects(:set_form_data).
-              with(has_entries("deploy[environment]" => "staging"))
-          end
-
-          [:local_username, :repository, :revision].each do |key|
-            before_should "use send the #{key} param if it's passed in." do
-              @options[key] = "value"
-              @post.expects(:set_form_data).
-                with(has_entries("deploy[#{key}]" => "value"))
-            end
-          end
-
-          before_should "puts the response body on success" do
-            HoneybadgerTasks.expects(:puts).with("Succesfully recorded deployment")
-            @http_proxy.expects(:request).with(any_parameters).returns(successful_response('body'))
-          end
-
-          before_should "puts the response body on failure" do
-            HoneybadgerTasks.expects(:puts).with("body")
-            @http_proxy.expects(:request).with(any_parameters).returns(unsuccessful_response('body'))
-          end
-
-          should "return false on failure", :before => lambda {
-            @http_proxy.expects(:request).with(any_parameters).returns(unsuccessful_response('body'))
-          } do
-            assert !@output
-          end
-
-          should "return true on success", :before => lambda {
-            @http_proxy.expects(:request).with(any_parameters).returns(successful_response('body'))
-          } do
-            assert @output
-          end
-        end
-      end
-    end
-
-    context "in a configured project with custom host" do
-      setup do
-        Honeybadger.configure do |config|
-          config.api_key = "1234123412341234"
-          config.host = "custom.host"
-          config.secure = false
-        end
-      end
-
-      context "on deploy(:environment => 'staging')" do
-        setup { @output = HoneybadgerTasks.deploy(:environment => "staging") }
-
-        before_should "post to the custom host" do
-          @post             = stub("post",     :set_form_data => nil)
-          @http_proxy       = stub("proxy",    :request => @response)
-
-          @post.stubs(:[]=).with('X-API-Key', '1234123412341234').returns(true)
-
-          @http_proxy_class = stub("proxy_class", :new => @http_proxy)
-          @http_proxy_class.expects(:new).with("custom.host", 80).returns(@http_proxy)
-          Net::HTTP.expects(:Proxy).with(any_parameters).returns(@http_proxy_class)
-          Net::HTTP::Post.expects(:new).with("/v1/deploys").returns(@post)
-          @post.expects(:set_form_data).with(kind_of(Hash))
-          @http_proxy.expects(:request).with(any_parameters).returns(successful_response)
-        end
-      end
-    end
-
-    context "when not configured" do
-      setup { Honeybadger.configure { |config| config.api_key = "" } }
-
-      context "on deploy(:environment => 'staging')" do
-        setup { @output = HoneybadgerTasks.deploy(:environment => "staging") }
-
-        before_should "complain about missing api key" do
-          HoneybadgerTasks.expects(:puts).with(regexp_matches(/api key/i))
-        end
-
-        should "return false" do
-          assert !@output
-        end
-      end
-    end
-  end
-end

data/test/unit/logger_test.rb

@@ -1,74 +0,0 @@
-require 'test_helper'
-
-class LoggerTest < Test::Unit::TestCase
-  def stub_http(response, body = nil)
-    response.stubs(:body => body) if body
-    @http = stub(:post => response,
-                 :read_timeout= => nil,
-                 :open_timeout= => nil,
-                 :use_ssl= => nil,
-                 :ca_file= => nil,
-                 :verify_mode= => nil)
-    Net::HTTP.stubs(:new).returns(@http)
-  end
-
-  def send_notice
-    Honeybadger.sender.send_to_honeybadger('data')
-  end
-
-  def stub_verbose_log
-    Honeybadger.stubs(:write_verbose_log)
-  end
-
-  def configure
-    Honeybadger.configure { |config| }
-  end
-
-  should "report that notifier is ready when configured" do
-    stub_verbose_log
-    configure
-    assert_logged /Notifier (.*) ready/
-  end
-
-  should "not report that notifier is ready when internally configured" do
-    stub_verbose_log
-    Honeybadger.configure(true) { |config| }
-    assert_not_logged /.*/
-  end
-
-  should "print environment info a successful notification without a body" do
-    reset_config
-    stub_verbose_log
-    stub_http(Net::HTTPSuccess)
-    send_notice
-    assert_logged /Environment Info:/
-    assert_not_logged /Response from Honeybadger:/
-  end
-
-  should "print environment info on a failed notification without a body" do
-    reset_config
-    stub_verbose_log
-    stub_http(Net::HTTPError)
-    send_notice
-    assert_logged /Environment Info:/
-    assert_not_logged /Response from Honeybadger:/
-  end
-
-  should "print environment info and response on a success with a body" do
-    reset_config
-    stub_verbose_log
-    stub_http(Net::HTTPSuccess, '{}')
-    send_notice
-    assert_logged /Environment Info:/
-    assert_logged /Response from Honeybadger:/
-  end
-
-  should "print environment info and response on a failure with a body" do
-    reset_config
-    stub_verbose_log
-    stub_http(Net::HTTPError, '{}')
-    send_notice
-    assert_logged /Environment Info:/
-    assert_logged /Response from Honeybadger:/
-  end
-end

data/test/unit/notifier_test.rb

@@ -1,265 +0,0 @@
-require 'test_helper'
-
-class NotifierTest < Test::Unit::TestCase
-  class OriginalException < Exception
-  end
-
-  class ContinuedException < Exception
-  end
-
-  def setup
-    super
-    reset_config
-  end
-
-  def assert_sent(notice, notice_args)
-    assert_received(Honeybadger::Notice, :new) {|expect| expect.with(has_entries(notice_args)) }
-    assert_received(Honeybadger.sender, :send_to_honeybadger) {|expect| expect.with(notice) }
-  end
-
-  def set_public_env
-    Honeybadger.configure { |config| config.environment_name = 'production' }
-  end
-
-  def set_development_env
-    Honeybadger.configure { |config| config.environment_name = 'development' }
-  end
-
-  should "yield and save a configuration when configuring" do
-    yielded_configuration = nil
-    Honeybadger.configure do |config|
-      yielded_configuration = config
-    end
-
-    assert_kind_of Honeybadger::Configuration, yielded_configuration
-    assert_equal yielded_configuration, Honeybadger.configuration
-  end
-
-  should "not remove existing config options when configuring twice" do
-    first_config = nil
-    Honeybadger.configure do |config|
-      first_config = config
-    end
-    Honeybadger.configure do |config|
-      assert_equal first_config, config
-    end
-  end
-
-  should "configure the sender" do
-    sender = stub_sender
-    Honeybadger::Sender.stubs(:new => sender)
-    configuration = nil
-
-    Honeybadger.configure { |yielded_config| configuration = yielded_config }
-
-    assert_received(Honeybadger::Sender, :new) { |expect| expect.with(configuration) }
-    assert_equal sender, Honeybadger.sender
-  end
-
-  should "create and send a notice asynchronously" do
-    set_public_env
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-
-    async_expectation = stub(:received => true)
-    async_handler = Proc.new do |notice|
-      async_expectation.received
-      notice.deliver
-    end
-
-    Honeybadger.configure do |config|
-      config.async = async_handler
-    end
-
-    stub_sender!
-
-    Honeybadger.notify(notice_args)
-
-    assert_received(async_expectation, :received)
-    assert_sent(notice, notice_args)
-  end
-
-  should "create and send a notice for an exception" do
-    set_public_env
-    exception = build_exception
-    stub_sender!
-    notice = stub_notice!
-
-    Honeybadger.notify(exception)
-
-    assert_sent notice, :exception => exception
-  end
-
-  should "create and send a notice for a hash" do
-    set_public_env
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    stub_sender!
-
-    Honeybadger.notify(notice_args)
-
-    assert_sent(notice, notice_args)
-  end
-
-  should "not pass the hash as an exception when sending a notice for it" do
-    set_public_env
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    stub_sender!
-
-    Honeybadger.notify(notice_args)
-
-    assert_received(Honeybadger::Notice, :new) {|expect| expect.with(Not(has_key(:exception))) }
-  end
-
-  should "create and send a notice for an exception that responds to to_hash" do
-    set_public_env
-    exception = build_exception
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    exception.stubs(:to_hash).returns(notice_args)
-    stub_sender!
-
-    Honeybadger.notify(exception)
-
-    assert_sent(notice, notice_args.merge(:exception => exception))
-  end
-
-  should "create and sent a notice for an exception and hash" do
-    set_public_env
-    exception = build_exception
-    notice = stub_notice!
-    notice_args = { :error_message => 'uh oh' }
-    stub_sender!
-
-    Honeybadger.notify(exception, notice_args)
-
-    assert_sent(notice, notice_args.merge(:exception => exception))
-  end
-
-  should "not create a notice in a development environment" do
-    set_development_env
-    sender = stub_sender!
-
-    Honeybadger.notify(build_exception)
-    Honeybadger.notify_or_ignore(build_exception)
-
-    assert_received(sender, :send_to_honeybadger) {|expect| expect.never }
-  end
-
-  should "not deliver an ignored exception when notifying implicitly" do
-    set_public_env
-    exception = build_exception
-    sender = stub_sender!
-    notice = stub_notice!
-    notice.stubs(:ignore? => true)
-
-    Honeybadger.notify_or_ignore(exception)
-
-    assert_received(sender, :send_to_honeybadger) {|expect| expect.never }
-  end
-
-  should "deliver an ignored exception when notifying manually" do
-    set_public_env
-    exception = build_exception
-    sender = stub_sender!
-    notice = stub_notice!
-    notice.stubs(:ignore? => true)
-
-    Honeybadger.notify(exception)
-
-    assert_sent(notice, :exception => exception)
-  end
-
-  should "pass config to created notices" do
-    exception = build_exception
-    config_opts = { 'one' => 'two', 'three' => 'four' }
-    notice = stub_notice!
-    stub_sender!
-    Honeybadger.configuration = stub('config', :merge => config_opts, :public? => true, :async? => false)
-
-    Honeybadger.notify(exception)
-
-    assert_received(Honeybadger::Notice, :new) do |expect|
-      expect.with(has_entries(config_opts))
-    end
-  end
-
-  context "building notice JSON for an exception" do
-    setup do
-      @params    = { :controller => "users", :action => "create" }
-      @exception = build_exception
-      @hash      = Honeybadger.build_lookup_hash_for(@exception, @params)
-    end
-
-    should "set action" do
-      assert_equal @params[:action], @hash[:action]
-    end
-
-    should "set controller" do
-      assert_equal @params[:controller], @hash[:component]
-    end
-
-    should "set line number" do
-      assert @hash[:line_number] =~ /\d+/
-    end
-
-    should "set file" do
-      assert_match /honeybadger\/rack_test\.rb$/, @hash[:file]
-    end
-
-    should "set environment_name to production" do
-      assert_equal 'production', @hash[:environment_name]
-    end
-
-    should "set error class" do
-      assert_equal @exception.class.to_s, @hash[:error_class]
-    end
-
-    should "not set file or line number with no backtrace" do
-      @exception.stubs(:backtrace).returns([])
-
-      @hash = Honeybadger.build_lookup_hash_for(@exception)
-
-      assert_nil @hash[:line_number]
-      assert_nil @hash[:file]
-    end
-
-    should "not set action or controller when not provided" do
-      @hash = Honeybadger.build_lookup_hash_for(@exception)
-
-      assert_nil @hash[:action]
-      assert_nil @hash[:controller]
-    end
-
-    context "when an exception that provides #original_exception is raised" do
-      setup do
-        @exception.stubs(:original_exception).returns(begin
-          raise NotifierTest::OriginalException.new
-        rescue Exception => e
-          e
-        end)
-      end
-
-      should "unwrap exceptions that provide #original_exception" do
-        @hash = Honeybadger.build_lookup_hash_for(@exception)
-        assert_equal "NotifierTest::OriginalException", @hash[:error_class]
-      end
-    end
-
-    context "when an exception that provides #continued_exception is raised" do
-      setup do
-        @exception.stubs(:continued_exception).returns(begin
-          raise NotifierTest::ContinuedException.new
-        rescue Exception => e
-          e
-        end)
-      end
-
-      should "unwrap exceptions that provide #continued_exception" do
-        @hash = Honeybadger.build_lookup_hash_for(@exception)
-        assert_equal "NotifierTest::ContinuedException", @hash[:error_class]
-      end
-    end
-  end
-end