airbrake 3.0.rc1

data/features/step_definitions/rake_steps.rb

@@ -0,0 +1,17 @@
+When /I run rake with (.+)/ do |command|
+  @rake_command = "rake #{command.gsub(' ','_')}"
+  @rake_result = `cd features/support/rake && GEM_HOME=#{BUILT_GEM_ROOT} #{@rake_command} 2>&1`
+end
+
+Then /Airbrake should (|not) ?catch the exception/ do |condition|
+  if condition=='not'
+    @rake_result.should_not =~ /^airbrake/
+  else
+    @rake_result.should =~ /^airbrake/
+  end
+end
+
+Then /Airbrake should send the rake command line as the component name/ do
+  component = @rake_result.match(/^airbrake (.*)$/)[1]
+  component.should == @rake_command
+end

data/features/support/airbrake_shim.rb.template

@@ -0,0 +1,15 @@
+require 'sham_rack'
+
+ShamRack.at("airbrakeapp.com") do |env|
+  xml = env['rack.input'].read
+  puts "Recieved the following exception:\n#{xml}"
+  response = <<-end_xml
+<?xml version="1.0" encoding="UTF-8"?>
+<notice>
+  <error-id type="integer">3799307</error-id>
+  <url>http://sample.airbrakeapp.com/errors/3799307/notices/643732254</url>
+  <id type="integer">643732254</id>
+</notice>
+  end_xml
+  ["200 OK", { "Content-type" => "text/xml" }, response]
+end

data/features/support/env.rb

