raygun4ruby 3.2.3 → 3.2.4

data/spec/raygun/breadcrumbs/store_spec.rb

@@ -1,170 +1,170 @@
-require "spec_helper"
-
-module Raygun
-  module Breadcrumbs
-    describe Store do
-      let(:subject) { Store }
-      after { subject.clear }
-
-      describe "#initialize" do
-        before do
-          expect(subject.stored).to eq(nil)
-
-          subject.initialize
-        end
-
-        it "creates the store on the current Thread" do
-          expect(subject.stored).to eq([])
-        end
-
-        it "does not effect other threads" do
-          Thread.new do
-            expect(subject.stored).to eq(nil)
-          end.join
-        end
-      end
-
-      describe "#any?" do
-        it "returns true if any breadcrumbs have been logged" do
-          subject.initialize
-
-          subject.record(message: "test")
-
-          expect(subject.any?).to eq(true)
-        end
-
-        it "returns false if none have been logged" do
-          subject.initialize
-
-          expect(subject.any?).to eq(false)
-        end
-
-        it "returns false if the store is uninitialized" do
-          expect(subject.any?).to eq(false)
-        end
-      end
-
-      describe "#clear" do
-        before do
-          subject.initialize
-        end
-
-        it "resets the store back to nil" do
-          subject.clear
-
-          expect(subject.stored).to eq(nil)
-        end
-      end
-
-      describe "#should_record?" do
-        it "returns false when the log level is above the breadcrumbs level" do
-          allow(Raygun.configuration).to receive(:breadcrumb_level).and_return(:error)
-
-          crumb = Breadcrumb.new
-          crumb.level = :warning
-
-          expect(subject.send(:should_record?, crumb)).to eq(false)
-        end
-      end
-
-      describe "#take_until_size" do
-        before do
-          subject.initialize
-        end
-
-        it "takes the most recent breadcrumbs until the size limit is reached" do
-          subject.record(message: '1' * 100)
-          subject.record(message: '2' * 100)
-          subject.record(message: '3' * 100)
-
-          crumbs = subject.take_until_size(500)
-
-          expect(crumbs.length).to eq(2)
-          expect(crumbs[0].message).to eq('2' * 100)
-          expect(crumbs[1].message).to eq('3' * 100)
-        end
-
-        it "does not crash with no recorded breadcrumbs" do
-          crumbs = subject.take_until_size(500)
-
-          expect(crumbs).to eq([])
-        end
-      end
-
-      context "adding a breadcrumb" do
-        class Foo
-          include ::Raygun::Breadcrumbs
-
-          def bar
-            record_breadcrumb(message: "test")
-          end
-        end
-
-        before do
-          subject.clear
-          subject.initialize
-        end
-
-        it "gets stored" do
-          subject.record(message: "test")
-
-          expect(subject.stored.length).to eq(1)
-          expect(subject.stored[0].message).to eq("test")
-        end
-
-        it "automatically sets the class name" do
-          Foo.new.bar
-
-          bc = subject.stored[0]
-          expect(bc.class_name).to eq("Raygun::Breadcrumbs::Foo")
-        end
-
-        it "automatically sets the method name" do
-          Foo.new.bar
-
-          bc = subject.stored[0]
-          expect(bc.method_name).to eq("bar")
-        end
-
-        it "does not set the method name if it is already set" do
-          subject.record(message: 'test', method_name: "foo")
-
-          expect(subject.stored[0].method_name).to eq("foo")
-        end
-
-
-        it "automatically sets the timestamp" do
-          Timecop.freeze do
-            Foo.new.bar
-
-            bc = subject.stored[0]
-            expect(bc.timestamp).to eq(Time.now.utc.to_i)
-          end
-        end
-
-        it "does not set the timestamp if it is already set" do
-          time = Time.now.utc
-
-          Timecop.freeze do
-            subject.record(message: 'test', timestamp: time)
-
-            expect(subject.stored[0].timestamp).to_not eq(Time.now.utc)
-          end
-        end
-
-        it "sets the log level to :info if one is not supplied" do
-          Foo.new.bar
-
-          expect(subject.stored[0].level).to eq(:info)
-        end
-
-        it "does not record the breadcrumb if should_record? is false" do
-          expect(subject).to receive(:should_record?).and_return(false)
-          Foo.new.bar
-
-          expect(subject.stored.length).to eq(0)
-        end
-      end
-    end
-  end
-end
+require "spec_helper"
+
+module Raygun
+  module Breadcrumbs
+    describe Store do
+      let(:subject) { Store }
+      after { subject.clear }
+
+      describe "#initialize" do
+        before do
+          expect(subject.stored).to eq(nil)
+
+          subject.initialize
+        end
+
+        it "creates the store on the current Thread" do
+          expect(subject.stored).to eq([])
+        end
+
+        it "does not effect other threads" do
+          Thread.new do
+            expect(subject.stored).to eq(nil)
+          end.join
+        end
+      end
+
+      describe "#any?" do
+        it "returns true if any breadcrumbs have been logged" do
+          subject.initialize
+
+          subject.record(message: "test")
+
+          expect(subject.any?).to eq(true)
+        end
+
+        it "returns false if none have been logged" do
+          subject.initialize
+
+          expect(subject.any?).to eq(false)
+        end
+
+        it "returns false if the store is uninitialized" do
+          expect(subject.any?).to eq(false)
+        end
+      end
+
+      describe "#clear" do
+        before do
+          subject.initialize
+        end
+
+        it "resets the store back to nil" do
+          subject.clear
+
+          expect(subject.stored).to eq(nil)
+        end
+      end
+
+      describe "#should_record?" do
+        it "returns false when the log level is above the breadcrumbs level" do
+          allow(Raygun.configuration).to receive(:breadcrumb_level).and_return(:error)
+
+          crumb = Breadcrumb.new
+          crumb.level = :warning
+
+          expect(subject.send(:should_record?, crumb)).to eq(false)
+        end
+      end
+
+      describe "#take_until_size" do
+        before do
+          subject.initialize
+        end
+
+        it "takes the most recent breadcrumbs until the size limit is reached" do
+          subject.record(message: '1' * 100)
+          subject.record(message: '2' * 100)
+          subject.record(message: '3' * 100)
+
+          crumbs = subject.take_until_size(500)
+
+          expect(crumbs.length).to eq(2)
+          expect(crumbs[0].message).to eq('2' * 100)
+          expect(crumbs[1].message).to eq('3' * 100)
+        end
+
+        it "does not crash with no recorded breadcrumbs" do
+          crumbs = subject.take_until_size(500)
+
+          expect(crumbs).to eq([])
+        end
+      end
+
+      context "adding a breadcrumb" do
+        class Foo
+          include ::Raygun::Breadcrumbs
+
+          def bar
+            record_breadcrumb(message: "test")
+          end
+        end
+
+        before do
+          subject.clear
+          subject.initialize
+        end
+
+        it "gets stored" do
+          subject.record(message: "test")
+
+          expect(subject.stored.length).to eq(1)
+          expect(subject.stored[0].message).to eq("test")
+        end
+
+        it "automatically sets the class name" do
+          Foo.new.bar
+
+          bc = subject.stored[0]
+          expect(bc.class_name).to eq("Raygun::Breadcrumbs::Foo")
+        end
+
+        it "automatically sets the method name" do
+          Foo.new.bar
+
+          bc = subject.stored[0]
+          expect(bc.method_name).to eq("bar")
+        end
+
+        it "does not set the method name if it is already set" do
+          subject.record(message: 'test', method_name: "foo")
+
+          expect(subject.stored[0].method_name).to eq("foo")
+        end
+
+
+        it "automatically sets the timestamp" do
+          Timecop.freeze do
+            Foo.new.bar
+
+            bc = subject.stored[0]
+            expect(bc.timestamp).to eq(Time.now.utc.to_i)
+          end
+        end
+
+        it "does not set the timestamp if it is already set" do
+          time = Time.now.utc
+
+          Timecop.freeze do
+            subject.record(message: 'test', timestamp: time)
+
+            expect(subject.stored[0].timestamp).to_not eq(Time.now.utc)
+          end
+        end
+
+        it "sets the log level to :info if one is not supplied" do
+          Foo.new.bar
+
+          expect(subject.stored[0].level).to eq(:info)
+        end
+
+        it "does not record the breadcrumb if should_record? is false" do
+          expect(subject).to receive(:should_record?).and_return(false)
+          Foo.new.bar
+
+          expect(subject.stored.length).to eq(0)
+        end
+      end
+    end
+  end
+end

