honeybadger 1.8.1 → 1.9.0.beta1

data/{test/unit/backtrace_test.rb → spec/honeybadger/backtrace_spec.rb}

@@ -1,8 +1,8 @@
-require 'test_helper'
+require 'spec_helper'
 require 'stringio'
 
-class BacktraceTest < Test::Unit::TestCase
-  should "parse a backtrace into lines" do
+describe Honeybadger::Backtrace do
+  it "parses a backtrace into lines" do
     array = [
       "app/models/user.rb:13:in `magic'",
       "app/controllers/users_controller.rb:8:in `index'"
@@ -11,17 +11,17 @@ class BacktraceTest < Test::Unit::TestCase
     backtrace = Honeybadger::Backtrace.parse(array)
 
     line = backtrace.lines.first
-    assert_equal '13', line.number
-    assert_equal 'app/models/user.rb', line.file
-    assert_equal 'magic', line.method
+    expect(line.number).to eq '13'
+    expect(line.file).to eq 'app/models/user.rb'
+    expect(line.method).to eq 'magic'
 
     line = backtrace.lines.last
-    assert_equal '8', line.number
-    assert_equal 'app/controllers/users_controller.rb', line.file
-    assert_equal 'index', line.method
+    expect(line.number).to eq '8'
+    expect(line.file).to eq 'app/controllers/users_controller.rb'
+    expect(line.method).to eq 'index'
   end
 
-  should "parse a windows backtrace into lines" do
+  it "parses a windows backtrace into lines" do
     array = [
       "C:/Program Files/Server/app/models/user.rb:13:in `magic'",
       "C:/Program Files/Server/app/controllers/users_controller.rb:8:in `index'"
@@ -30,34 +30,34 @@ class BacktraceTest < Test::Unit::TestCase
     backtrace = Honeybadger::Backtrace.parse(array)
 
     line = backtrace.lines.first
-    assert_equal '13', line.number
-    assert_equal 'C:/Program Files/Server/app/models/user.rb', line.file
-    assert_equal 'magic', line.method
+    expect(line.number).to eq '13'
+    expect(line.file).to eq 'C:/Program Files/Server/app/models/user.rb'
+    expect(line.method).to eq 'magic'
 
     line = backtrace.lines.last
-    assert_equal '8', line.number
-    assert_equal 'C:/Program Files/Server/app/controllers/users_controller.rb', line.file
-    assert_equal 'index', line.method
+    expect(line.number).to eq '8'
+    expect(line.file).to eq 'C:/Program Files/Server/app/controllers/users_controller.rb'
+    expect(line.method).to eq 'index'
   end
 
-  should "be equal with equal lines" do
+  it "is equal with equal lines" do
     one = build_backtrace_array
     two = one.dup
 
-    assert_equal Honeybadger::Backtrace.parse(one), Honeybadger::Backtrace.parse(two)
+    expect(Honeybadger::Backtrace.parse(one)).to eq Honeybadger::Backtrace.parse(two)
   end
 
-  should "parse massive one-line exceptions into multiple lines" do
+  it "parses massive one-line exceptions into multiple lines" do
     original_backtrace = Honeybadger::Backtrace.
       parse(["one:1:in `one'\n   two:2:in `two'\n      three:3:in `three`"])
     expected_backtrace = Honeybadger::Backtrace.
       parse(["one:1:in `one'", "two:2:in `two'", "three:3:in `three`"])
 
-    assert_equal expected_backtrace, original_backtrace
+    expect(expected_backtrace).to eq original_backtrace
   end
 
   context "when source file exists" do
-    setup do
+    before(:each) do
       source = <<-RUBY
         $:<<'lib'
         require 'honeybadger'
@@ -76,35 +76,35 @@ class BacktraceTest < Test::Unit::TestCase
       ]
 
       ['app/models/user.rb', 'app/concerns/authenticated_controller.rb', 'app/controllers/users_controller.rb'].each do |file|
-        File.expects(:exists?).with(file).returns true
-        File.expects(:open).with(file).yields StringIO.new(source)
+        File.should_receive(:exists?).with(file).and_return true
+        File.should_receive(:open).with(file).and_yield StringIO.new(source)
       end
 
       @backtrace = Honeybadger::Backtrace.parse(array)
     end
 
-    should "include a snippet from the source file for each line of the backtrace" do
-      assert_equal 4, @backtrace.lines[0].source.keys.size
-      assert_match /\$:<</, @backtrace.lines[0].source[1]
-      assert_match /require/, @backtrace.lines[0].source[2]
-      assert_match /\n/, @backtrace.lines[0].source[3]
-      assert_match /begin/, @backtrace.lines[0].source[4]
-
-      assert_equal 5, @backtrace.lines[1].source.keys.size
-      assert_match /require/, @backtrace.lines[1].source[2]
-      assert_match /\n/, @backtrace.lines[1].source[3]
-      assert_match /begin/, @backtrace.lines[1].source[4]
-      assert_match /StandardError/, @backtrace.lines[1].source[5]
-      assert_match /rescue/, @backtrace.lines[1].source[6]
-
-      assert_equal 3, @backtrace.lines[2].source.keys.size
-      assert_match /rescue/, @backtrace.lines[2].source[6]
-      assert_match /Honeybadger/, @backtrace.lines[2].source[7]
-      assert_match /end/, @backtrace.lines[2].source[8]
+    it "includes a snippet from the source file for each line of the backtrace" do
+      expect(@backtrace.lines[0].source.keys.size).to eq(4)
+      expect(@backtrace.lines[0].source[1]).to match(/\$:<</)
+      expect(@backtrace.lines[0].source[2]).to match(/require/)
+      expect(@backtrace.lines[0].source[3]).to match(/\n/)
+      expect(@backtrace.lines[0].source[4]).to match(/begin/)
+
+      expect(@backtrace.lines[1].source.keys.size).to eq(5)
+      expect(@backtrace.lines[1].source[2]).to match(/require/)
+      expect(@backtrace.lines[1].source[3]).to match(/\n/)
+      expect(@backtrace.lines[1].source[4]).to match(/begin/)
+      expect(@backtrace.lines[1].source[5]).to match(/StandardError/)
+      expect(@backtrace.lines[1].source[6]).to match(/rescue/)
+
+      expect(@backtrace.lines[2].source.keys.size).to eq(3)
+      expect(@backtrace.lines[2].source[6]).to match(/rescue/)
+      expect(@backtrace.lines[2].source[7]).to match(/Honeybadger/)
+      expect(@backtrace.lines[2].source[8]).to match(/end/)
     end
   end
 
-  should "fail gracefully when looking up snippet and file doesn't exist" do
+  it "fails gracefully when looking up snippet and file doesn't exist" do
     array = [
       "app/models/user.rb:13:in `magic'",
       "app/controllers/users_controller.rb:8:in `index'"
@@ -112,17 +112,17 @@ class BacktraceTest < Test::Unit::TestCase
 
     backtrace = Honeybadger::Backtrace.parse(array)
 
-    assert_equal backtrace.lines[0].source, {}
-    assert_equal backtrace.lines[1].source, {}
+    expect(backtrace.lines[0].source).to be_empty
+    expect(backtrace.lines[1].source).to be_empty
   end
 
-  should "have an empty application trace by default" do
+  it "has an empty application trace by default" do
     backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
-    assert_equal backtrace.application_lines, []
+    expect(backtrace.application_lines).to be_empty
   end
 
   context "with a project root" do
-    setup do
+    before(:each) do
       @project_root = '/some/path'
       Honeybadger.configure {|config| config.project_root = @project_root }
 
@@ -139,27 +139,27 @@ class BacktraceTest < Test::Unit::TestCase
          "/lib/something.rb:41:in `open'"])
     end
 
