rails-flog 1.3.2 → 1.6.1

data/test/unit/sql_formattable_test.rb

@@ -1,8 +1,9 @@
-# coding: utf-8
-require "active_record"
-require "test_helper"
+# frozen_string_literal: true
 
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+require 'active_record'
+require 'test_helper'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
 
 ActiveRecord::Schema.define version: 0 do
   create_table :books, force: true do |t|
@@ -13,7 +14,7 @@ end
 
 class Book < ActiveRecord::Base; end
 
-class SqlFormattableTest < ActiveSupport::TestCase
+module SqlFormattableTestHelper
   def setup
     # default configuration
     Flog.configure do |config|
@@ -30,101 +31,189 @@ class SqlFormattableTest < ActiveSupport::TestCase
     ActiveRecord::Base.logger = @old_logger
   end
 
+  def configure(pairs)
+    Flog.configure do |config|
+      pairs.each do |key, value|
+        meth = "#{key}="
+        config.send(meth, value) if config.respond_to?(meth)
+      end
+    end
+  end
+
+  def prepare_for_query_cache
+    Book.cache do
+      Book.where(category: 'comics').to_a
+      Book.where(category: 'comics').to_a
+    end
+  end
+
+  def assert_logger(&block)
+    raise ActiveRecord::Base.logger.errors.first if ActiveRecord::Base.logger.errors.present?
+
+    block.call(ActiveRecord::Base.logger)
+  end
+
+  def assert_one_line_sql(sql)
+    assert sql.include?('SELECT')
+    assert sql.include?('FROM')
+    assert sql.include?('WHERE')
+  end
+end
+
+class SqlFormattableTest < ActiveSupport::TestCase
+  include SqlFormattableTestHelper
+
   def test_sql_is_formatted
-    Book.where(category: "comics").to_a
+    Book.where(category: 'comics').to_a
     assert_logger do |logger|
-      logs = logger.debugs.map { |log| log.gsub("\t", "    ") }
-      assert_equal %{    SELECT}                             , logs[1]
-      assert_equal %{        "books" . *}                    , logs[2]
-      assert_equal %{    FROM}                               , logs[3]
-      assert_equal %{        "books"}                        , logs[4]
-      assert_equal %{    WHERE}                              , logs[5]
-      assert_equal %{        "books" . "category" = 'comics'}, logs[6]
+      assert_equal %(\tSELECT)       , logger.debugs[1]
+      assert_equal %(\t\t"books" . *), logger.debugs[2]
+      assert_equal %(\tFROM)         , logger.debugs[3]
+      assert_equal %(\t\t"books")    , logger.debugs[4]
+      assert_equal %(\tWHERE)        , logger.debugs[5]
+      assert logger.debugs[6].start_with?(%(\t\t"books"."category" = ))
     end
   end
 
   def test_colorized_on_colorize_loggin_is_true
     ActiveSupport::LogSubscriber.colorize_logging = true
-    Book.where(category: "comics").to_a
+    Book.where(category: 'comics').to_a
     assert_logger do |logger|
