airbrake-ruby 6.1.0 → 6.1.1

data/spec/config/processor_spec.rb

@@ -1,167 +0,0 @@
-RSpec.describe Airbrake::Config::Processor do
-  let(:notifier) { Airbrake::NoticeNotifier.new }
-
-  describe "#process_blocklist" do
-    let(:config) { Airbrake::Config.new(blocklist_keys: %w[a b c]) }
-
-    context "when there ARE blocklist keys" do
-      it "adds the blocklist filter" do
-        described_class.new(config).process_blocklist(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::KeysBlocklist)).to be(true)
-      end
-    end
-
-    context "when there are NO blocklist keys" do
-      let(:config) { Airbrake::Config.new(blocklist_keys: %w[]) }
-
-      it "doesn't add the blocklist filter" do
-        described_class.new(config).process_blocklist(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::KeysBlocklist))
-          .to be(false)
-      end
-    end
-  end
-
-  describe "#process_allowlist" do
-    let(:config) { Airbrake::Config.new(allowlist_keys: %w[a b c]) }
-
-    context "when there ARE allowlist keys" do
-      it "adds the allowlist filter" do
-        described_class.new(config).process_allowlist(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::KeysAllowlist)).to be(true)
-      end
-    end
-
-    context "when there are NO allowlist keys" do
-      let(:config) { Airbrake::Config.new(allowlist_keys: %w[]) }
-
-      it "doesn't add the allowlist filter" do
-        described_class.new(config).process_allowlist(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::KeysAllowlist))
-          .to be(false)
-      end
-    end
-  end
-
-  describe "#process_remote_configuration" do
-    before do
-      allow(Airbrake::RemoteSettings).to receive(:poll)
-    end
-
-    context "when the config doesn't define a project_id" do
-      let(:config) { Airbrake::Config.new(project_id: nil) }
-
-      it "doesn't set remote settings" do
-        described_class.new(config).process_remote_configuration
-
-        expect(Airbrake::RemoteSettings).not_to have_received(:poll)
-      end
-    end
-
-    context "when the config sets environment to 'test'" do
-      let(:config) { Airbrake::Config.new(project_id: 123, environment: 'test') }
-
-      it "doesn't set remote settings" do
-        described_class.new(config).process_remote_configuration
-
-        expect(Airbrake::RemoteSettings).not_to have_received(:poll)
-      end
-    end
-
-    context "when the config sets :ignore_environments and :environment matches" do
-      let(:config) do
-        Airbrake::Config.new(
-          project_id: 123,
-          ignore_environments: %w[dev],
-          environment: 'dev',
-        )
-      end
-
-      it "doesn't set remote settings" do
-        described_class.new(config).process_remote_configuration
-
-        expect(Airbrake::RemoteSettings).not_to have_received(:poll)
-      end
-    end
-
-    context "when the config defines a project_id" do
-      let(:config) do
-        Airbrake::Config.new(project_id: 123, environment: 'not-test')
-      end
-
-      it "sets remote settings" do
-        described_class.new(config).process_remote_configuration
-
-        expect(Airbrake::RemoteSettings).to have_received(:poll)
-      end
-    end
-
-    context "when the config disables the remote_config option" do
-      let(:config) { Airbrake::Config.new(project_id: 123, remote_config: false) }
-
-      it "doesn't set remote settings" do
-        described_class.new(config).process_remote_configuration
-
-        expect(Airbrake::RemoteSettings).not_to have_received(:poll)
-      end
-    end
-  end
-
-  describe "#add_filters" do
-    context "when there's a root directory" do
-      let(:config) { Airbrake::Config.new(root_directory: '/abc') }
-
-      it "adds RootDirectoryFilter" do
-        described_class.new(config).add_filters(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::RootDirectoryFilter))
-          .to be(true)
-      end
-
-      it "adds GitRevisionFilter" do
-        described_class.new(config).add_filters(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::GitRevisionFilter))
-          .to be(true)
-      end
-
-      it "adds GitRepositoryFilter" do
-        described_class.new(config).add_filters(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::GitRepositoryFilter))
-          .to be(true)
-      end
-
-      it "adds GitLastCheckoutFilter" do
-        described_class.new(config).add_filters(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::GitLastCheckoutFilter))
-          .to be(true)
-      end
-    end
-
-    context "when there's NO root directory" do
-      let(:config) { Airbrake::Config.new(root_directory: nil) }
-
-      it "doesn't add RootDirectoryFilter" do
-        described_class.new(config).add_filters(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::RootDirectoryFilter))
-          .to be(false)
-      end
-
-      it "doesn't add GitRevisionFilter" do
-        described_class.new(config).add_filters(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::GitRevisionFilter))
-          .to be(false)
-      end
-
-      it "doesn't add GitRepositoryFilter" do
-        described_class.new(config).add_filters(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::GitRepositoryFilter))
-          .to be(false)
-      end
-
-      it "doesn't add GitLastCheckoutFilter" do
-        described_class.new(config).add_filters(notifier)
-        expect(notifier.has_filter?(Airbrake::Filters::GitLastCheckoutFilter))
-          .to be(false)
-      end
-    end
-  end
-end