-    should "filter out the project root" do
-      assert_equal @backtrace_without_root, @backtrace_with_root
+    it "filters out the project root" do
+      expect(@backtrace_without_root).to eq @backtrace_with_root
     end
 
-    should "have an application trace" do
-      assert_equal @backtrace_without_root.application_lines, @backtrace_without_root.lines[0..1]
+    it "has an application trace" do
+      expect(@backtrace_without_root.application_lines).to eq @backtrace_without_root.lines[0..1]
     end
 
-    should "filter ./vendor from application trace" do
-      assert_does_not_contain @backtrace_without_root.application_lines, @backtrace_without_root.lines[2]
+    it "filters ./vendor from application trace" do
+      expect(@backtrace_without_root.application_lines).not_to include(@backtrace_without_root.lines[2])
     end
   end
 
   context "with a project root equals to a part of file name" do
-    setup do
+    before(:each) do
       # Heroku-like
       @project_root = '/app'
       Honeybadger.configure {|config| config.project_root = @project_root }
     end
 
-    should "filter out the project root" do
+    it "filters out the project root" do
       backtrace_with_root = Honeybadger::Backtrace.parse(
         ["#{@project_root}/app/models/user.rb:7:in `latest'",
          "#{@project_root}/app/controllers/users_controller.rb:13:in `index'",
@@ -170,16 +170,16 @@ class BacktraceTest < Test::Unit::TestCase
             "[PROJECT_ROOT]/app/controllers/users_controller.rb:13:in `index'",
             "/lib/something.rb:41:in `open'"])
 
