airbrake-ruby 4.6.0

data/spec/benchmark_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe Airbrake::Benchmark do
+  describe ".measure" do
+    it "returns measured performance time" do
+      expect(described_class.measure { '10' * 10 }).to be_kind_of(Numeric)
+    end
+  end
+
+  describe "#stop" do
+    before { subject }
+
+    context "when called one time" do
+      its(:stop) { is_expected.to eq(true) }
+    end
+
+    context "when called twice or more" do
+      before { subject.stop }
+
+      its(:stop) { is_expected.to eq(false) }
+    end
+  end
+
+  describe "#duration" do
+    context "when #stop wasn't called yet" do
+      its(:duration) { is_expected.to be_zero }
+    end
+
+    context "when #stop was called" do
+      before { subject.stop }
+
+      its(:duration) { is_expected.to be > 0 }
+    end
+  end
+end

data/spec/code_hunk_spec.rb

@@ -0,0 +1,115 @@
+RSpec.describe Airbrake::CodeHunk do
+  after do
+    %w[empty_file.rb code.rb banana.rb short_file.rb long_line.txt].each do |f|
+      Airbrake::FileCache[project_root_path(f)] = nil
+    end
+  end
+
+  describe "#to_h" do
+    context "when file is empty" do
+      subject do
+        described_class.new.get(project_root_path('empty_file.rb'), 1)
+      end
+
+      it { is_expected.to eq(1 => '') }
+    end
+
+    context "when line is nil" do
+      subject { described_class.new.get(project_root_path('code.rb'), nil) }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "when a file doesn't exist" do
+      subject { described_class.new.get(project_root_path('banana.rb'), 1) }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "when a file has less than NLINES lines before start line" do
+      subject { described_class.new.get(project_root_path('code.rb'), 1) }
+
+      it do
+        is_expected.to(
+          eq(
+            1 => 'module Airbrake',
+            2 => '  ##',
+            # rubocop:disable Metrics/LineLength
+            3 => '  # Represents a chunk of information that is meant to be either sent to',
+            # rubocop:enable Metrics/LineLength
+          )
+        )
+      end
+    end
+
+    context "when a file has less than NLINES lines after end line" do
+      subject { described_class.new.get(project_root_path('code.rb'), 222) }
+
+      it do
+        is_expected.to(
+          eq(
+            220 => '  end',
+            221 => 'end'
+          )
+        )
+      end
+    end
+
+    context "when a file has less than NLINES lines before and after" do
+      subject do
+        described_class.new.get(project_root_path('short_file.rb'), 2)
+      end
+
+      it do
+        is_expected.to(
+          eq(
+            1 => 'module Banana',
+            2 => '  attr_reader :bingo',
+            3 => 'end'
+          )
+        )
+      end
+    end
+
+    context "when a file has enough lines before and after" do
+      subject { described_class.new.get(project_root_path('code.rb'), 100) }
+
+      it do
+        is_expected.to(
+          eq(
+            98 => '          return json if json && json.bytesize <= MAX_NOTICE_SIZE',
+            99 => '        end',
+            100 => '',
+            101 => '        break if truncate == 0',
+            102 => '      end'
+          )
+        )
+      end
+    end
+
+    context "when a line exceeds the length limit" do
+      subject do
+        described_class.new.get(project_root_path('long_line.txt'), 1)
+      end
+
+      it "strips the line" do
+        expect(subject[1]).to eq('l' + 'o' * 196 + 'ng')
+      end
+    end
+
+    context "when an error occurrs while fetching code" do
+      before do
+        expect(Airbrake::FileCache).to receive(:[]).and_raise(Errno::EACCES)
+      end
+
+      it "logs error and returns nil" do
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /can't read code hunk.+Permission denied/
+        )
+        expect(subject.get(project_root_path('code.rb'), 1)).to(
+          eq(1 => '')
+        )
+      end
+    end
+  end
+end

data/spec/config/validator_spec.rb

