airbrake 9.2.1 → 9.2.2

data/spec/unit/rack/request_store_spec.rb

@@ -1,36 +0,0 @@
-RSpec.describe Airbrake::Rack::RequestStore do
-  after { described_class.clear }
-
-  describe "#store" do
-    it "returns an empty Hash" do
-      expect(subject.store).to be_a(Hash)
-      expect(subject.store).to be_empty
-    end
-  end
-
-  describe "#[]=" do
-    it "writes a value under a key" do
-      subject[:foo] = :bar
-      expect(subject.store).to eq(foo: :bar)
-    end
-  end
-
-  describe "#[]" do
-    it "reads a value under a key" do
-      subject[:foo] = :bar
-      expect(subject[:foo]).to eq(:bar)
-    end
-  end
-
-  describe "#clear" do
-    before do
-      subject[:foo] = 1
-      subject[:bar] = 2
-    end
-
-    it "clears everything in the store" do
-      subject.clear
-      expect(subject.store).to be_empty
-    end
-  end
-end

data/spec/unit/rack/route_filter_spec.rb

@@ -1,52 +0,0 @@
-RSpec.describe Airbrake::Rack::RouteFilter do
-  context "when there's no request object available" do
-    it "doesn't add context/route" do
-      notice = Airbrake.build_notice('oops')
-      subject.call(notice)
-      expect(notice[:context][:route]).to be_nil
-    end
-  end
-
-  context "when Sinatra route is unavailable" do
-    before { stub_const('Sinatra::Request', Class.new) }
-
-    let(:notice) do
-      notice = Airbrake.build_notice('oops')
-
-      request_mock = instance_double(Sinatra::Request)
-      expect(request_mock)
-        .to receive(:instance_of?).with(Sinatra::Request).and_return(true)
-      expect(request_mock).to receive(:env).and_return({})
-
-      notice.stash[:rack_request] = request_mock
-      notice
-    end
-
-    it "doesn't add context/route" do
-      subject.call(notice)
-      expect(notice[:context][:route]).to be_nil
-    end
-  end
-
-  context "when Sinatra route is available" do
-    before { stub_const('Sinatra::Request', Class.new) }
-
-    let(:notice) do
-      notice = Airbrake.build_notice('oops')
-
-      request_mock = instance_double(Sinatra::Request)
-      expect(request_mock)
-        .to receive(:instance_of?).with(Sinatra::Request).and_return(true)
-      expect(request_mock)
-        .to receive(:env).and_return('sinatra.route' => 'GET /test-route')
-
-      notice.stash[:rack_request] = request_mock
-      notice
-    end
-
-    it "doesn't add context/route" do
-      subject.call(notice)
-      expect(notice[:context][:route]).to eq('/test-route')
-    end
-  end
-end

data/spec/unit/rack/session_filter_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe Airbrake::Rack::SessionFilter do
-  def env_for(url, opts = {})
-    Rack::MockRequest.env_for(url, opts)
-  end
-
-  let(:notice) do
-    Airbrake.build_notice('oops').tap do |notice|
-      notice.stash[:rack_request] = Rack::Request.new(env_for(uri, opts))
-    end
-  end
-
-  context "when rack session is nil" do
-    let(:uri) { '/' }
-
-    let(:opts) do
-      { 'rack.session' => nil }
-    end
-
-    it "doesn't overwrite the session key with nil" do
-      expect(notice[:session]).to eq({})
-
-      subject.call(notice)
-
-      expect(notice[:session]).to eq({})
-    end
-  end
-
-  context "when session is present" do
-    let(:session) do
-      { a: 1, b: 2 }
-    end
-
-    let(:uri) { '/' }
-
-    let(:opts) do
-      { 'rack.session' => session }
-    end
-
-    it "sets session if it is present" do
-      subject.call(notice)
-      expect(notice[:session]).to eq(session)
-    end
-  end
-end