@@ -0,0 +1,18 @@
+require 'active_support'
+require 'nokogiri'
+require 'rspec'
+
+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
+BUILT_GEM_ROOT   = File.join(TEMP_DIR, 'built_gems').freeze
+LOCAL_GEM_ROOT   = File.join(TEMP_DIR, 'local_gems').freeze
+RACK_FILE        = File.join(TEMP_DIR, 'rack_app.rb').freeze
+
+Before do
+  FileUtils.mkdir_p(TEMP_DIR)
+  FileUtils.rm_rf(BUILT_GEM_ROOT)
+  FileUtils.rm_rf(LOCAL_RAILS_ROOT)
+  FileUtils.rm_f(RACK_FILE)
+  FileUtils.mkdir_p(BUILT_GEM_ROOT)
+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,181 @@
+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 rails3?
+    rails_version =~ /^3/
+  end
+
+  def rails_root
+    LOCAL_RAILS_ROOT
+  end
+
+  def rails_uses_rack?
+    rails3? || rails_version =~ /^2\.3/
+  end
+
+  def rails_version
+    @rails_version ||= begin
+      if 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 =~ /^2\.[123]/
+  end
+
+  def rails_supports_initializers?
+    rails3? || rails_version =~ /^2\./
+  end
+
+  def rails_finds_generators_in_gems?
+    rails3? || rails_version =~ /^2\./
+  end
+
+  def environment_path
+    File.join(rails_root, 'config', 'environment.rb')
+  end
+
+  def rakefile_path
+    File.join(rails_root, 'Rakefile')
+  end
+
+  def bundle_gem(gem_name, version = nil)
+    File.open(gemfile_path, 'a') do |file|
+      gem = "gem '#{gem_name}'"
+      gem += ", '#{version}'" if version
+      file.puts(gem)
+    end
+  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')
+    if rails3?
+      request_script = <<-SCRIPT
+        require 'config/environment'
+
+        env      = Rack::MockRequest.env_for(#{uri.inspect})
+        response = RailsRoot::Application.call(env).last
+
+        if response.is_a?(Array)
+          puts response.join
+        else
+          puts response.body
+        end
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/rails runner -e #{environment} request.rb")
+    elsif rails_uses_rack?
+      request_script = <<-SCRIPT
+        require 'config/environment'
+
+        env = Rack::MockRequest.env_for(#{uri.inspect})
+        app = Rack::Lint.new(ActionController::Dispatcher.new)
+
+        status, headers, body = app.call(env)
+
+        response = ""
+        if body.respond_to?(:to_str)
+          response << body
+        else
+          body.each { |part| response << part }
+        end
+
+        puts response
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/runner -e #{environment} request.rb")
+    else
+      uri = URI.parse(uri)
+      request_script = <<-SCRIPT
+        require 'cgi'
+        class CGIWrapper < CGI
+          def initialize(*args)
+            @env_table = {}
+            @stdinput = $stdin
+            super(*args)
+          end
+          attr_reader :env_table
+        end
+        $stdin = StringIO.new("")
+        cgi = CGIWrapper.new
+        cgi.env_table.update({
+          'HTTPS'          => 'off',
+          'REQUEST_METHOD' => "GET",
+          'HTTP_HOST'      => #{[uri.host, uri.port].join(':').inspect},
+          'SERVER_PORT'    => #{uri.port.inspect},
+          'REQUEST_URI'    => #{uri.request_uri.inspect},
+          'PATH_INFO'      => #{uri.path.inspect},
+          'QUERY_STRING'   => #{uri.query.inspect}
+        })
+        require 'dispatcher' unless defined?(ActionController::Dispatcher)
+        Dispatcher.dispatch(cgi)
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/runner -e #{environment} request.rb")
+    end
+  end
+end
+
+World(RailsHelpers)

data/features/support/rake/Rakefile

@@ -0,0 +1,57 @@
+# A test harness for RakeHandler
+#
+require 'rake'
+require 'rubygems'
+require 'airbrake'
+require 'airbrake/rake_handler'
+
+Airbrake.configure do |c|
+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 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
+
+module Airbrake
+  def self.notify(*args)
+    # TODO if you need to check more params, you'll have to use json.dump or something
+    $stderr.puts "airbrake #{args[1][:component]}"
+  end
+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
+  raise 'TEST'
+end

data/features/support/terminal.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+
+Before do
+  @terminal = Terminal.new
+end
+
+After do |story|
+  if story.failed?
+    # puts @terminal.output
+  end
+end
+
+class Terminal
+  attr_reader :output, :status
+  attr_accessor :environment_variables, :invoke_heroku_rake_tasks_locally
+
+  def initialize
+    @cwd = FileUtils.pwd
+    @output = ""
+    @status = 0
+    @logger = Logger.new(File.join(TEMP_DIR, 'terminal.log'))
+
+    @invoke_heroku_rake_tasks_locally = false
+
+    @environment_variables = {
+      "GEM_HOME" => LOCAL_GEM_ROOT,
+      "GEM_PATH" => "#{LOCAL_GEM_ROOT}:#{BUILT_GEM_ROOT}",
+      "PATH" => "#{gem_bin_path}:#{ENV['PATH']}"
+    }
+  end
+
+  def cd(directory)
+    @cwd = directory
+  end
+
+  def run(command)
+    command = optionally_invoke_heroku_rake_tasks_locally(command)
+
+    output << "#{command}\n"
+    FileUtils.cd(@cwd) do
+      # The ; forces ruby to shell out so the env settings work right
+      cmdline = "#{environment_settings} #{command} 2>&1 ; "
+      logger.debug(cmdline)
+      result = `#{cmdline}`
+      logger.debug(result)
+      output << result
+    end
+    @status = $?
+  end
+
+  def optionally_invoke_heroku_rake_tasks_locally(command)
+    if invoke_heroku_rake_tasks_locally
+      command.sub(/^heroku /, '')
+    else
+      command
+    end
+  end
+
+  def echo(string)
+    logger.debug(string)
+  end
+
+  def build_and_install_gem(gemspec)
+    pkg_dir = File.join(TEMP_DIR, 'pkg')
+    FileUtils.mkdir_p(pkg_dir)
+    output = `gem build #{gemspec} 2>&1`
+    gem_file = Dir.glob("*.gem").first
+    unless gem_file
+      raise "Gem didn't build:\n#{output}"
+    end
+    target = File.join(pkg_dir, gem_file)
+    FileUtils.mv(gem_file, target)
+    install_gem_to(LOCAL_GEM_ROOT, target)
+  end
+
+  def install_gem(gem)
+    install_gem_to(LOCAL_GEM_ROOT, gem)
+  end
+
+  def uninstall_gem(gem)
+    `gem uninstall -i #{LOCAL_GEM_ROOT} #{gem}`
+  end
+
+  def prepend_path(path)
+    @environment_variables['PATH'] = path + ":" + @environment_variables['PATH']
+  end
+
+  private
+
+  def install_gem_to(root, gem)
+    `gem install -i #{root} --no-ri --no-rdoc #{gem}`
+  end
+
+  def environment_settings
+    @environment_variables.map { |key, value| "#{key}=#{value}" }.join(' ')
+  end
+
+  def gem_bin_path
+    File.join(LOCAL_GEM_ROOT, "bin")
+  end
+
+  attr_reader :logger
+end

data/features/user_informer.feature

@@ -0,0 +1,63 @@
+Feature: Inform the user of the airbrake notice that was just created
+
+  Background:
+    Given I have built and installed the "airbrake" gem
+
+  Scenario: Rescue an exception in a controller
+    When I generate a new Rails application
+    And I configure the Airbrake shim
+    And I configure my application to require the "airbrake" gem
+    And I run the airbrake generator with "-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"
+    Then I should see "Airbrake Error 3799307"
+
+  Scenario: Rescue an exception in a controller with a custom error string
+    When I generate a new Rails application
+    And I configure the Airbrake shim
+    And I configure my application to require the "airbrake" gem
+    And I configure the notifier to use the following configuration lines:
+    """
+    config.user_information = 'Error #{{ error_id }}'
+    """
+    And I run the airbrake generator with "-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"
+    Then I should see "Error #3799307"
+
+  Scenario: Don't inform them user
+    When I generate a new Rails application
+    And I configure the Airbrake shim
+    And I configure my application to require the "airbrake" gem
+    And I configure the notifier to use the following configuration lines:
+    """
+    config.user_information = false
+    """
+    And I run the airbrake generator with "-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"
+    Then I should not see "Airbrake Error 3799307"