raygun4ruby 3.2.6 → 4.0.1

data/spec/raygun/breadcrumbs/breadcrumb_spec.rb

@@ -1,171 +1,171 @@
-require "spec_helper"
-
-module Raygun
-  module Breadcrumbs
-    describe Breadcrumb do
-      let(:subject) { Breadcrumb.new }
-      context 'fields' do
-        it 'has a message' do
-          message = 'foo'
-
-          subject.message = message
-
-          expect(subject.message).to eq(message)
-        end
-
-        it 'has a category' do
-          category = 'foo'
-
-          subject.category = category
-
-          expect(subject.category).to eq(category)
-        end
-
-        it 'has a level' do
-          level = 'foo'
-
-          subject.level = level
-
-          expect(subject.level).to eq(level)
-        end
-
-        it 'has a timestamp' do
-          timestamp = Time.now
-
-          subject.timestamp = timestamp
-
-          expect(subject.timestamp).to eq(timestamp)
-        end
-
-        it 'has metadata' do
-          metadata = {foo: '1'}
-
-          subject.metadata = metadata
-
-          expect(subject.metadata).to eq(metadata)
-        end
-
-        it 'has a class_name' do
-          class_name = 'foo'
-
-          subject.class_name = class_name
-
-          expect(subject.class_name).to eq(class_name)
-        end
-
-        it 'has a method_name' do
-          method_name = 'foo'
-
-          subject.method_name = method_name
-
-          expect(subject.method_name).to eq(method_name)
-        end
-
-        it 'has a line_number' do
-          line_number = 17
-
-          subject.line_number = line_number
-
-          expect(subject.line_number).to eq(line_number)
-        end
-      end
-
-      describe "#build_payload" do
-        before do
-          Timecop.freeze
-          Store.initialize
-        end
-        after do
-          Timecop.return
-          Store.clear
-        end
-
-        let(:breadcrumb) do
-          Store.record(
-            message: "test",
-            category: "test",
-            level: :info,
-            class_name: "HomeController",
-            method_name: "index",
-            line_number: 17,
-            metadata: {
-              foo: 'bar'
-            }
-          )
-
-          Store.stored[0]
-        end
-        let(:payload) { breadcrumb.build_payload }
-
-        it "joins the class name, method name and line number together" do
-          expect(payload[:location]).to eq("HomeController:index:17")
-        end
-
-        it "does not include the method name and line number if the class name is missing" do
-          breadcrumb.class_name = nil
-
-          expect(payload.has_key?(:location)).to eq(false)
-        end
-
-        it "does not inlcude the line number if is it missing" do
-          breadcrumb.line_number = nil
-
-          expect(payload[:location]).to eq("HomeController:index")
-        end
-
-        it "does not include keys in payload with nil values" do
-          breadcrumb.metadata = nil
-          breadcrumb.category = nil
-
-          expect(payload.key?(:CustomData)).to eq(false)
-          expect(payload.key?(:category)).to eq(false)
-        end
-
-        it 'includes the rest of the fields' do
-          expect(payload[:message]).to eq('test')
-          expect(payload[:category]).to eq('test')
-          expect(payload[:level]).to eq(1)
-          expect(payload[:timestamp]).to_not eq(nil)
-          expect(payload[:CustomData]).to eq(foo: 'bar')
-        end
-      end
-
-      describe "#size" do
-        before do
-          Timecop.freeze
-          Store.initialize
-        end
-        after do
-          Timecop.return
-          Store.clear
-        end
-
-        let(:message) { "This is a breadcrumb message" }
-
-        let(:breadcrumb) do
-          Store.record(
-            message: message,
-            category: "test",
-            level: :info,
-            class_name: "HomeController",
-            method_name: "index",
-            line_number: 17,
-            metadata: {
-              foo: 'bar'
-            }
-          )
-
-          Store.stored[0]
-        end
-
-        let(:size) { breadcrumb.size }
-
-        it "returns the estimated size of the breadcrumb" do
-          # Can't check all the fields but message so assume a standard 100 length for all of them
-          # The message should be the bulk of large breadcrumbs anyway
-          expect(size).to eq(message.length + 100)
-        end
-      end
-    end
-  end
-end
+require "spec_helper"
+
+module Raygun
+  module Breadcrumbs
+    describe Breadcrumb do
+      let(:subject) { Breadcrumb.new }
+      context 'fields' do
+        it 'has a message' do
+          message = 'foo'
+
+          subject.message = message
+
+          expect(subject.message).to eq(message)
+        end
+
+        it 'has a category' do
+          category = 'foo'
+
+          subject.category = category
+
+          expect(subject.category).to eq(category)
+        end
+
+        it 'has a level' do
+          level = 'foo'
+
+          subject.level = level
+
+          expect(subject.level).to eq(level)
+        end
+
+        it 'has a timestamp' do
+          timestamp = Time.now
+
+          subject.timestamp = timestamp
+
+          expect(subject.timestamp).to eq(timestamp)
+        end
+
+        it 'has metadata' do
+          metadata = {foo: '1'}
+
+          subject.metadata = metadata
+
+          expect(subject.metadata).to eq(metadata)
+        end
+
+        it 'has a class_name' do
+          class_name = 'foo'
+
+          subject.class_name = class_name
+
+          expect(subject.class_name).to eq(class_name)
+        end
+
+        it 'has a method_name' do
+          method_name = 'foo'
+
+          subject.method_name = method_name
+
+          expect(subject.method_name).to eq(method_name)
+        end
+
+        it 'has a line_number' do
+          line_number = 17
+
+          subject.line_number = line_number
+
+          expect(subject.line_number).to eq(line_number)
+        end
+      end
+
+      describe "#build_payload" do
+        before do
+          Timecop.freeze
+          Store.initialize
+        end
+        after do
+          Timecop.return
+          Store.clear
+        end
+
+        let(:breadcrumb) do
+          Store.record(
+            message: "test",
+            category: "test",
+            level: :info,
+            class_name: "HomeController",
+            method_name: "index",
+            line_number: 17,
+            metadata: {
+              foo: 'bar'
+            }
+          )
+
+          Store.stored[0]
+        end
+        let(:payload) { breadcrumb.build_payload }
+
+        it "joins the class name, method name and line number together" do
+          expect(payload[:location]).to eq("HomeController:index:17")
+        end
+
+        it "does not include the method name and line number if the class name is missing" do
+          breadcrumb.class_name = nil
+
+          expect(payload.has_key?(:location)).to eq(false)
+        end
+
+        it "does not inlcude the line number if is it missing" do
+          breadcrumb.line_number = nil
+
+          expect(payload[:location]).to eq("HomeController:index")
+        end
+
+        it "does not include keys in payload with nil values" do
+          breadcrumb.metadata = nil
+          breadcrumb.category = nil
+
+          expect(payload.key?(:CustomData)).to eq(false)
+          expect(payload.key?(:category)).to eq(false)
+        end
+
+        it 'includes the rest of the fields' do
+          expect(payload[:message]).to eq('test')
+          expect(payload[:category]).to eq('test')
+          expect(payload[:level]).to eq(1)
+          expect(payload[:timestamp]).to_not eq(nil)
+          expect(payload[:CustomData]).to eq(foo: 'bar')
+        end
+      end
+
+      describe "#size" do
+        before do
+          Timecop.freeze
+          Store.initialize
+        end
+        after do
+          Timecop.return
+          Store.clear
+        end
+
+        let(:message) { "This is a breadcrumb message" }
+
+        let(:breadcrumb) do
+          Store.record(
+            message: message,
+            category: "test",
+            level: :info,
+            class_name: "HomeController",
+            method_name: "index",
+            line_number: 17,
+            metadata: {
+              foo: 'bar'
+            }
+          )
+
+          Store.stored[0]
+        end
+
+        let(:size) { breadcrumb.size }
+
+        it "returns the estimated size of the breadcrumb" do
+          # Can't check all the fields but message so assume a standard 100 length for all of them
+          # The message should be the bulk of large breadcrumbs anyway
+          expect(size).to eq(message.length + 100)
+        end
+      end
+    end
+  end
+end

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