paul_bunyan 1.0.0

data/spec/lib/paul_bunyan/railtie/log_subscriber_spec.rb

@@ -0,0 +1,304 @@
+require 'spec_helper'
+
+module PaulBunyan
+  RSpec.describe LogSubscriber do
+    let(:aggregator) { subject.send(:aggregator) }
+
+    def preserving_event_lists
+      original_events = LogSubscriber.action_controller_events.dup
+      LogSubscriber.action_controller_events.clear
+      yield
+    ensure
+      LogSubscriber.instance_variable_set(:@action_controller_events, original_events)
+    end
+
+    before do
+      RequestStore.clear!
+    end
+
+    describe '.action_controller_event(event_name)' do
+      around(:each) do |example|
+        preserving_event_lists do
+          example.run
+        end
+      end
+
+      it 'must store the event name' do
+        LogSubscriber.action_controller_event :foo
+        expect(LogSubscriber.action_controller_events).to include :foo
+      end
+
+      it 'must only add one copy of each event name' do
+        LogSubscriber.action_controller_event :foo
+        LogSubscriber.action_controller_event :foo
+        LogSubscriber.action_controller_event :bar
+        LogSubscriber.action_controller_event :bar
+        expect(LogSubscriber.action_controller_events).to contain_exactly :foo, :bar
+      end
+    end
+
+    describe '.event_patterns' do
+      it 'must return a set including all action_controller events in that namespace', aggregate_failures: true do
+        LogSubscriber.action_controller_events.each do |event|
+          expect(LogSubscriber.event_patterns).to include "#{event}.action_controller"
+        end
+      end
+    end
+
+    describe '.subscribe_to_events' do
+      around(:each) do |example|
+        preserving_event_lists do
+          example.run
+        end
+      end
+
+      it 'must add a subscripton for all action_controller events' do
+        LogSubscriber.action_controller_event :nx_event
+        LogSubscriber.subscribe_to_events
+        expect(subscriber_classes_for('nx_event.action_controller')).
+          to include LogSubscriber
+      end
+    end
+
+    describe '#process_action(event)' do
+      let(:event) {
+        ActiveSupport::Notifications::Event.new(
+          'process_action.action_controller',
+          Time.now,
+          Time.at(Time.now.to_f - 0.240),
+          SecureRandom.hex(5),
+          {
+            :controller=>"FoosController",
+            :action => "show",
+            :params => {"controller"=>"foos", "action"=>"show", "id" => "42", "foo" => "bar"},
+            :format => :html,
+            :method => "GET",
+            :path => "/foos/42",
+            :request_id => "dfa6f7b5-8400-4572-a2f7-80504ed9d09a",
+            :ip => '127.0.0.1',
+            :status => 200,
+            :view_runtime => 220.038,
+            :db_runtime => 10.177,
+          }.with_indifferent_access
+        )
+      }
+
+      before do
+        allow(::PaulBunyan.logger).to receive(:info)
+        subject.process_action(event)
+      end
+
+      it 'it must log the contents of the aggregator to the specified logger at the info level' do
+        expect(::PaulBunyan.logger).to have_received(:info)
+      end
+
+      it 'must set the method on the aggregator' do
+        expect(aggregator.method).to eq 'GET'
+      end
+
+      it 'must set the controller on the aggregator' do
+        expect(aggregator.controller).to eq 'FoosController'
+      end
+
+      it 'must set the action on the aggregator' do
+        expect(aggregator.action).to eq 'show'
+      end
+
+      it 'must set the format on the aggregator' do
+        expect(aggregator.format).to eq :html
+      end
+
+      it 'must set the path on the aggregator' do
+        expect(aggregator.path).to eq '/foos/42'
+      end
+
+      it 'must set the request_id on the aggregator' do
+        expect(aggregator.request_id).to eq "dfa6f7b5-8400-4572-a2f7-80504ed9d09a"
+      end
+
+      it 'must set the ip address on the aggregator' do
+        expect(aggregator.ip).to eq '127.0.0.1'
+      end
+
+      it 'must set the status on the aggregator' do
+        expect(aggregator.status).to eq 200
+      end
+
+      it 'must set the view_runtime value on the aggregator' do
+        expect(aggregator.view_runtime).to eq 220.038
+      end
+
+      it 'must set the db_runtime value on the aggregator' do
+        expect(aggregator.db_runtime).to eq 10.177
+      end
+
+      context 'extracting the params' do
+        it 'must not include the ActionController internal params from the hash' do
+          expect(aggregator.params).to_not include ActionController::LogSubscriber::INTERNAL_PARAMS
+        end
+
+        it 'must include params passed to the controller action' do
+          expect(aggregator.params).to include "id" => "42", "foo" => "bar"
+        end
+      end
+    end
+
+    describe '#halted_callback(event)' do
+      let(:event) {
+        ActiveSupport::Notifications::Event.new(
+          'halted_callback.action_controller',
+          Time.now,
+          Time.at(Time.now.to_f - 0.240),
+          SecureRandom.hex(5),
+          {filter: described_class}.with_indifferent_access
+        )
+      }
+
+      before do
+        subject.halted_callback(event)
+      end
+
+      it 'must set the halting_filter field on the request aggregator' do
+        expect(aggregator.halting_filter).to eq 'PaulBunyan::LogSubscriber'
+      end
+    end
+
+    describe '#send_file(event)' do
+      let(:event) {
+        ActiveSupport::Notifications::Event.new(
+          'send_file.action_controller',
+          Time.at(Time.now.to_f - 0.240),
+          Time.now,
+          SecureRandom.hex(5),
+          {path: '/path/to/a/file'}.with_indifferent_access
+        )
+      }
+      let(:file_data) { aggregator.sent_file }
+
+      before do
+        subject.send_file(event)
+      end
+
+      it "must set the path field on the request aggregator's sent_file object" do
+        expect(file_data.path).to eq '/path/to/a/file'
+      end
+
+      it "must set the transfer_time on the request aggregator's sent_file object" do
+        expect(file_data.transfer_time).to be_within(1).of(240)
+      end
+    end
+
+    describe '#redirect_to(event)' do
+      let(:event) {
+        ActiveSupport::Notifications::Event.new(
+          'redirect_to.action_controller',
+          Time.now,
+          Time.at(Time.now.to_f - 0.240),
+          SecureRandom.hex(5),
+          {location: 'https://example.com/another/resource'}.with_indifferent_access
+        )
+      }
+
+      before do
+        subject.redirect_to(event)
+      end
+
+      it 'must set the redirect_location field on the request aggregator' do
+        expect(aggregator.redirect_location).to eq 'https://example.com/another/resource'
+      end
+    end
+
+    describe '#send_data(event)' do
+      let(:event) {
+        ActiveSupport::Notifications::Event.new(
+          'send_data.action_controller',
+          Time.at(Time.now.to_f - 0.240),
+          Time.now,
+          SecureRandom.hex(5),
+          {filename: '/path/to/a/file'}.with_indifferent_access
+        )
+      }
+      let(:file_data) { aggregator.sent_data }
+
+      before do
+        subject.send_data(event)
+      end
+
+      it "must set the path field on the request aggregator's sent_file object" do
+        expect(file_data.path).to eq '/path/to/a/file'
+      end
+
+      it "must set the transfer_time on the request aggregator's sent_file object" do
+        expect(file_data.transfer_time).to be_within(1).of(240)
+      end
+    end
+
+    describe '#render_template(event)' do
+      let(:event) {
+        ActiveSupport::Notifications::Event.new(
+          'render_template.action_view',
+          Time.at(Time.now.to_f - 0.240),
+          Time.now,
+          SecureRandom.hex(5),
+          {
+            identifier: Rails.root.join('app', 'views', 'controller', 'index.html.erb'),
+            layout: Rails.root.join('app', 'views', 'application', 'application.html.erb'),
+          }.with_indifferent_access
+        )
+      }
+      let(:view_data) { aggregator.view }
+
+      before do
+        subject.render_template(event)
+      end
+
+      it 'must set the view attribute on the aggregator' do
+        expect(aggregator.view).to_not be_nil
+      end
+
+      it 'must capture the rendered template path' do
+        expect(view_data.path.to_s).to end_with('controller/index.html.erb')
+      end
+
+      it 'must capture the render run time' do
+        expect(view_data.runtime).to be_within(1).of(240)
+      end
+
+      it 'must capture the layout used' do
+        expect(view_data.layout.to_s).to end_with('application/application.html.erb')
+      end
+
+      it 'must remove the Rails root path from the rendered template path' do
+        expect(view_data.path.to_s).to_not start_with Rails.root.to_s
+      end
+
+      it 'must remove the default rails view path from the rendered template path' do
+        expect(view_data.path.to_s).to_not match /\A\/?app\/views\//
+      end
+    end
+
+    describe '#render_partial(event)' do
+      let(:event) {
+        ActiveSupport::Notifications::Event.new(
+          'render_partial.action_view',
+          Time.at(Time.now.to_f - 0.240),
+          Time.now,
+          SecureRandom.hex(5),
+          {
+            identifier: Rails.root.join('app', 'views', 'controller', '_form.html.erb'),
+          }.with_indifferent_access
+        )
+      }
+      let(:view_data) { aggregator.view }
+
+      before do
+        subject.render_partial(event)
+      end
+
+      it 'must add an object to the partials array on every call' do
+        subject.render_partial(event)
+        expect(aggregator.partials.size).to eq 2
+      end
+    end
+  end
+end

