semantic_logger 2.15.0 → 2.16.0

data/test/debug_as_trace_logger_test.rb

@@ -2,89 +2,89 @@ require_relative 'test_helper'
 
 # Unit Test for SemanticLogger::Logger
 class DebugAsTraceLoggerTest < Minitest::Test
-  context SemanticLogger::Logger do
+  describe SemanticLogger::Logger do
     # Test each filter
-    [ nil, /\ADebugAsTraceLoggerTest/, Proc.new{|l| (/\AExclude/ =~ l.message).nil? } ].each do |filter|
-      context "filter: #{filter.class.name}" do
-        setup do
+    [nil, /\ADebugAsTraceLoggerTest/, Proc.new { |l| (/\AExclude/ =~ l.message).nil? }].each do |filter|
+      describe "filter: #{filter.class.name}" do
+        before do
           # Use a mock logger that just keeps the last logged entry in an instance
           # variable
           SemanticLogger.default_level = :trace
-          @mock_logger = MockLogger.new
-          appender = SemanticLogger.add_appender(@mock_logger)
-          appender.filter = filter
+          @mock_logger                 = MockLogger.new
+          appender                     = SemanticLogger.add_appender(@mock_logger)
+          appender.filter              = filter
 
           # Use this test's class name as the application name in the log output
-          @logger   = SemanticLogger::DebugAsTraceLogger.new(self.class)
-          @hash     = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
-          @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+          @logger                      = SemanticLogger::DebugAsTraceLogger.new(DebugAsTraceLoggerTest)
+          @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
+          @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
           assert_equal [], @logger.tags
         end
 
-        teardown do
+        after do
           # Remove all appenders
-          SemanticLogger.appenders.each{|appender| SemanticLogger.remove_appender(appender)}
+          SemanticLogger.appenders.each { |appender| SemanticLogger.remove_appender(appender) }
         end
 
-        context '.level?' do
-          should 'return true for debug? with :trace level' do
+        describe '.level?' do
+          it 'return true for debug? with :trace level' do
             SemanticLogger.default_level = :trace
             assert_equal :trace, @logger.level
-            assert_equal true,   @logger.debug?
-            assert_equal true,   @logger.trace?
+            assert_equal true, @logger.debug?
+            assert_equal true, @logger.trace?
           end
 
-          should 'return false for debug? with global :debug level' do
+          it 'return false for debug? with global :debug level' do
             SemanticLogger.default_level = :debug
-            assert_equal :debug, @logger.level,  @logger.inspect
-            assert_equal false,  @logger.debug?, @logger.inspect
-            assert_equal false,  @logger.trace?, @logger.inspect
+            assert_equal :debug, @logger.level, @logger.inspect
+            assert_equal false, @logger.debug?, @logger.inspect
+            assert_equal false, @logger.trace?, @logger.inspect
           end
 
-          should 'return true for debug? with global :info level' do
+          it 'return true for debug? with global :info level' do
             SemanticLogger.default_level = :info
-            assert_equal :info, @logger.level,  @logger.inspect
-            assert_equal false,  @logger.debug?, @logger.inspect
-            assert_equal false,  @logger.trace?, @logger.inspect
+            assert_equal :info, @logger.level, @logger.inspect
+            assert_equal false, @logger.debug?, @logger.inspect
+            assert_equal false, @logger.trace?, @logger.inspect
           end
 
-          should 'return false for debug? with instance :debug level' do
+          it 'return false for debug? with instance :debug level' do
             @logger.level = :debug
-            assert_equal :debug, @logger.level,  @logger.inspect
-            assert_equal false,   @logger.debug?, @logger.inspect
-            assert_equal false,  @logger.trace?, @logger.inspect
+            assert_equal :debug, @logger.level, @logger.inspect
+            assert_equal false, @logger.debug?, @logger.inspect
+            assert_equal false, @logger.trace?, @logger.inspect
           end
 
-          should 'return true for debug? with instance :info level' do
+          it 'return true for debug? with instance :info level' do
             @logger.level = :info
-            assert_equal :info, @logger.level,  @logger.inspect
-            assert_equal false,  @logger.debug?, @logger.inspect
-            assert_equal false,  @logger.trace?, @logger.inspect
+            assert_equal :info, @logger.level, @logger.inspect
+            assert_equal false, @logger.debug?, @logger.inspect
+            assert_equal false, @logger.trace?, @logger.inspect
           end
         end
 
