[test] align Rails logger initializer specs

Author: kares

src/spec/ruby/jruby/rack/app_layout_spec.rb

@@ -218,7 +218,7 @@
   it_behaves_like "FileSystemLayout"
 
   it "sets app uri from a rails.root context param" do
-    base = File.join File.dirname(__FILE__), '../../rails3x'
+    base = File.join File.dirname(__FILE__), '../../rails'
     @rack_context.should_receive(:getInitParameter).with("rails.root").and_return base
     expect( layout.app_uri ).to eq base
     expect( layout.app_path ).to eq File.expand_path(base)

src/spec/ruby/jruby/rack/rails_booter_spec.rb

@@ -99,17 +99,10 @@
     rails_booter.public_path.should == "."
   end
 
-  it "uses JRuby-Rack's logger by default" do
-    booter.boot!
-    expect( booter.logger ).to_not be nil
-    expect( booter.logger ).to be JRuby::Rack.logger
-    booter.logger.info 'hello-there'
-  end
-
-  RAILS_ROOT_DIR = File.expand_path("../../../rails3x", __FILE__)
+  RAILS_ROOT_DIR = File.expand_path("../../../rails", __FILE__)
 
   # NOTE: specs currently only test with a stubbed Rails::Railtie
-  describe "Rails 3.x", :lib => :stub do
+  describe "Rails (stubbed)", :lib => :stub do
 
     before :all do
       $LOAD_PATH.unshift File.join(RAILS_ROOT_DIR, 'stub') # for require 'rails/railtie'
@@ -173,6 +166,21 @@
 
     describe "logger" do
 
+      before(:all) do
+        @active_support = defined? ::ActiveSupport
+        @tagged_logging = active_support && ActiveSupport::TaggedLogging rescue false
+      end
+
+      after(:all) do
+        if @tagged_logging == false
+          if @active_support
+            ActiveSupport.send :remove_const, :TaggedLogging
+          else
+            Object.send :remove_const, :ActiveSupport rescue nil
+          end
+        end
+      end
+
       before do
         @app = double "app"
         @app.stub(:config).and_return @config = double("config")
@@ -187,17 +195,17 @@ def logger=(logger); @logger = logger; end
         log_initializer[1].should == [{:before => :initialize_logger}]
       end
 
-      it "gets set as config.logger" do
+      it "gets set as config.logger (wrapped with tagged logging)" do
         logger = JRuby::Rack::Logger.new STDERR
         @config.stub(:log_level).and_return(:info)
         @config.stub(:log_formatter).and_return(nil)
 
         JRuby::Rack.should_receive(:logger).and_return(logger)
-        #logger.class.should_receive(:const_get).with('INFO').and_return(nil)
-        #logger.should_receive(:level=).with(nil)
 
         log_initializer.last.call(@app)
-        @app.config.logger.should be(logger)
+        rails_logger = @app.config.logger
+        # ActiveSupport::TaggedLogging.new clones the original logger instance
+        expect(rails_logger).to be_a(JRuby::Rack::Logger)
       end
 
       it "has a configurable log level" do
@@ -206,38 +214,10 @@ def logger; @logger; end
           def logger=(logger); @logger = logger; end
         end
         @config.stub(:log_formatter).and_return(nil)
-        @config.should_receive(:log_level).and_return(:debug)
+        @config.should_receive(:log_level).and_return(:error)
 
         log_initializer.last.call(@app) ##
-        @app.config.logger.level.should be(JRuby::Rack::Logger::DEBUG)
-      end
-
-      it "is wrapped in tagged logging" do # Rails 3.2
-        active_support = defined? ::ActiveSupport
-        tagged_logging = active_support && ActiveSupport::TaggedLogging rescue nil
-        begin
-          klass = Class.new do # TaggedLogging stub
-            def initialize(logger); @logger = logger end
-          end
-          module ::ActiveSupport; end
-          ::ActiveSupport.const_set(:TaggedLogging, klass)
-          @config.stub(:log_level).and_return(nil)
-          @config.stub(:log_formatter).and_return(nil)
-
-          log_initializer.last.call(@app)
-          @app.config.logger.should be_a(klass)
-          @app.config.logger.instance_variable_get(:@logger).should be_a(JRuby::Rack::Logger)
-        ensure
-          if tagged_logging.nil?
-            if active_support
-              ActiveSupport.send :remove_const, :TaggedLogging
-            else
-              Object.send :remove_const, :ActiveSupport rescue nil
-            end
-          else
-            ActiveSupport.const_set(:TaggedLogging, tagged_logging)
-          end
-        end
+        @app.config.logger.level.should be(JRuby::Rack::Logger::ERROR)
       end
 
       private