@@ -0,0 +1,184 @@
+RSpec.describe Airbrake::Config::Validator do
+  let(:valid_id) { 123 }
+  let(:valid_key) { '123' }
+  let(:config) { Airbrake::Config.new(config_params) }
+
+  describe ".validate" do
+    context "when project_id is numerical" do
+      let(:config_params) { { project_id: valid_id, project_key: valid_key } }
+
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
+      end
+    end
+
+    context "when project_id is a numerical String" do
+      let(:config_params) { { project_id: '123', project_key: valid_key } }
+
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
+      end
+    end
+
+    context "when project_id is zero" do
+      let(:config_params) { { project_id: 0, project_key: valid_key } }
+
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq('error' => ':project_id is required')
+      end
+    end
+
+    context "when project_id consists of letters" do
+      let(:config_params) { { project_id: 'foo', project_key: valid_key } }
+
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq('error' => ':project_id is required')
+      end
+    end
+
+    context "when project_id is less than zero" do
+      let(:config_params) { { project_id: -123, project_key: valid_key } }
+
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq('error' => ':project_id is required')
+      end
+    end
+
+    context "when project_key is a non-empty String" do
+      let(:config_params) { { project_id: valid_id, project_key: '123' } }
+
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
+      end
+    end
+
+    context "when project_key is an empty String" do
+      let(:config_params) { { project_id: valid_id, project_key: '' } }
+
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq('error' => ':project_key is required')
+      end
+    end
+
+    context "when project_key is a non-String" do
+      let(:config_params) { { project_id: valid_id, project_key: 123 } }
+
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq('error' => ':project_key is required')
+      end
+    end
+
+    context "when environment is nil" do
+      let(:config_params) do
+        { project_id: valid_id, project_key: valid_key, environment: nil }
+      end
+
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
+      end
+    end
+
+    context "when environment is a String" do
+      let(:config_params) do
+        { project_id: valid_id, project_key: valid_key, environment: 'test' }
+      end
+
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
+      end
+    end
+
+    context "when environment is a Symbol" do
+      let(:config_params) do
+        { project_id: valid_id, project_key: valid_key, environment: :test }
+      end
+
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
+      end
+    end
+
+    context "when environment is non-String and non-Symbol" do
+      let(:config_params) do
+        { project_id: valid_id, project_key: valid_key, environment: 1.0 }
+      end
+
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq(
+          'error' => "the 'environment' option must be configured with a " \
+                     "Symbol (or String), but 'Float' was provided: 1.0"
+        )
+      end
+    end
+
+    context "when environment is String-like" do
+      let(:string_inquirer) { Class.new(String) }
+
+      let(:config_params) do
+        {
+          project_id: valid_id,
+          project_key: valid_key,
+          environment: string_inquirer.new('test')
+        }
+      end
+
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
+      end
+    end
+  end
+
+  describe "#check_notify_ability" do
+    context "when current environment is ignored" do
+      let(:config_params) do
+        {
+          project_id: valid_id,
+          project_key: valid_key,
+          environment: 'test',
+          ignore_environments: ['test']
+        }
+      end
+
+      it "returns a rejected promise" do
+        promise = described_class.check_notify_ability(config)
+        expect(promise.value).to eq(
+          'error' => "current environment 'test' is ignored"
+        )
+      end
+    end
+
+    context "when no environment is specified but ignore_environments is" do
+      let(:config_params) do
+        {
+          project_id: valid_id,
+          project_key: valid_key,
+          ignore_environments: ['test']
+        }
+      end
+
+      it "returns a rejected promise" do
+        promise = described_class.check_notify_ability(config)
+        expect(promise).to be_resolved
+      end
+
+      it "warns about 'no effect'" do
+        expect(config.logger).to receive(:warn)
+          .with(/'ignore_environments' has no effect/)
+        described_class.check_notify_ability(config)
+      end
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,154 @@
+RSpec.describe Airbrake::Config do
+  let(:resolved_promise) { Airbrake::Promise.new.resolve }
+  let(:rejected_promise) { Airbrake::Promise.new.reject }
+
+  let(:valid_params) { { project_id: 1, project_key: '2' } }
+
+  its(:project_id) { is_expected.to be_nil }
+  its(:project_key) { is_expected.to be_nil }
+  its(:logger) { is_expected.to be_a(Logger) }
+  its(:app_version) { is_expected.to be_nil }
+  its(:versions) { is_expected.to be_empty }
+  its(:host) { is_expected.to eq('https://api.airbrake.io') }
+  its(:endpoint) { is_expected.not_to be_nil }
+  its(:workers) { is_expected.to eq(1) }
+  its(:queue_size) { is_expected.to eq(100) }
+  its(:root_directory) { is_expected.to eq(Bundler.root.realpath.to_s) }
+  its(:environment) { is_expected.to be_nil }
+  its(:ignore_environments) { is_expected.to be_empty }
+  its(:timeout) { is_expected.to be_nil }
+  its(:blacklist_keys) { is_expected.to be_empty }
+  its(:whitelist_keys) { is_expected.to be_empty }
+  its(:performance_stats) { is_expected.to eq(true) }
+  its(:performance_stats_flush_period) { is_expected.to eq(15) }
+  its(:query_stats) { is_expected.to eq(false) }
+
+  describe "#new" do
+    context "when user config is passed" do
+      subject { described_class.new(logger: StringIO.new) }
+      its(:logger) { is_expected.to be_a(StringIO) }
+    end
+  end
+
+  describe "#valid?" do
+    context "when #validate returns a resolved promise" do
+      before { expect(subject).to receive(:validate).and_return(resolved_promise) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when #validate returns a rejected promise" do
+      before { expect(subject).to receive(:validate).and_return(rejected_promise) }
+      it { is_expected.not_to be_valid }
+    end
+  end
+
+  describe "#ignored_environment?" do
+    context "when Validator returns a resolved promise" do
+      before do
+        expect(Airbrake::Config::Validator).to receive(:check_notify_ability)
+          .and_return(resolved_promise)
+      end
+
+      its(:ignored_environment?) { is_expected.to be_falsey }
+    end
+
+    context "when Validator returns a rejected promise" do
+      before do
+        expect(Airbrake::Config::Validator).to receive(:check_notify_ability)
+          .and_return(rejected_promise)
+      end
+
+      its(:ignored_environment?) { is_expected.to be_truthy }
+    end
+  end
+
+  describe "#endpoint" do
+    subject { described_class.new(valid_params.merge(user_config)) }
+
+    context "when host ends with a URL with a slug with a trailing slash" do
+      let(:user_config) { { host: 'https://localhost/bingo/' } }
+
+      its(:endpoint) do
+        is_expected.to eq(URI('https://localhost/bingo/api/v3/projects/1/notices'))
+      end
+    end
+
+    context "when host ends with a URL with a slug without a trailing slash" do
+      let(:user_config) { { host: 'https://localhost/bingo' } }
+
+      its(:endpoint) do
+        is_expected.to eq(URI('https://localhost/api/v3/projects/1/notices'))
+      end
+    end
+  end
+
+  describe "#validate" do
+    its(:validate) { is_expected.to be_an(Airbrake::Promise) }
+  end
+
+  describe "#check_configuration" do
+    let(:user_config) { {} }
+
+    subject { described_class.new(valid_params.merge(user_config)) }
+
+    its(:check_configuration) { is_expected.to be_an(Airbrake::Promise) }
+
+    context "when config is invalid" do
+      let(:user_config) { { project_id: nil } }
+      its(:check_configuration) { is_expected.to be_rejected }
+    end
+
+    context "when current environment is ignored" do
+      let(:user_config) { { environment: 'test', ignore_environments: ['test'] } }
+      its(:check_configuration) { is_expected.to be_rejected }
+    end
+
+    context "when config is valid and allows notifying" do
+      its(:check_configuration) { is_expected.not_to be_rejected }
+    end
+  end
+
+  describe "#check_performance_options" do
+    it "returns a promise" do
+      resource = Airbrake::Query.new(
+        method: '', route: '', query: '', start_time: Time.now
+      )
+      expect(subject.check_performance_options(resource))
+        .to be_an(Airbrake::Promise)
+    end
+
+    context "when performance stats are disabled" do
+      before { subject.performance_stats = false }
+
+      let(:resource) do
+        Airbrake::Request.new(
+          method: 'GET', route: '/foo', status_code: 200, start_time: Time.new
+        )
+      end
+
+      it "returns a rejected promise" do
+        promise = subject.check_performance_options(resource)
+        expect(promise.value).to eq(
+          'error' => "The Performance Stats feature is disabled"
+        )
+      end
+    end
+
+    context "when query stats are disabled" do
+      before { subject.query_stats = false }
+
+      let(:resource) do
+        Airbrake::Query.new(
+          method: 'GET', route: '/foo', query: '', start_time: Time.new
+        )
+      end
+
+      it "returns a rejected promise" do
+        promise = subject.check_performance_options(resource)
+        expect(promise.value).to eq(
+          'error' => "The Query Stats feature is disabled"
+        )
+      end
+    end
+  end
+end