airbrake 3.0.rc1

data/rails/init.rb

@@ -0,0 +1 @@
+require 'airbrake/rails'

data/script/integration_test.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'logger'
+require 'fileutils'
+
+RAILS_ENV = "production"
+RAILS_ROOT = FileUtils.pwd
+RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'airbrake'
+require 'rails/init'
+
+fail "Please supply an API Key as the first argument" if ARGV.empty?
+
+host = ARGV[1]
+host ||= "airbrakeapp.com"
+
+secure = (ARGV[2] == "secure")
+
+exception = begin
+              raise "Testing airbrake notifier with secure = #{secure}. If you can see this, it works."
+            rescue => foo
+              foo
+            end
+
+Airbrake.configure do |config|
+  config.secure  = secure
+  config.host    = host
+  config.api_key = ARGV.first
+end
+puts "Configuration:"
+Airbrake.configuration.to_hash.each do |key, value|
+  puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+end
+puts "Sending #{secure ? "" : "in"}secure notification to project with key #{ARGV.first}"
+Airbrake.notify(exception)
+

data/test/airbrake_2_2.xsd

@@ -0,0 +1,78 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:element name="notice">
+    <xs:complexType>
+      <xs:all>
+        <xs:element name="api-key" type="xs:string"/>
+        <xs:element name="notifier" type="notifier"/>
+        <xs:element name="error" type="error"/>
+        <xs:element name="request" type="request" minOccurs="0"/>
+        <xs:element name="server-environment" type="serverEnvironment"/>
+      </xs:all>
+      <xs:attribute name="version" type="xs:string" use="required"/>
+    </xs:complexType>
+  </xs:element>
+
+  <xs:complexType name="notifier">
+    <xs:all>
+      <xs:element name="name" type="xs:string"/>
+      <xs:element name="version" type="xs:string"/>
+      <xs:element name="url" type="xs:string"/>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="error">
+    <xs:all>
+      <xs:element name="class" type="xs:string"/>
+      <xs:element name="message" type="xs:string" minOccurs="0"/>
+      <xs:element name="backtrace" type="backtrace"/>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="backtrace">
+    <xs:sequence>
+      <xs:element name="line" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:attribute name="file" type="xs:string" use="required"/>
+          <xs:attribute name="number" type="xs:string" use="required"/>
+          <xs:attribute name="method" type="xs:string" use="optional"/>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="request">
+    <xs:all>
+      <xs:element name="url" type="xs:string"/>
+      <xs:element name="component" type="xs:string"/>
+      <xs:element name="action" type="xs:string" minOccurs="0"/>
+      <xs:element name="params" type="varList" minOccurs="0"/>
+      <xs:element name="session" type="varList" minOccurs="0"/>
+      <xs:element name="cgi-data" type="varList" minOccurs="0"/>
+    </xs:all>
+  </xs:complexType>
+
+  <xs:complexType name="varList">
+    <xs:sequence>
+      <xs:element name="var" type="var" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="var" mixed="true">
+    <xs:sequence>
+      <xs:element name="var" type="var" minOccurs="0" maxOccurs="unbounded"/>
+    </xs:sequence>
+    <xs:attribute name="key" type="xs:string" use="required"/>
+  </xs:complexType>
+
+  <xs:complexType name="serverEnvironment">
+    <xs:sequence>
+      <xs:element name="project-root" type="xs:string" minOccurs="0"/>
+      <xs:element name="environment-name" type="xs:string"/>
+      <xs:element name="app-version" type="xs:string" minOccurs="0"/>
+      <xs:element name="hostname" type="xs:string" minOccurs="0"/>
+    </xs:sequence>
+  </xs:complexType>
+
+</xs:schema>

data/test/airbrake_tasks_test.rb

