statsd-instrument 2.3.2 → 2.6.0

data/test/rubocop/metric_prefix_argument_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class MetricPrefixArgumentTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::MetricPrefixArgument.new
+    end
+
+    def test_ok_for_metric_method_without_prefix_argument
+      assert_no_offenses("StatsD.measure('foo', 123) {}")
+      assert_no_offenses("StatsD.increment('foo', 123, sample_rate: 3, no_prefix: true)")
+      assert_no_offenses("StatsD.gauge('foo', 123)")
+    end
+
+    def test_ok_for_metaprogramming_method_without_prefix_argument
+      assert_no_offenses("statsd_measure(:method, 'metric_name')")
+      assert_no_offenses("statsd_count(:method, 'metric_name', sample_rate: 1, no_pefix: true)")
+      assert_no_offenses("statsd_count_if(:method, 'metric_name', sample_rate: 1) {}")
+    end
+
+    def test_offense_when_using_as_dist_with_measure_metric_method
+      assert_offense("StatsD.measure('foo', 123, sample_rate: 1, prefix: 'pre', tags: ['bar'])")
+      assert_offense("StatsD.gauge('foo', 123, prefix: nil)")
+      assert_offense("StatsD.increment('foo', prefix: 'pre', &block)")
+      assert_offense("StatsD.set('foo', prefix: 'pre') { } ")
+    end
+
+    def test_offense_when_using_as_dist_with_measure_metaprogramming_method
+      assert_offense("statsd_measure(:method, 'foo', prefix: 'foo')")
+      assert_offense("statsd_count_if(:method, 'foo', prefix: nil) { } ")
+    end
+  end
+end

data/test/rubocop/metric_return_value_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class MetricReturnValueTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::MetricReturnValue.new
+    end
+
+    def test_ok_for_non_metric_method
+      assert_no_offenses('backend = StatsD.backend')
+    end
+
+    def test_ok_as_naked_statement
+      assert_no_offenses("StatsD.increment('foo')")
+      assert_no_offenses("StatsD.measure('foo') { foo }")
+    end
+
+    def test_ok_as_multiple_statement
+      assert_no_offenses <<~RUBY
+        StatsD.increment 'foo'
+        StatsD.increment 'bar'
+      RUBY
+    end
+
+    def test_ok_inside_block
+      assert_no_offenses <<~RUBY
+        block do
+          StatsD.measure
+        end
+      RUBY
+    end
+
+    def test_ok_when_passing_a_block_as_param
+      assert_no_offenses("block_result = StatsD.measure('foo', &block)")
+    end
+
+    def test_ok_when_passing_a_curly_braces_block
+      assert_no_offenses("block_result = StatsD.measure('foo') { measure_me }")
+    end
+
+    def test_ok_when_passing_do_end_block
+      assert_no_offenses <<~RUBY
+        block_result = StatsD.measure('foo') do
+          return_something_useful
+        end
+      RUBY
+    end
+
+    def test_offense_in_assignment
+      assert_offense("metric = StatsD.increment('foo')")
+    end
+
+    def test_offense_in_multi_assignment
+      assert_offense("foo, metric = bar, StatsD.increment('foo')")
+    end
+
+    def test_offense_in_hash
+      assert_offense("{ metric: StatsD.increment('foo') }")
+    end
+
+    def test_offense_in_method_call
+      assert_offense("process(StatsD.increment('foo'))")
+    end
+
+    def test_offense_when_returning
+      assert_offense("return StatsD.increment('foo')")
+    end
+
+    def test_offense_when_yielding
+      assert_offense("yield StatsD.increment('foo')")
+    end
+  end
+end

data/test/rubocop/metric_value_keyword_argument_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class MetricValueKeywordArgumentTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::MetricValueKeywordArgument.new
+    end
+
+    def test_ok_for_method_without_arguments
+      assert_no_offenses("StatsD.increment")
+    end
+
+    def test_ok_for_non_metric_method
+      assert_no_offenses("StatsD.backend('foo', value: 1)")
+    end
+
+    def test_ok_with_no_keywords
+      assert_no_offenses("StatsD.increment('foo', 1)")
+    end
+
+    def test_ok_with_no_matching_keyword
+      assert_no_offenses("StatsD.increment('foo', 1, tags: ['foo'])")
+      assert_no_offenses("StatsD.increment('foo', 1, tags: { value: 'bar' })")
+    end
+
+    def test_offense_with_value_keyword
+      assert_offense("StatsD.increment('foo', value: 1)")
+      assert_offense("StatsD.increment('foo', :value => 1)")
+      assert_offense("StatsD.increment('foo', 'value' => 1)")
+      assert_offense("StatsD.increment('foo', sample_rate: 0.1, value: 1, tags: ['foo'])")
+      assert_offense("StatsD.increment('foo', value: 1, &block)")
+    end
+  end
+end

