honeybadger 1.10.3 → 1.11.0.beta1

data/lib/honeybadger_tasks.rb

@@ -17,12 +17,12 @@ module HoneybadgerTasks
   def self.deploy(opts = {})
     api_key = opts.delete(:api_key) || Honeybadger.configuration.api_key
     unless api_key =~ /\S/
-      puts "I don't seem to be configured with an API key.  Please check your configuration."
+      $stderr.puts "I don't seem to be configured with an API key.  Please check your configuration."
       return false
     end
 
     unless opts[:environment] =~ /\S/
-      puts "I don't know to which environment you are deploying (use the TO=production option)."
+      $stderr.puts "I don't know to which environment you are deploying (use the TO=production option)."
       return false
     end
 
@@ -60,7 +60,7 @@ module HoneybadgerTasks
         puts "Succesfully recorded deployment"
         return true
       else
-        puts response.body
+        $stderr.puts "Error recording deployment: #{response.class} -- #{response.body || 'no response'}"
         return false
       end
     end

data/lib/rails/generators/honeybadger/honeybadger_generator.rb

@@ -36,9 +36,8 @@ class HoneybadgerGenerator < Rails::Generators::Base
 
   def append_capistrano_hook
     if File.exists?('config/deploy.rb') && File.exists?('Capfile')
-      append_file('config/deploy.rb', <<-HOOK)
+      append_file('Capfile', <<-HOOK)
 
-        require './config/boot'
         require 'honeybadger/capistrano'
       HOOK
     end

data/spec/honeybadger/capistrano_spec.rb

@@ -1,33 +1,36 @@
 require 'spec_helper'
+require 'capistrano'
 
-require 'capistrano/configuration'
-require 'honeybadger/capistrano'
+if defined?(Capistrano::Configuration.instance)
+  describe 'Honeybadger::Capistrano' do
+    require 'capistrano/configuration'
+    require 'honeybadger/capistrano'
 
-describe Honeybadger::Capistrano do
-  before(:each) do
-    reset_config
+    before { reset_config }
 
-    @configuration = Capistrano::Configuration.new
-    Honeybadger::Capistrano.load_into(@configuration)
-    @configuration.dry_run = true
-  end
+    before(:each) do
+      @configuration = Capistrano::Configuration.new
+      Honeybadger::Capistrano.load_into(@configuration)
+      @configuration.dry_run = true
+    end
 
-  it "defines honeybadger:deploy task" do
-    expect(@configuration.find_task('honeybadger:deploy')).not_to be_nil
-  end
+    it "defines honeybadger:deploy task" do
+      expect(@configuration.find_task('honeybadger:deploy')).not_to be_nil
+    end
 
-  it "logs when calling honeybadger:deploy task" do
-    @configuration.set(:current_revision, '084505b1c0e0bcf1526e673bb6ac99fbcb18aecc')
-    @configuration.set(:repository, 'repository')
-    @configuration.set(:current_release, '/home/deploy/rails_app/honeybadger')
-    io = StringIO.new
-    logger = Capistrano::Logger.new(:output => io)
-    logger.level = Capistrano::Logger::MAX_LEVEL
+    it "logs when calling honeybadger:deploy task" do
+      @configuration.set(:current_revision, '084505b1c0e0bcf1526e673bb6ac99fbcb18aecc')
+      @configuration.set(:repository, 'repository')
+      @configuration.set(:current_release, '/home/deploy/rails_app/honeybadger')
+      io = StringIO.new
+      logger = Capistrano::Logger.new(:output => io)
+      logger.level = Capistrano::Logger::MAX_LEVEL
 
-    @configuration.logger = logger
-    @configuration.find_and_execute_task('honeybadger:deploy')
+      @configuration.logger = logger
+      @configuration.find_and_execute_task('honeybadger:deploy')
 
-    expect(io.string).to include '** Notifying Honeybadger of Deploy'
-    expect(io.string).to include '** Honeybadger Notification Complete'
+      expect(io.string).to include '** Notifying Honeybadger of Deploy'
+      expect(io.string).to include '** Honeybadger Notification Complete'
+    end
   end
 end

data/spec/honeybadger/configuration_spec.rb