-        should 'not log trace when level is debug' do
+        it 'not log trace when level is debug' do
           @logger.level = :debug
           @logger.trace('hello world', @hash) { "Calculations" }
           SemanticLogger.flush
           assert_nil @mock_logger.message
         end
 
-        should 'not log debug when level is debug' do
+        it 'not log debug when level is debug' do
           @logger.level = :debug
           @logger.debug('hello world', @hash) { "Calculations" }
           SemanticLogger.flush
           assert_nil @mock_logger.message
         end
 
-        should 'map trace to debug' do
+        it 'map trace to debug' do
           @logger.level = :trace
           @logger.debug('hello world', @hash) { "Calculations" }
           SemanticLogger.flush
           assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] DebugAsTraceLoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
         end
 
-        should 'log trace as trace' do
+        it 'log trace as trace' do
           @logger.level = :trace
           @logger.trace('hello world', @hash) { "Calculations" }
           SemanticLogger.flush
@@ -94,4 +94,4 @@ class DebugAsTraceLoggerTest < Minitest::Test
     end
 
   end
-end
+end

data/test/loggable_test.rb

@@ -8,31 +8,31 @@ end
 # Unit Test for SemanticLogger::Appender::File
 #
 class AppenderFileTest < Minitest::Test
-  context SemanticLogger::Loggable do
-    setup do
-      @time = Time.new
-      @io = StringIO.new
-      @appender = SemanticLogger::Appender::File.new(@io)
+  describe SemanticLogger::Loggable do
+    before do
+      @time                        = Time.new
+      @io                          = StringIO.new
+      @appender                    = SemanticLogger::Appender::File.new(@io)
       SemanticLogger.default_level = :trace
       SemanticLogger.add_appender(@appender)
-      @hash = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
-      @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+      @hash        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
+      @hash_str    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
       @thread_name = Thread.current.name
     end
 
-    teardown do
+    after do
       SemanticLogger.remove_appender(@appender)
     end
 
-    context "for each log level" do
+    describe "for each log level" do
       # Ensure that any log level can be logged
       SemanticLogger::LEVELS.each do |level|
-        should "log #{level} information with class attribute" do
+        it "log #{level} information with class attribute" do
           TestAttribute.logger.send(level, "hello #{level}", @hash)
           SemanticLogger.flush
           assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}\] TestAttribute -- hello #{level} -- #{@hash_str}\n/, @io.string
         end
-        should "log #{level} information with instance attribute" do
+        it "log #{level} information with instance attribute" do
           TestAttribute.new.logger.send(level, "hello #{level}", @hash)
           SemanticLogger.flush
           assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}\] TestAttribute -- hello #{level} -- #{@hash_str}\n/, @io.string
@@ -41,4 +41,4 @@ class AppenderFileTest < Minitest::Test
     end
 
   end
-end
+end

data/test/logger_test.rb

@@ -2,48 +2,48 @@ require_relative 'test_helper'
 
 # Unit Test for SemanticLogger::Logger
 class LoggerTest < Minitest::Test
-  context SemanticLogger::Logger do
+  describe SemanticLogger::Logger do
     # Test each filter
-    [ nil, /\ALogger/, Proc.new{|l| (/\AExclude/ =~ l.message).nil? } ].each do |filter|
-      context "filter: #{filter.class.name}" do
-        setup do
+    [nil, /\ALogger/, Proc.new { |l| (/\AExclude/ =~ l.message).nil? }].each do |filter|
+      describe "filter: #{filter.class.name}" do
+        before do
           # Use a mock logger that just keeps the last logged entry in an instance
           # variable
           SemanticLogger.default_level = :trace
-          @mock_logger = MockLogger.new
-          appender = SemanticLogger.add_appender(@mock_logger)
-          appender.filter = filter
+          @mock_logger                 = MockLogger.new
+          appender                     = SemanticLogger.add_appender(@mock_logger)
+          appender.filter              = filter
 
           # Add mock metric subscriber
-          $last_metric = nil
+          $last_metric                 = nil
           SemanticLogger.on_metric do |log_struct|
             $last_metric = log_struct.dup
           end
 
           # Use this test's class name as the application name in the log output
-          @logger   = SemanticLogger[self.class]
-          @hash     = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
+          @logger   = SemanticLogger[LoggerTest]
+          @hash     = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
           @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
           assert_equal [], @logger.tags
         end
 