data/test/rubocop/positional_arguments_test.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class PositionalArgumentsTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::PositionalArguments.new
+    end
+
+    def test_no_offenses
+      assert_no_offenses("StatsD.increment 'foo'")
+      assert_no_offenses("StatsD.gauge('foo', 2)")
+      assert_no_offenses("StatsD.increment('foo', 2, tags: ['foo:bar'])")
+      assert_no_offenses("StatsD.increment('foo', 2, sample_rate: 0.1, tags: { foo: 'bar' })")
+      assert_no_offenses("StatsD.increment('foo', 2) { foo }")
+      assert_no_offenses("StatsD.increment('foo', 2, &block)")
+      assert_no_offenses("StatsD.gauge('foo', 2, **kwargs)")
+    end
+
+    def test_no_offense_for_now_when_using_value_keyword_argumenr
+      assert_no_offenses("StatsD.increment 'foo', value: 3")
+      assert_no_offenses("StatsD.increment 'foo', value: 3, sample_rate: 0.5")
+      assert_no_offenses("StatsD.increment('foo', value: 3, tags: ['foo']) { foo }")
+    end
+
+    def test_offense_when_using_method_or_constant
+      assert_offense("StatsD.gauge('foo', 2, SAMPLE_RATE_CONSTANT)")
+      assert_offense("StatsD.gauge('foo', 2, method_ruturning_a_hash)")
+    end
+
+    def test_offense_when_using_local_variable
+      assert_offense("lambda { |x| StatsD.gauge('foo', 2, x) }")
+      assert_offense(<<~RUBY)
+        x = foo
+        StatsD.gauge('foo', 2, x)
+      RUBY
+    end
+
+    def test_offense_when_using_splat
+      assert_offense("StatsD.gauge('foo', 2, *options)")
+    end
+
+    def test_no_autocorrect_when_using_method_or_constant
+      assert_no_autocorrect("StatsD.gauge('foo', 2, SAMPLE_RATE_CONSTANT)")
+      assert_no_autocorrect("StatsD.gauge('foo', 2, method_ruturning_a_hash)")
+    end
+
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    end
+
+    def test_autocorrect_sample_rate_and_do_end_block
+      corrected = autocorrect_source(<<~RUBY)
+        StatsD.distribution 'foo', 124, 0.6, ['bar'] do
+          foo
+        end
+      RUBY
+      assert_equal <<~RUBY, corrected
+        StatsD.distribution 'foo', 124, sample_rate: 0.6, tags: ['bar'] do
+          foo
+        end
+      RUBY
+    end
+  end
+end

data/test/rubocop/splat_arguments_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class SplatArgumentsTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::SplatArguments.new
+    end
+
+    def test_no_offenses
+      assert_no_offenses("StatsD.increment 'foo'")
+      assert_no_offenses("StatsD.gauge('foo', 2, tags: 'foo')")
+      assert_no_offenses("StatsD.measure('foo', 2, **kwargs)")
+      assert_no_offenses("StatsD.measure('foo', 2, **kwargs) { }")
+    end
+
+    def test_offenses
+      assert_offense("StatsD.increment(*increment_arguments)")
+      assert_offense("StatsD.gauge('foo', 2, *options)")
+      assert_offense("StatsD.measure('foo', 2, *options, &block)")
+    end
+  end
+end