@@ -3,6 +3,7 @@ require 'socket'
 
 describe Honeybadger::Configuration do
   it "provides default values" do
+    assert_config_default :api_key,             nil
     assert_config_default :proxy_host,          nil
     assert_config_default :proxy_port,          nil
     assert_config_default :proxy_user,          nil
@@ -206,29 +207,32 @@ describe Honeybadger::Configuration do
     expect(config.public?).to be_true
   end
 
-  it "is not be public if the notices feature is missing" do
-    config = Honeybadger::Configuration.new
-    config.features = {}
-    expect(config.public?).to be_false
-  end
+  describe "#metrics?" do
+    let(:config) { Honeybadger::Configuration.new }
 
-  it "sends metrics by default in a public environment" do
-    config = Honeybadger::Configuration.new
-    config.environment_name = 'production'
-    expect(config.metrics?).to be_true
-  end
+    context "when public" do
+      before { config.stub(:public?).and_return(true) }
 
-  it "sends not send metrics when disabled" do
-    config = Honeybadger::Configuration.new
-    config.environment_name = 'production'
-    config.metrics = false
-    expect(config.metrics?).to be_false
-  end
+      it "sends metrics by default" do
+        expect(config.metrics?).to be_true
+      end
 
-  it "sends not send metrics in a development environment" do
-    config = Honeybadger::Configuration.new
-    config.environment_name = 'development'
-    expect(config.metrics?).to be_false
+      context "when disabled" do
+        before { config.metrics = false }
+
+        it "does not send metrics" do
+          expect(config.metrics?).to be_false
+        end
+      end
+    end
+
+    context "when not public" do
+      before { config.stub(:public?).and_return(false) }
+
+      it "does not send metrics" do
+        expect(config.metrics?).to be_false
+      end
+    end
   end
 
   it "uses the assigned logger if set" do
@@ -237,7 +241,7 @@ describe Honeybadger::Configuration do
     expect(config.logger).to eq "CUSTOM LOGGER"
   end
 
-  it 'gives a new instance if non defined' do
+  it "gives a new instance if non defined" do
     Honeybadger.configuration = nil
     expect(Honeybadger.configuration).to be_a Honeybadger::Configuration
   end

data/spec/honeybadger/notice_spec.rb

@@ -14,15 +14,6 @@ describe Honeybadger::Notice do
     Honeybadger::Notice.new(configuration.merge(args))
   end
 
-  def stub_request(attrs = {})
-    double('request', { :parameters  => { 'one' => 'two' },
-                      :protocol    => 'http',
-                      :host        => 'some.host',
-                      :request_uri => '/some/uri',
-                      :session     => { :to_hash => { 'a' => 'b' } },
-                      :env         => { 'three' => 'four' } }.update(attrs))
-  end
-
   context '#deliver' do
     context 'sender is configured' do
       it "delivers to sender" do
@@ -313,53 +304,55 @@ describe Honeybadger::Notice do
     assert_filters_hash(:session_data)
   end
 
-  describe 'url' do
-    let(:params_filters) { [] }
-    let(:notice) { build_notice(:params_filters => params_filters, :url => url) }
-
-    context 'filtered params in query' do
-      let(:params_filters) { [:bar] }
-      let(:url) { 'https://www.honeybadger.io/?foo=1&bar=2&baz=3' }
+  context 'filtered parameters in query string' do
+    let(:params_filters) { [:foo, :bar] }
 
+    describe '#url' do
+      let(:notice) { build_notice(:params_filters => params_filters, :url => 'https://www.honeybadger.io/?foo=1&bar=2&baz=3') }
       it 'filters query' do
-        expect(notice.url).to eq 'https://www.honeybadger.io/?foo=1&bar=[FILTERED]&baz=3'
+        expect(notice.url).to eq 'https://www.honeybadger.io/?foo=[FILTERED]&bar=[FILTERED]&baz=3'
       end
     end
 
-    context 'malformed query' do
-      let(:url) { 'https://www.honeybadger.io/?foobar12' }
+    describe '#cgi_data' do
+      let(:cgi_data) { { 'QUERY_STRING' => 'foo=1&bar=2&baz=3', 'ORIGINAL_FULLPATH' => '/?foo=1&bar=2&baz=3' } }
+      let(:notice) { build_notice(:params_filters => params_filters, :cgi_data => cgi_data) }
+
+      subject { notice.cgi_data }
 