data/spec/raygun/raygun_spec.rb

@@ -1,47 +1,47 @@
-require 'spec_helper'
-
-describe Raygun do
-  let(:failsafe_logger) { FakeLogger.new }
-
-  describe '#track_exception' do
-    context 'send in background' do
-      before do
-        Raygun.setup do |c|
-          c.silence_reporting = false
-          c.send_in_background = true
-          c.api_url = 'http://example.api'
-          c.api_key = 'foo'
-          c.debug = true
-          c.failsafe_logger = failsafe_logger
-        end
-      end
-
-      context 'request times out' do
-        before do
-          stub_request(:post, 'http://example.api/entries').to_timeout
-        end
-
-        it 'logs the failure to the failsafe logger' do
-          error = StandardError.new
-
-          Raygun.track_exception(error)
-
-          # Occasionally doesn't write to the failsafe logger, add small timeout to add some safety
-          sleep 0.1
-          expect(failsafe_logger.get).to match /Problem reporting exception to Raygun/
-        end
-      end
-    end
-  end
-
-  describe '#reset_configuration' do
-    subject { Raygun.reset_configuration }
-    it 'clears any customized configuration options' do
-      Raygun.setup do |c|
-        c.api_url = 'http://test.api'
-      end
-
-      expect { subject }.to change { Raygun.configuration.api_url }.from('http://test.api').to(Raygun.default_configuration.api_url)
-    end
-  end
-end
+require 'spec_helper'
+
+describe Raygun do
+  let(:failsafe_logger) { FakeLogger.new }
+
+  describe '#track_exception' do
+    context 'send in background' do
+      before do
+        Raygun.setup do |c|
+          c.silence_reporting = false
+          c.send_in_background = true
+          c.api_url = 'http://example.api'
+          c.api_key = 'foo'
+          c.debug = true
+          c.failsafe_logger = failsafe_logger
+        end
+      end
+
+      context 'request times out' do
+        before do
+          stub_request(:post, 'http://example.api/entries').to_timeout
+        end
+
+        it 'logs the failure to the failsafe logger' do
+          error = StandardError.new
+
+          Raygun.track_exception(error)
+
+          # Occasionally doesn't write to the failsafe logger, add small timeout to add some safety
+          sleep 0.1
+          expect(failsafe_logger.get).to match /Problem reporting exception to Raygun/
+        end
+      end
+    end
+  end
+
+  describe '#reset_configuration' do
+    subject { Raygun.reset_configuration }
+    it 'clears any customized configuration options' do
+      Raygun.setup do |c|
+        c.api_url = 'http://test.api'
+      end
+
+      expect { subject }.to change { Raygun.configuration.api_url }.from('http://test.api').to(Raygun.default_configuration.api_url)
+    end
+  end
+end

