sentry-raven 3.1.1 → 3.1.2

data/sentry-ruby/spec/sentry/configuration_spec.rb

@@ -1,400 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Sentry::Configuration do
-  before do
-    # Make sure we reset the env in case something leaks in
-    ENV.delete('SENTRY_DSN')
-    ENV.delete('SENTRY_CURRENT_ENV')
-    ENV.delete('SENTRY_ENVIRONMENT')
-    ENV.delete('SENTRY_RELEASE')
-    ENV.delete('RAILS_ENV')
-    ENV.delete('RACK_ENV')
-  end
-
-  it "should set some attributes when server is set" do
-    subject.server = "http://12345:67890@sentry.localdomain:3000/sentry/42"
-
-    expect(subject.project_id).to eq("42")
-    expect(subject.public_key).to eq("12345")
-    expect(subject.secret_key).to eq("67890")
-
-    expect(subject.scheme).to     eq("http")
-    expect(subject.host).to       eq("sentry.localdomain")
-    expect(subject.port).to       eq(3000)
-    expect(subject.path).to       eq("/sentry")
-
-    expect(subject.server).to     eq("http://sentry.localdomain:3000/sentry")
-  end
-
-  describe "#breadcrumbs_logger=" do
-    it "raises error when given an invalid option" do
-      expect { subject.breadcrumbs_logger = :foo }.to raise_error(
-        Sentry::Error,
-        'Unsupported breadcrumbs logger. Supported loggers: [:sentry_logger, :active_support_logger]'
-      )
-    end
-  end
-
-  it "doesnt accept invalid encodings" do
-    expect { subject.encoding = "apple" }.to raise_error(Sentry::Error, 'Unsupported encoding')
-  end
-
-  it "has hashlike attribute accessors" do
-    expect(subject.encoding).to   eq("gzip")
-    expect(subject[:encoding]).to eq("gzip")
-  end
-
-  context 'configuring for async' do
-    it 'should be configurable to send events async' do
-      subject.async = ->(_e) { :ok }
-      expect(subject.async.call('event')).to eq(:ok)
-    end
-
-    it 'should raise when setting async to anything other than callable or false' do
-      subject.transport_failure_callback = -> {}
-      subject.transport_failure_callback = false
-      expect { subject.async = true }.to raise_error(ArgumentError)
-    end
-  end
-
-  it 'should raise when setting transport_failure_callback to anything other than callable or false' do
-    subject.transport_failure_callback = -> {}
-    subject.transport_failure_callback = false
-    expect { subject.transport_failure_callback = true }.to raise_error(ArgumentError)
-  end
-
-  it 'should raise when setting should_capture to anything other than callable or false' do
-    subject.should_capture = -> {}
-    subject.should_capture = false
-    expect { subject.should_capture = true }.to raise_error(ArgumentError)
-  end
-
-  it 'should raise when setting before_send to anything other than callable or false' do
-    subject.before_send = -> {}
-    subject.before_send = false
-    expect { subject.before_send = true }.to raise_error(ArgumentError)
-  end
-
-  context 'being initialized with a current environment' do
-    before(:each) do
-      subject.current_environment = 'test'
-      subject.server = 'http://12345:67890@sentry.localdomain:3000/sentry/42'
-    end
-
-    it 'should send events if test is whitelisted' do
-      subject.environments = %w(test)
-      subject.capture_allowed?
-      puts subject.errors
-      expect(subject.capture_allowed?).to eq(true)
-    end
-
-    it 'should not send events if test is not whitelisted' do
-      subject.environments = %w(not_test)
-      expect(subject.capture_allowed?).to eq(false)
-      expect(subject.errors).to eq(["Not configured to send/capture in environment 'test'"])
-    end
-  end
-
-  context 'being initialized without a current environment' do
-    after do
-      ENV.delete('SENTRY_CURRENT_ENV')
-      ENV.delete('SENTRY_ENVIRONMENT')
-      ENV.delete('RAILS_ENV')
-      ENV.delete('RACK_ENV')
-    end
-
-    it 'defaults to "default"' do
-      expect(subject.current_environment).to eq('default')
-    end
-
-    it 'uses `SENTRY_CURRENT_ENV` env variable' do
-      ENV['SENTRY_CURRENT_ENV'] = 'set-with-sentry-current-env'
-      ENV['SENTRY_ENVIRONMENT'] = 'set-with-sentry-environment'
-      ENV['RAILS_ENV'] = 'set-with-rails-env'
-      ENV['RACK_ENV'] = 'set-with-rack-env'
-
-      expect(subject.current_environment).to eq('set-with-sentry-current-env')
-    end
-
-    it 'uses `SENTRY_ENVIRONMENT` env variable' do
-      ENV['SENTRY_ENVIRONMENT'] = 'set-with-sentry-environment'
-      ENV['RAILS_ENV'] = 'set-with-rails-env'
-      ENV['RACK_ENV'] = 'set-with-rack-env'
-
-      expect(subject.current_environment).to eq('set-with-sentry-environment')
-    end
-
-    it 'uses `RAILS_ENV` env variable' do
-      ENV['SENTRY_CURRENT_ENV'] = nil
-      ENV['RAILS_ENV'] = 'set-with-rails-env'
-      ENV['RACK_ENV'] = 'set-with-rack-env'
-
-      expect(subject.current_environment).to eq('set-with-rails-env')
-    end
-
-    it 'uses `RACK_ENV` env variable' do
-      ENV['SENTRY_CURRENT_ENV'] = nil
-      ENV['RAILS_ENV'] = nil
-      ENV['RACK_ENV'] = 'set-with-rack-env'
-
-      expect(subject.current_environment).to eq('set-with-rack-env')
-    end
-  end
-
-  context 'being initialized without a release' do
-    let(:fake_root) { "/tmp/sentry/" }
-
-    before do
-      allow(File).to receive(:directory?).and_return(false)
-      allow_any_instance_of(described_class).to receive(:project_root).and_return(fake_root)
-    end
-
-    it 'defaults to nil' do
-      expect(subject.release).to eq(nil)
-    end
-
-    it 'uses `SENTRY_RELEASE` env variable' do
-      ENV['SENTRY_RELEASE'] = 'v1'
-
-      expect(subject.release).to eq('v1')
-
-      ENV.delete('SENTRY_CURRENT_ENV')
-    end
-
-    context "when git is available" do
-      before do
-        allow(File).to receive(:directory?).and_return(false)
-        allow(File).to receive(:directory?).with(".git").and_return(true)
-      end
-      it 'gets release from git' do
-        allow(Sentry).to receive(:`).with("git rev-parse --short HEAD 2>&1").and_return("COMMIT_SHA")
-
-        expect(subject.release).to eq('COMMIT_SHA')
-      end
-    end
-
-    context "when Capistrano is available" do
-      let(:revision) { "2019010101000" }
-
-      before do
-        Dir.mkdir(fake_root) unless Dir.exist?(fake_root)
-        File.write(filename, file_content)
-      end
-
-      after do
-        File.delete(filename)
-        Dir.delete(fake_root)
-      end
-
-      context "when the REVISION file is present" do
-        let(:filename) do
-          File.join(fake_root, "REVISION")
-        end
-        let(:file_content) { revision }
-
-        it "gets release from the REVISION file" do
-          expect(subject.release).to eq(revision)
-        end
-      end
-
-      context "when the revisions.log file is present" do
-        let(:filename) do
-          File.join(fake_root, "..", "revisions.log")
-        end
-        let(:file_content) do
-          "Branch master (at COMMIT_SHA) deployed as release #{revision} by alice"
-        end
-
-        it "gets release from the REVISION file" do
-          expect(subject.release).to eq(revision)
-        end
-      end
-    end
-
-    context "when running on heroku" do
-      before do
-        allow(File).to receive(:directory?).and_return(false)
-        allow(File).to receive(:directory?).with("/etc/heroku").and_return(true)
-      end
-
-      context "when it's on heroku ci" do
-        it "returns nil" do
-          begin
-            original_ci_val = ENV["CI"]
-            ENV["CI"] = "true"
-
-            expect(subject.release).to eq(nil)
-          ensure
-            ENV["CI"] = original_ci_val
-          end
-        end
-      end
-
-      context "when it's not on heroku ci" do
-        around do |example|
-          begin
-            original_ci_val = ENV["CI"]
-            ENV["CI"] = nil
-
-            example.run
-          ensure
-            ENV["CI"] = original_ci_val
-          end
-        end
-
-        it "returns nil + logs an warning if HEROKU_SLUG_COMMIT is not set" do
-          logger = double("logger")
-          expect(::Sentry::Logger).to receive(:new).and_return(logger)
-          expect(logger).to receive(:warn).with(described_class::HEROKU_DYNO_METADATA_MESSAGE)
-
-          expect(described_class.new.release).to eq(nil)
-        end
-
-        it "returns HEROKU_SLUG_COMMIT" do
-          begin
-            ENV["HEROKU_SLUG_COMMIT"] = "REVISION"
-
-            expect(subject.release).to eq("REVISION")
-          ensure
-            ENV["HEROKU_SLUG_COMMIT"] = nil
-          end
-        end
-      end
-    end
-  end
-
-  describe "config: backtrace_cleanup_callback" do
-    it "defaults to nil" do
-      expect(subject.backtrace_cleanup_callback).to eq(nil)
-    end
-
-    it "takes a proc and store it" do
-      subject.backtrace_cleanup_callback = proc {}
-
-      expect(subject.backtrace_cleanup_callback).to be_a(Proc)
-    end
-  end
-
-  context 'with a should_capture callback configured' do
-    before(:each) do
-      subject.should_capture = ->(exc_or_msg) { exc_or_msg != "dont send me" }
-      subject.server = 'http://12345:67890@sentry.localdomain:3000/sentry/42'
-    end
-
-    it 'should not send events if should_capture returns false' do
-      expect(subject.capture_allowed?("dont send me")).to eq(false)
-      expect(subject.errors).to eq(["should_capture returned false"])
-      expect(subject.capture_allowed?("send me")).to eq(true)
-    end
-  end
-
-  context "with an invalid server" do
-    before(:each) do
-      subject.server = 'dummy://trololo'
-    end
-
-    it 'captured_allowed returns false' do
-      expect(subject.capture_allowed?).to eq(false)
-      expect(subject.errors).to eq(["No public_key specified", "No project_id specified"])
-    end
-  end
-
-  context "with the new Sentry 9 DSN format" do
-    # Basically the same as before, without a secret
-    before(:each) do
-      subject.server = "https://66260460f09b5940498e24bb7ce093a0@sentry.io/42"
-    end
-
-    it 'captured_allowed is true' do
-      expect(subject.capture_allowed?).to eq(true)
-    end
-
-    it "sets the DSN in the way we expect" do
-      expect(subject.dsn).to eq("https://66260460f09b5940498e24bb7ce093a0@sentry.io/42")
-      expect(subject.server).to eq("https://sentry.io")
-      expect(subject.project_id).to eq("42")
-      expect(subject.public_key).to eq("66260460f09b5940498e24bb7ce093a0")
-      expect(subject.secret_key).to be_nil
-    end
-  end
-
-  context "with a sample rate" do
-    before(:each) do
-      subject.server = 'http://12345:67890@sentry.localdomain:3000/sentry/42'
-      subject.sample_rate = 0.75
-    end
-
-    it 'captured_allowed false when sampled' do
-      allow(Random::DEFAULT).to receive(:rand).and_return(0.76)
-      expect(subject.capture_allowed?).to eq(false)
-      expect(subject.errors).to eq(["Excluded by random sample"])
-    end
-
-    it 'captured_allowed true when not sampled' do
-      allow(Random::DEFAULT).to receive(:rand).and_return(0.74)
-      expect(subject.capture_allowed?).to eq(true)
-    end
-  end
-
-  describe '#exception_class_allowed?' do
-    class MyTestException < RuntimeError; end
-
-    context 'with custom excluded_exceptions' do
-      before do
-        subject.excluded_exceptions = ['MyTestException']
-      end
-
-      context 'when the raised exception is a Sentry::Error' do
-        let(:incoming_exception) { Sentry::Error.new }
-        it 'returns false' do
-          expect(subject.exception_class_allowed?(incoming_exception)).to eq false
-        end
-      end
-
-      context 'when the raised exception is not in excluded_exceptions' do
-        let(:incoming_exception) { RuntimeError.new }
-        it 'returns true' do
-          expect(subject.exception_class_allowed?(incoming_exception)).to eq true
-        end
-      end
-
-      context 'when the raised exception has a cause that is in excluded_exceptions' do
-        let(:incoming_exception) { build_exception_with_cause(MyTestException.new) }
-        context 'when inspect_exception_causes_for_exclusion is false' do
-          it 'returns true' do
-            expect(subject.exception_class_allowed?(incoming_exception)).to eq true
-          end
-        end
-
-        # Only check causes when they're supported by the ruby version
-        context 'when inspect_exception_causes_for_exclusion is true' do
-          before do
-            subject.inspect_exception_causes_for_exclusion = true
-          end
-
-          if Exception.new.respond_to? :cause
-            context 'when the language version supports exception causes' do
-              it 'returns false' do
-                expect(subject.exception_class_allowed?(incoming_exception)).to eq false
-              end
-            end
-          else
-            context 'when the language version does not support exception causes' do
-              it 'returns true' do
-                expect(subject.exception_class_allowed?(incoming_exception)).to eq true
-              end
-            end
-          end
-        end
-      end
-
-      context 'when the raised exception is in excluded_exceptions' do
-        let(:incoming_exception) { MyTestException.new }
-
-        it 'returns false' do
-          expect(subject.exception_class_allowed?(incoming_exception)).to eq false
-        end
-      end
-    end
-  end
-end

data/sentry-ruby/spec/sentry/event_spec.rb

@@ -1,238 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Sentry::Event do
-  let(:configuration) { Sentry::Configuration.new }
-  let(:essential_options) do
-    {
-      configuration: configuration
-    }
-  end
-
-  describe "#initialize" do
-    it "initializes a Event when all required keys are provided" do
-      expect(described_class.new(essential_options)).to be_a(described_class)
-    end
-  end
-
-  context 'a fully implemented event' do
-    let(:hash) do
-      Sentry::Event.new(
-        configuration: configuration,
-        message: 'test',
-        level: 'warn',
-        tags: {
-          'foo' => 'bar'
-        },
-        extra: {
-          'my_custom_variable' => 'value'
-        },
-        server_name: 'foo.local',
-        release: '721e41770371db95eee98ca2707686226b993eda',
-        environment: 'production'
-      ).to_hash
-    end
-
-    it 'has message' do
-      expect(hash[:message]).to eq('test')
-    end
-
-    it 'has level' do
-      expect(hash[:level]).to eq(:warning)
-    end
-
-    it 'has server name' do
-      expect(hash[:server_name]).to eq('foo.local')
-    end
-
-    it 'has release' do
-      expect(hash[:release]).to eq('721e41770371db95eee98ca2707686226b993eda')
-    end
-
-    it 'has environment' do
-      expect(hash[:environment]).to eq('production')
-    end
-
-    it 'has tag data' do
-      expect(hash[:tags]).to eq('foo' => 'bar')
-    end
-
-    it 'has extra data' do
-      expect(hash[:extra]["my_custom_variable"]).to eq('value')
-    end
-
-    it 'has platform' do
-      expect(hash[:platform]).to eq(:ruby)
-    end
-
-    it 'has SDK' do
-      expect(hash[:sdk]).to eq("name" => "sentry-ruby", "version" => Sentry::VERSION)
-    end
-
-    it 'has server os' do
-      expect(hash[:extra][:server][:os].keys).to eq([:name, :version, :build, :kernel_version])
-    end
-
-    it 'has runtime' do
-      expect(hash[:extra][:server][:runtime][:version]).to match(/ruby/)
-    end
-  end
-
-  context 'parameter entries are nil' do
-    let(:hash) do
-      Sentry::Event.new(
-        message: 'test',
-        level: 'warn',
-        tags: nil,
-        extra: nil,
-        user: nil,
-        server_name: 'foo.local',
-        release: '721e41770371db95eee98ca2707686226b993eda',
-        environment: 'production',
-        configuration: configuration
-      ).to_hash
-    end
-
-    it "skips nil values" do
-      expect(hash[:extra]).to eq({})
-      expect(hash[:user]).to eq({})
-      expect(hash[:tags]).to eq({})
-    end
-  end
-
-  context 'configuration tags specified' do
-    let(:hash) do
-      config = Sentry::Configuration.new
-      config.tags = { 'key' => 'value' }
-      config.release = "custom"
-      config.current_environment = "custom"
-
-      Sentry::Event.new(
-        level: 'warning',
-        tags: {
-          'foo' => 'bar'
-        },
-        server_name: 'foo.local',
-        configuration: config,
-      ).to_hash
-    end
-
-    it 'merges tags data' do
-      expect(hash[:tags]).to eq('key' => 'value',
-                                'foo' => 'bar')
-      expect(hash[:release]).to eq("custom")
-      expect(hash[:environment]).to eq("custom")
-    end
-
-    it 'does not persist tags between unrelated events' do
-      config = Sentry::Configuration.new
-      config.logger = Logger.new(nil)
-
-      Sentry::Event.new(
-        level: 'warning',
-        tags: {
-          'foo' => 'bar'
-        },
-        server_name: 'foo.local',
-        configuration: config
-      )
-
-      hash = Sentry::Event.new(
-        level: 'warning',
-        server_name: 'foo.local',
-        configuration: config
-      ).to_hash
-
-      expect(hash[:tags]).to eq({})
-    end
-  end
-
-  # context 'tags hierarchy respected' do
-  #   let(:hash) do
-  #     config = Sentry::Configuration.new
-  #     config.logger = Logger.new(nil)
-  #     config.tags = {
-  #       'configuration_context_event_key' => 'configuration_value',
-  #       'configuration_context_key' => 'configuration_value',
-  #       'configuration_event_key' => 'configuration_value',
-  #       'configuration_key' => 'configuration_value'
-  #     }
-
-  #     Sentry.tags_context('configuration_context_event_key' => 'context_value',
-  #                        'configuration_context_key' => 'context_value',
-  #                        'context_event_key' => 'context_value',
-  #                        'context_key' => 'context_value')
-
-  #     Sentry::Event.new(
-  #       level: 'warning',
-  #       logger: 'foo',
-  #       tags: {
-  #         'configuration_context_event_key' => 'event_value',
-  #         'configuration_event_key' => 'event_value',
-  #         'context_event_key' => 'event_value',
-  #         'event_key' => 'event_value'
-  #       },
-  #       server_name: 'foo.local',
-  #       configuration: config
-  #     ).to_hash
-  #   end
-
-  #   it 'merges tags data' do
-  #     expect(hash[:tags]).to eq('configuration_context_event_key' => 'event_value',
-  #                               'configuration_context_key' => 'context_value',
-  #                               'configuration_event_key' => 'event_value',
-  #                               'context_event_key' => 'event_value',
-  #                               'configuration_key' => 'configuration_value',
-  #                               'context_key' => 'context_value',
-  #                               'event_key' => 'event_value')
-  #   end
-  # end
-
-  describe '#to_json_compatible' do
-    subject do
-      Sentry::Event.new(
-        extra: {
-          'my_custom_variable' => 'value',
-          'date' => Time.utc(0),
-          'anonymous_module' => Class.new
-        },
-        configuration: configuration
-      )
-    end
-
-    it "should coerce non-JSON-compatible types" do
-      json = subject.to_json_compatible
-
-      expect(json["extra"]['my_custom_variable']).to eq('value')
-      expect(json["extra"]['date']).to be_a(String)
-      expect(json["extra"]['anonymous_module']).not_to be_a(Class)
-    end
-
-    # context "with bad data" do
-    #   subject do
-    #     data = {}
-    #     data['data'] = data
-    #     data['ary'] = []
-    #     data['ary'].push('x' => data['ary'])
-    #     data['ary2'] = data['ary']
-
-    #     Sentry::Event.new(extra: {
-    #                        invalid: "invalid\255".dup.force_encoding('UTF-8'),
-    #                        circular: data
-    #                      },
-    #                      configuration: configuration)
-    #   end
-
-    #   it "should remove bad UTF-8" do
-    #     json = subject.to_json_compatible
-
-    #     expect(json["extra"]["invalid"]).to eq("invalid")
-    #   end
-
-    #   it "should remove circular references" do
-    #     json = subject.to_json_compatible
-
-    #     expect(json["extra"]["circular"]["ary2"]).to eq("(...)")
-    #   end
-    # end
-  end
-end