data/spec/lib/paul_bunyan/railtie_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module PaulBunyan
+  RSpec.describe Railtie do
+    describe '#unsubscribe_default_log_subscribers' do
+      before do
+        @action_controller_subscriber = ActiveSupport::LogSubscriber.subscribers.find{|s|
+          s.class == ActionController::LogSubscriber
+        }
+
+        Railtie.instance.unsubscribe_default_log_subscribers
+      end
+
+      after do
+        # replace any subscriptions we may have blown away so the next test
+        # can be assured of a clean slate
+        ActionController::LogSubscriber.attach_to(
+          :action_controller,
+          @action_controller_subscriber
+        )
+      end
+
+      it 'must remove the ActionController::LogSubscriber subscription to process_action' do
+        expect(subscriber_classes_for('process_action.action_controller')).
+          to_not include ActionController::LogSubscriber
+      end
+
+      it 'must leave the ActionController::LogSubscriber subscription to deep_munge.action_controller in place' do
+        # I don't expect that we'll ever care to unsubcribe the logger
+        # non-event so we'll use it as a check to ensure we don't
+        # clobber all of the listeners, only the ones we care about
+        expect(subscriber_classes_for('logger.action_controller')).
+          to include ActionController::LogSubscriber
+      end
+    end
+  end
+end