data/test/statsd_datagram_builder_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class StatsDDatagramBuilderTest < Minitest::Test
+  def setup
+    @datagram_builder = StatsD::Instrument::StatsDDatagramBuilder.new
+  end
+
+  def test_raises_on_unsupported_metrics
+    assert_raises(NotImplementedError) { @datagram_builder.h('fo:o', 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.d('fo:o', 10, nil, nil) }
+    assert_raises(NotImplementedError) { @datagram_builder.kv('fo:o', 10, nil, nil) }
+  end
+
+  def test_raises_when_using_tags
+    assert_raises(NotImplementedError) { @datagram_builder.c('fo:o', 10, nil, foo: 'bar') }
+    assert_raises(NotImplementedError) { StatsD::Instrument::StatsDDatagramBuilder.new(default_tags: ['foo']) }
+  end
+end

data/test/statsd_instrumentation_test.rb

@@ -1,73 +1,75 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-module ActiveMerchant; end
-class ActiveMerchant::Base
-  def ssl_post(arg)
-    if arg
-      'OK'
-    else
-      raise 'Not OK'
-    end
-  end
+class StatsDInstrumentationTest < Minitest::Test
+  module ActiveMerchant
+    class Base
+      extend StatsD::Instrument
 
-  def post_with_block(&block)
-    yield if block_given?
-  end
-end
+      def ssl_post(arg)
+        if arg
+          'OK'
+        else
+          raise 'Not OK'
+        end
+      end
 
-class ActiveMerchant::Gateway < ActiveMerchant::Base
-  def purchase(arg)
-    ssl_post(arg)
-    true
-  rescue
-    false
-  end
+      def post_with_block(&block)
+        block.call if block_given?
+      end
+    end
 
-  def self.sync
-    true
-  end
+    class Gateway < Base
+      def purchase(arg)
+        ssl_post(arg)
+        true
+      rescue
+        false
+      end
 
-  def self.singleton_class
-    class << self; self; end
-  end
-end
+      def self.sync
+        true
+      end
+    end
 
-class ActiveMerchant::UniqueGateway < ActiveMerchant::Base
-  def ssl_post(arg)
-    {:success => arg}
-  end
+    class UniqueGateway < Base
+      def ssl_post(arg)
+        { success: arg }
+      end
 
-  def purchase(arg)
-    ssl_post(arg)
+      def purchase(arg)
+        ssl_post(arg)
+      end
+    end
   end
-end
 
-class GatewaySubClass < ActiveMerchant::Gateway
-end
+  class GatewaySubClass < ActiveMerchant::Gateway
+    def metric_name
+      'subgateway'
+    end
+  end
 
-class InstrumentedClass
-  extend StatsD::Instrument
+  class InstrumentedClass
+    extend StatsD::Instrument
 
-  def public_and_instrumented
-  end
-  statsd_count :public_and_instrumented, 'InstrumentedClass.public_and_instrumented'
+    def public_and_instrumented
+    end
+    statsd_count :public_and_instrumented, 'InstrumentedClass.public_and_instrumented'
 
-  protected
+    protected
 
-  def protected_and_instrumented
-  end
-  statsd_count :protected_and_instrumented, 'InstrumentedClass.protected_and_instrumented'
+    def protected_and_instrumented
+    end
+    statsd_count :protected_and_instrumented, 'InstrumentedClass.protected_and_instrumented'
 
-  private
+    private
 
-  def private_and_instrumented
+    def private_and_instrumented
+    end
+    statsd_count :private_and_instrumented, 'InstrumentedClass.private_and_instrumented'
   end
-  statsd_count :private_and_instrumented, 'InstrumentedClass.private_and_instrumented'
-end
-
-ActiveMerchant::Base.extend StatsD::Instrument
 
-class StatsDInstrumentationTest < Minitest::Test
   include StatsD::Instrument::Assertions
 
   def test_statsd_count_if
@@ -87,7 +89,7 @@ class StatsDInstrumentationTest < Minitest::Test
     end
 
     assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
-      assert_equal 'true',  ActiveMerchant::Base.new.post_with_block { 'true' }
+      assert_equal 'true', ActiveMerchant::Base.new.post_with_block { 'true' }
       assert_equal 'false', ActiveMerchant::Base.new.post_with_block { 'false' }
     end
   ensure
@@ -108,7 +110,7 @@ class StatsDInstrumentationTest < Minitest::Test
   end
 
   def test_statsd_count_success
-    ActiveMerchant::Gateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway', 0.5
+    ActiveMerchant::Gateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway', sample_rate: 0.5
 
     assert_statsd_increment('ActiveMerchant.Gateway.success', sample_rate: 0.5, times: 1) do
       ActiveMerchant::Gateway.new.purchase(true)
@@ -168,11 +170,22 @@ class StatsDInstrumentationTest < Minitest::Test
   end
 
   def test_statsd_count_with_name_as_lambda
-    metric_namer = lambda { |object, args| object.class.to_s.downcase + ".insert." + args.first.to_s }
+    metric_namer = lambda { |object, args| "#{object.metric_name}.#{args.first}" }
     ActiveMerchant::Gateway.statsd_count(:ssl_post, metric_namer)
 
-    assert_statsd_increment('gatewaysubclass.insert.true') do
-      GatewaySubClass.new.purchase(true)
+    assert_statsd_increment('subgateway.foo') do
+      GatewaySubClass.new.purchase('foo')
+    end
+  ensure
+    ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, metric_namer)
+  end
+
+  def test_statsd_count_with_name_as_proc
+    metric_namer = proc { |object, args| "#{object.metric_name}.#{args.first}" }
+    ActiveMerchant::Gateway.statsd_count(:ssl_post, metric_namer)
+
+    assert_statsd_increment('subgateway.foo') do
+      GatewaySubClass.new.purchase('foo')
     end
   ensure
     ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, metric_namer)
