airbrake-ruby 4.0.1 → 4.1.0

data/lib/airbrake-ruby/version.rb

@@ -2,5 +2,5 @@
 # More information: http://semver.org/
 module Airbrake
   # @return [String] the library version
-  AIRBRAKE_RUBY_VERSION = '4.0.1'.freeze
+  AIRBRAKE_RUBY_VERSION = '4.1.0'.freeze
 end

data/spec/airbrake_spec.rb

@@ -25,15 +25,15 @@ RSpec.describe Airbrake do
 
     context "when user config doesn't contain a project id" do
       it "raises error" do
-        expect { described_class.configure { |c| c.project_key = '1' } }.
-          to raise_error(Airbrake::Error, ':project_id is required')
+        expect { described_class.configure { |c| c.project_key = '1' } }
+          .to raise_error(Airbrake::Error, ':project_id is required')
       end
     end
 
     context "when user config doesn't contain a project key" do
       it "raises error" do
-        expect { described_class.configure { |c| c.project_id = 1 } }.
-          to raise_error(Airbrake::Error, ':project_key is required')
+        expect { described_class.configure { |c| c.project_id = 1 } }
+          .to raise_error(Airbrake::Error, ':project_key is required')
       end
     end
   end

data/spec/backtrace_spec.rb

@@ -20,8 +20,8 @@ RSpec.describe Airbrake::Backtrace do
       end
 
       it "returns a properly formatted array of hashes" do
-        expect(described_class.parse(AirbrakeTestError.new)).
-          to eq(parsed_backtrace)
+        expect(described_class.parse(AirbrakeTestError.new))
+          .to eq(parsed_backtrace)
       end
     end
 
@@ -65,8 +65,8 @@ RSpec.describe Airbrake::Backtrace do
       it "returns a properly formatted array of hashes" do
         allow(described_class).to receive(:java_exception?).and_return(true)
 
-        expect(described_class.parse(JavaAirbrakeTestError.new)).
-          to eq(backtrace_array)
+        expect(described_class.parse(JavaAirbrakeTestError.new))
+          .to eq(backtrace_array)
       end
     end
 

data/spec/config/validator_spec.rb

@@ -1,188 +1,183 @@
 RSpec.describe Airbrake::Config::Validator do
-  subject { described_class.new(config) }
+  let(:valid_id) { 123 }
+  let(:valid_key) { '123' }
+  let(:config) { Airbrake::Config.new(config_params) }
 
-  describe "#valid_project_id?" do
-    context "when project id is zero" do
-      let(:config) { Airbrake::Config.new(project_id: 0) }
+  describe ".validate" do
+    context "when project_id is numerical" do
+      let(:config_params) { { project_id: valid_id, project_key: valid_key } }
 
-      it "returns false" do
-        expect(subject.valid_project_id?).to be false
-      end
-
-      it "sets correct error message" do
-        expect { subject.valid_project_id? }.to(
-          change { subject.error_message }.to(/:project_id is required/)
-        )
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
       end
     end
 
-    context "when project_id is a String" do
-      let(:config) { Airbrake::Config.new(project_id: '000') }
+    context "when project_id is a numerical String" do
+      let(:config_params) { { project_id: '123', project_key: valid_key } }
 
-      context "and when it's zero" do
-        it "returns false" do
-          expect(subject.valid_project_id?).to be false
-        end
-
-        it "sets correct error message" do
-          expect { subject.valid_project_id? }.
-            to(
-              change { subject.error_message }.to(/:project_id is required/)
-            )
-        end
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
       end
+    end
 
-      context "and when it consists of letters" do
-        let(:config) { Airbrake::Config.new(project_id: 'bingo') }
-
-        it "returns false" do
-          expect(subject.valid_project_id?).to be false
-        end
+    context "when project_id is zero" do
+      let(:config_params) { { project_id: 0, project_key: valid_key } }
 
-        it "sets correct error message" do
-          expect { subject.valid_project_id? }.to(
-            change { subject.error_message }.to(/:project_id is required/)
-          )
-        end
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq('error' => ':project_id is required')
       end
+    end
 
-      context "and when it's numerical" do
-        let(:config) { Airbrake::Config.new(project_id: '123') }
-
-        it "returns true" do
-          expect(subject.valid_project_id?).to be true
-        end
+    context "when project_id consists of letters" do
+      let(:config_params) { { project_id: 'foo', project_key: valid_key } }
 
