statsd-instrument 3.0.0 → 3.0.1

data/test/datagram_test.rb

@@ -9,6 +9,6 @@ class DatagramTest < Minitest::Test
       'multi_currency:false,fulfillment_orders_beta_enabled:false'
 
     parsed = StatsD::Instrument::Datagram.new(datagram)
-    assert_includes parsed.tags, 'code_source:NilController#NilAction'
+    assert_includes(parsed.tags, 'code_source:NilController#NilAction')
   end
 end

data/test/dogstatsd_datagram_builder_test.rb

@@ -13,55 +13,55 @@ class DogStatsDDatagramBuilderTest < Minitest::Test
 
   def test_simple_service_check
     datagram = @datagram_builder._sc('service', :ok)
-    assert_equal '_sc|service|0', datagram
+    assert_equal('_sc|service|0', datagram)
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_sc, parsed_datagram.type
-    assert_equal 'service', parsed_datagram.name
-    assert_equal 0, parsed_datagram.value
+    assert_equal(:_sc, parsed_datagram.type)
+    assert_equal('service', parsed_datagram.name)
+    assert_equal(0, parsed_datagram.value)
   end
 
   def test_complex_service_check
     datagram = @datagram_builder._sc('service', :warning, timestamp: Time.parse('2019-09-30T04:22:12Z'),
       hostname: 'localhost', tags: { foo: 'bar|baz' }, message: 'blah')
-    assert_equal "_sc|service|1|h:localhost|d:1569817332|#foo:barbaz|m:blah", datagram
+    assert_equal("_sc|service|1|h:localhost|d:1569817332|#foo:barbaz|m:blah", datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_sc, parsed_datagram.type
-    assert_equal 'service', parsed_datagram.name
-    assert_equal 1, parsed_datagram.value
-    assert_equal 'localhost', parsed_datagram.hostname
-    assert_equal Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp
-    assert_equal ["foo:barbaz"], parsed_datagram.tags
-    assert_equal 'blah', parsed_datagram.message
+    assert_equal(:_sc, parsed_datagram.type)
+    assert_equal('service', parsed_datagram.name)
+    assert_equal(1, parsed_datagram.value)
+    assert_equal('localhost', parsed_datagram.hostname)
+    assert_equal(Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp)
+    assert_equal(["foo:barbaz"], parsed_datagram.tags)
+    assert_equal('blah', parsed_datagram.message)
   end
 
   def test_simple_event
     datagram = @datagram_builder._e('hello', "world")
-    assert_equal '_e{5,5}:hello|world', datagram
+    assert_equal('_e{5,5}:hello|world', datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_e, parsed_datagram.type
-    assert_equal 'hello', parsed_datagram.name
-    assert_equal 'world', parsed_datagram.value
+    assert_equal(:_e, parsed_datagram.type)
+    assert_equal('hello', parsed_datagram.name)
+    assert_equal('world', parsed_datagram.value)
   end
 
   def test_complex_event
     datagram = @datagram_builder._e("testing", "with\nnewline", timestamp: Time.parse('2019-09-30T04:22:12Z'),
       hostname: 'localhost', aggregation_key: 'my-key', priority: 'low', source_type_name: 'source',
       alert_type: 'success', tags: { foo: 'bar|baz' })
-    assert_equal '_e{7,13}:testing|with\\nnewline|h:localhost|d:1569817332|k:my-key|' \
-      'p:low|s:source|t:success|#foo:barbaz', datagram
+    assert_equal('_e{7,13}:testing|with\\nnewline|h:localhost|d:1569817332|k:my-key|' \
+      'p:low|s:source|t:success|#foo:barbaz', datagram)
 
     parsed_datagram = StatsD::Instrument::DogStatsDDatagramBuilder.datagram_class.new(datagram)
-    assert_equal :_e, parsed_datagram.type
-    assert_equal 'testing', parsed_datagram.name
-    assert_equal "with\nnewline", parsed_datagram.value
-    assert_equal 'localhost', parsed_datagram.hostname
-    assert_equal Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp
-    assert_equal ["foo:barbaz"], parsed_datagram.tags
-    assert_equal "my-key", parsed_datagram.aggregation_key
-    assert_equal "low", parsed_datagram.priority
-    assert_equal "source", parsed_datagram.source_type_name
-    assert_equal "success", parsed_datagram.alert_type
+    assert_equal(:_e, parsed_datagram.type)
+    assert_equal('testing', parsed_datagram.name)
+    assert_equal("with\nnewline", parsed_datagram.value)
+    assert_equal('localhost', parsed_datagram.hostname)
+    assert_equal(Time.parse('2019-09-30T04:22:12Z'), parsed_datagram.timestamp)
+    assert_equal(["foo:barbaz"], parsed_datagram.tags)
+    assert_equal("my-key", parsed_datagram.aggregation_key)
+    assert_equal("low", parsed_datagram.priority)
+    assert_equal("source", parsed_datagram.source_type_name)
+    assert_equal("success", parsed_datagram.alert_type)
   end
 end

data/test/environment_test.rb

@@ -11,48 +11,48 @@ class EnvironmentTest < Minitest::Test
       'RACK_ENV' => 'set_from_RACK_ENV',
       'ENV' => 'set_from_ENV',
     )
-    assert_equal 'set_from_STATSD_ENV', env.environment
+    assert_equal('set_from_STATSD_ENV', env.environment)
   end
 
   def test_environment_uses_env_when_rails_does_not_respond_to_env_and_statsd_env_is_not_set
     env = StatsD::Instrument::Environment.new(
       'ENV' => 'set_from_ENV',
     )
-    assert_equal 'set_from_ENV', env.environment
+    assert_equal('set_from_ENV', env.environment)
   end
 
   def test_environment_uses_rails_env_when_rails_is_available
     Rails.stubs(:env).returns('production')
-    assert_equal 'production', StatsD::Instrument::Environment.environment
+    assert_equal('production', StatsD::Instrument::Environment.environment)
   end
 
   def test_environment_defaults_to_development
     env = StatsD::Instrument::Environment.new({})
-    assert_equal 'development', env.environment
+    assert_equal('development', env.environment)
   end
 
   def test_client_returns_client_instance
     env = StatsD::Instrument::Environment.new({})
-    assert_kind_of StatsD::Instrument::Client, env.client
+    assert_kind_of(StatsD::Instrument::Client, env.client)
   end
 
   def test_client_from_env_uses_log_sink_in_development_environment
     env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'development')
