Testing coverage improvement (#410)

* Added unit tests for middleware stack

* Added rack middleware test

* Moved integration specs into folder, added rake spec

* Added warden_user_spec

* Added clearance user middleware tests

* Moved rake middleware test into rake integration spec

* Added unset request data test

* Added shoryuken spec

* Removed rack requirement

* Fix issue with cal;led function

* Added mailman spec

* Added resque integration spec

* Updated mailman spec

* Added que tests

Author: Cawllec

spec/integration_spec.rb

@@ -23,21 +23,6 @@
 
   let(:request) { JSON.parse(queue.pop) }
 
-  it 'should run the rake middleware when rake tasks crash' do
-    #Skips this test in ruby 1.9.3 with travis
-    unless ENV['TRAVIS'] && RUBY_VERSION == "1.9.3"
-      ENV['BUGSNAG_TEST_SERVER_PORT'] = server.config[:Port].to_s
-      task_fixtures_path = File.join(File.dirname(__FILE__), 'fixtures', 'tasks')
-      Dir.chdir(task_fixtures_path) do
-        system("bundle exec rake test:crash > /dev/null 2>&1")
-      end
-
-      result = request()
-      expect(result["events"][0]["metaData"]["rake_task"]).not_to be_nil
-      expect(result["events"][0]["metaData"]["rake_task"]["name"]).to eq("test:crash")
-    end
-  end
-
   it 'should send notifications over the wire' do
     Bugsnag.configure do |config|
       config.endpoint = "http://localhost:#{server.config[:Port]}"

spec/integrations/clearance_user_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Bugsnag::Middleware::ClearanceUser do
+  it "updates the reports user with warden parameters" do
+    callback = double
+
+    user = double
+    allow(user).to receive_messages(
+      :email => "TEST_EMAIL",
+      :name => "TEST_NAME",
+      :created_at => "TEST_NOW"
+    )
+
+    clearance = double
+    allow(clearance).to receive_messages(
+      :signed_in? => true,
+      :current_user => user
+    )
+
+    report = double("Bugsnag::Report") 
+    expect(report).to receive(:request_data).exactly(5).times.and_return({
+      :rack_env => {
+        :clearance => clearance
+      }
+    })
+
+    expect(report).to receive(:user=).with({
+      :email => "TEST_EMAIL",
+      :name => "TEST_NAME",
+      :created_at => "TEST_NOW"
+    })
+
+    expect(callback).to receive(:call).with(report)
+
+    middleware = Bugsnag::Middleware::ClearanceUser.new(callback)
+    middleware.call(report)
+  end
+end

spec/integrations/mailman_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe 'Bugsnag::Mailman', :order => :defined do
+  before do
+    unless defined?(::Mailman)
+      @mocked_mailman = true
+      class Mailman
+      end
+      module Kernel
+        alias_method :old_require, :require
+        def require(path)
+          old_require(path) unless /^mailman/.match(path)
+        end
+      end
+    end
+  end
+
+  it "should load Bugsnag::Mailman" do
+    config = double('mailman-config')
+    allow(Mailman).to receive(:config).and_return(config)
+    expect(config).to receive(:respond_to?).with(:middleware).and_return(true)
+    middleware = double('mailman-config-middleware')
+    expect(config).to receive(:middleware).and_return(middleware)
+    expect(middleware).to receive(:add).with(any_args)
+
+    #Kick off
+    require './lib/bugsnag/integrations/mailman'
+  end
+
+  it "can be called" do
+    config = double('config')
+    allow(Bugsnag).to receive(:configuration).and_return(config)
+    int_middleware = double('internal_middleware')
+    expect(config).to receive(:internal_middleware).and_return(int_middleware)
+    expect(int_middleware).to receive(:use).with(Bugsnag::Middleware::Mailman)
+    expect(config).to receive(:app_type=).with("mailman")
+
+    integration = Bugsnag::Mailman.new
+
+    mail = double('mail')
+    expect(config).to receive(:set_request_data).with(:mailman_msg, mail)
+    expect(mail).to receive(:to_s).and_return(mail)
+    allow(config).to receive(:clear_request_data)
+
+    exception = RuntimeError.new('oops')
+    report = double('report')
+    expect(Bugsnag).to receive(:notify).with(exception, true).and_yield(report)
+    expect(report).to receive(:severity=).with('error')
+    expect(report).to receive(:severity_reason=).with({
+      :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+      :attributes => Bugsnag::Mailman::FRAMEWORK_ATTRIBUTES
+    })
+    expect{integration.call(mail) {raise exception}}.to raise_error(exception)
+  end
+
+  after do
+    Object.send(:remove_const, :Mailman) if @mocked_mailman
+    module Kernel
+      alias_method :require, :old_require
+    end
+  end
+end
+
+
+describe Bugsnag::Middleware::Mailman do
+  it "adds mailman message to the metadata" do
+    callback = double
+
+    report = double("Bugsnag::Report")
+    expect(report).to receive(:request_data).and_return({
+      :mailman_msg => "test message"
+    })
+
+    expect(report).to receive(:add_tab).with(:mailman, {
+      "message" => "test message"
+    })
+
+    expect(callback).to receive(:call).with(report)
+
+    middleware = Bugsnag::Middleware::Mailman.new(callback)
+    middleware.call(report)
+  end
+end

spec/integrations/que_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Bugsnag::Que', :order => :defined do
+  before do
+    unless defined?(::Que)
+      @mocked_que = true
+      class ::Que
+      end
+    end
+  end
+
+  it "should create and register a que handler" do
+    error = RuntimeError.new("oops")
+    job = double('que_job')
+    expect(job).to receive(:dup).and_return({
+      :error_count => 0,
+      :job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
+      :args => [{"queue_name" => "foo", "arguments" => "bar"}],
+      :job_id => "ID"
+    })
+
+    report = double('report')
+    expect(Bugsnag).to receive(:notify).with(error, true).and_yield(report)
+    expect(report).to receive(:add_tab).with(:job, {
+      :error_count => 1,
+      :job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
+      :args => [{"queue_name" => "foo", "arguments" => "bar"}],
+      :job_id => "ID",
+      :wrapper_job_class => 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper',
+      :wrapper_job_id => "ID",
+      :queue => "foo",
+      :args => "bar"
+    })
+    expect(report).to receive(:severity=).with("error")
+    expect(report).to receive(:severity_reason=).with({
+      :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+      :attributes => {
+        :framework => 'Que'
+      }
+    })
+
+    allow(Que).to receive(:respond_to?).with(:error_notifier=).and_return(true)
+    config = double('config')
+    allow(Bugsnag).to receive(:configuration).and_return(config)
+    expect(config).to receive(:app_type)
+    expect(config).to receive(:app_type=).with('que')
+    allow(config).to receive(:clear_request_data)
+    expect(Que).to receive(:error_notifier=) do |handler|
+      handler.call(error, job)
+    end
+
+    #Kick off
+    load './lib/bugsnag/integrations/que.rb'
+  end
+
+  after do
+    Object.send(:remove_const, :Que) if @mocked_que
+  end
+end

spec/integrations/rack_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Bugsnag::Rack do
+  it "calls the upstream rack app with the environment" do
+    rack_env = {"key" => "value"}
+    app = lambda { |env| ['response', {}, env] }
+    rack_stack = Bugsnag::Rack.new(app)
+
+    response = rack_stack.call(rack_env)
+
+    expect(response).to eq(['response', {}, rack_env])
+  end
+
+  context "when an exception is raised in rack middleware" do
+    # Build a fake crashing rack app
+    exception = BugsnagTestException.new("It crashed")
+    rack_env = {"key" => "value"}
+    app = lambda { |env| raise exception }
+    rack_stack = Bugsnag::Rack.new(app)
+
+    it "re-raises the exception" do
+      expect { rack_stack.call(rack_env) }.to raise_error(BugsnagTestException)
+    end
+
+    it "delivers an exception if auto_notify is enabled" do
+      rack_stack.call(rack_env) rescue nil
+
+      expect(Bugsnag).to have_sent_notification{ |payload, headers|
+        exception_class = payload["events"].first["exceptions"].first["errorClass"]
+        expect(exception_class).to eq(exception.class.to_s)
+      }
+
+    end
+
+    it "applies the correct severity reason" do
+      rack_stack.call(rack_env) rescue nil
+
+      expect(Bugsnag).to have_sent_notification{ |payload, headers|
+        event = get_event_from_payload(payload)
+        expect(event["unhandled"]).to be true
+        expect(event["severityReason"]).to eq({
+          "type" => "unhandledExceptionMiddleware",
+          "attributes" => {
+            "framework" => "Rack"
+          }
+        })
+      }
+    end
+
+    it "does not deliver an exception if auto_notify is disabled" do
+      Bugsnag.configure do |config|
+        config.auto_notify = false
+      end
+
+      rack_stack.call(rack_env) rescue nil
+
+      expect(Bugsnag).not_to have_sent_notification
+    end
+  end
+
+  context "when running against the middleware" do
+    before do
+      unless defined?(::Rack)
+        @mocked_rack = true
+        class ::Rack
+          class ::Request
+          end
+        end
+      end
+    end
+
+    it "correctly extracts data from rack middleware" do
+      callback = double
+      rack_env = {
+        :env => true,
+        :HTTP_test_key => "test_key",
+        "rack.session" => {
+          :session => true
+        }
+      }
+      
+      rack_request = double
+      rack_params = {
+        :param => 'test'
+      }
+      allow(rack_request).to receive_messages(
+        :params => rack_params,
+        :ip => "rack_ip",
+        :request_method => "TEST",
+        :path => "/TEST_PATH",
+        :scheme => "http",
+        :host => "test_host",
+        :port => 80,
+        :referer => "referer",
+        :fullpath => "/TEST_PATH"
+      )
+      expect(::Rack::Request).to receive(:new).with(rack_env).and_return(rack_request)
+
+      report = double("Bugsnag::Report")
+      allow(report).to receive(:request_data).and_return({
+        :rack_env => rack_env
+      })
+      expect(report).to receive(:context=).with("TEST /TEST_PATH")
+      expect(report).to receive(:user).and_return({})
+
+      config = double
+      allow(config).to receive(:send_environment).and_return(true)
+      allow(config).to receive(:meta_data_filters).and_return(nil)
+      allow(report).to receive(:configuration).and_return(config)
+      expect(report).to receive(:add_tab).once.with(:environment, rack_env)
+      expect(report).to receive(:add_tab).once.with(:request, {
+        :url => "http://test_host/TEST_PATH",
+        :httpMethod => "TEST",
+        :params => rack_params,
+        :referer => "referer",
+        :clientIp => "rack_ip",
+        :headers => {
+          "Test-Key" => "test_key"
+        }
+      })
+      expect(report).to receive(:add_tab).once.with(:session, {
+        :session => true
+      })
+
+      expect(callback).to receive(:call).with(report)
+
+      middleware = Bugsnag::Middleware::RackRequest.new(callback)
+      middleware.call(report)
+    end
+
+    after do
+      Object.send(:remove_const, :Rack) if @mocked_rack
+    end
+
+  end
+
+  it "don't mess with middlewares list on each req" do
+    stub_const('Rack', nil)
+    app = lambda { |env| ['200', {}, ['']] }
+
+    Bugsnag::Rack.new(app)
+
+    expect { 2.times { Bugsnag::Rack.new(app) } }.not_to change {
+      Bugsnag.configuration.middleware.instance_variable_get(:@middlewares)
+    }
+  end
+end

spec/rails3_request_spec.rb spec/integrations/rails3_request_spec.rbspec/rails3_request_spec.rb renamed to spec/integrations/rails3_request_spec.rb

@@ -23,6 +23,21 @@
       }
     end
 
+    it "unsets request metadata" do
+      Bugsnag.configuration.set_request_data(:rack_env, {
+        "action_dispatch.remote_ip" => "10.2.2.224",
+        "action_dispatch.request_id" => "5",
+      })
+      Bugsnag.configuration.unset_request_data(:rack_env, nil)
+      Bugsnag.notify(BugsnagTestException.new('Grimbles'))
+
+      expect(Bugsnag).to have_sent_notification { |payload, headers|
+        event = get_event_from_payload(payload)
+        puts event["metaData"].inspect
+        expect(event["metaData"]["request"]).to be nil
+      }
+    end
+
     context "the Remote IP will throw when serialized" do
 
       it "sets the client IP metdata to [SPOOF]" do