src/spec/ruby/rails3x/config/application.rb renamed to src/spec/ruby/rails/config/application.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# require "active_support/logger_silence"
+# require "active_support/logger_thread_safe_level"
+require "logger"
+
+module ActiveSupport
+  class Logger < ::Logger
+    # include LoggerSilence
+
+    # Returns true if the logger destination matches one of the sources
+    #
+    #   logger = Logger.new(STDOUT)
+    #   ActiveSupport::Logger.logger_outputs_to?(logger, STDOUT)
+    #   # => true
+    def self.logger_outputs_to?(logger, *sources)
+      logdev = logger.instance_variable_get(:@logdev)
+      logger_source = logdev.dev if logdev.respond_to?(:dev)
+      sources.any? { |source| source == logger_source }
+    end
+
+    # Broadcasts logs to multiple loggers.
+    def self.broadcast(logger) # :nodoc:
+      Module.new do
+        define_method(:add) do |*args, &block|
+          logger.add(*args, &block)
+          super(*args, &block)
+        end
+
+        define_method(:<<) do |x|
+          logger << x
+          super(x)
+        end
+
+        define_method(:close) do
+          logger.close
+          super()
+        end
+
+        define_method(:progname=) do |name|
+          logger.progname = name
+          super(name)
+        end
+
+        define_method(:formatter=) do |formatter|
+          logger.formatter = formatter
+          super(formatter)
+        end
+
+        define_method(:level=) do |level|
+          logger.level = level
+          super(level)
+        end
+
+        define_method(:local_level=) do |level|
+          logger.local_level = level if logger.respond_to?(:local_level=)
+          super(level) if respond_to?(:local_level=)
+        end
+
+        define_method(:silence) do |level = Logger::ERROR, &block|
+          if logger.respond_to?(:silence)
+            logger.silence(level) do
+              if defined?(super)
+                super(level, &block)
+              else
+                block.call(self)
+              end
+            end
+          else
+            if defined?(super)
+              super(level, &block)
+            else
+              block.call(self)
+            end
+          end
+        end
+      end
+    end
+
+    # Simple formatter which only displays the message.
+    class SimpleFormatter < ::Logger::Formatter
+      # This method is invoked when a log event occurs
+      def call(severity, timestamp, progname, msg)
+        "#{String === msg ? msg : msg.inspect}\n"
+      end
+    end
+  end
+end

src/spec/ruby/rails3x/config/boot.rb renamed to src/spec/ruby/rails/config/boot.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_support/logger"
+
+module ActiveSupport
+  # Wraps any standard Logger object to provide tagging capabilities.
+  #
+  # May be called with a block:
+  #
+  #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+  #   logger.tagged('BCX') { logger.info 'Stuff' }                            # Logs "[BCX] Stuff"
+  #   logger.tagged('BCX', "Jason") { logger.info 'Stuff' }                   # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } } # Logs "[BCX] [Jason] Stuff"
+  #
+  # If called without a block, a new logger will be returned with applied tags:
+  #
+  #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+  #   logger.tagged("BCX").info "Stuff"                 # Logs "[BCX] Stuff"
+  #   logger.tagged("BCX", "Jason").info "Stuff"        # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged("BCX").tagged("Jason").info "Stuff" # Logs "[BCX] [Jason] Stuff"
+  #
+  # This is used by the default Rails.logger as configured by Railties to make
+  # it easy to stamp log lines with subdomains, request ids, and anything else
+  # to aid debugging of multi-user production applications.
+  module TaggedLogging
+    module Formatter # :nodoc:
+      # This method is invoked when a log event occurs.
+      def call(severity, timestamp, progname, msg)
+        super(severity, timestamp, progname, "#{tags_text}#{msg}")
+      end
+    end
+
+    def self.new(logger)
+      logger = logger.clone
+
+      if logger.formatter
+        logger.formatter = logger.formatter.dup
+      else
+        # Ensure we set a default formatter so we aren't extending nil!
+        logger.formatter = ActiveSupport::Logger::SimpleFormatter.new
+      end
+
+      logger.formatter.extend Formatter
+      logger.extend(self)
+    end
+  end
+end