-    assert_kind_of StatsD::Instrument::LogSink, env.client.sink
+    assert_kind_of(StatsD::Instrument::LogSink, env.client.sink)
   end
 
   def test_client_from_env_uses_null_sink_in_test_environment
     env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'test')
-    assert_kind_of StatsD::Instrument::NullSink, env.client.sink
+    assert_kind_of(StatsD::Instrument::NullSink, env.client.sink)
   end
 
   def test_client_from_env_uses_udp_sink_in_staging_environment
     env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'staging')
-    assert_kind_of StatsD::Instrument::UDPSink, env.client.sink
+    assert_kind_of(StatsD::Instrument::UDPSink, env.client.sink)
   end
 
   def test_client_from_env_uses_udp_sink_in_production_environment
     env = StatsD::Instrument::Environment.new('STATSD_USE_NEW_CLIENT' => '1', 'STATSD_ENV' => 'production')
-    assert_kind_of StatsD::Instrument::UDPSink, env.client.sink
+    assert_kind_of(StatsD::Instrument::UDPSink, env.client.sink)
   end
 end

data/test/helpers/rubocop_helper.rb

@@ -7,19 +7,22 @@ module RubocopHelper
 
   private
 
+  RUBY_VERSION = 2.5
+  private_constant :RUBY_VERSION
+
   def assert_no_offenses(source)
-    investigate(RuboCop::ProcessedSource.new(source, 2.3, nil))
-    assert_predicate cop.offenses, :empty?, "Did not expect Rubocop to find offenses"
+    investigate(RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil))
+    assert_predicate(cop.offenses, :empty?, "Did not expect Rubocop to find offenses")
   end
 
   def assert_offense(source)