-        teardown do
+        after do
           # Remove all appenders
-          SemanticLogger.appenders.each{|appender| SemanticLogger.remove_appender(appender)}
+          SemanticLogger.appenders.each { |appender| SemanticLogger.remove_appender(appender) }
         end
 
         # Ensure that any log level can be logged
         SemanticLogger::LEVELS.each do |level|
           level_char = level.to_s.upcase[0]
 
-          context level do
-            should "log" do
+          describe level do
+            it "log" do
               @logger.send(level, 'hello world', @hash) { "Calculations" }
               SemanticLogger.flush
               assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
             end
 
-            should "exclude log messages using Proc filter" do
+            it "exclude log messages using Proc filter" do
               if filter.is_a?(Proc)
                 @logger.send(level, 'Exclude this log message', @hash) { "Calculations" }
                 SemanticLogger.flush
@@ -51,7 +51,7 @@ class LoggerTest < Minitest::Test
               end
             end
 
-            should "exclude log messages using RegExp filter" do
+            it "exclude log messages using RegExp filter" do
               if filter.is_a?(Regexp)
                 logger = SemanticLogger::Logger.new('NotLogger', :trace, filter)
                 logger.send(level, 'Ignore all log messages from this class', @hash) { "Calculations" }
@@ -63,8 +63,8 @@ class LoggerTest < Minitest::Test
           end
         end
 
-        context "tagged logging" do
-          should "add tags to log entries" do
+        describe "tagged logging" do
+          it "add tags to log entries" do
             @logger.tagged('12345', 'DJHSFK') do
               @logger.info('Hello world')
               SemanticLogger.flush
@@ -72,7 +72,7 @@ class LoggerTest < Minitest::Test
             end
           end
 
-          should "add embedded tags to log entries" do
+          it "add embedded tags to log entries" do
             @logger.tagged('First Level', 'tags') do
               @logger.tagged('Second Level') do
                 @logger.info('Hello world')
@@ -85,11 +85,11 @@ class LoggerTest < Minitest::Test
             end
           end
 
-          should "add payload to log entries" do
-            hash = {:tracking_number=>"123456", :even=>2, :more=>"data"}
+          it "add payload to log entries" do
+            hash     = {tracking_number: "123456", even: 2, more: "data"}
             hash_str = hash.inspect.sub("{", "\\{").sub("}", "\\}")
-            @logger.with_payload(:tracking_number => '123456') do
-              @logger.with_payload(:even => 2, :more => 'data') do
+            @logger.with_payload(tracking_number: '123456') do
+              @logger.with_payload(even: 2, more: 'data') do
                 @logger.info('Hello world')
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
@@ -98,10 +98,10 @@ class LoggerTest < Minitest::Test
           end
         end
 
-        context "Ruby Logger" do
+        describe "Ruby Logger" do
           # Ensure that any log level can be logged
           Logger::Severity.constants.each do |level|
-            should "log Ruby logger #{level} info" do
+            it "log Ruby logger #{level} info" do
               @logger.level = Logger::Severity.const_get(level)
               if level.to_s == 'UNKNOWN'
                 assert_equal Logger::Severity.const_get('ERROR')+1, @logger.send(:level_index)
@@ -112,37 +112,37 @@ class LoggerTest < Minitest::Test
           end
         end
 
-        context "benchmark" do
+        describe "benchmark" do
           # Ensure that any log level can be benchmarked and logged
           SemanticLogger::LEVELS.each do |level|
             level_char = level.to_s.upcase[0]
 
-            context 'direct method' do
-              should "log #{level} info" do
+            describe 'direct method' do
+              it "log #{level} info" do
                 assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world') { "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
               end
 
-              should "log #{level} info with payload" do
+              it "log #{level} info with payload" do
                 assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', payload: @hash) { "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
-              should "not log #{level} info when block is faster than :min_duration" do
-                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 500) { "result" } # Measure duration of the supplied block
+              it "not log #{level} info when block is faster than :min_duration" do
+                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', min_duration: 500) { "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_nil @mock_logger.message
               end
 
