honeybadger 1.8.1 → 1.9.0.beta1

data/{test/unit/rails_test.rb → spec/honeybadger/rails_spec.rb}

@@ -1,10 +1,10 @@
-require 'test_helper'
+require 'spec_helper'
 require 'honeybadger/rails'
 
-class RailsInitializerTest < Test::Unit::TestCase
+describe Honeybadger::Rails do
   include DefinesConstants
 
-  should "trigger use of Rails' logger if logger isn't set and Rails' logger exists" do
+  it "triggers use of Rails' logger if logger isn't set and Rails' logger exists" do
     rails = Module.new do
       def self.logger
         "RAILS LOGGER"
@@ -12,17 +12,17 @@ class RailsInitializerTest < Test::Unit::TestCase
     end
     define_constant("Rails", rails)
     Honeybadger::Rails.initialize
-    assert_equal "RAILS LOGGER", Honeybadger.logger
+    expect(Honeybadger.logger).to eq "RAILS LOGGER"
   end
 
-  should "trigger use of Rails' default logger if logger isn't set and Rails.logger doesn't exist" do
+  it "triggers use of Rails' default logger if logger isn't set and Rails.logger doesn't exist" do
     define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
 
     Honeybadger::Rails.initialize
-    assert_equal "RAILS DEFAULT LOGGER", Honeybadger.logger
+    expect(Honeybadger.logger).to eq "RAILS DEFAULT LOGGER"
   end
 
-  should "allow overriding of the logger if already assigned" do
+  it "allows overriding of the logger if already assigned" do
     define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
     Honeybadger::Rails.initialize
 
@@ -30,6 +30,6 @@ class RailsInitializerTest < Test::Unit::TestCase
       config.logger = "OVERRIDDEN LOGGER"
     end
 
-    assert_equal "OVERRIDDEN LOGGER", Honeybadger.logger
+    expect(Honeybadger.logger).to eq "OVERRIDDEN LOGGER"
   end
 end