-    investigate(RuboCop::ProcessedSource.new(source, 2.3, nil))
-    refute_predicate cop.offenses, :empty?, "Expected Rubocop to find offenses"
+    investigate(RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil))
+    refute_predicate(cop.offenses, :empty?, "Expected Rubocop to find offenses")
   end
 
   def assert_no_autocorrect(source)
     corrected = autocorrect_source(source)
-    assert_equal source, corrected
+    assert_equal(source, corrected)
   end
 
   def autocorrect_source(source)
@@ -27,7 +30,7 @@ module RubocopHelper
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
     cop.instance_variable_get(:@options)[:auto_correct] = true
 
-    processed_source = RuboCop::ProcessedSource.new(source, 2.3, nil)
+    processed_source = RuboCop::ProcessedSource.new(source, RUBY_VERSION, nil)
     investigate(processed_source)
 
     corrector = RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)

data/test/helpers_test.rb

@@ -17,10 +17,10 @@ class HelpersTest < Minitest::Test
     end
     StatsD.gauge('gauge', 15)
 
-    assert_equal 2, metrics.length
-    assert_equal 'counter', metrics[0].name
-    assert_equal 'gauge', metrics[1].name
-    assert_equal 12, metrics[1].value
+    assert_equal(2, metrics.length)
+    assert_equal('counter', metrics[0].name)
+    assert_equal('gauge', metrics[1].name)
+    assert_equal(12, metrics[1].value)
   end
 
   def test_capture_metrics_with_new_client
@@ -34,7 +34,7 @@ class HelpersTest < Minitest::Test
     end
     StatsD.gauge('gauge', 15)
 
-    assert_equal 2, metrics.length
+    assert_equal(2, metrics.length)
 
   ensure
     StatsD.singleton_client = @old_client

data/test/integration_test.rb

@@ -24,6 +24,6 @@ class IntegrationTest < Minitest::Test
 
   def test_live_local_udp_socket
     StatsD.increment('counter')
-    assert_equal "counter:1|c", @server.recvfrom(100).first
+    assert_equal("counter:1|c", @server.recvfrom(100).first)
   end
 end

data/test/log_sink_test.rb

@@ -12,7 +12,7 @@ class LogSinkTest < Minitest::Test
     log_sink = StatsD::Instrument::LogSink.new(logger)
     log_sink << 'foo:1|c' << 'bar:1|c'
 
-    assert_equal <<~LOG, log.string
+    assert_equal(<<~LOG, log.string)
       DEBUG: [StatsD] foo:1|c
       DEBUG: [StatsD] bar:1|c
     LOG
@@ -27,7 +27,7 @@ class LogSinkTest < Minitest::Test
     log_sink = StatsD::Instrument::LogSink.new(logger)
     log_sink << "foo:1|c\n" << "bar:1|c\n"
 
-    assert_equal <<~LOG, log.string
+    assert_equal(<<~LOG, log.string)
       DEBUG: [StatsD] foo:1|c
       DEBUG: [StatsD] bar:1|c
     LOG

data/test/matchers_test.rb

@@ -5,112 +5,112 @@ require 'statsd/instrument/matchers'
 
 class MatchersTest < Minitest::Test
   def test_statsd_increment_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
-      .matches?(lambda { StatsD.increment('counter') })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
+      .matches?(lambda { StatsD.increment('counter') }))
   end
 
   def test_statsd_increment_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
-      .matches?(lambda { StatsD.increment('not_counter') })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', {})
+      .matches?(lambda { StatsD.increment('not_counter') }))
   end
 
   def test_statsd_increment_compound_matched
     matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
     matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
 
-    assert RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches? lambda {
+    assert(RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches?(lambda {
       StatsD.increment('counter', tags: ['a'])
       StatsD.increment('counter', tags: ['b'])
-    }
+    }))
   end
 
   def test_statsd_increment_compound_not_matched
     matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
     matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
 
