party_fouls 1.5.6

data/lib/party_foul/issue_renderers/rack.rb

@@ -0,0 +1,54 @@
+class PartyFoul::IssueRenderers::Rack < PartyFoul::IssueRenderers::Base
+    
+  def request
+    @request ||= ::Rack::Request.new(env)
+  end      
+  
+  def comment_options
+    super.merge(URL: url, Params: params, Session: session, 'IP Address' => ip_address_locator, 'HTTP Headers' => http_headers)
+  end
+
+  # Rack params
+  #
+  # @return [Hash]
+  def params
+    request.params
+  end
+
+  # Link to IP address geolocator of the client who triggered the exception
+  #
+  # @return [String]
+  def ip_address_locator
+    "<a href='http://ipinfo.io/#{request.ip}'>#{request.ip}</a>"
+  end
+
+  def url
+    "[#{request.request_method}] #{env['REQUEST_URI']}"
+  end
+
+  # The session hash for the client at the time of the exception
+  #
+  # @return [Hash]
+  def session
+    request.session
+  end
+
+  # HTTP Headers hash from the request. Headers can be filtered out by
+  # adding matching key names to {PartyFoul.blacklisted_headers}
+  #
+  # @return [Hash]
+  def http_headers
+    {
+      Version: env['HTTP_VERSION'], 
+      'User Agent' => request.user_agent, 
+      'Accept Encoding' => env['HTTP_ACCEPT_ENCODING'], 
+      Accept: env['HTTP_ACCEPT'], 
+    }
+  end
+
+  private
+
+  def raw_title
+    %{(#{exception.class}) "#{exception.message}"}
+  end
+end

data/lib/party_foul/issue_renderers/rackless.rb

@@ -0,0 +1,25 @@
+require 'party_foul/issue_renderers/base'
+
+class PartyFoul::IssueRenderers::Rackless < PartyFoul::IssueRenderers::Base
+  # env in a rackless environment is expected to contain three keys:
+  # class: name of the class that raised the exception
+  # method: name of the method that raised the exception
+  # params: parameters passed to the method that raised the exception
+
+  # Rails params hash. Filtered parms are respected.
+  #
+  # @return [Hash]
+  def params
+    env[:params]
+  end
+
+  def comment_options
+    super.merge(Params: params)
+  end
+
+  private
+
+  def raw_title
+    %{#{env[:class]}##{env[:method]} (#{exception.class}) "#{exception.message}"}
+  end
+end

data/lib/party_foul/issue_renderers/rails.rb

@@ -0,0 +1,35 @@
+class PartyFoul::IssueRenderers::Rails < PartyFoul::IssueRenderers::Rack
+  # Rails params hash. Filtered parms are respected.
+  #
+  # @return [Hash]
+  def params
+    parameter_filter = ActionDispatch::Http::ParameterFilter.new(env["action_dispatch.parameter_filter"])
+    parameter_filter.filter(env['action_dispatch.request.parameters'] || {})
+  end
+
+  # Rails session hash. Filtered parms are respected.
+  #
+  # @return [Hash]
+  def session
+    parameter_filter = ActionDispatch::Http::ParameterFilter.new(env['action_dispatch.parameter_filter'])
+    parameter_filter.filter(env['rack.session'] || { } )
+  end
+
+  # The timestamp when the exception occurred. Will use Time.current when available to record
+  # the time with the proper timezone
+  #
+  # @return [String]
+  def occurred_at
+    @occurred_at ||= Time.current.strftime('%B %d, %Y %H:%M:%S %z')
+  end
+
+  private
+
+  def app_root
+    Rails.root.to_s
+  end
+
+  def raw_title
+    %{#{env['action_controller.instance'].class}##{(env['action_dispatch.request.parameters'] || {})['action']} (#{exception.class}) "#{exception.message}"}
+  end
+end

data/lib/party_foul/issue_renderers.rb

@@ -0,0 +1,5 @@
+module PartyFoul::IssueRenderers; end
+require 'party_foul/issue_renderers/base'
+require 'party_foul/issue_renderers/rack'
+require 'party_foul/issue_renderers/rails'
+require 'party_foul/issue_renderers/rackless'

data/lib/party_foul/middleware.rb

@@ -0,0 +1,32 @@
+module PartyFoul
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => captured_exception
+      if allow_handling?(captured_exception)
+        PartyFoul::ExceptionHandler.handle(captured_exception, env)
+      end
+      raise captured_exception
+    end
+
+    private
+
+    def allow_handling?(captured_exception)
+      !PartyFoul.blacklisted_exceptions.find do |blacklisted_exception|
+        names = blacklisted_exception.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+
+        constant === captured_exception
+      end
+    end
+  end
+end

data/lib/party_foul/processors/base.rb

@@ -0,0 +1,11 @@
+class PartyFoul::Processors::Base
+  # Passes the exception and rack env data to the ExceptionHandler and
+  # runs everything synchronously. This base class method must be
+  # overriden by any inheriting class.
+  #
+  # @param [Exception, Hash]
+  # @return [NotImplementedError]
+  def self.handle(exception, env)
+    raise NotImplementedError
+  end
+end

data/lib/party_foul/processors/delayed_job.rb

@@ -0,0 +1,16 @@
+require 'party_foul/processors/base'
+
+class PartyFoul::Processors::DelayedJob < PartyFoul::Processors::Base
+  @queue = 'party_foul'
+
+  # Passes the exception and rack env data to DelayedJob to be processed later
+  #
+  # @param [Exception, Hash]
+  def self.handle(exception, env)
+    new.delay(queue: @queue).perform(Marshal.dump(exception), Marshal.dump(env))
+  end
+
+  def perform(exception, env)
+    PartyFoul::ExceptionHandler.new(Marshal.load(exception), Marshal.load(env)).run
+  end
+end

data/lib/party_foul/processors/resque.rb

@@ -0,0 +1,16 @@
+require 'party_foul/processors/base'
+
+class PartyFoul::Processors::Resque < PartyFoul::Processors::Base
+  @queue = :party_foul
+
+  # Passes the exception and rack env data to Resque to be processed later
+  #
+  # @param [Exception, Hash]
+  def self.handle(exception, env)
+    Resque.enqueue(PartyFoul::Processors::Resque, Marshal.dump(exception), Marshal.dump(env))
+  end
+
+  def self.perform(exception, env)
+    PartyFoul::ExceptionHandler.new(Marshal.load(exception), Marshal.load(env)).run
+  end
+end

data/lib/party_foul/processors/sidekiq.rb

@@ -0,0 +1,17 @@
+require 'party_foul/processors/base'
+
+class PartyFoul::Processors::Sidekiq < PartyFoul::Processors::Base
+  include Sidekiq::Worker
+  sidekiq_options queue: 'party_foul'
+
+  # Passes the exception and rack env data to Sidekiq to be processed later
+  #
+  # @param [Exception, Hash]
+  def self.handle(exception, env)
+    perform_async(Marshal.dump(exception), Marshal.dump(env))
+  end
+
+  def perform(exception, env)
+    PartyFoul::ExceptionHandler.new(Marshal.load(exception), Marshal.load(env)).run
+  end
+end

data/lib/party_foul/processors/sync.rb

@@ -0,0 +1,11 @@
+require 'party_foul/processors/base'
+
+class PartyFoul::Processors::Sync < PartyFoul::Processors::Base
+  # Passes the exception and rack env data to the ExceptionHandler and
+  # runs everything synchronously.
+  #
+  # @param [Exception, Hash]
+  def self.handle(exception, env)
+    PartyFoul::ExceptionHandler.new(exception, env).run
+  end
+end

data/lib/party_foul/processors.rb

@@ -0,0 +1,2 @@
+module PartyFoul::Processors; end
+require 'party_foul/processors/sync'

data/lib/party_foul/rackless_exception_handler.rb

@@ -0,0 +1,17 @@
+class PartyFoul::RacklessExceptionHandler < PartyFoul::ExceptionHandler
+  # This handler will pass the exception and working environment from Rack off to a processor.
+  # The default PartyFoul processor will work synchronously. Processor adapters can be written
+  # to push this logic to a background job if desired.
+  #
+  # @param [Exception, Hash]
+  def self.handle(exception, env)
+    self.new(exception, clean_env(env)).run
+  end
+
+  # Uses the Rackless IssueRenderer for a rackless environment
+  #
+  # @param [Exception, Hash]
+  def initialize(exception, env)
+    self.rendered_issue = PartyFoul::IssueRenderers::Rackless.new(exception, env)
+  end
+end

data/lib/party_foul/version.rb

@@ -0,0 +1,3 @@
+module PartyFoul
+  VERSION = '1.5.6'.freeze
+end

data/lib/party_foul.rb

@@ -0,0 +1,92 @@
+require 'octokit'
+
+module PartyFoul
+  class << self
+    attr_accessor :github, :oauth_token, :owner, :repo, :additional_labels, :comment_limit, :title_prefix
+    attr_writer :branch, :web_url, :api_endpoint, :processor, :blacklisted_exceptions
+  end
+
+  # The git branch that is used for linking in the stack trace
+  #
+  # @return [String] Defaults to 'master' if not set
+  def self.branch
+    @branch ||= 'master'
+  end
+
+  # The web url for GitHub. This is only interesting for Enterprise
+  # users
+  #
+  # @return [String] Defaults to 'https://github.com' if not set
+  def self.web_url
+    @web_url ||= 'https://github.com'
+  end
+
+  # The api endpoint for GitHub. This is only interesting for Enterprise
+  # users
+  #
+  # @return [String] Defaults to 'https://api.github.com' if not set
+  def self.api_endpoint
+    @api_endpoint ||= 'https://api.github.com'
+  end
+
+  # The processor to be used when handling the exception. Defaults to a
+  # synchrons processor
+  #
+  # @return [Class] Defaults to 'PartyFoul::Processors:Sync
+  def self.processor
+    @processor ||= PartyFoul::Processors::Sync
+  end
+
+  # The collection of exceptions that should not be captured. Members of
+  # the collection must be string representations of the exception. For
+  # example:
+  #
+  #     # This is good
+  #     ['ActiveRecord::RecordNotFound']
+  #
+  #     # This is not
+  #     [ActiveRecord::RecordNotFound]
+  #
+  # @return [Array]
+  def self.blacklisted_exceptions
+    @blacklisted_exceptions || []
+  end
+
+  # The GitHub path to the repo
+  # Built using {.owner} and {.repo}
+  #
+  # @return [String]
+  def self.repo_path
+    "#{owner}/#{repo}"
+  end
+
+  # The url of the repository. Built using the {.web_url} and {.repo_path}
+  # values
+  #
+  # @return [String]
+  def self.repo_url
+    "#{web_url}/#{repo_path}"
+  end
+
+  # The configure block for PartyFoul. Use to initialize settings
+  #
+  #     PartyFoul.configure do |config|
+  #       config.owner 'dockyard'
+  #       config.repo  'test_app'
+  #       config.oauth_token = ENV['oauth_token']
+  #     end
+  #
+  # Will also setup for GitHub api connections
+  #
+  # @param [Block]
+  def self.configure
+    yield self
+    self.github = Octokit::Client.new access_token: oauth_token, api_endpoint: api_endpoint
+  end
+end
+
+require 'party_foul/exception_handler'
+require 'party_foul/rackless_exception_handler'
+require 'party_foul/issue_renderers'
+require 'party_foul/middleware'
+require 'party_foul/processors'

data/test/generator_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+require 'rails/generators/test_case'
+require 'generators/party_foul/install_generator'
+
+class PartyFoul::GeneratorTest < Rails::Generators::TestCase
+  destination File.expand_path('../tmp', __FILE__)
+  tests PartyFoul::InstallGenerator
+
+  test 'it copies the initializer' do
+    owner = 'test_owner'
+    repo  = 'test_repo'
+    octokit = mock('Octokit::Client')
+    octokit.expects(:create_authorization).with(scopes: ['repo'], note: 'PartyFoul test_owner/test_repo', note_url: 'http://example.com/test_owner/test_repo').returns(sawyer_resource({token: 'test_token'}))
+    Octokit::Client.stubs(:new).with(:login => 'test_login', :password => 'test_password', :api_endpoint => 'http://api.example.com').returns(octokit)
+    ::Readline.stubs(:readline).returns('test_login').then.returns('test_password').then.returns(owner).then.returns(repo).then.returns('http://api.example.com').then.returns('http://example.com').then.returns('')
+    run_generator
+
+    assert_file 'config/initializers/party_foul.rb' do |initializer|
+      assert_match(/config\.api_endpoint\s+=\s'http:\/\/api\.example\.com'/, initializer)
+      assert_match(/config\.web_url\s+=\s'http:\/\/example\.com'/, initializer)
+      assert_match(/config\.owner\s+=\s'test_owner'/, initializer)
+      assert_match(/config\.repo\s+=\s'test_repo'/, initializer)
+      assert_match(/config\.oauth_token\s+=\s'test_token'/, initializer)
+    end
+  end
+end

data/test/party_foul/configure_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+describe 'Party Foul Confg' do
+
+  after do
+    clean_up_party
+  end
+
+  it 'sets the proper config variables' do
+    PartyFoul.configure do |config|
+      config.blacklisted_exceptions = ['StandardError']
+      config.oauth_token        = 'test_token'
+      config.web_url            = 'http://example.com'
+      config.api_endpoint       = 'http://api.example.com'
+      config.owner              = 'test_owner'
+      config.repo               = 'test_repo'
+      config.branch             = 'master'
+      config.comment_limit      = 10
+    end
+
+    PartyFoul.blacklisted_exceptions.must_equal ['StandardError']
+    PartyFoul.github.must_be_instance_of Octokit::Client
+    PartyFoul.github.access_token.must_equal 'test_token'
+    PartyFoul.github.api_endpoint.must_equal 'http://api.example.com/'
+    PartyFoul.owner.must_equal 'test_owner'
+    PartyFoul.repo.must_equal 'test_repo'
+    PartyFoul.repo_path.must_equal 'test_owner/test_repo'
+    PartyFoul.repo_url.must_equal 'http://example.com/test_owner/test_repo'
+    PartyFoul.branch.must_equal 'master'
+    PartyFoul.comment_limit.must_equal 10
+  end
+
+  it 'has default values' do
+    PartyFoul.web_url.must_equal 'https://github.com'
+    PartyFoul.branch.must_equal  'master'
+  end
+end

data/test/party_foul/exception_handler_test.rb

@@ -0,0 +1,205 @@
+require 'test_helper'
+
+describe 'Party Foul Exception Handler' do
+  before do
+    PartyFoul.configure do |config|
+      config.oauth_token = 'abcdefg1234567890'
+      config.owner       = 'test_owner'
+      config.repo        = 'test_repo'
+    end
+
+    PartyFoul.stubs(:branch).returns('deploy')
+    PartyFoul::IssueRenderers::Rails.any_instance.stubs(:title).returns('Test Title')
+    PartyFoul::IssueRenderers::Rails.any_instance.stubs(:fingerprint).returns('test_fingerprint')
+  end
+
+  context 'when error is new' do
+    it 'will open a new error on GitHub' do
+      PartyFoul::IssueRenderers::Rails.any_instance.stubs(:body).returns('Test Body')
+      PartyFoul::IssueRenderers::Rails.any_instance.stubs(:comment).returns('Test Comment')
+      PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:open').returns(no_search_results)
+      PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:closed').returns(no_search_results)
+      PartyFoul.github.expects(:create_issue).with('test_owner/test_repo', 'Test Title', 'Test Body', labels: ['bug']).returns( {number: 1} )
+      PartyFoul.github.expects(:references).with('test_owner/test_repo', 'heads/deploy').returns( sawyer_resource({object: {sha: 'abcdefg1234567890'}}) )
+      PartyFoul.github.expects(:add_comment).with('test_owner/test_repo', 1, 'Test Comment')
+      PartyFoul::ExceptionHandler.new(nil, {}).run
+    end
+
+    context 'when additional labels are configured' do
+      before do
+        PartyFoul.configure do |config|
+          config.additional_labels = ['custom', 'label']
+        end
+      end
+      after do
+        clean_up_party
+      end
+      it 'will open a new error on GitHub with the additional labels' do
+        PartyFoul::IssueRenderers::Rails.any_instance.stubs(:body).returns('Test Body')
+        PartyFoul::IssueRenderers::Rails.any_instance.stubs(:comment).returns('Test Comment')
+        PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:open').returns(no_search_results)
+        PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:closed').returns(no_search_results)
+        PartyFoul.github.expects(:create_issue).with('test_owner/test_repo', 'Test Title', 'Test Body', :labels => ['bug', 'custom', 'label']).returns( { number: 1 } )
+        PartyFoul.github.expects(:references).with('test_owner/test_repo', 'heads/deploy').returns( sawyer_resource({object: {sha: 'abcdefg1234567890'}}) )
+        PartyFoul.github.expects(:add_comment).with('test_owner/test_repo', 1, 'Test Comment')
+        PartyFoul::ExceptionHandler.new(nil, {}).run
+      end
+    end
+
+    context 'when a proc for additional labels are configured' do
+      before do
+        PartyFoul.configure do |config|
+          config.additional_labels = Proc.new do |exception, env|
+            if env[:http_host] =~ /beta\./
+              ['beta']
+            elsif exception.message =~ /Database/
+              ['database_error']
+            end
+          end
+        end
+        PartyFoul::IssueRenderers::Rails.any_instance.stubs(:body).returns('Test Body')
+        PartyFoul::IssueRenderers::Rails.any_instance.stubs(:comment).returns('Test Comment')
+        PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:open').returns(no_search_results)
+        PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:closed').returns(no_search_results)
+        PartyFoul.github.expects(:references).with('test_owner/test_repo', 'heads/deploy').returns( sawyer_resource({object: {sha: 'abcdefg1234567890'}}) )
+        PartyFoul.github.expects(:add_comment).with('test_owner/test_repo', 1, 'Test Comment')
+      end
+      after do
+        clean_up_party
+      end
+
+      it 'will open a new error on GitHub with the default labels if no additional labels are returned from the proc' do
+        PartyFoul.github.expects(:create_issue).with('test_owner/test_repo', 'Test Title', 'Test Body', :labels => ['bug']).returns({ number: 1 })
+        PartyFoul::ExceptionHandler.new(stub(:message => ''), {}).run
+      end
+
+      it 'will open a new error on GitHub with the additional labels based on the exception message' do
+        PartyFoul.github.expects(:create_issue).with('test_owner/test_repo', 'Test Title', 'Test Body', :labels => ['bug', 'database_error']).returns({ number: 1 })
+        PartyFoul::ExceptionHandler.new(stub(:message => 'Database'), {}).run
+      end
+
+      it 'will open a new error on GitHub with the additional labels based on the env' do
+        PartyFoul.github.expects(:create_issue).with('test_owner/test_repo', 'Test Title', 'Test Body', :labels => ['bug', 'beta']).returns({ number: 1 })
+        PartyFoul::ExceptionHandler.new(stub(:message => ''), {:http_host => 'beta.example.com'}).run
+      end
+    end
+  end
+
+  context 'when error is not new' do
+    before do
+      PartyFoul::IssueRenderers::Rails.any_instance.stubs(:update_body).returns('New Body')
+      PartyFoul::IssueRenderers::Rails.any_instance.stubs(:comment).returns('Test Comment')
+    end
+
+    context 'and open' do
+      before do
+        PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:open').returns(
+          sawyer_resource({total_count: 1, incomplete_results: false, items:[{title: 'Test Title', body: 'Test Body', state: 'open', number: 1}]}) )
+        PartyFoul.github.expects(:update_issue).with('test_owner/test_repo', 1, 'Test Title', 'New Body', state: 'open')
+        PartyFoul.github.expects(:references).with('test_owner/test_repo', 'heads/deploy').returns(
+          sawyer_resource({object: {sha: 'abcdefg1234567890'}}) )
+      end
+
+      it 'will update the issue' do
+        PartyFoul.github.expects(:add_comment).with('test_owner/test_repo', 1, 'Test Comment')
+        PartyFoul::ExceptionHandler.new(nil, {}).run
+      end
+
+      it "doesn't post a comment if the limit has been met" do
+        PartyFoul.comment_limit = 10
+        PartyFoul::ExceptionHandler.any_instance.expects(:occurrence_count).returns(10)
+        PartyFoul.github.expects(:add_comment).never
+        PartyFoul::ExceptionHandler.new(nil, {}).run
+      end
+    end
+
+    context 'and closed' do
+      it 'will update the count on the body and re-open the issue' do
+        PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:open').returns(no_search_results)
+        PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:closed').returns(
+          sawyer_resource({total_count: 1, incomplete_results: false, items:[{title: 'Test Title', body: 'Test Body', state: 'closed', number: 1, labels: [{url: 'https://api.github.com/repos/test_owner/test_repo/labels/staging', name: 'staging', color: 'f29513'}]}]}) )
+        PartyFoul.github.expects(:update_issue).with('test_owner/test_repo', 1, 'Test Title', 'New Body', state: 'open', labels: ['bug', 'regression', 'staging'])
+        PartyFoul.github.expects(:add_comment).with('test_owner/test_repo', 1, 'Test Comment')
+        PartyFoul.github.expects(:references).with('test_owner/test_repo', 'heads/deploy').returns(sawyer_resource({object: {sha: 'abcdefg1234567890'}}))
+        PartyFoul::ExceptionHandler.new(nil, {}).run
+      end
+    end
+  end
+
+  context 'when issue is marked as "wontfix"' do
+    it 'does nothing' do
+      PartyFoul::IssueRenderers::Rails.any_instance.stubs(:body).returns('Test Body')
+      PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:open').returns(no_search_results)
+      PartyFoul.github.expects(:search_issues).with('test_fingerprint repo:test_owner/test_repo state:closed').returns(
+        sawyer_resource({total_count: 1, incomplete_results: false, items:[{title: 'Test Title', body: 'Test Body', state: 'closed', number: 1, labels: [{url: 'https://api.github.com/repos/test_owner/test_repo/labels/wontfix', name: 'wontfix', color: 'f29513'}]}]}) )
+      PartyFoul.github.expects(:create_issue).never
+      PartyFoul.github.expects(:update_issue).never
+      PartyFoul.github.expects(:add_comment).never
+      PartyFoul.github.expects(:references).never
+      PartyFoul::ExceptionHandler.new(nil, {}).run
+    end
+  end
+
+  describe '#occurrence_count' do
+    before do
+      @handler = PartyFoul::ExceptionHandler.new(nil, {})
+    end
+
+    it "returns the count" do
+      @handler.send(:occurrence_count, "<th>Count</th><td>1</td>").must_equal 1
+    end
+
+    it "returns 0 if no count is found" do
+      @handler.send(:occurrence_count, "Unexpected Body").must_equal 0
+    end
+  end
+
+  describe '#comment_limit_met?' do
+    before do
+      @handler = PartyFoul::ExceptionHandler.new(nil, {})
+    end
+
+    context "with no limit" do
+      it "returns false when there is no limit" do
+        PartyFoul.configure do |config|
+          config.comment_limit = nil
+        end
+        @handler.send(:comment_limit_met?, "").must_equal false
+      end
+    end
+
+    context "with a limit" do
+      before do
+        PartyFoul.configure do |config|
+          config.comment_limit = 10
+        end
+      end
+
+      it "returns false when there is a limit that has not been hit" do
+        @handler.stubs(:occurrence_count).returns(1)
+        @handler.send(:comment_limit_met?, "").must_equal false
+      end
+
+      it "returns true if the limit has been hit" do
+        @handler.stubs(:occurrence_count).returns(10)
+        @handler.send(:comment_limit_met?, "").must_equal true
+      end
+    end
+  end
+
+  describe '.clean_env' do
+    context 'when env contains file reference' do
+      before do
+        @env = { 
+          'action_dispatch.request.parameters' => {
+            :@tempfile => File.open(__FILE__)
+          }
+        }
+      end
+
+      it "marshal dump shouldn't reject values when they contain File" do
+        PartyFoul::ExceptionHandler.send(:clean_env, @env)['action_dispatch.request.parameters'].must_be_instance_of Hash
+      end
+    end
+  end
+end