-            assert_equal backtrace_without_root, backtrace_with_root
+         expect(backtrace_without_root).to eq backtrace_with_root
     end
   end
 
   context "with a blank project root" do
-    setup do
+    before(:each) do
       Honeybadger.configure {|config| config.project_root = '' }
     end
 
-    should "not filter line numbers with respect to any project root" do
+    it "does not filter line numbers with respect to any project root" do
       backtrace = ["/app/models/user.rb:7:in `latest'",
                    "/app/controllers/users_controller.rb:13:in `index'",
                    "/lib/something.rb:41:in `open'"]
@@ -190,11 +190,11 @@ class BacktraceTest < Test::Unit::TestCase
       backtrace_without_root =
         Honeybadger::Backtrace.parse(backtrace)
 
-      assert_equal backtrace_without_root, backtrace_with_root
+      expect(backtrace_without_root).to eq backtrace_with_root
     end
   end
 
-  should "remove notifier trace" do
+  it "removes notifier trace" do
     inside_notifier  = ['lib/honeybadger.rb:13:in `voodoo`']
     outside_notifier = ['users_controller:8:in `index`']
 
@@ -202,35 +202,33 @@ class BacktraceTest < Test::Unit::TestCase
     with_inside    = Honeybadger::Backtrace.parse(inside_notifier + outside_notifier,
                                                   :filters => default_filters)
 
-    assert_equal without_inside, with_inside
+    expect(without_inside).to eq with_inside
   end
 
-  should "run filters on the backtrace" do
+  it "runs filters on the backtrace" do
     filters = [lambda { |line| line.sub('foo', 'bar') }]
     input = Honeybadger::Backtrace.parse(["foo:13:in `one'", "baz:14:in `two'"],
                                          :filters => filters)
     expected = Honeybadger::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
-    assert_equal expected, input
+    expect(expected).to eq input
   end
 
-  should "alias #to_ary as #to_a" do
+  it "aliases #to_ary as #to_a" do
     backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
 
-    assert_equal backtrace.to_a, backtrace.to_ary
+    expect(backtrace.to_a).to eq backtrace.to_ary
   end
 
-  should "generate json from to_array template" do
+  it "generates json from to_array template" do
     backtrace = Honeybadger::Backtrace.parse(build_backtrace_array)
     array = [{'foo' => 'bar'}]
