airbrake 3.1.6 → 11.0.0

data/script/integration_test.rb

@@ -1,38 +0,0 @@
-#!/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 ||= "api.airbrake.io"
-
-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_3.xsd

@@ -1,88 +0,0 @@
-<?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:element name="current-user" type="current-user" minOccurs="0"/>
-      </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" minOccurs="0">
-        <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:complexType name="current-user">
-    <xs:all>
-      <xs:element name="id" type="xs:string"/>
-      <xs:element name="name" type="xs:string" minOccurs="0"/>
-      <xs:element name="email" type="xs:string" minOccurs="0"/>
-      <xs:element name="username" type="xs:string" minOccurs="0"/>
-    </xs:all>
-  </xs:complexType>
-
-</xs:schema>

data/test/airbrake_tasks_test.rb

@@ -1,170 +0,0 @@
-require File.expand_path '../helper', __FILE__
-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",       :request => @response)
-          @http_proxy_class = stub("proxy_class", :new => @http_proxy)
-          @post             = stub("post",        :set_form_data => nil)
-
-          Net::HTTP.expects(:Proxy).
-            with(Airbrake.configuration.proxy_host,
-                 Airbrake.configuration.proxy_port,
-                 Airbrake.configuration.proxy_user,
-                 Airbrake.configuration.proxy_pass).
-            returns(@http_proxy_class)
-          Net::HTTP::Post.expects(:new).with("/deploys.txt").returns(@post)
-
-          @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, :request) do |expects|
-              expects.never
-            end
-          end
-        end
-
-        context "on deploy(options)" do
-          setup do
-            @output = AirbrakeTasks.deploy(@options)
-          end
-
-          before_should "post to http://api.airbrake.io:80/deploys.txt" do
-            @http_proxy_class.expects(:new).with("api.airbrake.io", 80).returns(@http_proxy)
-            @post.expects(:set_form_data).with(kind_of(Hash))
-            @http_proxy.expects(:request).with(any_parameters).returns(successful_response)
-          end
-
-          before_should "use the project api key" do
-            @post.expects(:set_form_data).
-              with(has_entries('api_key' => "1234123412341234"))
-          end
-
-          before_should "use send the rails_env param" do
-            @post.expects(:set_form_data).
-              with(has_entries("deploy[rails_env]" => "staging"))
-          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"
-              @post.expects(:set_form_data).
-                with(has_entries("deploy[#{key}]" => "value"))
-            end
-          end
-
-          before_should "use the :api_key param if it's passed in." do
-            @options[:api_key] = "value"
-            @post.expects(:set_form_data).
-              with(has_entries("api_key" => "value"))
-          end
-
-          before_should "puts the response body on success" do
-            AirbrakeTasks.expects(:puts).with("body")
-            @http_proxy.expects(:request).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(:request).with(any_parameters).returns(unsuccessful_response('body'))
-          end
-
-          should "return false on failure", :before => lambda {
-            @http_proxy.expects(:request).with(any_parameters).returns(unsuccessful_response('body'))
-          } do
-            assert !@output
-          end
-
-          should "return true on success", :before => lambda {
-            @http_proxy.expects(:request).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
-          @post             = stub("post",     :set_form_data => nil)
-          @http_proxy       = stub("proxy",    :request => @response)
-
-          @http_proxy_class = stub("proxy_class", :new => @http_proxy)
-          @http_proxy_class.expects(:new).with("custom.host", 80).returns(@http_proxy)
-          Net::HTTP.expects(:Proxy).with(any_parameters).returns(@http_proxy_class)
-          Net::HTTP::Post.expects(:new).with("/deploys.txt").returns(@post)
-          @post.expects(:set_form_data).with(kind_of(Hash))
-          @http_proxy.expects(:request).with(any_parameters).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

@@ -1,162 +0,0 @@
-require File.expand_path '../helper', __FILE__
-
-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 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