-        it "doesn't set the error message" do
-          expect { subject.valid_project_id? }.not_to(change { subject.error_message })
-        end
+      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 non-zero" do
-      let(:config) { Airbrake::Config.new(project_id: 123) }
+    context "when project_id is less than zero" do
+      let(:config_params) { { project_id: -123, project_key: valid_key } }
 
-      it "returns true" do
-        expect(subject.valid_project_id?).to be true
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq('error' => ':project_id is required')
       end
+    end
 
-      it "doesn't set the error message" do
-        expect { subject.valid_project_id? }.not_to(change { subject.error_message })
+    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
-  end
 
-  describe "#valid_project_key?" do
-    context "when it's a String" do
-      context "and when it's empty" do
-        let(:config) { Airbrake::Config.new(project_key: '') }
+    context "when project_key is an empty String" do
+      let(:config_params) { { project_id: valid_id, project_key: '' } }
 
-        it "returns false" do
-          expect(subject.valid_project_key?).to be false
-        end
-
-        it "sets correct error message" do
-          expect { subject.valid_project_key? }.
-            to change { subject.error_message }.
-            to(/:project_key is required/)
-        end
+      it "returns a rejected promise" do
+        promise = described_class.validate(config)
+        expect(promise.value).to eq('error' => ':project_key is required')
       end
+    end
 
-      context "and when it's non-empty" do
-        let(:config) { Airbrake::Config.new(project_key: '123abc') }
-
-        it "returns true" do
-          expect(subject.valid_project_key?).to be true
-        end
+    context "when project_key is a non-String" do
+      let(:config_params) { { project_id: valid_id, project_key: 123 } }
 
-        it "doesn't set the error message" do
-          expect { subject.valid_project_key? }.not_to(change { subject.error_message })
-        end
+      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 it's not a String" do
-      let(:config) { Airbrake::Config.new(project_key: 123) }
-
-      it "returns false" do
-        expect(subject.valid_project_key?).to be false
+    context "when environment is nil" do
+      let(:config_params) do
+        { project_id: valid_id, project_key: valid_key, environment: nil }
       end
 
-      it "sets correct error message" do
-        expect { subject.valid_project_key? }.to(
-          change { subject.error_message }.to(/:project_key is required/)
-        )
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
       end
     end
-  end
 
-  describe "#valid_environment?" do
-    context "when config.environment is not set" do
-      let(:config) { Airbrake::Config.new }
-
-      it "returns true" do
-        expect(subject.valid_environment?).to be true
+    context "when environment is a String" do
+      let(:config_params) do
+        { project_id: valid_id, project_key: valid_key, environment: 'test' }
       end
 
-      it "doesn't set the error message" do
-        expect { subject.valid_environment? }.not_to(change { subject.error_message })
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
       end
     end
 
-    context "when config.environment is set" do
-      context "and when it is not a Symbol or String" do
-        let(:config) { Airbrake::Config.new(environment: 123) }
-
-        it "returns false" do
-          expect(subject.valid_environment?).to be false
-        end
-
-        it "sets the error message" do
-          expect { subject.valid_environment? }.to(
-            change { subject.error_message }.
-              to(/the 'environment' option must be configured with a Symbol/)
-          )
-        end
+    context "when environment is a Symbol" do
+      let(:config_params) do
+        { project_id: valid_id, project_key: valid_key, environment: :test }
       end
 
-      context "and when it is a Symbol" do
-        let(:config) { Airbrake::Config.new(environment: :bingo) }
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
+      end
+    end
 
-        it "returns true" do
-          expect(subject.valid_environment?).to be true
-        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 "doesn't set the error message" do
-          expect { subject.valid_environment? }.not_to(change { subject.error_message })
-        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 "and when it is a String" do
-        let(:config) { Airbrake::Config.new(environment: 'bingo') }
+    context "when environment is String-like" do
+      let(:string_inquirer) { Class.new(String) }
 
-        it "returns true" do
-          expect(subject.valid_environment?).to be true
-        end
+      let(:config_params) do
+        {
+          project_id: valid_id,
+          project_key: valid_key,
+          environment: string_inquirer.new('test')
+        }
+      end
 
-        it "doesn't set the error message" do
-          expect { subject.valid_environment? }.not_to(change { subject.error_message })
-        end
+      it "returns a resolved promise" do
+        promise = described_class.validate(config)
+        expect(promise).to be_resolved
       end