-    backtrace.expects(:to_ary).once.returns(array)
+    backtrace.should_receive(:to_ary).once.and_return(array)
     json = backtrace.to_json
 
     payload = nil
-    assert_nothing_raised do
-      payload = JSON.parse(json)
-    end
+    expect { payload = JSON.parse(json) }.not_to raise_error
 
-    assert_equal payload, array
+    expect(payload).to eq array
   end
 
   def build_backtrace_array

data/{test/unit/capistrano_test.rb → spec/honeybadger/capistrano_spec.rb}

@@ -1,11 +1,10 @@
-require 'test_helper'
+require 'spec_helper'
 
 require 'capistrano/configuration'
 require 'honeybadger/capistrano'
 
-class CapistranoTest < Test::Unit::TestCase
-  def setup
-    super
+describe Honeybadger::Capistrano do
+  before(:each) do
     reset_config
 
     @configuration = Capistrano::Configuration.new
@@ -13,11 +12,11 @@ class CapistranoTest < Test::Unit::TestCase
     @configuration.dry_run = true
   end
 
-  should "define honeybadger:deploy task" do
-    assert_not_nil @configuration.find_task('honeybadger:deploy')
+  it "defines honeybadger:deploy task" do
+    expect(@configuration.find_task('honeybadger:deploy')).not_to be_nil
   end
 
-  should "log when calling honeybadger:deploy task" do
+  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')
@@ -28,7 +27,7 @@ class CapistranoTest < Test::Unit::TestCase
     @configuration.logger = logger
     @configuration.find_and_execute_task('honeybadger:deploy')
 
-    assert io.string.include?('** Notifying Honeybadger of Deploy')
-    assert io.string.include?('** Honeybadger Notification Complete')
+    expect(io.string).to include '** Notifying Honeybadger of Deploy'
+    expect(io.string).to include '** Honeybadger Notification Complete'
   end
 end

data/{test/unit/configuration_test.rb → spec/honeybadger/configuration_spec.rb}

@@ -1,7 +1,8 @@
-require 'test_helper'
+require 'spec_helper'
+require 'socket'
 
-class ConfigurationTest < Test::Unit::TestCase
-  should "provide default values" do
+describe Honeybadger::Configuration do
+  it "provides default values" do
     assert_config_default :proxy_host,          nil
     assert_config_default :proxy_port,          nil
     assert_config_default :proxy_user,          nil
@@ -30,67 +31,67 @@ class ConfigurationTest < Test::Unit::TestCase
     assert_config_default :send_request_session, true
     assert_config_default :debug, false
     assert_config_default :fingerprint, nil
-    assert_config_default :hostname, nil
+    assert_config_default :hostname, Socket.gethostname
   end
 
-  should "configure async as Proc" do
+  it "configures async as Proc" do
     config = Honeybadger::Configuration.new
     async_handler = Proc.new { |n| n.deliver }
-    assert !config.async?, 'Configuration#async? should be falsey'
+    expect(config.async?).to be_false
     config.async = async_handler
-    assert config.async?, 'Configuration#async? should be truthy'
-    assert_equal config.async, async_handler
+    expect(config.async?).to be_true
+    expect(config.async).to be async_handler
   end
 
-  should "configure async with block" do
+  it "configures async with block" do
     config = Honeybadger::Configuration.new
-    assert !config.async?, 'Configuration#async? should be falsey'
+    expect(config.async?).to be_false
     config.async { |n| n }
-    assert config.async?, 'Configuration#async? should be truthy'
-    assert_equal config.async.call('foo'), 'foo'
+    expect(config.async?).to be_true
+    expect(config.async.call('foo')).to eq 'foo'
   end
 
-  should "configure fingerprint as Proc" do
+  it "configures fingerprint as Proc" do
     config = Honeybadger::Configuration.new
     fingerprint_generator = Proc.new { |n| n[:error_class] }
     config.fingerprint = fingerprint_generator
-    assert_equal config.fingerprint.call({ :error_class => 'foo' }), 'foo'
+    expect(config.fingerprint.call({ :error_class => 'foo' })).to eq 'foo'
   end
 
