dfg-airbrake 5.6.2

data/spec/unit/rack/middleware_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Rack::Middleware do
+  let(:app) do
+    proc { |env| [200, env, 'Bingo bango content'] }
+  end
+
+  let(:faulty_app) do
+    proc { raise AirbrakeTestError }
+  end
+
+  let(:endpoint) do
+    'https://airbrake.io/api/v3/projects/113743/notices?key=fd04e13d806a90f96614ad8e529b2822'
+  end
+
+  let(:middleware) { described_class.new(app) }
+
+  def env_for(url, opts = {})
+    Rack::MockRequest.env_for(url, opts)
+  end
+
+  def wait_for_a_request_with_body(body)
+    wait_for(a_request(:post, endpoint).with(body: body)).to have_been_made.once
+  end
+
+  before do
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+  end
+
+  describe "#call" do
+    context "when app raises an exception" do
+      context "and when the notifier name is specified" do
+        let(:notifier_name) { :rack_middleware_initialize }
+
+        let(:bingo_endpoint) do
+          'https://airbrake.io/api/v3/projects/92123/notices?key=ad04e13d806a90f96614ad8e529b2821'
+        end
+
+        let(:expected_body) do
+          /"errors":\[{"type":"AirbrakeTestError"/
+        end
+
+        before do
+          Airbrake.configure(notifier_name) do |c|
+            c.project_id = 92123
+            c.project_key = 'ad04e13d806a90f96614ad8e529b2821'
+            c.logger = Logger.new('/dev/null')
+            c.app_version = '3.2.1'
+          end
+
+          stub_request(:post, bingo_endpoint).to_return(status: 201, body: '{}')
+        end
+
+        after { Airbrake.close(notifier_name) }
+
+        it "notifies via the specified notifier" do
+          expect do
+            described_class.new(faulty_app, notifier_name).call(env_for('/'))
+          end.to raise_error(AirbrakeTestError)
+
+          wait_for(
+            a_request(:post, bingo_endpoint).
+              with(body: expected_body)
+          ).to have_been_made.once
+
+          expect(
+            a_request(:post, endpoint).
+              with(body: expected_body)
+          ).not_to have_been_made
+        end
+      end
+
+      context "and when the notifier is not configured" do
+        it "rescues the exception, notifies Airbrake & re-raises it" do
+          expect { described_class.new(faulty_app).call(env_for('/')) }.
+            to raise_error(AirbrakeTestError)
+
+          wait_for_a_request_with_body(/"errors":\[{"type":"AirbrakeTestError"/)
+        end
+
+        it "sends framework version and name" do
+          expect { described_class.new(faulty_app).call(env_for('/bingo/bango')) }.
+            to raise_error(AirbrakeTestError)
+
+          wait_for_a_request_with_body(
+            %r("context":{.*"version":"1.2.3 (Rails|Sinatra|Rack\.version)/.+".+})
+          )
+        end
+      end
+    end
+
+    context "when app doesn't raise" do
+      context "and previous middleware stored an exception in env" do
+        shared_examples 'stored exception' do |type|
+          it "notifies on #{type}, but doesn't raise" do
+            env = env_for('/').merge(type => AirbrakeTestError.new)
+            described_class.new(app).call(env)
+
+            wait_for_a_request_with_body(/"errors":\[{"type":"AirbrakeTestError"/)
+          end
+        end
+
+        ['rack.exception', 'action_dispatch.exception', 'sinatra.error'].each do |type|
+          include_examples 'stored exception', type
+        end
+      end
+
+      it "doesn't notify Airbrake" do
+        described_class.new(app).call(env_for('/'))
+        sleep 1
+        expect(a_request(:post, endpoint)).not_to have_been_made
+      end
+    end
+
+    it "returns a response" do
+      response =  described_class.new(app).call(env_for('/'))
+
+      expect(response[0]).to eq(200)
+      expect(response[1]).to be_a(Hash)
+      expect(response[2]).to eq('Bingo bango content')
+    end
+  end
+
+  context "when Airbrake is not configured" do
+    it "returns nil" do
+      allow(Airbrake).to receive(:build_notice).and_return(nil)
+      allow(Airbrake).to receive(:notify)
+
+      expect { described_class.new(faulty_app).call(env_for('/')) }.
+        to raise_error(AirbrakeTestError)
+
+      expect(Airbrake).to have_received(:build_notice)
+      expect(Airbrake).not_to have_received(:notify)
+    end
+  end
+end

data/spec/unit/rack/notice_builder_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Rack::NoticeBuilder do
+  def env_for(url, opts = {})
+    Rack::MockRequest.env_for(url, opts)
+  end
+
+  describe "#build_notice" do
+    it "doesn't overwrite the session key with nil" do
+      notice_builder = described_class.new(env_for('/', 'rack.session' => nil))
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:session]).to eq({})
+    end
+
+    it "sets session if it is present" do
+      session = { a: 1, b: 2 }
+      notice_builder = described_class.new(env_for('/', 'rack.session' => session))
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:session]).to eq(session)
+    end
+
+    it "doesn't overwrite the params key with nil" do
+      notice_builder = described_class.new(env_for('/'))
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:session]).to eq({})
+    end
+
+    it "sets form params if they're present" do
+      params = { a: 1, b: 2 }
+      input = StringIO.new
+
+      notice_builder = described_class.new(
+        'rack.request.form_hash' => params,
+        'rack.request.form_input' => input,
+        'rack.input' => input
+      )
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:params]).to eq(params)
+    end
+
+    it "sets query string params if they're present" do
+      notice_builder = described_class.new(env_for('/?bingo=bango&bongo=bish'))
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:params]).to eq('bingo' => 'bango', 'bongo' => 'bish')
+    end
+
+    it "adds CONTENT_TYPE, CONTENT_LENGTH and HTTP_* headers in the environment" do
+      headers = {
+        "HTTP_HOST" => "example.com",
+        "CONTENT_TYPE" => "text/html",
+        "CONTENT_LENGTH" => 100500
+      }
+      notice_builder = described_class.new(env_for('/', headers.dup))
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+      expect(notice[:environment][:headers]).to eq(headers)
+    end
+
+    it "skips headers that were not selected to be stored in the environment" do
+      headers = {
+        "HTTP_HOST" => "example.com",
+        "CONTENT_TYPE" => "text/html",
+        "CONTENT_LENGTH" => 100500
+      }
+      notice_builder = described_class.new(
+        env_for('/', headers.merge("X-SOME-HEADER" => "value"))
+      )
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:environment][:headers]).to eq(headers)
+    end
+
+    it "preserves data that already has been added to the environment" do
+      headers = {
+        "HTTP_HOST" => "example.com",
+        "CONTENT_TYPE" => "text/html",
+        "CONTENT_LENGTH" => 100500
+      }
+      allow(Airbrake).to receive(:build_notice).and_wrap_original do |method, *args|
+        notice = method.call(*args)
+        notice[:environment]["SOME_KEY"] = "SOME_VALUE"
+        notice
+      end
+      notice_builder = described_class.new(env_for('/', headers))
+      notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+      expect(notice[:environment]["SOME_KEY"]).to eq("SOME_VALUE")
+    end
+
+    context "when a custom builder is defined" do
+      before do
+        described_class.add_builder do |notice, request|
+          notice[:params][:remoteIp] = request.env['REMOTE_IP']
+        end
+      end
+
+      after do
+        described_class.instance_variable_get(:@builders).pop
+      end
+
+      it "runs the builder against notices" do
+        notice_builder = described_class.new(env_for('/', 'REMOTE_IP' => '127.0.0.1'))
+        notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+        expect(notice[:params][:remoteIp]).to eq("127.0.0.1")
+      end
+    end
+
+    context "when Airbrake is not configured" do
+      it "returns nil" do
+        allow(Airbrake).to receive(:build_notice).and_return(nil)
+        notice_builder = described_class.new(env_for('/', 'bingo' => 'bango'))
+
+        expect(notice_builder.build_notice('bongo')).to be_nil
+        expect(Airbrake).to have_received(:build_notice)
+      end
+    end
+
+    context "when a request has a body" do
+      it "reads the body" do
+        body = StringIO.new('<bingo>bongo</bango>')
+        notice_builder = described_class.new(
+          env_for('/', 'rack.input' => body)
+        )
+        notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+        expect(notice[:environment][:body]).to eq(body.string)
+      end
+
+      it "rewinds rack.input" do
+        body = StringIO.new('<bingo>bongo</bango>' * 512)
+        notice_builder = described_class.new(
+          env_for('/', 'rack.input' => body)
+        )
+
+        notice_builder.build_notice(AirbrakeTestError.new)
+
+        expect(body.pos).to be_zero
+      end
+
+      it "reads only first 4096 bytes" do
+        len = 4097
+        body = StringIO.new('a' * len)
+        notice_builder = described_class.new(
+          env_for('/', 'rack.input' => body)
+        )
+        notice = notice_builder.build_notice(AirbrakeTestError.new)
+
+        expect(notice[:environment][:body]).to eq(body.string[0...len - 1])
+      end
+    end
+  end
+end