-      it 'maintains query' do
-        expect(notice.url).to eq url
+      it 'filters QUERY_STRING key' do
+        expect(subject['QUERY_STRING']).to eq 'foo=[FILTERED]&bar=[FILTERED]&baz=3'
       end
+
+      it 'filters ORIGINAL_FULLPATH key' do
+        expect(subject['ORIGINAL_FULLPATH']).to eq '/?foo=[FILTERED]&bar=[FILTERED]&baz=3'
+      end
+    end
+  end
+
+  describe '#filter_url' do
+    let(:notice) { build_notice(:params_filters => [], :url => url) }
+    subject { notice.send(:filter_url, url) }
+
+    context 'malformed query' do
+      let(:url) { 'https://www.honeybadger.io/?foobar12' }
+      it { should eq url }
     end
 
     context 'no query' do
       let(:url) { 'https://www.honeybadger.io' }
-
-      it 'keeps original URL' do
-        expect(notice.url).to eq url
-      end
+      it { should eq url }
     end
 
     context 'malformed url' do
       let(:url) { 'http s ! honeybadger' }
-
-      before do
-        expect { URI.parse(url) }.to raise_error
-      end
-
-      it 'keeps original URL' do
-        expect(notice.url).to eq url
-      end
+      before { expect { URI.parse(url) }.to raise_error }
+      it { should eq url }
     end
 
     context 'complex url' do
       let(:url) { 'https://foo:bar@www.honeybadger.io:123/asdf/?foo=1&bar=2&baz=3' }
-
-      it 'keeps original URL' do
-        expect(notice.url).to eq url
-      end
+      it { should eq url }
     end
   end
 

data/spec/honeybadger/notifier_spec.rb

@@ -7,10 +7,6 @@ describe 'Honeybadger' do
   class ContinuedException < Exception
   end
 
-  before(:each) do
-    reset_config
-  end
-
   def assert_sends(notice, notice_args)
     Honeybadger::Notice.should_receive(:new).with(hash_including(notice_args))
     Honeybadger.sender.should_receive(:send_to_honeybadger).with(notice)
@@ -24,6 +20,66 @@ describe 'Honeybadger' do
     Honeybadger.configure { |config| config.environment_name = 'development' }
   end
 
+  before(:each) { reset_config }
+
+  describe "#ping" do
+    let(:config) { Honeybadger::Configuration.new }
+    let(:sender) { double() }
+
+    let(:invoke_subject) { Honeybadger.ping(config) }
+    subject { invoke_subject }
+
+    before do
+      config.framework = 'Rails 4.1.0'
+      config.environment_name = 'production'
+      config.hostname = 'twix'
+      stub_const('Honeybadger::VERSION', '1.11.0')
+
+      Honeybadger.stub(:sender).and_return(sender)
+    end
+
+    context "configuration is public" do
+      before { config.stub(:public?).and_return(true) }
+
+      it "pings the sender" do
+        sender.should_receive(:ping).with(hash_including(:version => '1.11.0', :framework => 'Rails 4.1.0', :environment => 'production', :hostname => 'twix'))
+        invoke_subject
+      end
+
+      context "result is truthy" do
+        before { sender.should_receive(:ping).and_return(result) }
+
+        context "result does not contain features" do
+          let(:result) { {} }
+          it { should be_nil }
+          specify { expect { subject }.not_to change(config, :features) }
+        end
+
+        context "result contains features" do
+          let(:result) { {'features' => {'notices' => true, 'metrics' => true}} }
+          it { should eq result['features'] }
+          specify { expect { subject }.to change(config, :features).to(result['features']) }
+        end
+      end
+
+      context "result is falsey" do
+        before { sender.should_receive(:ping) }
+        it { should be_nil }
+        specify { expect { invoke_subject }.not_to change(config, :features) }
+      end
+    end
+
+    context "configuration is not public" do
+      before { config.stub(:public?).and_return(false) }
+      it { should be_nil }
+
+      it "doesn't attempt to ping sender" do
+        sender.should_not_receive(:ping)
+        invoke_subject
+      end
+    end
+  end
+
   it "yields and save a configuration when configuring" do
     yielded_configuration = nil
     Honeybadger.configure do |config|