+    end
+  end
 
-      context "and when it is kind of a String" do
-        let(:string_inquirer) { Class.new(String) }
+  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
 
-        let(:config) do
-          Airbrake::Config.new(environment: string_inquirer.new('bingo'))
-        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 true" do
-          expect(subject.valid_environment?).to be true
-        end
+      it "returns a rejected promise" do
+        promise = described_class.check_notify_ability(config)
+        expect(promise).to be_resolved
+      end
 
-        it "doesn't set the error message" do
-          expect { subject.valid_environment? }.not_to(change { subject.error_message })
-        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

data/spec/config_spec.rb

@@ -1,264 +1,109 @@
 RSpec.describe Airbrake::Config do
-  describe "#new" do
-    describe "options" do
-      it "doesn't set the default project_id" do
-        expect(subject.project_id).to be_nil
-      end
-
-      it "doesn't set the default project_key" do
-        expect(subject.project_key).to be_nil
-      end
-
-      it "doesn't set the default proxy" do
-        expect(subject.proxy).to be_empty
-      end
-
-      it "sets the default logger" do
-        expect(subject.logger).to be_a Logger
-      end
-
-      it "doesn't set the default app_version" do
-        expect(subject.app_version).to be_nil
-      end
-
-      it "sets the default versions" do
-        expect(subject.versions).to be_empty
-      end
-
-      it "sets the default host" do
-        expect(subject.host).to eq('https://api.airbrake.io')
-      end
-
-      it "sets the default endpoint" do
-        expect(subject.endpoint).not_to be_nil
-      end
-
-      it "creates a new Config and merges it with the user config" do
-        config = described_class.new(logger: StringIO.new)
-        expect(config.logger).to be_a(StringIO)
-      end
-
-      it "raises error on unknown config options" do
-        expect { described_class.new(unknown_option: true) }.
-          to raise_error(Airbrake::Error, /unknown option/)
-      end
-
-      it "sets the default number of workers" do
-        expect(subject.workers).to eq(1)
-      end
-
-      it "sets the default number of queue size" do
-        expect(subject.queue_size).to eq(100)
-      end
-
-      it "sets the default root_directory" do
-        expect(subject.root_directory).to eq Bundler.root.realpath.to_s
-      end
-
-      it "doesn't set the default environment" do
-        expect(subject.environment).to be_nil
-      end
-
-      it "doesn't set default notify_environments" do
-        expect(subject.ignore_environments).to be_empty
-      end
-
-      it "doesn't set default timeout" do
-        expect(subject.timeout).to be_nil
-      end
-
-      it "doesn't set default blacklist" do
-        expect(subject.blacklist_keys).to be_empty
-      end
-
-      it "doesn't set default whitelist" do
-        expect(subject.whitelist_keys).to be_empty
-      end
-
-      it "disables performance stats by default" do
-        expect(subject.performance_stats).to be_falsey
-      end
+  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 be_falsey }
+  its(:performance_stats_flush_period) { is_expected.to eq(15) }
 
-      it "sets the default performance_stats_flush_period" do
-        expect(subject.performance_stats_flush_period).to eq(15)
-      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 project_id is nil" do
-      it "returns false" do
-        config = described_class.new(
-          project_id: nil,
-          project_key: '123'
-        )
-        expect(config).not_to be_valid
-      end
+    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 project_key is nil" do
-      it "returns false" do
-        config = described_class.new(
-          project_id: 123,
-          project_key: nil
-        )
-        expect(config).not_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
 
-    context "when the current environment is ignored" do
-      context "and when the notifier misconfigures configure project_key & project_id" do
-        it "returns true" do
-          config = described_class.new(
-            project_id: Object.new,
-            project_key: Object.new,
-            environment: :bingo,
-            ignore_environments: [:bingo]
-          )
-          expect(config).to be_valid
-        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
 
-      context "and when the notifier configures project_key & project_id" do
-        it "returns true" do
-          config = described_class.new(
-            project_id: 123,
-            project_key: '321',
-            environment: :bingo,
-            ignore_environments: [:bingo]
-          )
-          expect(config).to be_valid
-        end
-      end
+      its(:ignored_environment?) { is_expected.to be_falsey }
     end
 