data/spec/unit/rack/user_filter_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe Airbrake::Rack::UserFilter do
-  def env_for(url, opts = {})
-    Rack::MockRequest.env_for(url, opts)
-  end
-
-  let(:notice) do
-    Airbrake.build_notice('oops').tap do |notice|
-      notice.stash[:rack_request] = Rack::Request.new(env_for('/', {}))
-    end
-  end
-
-  let(:user_payload) { { username: 'bingo' } }
-  let(:user) { Airbrake::Rack::User.new(double(user_payload)) }
-
-  it "delegates extraction of the current user information" do
-    expect(Airbrake::Rack::User).to receive(:extract).and_return(user)
-    subject.call(notice)
-    expect(notice[:context][:user]).to eq(user_payload)
-  end
-
-  context "when no current user is found" do
-    let(:user) { Airbrake::Rack::User.new(double) }
-
-    it "does not include the user key in the payload" do
-      expect(Airbrake::Rack::User).to receive(:extract).and_return(user)
-      subject.call(notice)
-      expect(notice[:context].keys).not_to include(:user)
-    end
-  end
-end

data/spec/unit/rack/user_spec.rb

@@ -1,218 +0,0 @@
-RSpec.describe Airbrake::Rack::User do
-  let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/113743/notices' }
-
-  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
-
-      context 'and it is a private method' do
-        context "and it is not nil" do
-          let(:dummy_controller) do
-            Class.new do
-              private
-
-              def current_user
-                "username"
-              end
-            end
-          end
-
-          let(:controller) { dummy_controller.new }
-
-          it "returns the wrapped user" do
-            retval = described_class.extract(env)
-            expect(retval).to 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
-
-    context "when Rack user's field expects a parameter" do
-      let(:user_data) do
-        described_class.new(
-          Class.new do
-            def name(required_param)
-              "my name is #{required_param}"
-            end
-
-            def id(required_param, *optional_params)
-              "id is #{required_param} #{optional_params.inspect}"
-            end
-
-            def username(*optional_params)
-              "username is #{optional_params.inspect}"
-            end
-          end.new
-        ).as_json
-      end
-
-      it "does not call the method if it has required parameters" do
-        expect(user_data[:user]).not_to include(:id)
-        expect(user_data[:user]).not_to include(:name)
-      end
-
-      it "calls the method if it has a variable number of optional parameters" do
-        expect(user_data[:user]).to include(:username)
-      end
-    end
-  end
-end

data/spec/unit/rails/action_cable/notify_callback_spec.rb

@@ -1,26 +0,0 @@
-require 'airbrake/rails/action_cable/notify_callback'
-
-RSpec.describe Airbrake::Rails::ActionCable::NotifyCallback do
-  describe ".call" do
-    context "when block raises exception" do
-      let(:channel) { double }
-      let(:block) { proc { raise AirbrakeTestError } }
-
-      before do
-        expect(channel).to receive(:channel_name).and_return('web_notifications')
-      end
-
-      it "notifies Airbrake" do
-        expect(Airbrake).to(
-          receive(:notify).with(an_instance_of(Airbrake::Notice))
-        ) do |notice|
-          expect(notice[:context][:component]).to eq('action_cable')
-          expect(notice[:context][:action]).to eq('web_notifications')
-        end
-
-        expect { described_class.call(channel, block) }
-          .to raise_error(AirbrakeTestError)
-      end
-    end
-  end
-end

data/spec/unit/rails/action_controller_notify_subscriber_spec.rb

@@ -1,43 +0,0 @@
-require 'airbrake/rails/action_controller_notify_subscriber'
-
-RSpec.describe Airbrake::Rails::ActionControllerNotifySubscriber do
-  after { Airbrake::Rack::RequestStore.clear }
-
-  describe "#call" do
-    let(:event) { double(Airbrake::Rails::Event) }
-
-    before do
-      allow(Airbrake::Rails::Event).to receive(:new).and_return(event)
-    end
-
-    context "when there are no routes in the request store" do
-      it "doesn't notify requests" do
-        expect(Airbrake).not_to receive(:notify_request)
-        subject.call([])
-      end
-    end
-
-    context "when there's a route in the request store" do
-      before do
-        Airbrake::Rack::RequestStore[:routes] = {
-          '/test-route' => { method: 'GET', response_type: :html }
-        }
-
-        expect(event).to receive(:method).and_return('GET')
-        expect(event).to receive(:status_code).and_return(200)
-        expect(event).to receive(:time).and_return(Time.now)
-      end
-
-      it "sends request info to Airbrake" do
-        expect(Airbrake).to receive(:notify_request).with(
-          hash_including(
-            method: 'GET',
-            route: '/test-route',
-            status_code: 200
-          )
-        )
-        subject.call([])
-      end
-    end
-  end
-end