airbrake 9.2.1 → 9.2.2

data/spec/unit/rack/context_filter_spec.rb

@@ -1,90 +0,0 @@
-RSpec.describe Airbrake::Rack::ContextFilter 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
-
-  let(:uri) { '/' }
-  let(:opts) { {} }
-
-  it "adds framework version to the context" do
-    subject.call(notice)
-    expect(notice[:context][:versions]).to include(
-      'rack_version' => a_string_matching(/\d.\d/),
-      'rack_release' => a_string_matching(/\d.\d\.\d/)
-    )
-  end
-
-  context "when URL is present" do
-    let(:uri) { '/bingo' }
-    let(:opts) { {} }
-
-    it "adds URL to the context" do
-      subject.call(notice)
-      expect(notice[:context][:url]).to eq('http://example.org/bingo')
-    end
-  end
-
-  context "when User-Agent is present" do
-    let(:uri) { '/' }
-    let(:opts) do
-      { 'HTTP_USER_AGENT' => 'Bingo Agent' }
-    end
-
-    it "adds User-Agent to the context" do
-      subject.call(notice)
-      expect(notice[:context][:userAgent]).to eq('Bingo Agent')
-    end
-  end
-
-  context "when visitor address is present" do
-    let(:opts) do
-      { 'REMOTE_ADDR' => '1.2.3.4' }
-    end
-
-    it "adds userAddr to the context" do
-      subject.call(notice)
-      expect(notice[:context][:userAddr]).to eq('1.2.3.4')
-    end
-  end
-
-  context "when visitor is behind a proxy or load balancer" do
-    let(:opts) do
-      { 'HTTP_X_FORWARDED_FOR' => '8.8.8.8, 9.9.9.9' }
-    end
-
-    it "adds userAddr to the context" do
-      subject.call(notice)
-      expect(notice[:context][:userAddr]).to eq('9.9.9.9')
-    end
-  end
-
-  context "when controller is present" do
-    let(:controller) do
-      double.tap do |ctrl|
-        allow(ctrl).to receive(:controller_name).and_return('BingoController')
-        allow(ctrl).to receive(:action_name).and_return('bango_name')
-      end
-    end
-
-    let(:uri) { '/' }
-    let(:opts) do
-      { 'action_controller.instance' => controller }
-    end
-
-    it "adds controller name as component" do
-      subject.call(notice)
-      expect(notice[:context][:component]).to eq('BingoController')
-    end
-
-    it "adds action name as action" do
-      subject.call(notice)
-      expect(notice[:context][:action]).to eq('bango_name')
-    end
-  end
-end

data/spec/unit/rack/http_headers_filter_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe Airbrake::Rack::HttpHeadersFilter 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
-
-  let(:headers) do
-    {
-      'HTTP_HOST' => 'example.com',
-      'CONTENT_TYPE' => 'text/html',
-      'CONTENT_LENGTH' => 100500
-    }
-  end
-
-  let(:uri) { '/' }
-  let(:opts) { headers.dup }
-
-  it "preserves data that already has been added to the context" do
-    notice[:context]['SOME_KEY'] = 'SOME_VALUE'
-    subject.call(notice)
-    expect(notice[:context]['SOME_KEY']).to eq('SOME_VALUE')
-  end
-
-  context "when CONTENT_TYPE, CONTENT_LENGTH and HTTP_* headers are present" do
-    it "adds them to the context hash" do
-      subject.call(notice)
-      expect(notice[:context][:headers]).to eq(headers)
-    end
-  end
-
-  context "when unexpected headers are present" do
-    let(:opts) { headers.dup.merge('X-SOME-HEADER' => 'value') }
-
-    it "adds them to the context hash" do
-      subject.call(notice)
-      expect(notice[:context][:headers]).to eq(headers)
-    end
-  end
-end

data/spec/unit/rack/http_params_filter_spec.rb