@@ -0,0 +1,163 @@
+require File.dirname(__FILE__) + '/helper'
+require 'rubygems'
+
+require File.dirname(__FILE__) + '/../lib/airbrake_tasks'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+class AirbrakeTasksTest < 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 { AirbrakeTasks.stubs(:puts) }
+
+    context "in a configured project" do
+      setup { Airbrake.configure { |config| config.api_key = "1234123412341234" } }
+
+      context "on deploy({})" do
+        setup { @output = AirbrakeTasks.deploy({}) }
+
+        before_should "complain about missing rails env" do
+          AirbrakeTasks.expects(:puts).with(regexp_matches(/rails 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", :post_form => @response)
+
+          Net::HTTP.expects(:Proxy).
+            with(Airbrake.configuration.proxy_host,
+                 Airbrake.configuration.proxy_port,
+                 Airbrake.configuration.proxy_user,
+                 Airbrake.configuration.proxy_pass).
+            returns(@http_proxy)
+
+          @options    = { :rails_env => "staging", :dry_run => false }
+        end
+        
+        context "performing a dry run" do
+          setup { @output = AirbrakeTasks.deploy(@options.merge(:dry_run => true)) }
+
+          should "return true without performing any actual request" do
+            assert_equal true, @output
+            assert_received(@http_proxy, :post_form) do|expects|
+              expects.never
+            end
+          end
+        end
+
+        context "on deploy(options)" do
+          setup do
+            @output = AirbrakeTasks.deploy(@options)
+          end
+
+          before_should "post to http://airbrakeapp.com/deploys.txt" do
+            URI.stubs(:parse).with('http://airbrakeapp.com/deploys.txt').returns(:uri)
+            @http_proxy.expects(:post_form).with(:uri, kind_of(Hash)).returns(successful_response)
+          end
+
+          before_should "use the project api key" do
+            @http_proxy.expects(:post_form).
+              with(kind_of(URI), has_entries('api_key' => "1234123412341234")).
+              returns(successful_response)
+          end
+
+          before_should "use send the rails_env param" do
+            @http_proxy.expects(:post_form).
+              with(kind_of(URI), has_entries("deploy[rails_env]" => "staging")).
+              returns(successful_response)
+          end
+
+          [:local_username, :scm_repository, :scm_revision].each do |key|
+            before_should "use send the #{key} param if it's passed in." do
+              @options[key] = "value"
+              @http_proxy.expects(:post_form).
+                with(kind_of(URI), has_entries("deploy[#{key}]" => "value")).
+                returns(successful_response)
+            end
+          end
+
+          before_should "use the :api_key param if it's passed in." do
+            @options[:api_key] = "value"
+            @http_proxy.expects(:post_form).
+              with(kind_of(URI), has_entries("api_key" => "value")).
+              returns(successful_response)
+          end
+
+          before_should "puts the response body on success" do
+            AirbrakeTasks.expects(:puts).with("body")
+            @http_proxy.expects(:post_form).with(any_parameters).returns(successful_response('body'))
+          end
+
+          before_should "puts the response body on failure" do
+            AirbrakeTasks.expects(:puts).with("body")
+            @http_proxy.expects(:post_form).with(any_parameters).returns(unsuccessful_response('body'))
+          end
+
+          should "return false on failure", :before => lambda {
+            @http_proxy.expects(:post_form).with(any_parameters).returns(unsuccessful_response('body'))
+          } do
+            assert !@output
+          end
+
+          should "return true on success", :before => lambda {
+            @http_proxy.expects(:post_form).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
+        Airbrake.configure do |config| 
+          config.api_key = "1234123412341234"
+          config.host = "custom.host"
+        end
+      end
+
+      context "on deploy(:rails_env => 'staging')" do
+        setup { @output = AirbrakeTasks.deploy(:rails_env => "staging") }
+
+        before_should "post to the custom host" do
+          URI.stubs(:parse).with('http://custom.host/deploys.txt').returns(:uri)
+          Net::HTTP.expects(:post_form).with(:uri, kind_of(Hash)).returns(successful_response)
+        end
+      end
+    end
+
+    context "when not configured" do
+      setup { Airbrake.configure { |config| config.api_key = "" } }
+
+      context "on deploy(:rails_env => 'staging')" do
+        setup { @output = AirbrakeTasks.deploy(:rails_env => "staging") }
+
+        before_should "complain about missing api key" do
+          AirbrakeTasks.expects(:puts).with(regexp_matches(/api key/i))
+        end
+
+        should "return false" do
+          assert !@output
+        end
+      end
+    end
+  end
+end

data/test/backtrace_test.rb

@@ -0,0 +1,163 @@
+require File.dirname(__FILE__) + '/helper'
+
+class BacktraceTest < Test::Unit::TestCase
+
+  should "parse a backtrace into lines" do
+    array = [
+      "app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"
+    ]
+
+    backtrace = Airbrake::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
+
+    line = backtrace.lines.last
+    assert_equal '8', line.number
+    assert_equal 'app/controllers/users_controller.rb', line.file
+    assert_equal 'index', line.method
+  end
+  
+  should "parse 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'"
+    ]
+
+    backtrace = Airbrake::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
+
+    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
+  end
+
+  should "be equal with equal lines" do
+    one = build_backtrace_array
+    two = one.dup
+    assert_equal one, two
+
+    assert_equal Airbrake::Backtrace.parse(one), Airbrake::Backtrace.parse(two)
+  end
+
+  should "parse massive one-line exceptions into multiple lines" do
+    original_backtrace = Airbrake::Backtrace.
+      parse(["one:1:in `one'\n   two:2:in `two'\n      three:3:in `three`"])
+    expected_backtrace = Airbrake::Backtrace.
+      parse(["one:1:in `one'", "two:2:in `two'", "three:3:in `three`"])
+
+    assert_equal expected_backtrace, original_backtrace
+  end
+
+  context "with a project root" do
+    setup do
+      @project_root = '/some/path'
+      Airbrake.configure {|config| config.project_root = @project_root }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "filter out the project root" do
+      backtrace_with_root = Airbrake::Backtrace.parse(
+        ["#{@project_root}/app/models/user.rb:7:in `latest'",
+         "#{@project_root}/app/controllers/users_controller.rb:13:in `index'",
+         "/lib/something.rb:41:in `open'"],
+        :filters => default_filters)
+      backtrace_without_root = Airbrake::Backtrace.parse(
+        ["[PROJECT_ROOT]/app/models/user.rb:7:in `latest'",
+         "[PROJECT_ROOT]/app/controllers/users_controller.rb:13:in `index'",
+         "/lib/something.rb:41:in `open'"])
+
+      assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  context "with a project root equals to a part of file name" do
+    setup do
+      # Heroku-like
+      @project_root = '/app'
+      Airbrake.configure {|config| config.project_root = @project_root }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "filter out the project root" do
+      backtrace_with_root = Airbrake::Backtrace.parse(
+        ["#{@project_root}/app/models/user.rb:7:in `latest'",
+         "#{@project_root}/app/controllers/users_controller.rb:13:in `index'",
+         "/lib/something.rb:41:in `open'"],
+        :filters => default_filters)
+      backtrace_without_root = Airbrake::Backtrace.parse(
+        ["[PROJECT_ROOT]/app/models/user.rb:7:in `latest'",
+         "[PROJECT_ROOT]/app/controllers/users_controller.rb:13:in `index'",
+         "/lib/something.rb:41:in `open'"])
+
+      assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  context "with a blank project root" do
+    setup do
+      Airbrake.configure {|config| config.project_root = '' }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "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'"]
+
+      backtrace_with_root =
+        Airbrake::Backtrace.parse(backtrace, :filters => default_filters)
+
+      backtrace_without_root =
+        Airbrake::Backtrace.parse(backtrace)
+
+      assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  should "remove notifier trace" do
+    inside_notifier  = ['lib/airbrake.rb:13:in `voodoo`']
+    outside_notifier = ['users_controller:8:in `index`']
+
+    without_inside = Airbrake::Backtrace.parse(outside_notifier)
+    with_inside    = Airbrake::Backtrace.parse(inside_notifier + outside_notifier,
+                                                      :filters => default_filters)
+
+    assert_equal without_inside, with_inside
+  end
+
+  should "run filters on the backtrace" do
+    filters = [lambda { |line| line.sub('foo', 'bar') }]
+    input = Airbrake::Backtrace.parse(["foo:13:in `one'", "baz:14:in `two'"],
+                                             :filters => filters)
+    expected = Airbrake::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
+    assert_equal expected, input
+  end
+
+  def build_backtrace_array
+    ["app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"]
+  end
+
+  def default_filters
+    Airbrake::Configuration::DEFAULT_BACKTRACE_FILTERS
+  end
+
+end