-    refute RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches? lambda {
+    refute(RSpec::Matchers::BuiltIn::Compound::And.new(matcher_1, matcher_2).matches?(lambda {
       StatsD.increment('counter', tags: ['a'])
       StatsD.increment('counter', tags: ['a'])
-    }
+    }))
   end
 
   def test_statsd_increment_with_times_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 1)
-      .matches?(lambda { StatsD.increment('counter') })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 1)
+      .matches?(lambda { StatsD.increment('counter') }))
   end
 
   def test_statsd_increment_with_times_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2)
-      .matches? lambda { 3.times { StatsD.increment('counter') } }
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2)
+      .matches?(lambda { 3.times { StatsD.increment('counter') } }))
   end
 
   def test_statsd_increment_with_sample_rate_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) }))
   end
 
   def test_statsd_increment_with_sample_rate_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: 0.5)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) }))
   end
 
   def test_statsd_increment_with_value_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1)
-      .matches?(lambda { StatsD.increment('counter') })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1)
+      .matches?(lambda { StatsD.increment('counter') }))
   end
 
   def test_statsd_increment_with_value_matched_when_multiple_metrics
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
       StatsD.increment('counter', 2)
       StatsD.increment('counter', 1)
-    })
+    }))
   end
 
   def test_statsd_increment_with_value_not_matched_when_multiple_metrics
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 1).matches?(lambda {
       StatsD.increment('counter', 2)
       StatsD.increment('counter', 3)
-    })
+    }))
   end
 
   def test_statsd_increment_with_value_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 3)
-      .matches?(lambda { StatsD.increment('counter') })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', value: 3)
+      .matches?(lambda { StatsD.increment('counter') }))
   end
 
   def test_statsd_increment_with_tags_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
-      .matches?(lambda { StatsD.increment('counter', tags: ['a', 'b']) })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
+      .matches?(lambda { StatsD.increment('counter', tags: ['a', 'b']) }))
   end
 
   def test_statsd_increment_with_tags_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
-      .matches?(lambda { StatsD.increment('counter', tags: ['c']) })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a', 'b'])
+      .matches?(lambda { StatsD.increment('counter', tags: ['c']) }))
   end
 
   def test_statsd_increment_with_times_and_value_matched
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
       StatsD.increment('counter', 1)
       StatsD.increment('counter', 1)
-    })
+    }))
   end
 
   def test_statsd_increment_with_times_and_value_not_matched
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', times: 2, value: 1).matches?(lambda {
       StatsD.increment('counter', 1)
       StatsD.increment('counter', 2)
-    })
+    }))
   end
 
   def test_statsd_increment_with_sample_rate_and_argument_matcher_matched
     between_matcher = RSpec::Matchers::BuiltIn::BeBetween.new(0.4, 0.6).inclusive
-    assert StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) })
+    assert(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.5) }))
   end
 
   def test_statsd_increment_with_sample_rate_and_argument_matcher_not_matched
     between_matcher = RSpec::Matchers::BuiltIn::BeBetween.new(0.4, 0.6).inclusive
-    refute StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
-      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) })
+    refute(StatsD::Instrument::Matchers::Increment.new(:c, 'counter', sample_rate: between_matcher)
+      .matches?(lambda { StatsD.increment('counter', sample_rate: 0.7) }))
   end
 end

data/test/null_sink_test.rb

@@ -11,7 +11,7 @@ class NullSinkTest < Minitest::Test
 
   def test_null_sink_sample
     null_sink = StatsD::Instrument::NullSink.new
-    assert null_sink.sample?(0), "The null sink should always sample"
-    assert null_sink.sample?(1), "The null sink should always sample"
+    assert(null_sink.sample?(0), "The null sink should always sample")
+    assert(null_sink.sample?(1), "The null sink should always sample")
   end
 end

data/test/rubocop/metric_return_value_test.rb

@@ -21,14 +21,14 @@ module Rubocop
     end
 
     def test_ok_as_multiple_statement