data/spec/honeybadger/rack_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'rack'
 
 describe Honeybadger::Rack do
   it "calls the upstream app with the environment" do

data/spec/honeybadger/user_feedback_spec.rb

@@ -12,11 +12,12 @@ describe Honeybadger::UserFeedback do
   let(:response) { Net::HTTP.get_response(URI.parse("http://example.com/")) }
 
   before do
+    reset_config
     ShamRack.mount(informer_app, "example.com")
   end
 
   context "feedback feature is disabled by ping" do
-    it 'does not modify the output' do
+    it "does not modify the output" do
       expect(response.body).to eq '<!-- HONEYBADGER FEEDBACK -->'
     end
   end
@@ -29,25 +30,49 @@ describe Honeybadger::UserFeedback do
     context "there is a honeybadger id" do
       let(:honeybadger_id) { 1 }
 
-      it 'modifies output' do
+      it "modifies output" do
         rendered_length = informer_app.render_form(1).size
         expect(response.body).to match(/honeybadger_feedback_token/)
         expect(response["Content-Length"].to_i).to eq rendered_length
       end
 
+      context "a project root is configured" do
+        let(:tmp_dir) { File.expand_path('../../../tmp', __FILE__) }
+        let(:template_dir) { File.join(tmp_dir, 'lib', 'honeybadger', 'templates') }
+        let(:template_file) { File.join(template_dir, 'feedback_form.erb') }
+
+        before do
+          FileUtils.mkdir_p(template_dir)
+          FileUtils.rm_f(template_file)
+          Honeybadger.configure(true) do |config|
+            config.project_root = tmp_dir
+          end
+        end
+
+        context "custom template is implemented" do
+          before do
+            File.open(template_file, 'w') { |f| f.write 'custom feedback form' }
+          end
+
+          it "renders with custom template" do
+            expect(response.body).to match(/custom feedback form/)
+          end
+        end
+      end
+
       context "feedback feature is disabled by customer" do
         before do
           Honeybadger.configuration.feedback = false
         end
 
-        it 'does not modify the output' do
+        it "does not modify the output" do
           expect(response.body).to eq '<!-- HONEYBADGER FEEDBACK -->'
         end
       end
     end
 
     context "there is no honeybadger id" do
-      it 'does not modify the output' do
+      it "does not modify the output" do
         expect(response.body).to eq '<!-- HONEYBADGER FEEDBACK -->'
       end
     end

data/spec/honeybadger_tasks_spec.rb

@@ -17,14 +17,17 @@ describe HoneybadgerTasks do
   end
 
   context "being quiet" do
-    before(:each) { HoneybadgerTasks.stub(:puts) }
+    before do
+      HoneybadgerTasks.stub(:puts)
+      $stderr.stub(:puts)
+    end
 
     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)
+          $stderr.should_receive(:puts).with(/which environment/i)
           HoneybadgerTasks.deploy({})
         end
 
@@ -95,11 +98,17 @@ describe HoneybadgerTasks do
           end
 
           it "puts the response body on failure" do
-            HoneybadgerTasks.should_receive(:puts).with("body")
+            $stderr.should_receive(:puts).with(/body/)
             @http_proxy.should_receive(:request).with(anything).and_return(unsuccessful_response('body'))
             HoneybadgerTasks.deploy(@options)
           end
 
+          it "puts the response class on failure" do
+            $stderr.should_receive(:puts).with(/Net::HTTPClientError/)
+            @http_proxy.should_receive(:request).with(anything).and_return(unsuccessful_response)
+            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)
@@ -148,7 +157,7 @@ describe HoneybadgerTasks do
 
       context "on deploy(:environment => 'staging')" do
         it "complains about missing api key" do
-          HoneybadgerTasks.should_receive(:puts).with(/api key/i)
+          $stderr.should_receive(:puts).with(/api key/i)
           HoneybadgerTasks.deploy(:environment => "staging")
         end