-  should "configure fingerprint with block" do
+  it "configures fingerprint with block" do
     config = Honeybadger::Configuration.new
     config.fingerprint { |n| n[:error_class] }
-    assert_equal config.fingerprint.call({ :error_class => 'foo' }), 'foo'
+    expect(config.fingerprint.call({ :error_class => 'foo' })).to eq 'foo'
   end
 
-  should "stub current_user_method" do
+  it "stubs current_user_method" do
     config = Honeybadger::Configuration.new
-    assert_nothing_raised { config.current_user_method = :foo }
+    expect { config.current_user_method = :foo }.not_to raise_error
   end
 
-  should "provide default values for secure connections" do
+  it "provides default values for secure connections" do
     config = Honeybadger::Configuration.new
     config.secure = true
-    assert_equal 443, config.port
-    assert_equal 'https', config.protocol
+    expect(config.port).to eq 443
+    expect(config.protocol).to eq 'https'
   end
 
-  should "provide default values for insecure connections" do
+  it "provides default values for insecure connections" do
     config = Honeybadger::Configuration.new
     config.secure = false
-    assert_equal 80, config.port
-    assert_equal 'http', config.protocol
+    expect(config.port).to eq 80
+    expect(config.protocol).to eq 'http'
   end
 
-  should "not cache inferred ports" do
+  it "does not cache inferred ports" do
     config = Honeybadger::Configuration.new
     config.secure = false
     config.port
     config.secure = true
-    assert_equal 443, config.port
+    expect(config.port).to eq 443
   end
 
-  should "allow values to be overwritten" do
+  it "allows values to be overwritten" do
     assert_config_overridable :proxy_host
     assert_config_overridable :proxy_port
     assert_config_overridable :proxy_user
@@ -114,11 +115,11 @@ class ConfigurationTest < Test::Unit::TestCase
     assert_config_overridable :hostname
   end
 
-  should "have an api key" do
+  it "has an api key" do
     assert_config_overridable :api_key
   end
 
-  should "act like a hash" do
+  it "acts like a hash" do
     config = Honeybadger::Configuration.new
     hash = config.to_hash
     [:api_key, :backtrace_filters, :development_environments,
@@ -128,25 +129,25 @@ class ConfigurationTest < Test::Unit::TestCase
      :proxy_host, :proxy_pass, :proxy_port, :proxy_user, :secure,
      :source_extract_radius, :async, :send_request_session, :debug,
      :fingerprint, :hostname].each do |option|
-       assert_equal config[option], hash[option], "Wrong value for #{option}"
+       expect(hash[option]).to eq config[option]
     end
   end
 
-  should "be mergable" do
+  it "is mergable" do
     config = Honeybadger::Configuration.new
     hash = config.to_hash
-    assert_equal hash.merge(:key => 'value'), config.merge(:key => 'value')
+    expect(hash.merge(:key => 'value')).to eq config.merge(:key => 'value')
   end
 
-  should "allow param filters to be appended" do
+  it "allows param filters to be appended" do
     assert_appends_value :params_filters
   end
 
-  should "allow ignored user agents to be appended" do
+  it "allows ignored user agents to be appended" do
     assert_appends_value :ignore_user_agent
   end
 
-  should "allow backtrace filters to be appended" do
+  it "allows backtrace filters to be appended" do
     assert_appends_value(:backtrace_filters) do |config|
       new_filter = lambda {}
       config.filter_backtrace(&new_filter)
@@ -154,7 +155,7 @@ class ConfigurationTest < Test::Unit::TestCase
     end
   end
 
-  should "allow ignore by filters to be appended" do
+  it "allows ignore by filters to be appended" do
     assert_appends_value(:ignore_by_filters) do |config|
       new_filter = lambda {}
       config.ignore_by_filter(&new_filter)
