airbrake 4.3.8 → 5.0.0

data/features/step_definitions/rails_application_steps.rb

@@ -1,267 +0,0 @@
-require 'uri'
-
-require 'active_support/core_ext/string/inflections'
-
-Given /^Airbrake server is not responding$/ do
-  content = <<-CONTENT
-  require 'sham_rack'
-
-  ShamRack.at("api.airbrake.io") {["500", { "Content-type" => "text/xml" }, ["Internal server error"]]}
-
-  CONTENT
-  target = File.join(rails_root, 'config', 'initializers', 'airbrake_shim.rb')
-  File.open(target,"w") { |f| f.write content }
-end
-
-Then /^I should (?:(not ))?receive a Airbrake notification$/ do |negator|
-  steps %{
-    Then the output should #{negator}contain "** [Airbrake] Response from Airbrake:"
-    And the output should #{negator}contain "b6817316-9c45-ed26-45eb-780dbb86aadb"
-    And the output should #{negator}contain "http://airbrake.io/locate/b6817316-9c45-ed26-45eb-780dbb86aadb"
-  }
-end
-
-Then /^I should receive two Airbrake notifications$/ do
-  step %{the output should match /\[Airbrake\] Response from Airbrake:/}
-end
-
-When /^I configure the Airbrake shim$/ do
-  shim_file = File.join(PROJECT_ROOT, 'features', 'support', 'airbrake_shim.rb.template')
-  target = File.join(rails_root, 'config', 'initializers', 'airbrake_shim.rb')
-  FileUtils.cp(shim_file, target)
-end
-
-When /^I configure the notifier to use "([^\"]*)" as an API key$/ do |api_key|
-  steps %{
-    When I configure the notifier to use the following configuration lines:
-      """
-      config.api_key = #{api_key.inspect}
-      """
-  }
-end
-
-When /^I configure the notifier to use the following configuration lines:$/ do |configuration_lines|
-  initializer_code = <<-EOF
-    Airbrake.configure do |config|
-      config.test_mode = true
-      #{configuration_lines}
-    end
-  EOF
-
-  File.open(rails_initializer_file, 'w') { |file| file.write(initializer_code) }
-end
-
-def rails_initializer_file
-  File.join(rails_root, 'config', 'initializers', 'airbrake.rb')
-end
-
-def rails_non_initializer_airbrake_config_file
-  File.join(rails_root, 'config', 'airbrake.rb')
-end
-
-Then /^I should (?:(not ))?see "([^\"]*)"$/ do |negator,expected_text|
-  step %{the output should #{negator}contain "#{expected_text}"}
-end
-
-When /^I install the "([^\"]*)" plugin$/ do |plugin_name|
-  FileUtils.mkdir_p("#{rails_root}/vendor/plugins/#{plugin_name}")
-end
-
-When /^I define a response for "([^\"]*)":$/ do |controller_and_action, definition|
-  controller_class_name, action = controller_and_action.split('#')
-  controller_name = controller_class_name.underscore
-  controller_file_name = File.join(rails_root, 'app', 'controllers', "#{controller_name}.rb")
-  File.open(controller_file_name, "w") do |file|
-    file.puts "class #{controller_class_name} < ApplicationController"
-    file.puts "def consider_all_requests_local; false; end"
-    file.puts "def local_request?; false; end"
-    file.puts "def #{action}"
-    file.puts definition
-    file.puts "end"
-    file.puts "end"
-  end
-end
-
-When /^I perform a request to "([^\"]*)"$/ do |uri|
-  perform_request(uri)
-  step %{I run `bundle exec rails runner request.rb`}
-end
-
-When /^I perform a request to "([^\"]*)" in the "([^\"]*)" environment$/ do |uri, environment|
-  perform_request(uri,environment)
-  step %{I run `bundle exec rails runner -e #{environment} request.rb`}
-end
-
-Given /^the response page for a "([^\"]*)" error is$/ do |error, html|
-  File.open(File.join(rails_root, "public", "#{error}.html"), "w") do |file|
-    file.write(html)
-  end
-end
-
-Then /^I should see the Rails version$/ do
-  step %{I should see "Rails: #{ENV["RAILS_VERSION"]}"}
-end
-
-Then /^I should see that "([^\"]*)" is not considered a framework gem$/ do |gem_name|
-  step %{I should not see "[R] #{gem_name}"}
-end
-
-When /^I route "([^\"]*)" to "([^\"]*)"$/ do |path, controller_action_pair|
-  route = %(get "#{path}", :to => "#{controller_action_pair}")
-  routes_file = File.join(rails_root, "config", "routes.rb")
-  File.open(routes_file, "r+") do |file|
-    content = file.read
-    content.gsub!(/^end$/, "  #{route}\nend")
-    file.rewind
-    file.write(content)
-  end
-end
-
-Then /^"([^\"]*)" should not contain "([^\"]*)"$/ do |file_path, text|
-  actual_text = IO.read(File.join(rails_root, file_path))
-  if actual_text.include?(text)
-    raise "Didn't expect text:\n#{actual_text}\nTo include:\n#{text}"
-  end
-end
-
-Then /^my Airbrake configuration should contain the following line:$/ do |line|
-  configuration_file = rails_initializer_file
-
-  configuration = File.read(configuration_file)
-  if ! configuration.include?(line.strip)
-    raise "Expected text:\n#{configuration}\nTo include:\n#{line}\nBut it didn't."
-  end
-end
-
-When /^I configure the Heroku shim with "([^\"]*)"( and multiple app support)?$/ do |api_key, multi_app|
-  heroku_script_bin = File.join(TEMP_DIR, "bin")
-  FileUtils.mkdir_p(heroku_script_bin)
-  heroku_script     = File.join(heroku_script_bin, "heroku")
-  heroku_env_vars = <<-VARS
-AIRBRAKE_API_KEY    => myapikey
-  APP_NAME            => cold-moon-2929
-  BUNDLE_WITHOUT      => development:test
-  COMMIT_HASH         => lj32j42ss9332jfa2
-  DATABASE_URL        => postgres://fchovwjcyb:QLPVWmBBbf4hCG_YMrtV@ec3-107-28-193-23.compute-1.amazonaws.com/fhcvojwwcyb
-  LANG                => en_US.UTF-8
-  LAST_GIT_BY         => kensa
-  RACK_ENV            => production
-  SHARED_DATABASE_URL => postgres://fchovwjcyb:QLPVwMbbbF8Hcg_yMrtV@ec2-94-29-181-224.compute-1.amazonaws.com/fhcvojcwwyb
-  STACK               => bamboo-mri-1.9.2
-  URL                 => cold-moon-2929.heroku.com
-  VARS
-  single_app_script = <<-SINGLE
-#!/bin/bash
-if [ $1 == 'config' ]
-then
-  echo "#{heroku_env_vars}"
-fi
-  SINGLE
-
-  multi_app_script = <<-MULTI
-#!/bin/bash
-if [[ $1 == 'config' && $2 == '--app' ]]
-then
-  echo "#{heroku_env_vars}"
-fi
-  MULTI
-
-  File.open(heroku_script, "w") do |f|
-    if multi_app
-      f.puts multi_app_script
-    else
-      f.puts single_app_script
-    end
-  end
-  FileUtils.chmod(0755, heroku_script)
-  prepend_path(heroku_script_bin)
-end
-
-When /^I configure the application to filter parameter "([^\"]*)"$/ do |parameter|
-  application_filename = File.join(rails_root, 'config', 'application.rb')
-  application_lines = File.open(application_filename).readlines
-
-  application_definition_line       = application_lines.detect { |line| line =~ /Application/ }
-  application_definition_line_index = application_lines.index(application_definition_line)
-
-  parameter = (parameter == "block" ? "lambda { |x,y| x }" : parameter.inspect)
-  application_lines.insert(application_definition_line_index + 1, "    config.filter_parameters += [#{parameter}]")
-
-  File.open(application_filename, "w") do |file|
-    file.puts application_lines.join("\n")
-  end
-end
-
-When /^I have set up authentication system in my app that uses "([^\"]*)"$/ do |current_user|
-  application_controller = File.join(rails_root, 'app', 'controllers', "application_controller.rb")
-  definition =
-    """
-  class ApplicationController < ActionController::Base
-    def consider_all_requests_local; false; end
-    def local_request?; false; end
-
-    # this is the ultimate authentication system, devise is history
-    def #{current_user}
-      Struct.new(:id, :name, :email, :username, :class_name).new(1, 'Bender', 'bender@beer.com', 'b3nd0r', 'User')
-    end
-  end
-  """
-  File.open(application_controller, "w") {|file| file.puts definition }
-end
-
-Then /^the Airbrake notification should contain "([^\"]*)"$/ do |content|
-  step %{the last notice sent should contain "#{content}"}
-end
-
-Then /^the Airbrake notification should not contain "([^\"]*)"$/ do |content|
-  step %{the last notice sent should not contain "#{content}"}
-end
-
-Then /^the Airbrake notification should contain the custom user details$/ do
-  step %{the last notice sent should contain "<name>Bender</name>"}
-  step %{the last notice sent should contain "<email>bender@beer.com</email>"}
-  step %{the last notice sent should contain "<username>b3nd0r</username>"}
-end
-
-Then /^the Airbrake notification should contain user details$/ do
-  step %{the last notice sent should contain "<id>1</id>"}
-end
-
-Then /^the Airbrake notification should not contain any of the sensitive Rack variables$/ do
-  sensitive_rack_data_regex = FILTERED_RACK_VARS.map do |var|
-    var.instance_of?(Regexp) ? var : Regexp.quote(var)
-  end.join("|")
-  step %{the last notice sent should not contain keys with "#{sensitive_rack_data_regex}"}
-end
-
-Then /^the last notice sent should contain "([^\"]*)"$/ do |data|
-  last_notice = File.read(LAST_NOTICE)
-  last_notice.should match(%r{#{data}})
-end
-
-Then /^the last notice sent should not contain "([^\"]*)"$/ do |data|
-  last_notice = File.read(LAST_NOTICE)
-  last_notice.should_not match(%r{#{data}})
-end
-
-Then /^the last notice sent should not contain keys with "([^\"]*)"$/ do |data|
-  last_notice = File.read(LAST_NOTICE)
-  last_notice.should_not match(%r{key\=\"(#{data})\"})
-end
-
-Then /^the Airbrake notification should contain the framework information$/ do
-  step %{the last notice sent should contain "Rails: #{ENV["RAILS_VERSION"]}"}
-end
-
-When /^I list the application's middleware and save it into a file$/ do
-  step %{I run `bash -c 'bundle exec rake middleware > middleware.dump'`}
-end
-
-Then /^the Airbrake middleware should be placed correctly$/ do
-  middleware_file = File.join(LOCAL_RAILS_ROOT, 'middleware.dump')
-  middleware      = File.read(middleware_file).split(/\n/)
-  airbrake_index  = middleware.rindex("use Airbrake::Rails::Middleware")
-  middleware_index = middleware.rindex("use ActionDispatch::DebugExceptions") ||
-    middleware.rindex("use ActionDispatch::ShowExceptions")
-  (airbrake_index > middleware_index).should be_true
-end

data/features/step_definitions/rake_steps.rb

@@ -1,22 +0,0 @@
-Given /I've prepared the Rakefile/ do
-  rakefile = File.join(PROJECT_ROOT, 'features', 'support', 'rake', 'Rakefile')
-  target = File.join(TEMP_DIR, 'Rakefile')
-  FileUtils.cp(rakefile, target)
-end
-
-When /I run rake with (.+)/ do |command|
-  command = "rake #{command.gsub(' ','_')}"
-  step %{I run `#{command}`}
-end
-
-Then "Airbrake should not catch the exception" do
-  step %{I should not see "[airbrake]"}
-end
-
-Then "Airbrake should catch the exception" do
-  step %{I should see "[airbrake]"}
-end
-
-Then /^command "(.*?)" should be reported$/ do |command_name|
-  step %{the output should contain "[airbrake] rake #{command_name}"}
-end

data/features/support/airbrake_shim.rb.template

@@ -1,11 +0,0 @@
-require 'sham_rack'
-
-ShamRack.at("api.airbrake.io") do |env|
-  response = <<-end_xml
-<notice>
-<id>b6817316-9c45-ed26-45eb-780dbb86aadb</id>
-<url>http://airbrake.io/locate/b6817316-9c45-ed26-45eb-780dbb86aadb</url>
-</notice>
-  end_xml
-  ["200 OK", { "Content-type" => "text/xml" }, [response]]
-end

data/features/support/aruba.rb

@@ -1,5 +0,0 @@
-Before do
-  @aruba_timeout_seconds = 30
-  @aruba_io_wait_seconds = 5
-  @dirs = ["tmp"]
-end

data/features/support/env.rb

@@ -1,39 +0,0 @@
-require 'active_support'
-require 'nokogiri'
-require 'rspec'
-require 'aruba/cucumber'
-require 'pry'
-
-PROJECT_ROOT          = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
-TEMP_DIR              = File.join(PROJECT_ROOT, 'tmp').freeze
-LOCAL_RAILS_ROOT      = File.join(TEMP_DIR, 'rails_root').freeze
-RACK_FILE             = File.join(TEMP_DIR, 'rack_app.rb').freeze
-LAST_NOTICE           = File.join(PROJECT_ROOT, 'resources', 'notice.xml')
-ORIGINAL_RACK_FILTERS = File.join(PROJECT_ROOT, 'lib', 'airbrake', 'utils', 'rack_filters.rb')
-
-Before do
-  FileUtils.rm_rf(LOCAL_RAILS_ROOT)
-
-  reload_rack_filters
-end
-
-When /^I reset Bundler environment variable$/ do
-  BUNDLE_ENV_VARS.each do |key|
-    ENV[key] = nil
-  end
-end
-
-def prepend_path(path)
-  ENV['PATH'] = path + ":" + ENV['PATH']
-end
-
-def reload_rack_filters
-  original_filters = File.read(ORIGINAL_RACK_FILTERS)
-
-  Dir.mkdir(TEMP_DIR) unless Dir.exist?(TEMP_DIR)
-
-  File.write(File.join(TEMP_DIR, "rack_filters.rb"), 
-             original_filters.lines.to_a[1..-2].join("\n"))
-
-  require File.join(TEMP_DIR, "rack_filters.rb")
-end

data/features/support/matchers.rb

@@ -1,35 +0,0 @@
-RSpec::Matchers.define :have_content do |xpath, content|
-  match do |document|
-    @elements = document.search(xpath)
-
-    if @elements.empty?
-      false
-    else
-      element_with_content = document.at("#{xpath}[contains(.,'#{content}')]")
-
-      if element_with_content.nil?
-        @found = @elements.collect { |element| element.content }
-
-        false
-      else
-        true
-      end
-    end
-  end
-
-  failure_message_for_should do |document|
-    if @elements.empty?
-      "In XML:\n#{document}\nNo element at #{xpath}"
-    else
-      "In XML:\n#{document}\nGot content #{@found.inspect} at #{xpath} instead of #{content.inspect}"
-    end
-  end
-
-  failure_message_for_should_not do |document|
-    unless @elements.empty?
-      "In XML:\n#{document}\nExpcted no content #{content.inspect} at #{xpath}"
-    end
-  end
-end
-
-World(RSpec::Matchers)

data/features/support/rails.rb

@@ -1,156 +0,0 @@
-BUNDLE_ENV_VARS = %w(RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE)
-ORIGINAL_BUNDLE_VARS = Hash[ENV.select{ |key,value| BUNDLE_ENV_VARS.include?(key) }]
-
-ENV['RAILS_ENV'] = 'test'
-
-Before do
-  ENV['BUNDLE_GEMFILE'] = File.join(Dir.pwd, ENV['BUNDLE_GEMFILE']) unless ENV['BUNDLE_GEMFILE'].start_with?(Dir.pwd)
-  @framework_version = nil
-end
-
-After do |s|
-  ORIGINAL_BUNDLE_VARS.each_pair do |key, value|
-    ENV[key] = value
-  end
-  Cucumber.wants_to_quit = true if s.failed?
-end
-
-module RailsHelpers
-  def rails_root_exists?
-    File.exists?(environment_path)
-  end
-
-  def application_controller_filename
-    controller_filename = File.join(rails_root, 'app', 'controllers', "application_controller.rb")
-  end
-
-  def rails_3_or_4?
-    rails_version =~ /\A[34]/
-  end
-
-  def rails_root
-    LOCAL_RAILS_ROOT
-  end
-
-  def rails_uses_rack?
-    rails_3_or_4? || rails_version =~ /^2\.3/
-  end
-
-  def rails_version
-    @rails_version ||= begin
-      if ENV["RAILS_VERSION"]
-        ENV["RAILS_VERSION"]
-      elsif bundler_manages_gems?
-        rails_version = open(gemfile_path).read.match(/gem.*rails["'].*["'](.+)["']/)[1]
-      else
-        environment_file = File.join(rails_root, 'config', 'environment.rb')
-        rails_version = `grep RAILS_GEM_VERSION #{environment_file}`.match(/[\d.]+/)[0]
-      end
-    end
-  end
-
-  def bundler_manages_gems?
-    File.exists?(gemfile_path)
-  end
-
-  def gemfile_path
-    gemfile = File.join(rails_root, 'Gemfile')
-  end
-
-  def rails_manages_gems?
-    rails_version =~ /\A2\.[123]/
-  end
-
-  def rails_supports_initializers?
-    rails_3_or_4? || rails_version =~ /\A2\./
-  end
-
-  def rails_finds_generators_in_gems?
-    rails_3_or_4? || rails_version =~ /\A2\./
-  end
-
-  def version_string
-    ENV['RAILS_VERSION'] || `tail -n 1 SUPPORTED_RAILS_VERSIONS` # use latest version if ENV["RAILS_VERSION"] is undefined
-  end
-
-  def environment_path
-    File.join(rails_root, 'config', 'environment.rb')
-  end
-
-  def rakefile_path
-    File.join(rails_root, 'Rakefile')
-  end
-
-  def config_gem(gem_name, version = nil)
-    run     = "Rails::Initializer.run do |config|"
-    insert  = "  config.gem '#{gem_name}'"
-    insert += ", :version => '#{version}'" if version
-    content = File.read(environment_path)
-    content = "require 'thread'\n#{content}"
-    if content.sub!(run, "#{run}\n#{insert}")
-      File.open(environment_path, 'wb') { |file| file.write(content) }
-    else
-      raise "Couldn't find #{run.inspect} in #{environment_path}"
-    end
-  end
-
-  def config_gem_dependencies
-    insert = <<-END
-    if Gem::VERSION >= "1.3.6"
-      module Rails
-        class GemDependency
-          def requirement
-            r = super
-            (r == Gem::Requirement.default) ? nil : r
-          end
-        end
-      end
-    end
-    END
-    run     = "Rails::Initializer.run do |config|"
-    content = File.read(environment_path)
-    if content.sub!(run, "#{insert}\n#{run}")
-      File.open(environment_path, 'wb') { |file| file.write(content) }
-    else
-      raise "Couldn't find #{run.inspect} in #{environment_path}"
-    end
-  end
-
-  def require_thread
-    content = File.read(rakefile_path)
-    content = "require 'thread'\n#{content}"
-    File.open(rakefile_path, 'wb') { |file| file.write(content) }
-  end
-
-  def perform_request(uri, environment = 'production')
-    request_script = <<-SCRIPT
-require File.expand_path('../config/environment', __FILE__)
-
-env      = Rack::MockRequest.env_for(#{uri.inspect})
-response = RailsRoot::Application.call(env)
-
-response = response.last if response.last.is_a?(ActionDispatch::Response)
-
-if response.is_a?(Array)
-  puts "Status: " + response.first.to_s
-  puts "Headers: " + response.second.to_s
-  if response.last.respond_to?(:each)
-    # making it work even with Rack::BodyProxy
-    body = ""
-    response.last.each do |chunk|
-      body << chunk
-    end
-    response.pop
-    response << body
-  end
-  puts "Body: " + response.last.to_s
-else
-  puts response.body
-end
-    SCRIPT
-    File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
-  end
-
-end
-
-World(RailsHelpers)

data/features/support/rake/Rakefile

@@ -1,77 +0,0 @@
-# A test harness for RakeHandler
-#
-require 'rake'
-require 'rubygems'
-require 'airbrake'
-require 'airbrake/rake_handler'
-
-class IgnoredException < StandardError; end
-
-Airbrake.configure do |c|
-  c.ignore_rake_only = ["IgnoredException"]
-end
-
-# Should catch exception
-task :airbrake do
-  Airbrake.configuration.rescue_rake_exceptions = true
-  stub_tty_output(true)
-  raise_exception 
-end
-
-# Should not catch exception
-task :airbrake_disabled do
-  Airbrake.configuration.rescue_rake_exceptions = false
-  stub_tty_output(true)
-  raise_exception 
-end
-
-# Should ignore the exception
-task :airbrake_ignored do
-  Airbrake.configuration.rescue_rake_exceptions = true
-  stub_tty_output(true)
-  raise_exception(IgnoredException)
-end
-
-# Should not catch exception as tty_output is true
-task :airbrake_autodetect_from_terminal do
-  Airbrake.configuration.rescue_rake_exceptions = nil
-  stub_tty_output(true) 
-  raise_exception 
-end
-
-# Should catch exception as tty_output is false
-task :airbrake_autodetect_not_from_terminal do
-  Airbrake.configuration.rescue_rake_exceptions = nil
-  stub_tty_output(false) 
-  raise_exception 
-end
-
-task :airbrake_not_yet_configured do
-  Airbrake.configuration.rescue_rake_exceptions = true
-  stub_tty_output(true)
-  stub_empty_sender
-  raise_exception
-end
-
-module Airbrake
-  def self.send_notice(notice)
-    $stderr.puts "[airbrake] #{notice.component}"
-  end
-end
-
-def stub_empty_sender
-  Airbrake.sender = nil
-end
-
-def stub_tty_output(value)
-  Rake.application.instance_eval do
-    @tty_output_stub = value
-    def tty_output?
-      @tty_output_stub
-    end
-  end
-end
-
-def raise_exception(exception_class = StandardError)
-  raise exception_class.new('TEST')
-end

data/features/user_informer.feature

@@ -1,57 +0,0 @@
-Feature: Inform the user of the airbrake notice that was just created
-
-  Background:
-    Given I successfully run `rails new rails_root -O --skip-gemfile`
-    And I cd to "rails_root"
-    And I configure the Airbrake shim
-
-  Scenario: Rescue an exception in a controller
-    When I run `rails generate airbrake -k myapikey`
-    And I define a response for "TestController#index":
-      """
-      raise RuntimeError, "some message"
-      """
-    And the response page for a "500" error is
-      """
-      <!-- AIRBRAKE ERROR -->
-      """
-    And I route "/test/index" to "test#index"
-    And I perform a request to "http://example.com:123/test/index?param=value" in the "production" environment
-    Then I should see "Airbrake Error b6817316-9c45-ed26-45eb-780dbb86aadb"
-
-  Scenario: Rescue an exception in a controller with a custom error string
-    When I configure the notifier to use the following configuration lines:
-    """
-    config.api_key = "myapikey"
-    config.user_information = 'Error #{{ error_id }}'
-    """
-    And I run `rails generate airbrake -k myapikey`
-    And I define a response for "TestController#index":
-      """
-      raise RuntimeError, "some message"
-      """
-    And the response page for a "500" error is
-      """
-      <!-- AIRBRAKE ERROR -->
-      """
-    And I route "/test/index" to "test#index"
-    And I perform a request to "http://example.com:123/test/index?param=value" in the "production" environment
-    Then I should see "Error #b6817316-9c45-ed26-45eb-780dbb86aadb"
-
-  Scenario: Don't inform the user
-    When I configure the notifier to use the following configuration lines:
-    """
-    config.user_information = false
-    """
-    And I run `rails generate airbrake -k myapikey`
-    And I define a response for "TestController#index":
-      """
-      raise RuntimeError, "some message"
-      """
-    And the response page for a "500" error is
-      """
-      <!-- AIRBRAKE ERROR -->
-      """
-    And I route "/test/index" to "test#index"
-    And I perform a request to "http://example.com:123/test/index?param=value" in the "production" environment
-    Then I should not see "Airbrake Error b6817316-9c45-ed26-45eb-780dbb86aadb"