data/spec/unit/rack/user_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Rack::User do
+  let(:endpoint) do
+    'https://airbrake.io/api/v3/projects/113743/notices?key=fd04e13d806a90f96614ad8e529b2822'
+  end
+
+  let(:user) do
+    OpenStruct.new(
+      id: 1,
+      email: 'qa@example.com',
+      username: 'qa-dept',
+      first_name: 'Bingo',
+      last_name: 'Bongo'
+    )
+  end
+
+  def env_for(url, opts = {})
+    Rack::MockRequest.env_for(url, opts)
+  end
+
+  before do
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+  end
+
+  describe ".extract" do
+    context "when the Warden authentication framework is present" do
+      it "returns the wrapped user" do
+        warden = instance_double('Warden::Proxy')
+        allow(warden).to receive(:user) { user }
+
+        retval = described_class.extract(env_for('/', 'warden' => warden))
+        expect(retval).to be_a(described_class)
+      end
+
+      context "and the warden user is nil" do
+        it "returns nil" do
+          warden = instance_double('Warden::Proxy')
+          allow(warden).to receive(:user) { nil }
+
+          retval = described_class.extract(env_for('/', 'warden' => warden))
+          expect(retval).to be_nil
+        end
+      end
+    end
+
+    context "when the user was not found" do
+      it "returns nil" do
+        retval = described_class.extract(env_for('/'))
+        expect(retval).to be_nil
+      end
+    end
+
+    context "when the current_user Rails controller method is defined" do
+      let(:controller) { instance_double('DummyController') }
+      let(:env) { env_for('/', 'action_controller.instance' => controller) }
+
+      context "and it is nil" do
+        it "returns nil" do
+          allow(controller).to receive(:current_user) { nil }
+
+          retval = described_class.extract(env)
+          expect(retval).to be_nil
+        end
+      end
+
+      context "and it is not nil" do
+        it "returns the wrapped user" do
+          allow(controller).to receive(:current_user) { user }
+
+          retval = described_class.extract(env)
+          expect(retval).to be_a(described_class)
+        end
+
+        context "but it requires parameters" do
+          let(:controller) { dummy_controller.new }
+          subject { described_class.extract(env) }
+
+          context ": current_user(a)" do
+            let(:dummy_controller) do
+              Class.new do
+                def current_user(_a)
+                  "username"
+                end
+              end
+            end
+
+            it { should be_nil }
+          end
+
+          context ": current_user(a, b)" do
+            let(:dummy_controller) do
+              Class.new do
+                def current_user(_a, _b)
+                  "username"
+                end
+              end
+            end
+
+            it { should be_nil }
+          end
+
+          context ": current_user(a, *b)" do
+            let(:dummy_controller) do
+              Class.new do
+                def current_user(_a, *_b)
+                  "username"
+                end
+              end
+            end
+
+            it { should be_nil }
+          end
+
+          context ": current_user(a, b, *c, &d)" do
+            let(:dummy_controller) do
+              Class.new do
+                def current_user(_a, _b, *_c, &_d)
+                  "username"
+                end
+              end
+            end
+
+            it { should be_nil }
+          end
+
+          context ": current_user(*a)" do
+            let(:dummy_controller) do
+              Class.new do
+                def current_user(*_a)
+                  "username"
+                end
+              end
+            end
+
+            it { should be_a(described_class) }
+          end
+        end
+      end
+    end
+  end
+
+  describe "#as_json" do
+    context "when Rack user contains all expect fields" do
+      let(:user_data) { described_class.new(user).as_json[:user] }
+
+      it "contains the 'id' key" do
+        expect(user_data).to include(:id)
+      end
+
+      it "contains the 'name' key" do
+        expect(user_data).to include(:name)
+      end
+
+      it "contains the 'username' key" do
+        expect(user_data).to include(:username)
+      end
+
+      it "contains the 'email' key" do
+        expect(user_data).to include(:email)
+      end
+    end
+
+    context "when Rack user doesn't contain any of the expect fields" do
+      let(:user_data) { described_class.new(OpenStruct.new).as_json }
+
+      it "is empty" do
+        expect(user_data).to be_empty
+      end
+    end
+  end
+end