-    context "when the project_id value is not a number" do
-      it "returns false" do
-        config = described_class.new(
-          project_id: 'bingo',
-          project_key: '321'
-        )
-        expect(config).not_to be_valid
+    context "when Validator returns a rejected promise" do
+      before do
+        expect(Airbrake::Config::Validator).to receive(:check_notify_ability)
+          .and_return(rejected_promise)
       end
-    end
 
-    context "when the project_id value is a String number" do
-      it "returns true" do
-        config = described_class.new(
-          project_id: '123',
-          project_key: '321'
-        )
-        expect(config).to be_valid
-      end
+      its(:ignored_environment?) { is_expected.to be_truthy }
     end
+  end
 
-    context "when the project_key value is not a String" do
-      it "returns false" do
-        config = described_class.new(
-          project_id: 123,
-          project_key: 321
-        )
-        expect(config).not_to be_valid
-      end
-    end
+  describe "#endpoint" do
+    subject { described_class.new(valid_params.merge(user_config)) }
 
-    context "when the project_key value is an empty String" do
-      it "returns false" do
-        config = described_class.new(
-          project_id: 123,
-          project_key: ''
-        )
-        expect(config).not_to be_valid
+    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 the environment value is not a String" do
-      before do
-      end
+    context "when host ends with a URL with a slug without a trailing slash" do
+      let(:user_config) { { host: 'https://localhost/bingo' } }
 
-      it "returns false" do
-        config = described_class.new(
-          project_id: 123,
-          project_key: '321',
-          environment: ['bingo']
-        )
-        expect(config).not_to be_valid
+      its(:endpoint) do
+        is_expected.to eq(URI('https://localhost/api/v3/projects/1/notices'))
       end
     end
   end
 
-  describe "#ignored_environment?" do
-    describe "warnings" do
-      context "when 'ignore_environments' is set and 'environment' isn't" do
-        it "prints a warning" do
-          config = described_class.new(ignore_environments: [:bingo])
+  describe "#validate" do
+    its(:validate) { is_expected.to be_an(Airbrake::Promise) }
+  end
 
-          expect(config.logger).to receive(:warn).with(
-            /'ignore_environments' has no effect/
-          )
-          expect(config.ignored_environment?).to be_falsey
-        end
-      end
+  describe "#check_configuration" do
+    let(:user_config) { {} }
 
-      context "when 'ignore_environments' is set along with 'environment'" do
-        it "doesn't print a warning" do
-          config = described_class.new(
-            environment: :bango,
-            ignore_environments: [:bingo]
-          )
+    subject { described_class.new(valid_params.merge(user_config)) }
 
-          expect(config.logger).not_to receive(:warn)
-          expect(config.ignored_environment?).to be_falsey
-        end
-      end
-    end
+    its(:check_configuration) { is_expected.to be_an(Airbrake::Promise) }
 
-    describe "environment value types" do
-      context "when 'environment' is a String" do
-        context "and when 'ignore_environments' contains Symbols" do
-          it "returns true" do
-            config = described_class.new(
-              environment: 'bango',
-              ignore_environments: [:bango]
-            )
-            expect(config.ignored_environment?).to be_truthy
-          end
-        end
-      end
-
-      context "when 'environment' is a Symbol" do
-        context "and when 'ignore_environments' contains Strings" do
-          it "returns true" do
-            config = described_class.new(
-              environment: :bango,
-              ignore_environments: %w[bango]
-            )
-            expect(config.ignored_environment?).to be_truthy
-          end
-        end
-      end
+    context "when config is invalid" do
+      let(:user_config) { { project_id: nil } }
+      its(:check_configuration) { is_expected.to be_rejected }
     end
-  end
-
-  describe "#endpoint" do
-    context "when host is configured with a URL with a slug" do
-      let(:config) { described_class.new(project_id: 1, project_key: '2') }
 
-      context "and with a trailing slash" do
-        it "sets the endpoint with the slug" do
-          config.host = 'https://localhost/bingo/'
-          expect(config.endpoint.to_s).
-            to eq('https://localhost/bingo/api/v3/projects/1/notices')
-        end
-      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 "and without a trailing slash" do
-        it "sets the endpoint without the slug" do
-          config.host = 'https://localhost/bingo'
-          expect(config.endpoint.to_s).
-            to eq('https://localhost/api/v3/projects/1/notices')
-        end
-      end
+    context "when config is valid and allows notifying" do
+      its(:check_configuration) { is_expected.not_to be_rejected }
     end
   end
 end