@@ -162,86 +163,111 @@ class ConfigurationTest < Test::Unit::TestCase
     end
   end
 
-  should "allow ignored exceptions to be appended" do
+  it "allows ignored exceptions to be appended" do
     config = Honeybadger::Configuration.new
     original_filters = config.ignore.dup
     new_filter = 'hello'
     config.ignore << new_filter
-    assert_same_elements original_filters + [new_filter], config.ignore
+    expect(original_filters + [new_filter]).to eq config.ignore
   end
 
-  should "allow ignored exceptions to be replaced" do
+  it "allows ignored exceptions to be replaced" do
     assert_replaces(:ignore, :ignore_only=)
   end
 
-  should "allow ignored user agents to be replaced" do
+  it "allows ignored user agents to be replaced" do
     assert_replaces(:ignore_user_agent, :ignore_user_agent_only=)
   end
 
-  should "use development and test as development environments by default" do
+  it "uses development and test as development environments by default" do
     config = Honeybadger::Configuration.new
-    assert_same_elements %w(development test cucumber), config.development_environments
+    expect(config.development_environments).to eq %w(development test cucumber)
   end
 
-  should "be public in a public environment" do
+  it "is public in a public environment" do
     config = Honeybadger::Configuration.new
     config.development_environments = %w(development)
     config.environment_name = 'production'
-    assert config.public?
+    expect(config.public?).to be_true
   end
 
-  should "not be public in a development environment" do
+  it "is not public in a development environment" do
     config = Honeybadger::Configuration.new
     config.development_environments = %w(staging)
     config.environment_name = 'staging'
-    assert !config.public?
+    expect(config.public?).to be_false
   end
 
-  should "be public without an environment name" do
+  it "is public without an environment name" do
     config = Honeybadger::Configuration.new
-    assert config.public?
+    expect(config.public?).to be_true
   end
 
-  should "use the assigned logger if set" do
+  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
+
+  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
+
+  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 not send metrics in a development environment" do
+    config = Honeybadger::Configuration.new
+    config.environment_name = 'development'
+    expect(config.metrics?).to be_false
+  end
+
+  it "uses the assigned logger if set" do
     config = Honeybadger::Configuration.new
     config.logger = "CUSTOM LOGGER"
-    assert_equal "CUSTOM LOGGER", config.logger
+    expect(config.logger).to eq "CUSTOM LOGGER"
   end
 
-  should 'give a new instance if non defined' do
+  it 'gives a new instance if non defined' do
     Honeybadger.configuration = nil
-    assert_kind_of Honeybadger::Configuration, Honeybadger.configuration
+    expect(Honeybadger.configuration).to be_a Honeybadger::Configuration
   end
 
   def assert_config_default(option, default_value, config = nil)
     config ||= Honeybadger::Configuration.new
-    assert_equal default_value, config.send(option)
+    expect(config.send(option)).to eq default_value
   end
 
   def assert_config_overridable(option, value = 'a value')
     config = Honeybadger::Configuration.new
     config.send(:"#{option}=", value)
-    assert_equal value, config.send(option)
+    expect(config.send(option)).to eq value
   end
 
   def assert_appends_value(option, &block)
     config = Honeybadger::Configuration.new
     original_values = config.send(option).dup
-    block ||= lambda do |config|
+    block ||= lambda do |c|
       new_value = 'hello'
-      config.send(option) << new_value
+      c.send(option) << new_value
       new_value
     end
     new_value = block.call(config)
-    assert_same_elements original_values + [new_value], config.send(option)
+    expect(original_values + [new_value]).to eq config.send(option)
   end
 
   def assert_replaces(option, setter)
     config = Honeybadger::Configuration.new
     new_value = 'hello'
     config.send(setter, [new_value])
-    assert_equal [new_value], config.send(option)
+    expect(config.send(option)).to eq [new_value]
     config.send(setter, new_value)
-    assert_equal [new_value], config.send(option)
+    expect(config.send(option)).to eq [new_value]
   end
 end