data/spec/lib/paul_bunyan_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+initial_default_formatter_type = PaulBunyan.default_formatter_type
+
+describe PaulBunyan do
+  shared_examples 'respecting the ::default_formatter_type' do
+    let(:logger) { double('logger') }
+
+    before do
+      allow(Logger).to receive(:new).and_return(logger)
+    end
+
+    it 'sets the default formatter to json, if set to :json' do
+      PaulBunyan.default_formatter_type = :json
+      expect(logger).to receive(:formatter=).with(instance_of(PaulBunyan::JSONFormatter))
+      default_formatter_type_call
+    end
+
+    it 'sets the default formatter to text, if set to :text' do
+      PaulBunyan.default_formatter_type = :text
+      expect(logger).to receive(:formatter=).with(instance_of(PaulBunyan::TextFormatter))
+      default_formatter_type_call
+    end
+
+    it 'does not modify the default formatter, if set to nil' do
+      PaulBunyan.default_formatter_type = nil
+      expect(logger).not_to receive(:formatter=)
+      default_formatter_type_call
+    end
+  end
+
+  before do
+    # reset the PaulBunyan module before each test
+    PaulBunyan.remove_instance_variable(:@logger) if PaulBunyan.instance_variable_defined?(:@logger)
+    PaulBunyan.default_formatter_type = initial_default_formatter_type
+  end
+
+  describe 'include' do
+    subject(:klass) { Class.new }
+    subject(:logging_klass) { Class.new { include PaulBunyan } }
+
+    it 'adds #logger to the host class' do
+      expect(klass.new).not_to respond_to(:logger)
+      expect(logging_klass.new).to respond_to(:logger)
+    end
+  end
+
+  describe '::logger' do
+    it 'instantiates a log relayer' do
+      expect(PaulBunyan.logger).to be_a(PaulBunyan::LogRelayer)
+    end
+
+    it 'maintains a single instance' do
+      logger = PaulBunyan.logger
+      expect(PaulBunyan.logger).to be(logger)
+    end
+
+    it 'adds a default STDOUT logger' do
+      expect(STDOUT).to receive(:write)
+      PaulBunyan.logger << 'msg'
+    end
+
+    def default_formatter_type_call
+      PaulBunyan.logger
+    end
+
+    it_behaves_like 'respecting the ::default_formatter_type'
+  end
+
+  describe '::create_logger' do
+    let(:device) { double('device') }
+    let(:logger) { double('logger') }
+
+    before do
+      allow(logger).to receive(:formatter=)
+    end
+
+    it 'creates a new logger and adds it to the log relayer' do
+      expect(Logger).to receive(:new).with(device, 12, 42).and_return(logger)
+      PaulBunyan.create_logger(device, 12, 42)
+    end
+
+    it 'returns the newly created logger' do
+      expect(Logger).to receive(:new).and_return(logger)
+      expect(PaulBunyan.create_logger(device)).to be(logger)
+    end
+
+    it 'allows the default formatter type to be overridden' do
+      PaulBunyan.default_formatter_type = :json
+      expect(Logger).to receive(:new).and_return(logger)
+      expect(logger).to receive(:formatter=).with(instance_of(PaulBunyan::TextFormatter))
+      PaulBunyan.create_logger(device, formatter_type: :text)
+    end
+
+    def default_formatter_type_call
+      PaulBunyan.create_logger(device)
+    end
+
+    it_behaves_like 'respecting the ::default_formatter_type'
+  end
+
+  describe '::add_logger' do
+    it 'adds the logger to the log relayer' do
+      logger = double('logger')
+      expect(PaulBunyan.logger).not_to be(nil)
+      PaulBunyan.add_logger(logger)
+      expect(PaulBunyan.logger.secondary_loggers).to include(logger)
+    end
+
+    it 'creates an empty log relayer, if not present' do
+      logger = double('logger')
+      PaulBunyan.add_logger(logger)
+      expect(PaulBunyan.logger.loggers).to eq([logger])
+    end
+
+    it 'does not recreate the log relayer, if already present' do
+      logger1 = double('logger1')
+      logger2 = double('logger2')
+      PaulBunyan.add_logger(logger1)
+      PaulBunyan.add_logger(logger2)
+      expect(PaulBunyan.logger.loggers).to include(logger1)
+      expect(PaulBunyan.logger.loggers).to include(logger2)
+    end
+
+    it 'returns the logger added' do
+      logger = double('logger')
+      expect(PaulBunyan.add_logger(logger)).to be(logger)
+    end
+  end
+
+  describe '::remove_logger' do
+    it 'removes the logger from the log relayer' do
+      expect(PaulBunyan.logger).to receive(:remove_logger).with(PaulBunyan.logger.primary_logger)
+      PaulBunyan.remove_logger(PaulBunyan.logger.primary_logger)
+    end
+  end
+end