airbrake 3.1.6 → 11.0.0

data/features/step_definitions/rake_steps.rb

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

@@ -1,16 +0,0 @@
-require 'sham_rack'
-
-Airbrake.configuration.logger = Logger.new STDOUT if defined?(Airbrake)
-
-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>
-
-Request:
-#{env["rack.input"].read}
-  end_xml
-  ["200 OK", { "Content-type" => "text/xml" }, [response]]
-end

data/features/support/env.rb

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

@@ -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,201 +0,0 @@
-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 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 =~ /^2\.[123]/
-  end
-
-  def rails_supports_initializers?
-    rails3? || rails_version =~ /^2\./
-  end
-
-  def rails_finds_generators_in_gems?
-    rails3? || rails_version =~ /^2\./
-  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 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 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 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 File.expand_path('../config/environment', __FILE__)
-
-        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
-
-  def monkeypatch_old_version
-    monkeypatchin= <<-MONKEYPATCHIN
-
-    MissingSourceFile::REGEXPS << [/^cannot load such file -- (.+)$/i, 1]
-
-    MONKEYPATCHIN
-
-    File.open(File.join(rails_root,"config","initializers", 'monkeypatchin.rb'), 'w') { |file| file.write(monkeypatchin) }
-  end
-end
-
-World(RailsHelpers)

data/features/support/rake/Rakefile

@@ -1,68 +0,0 @@
-# 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
-
-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.notify_or_ignore(*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_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
-  raise 'TEST'
-end

data/features/support/terminal.rb

@@ -1,107 +0,0 @@
-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 flush!
-    @output = ""
-  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