airbrakeV4rails5 4.3.8

data/features/step_definitions/rake_steps.rb

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,11 @@
+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

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

data/features/support/env.rb

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,77 @@
+# 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

@@ -0,0 +1,57 @@
+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"

data/generators/airbrake/airbrake_generator.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + "/lib/insert_commands.rb")
+require File.expand_path(File.dirname(__FILE__) + "/lib/rake_commands.rb")
+
+class AirbrakeGenerator < Rails::Generator::Base
+  def add_options!(opt)
+    opt.on('-k', '--api-key=key', String, "Your Airbrake API key")                                               { |v| options[:api_key] = v}
+    opt.on('-h', '--heroku',              "Use the Heroku addon to provide your Airbrake API key")               { |v| options[:heroku]  = v}
+    opt.on('-a', '--app=myapp', String,   "Your Heroku app name (only required if deploying to >1 Heroku app)") { |v| options[:app]     = v}
+  end
+
+  def manifest
+    if !api_key_configured? && !options[:api_key] && !options[:heroku]
+      puts "Must pass --api-key or --heroku or create config/initializers/airbrake.rb"
+      exit
+    end
+    if plugin_is_present?
+      puts "You must first remove the airbrake plugin. Please run: script/plugin remove airbrake"
+      exit
+    end
+    record do |m|
+      m.directory 'lib/tasks'
+      m.file 'airbrake_tasks.rake', 'lib/tasks/airbrake_tasks.rake'
+      if ['config/deploy.rb', 'Capfile'].all? { |file| File.exists?(file) }
+        m.append_to 'config/deploy.rb', capistrano_hook
+      end
+      if api_key_expression
+        if use_initializer?
+          m.template 'initializer.rb', 'config/initializers/airbrake.rb',
+            :assigns => {:api_key => api_key_expression}
+        else
+          m.template 'initializer.rb', 'config/airbrake.rb',
+            :assigns => {:api_key => api_key_expression}
+          m.append_to 'config/environment.rb', "require 'config/airbrake'"
+        end
+      end
+      determine_api_key if heroku?
+      m.rake "airbrake:test", :generate_only => true
+    end
+  end
+
+  def api_key_expression
+    s = if options[:api_key]
+      "'#{options[:api_key]}'"
+    elsif options[:heroku]
+      "ENV['HOPTOAD_API_KEY']"
+    end
+  end
+
+  def determine_api_key
+    puts "Attempting to determine your API Key from Heroku..."
+    ENV['HOPTOAD_API_KEY'] = heroku_api_key
+    if ENV['HOPTOAD_API_KEY'] =~ /\S/
+      puts "... Done."
+      puts "Heroku's Airbrake API Key is '#{ENV['HOPTOAD_API_KEY']}'"
+    else
+      puts "... Failed."
+      puts "WARNING: We were unable to detect the Airbrake API Key from your Heroku environment."
+      puts "Your Heroku application environment may not be configured correctly."
+      exit 1
+    end
+  end
+
+  def heroku_var(var,app_name = nil)
+    app = app_name ? "--app #{app_name}" : ''
+    `heroku config #{app} | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
+  end
+
+  def heroku_api_key
+    heroku_var("(hoptoad|airbrake)_api_key",options[:app]).split.find {|x| x =~ /\S/ }
+  end
+
+  def heroku?
+    options[:heroku] ||
+      system("grep HOPTOAD_API_KEY config/initializers/airbrake.rb") ||
+      system("grep HOPTOAD_API_KEY config/environment.rb")
+  end
+
+  def use_initializer?
+    ::Rails::VERSION::MAJOR > 1
+  end
+
+  def api_key_configured?
+    File.exists?('config/initializers/airbrake.rb') ||
+      system("grep Airbrake config/environment.rb")
+  end
+
+  def capistrano_hook
+    IO.read(source_path('capistrano_hook.rb'))
+  end
+
+  def plugin_is_present?
+    File.exists?('vendor/plugins/airbrake')
+  end
+end