@@ -1,58 +0,0 @@
-RSpec.describe Airbrake::Rack::HttpParamsFilter 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 params is nil" do
-    let(:uri) { '/' }
-    let(:opts) { {} }
-
-    it "doesn't overwrite the params key with nil" do
-      subject.call(notice)
-      expect(notice[:params]).to eq({})
-    end
-  end
-
-  context "when form params are present" do
-    let(:params) do
-      { a: 1, b: 2 }
-    end
-
-    let(:input) { StringIO.new }
-    let(:uri) { '/' }
-    let(:opts) do
-      {
-        'rack.request.form_hash' => params,
-        'rack.request.form_input' => input,
-        'rack.input' => input
-      }
-    end
-
-    it "sets the params hash" do
-      subject.call(notice)
-      expect(notice[:params]).to eq(params)
-    end
-
-    it "merges given params with existing params" do
-      notice[:params] = { bingo: :bango }
-      subject.call(notice)
-      expect(notice[:params]).to eq(bingo: :bango, a: 1, b: 2)
-    end
-  end
-
-  context "when query string params are present" do
-    let(:uri) { '/?bingo=bango&bongo=bish' }
-    let(:opts) { {} }
-
-    it "sets the params hash" do
-      subject.call(notice)
-      expect(notice[:params]).to eq('bingo' => 'bango', 'bongo' => 'bish')
-    end
-  end
-end

data/spec/unit/rack/instrumentable_spec.rb

@@ -1,105 +0,0 @@
-RSpec.describe Airbrake::Rack::Instrumentable do
-  after { Airbrake::Rack::RequestStore.clear }
-
-  describe ".airbrake_capture_timing" do
-    let(:routes) { Airbrake::Rack::RequestStore[:routes] }
-
-    let(:klass) do
-      Class.new do
-        extend Airbrake::Rack::Instrumentable
-
-        def method; end
-        airbrake_capture_timing :method
-
-        def method_with_arg(a); end
-        airbrake_capture_timing :method_with_arg
-
-        def method_with_args(a, b); end
-        airbrake_capture_timing :method_with_args
-
-        def method_with_vla(*args); end
-        airbrake_capture_timing :method_with_vla
-
-        def method_with_args_and_vla(*args); end
-        airbrake_capture_timing :method_with_args_and_vla
-
-        def method_with_kwargs(foo:, bar:); end
-        airbrake_capture_timing :method_with_kwargs
-      end
-    end
-
-    context "when request store doesn't have any routes" do
-      before { Airbrake::Rack::RequestStore.clear }
-
-      it "doesn't store timing of the tracked method" do
-        klass.new.method
-        expect(Airbrake::Rack::RequestStore.store).to be_empty
-      end
-    end
-
-    context "when request store has a route" do
-      let(:groups) { routes['/about'][:groups] }
-
-      before do
-        Airbrake::Rack::RequestStore[:routes] = {
-          '/about' => {
-            method: 'GET',
-            response_type: :html,
-            groups: {}
-          }
-        }
-      end
-
-      it "attaches timing for a method without an argument" do
-        klass.new.method
-        expect(groups).to match('method' => be > 0)
-      end
-
-      it "attaches timing for a method with an argument" do
-        klass.new.method_with_arg(1)
-        expect(groups).to match('method_with_arg' => be > 0)
-      end
-
-      it "attaches timing for a variable-length argument method" do
-        klass.new.method_with_vla(1, 2, 3)
-        expect(groups).to match('method_with_vla' => be > 0)
-      end
-
-      it "attaches timing for a method with args and a variable-length array" do
-        klass.new.method_with_args_and_vla(1, 2, 3)
-        expect(groups).to match('method_with_args_and_vla' => be > 0)
-      end
-
-      it "attaches timing for a method with kwargs" do
-        klass.new.method_with_kwargs(foo: 1, bar: 2)
-        expect(groups).to match('method_with_kwargs' => be > 0)
-      end
-
-      it "attaches all timings for multiple methods to the request store" do
-        klass.new.method
-        klass.new.method_with_arg(1)
-
-        expect(groups).to match(
-          'method' => be > 0,
-          'method_with_arg' => be > 0
-        )
-      end
-
-      context "and when a custom label was provided" do
-        let(:klass) do
-          Class.new do
-            extend Airbrake::Rack::Instrumentable
-
-            def method; end
-            airbrake_capture_timing :method, label: 'custom label'
-          end
-        end
-
-        it "attaches timing under the provided label" do
-          klass.new.method
-          expect(groups).to match('custom label' => be > 0)
-        end
-      end
-    end
-  end
-end

