statsd-instrument 2.4.0 → 2.5.0

data/test/rubocop/metaprogramming_positional_arguments_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop/metaprogramming_positional_arguments'
+
+module Rubocop
+  class MetaprogrammingPositionalArgumentsTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::MetaprogrammingPositionalArguments.new
+    end
+
+    def test_ok_with_two_arguments
+      assert_no_offenses("ClassName.statsd_count_if(:method, 'metric') { foo }")
+      assert_no_offenses("ClassName.statsd_measure :method, 'metric'")
+      assert_no_offenses(<<~RUBY)
+        class Foo
+          statsd_count :method, 'metric'
+        end
+      RUBY
+    end
+
+    def test_ok_with_keyword_arguments_and_blocks
+      assert_no_offenses("ClassName.statsd_measure :method, 'metric', foo: 'bar'")
+      assert_no_offenses("ClassName.statsd_count_success(:method, 'metric', **kwargs)")
+      assert_no_offenses("ClassName.statsd_measure(:method, 'metric', foo: 'bar', &block)")
+      assert_no_offenses(<<~RUBY)
+        class Foo
+          statsd_count_if(:method, 'metric', foo: 'bar', baz: 'quc') do |result|
+            result == 'ok'
+          end
+        end
+      RUBY
+    end
+
+    def test_offense_with_positional_arguments
+      assert_offense("ClassName.statsd_measure(:method, 'metric', 1)")
+      assert_offense("ClassName.statsd_measure(:method, 'metric', 1, ['tag'])")
+      assert_offense("ClassName.statsd_measure(:method, 'metric', 1, tag: 'value')")
+      assert_offense(<<~RUBY)
+        class Foo
+          extend StatsD::Instrument
+          statsd_measure(:method, 'metric', 1)
+        end
+      RUBY
+    end
+
+    def test_offense_with_splat
+      assert_offense("ClassName.statsd_measure(:method, 'metric', *options)")
+    end
+
+    def test_offense_with_constant_or_method_as_third_argument
+      assert_offense("ClassName.statsd_measure(:method, 'metric', SAMPLE_RATE_CONSTANT)")
+      assert_offense("ClassName.statsd_measure(:method, 'metric', method_returning_a_hash)")
+    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/metric_return_value'
+
+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/metric_value_keyword_argument'
+
+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/positional_arguments'
+
+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/splat_arguments'
+
+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_instrumentation_test.rb

@@ -2,74 +2,74 @@
 
 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)
-    block.call 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
@@ -110,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)
@@ -170,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)
@@ -227,37 +238,17 @@ 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
+  def test_statsd_measure_as_distribution
     ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', as_dist: true
 
     assert_statsd_distribution('ActiveMerchant.Gateway.ssl_post') do
@@ -304,20 +295,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