data/spec/config/validator_spec.rb

@@ -1,204 +0,0 @@
-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 resolved promise" do
-        promise = described_class.check_notify_ability(config)
-        expect(promise).to be_resolved
-      end
-
-      it "warns about 'no effect'" do
-        allow(config.logger).to receive(:warn)
-
-        described_class.check_notify_ability(config)
-
-        expect(config.logger).to have_received(:warn)
-          .with(/'ignore_environments' has no effect/)
-      end
-    end
-
-    context "when the error_notifications option is false" do
-      let(:config_params) do
-        {
-          project_id: valid_id,
-          project_key: valid_key,
-          error_notifications: false,
-        }
-      end
-
-      it "returns a rejected promise" do
-        promise = described_class.check_notify_ability(config)
-        expect(promise.value).to eq(
-          'error' => "error notifications are disabled",
-        )
-      end
-    end
-  end
-end

data/spec/config_spec.rb

@@ -1,188 +0,0 @@
-RSpec.describe Airbrake::Config do
-  subject(:config) { described_class.new }
-
-  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(:error_host) { is_expected.to eq('https://api.airbrake.io') }
-  its(:apm_host) { is_expected.to eq('https://api.airbrake.io') }
-  its(:error_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(:blocklist_keys) { is_expected.to be_empty }
-  its(:allowlist_keys) { is_expected.to be_empty }
-  its(:performance_stats) { is_expected.to be(true) }
-  its(:performance_stats_flush_period) { is_expected.to eq(15) }
-  its(:query_stats) { is_expected.to be(true) }
-  its(:job_stats) { is_expected.to be(true) }
-  its(:error_notifications) { is_expected.to be(true) }
-  its(:remote_config) { is_expected.to be(true) }
-
-  its(:remote_config_host) do
-    is_expected.to eq('https://notifier-configs.airbrake.io')
-  end
-
-  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 the config is valid" do
-      before do
-        config.project_id = 123
-        config.project_key = 'abc'
-      end
-
-      it { is_expected.to be_valid }
-    end
-
-    context "when the config is invalid" do
-      it { is_expected.not_to be_valid }
-    end
-  end
-
-  describe "#ignored_environment?" do
-    context "when Validator returns a resolved promise" do
-      before do
-        allow(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
-        allow(Airbrake::Config::Validator).to receive(:check_notify_ability)
-          .and_return(rejected_promise)
-      end
-
-      its(:ignored_environment?) { is_expected.to be_truthy }
-    end
-  end
-
-  describe "#error_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(:error_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(:error_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
-    subject { described_class.new(valid_params.merge(user_config)) }
-
-    let(: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
-      metric = Airbrake::Query.new(method: '', route: '', query: '', timing: 1)
-      expect(config.check_performance_options(metric))
-        .to be_an(Airbrake::Promise)
-    end
-
-    context "when performance stats are disabled" do
-      before { config.performance_stats = false }
-
-      let(:metric) do
-        Airbrake::Request.new(
-          method: 'GET', route: '/foo', status_code: 200, timing: 1,
-        )
-      end
-
-      it "returns a rejected promise" do
-        promise = config.check_performance_options(metric)
-        expect(promise.value).to eq(
-          'error' => "The Performance Stats feature is disabled",
-        )
-      end
-    end
-
-    context "when query stats are disabled" do
-      before { config.query_stats = false }
-
-      let(:metric) do
-        Airbrake::Query.new(method: 'GET', route: '/foo', query: '', timing: 1)
-      end
-
-      it "returns a rejected promise" do
-        promise = config.check_performance_options(metric)
-        expect(promise.value).to eq(
-          'error' => "The Query Stats feature is disabled",
-        )
-      end
-    end
-
-    context "when job stats are disabled" do
-      before { config.job_stats = false }
-
-      let(:metric) do
-        Airbrake::Queue.new(queue: 'foo_queue', error_count: 0, timing: 1)
-      end
-
-      it "returns a rejected promise" do
-        promise = config.check_performance_options(metric)
-        expect(promise.value).to eq(
-          'error' => "The Job Stats feature is disabled",
-        )
-      end
-    end
-  end
-
-  describe "#logger" do
-    it "sets logger level to Logger::WARN" do
-      expect(config.logger.level).to eq(Logger::WARN)
-    end
-  end
-end

data/spec/context_spec.rb

@@ -1,54 +0,0 @@
-RSpec.describe Airbrake::Context do
-  subject(:context) { described_class.current }
-
-  before { described_class.current.clear }
-
-  after { described_class.current.clear }
-
-  describe "#merge!" do
-    it "merges the given context with the current one" do
-      context.merge!(apples: 'oranges')
-      expect(context.to_h).to match(apples: 'oranges')
-    end
-  end
-
-  describe "#clear" do
-    it "clears the context" do
-      context.merge!(apples: 'oranges')
-      context.clear
-      expect(context.to_h).to be_empty
-    end
-  end
-
-  describe "#to_h" do
-    it "returns a hash representation of the context" do
-      expect(context.to_h).to be_a(Hash)
-    end
-  end
-
-  describe "#empty?" do
-    context "when the context has data" do
-      it "returns true" do
-        context.merge!(apples: 'oranges')
-        expect(context).not_to be_empty
-      end
-    end
-
-    context "when the context has NO data" do
-      it "returns false" do
-        expect(context).to be_empty
-      end
-    end
-  end
-
-  context "when another thread is spawned" do
-    it "doesn't clash with other threads' contexts" do
-      described_class.current.merge!(apples: 'oranges')
-      th = Thread.new do
-        described_class.current.merge!(foos: 'bars')
-      end
-      th.join
-      expect(described_class.current.to_h).to match(apples: 'oranges')
-    end
-  end
-end

data/spec/deploy_notifier_spec.rb

@@ -1,50 +0,0 @@
-RSpec.describe Airbrake::DeployNotifier do
-  before do
-    Airbrake::Config.instance = Airbrake::Config.new(project_id: 1, project_key: '123')
-  end
-
-  describe "#notify" do
-    subject(:deploy_notifier) { described_class.new }
-
-    it "returns a promise" do
-      stub_request(:post, 'https://api.airbrake.io/api/v4/projects/1/deploys')
-        .to_return(status: 201, body: '{}')
-      expect(deploy_notifier.notify({})).to be_an(Airbrake::Promise)
-    end
-
-    context "when config is invalid" do
-      before { Airbrake::Config.instance.merge(project_id: nil) }
-
-      it "returns a rejected promise" do
-        promise = deploy_notifier.notify({})
-        expect(promise).to be_rejected
-      end
-    end
-
-    context "when environment is configured" do
-      before { Airbrake::Config.instance.merge(environment: 'fooenv') }
-
-      it "prefers the passed environment to the config env" do
-        expect_any_instance_of(Airbrake::SyncSender).to receive(:send).with(
-          { environment: 'barenv' },
-          instance_of(Airbrake::Promise),
-          URI('https://api.airbrake.io/api/v4/projects/1/deploys'),
-        )
-        deploy_notifier.notify(environment: 'barenv')
-      end
-    end
-
-    context "when environment is not configured" do
-      before { Airbrake::Config.instance.merge(environment: 'fooenv') }
-
-      it "sets the environment from the config" do
-        expect_any_instance_of(Airbrake::SyncSender).to receive(:send).with(
-          { environment: 'fooenv' },
-          instance_of(Airbrake::Promise),
-          URI('https://api.airbrake.io/api/v4/projects/1/deploys'),
-        )
-        deploy_notifier.notify({})
-      end
-    end
-  end
-end

data/spec/file_cache_spec.rb

@@ -1,35 +0,0 @@
-RSpec.describe Airbrake::FileCache do
-  before { described_class.reset }
-
-  after { described_class.reset }
-
-  describe ".[]=" do
-    context "when cache limit isn't reached" do
-      before do
-        stub_const("#{described_class.name}::MAX_SIZE", 10)
-      end
-
-      it "adds objects" do
-        described_class[:banana] = 1
-        described_class[:mango] = 2
-
-        expect(described_class[:banana]).to eq(1)
-        expect(described_class[:mango]).to eq(2)
-      end
-    end
-
-    context "when cache limit is reached" do
-      before do
-        stub_const("#{described_class.name}::MAX_SIZE", 1)
-      end
-
-      it "replaces old objects with new ones" do
-        described_class[:banana] = 1
-        described_class[:mango] = 2
-
-        expect(described_class[:banana]).to be_nil
-        expect(described_class[:mango]).to eq(2)
-      end
-    end
-  end
-end