data/spec/unit/rack/middleware_spec.rb

@@ -1,98 +0,0 @@
-RSpec.describe Airbrake::Rack::Middleware do
-  # The list of Rack filters that read Rack request information and append it to
-  # notices.
-  [
-    Airbrake::Rack::ContextFilter,
-    Airbrake::Rack::UserFilter,
-    Airbrake::Rack::SessionFilter,
-    Airbrake::Rack::HttpParamsFilter,
-    Airbrake::Rack::HttpHeadersFilter,
-    Airbrake::Rack::RouteFilter,
-
-    # Optional filters (must be included by users):
-    # Airbrake::Rack::RequestBodyFilter
-  ].each do |filter|
-    Airbrake.add_filter(filter.new)
-  end
-
-  let(:app) { proc { |env| [200, env, 'Bingo bango content'] } }
-  let(:faulty_app) { proc { raise AirbrakeTestError } }
-  let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/113743/notices' }
-  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
-      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(
-          /"context":{.*"versions":{"(rails|sinatra|rack_version)"/
-        )
-      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/rack_spec.rb

@@ -1,46 +0,0 @@
-RSpec.describe Airbrake::Rack do
-  after { Airbrake::Rack::RequestStore.clear }
-
-  describe ".timing" do
-    let(:routes) { Airbrake::Rack::RequestStore[:routes] }
-
-    context "when request store doesn't have any routes" do
-      it "doesn't store timing" do
-        described_class.capture_timing('operation') {}
-        expect(Airbrake::Rack::RequestStore.store).to be_empty
-      end
-
-      it "returns the value of the block" do
-        expect(described_class.capture_timing('operation') { 1 }).to eq(1)
-      end
-    end
-
-    context "when request store has a route" do
-      before do
-        Airbrake::Rack::RequestStore[:routes] = {
-          '/about' => {
-            method: 'GET',
-            response_type: :html,
-            groups: {}
-          }
-        }
-      end
-
-      it "attaches all timings for different operations to the request store" do
-        described_class.capture_timing('operation 1') {}
-        described_class.capture_timing('operation 2') {}
-        described_class.capture_timing('operation 3') {}
-
-        expect(routes['/about'][:groups]).to match(
-          'operation 1' => be > 0,
-          'operation 2' => be > 0,
-          'operation 3' => be > 0
-        )
-      end
-
-      it "returns the value of the block" do
-        expect(described_class.capture_timing('operation') { 1 }).to eq(1)
-      end
-    end
-  end
-end

data/spec/unit/rack/request_body_filter_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe Airbrake::Rack::RequestBodyFilter 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
-
-  let(:uri) { '/' }
-  let(:opts) do
-    { 'rack.input' => body }
-  end
-
-  context "when a request has a body" do
-    let(:body) { StringIO.new('<bingo>bongo</bango>') }
-
-    it "reads the body" do
-      subject.call(notice)
-      expect(notice[:environment][:body]).to eq(body.string)
-    end
-  end
-
-  context "when body was read" do
-    let(:body) { StringIO.new('<bingo>bongo</bango>' * 512) }
-
-    it "rewinds rack.input" do
-      subject.call(notice)
-      expect(body.pos).to be_zero
-    end
-  end
-
-  context "when body is bigger than the limit" do
-    let(:len) { 4097 }
-    let(:body) { StringIO.new('a' * len) }
-
-    it "reads only first 4096 bytes" do
-      subject.call(notice)
-      expect(notice[:environment][:body]).to eq(body.string[0...len - 1])
-    end
-  end
-end