-              should "log #{level} info when block duration exceeds :min_duration" do
-                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+              it "log #{level} info when block duration exceeds :min_duration" do
+                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', min_duration: 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
-              should "log #{level} info with an exception" do
+              it "log #{level} info with an exception" do
                 assert_raises RuntimeError do
                   @logger.send("benchmark_#{level}", 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                 end
@@ -150,7 +150,7 @@ class LoggerTest < Minitest::Test
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
               end
 
-              should "change log #{level} info with an exception" do
+              it "change log #{level} info with an exception" do
                 assert_raises RuntimeError do
                   @logger.send("benchmark_#{level}", 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                 end
@@ -158,41 +158,41 @@ class LoggerTest < Minitest::Test
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
               end
 
-              should "log #{level} info with metric" do
+              it "log #{level} info with metric" do
                 metric_name = '/my/custom/metric'
-                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
+                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', metric: metric_name) { "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
                 assert metric_name, $last_metric.metric
               end
             end
 
-            context 'generic method' do
-              should "log #{level} info" do
+            describe 'generic method' do
+              it "log #{level} info" do
                 assert_equal "result", @logger.benchmark(level, 'hello world') { "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
               end
 
-              should "log #{level} info with payload" do
+              it "log #{level} info with payload" do
                 assert_equal "result", @logger.benchmark(level, 'hello world', payload: @hash) { "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
-              should "not log #{level} info when block is faster than :min_duration" do
-                assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 500) { "result" } # Measure duration of the supplied block
+              it "not log #{level} info when block is faster than :min_duration" do
+                assert_equal "result", @logger.benchmark(level, 'hello world', min_duration: 500) { "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_nil @mock_logger.message
               end
 
-              should "log #{level} info when block duration exceeds :min_duration" do
-                assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+              it "log #{level} info when block duration exceeds :min_duration" do
+                assert_equal "result", @logger.benchmark(level, 'hello world', min_duration: 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
-              should "log #{level} info with an exception" do
+              it "log #{level} info with an exception" do
                 assert_raises RuntimeError do
                   @logger.benchmark(level, 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                 end
@@ -200,9 +200,9 @@ class LoggerTest < Minitest::Test
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
               end
 
-              should "log #{level} info with metric" do
+              it "log #{level} info with metric" do
                 metric_name = '/my/custom/metric'
-                assert_equal "result", @logger.benchmark(level, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
+                assert_equal "result", @logger.benchmark(level, 'hello world', metric: metric_name) { "result" } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
                 assert metric_name, $last_metric.metric
@@ -210,13 +210,13 @@ class LoggerTest < Minitest::Test
             end
           end
 
-          should "log when the block performs a return" do
+          it "log when the block performs a return" do
             assert_equal "Good", function_with_return(@logger)
             SemanticLogger.flush
             assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
           end
 
-          should 'not log at a level below the silence level' do
+          it 'not log at a level below the silence level' do
             SemanticLogger.default_level = :info
             @logger.benchmark_info('hello world', silence: :error) do
               @logger.warn "don't log me"
@@ -225,9 +225,9 @@ class LoggerTest < Minitest::Test
             assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
           end
 
-          should 'log at a silence level below the default level' do
+          it 'log at a silence level below the default level' do
             SemanticLogger.default_level = :info
-            first_message = nil
+            first_message                = nil
             @logger.benchmark_info('hello world', silence: :trace) do
               @logger.debug('hello world', @hash) { "Calculations" }
               SemanticLogger.flush
@@ -240,12 +240,12 @@ class LoggerTest < Minitest::Test
           end
         end
 
-        context '.default_level' do
-          setup do
+        describe '.default_level' do
+          before do
             SemanticLogger.default_level = :debug
           end
 
-          should 'not log at a level below the global default' do
+          it 'not log at a level below the global default' do
             assert_equal :debug, SemanticLogger.default_level
             assert_equal :debug, @logger.level
             @logger.trace('hello world', @hash) { "Calculations" }
@@ -253,7 +253,7 @@ class LoggerTest < Minitest::Test
             assert_nil @mock_logger.message
           end
 
-          should 'log at the instance level' do
+          it 'log at the instance level' do
             assert_equal :debug, SemanticLogger.default_level
             @logger.level = :trace
             assert_equal :trace, @logger.level
@@ -262,7 +262,7 @@ class LoggerTest < Minitest::Test
             assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
           end
 
-          should 'not log at a level below the instance level' do
+          it 'not log at a level below the instance level' do
             assert_equal :debug, SemanticLogger.default_level
             @logger.level = :warn
             assert_equal :warn, @logger.level
@@ -272,12 +272,12 @@ class LoggerTest < Minitest::Test
           end
         end
 
-        context '.silence' do
-          setup do
+        describe '.silence' do
+          before do
             SemanticLogger.default_level = :info
           end
 
-          should 'not log at a level below the silence level' do
+          it 'not log at a level below the silence level' do
             assert_equal :info, SemanticLogger.default_level
             assert_equal :info, @logger.level
             @logger.silence do
@@ -290,7 +290,7 @@ class LoggerTest < Minitest::Test
             assert_nil @mock_logger.message
           end
 
-          should 'log at the instance level even with the silencer at a higher level' do
+          it 'log at the instance level even with the silencer at a higher level' do
             @logger.level = :trace
             assert_equal :trace, @logger.level
             @logger.silence do
@@ -300,7 +300,7 @@ class LoggerTest < Minitest::Test
             assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
           end
 
-          should 'log at a silence level below the default level' do
+          it 'log at a silence level below the default level' do
             assert_equal :info, SemanticLogger.default_level
             assert_equal :info, @logger.level
             @logger.silence(:debug) do
@@ -311,55 +311,54 @@ class LoggerTest < Minitest::Test
           end
         end
 
-        context '.level?' do
-          should 'return true for debug? with :trace level' do
+        describe '.level?' do
+          it 'return true for debug? with :trace level' do
             SemanticLogger.default_level = :trace
             assert_equal :trace, @logger.level
-            assert_equal true,   @logger.debug?
-            assert_equal true,   @logger.trace?
+            assert_equal true, @logger.debug?
+            assert_equal true, @logger.trace?
           end
 
-          should 'return false for debug? with global :debug level' do
+          it 'return false for debug? with global :debug level' do
             SemanticLogger.default_level = :debug
-            assert_equal :debug, @logger.level,  @logger.inspect
-            assert_equal true,   @logger.debug?, @logger.inspect
-            assert_equal false,  @logger.trace?, @logger.inspect
+            assert_equal :debug, @logger.level, @logger.inspect
+            assert_equal true, @logger.debug?, @logger.inspect
+            assert_equal false, @logger.trace?, @logger.inspect
           end
 
-          should 'return true for debug? with global :info level' do
+          it 'return true for debug? with global :info level' do
             SemanticLogger.default_level = :info
-            assert_equal :info, @logger.level,  @logger.inspect
-            assert_equal false,  @logger.debug?, @logger.inspect
-            assert_equal false,  @logger.trace?, @logger.inspect
+            assert_equal :info, @logger.level, @logger.inspect
+            assert_equal false, @logger.debug?, @logger.inspect
+            assert_equal false, @logger.trace?, @logger.inspect
           end
 
-          should 'return false for debug? with instance :debug level' do
+          it 'return false for debug? with instance :debug level' do
             @logger.level = :debug
-            assert_equal :debug, @logger.level,  @logger.inspect
-            assert_equal true,   @logger.debug?, @logger.inspect
-            assert_equal false,  @logger.trace?, @logger.inspect
+            assert_equal :debug, @logger.level, @logger.inspect
+            assert_equal true, @logger.debug?, @logger.inspect
+            assert_equal false, @logger.trace?, @logger.inspect
           end
 
-          should 'return true for debug? with instance :info level' do
+          it 'return true for debug? with instance :info level' do
             @logger.level = :info
-            assert_equal :info, @logger.level,  @logger.inspect
-            assert_equal false,  @logger.debug?, @logger.inspect
-            assert_equal false,  @logger.trace?, @logger.inspect
+            assert_equal :info, @logger.level, @logger.inspect
+            assert_equal false, @logger.debug?, @logger.inspect
+            assert_equal false, @logger.trace?, @logger.inspect
           end
         end
 
       end
     end
 
-  end
-
-  # Make sure that benchmark still logs when a block uses return to return from
-  # a function
-  def function_with_return(logger)
-    logger.benchmark_info('hello world', payload: @hash) do
-      return "Good"
+    # Make sure that benchmark still logs when a block uses return to return from
+    # a function
+    def function_with_return(logger)
+      logger.benchmark_info('hello world', payload: @hash) do
+        return "Good"
+      end
+      "Bad"
     end
-    "Bad"
-  end
 
-end
+  end
+end