honeybadger 1.16.7 → 2.0.0.beta.1

data/spec/honeybadger/user_informer_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'sham_rack'
-
-describe Honeybadger::Rack::UserInformer do
-  it 'modifies output if there is a honeybadger id' do
-    main_app = lambda do |env|
-      env['honeybadger.error_id'] = 1
-      [200, {}, ["<!-- HONEYBADGER ERROR -->"]]
-    end
-    informer_app = Honeybadger::Rack::UserInformer.new(main_app)
-
-    ShamRack.mount(informer_app, "example.com")
-
-    response = Net::HTTP.get_response(URI.parse("http://example.com/"))
-    expect(response.body).to eq 'Honeybadger Error 1'
-    expect(response["Content-Length"].to_i).to eq 19
-  end
-
-  it 'does not modify output if there is no honeybadger id' do
-    main_app = lambda do |env|
-      [200, {}, ["<!-- HONEYBADGER ERROR -->"]]
-    end
-    informer_app = Honeybadger::Rack::UserInformer.new(main_app)
-
-    ShamRack.mount(informer_app, "example.com")
-
-    response = Net::HTTP.get_response(URI.parse("http://example.com/"))
-    expect(response.body).to eq '<!-- HONEYBADGER ERROR -->'
-  end
-end

data/spec/honeybadger_tasks_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-require 'rubygems'
-
-require File.expand_path('../../lib/honeybadger_tasks', __FILE__)
-
-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 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
-          $stderr.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("Successfully 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
-            $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)
-            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
-          $stderr.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

data/spec/spec_helper.rb

@@ -1,24 +0,0 @@
-require 'rspec'
-require 'honeybadger'
-
-begin
-  require 'binding_of_caller'
-rescue LoadError
-  nil
-end
-
-# Require files in spec/support/ and its subdirectories.
-Dir[File.expand_path('../../spec/support/**/*.rb', __FILE__)].each {|f| require f}
-
-RSpec.configure do |c|
-  c.mock_with :rspec
-  c.color_enabled = true
-  c.tty = true
-
-  c.treat_symbols_as_metadata_keys_with_true_values = true
-  c.filter_run :focus => true
-  c.run_all_when_everything_filtered = true
-
-  c.include Helpers
-  c.after(:each) { Honeybadger.context.clear! }
-end

data/spec/support/array_including.rb

@@ -1,31 +0,0 @@
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-      class ArrayIncludingMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ==(actual)
-          @expected.all? do |value|
-            if Regexp === value
-              actual.any? {|v| value =~ v }
-            else
-              actual.include?(value)
-            end
-          end
-        rescue NoMethodError
-          false
-        end
-
-        def description
-          "array_including(#{@expected.inspect})"
-        end
-      end
-
-      def array_including(*args)
-        ArrayIncludingMatcher.new(args.flatten)
-      end
-    end
-  end
-end

data/spec/support/backtraced_exception.rb

@@ -1,9 +0,0 @@
-class BacktracedException < Exception
-  attr_accessor :backtrace
-  def initialize(opts)
-    @backtrace = opts[:backtrace]
-  end
-  def set_backtrace(bt)
-    @backtrace = bt
-  end
-end

data/spec/support/collected_sender.rb

@@ -1,12 +0,0 @@
-class CollectingSender
-  attr_reader :collected
-
-  def initialize
-    @collected = []
-  end
-
-  def send_to_honeybadger(notice)
-    data = notice.respond_to?(:to_json) ? notice.to_json : notice
-    @collected << data
-  end
-end

data/spec/support/defines_constants.rb

@@ -1,18 +0,0 @@
-module DefinesConstants
-  def self.included(base)
-    base.before(:each) do
-      @defined_constants = []
-    end
-
-    base.after(:each) do
-      @defined_constants.each do |constant|
-        Object.__send__(:remove_const, constant)
-      end
-    end
-  end
-
-  def define_constant(name, value)
-    Object.const_set(name, value)
-    @defined_constants << name
-  end
-end

data/spec/support/helpers.rb

@@ -1,101 +0,0 @@
-module Helpers
-  def assert_no_difference(expression, message = nil, &block)
-    assert_difference expression, 0, message, &block
-  end
-
-  def stub_sender
-    double('sender', :send_to_honeybadger => nil)
-  end
-
-  def stub_sender!
-    Honeybadger.sender = stub_sender
-  end
-
-  def stub_notice
-    Honeybadger::Notice.new({}).tap do |notice|
-      notice.stub(:ignored? => false, :to_json => '{"foo":"bar"}')
-    end
-  end
-
-  def stub_notice!
-     stub_notice.tap do |notice|
-       Honeybadger::Notice.stub(:new => notice)
-    end
-  end
-
-  def stub_http(options = {})
-    response = options[:response] || Net::HTTPSuccess.new('1.2', '200', 'OK')
-    response.stub(:body => options[:body] || '{"id":"1234"}')
-    http = double(:post          => response,
-                :read_timeout= => nil,
-                :open_timeout= => nil,
-                :ca_file=      => nil,
-                :verify_mode=  => nil,
-                :use_ssl=      => nil)
-    Net::HTTP.stub(:new).and_return(http)
-    http
-  end
-
-  def reset_config
-    Honeybadger.configuration = nil
-    Honeybadger.configure do |config|
-      config.api_key = 'abc123'
-    end
-  end
-
-  def build_notice_data(exception = nil)
-    exception ||= build_exception
-    {
-      :api_key       => nil,
-      :error_class   => exception.class.name,
-      :error_message => "#{exception.class.name}: #{exception.message}",
-      :backtrace     => exception.backtrace,
-      :environment   => { 'PATH' => '/bin', 'REQUEST_URI' => '/users/1' },
-      :request       => {
-        :params     => { 'controller' => 'users', 'action' => 'show', 'id' => '1' },
-        :rails_root => '/path/to/application',
-        :url        => "http://test.host/users/1"
-      },
-      :session       => {
-        :key  => '123abc',
-        :data => { 'user_id' => '5', 'flash' => { 'notice' => 'Logged in successfully' } }
-      }
-    }
-  end
-
-  def build_exception(opts = {})
-    backtrace = ["test/honeybadger/rack_test.rb:15:in `build_exception'",
-                 "test/honeybadger/rack_test.rb:52:in `test_delivers_exception_from_rack'",
-                 "/Users/josh/Developer/.rvm/gems/ruby-1.9.3-p0/gems/mocha-0.10.5/lib/mocha/integration/mini_test/version_230_to_262.rb:28:in `run'"]
-    opts = { :backtrace => backtrace }.merge(opts)
-    BacktracedException.new(opts)
-  end
-
-  def assert_array_starts_with(expected, actual)
-    expect(actual).to respond_to :to_ary
-    array = actual.to_ary.reverse
-    expected.reverse.each_with_index do |value, i|
-      expect(array[i]).to eq value
-    end
-  end
-
-  def assert_logged(expected)
-    assert_received(Honeybadger, :write_verbose_log) do |expect|
-      expect.with {|actual, level| actual =~ expected }
-    end
-  end
-
-  def assert_not_logged(expected)
-    assert_received(Honeybadger, :write_verbose_log) do |expect|
-      expect.with {|actual, level| actual =~ expected }.never
-    end
-  end
-
-  def assert_caught_and_sent
-    expect(Honeybadger.sender.collected).not_to be_empty
-  end
-
-  def assert_caught_and_not_sent
-    expect(Honeybadger.sender.collected).to be_empty
-  end
-end