data/spec/services/apply_whitelist_filter_to_payload_spec.rb

@@ -1,251 +1,251 @@
-require "spec_helper"
-
-module Raygun
-  module Services
-    describe ApplyWhitelistFilterToPayload do
-      let(:service) { ApplyWhitelistFilterToPayload.new }
-
-      describe "top level keys" do
-        let(:payload) do
-          { foo: 1, bar: 2 }
-        end
-        let(:expected) do
-          { foo: 1 , bar: '[FILTERED]'}
-        end
-
-        it "filters out keys that are not present in the shape" do
-          shape = {
-            foo: true
-          }
-
-          new_payload = service.call(shape, payload)
-
-          expect(new_payload).to eq(expected)
-        end
-
-        it "filters out keys that are set to false" do
-          shape = {
-            foo: true,
-            bar: false
-          }
-
-          new_payload = service.call(shape, payload)
-
-          expect(new_payload).to eq(expected)
-        end
-      end
-
-      describe "nested hashes" do
-        let(:payload) {{
-          foo: 1,
-          bar: {
-            baz: 2,
-            qux: 3
-          }
-        }}
-        let(:expected) {{
-          foo: 1,
-          bar: {
-            baz: 2,
-            qux: '[FILTERED]'
-          }
-        }}
-
-        it "filters out keys in nested hashes" do
-          shape = {
-            foo: true,
-            bar: {
-              baz: true
-            }
-          }
-
-          new_payload = service.call(shape, payload)
-
-          expect(new_payload).to eq(expected)
-        end
-
-        it "filters out a nested hash if the whitelist does not contain it" do
-          shape = {
-            foo: true
-          }
-          expected[:bar] = "[FILTERED]"
-
-          new_payload = service.call(shape, payload)
-
-          expect(new_payload).to eq(expected)
-        end
-
-        it "handles nested hashes when the whitelist is set to allow the whole hash" do
-          shape = {
-            bar: true
-          }
-          expected = {
-            foo: '[FILTERED]',
-            bar: {
-              baz: 2,
-              qux: 3
-            }
-          }
-
-          new_payload = service.call(shape, payload)
-
-          expect(new_payload).to eq(expected)
-        end
-
-        it "handles nested hashes when the whitelist is set to not allow the whole hash" do
-          shape = {
-            foo: true,
-            bar: false
-          }
-          expected = {
-            foo: 1,
-            bar: '[FILTERED]'
-          }
-
-          new_payload = service.call(shape, payload)
-
-          expect(new_payload).to eq(expected)
-        end
-      end
-
-      describe "string keys" do
-        it "handles the case where a payload key is a string and a whitelist key is a symbol" do
-          shape = {
-            foo: true
-          }
-          payload = {
-            "foo" => 1,
-            "bar" => 2
-          }
-          expected = {
-            "foo" => 1,
-            "bar" => '[FILTERED]'
-          }
-
-          new_payload = service.call(shape, payload)
-
-          expect(new_payload).to eq(expected)
-        end
-      end
-
-      it "handles a very complex shape" do
-        shape = {
-          machineName: true,
-          version: true,
-          client: true,
-          error: {
-            className: true,
-            message: true,
-            stackTrace: true
-          },
-          userCustomData: true,
-          tags: true,
-          request: {
-            hostName: true,
-            url: true,
-            httpMethod: true,
-            iPAddress: true,
-            queryString: {
-              param1: true,
-              param2: true,
-            },
-            headers: {
-              "Host" => true,
-              "Connection" => true,
-              "Upgrade-Insecure_requests" => true,
-              "User-Agent" => false,
-              "Accept" => true,
-            },
-            form: {
-              controller: true,
-              action: false
-            },
-            rawData: {
-              controller: true,
-              action: false
-            }
-          },
-          user: false,
-        }
-        payload = {
-          machineName: "mindscapes-MacBook-Pro.local",
-          version: nil,
-          client: {name: "Raygun4Ruby Gem", version: "1.1.12", clientUrl: "https://github.com/MindscapeHQ/raygun4ruby"},
-          error: {className: "Exception", message: "foo", stackTrace: []},
-          userCustomData: {},
-          tags: ["development"],
-          request: {
-            hostName: "localhost",
-            url: "/make-me-an-error-charlie",
-            httpMethod: "GET",
-            iPAddress: "::1",
-            queryString: {
-              param1: "1",
-              param2: "2",
-              param3: "3",
-            },
-            headers: {
-              "Host"=>"localhost:3000",
-              "Connection"=>"keep-alive",
-              "Upgrade-Insecure_requests"=>"1",
-              "User-Agent"=> "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
-              "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
-              "Accept-Encoding"=>"gzip, deflate, sdch, br",
-              "Accept-Language"=>"en-US,en;q=0.8",
-              "Version"=>"HTTP/1.1"
-            },
-            form: {
-              controller: "home",
-              action: "raise_error"
-            },
-            rawData: {
-              controller: "home",
-              action: "raise_error"
-            }
-          }
-        }
-        expected = {
-          machineName: "mindscapes-MacBook-Pro.local",
-          version: nil,
-          client: {name: "Raygun4Ruby Gem", version: "1.1.12", clientUrl: "https://github.com/MindscapeHQ/raygun4ruby"},
-          error: {className: "Exception", message: "foo", stackTrace: []},
-          userCustomData: {},
-          tags: ["development"],
-          request: {
-            hostName: "localhost",
-            url: "/make-me-an-error-charlie",
-            httpMethod: "GET",
-            iPAddress: "::1",
-            queryString: {
-              param1: "1",
-              param2: "2",
-              param3: '[FILTERED]'
-            },
-            headers: {
-              "Host"=>"localhost:3000",
-              "Connection"=>"keep-alive",
-              "Upgrade-Insecure_requests"=>"1",
-              "User-Agent" => "[FILTERED]",
-              "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
-              "Accept-Encoding" => "[FILTERED]",
-              "Accept-Language" => "[FILTERED]",
-              "Version" => "[FILTERED]"
-            },
-            form: {
-              controller: "home",
-              action: "[FILTERED]"
-            },
-            rawData: {
-              controller: "home",
-              action: "[FILTERED]"
-            }
-          }
-        }
-
-        new_payload = service.call(shape, payload)
-
-        expect(new_payload).to eq(expected)
-      end
-    end
-  end
-end
+require "spec_helper"
+
+module Raygun
+  module Services
+    describe ApplyWhitelistFilterToPayload do
+      let(:service) { ApplyWhitelistFilterToPayload.new }
+
+      describe "top level keys" do
+        let(:payload) do
+          { foo: 1, bar: 2 }
+        end
+        let(:expected) do
+          { foo: 1 , bar: '[FILTERED]'}
+        end
+
+        it "filters out keys that are not present in the shape" do
+          shape = {
+            foo: true
+          }
+
+          new_payload = service.call(shape, payload)
+
+          expect(new_payload).to eq(expected)
+        end
+
+        it "filters out keys that are set to false" do
+          shape = {
+            foo: true,
+            bar: false
+          }
+
+          new_payload = service.call(shape, payload)
+
+          expect(new_payload).to eq(expected)
+        end
+      end
+
+      describe "nested hashes" do
+        let(:payload) {{
+          foo: 1,
+          bar: {
+            baz: 2,
+            qux: 3
+          }
+        }}
+        let(:expected) {{
+          foo: 1,
+          bar: {
+            baz: 2,
+            qux: '[FILTERED]'
+          }
+        }}
+
+        it "filters out keys in nested hashes" do
+          shape = {
+            foo: true,
+            bar: {
+              baz: true
+            }
+          }
+
+          new_payload = service.call(shape, payload)
+
+          expect(new_payload).to eq(expected)
+        end
+
+        it "filters out a nested hash if the whitelist does not contain it" do
+          shape = {
+            foo: true
+          }
+          expected[:bar] = "[FILTERED]"
+
+          new_payload = service.call(shape, payload)
+
+          expect(new_payload).to eq(expected)
+        end
+
+        it "handles nested hashes when the whitelist is set to allow the whole hash" do
+          shape = {
+            bar: true
+          }
+          expected = {
+            foo: '[FILTERED]',
+            bar: {
+              baz: 2,
+              qux: 3
+            }
+          }
+
+          new_payload = service.call(shape, payload)
+
+          expect(new_payload).to eq(expected)
+        end
+
+        it "handles nested hashes when the whitelist is set to not allow the whole hash" do
+          shape = {
+            foo: true,
+            bar: false
+          }
+          expected = {
+            foo: 1,
+            bar: '[FILTERED]'
+          }
+
+          new_payload = service.call(shape, payload)
+
+          expect(new_payload).to eq(expected)
+        end
+      end
+
+      describe "string keys" do
+        it "handles the case where a payload key is a string and a whitelist key is a symbol" do
+          shape = {
+            foo: true
+          }
+          payload = {
+            "foo" => 1,
+            "bar" => 2
+          }
+          expected = {
+            "foo" => 1,
+            "bar" => '[FILTERED]'
+          }
+
+          new_payload = service.call(shape, payload)
+
+          expect(new_payload).to eq(expected)
+        end
+      end
+
+      it "handles a very complex shape" do
+        shape = {
+          machineName: true,
+          version: true,
+          client: true,
+          error: {
+            className: true,
+            message: true,
+            stackTrace: true
+          },
+          userCustomData: true,
+          tags: true,
+          request: {
+            hostName: true,
+            url: true,
+            httpMethod: true,
+            iPAddress: true,
+            queryString: {
+              param1: true,
+              param2: true,
+            },
+            headers: {
+              "Host" => true,
+              "Connection" => true,
+              "Upgrade-Insecure_requests" => true,
+              "User-Agent" => false,
+              "Accept" => true,
+            },
+            form: {
+              controller: true,
+              action: false
+            },
+            rawData: {
+              controller: true,
+              action: false
+            }
+          },
+          user: false,
+        }
+        payload = {
+          machineName: "mindscapes-MacBook-Pro.local",
+          version: nil,
+          client: {name: "Raygun4Ruby Gem", version: "1.1.12", clientUrl: "https://github.com/MindscapeHQ/raygun4ruby"},
+          error: {className: "Exception", message: "foo", stackTrace: []},
+          userCustomData: {},
+          tags: ["development"],
+          request: {
+            hostName: "localhost",
+            url: "/make-me-an-error-charlie",
+            httpMethod: "GET",
+            iPAddress: "::1",
+            queryString: {
+              param1: "1",
+              param2: "2",
+              param3: "3",
+            },
+            headers: {
+              "Host"=>"localhost:3000",
+              "Connection"=>"keep-alive",
+              "Upgrade-Insecure_requests"=>"1",
+              "User-Agent"=> "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
+              "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+              "Accept-Encoding"=>"gzip, deflate, sdch, br",
+              "Accept-Language"=>"en-US,en;q=0.8",
+              "Version"=>"HTTP/1.1"
+            },
+            form: {
+              controller: "home",
+              action: "raise_error"
+            },
+            rawData: {
+              controller: "home",
+              action: "raise_error"
+            }
+          }
+        }
+        expected = {
+          machineName: "mindscapes-MacBook-Pro.local",
+          version: nil,
+          client: {name: "Raygun4Ruby Gem", version: "1.1.12", clientUrl: "https://github.com/MindscapeHQ/raygun4ruby"},
+          error: {className: "Exception", message: "foo", stackTrace: []},
+          userCustomData: {},
+          tags: ["development"],
+          request: {
+            hostName: "localhost",
+            url: "/make-me-an-error-charlie",
+            httpMethod: "GET",
+            iPAddress: "::1",
+            queryString: {
+              param1: "1",
+              param2: "2",
+              param3: '[FILTERED]'
+            },
+            headers: {
+              "Host"=>"localhost:3000",
+              "Connection"=>"keep-alive",
+              "Upgrade-Insecure_requests"=>"1",
+              "User-Agent" => "[FILTERED]",
+              "Accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+              "Accept-Encoding" => "[FILTERED]",
+              "Accept-Language" => "[FILTERED]",
+              "Version" => "[FILTERED]"
+            },
+            form: {
+              controller: "home",
+              action: "[FILTERED]"
+            },
+            rawData: {
+              controller: "home",
+              action: "[FILTERED]"
+            }
+          }
+        }
+
+        new_payload = service.call(shape, payload)
+
+        expect(new_payload).to eq(expected)
+      end
+    end
+  end
+end