-      assert /\e\[(\d+;)*\d+m/.match(logger.debugs.join())
+      assert match_color_seq(logger.debugs.join)
     end
   end
 
   def test_not_colorized_on_colorize_loggin_is_false
-    Book.where(category: "comics").to_a
+    Book.where(category: 'comics').to_a
     assert_logger do |logger|
-      assert_nil /\e\[(\d+;)*\d+m/.match(logger.debugs.join())
+      assert_nil match_color_seq(logger.debugs.join)
     end
   end
 
   def test_sql_is_not_formatted_when_enabled_is_false
-    Flog::Status.stubs(:enabled?).returns(false)
-    Book.where(category: "comics").to_a
-    assert_logger do |logger|
-      assert_one_line_sql logger.debugs.first
+    Flog::Status.stub(:enabled?, false) do
+      Book.where(category: 'comics').to_a
+      assert_logger do |logger|
+        assert_one_line_sql logger.debugs.first
+      end
     end
   end
 
   def test_sql_is_not_formatted_when_sql_formattable_is_false
-    Flog::Status.stubs(:sql_formattable?).returns(false)
-    Book.where(category: "comics").to_a
-    assert_logger do |logger|
-      assert_one_line_sql logger.debugs.first
+    Flog::Status.stub(:sql_formattable?, false) do
+      Book.where(category: 'comics').to_a
+      assert_logger do |logger|
+        assert_one_line_sql logger.debugs.first
+      end
     end
   end
 
   def test_sql_is_not_formatted_on_cached_query
-    Book.cache do
-      Book.where(category: "comics").to_a
-      Book.where(category: "comics").to_a
-    end
+    prepare_for_query_cache
     assert_logger do |logger|
-      logs = logger.debugs.map { |log| log.gsub("\t", "    ") }
-      logs.each do |log|
-        assert_one_line_sql log if log.include?("CACHE")
+      logger.debugs.each do |log|
+        assert_one_line_sql log if log.include?('CACHE')
       end
     end
   end
 
   def test_sql_is_formatted_on_cached_query_when_ignore_cached_query_configration_is_false
-    Flog.configure do |config|
-      config.ignore_cached_query = false
-    end
-    Book.cache do
-      Book.where(category: "comics").to_a
-      Book.where(category: "comics").to_a
+    configure(ignore_cached_query: false)
+    prepare_for_query_cache
+    assert_logger do |logger|
+      logger.debugs.each do |log|
+        assert_equal log.include?('SELECT'), false if log.include?('CACHE')
+      end
     end
+  end
+
+  def test_sql_is_not_formatted_on_cached_query_when_ignore_query_configuration_is_true
+    configure(ignore_cached_query: false, ignore_query: true)
+    prepare_for_query_cache
     assert_logger do |logger|
-      logs = logger.debugs.map { |log| log.gsub("\t", "    ") }
-      logs.each do |log|
-        assert_equal log.include?("SELECT"), false if log.include?("CACHE")
+      logger.debugs.each do |log|
+        assert_one_line_sql log if log.include?('CACHE')
       end
     end
   end
 
-  def test_sql_is_not_formatted_when_duration_is_under_threshold
-    Flog.configure do |config|
-      config.query_duration_threshold = 100.0
+  def test_sql_is_not_formatted_when_ignore_query_configuration_is_true
+    configure(ignore_query: true)
+    Book.where(category: 'comics').to_a
+    assert_logger do |logger|
+      assert_one_line_sql logger.debugs.first
     end
-    Book.where(category: "comics").to_a
+  end
+
+  def test_sql_is_not_formatted_when_duration_is_under_threshold
+    configure(query_duration_threshold: 100.0)
+    Book.where(category: 'comics').to_a
     assert_logger do |logger|
       assert_one_line_sql logger.debugs.first
     end
   end
 
-  private
-  def assert_logger(&block)
-    if ActiveRecord::Base.logger.errors.present?
-      fail ActiveRecord::Base.logger.errors.first
-    else
-      block.call(ActiveRecord::Base.logger)
+  def test_2space_indent
+    configure(sql_indent: '  ')
+    Book.where(category: 'comics').to_a
+    assert_logger do |logger|
+      assert_equal %(  SELECT)       , logger.debugs[1]
+      assert_equal %(    "books" . *), logger.debugs[2]
+      assert_equal %(  FROM)         , logger.debugs[3]
+      assert_equal %(    "books")    , logger.debugs[4]
+      assert_equal %(  WHERE)        , logger.debugs[5]
+      assert logger.debugs[6].start_with?(%(    "books"."category" = ))
     end
   end
+end
 
-  def assert_one_line_sql(sql)
-    assert sql.include?("SELECT")
-    assert sql.include?("FROM")
-    assert sql.include?("WHERE")
+class SqlFormattableInValuesTest < ActiveSupport::TestCase
+  include SqlFormattableTestHelper
+
+  def test_default_in_values_num
+    Book.where(id: (1..10).to_a).to_a
+    assert_logger do |logger|
+      assert_equal %(\tSELECT)               , logger.debugs[1]
+      assert_equal %(\t\t"books" . *)        , logger.debugs[2]
+      assert_equal %(\tFROM)                 , logger.debugs[3]
+      assert_equal %(\t\t"books")            , logger.debugs[4]
+      assert_equal %(\tWHERE)                , logger.debugs[5]
+      assert_equal %{\t\t"books"."id" IN (}, logger.debugs[6]
+      (8..16).each do |l|
+        assert_equal 1, logger.debugs[l].count(',')
+      end
+      assert logger.debugs[17].start_with?(%{\t\t)})
+    end
+  end
+
+  def test_in_values_num_set
+    configure(sql_in_values_num: 5)
+    Book.where(id: (1..10).to_a).to_a
+    assert_logger do |logger|
+      assert_equal %(\tSELECT)               , logger.debugs[1]
+      assert_equal %(\t\t"books" . *)        , logger.debugs[2]
+      assert_equal %(\tFROM)                 , logger.debugs[3]
+      assert_equal %(\t\t"books")            , logger.debugs[4]
+      assert_equal %(\tWHERE)                , logger.debugs[5]
+      assert_equal %{\t\t"books"."id" IN (}, logger.debugs[6]
+      assert_equal 4, logger.debugs[7].count(',')
+      assert_equal 5, logger.debugs[8].count(',')
+      assert logger.debugs[9].start_with?(%{\t\t)})
+    end
+  end
+
+  def test_oneline_in_values
+    configure(sql_in_values_num: Flog::ONELINE_IN_VALUES_NUM)
+    Book.where(id: (1..10).to_a).to_a
+    assert_logger do |logger|
+      assert_equal %(\tSELECT)               , logger.debugs[1]
+      assert_equal %(\t\t"books" . *)        , logger.debugs[2]
+      assert_equal %(\tFROM)                 , logger.debugs[3]
+      assert_equal %(\t\t"books")            , logger.debugs[4]
+      assert_equal %(\tWHERE)                , logger.debugs[5]
+      assert_equal %{\t\t"books"."id" IN (}, logger.debugs[6]
+      assert_equal 9, logger.debugs[7].count(',')
+      assert logger.debugs[8].start_with?(%{\t\t)})
+    end
   end
 end

data/test/unit/status_test.rb

@@ -1,10 +1,47 @@
-# coding: utf-8
-require "rails"
-require "test_helper"
+# frozen_string_literal: true
+
+require 'rails'
+require 'test_helper'
+
+module StatusTestHelper
+  def create_switch_file
+    create_file(@test_root.join('tmp', Flog::Status::SWITCH_FILE_NAME))
+  end
+
+  def delete_switch_file
+    delete_file(@test_root.join('tmp', Flog::Status::SWITCH_FILE_NAME))
+  end
+
+  def create_sql_switch_file
+    create_file(@test_root.join('tmp', Flog::Status::SQL_SWITCH_FILE_NAME))
+  end
+
+  def delete_sql_switch_file
+    delete_file(@test_root.join('tmp', Flog::Status::SQL_SWITCH_FILE_NAME))
+  end
+
+  def create_params_switch_file
+    create_file(@test_root.join('tmp', Flog::Status::PARAMS_SWITCH_FILE_NAME))
+  end
+
+  def delete_params_switch_file
+    delete_file(@test_root.join('tmp', Flog::Status::PARAMS_SWITCH_FILE_NAME))
+  end
+
+  def create_file(file_path)
+    File.open(file_path, 'w').close
+  end
+
+  def delete_file(file_path)
+    File.delete(file_path) if File.exist?(file_path)
+  end
+end
 
 class StatusTest < ActiveSupport::TestCase
+  include StatusTestHelper
+
   def setup
-    @test_root = Pathname.new(File.expand_path(File.dirname(__FILE__) + "../../"))
+    @test_root = Pathname.new(File.expand_path(File.dirname(__FILE__) + '../../'))
   end
 
   def teardown
@@ -19,117 +56,94 @@ class StatusTest < ActiveSupport::TestCase
   end
 
   def test_enabled_is_false_when_switch_file_exists
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    create_switch_file
-    assert_equal false, Flog::Status.enabled?
+    Rails.stub(:root, @test_root) do
+      create_switch_file
+      assert_equal false, Flog::Status.enabled?
+    end
   end
 
   def test_enabled_is_true_when_error_is_raised_in_process
-    Rails.expects(:root).returns(nil) # For raise NoMethodError
-    create_switch_file
-    assert Flog::Status.enabled?
+    Rails.stub(:root, nil) do # For raise NoMethodError
+      create_switch_file
+      assert Flog::Status.enabled?
+    end
   end
 
   def test_sql_formattable_is_true_when_enable_and_sql_switch_file_does_not_exist
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    delete_switch_file
-    delete_sql_switch_file
-    assert Flog::Status.sql_formattable?
+    Rails.stub(:root, @test_root) do
+      delete_switch_file
+      delete_sql_switch_file
+      assert Flog::Status.sql_formattable?
+    end
   end
 
   def test_sql_formattable_is_false_when_enable_and_sql_switch_file_exists
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    delete_switch_file
-    create_sql_switch_file
-    assert_equal false, Flog::Status.sql_formattable?
+    Rails.stub(:root, @test_root) do
+      delete_switch_file
+      create_sql_switch_file
+      assert_equal false, Flog::Status.sql_formattable?
+    end
   end
 
   def test_sql_formattable_is_false_when_disable_and_sql_switch_file_not_exist
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    create_switch_file
-    delete_sql_switch_file
-    assert_equal false, Flog::Status.sql_formattable?
+    Rails.stub(:root, @test_root) do
+      create_switch_file
+      delete_sql_switch_file
+      assert_equal false, Flog::Status.sql_formattable?
+    end
   end
 
   def test_sql_formattable_is_true_when_error_is_raised_in_process
-    Rails.expects(:root).at_most(2).returns(nil) # For raise NoMethodError
-    create_sql_switch_file
-    assert Flog::Status.sql_formattable?
+    Rails.stub(:root, nil) do # For raise NoMethodError
+      create_sql_switch_file
+      assert Flog::Status.sql_formattable?
+    end
   end
 
   def test_sql_formattable_is_false_when_disable_and_sql_switch_file_exists
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    create_switch_file
-    create_sql_switch_file
-    assert_equal false, Flog::Status.sql_formattable?
+    Rails.stub(:root, @test_root) do
+      create_switch_file
+      create_sql_switch_file
+      assert_equal false, Flog::Status.sql_formattable?
+    end
   end
 
   def test_params_formattable_is_true_when_enable_and_params_switch_file_does_not_exist
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    delete_switch_file
-    delete_params_switch_file
-    assert Flog::Status.params_formattable?
+    Rails.stub(:root, @test_root) do
+      delete_switch_file
+      delete_params_switch_file
+      assert Flog::Status.params_formattable?
+    end
   end
 
   def test_params_formattable_is_false_when_enable_and_params_switch_file_exists
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    delete_switch_file
-    create_params_switch_file
-    assert_equal false, Flog::Status.params_formattable?
+    Rails.stub(:root, @test_root) do
+      delete_switch_file
+      create_params_switch_file
+      assert_equal false, Flog::Status.params_formattable?
+    end
   end
 
   def test_params_formattable_is_false_when_disable_and_params_switch_file_not_exist
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    create_switch_file
-    delete_params_switch_file
-    assert_equal false, Flog::Status.params_formattable?
+    Rails.stub(:root, @test_root) do
+      create_switch_file
+      delete_params_switch_file
+      assert_equal false, Flog::Status.params_formattable?
+    end
   end
 
   def test_params_formattable_is_false_when_disable_and_params_switch_file_exists
-    Rails.expects(:root).at_most(2).returns(@test_root)
-    create_switch_file
-    create_params_switch_file
-    assert_equal false, Flog::Status.params_formattable?
+    Rails.stub(:root, @test_root) do
+      create_switch_file
+      create_params_switch_file
+      assert_equal false, Flog::Status.params_formattable?
+    end
   end
 
   def test_params_formattable_is_true_when_error_is_raised_in_process
-    Rails.expects(:root).at_most(2).returns(nil) # For raise NoMethodError
-    create_params_switch_file
-    assert Flog::Status.params_formattable?
-  end
-
-  private
-  def create_switch_file
-    create_file(@test_root.join("tmp", Flog::Status::SWITCH_FILE_NAME))
-  end
-
-  def delete_switch_file
-    delete_file(@test_root.join("tmp", Flog::Status::SWITCH_FILE_NAME))
-  end
-
-  def create_sql_switch_file
-    create_file(@test_root.join("tmp", Flog::Status::SQL_SWITCH_FILE_NAME))
-  end
-
-  def delete_sql_switch_file
-    delete_file(@test_root.join("tmp", Flog::Status::SQL_SWITCH_FILE_NAME))
-  end
-
-  def create_params_switch_file
-    create_file(@test_root.join("tmp", Flog::Status::PARAMS_SWITCH_FILE_NAME))
-  end
-
-  def delete_params_switch_file
-    delete_file(@test_root.join("tmp", Flog::Status::PARAMS_SWITCH_FILE_NAME))
-  end
-
-  def create_file(file_path)
-    File.open(file_path, "w").close
-  end
-
-  def delete_file(file_path)
-    if File.exist?(file_path)
-      File.delete(file_path)
+    Rails.stub(:root, nil) do # For raise NoMethodError
+      create_params_switch_file
+      assert Flog::Status.params_formattable?
     end
   end
 end