-      assert_no_offenses <<~RUBY
+      assert_no_offenses(<<~RUBY)
         StatsD.increment 'foo'
         StatsD.increment 'bar'
       RUBY
     end
 
     def test_ok_inside_block
-      assert_no_offenses <<~RUBY
+      assert_no_offenses(<<~RUBY)
         block do
           StatsD.measure
         end
@@ -44,7 +44,7 @@ module Rubocop
     end
 
     def test_ok_when_passing_do_end_block
-      assert_no_offenses <<~RUBY
+      assert_no_offenses(<<~RUBY)
         block_result = StatsD.measure('foo') do
           return_something_useful
         end

data/test/rubocop/positional_arguments_test.rb

@@ -51,47 +51,47 @@ module Rubocop
 
     def test_autocorrect_only_sample_rate
       corrected = autocorrect_source("StatsD.increment('foo', 2, 0.5)")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 0.5)", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 0.5)", corrected)
     end
 
     def test_autocorrect_only_sample_rate_as_int
       corrected = autocorrect_source("StatsD.increment('foo', 2, 1)")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 1)", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 1)", corrected)
     end
 
     def test_autocorrect_only_tags
       corrected = autocorrect_source("StatsD.increment('foo', 2, nil, ['foo', 'bar'])")
-      assert_equal "StatsD.increment('foo', 2, tags: ['foo', 'bar'])", corrected
+      assert_equal("StatsD.increment('foo', 2, tags: ['foo', 'bar'])", corrected)
     end
 
     def test_autocorrect_sample_rate_and_tags_as_array
       corrected = autocorrect_source("StatsD.increment('foo', 2, 0.5, ['foo', 'bar'])")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 0.5, tags: ['foo', 'bar'])", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 0.5, tags: ['foo', 'bar'])", corrected)
     end
 
     def test_autocorrect_sample_rate_and_tags_as_hash_with_curly_braces
       corrected = autocorrect_source("StatsD.increment('foo', 2, 0.5, { foo: 'bar' })")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 0.5, tags: { foo: 'bar' })", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 0.5, tags: { foo: 'bar' })", corrected)
     end
 
     def test_autocorrect_sample_rate_and_tags_as_hash_without_curly_braces
       corrected = autocorrect_source("StatsD.increment('foo', 2, 0.5, foo: 'bar')")
-      assert_equal "StatsD.increment('foo', 2, sample_rate: 0.5, tags: { foo: 'bar' })", corrected
+      assert_equal("StatsD.increment('foo', 2, sample_rate: 0.5, tags: { foo: 'bar' })", corrected)
     end
 
     def test_autocorrect_sample_rate_and_block_pass
       corrected = autocorrect_source("StatsD.distribution('foo', 2, 0.5, &block)")
-      assert_equal "StatsD.distribution('foo', 2, sample_rate: 0.5, &block)", corrected
+      assert_equal("StatsD.distribution('foo', 2, sample_rate: 0.5, &block)", corrected)
     end
 
     def test_autocorrect_sample_rate_tags_and_block_pass
       corrected = autocorrect_source("StatsD.measure('foo', 2, nil, foo: 'bar', &block)")
-      assert_equal "StatsD.measure('foo', 2, tags: { foo: 'bar' }, &block)", corrected
+      assert_equal("StatsD.measure('foo', 2, tags: { foo: 'bar' }, &block)", corrected)
     end
 
     def test_autocorrect_sample_rate_and_curly_braces_block
       corrected = autocorrect_source("StatsD.measure('foo', 2, 0.5) { foo }")
-      assert_equal "StatsD.measure('foo', 2, sample_rate: 0.5) { foo }", corrected
+      assert_equal("StatsD.measure('foo', 2, sample_rate: 0.5) { foo }", corrected)
     end
 
     def test_autocorrect_sample_rate_and_do_end_block
@@ -100,7 +100,7 @@ module Rubocop
           foo
         end
       RUBY
-      assert_equal <<~RUBY, corrected
+      assert_equal(<<~RUBY, corrected)
         StatsD.distribution 'foo', 124, sample_rate: 0.6, tags: ['bar'] do
           foo
         end