data/spec/honeybadger/sender_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+describe Honeybadger::Sender do
+  before(:each) { reset_config }
+
+  it "posts to Honeybadger when using an HTTP proxy" do
+    post = double()
+    http = double(:adapter     => nil,
+                  :url_prefix= => nil,
+                  :headers     => nil)
+    http.stub(:post).and_yield(post).and_return(false)
+
+    url = "http://api.honeybadger.io:80#{Honeybadger::Sender::NOTICES_URI}"
+    uri = URI.parse(url)
+
+    post.should_receive(:url).with(uri.path)
+    post.should_receive(:body=).with('asdf')
+
+    Faraday.should_receive(:new).
+      with(hash_including(:request => hash_including({ :proxy => { :uri => 'https://some.host:88', :user => 'login', :password => 'passwd' } }))).and_return(http)
+
+    send_exception(:proxy_host => 'some.host',
+                   :proxy_port => 88,
+                   :proxy_user => 'login',
+                   :proxy_pass => 'passwd',
+                   :notice => 'asdf')
+  end
+
+  it "returns the created group's id on successful posting" do
+    stub_http(:body => '{"id":"3799307"}')
+    expect(send_exception(:secure => false)).to eq '3799307'
+  end
+
+  it "returns nil on failed posting" do
+    stub_http(:response => Faraday::Response.new(:status => 500))
+    expect(send_exception(:secure => false)).to be_nil
+  end
+
+  it "logs missing API key and return nil" do
+    sender = build_sender(:api_key => nil)
+    sender.should_receive(:log).with(:error, /API key/)
+    expect(send_exception(:sender => sender, :secure => false)).to be_nil
+  end
+
+  it "logs success" do
+    stub_http
+    sender = build_sender
+    sender.should_receive(:log).with(:debug, /Success/, kind_of(Faraday::Response), kind_of(String))
+    send_exception(:sender => sender, :secure => false)
+  end
+
+  it "logs failure" do
+    stub_http(:response => Faraday::Response.new(:status => 500))
+    sender = build_sender
+    sender.should_receive(:log).with(:error, /Failure/, kind_of(Faraday::Response), kind_of(String))
+    send_exception(:sender => sender, :secure => false)
+  end
+
+  context "when encountering exceptions" do
+    # TODO: Figure out why nested groups aren't running
+    context "HTTP connection setup problems" do
+      it "should not be rescued" do
+        Faraday.should_receive(:new).and_raise(NoMemoryError)
+        expect { build_sender.send(:client) }.to raise_error(NoMemoryError)
+      end
+
+      it "should be logged" do
+        Faraday.should_receive(:new).and_raise(RuntimeError)
+
+        sender = build_sender
+        sender.should_receive(:log).with(:error, /Failure initializing the HTTP connection/)
+
+        expect { sender.send(:client) }.to raise_error(RuntimeError)
+      end
+    end
+
+    context "unexpected exception sending problems" do
+      it "should be logged" do
+        sender  = build_sender
+        sender.should_receive(:client).and_raise(RuntimeError)
+
+        sender.should_receive(:log).with(:error, /Error/)
+        sender.send_to_honeybadger("stuff")
+      end
+
+      it "returns nil no matter what" do
+        sender  = build_sender
+        sender.should_receive(:client).and_raise(LocalJumpError)
+
+        expect { sender.send_to_honeybadger("stuff").should be_nil }.not_to raise_error
+      end
+    end
+
+    it "returns nil on failed posting" do
+      http = stub_http
+      http.should_receive(:post).and_raise(Errno::ECONNREFUSED)
+      expect(send_exception(:secure => false)).to be_nil
+    end
+
+    it "not fail when posting and a timeout exception occurs" do
+      http = stub_http
+      http.should_receive(:post).and_raise(TimeoutError)
+      expect { send_exception(:secure => false) }.not_to raise_error
+    end
+
+    it "not fail when posting and a connection refused exception occurs" do
+      http = stub_http
+      http.should_receive(:post).and_raise(Errno::ECONNREFUSED)
+      expect { send_exception(:secure => false) }.not_to raise_error
+    end
+
+    it "not fail when posting any http exception occurs" do
+      http = stub_http
+      Honeybadger::Sender::HTTP_ERRORS.each do |error|
+        http.stub(:post).and_raise(error)
+        expect { send_exception(:secure => false) }.not_to raise_error
+      end
+    end
+  end
+
+  context "SSL" do
+    it "posts to the right url for non-ssl" do
+      http = stub_http
+      url = "http://api.honeybadger.io:80#{Honeybadger::Sender::NOTICES_URI}"
+      uri = URI.parse(url)
+      post = double(:body= => nil)
+      http.should_receive(:post).and_yield(post)
+      post.should_receive(:url).with(uri.path)
+      send_exception(:secure => false)
+    end
+
+    it "post to the right path for ssl" do
+      http = stub_http
+      post = double(:body= => nil)
+      http.should_receive(:post).and_yield(post)
+      post.should_receive(:url).with(Honeybadger::Sender::NOTICES_URI)
+      send_exception(:secure => true)
+    end
+
+    it "verifies the SSL peer when the use_ssl option is set to true" do
+      url = "https://api.honeybadger.io#{Honeybadger::Sender::NOTICES_URI}"
+
+      real_http = Faraday.new(:url => url)
+      real_http.stub(:post => nil)
+      Faraday.stub(:new).and_yield(real_http)
+
+      File.stub(:exist?).with(OpenSSL::X509::DEFAULT_CERT_FILE).and_return(false)
+
+      send_exception(:secure => true)
+
+      expect(real_http.ssl).not_to be_empty
+      expect(real_http.ssl[:verify_mode]).to eq OpenSSL::SSL::VERIFY_PEER
+      expect(real_http.ssl[:ca_file]).to eq Honeybadger.configuration.local_cert_path
+    end
+
+    it "uses the default DEFAULT_CERT_FILE if asked to" do
+      File.should_receive(:exist?).with(OpenSSL::X509::DEFAULT_CERT_FILE).and_return(true)
+
+      Honeybadger.configure do |config|
+        config.secure = true
+        config.use_system_ssl_cert_chain = true
+      end
+
+      sender = Honeybadger::Sender.new(Honeybadger.configuration)
+
+      expect(sender.use_system_ssl_cert_chain?).to be_true
+
+      http    = sender.send(:client)
+      expect(http.ssl[:ca_file]).not_to eq Honeybadger.configuration.local_cert_path
+    end
+
+    it "verifies the connection when the use_ssl option is set (VERIFY_PEER)" do
+      sender  = build_sender(:secure => true)
+      http    = sender.send(:client)
+      expect(http.ssl[:verify_mode]).to eq OpenSSL::SSL::VERIFY_PEER
+    end
+
+    it "uses the default cert (OpenSSL::X509::DEFAULT_CERT_FILE) only if explicitly told to" do
+      sender  = build_sender(:secure => true)
+      http    = sender.send(:client)
+
+      expect(http.ssl[:ca_file]).to eq Honeybadger.configuration.local_cert_path
+
+      File.stub(:exist?).with(OpenSSL::X509::DEFAULT_CERT_FILE).and_return(true)
+      sender  = build_sender(:secure => true, :use_system_ssl_cert_chain => true)
+      http    = sender.send(:client)
+
+      expect(http.ssl[:ca_file]).not_to eq Honeybadger.configuration.local_cert_path
+      expect(http.ssl[:ca_file]).to eq OpenSSL::X509::DEFAULT_CERT_FILE
+    end
+
+    it "uses ssl if secure" do
+      sender  = build_sender(:secure => true)
+      http    = sender.send(:client)
+      expect(http.port).to eq 443
+    end
+
+    it "does not use ssl if not secure" do
+      sender  = build_sender(:secure => false)
+      http    = sender.send(:client)
+      expect(http.port).to eq 80
+    end
+  end
+
+  context "network timeouts" do
+    it "default the open timeout to 2 seconds" do
+      Faraday.should_receive(:new).with(hash_including({ :request => hash_including({ :open_timeout => 2 }) }))
+      send_exception
+    end
+
+    it "default the read timeout to 5 seconds" do
+      Faraday.should_receive(:new).with(hash_including({ :request => hash_including({ :timeout => 5 }) }))
+      send_exception
+    end
+
+    it "allow override of the open timeout" do
+      Faraday.should_receive(:new).with(hash_including({ :request => hash_including({ :open_timeout => 4 }) }))
+      send_exception(:http_open_timeout => 4)
+    end
+
+    it "allow override of the read timeout" do
+      Faraday.should_receive(:new).with(hash_including({ :request => hash_including({ :timeout => 10 }) }))
+      send_exception(:http_read_timeout => 10)
+    end
+  end
+
+  def build_sender(opts = {})
+    Honeybadger.configure do |conf|
+      opts.each {|opt, value| conf.send(:"#{opt}=", value) }
+    end
+  end
+
+  def send_exception(args = {})
+    notice = args.delete(:notice) || build_notice_data
+    sender = args.delete(:sender) || build_sender(args)
+    sender.send_to_honeybadger(notice)
+  end
+
+  def stub_http(options = {})
+    response = options[:response] || Faraday::Response.new(:status => 200)
+    response.stub(:body => options[:body] || '{"id":"1234"}')
+    http = double(:post => response,
+                :adapter => nil,
+                :url_prefix= => nil,
+                :headers => nil)
+    Faraday.stub(:new => http)
+    http
+  end
+end

data/spec/honeybadger_tasks_spec.rb

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