@@ -225,47 +238,16 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::Base.statsd_remove_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
 
-  def test_statsd_measure_with_value
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', 1
-
-    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post') do
-      ActiveMerchant::UniqueGateway.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-  end
-
-  def test_statsd_measure_with_value_and_options
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', 1, sample_rate: 0.45
+  def test_statsd_measure_with_sample_rate
+    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.1
 
-    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.45) do
+    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.1) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
     ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
   end
 
-  def test_statsd_measure_with_value_and_distribution
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', 1, as_dist: true
-
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post') do
-      ActiveMerchant::UniqueGateway.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-  end
-
-  def test_statsd_measure_without_value_as_distribution
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', as_dist: true
-
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post') do
-      ActiveMerchant::UniqueGateway.new.purchase(true)
-    end
-  ensure
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
-  end
-
-
   def test_statsd_distribution
     ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
 
@@ -303,20 +285,20 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::Base.statsd_remove_distribution :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
 
-  def test_statsd_distribution_with_value
-    ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', 1
+  def test_statsd_distribution_with_tags
+    ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', tags: ['foo']
 
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post') do
+    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post', tags: ['foo']) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
     ActiveMerchant::UniqueGateway.statsd_remove_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
   end
 
-  def test_statsd_distribution_with_value_and_options
-    ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', 1, sample_rate: 0.45
+  def test_statsd_distribution_with_sample_rate
+    ActiveMerchant::UniqueGateway.statsd_distribution :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.1
 
-    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.45) do
+    assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.1) do
       ActiveMerchant::UniqueGateway.new.purchase(true)
     end
   ensure
@@ -345,6 +327,34 @@ class StatsDInstrumentationTest < Minitest::Test
     ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
   end
 
+  def test_statsd_respects_global_prefix_changes
+    StatsD.prefix = 'Foo'
+    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
+    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync'
+    StatsD.prefix = 'Quc'
+
+    statsd_calls = capture_statsd_calls { ActiveMerchant::Gateway.sync }
+    assert_equal 1, statsd_calls.length
+    assert_equal "Quc.ActiveMerchant.Gateway.sync", statsd_calls.first.name
+  ensure
+    StatsD.prefix = nil
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
+  end
+
+  def test_statsd_macro_can_disable_prefix
+    StatsD.prefix = 'Foo'
+    ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
+    ActiveMerchant::Gateway.singleton_class.statsd_count_success :sync, 'ActiveMerchant.Gateway.sync', no_prefix: true
+    StatsD.prefix = 'Quc'
+
+    statsd_calls = capture_statsd_calls { ActiveMerchant::Gateway.sync }
+    assert_equal 1, statsd_calls.length
+    assert_equal "ActiveMerchant.Gateway.sync.success", statsd_calls.first.name
+  ensure
+    StatsD.prefix = nil
+    ActiveMerchant::Gateway.singleton_class.statsd_remove_count_success :sync, 'ActiveMerchant.Gateway.sync'
+  end
+
   def test_statsd_doesnt_change_method_scope_of_public_method
     assert_scope InstrumentedClass, :public_and_instrumented, :public
 
@@ -412,10 +422,9 @@ class StatsDInstrumentationTest < Minitest::Test
   private
 
   def assert_scope(klass, method, expected_scope)
-    method_scope = case
-    when klass.private_method_defined?(method)
+    method_scope = if klass.private_method_defined?(method)
       :private
-    when klass.protected_method_defined?(method)
+    elsif klass.protected_method_defined?(method)
       :protected
     else
       :public