statsd-instrument 2.3.2 → 2.6.0

data/test/dogstatsd_datagram_builder_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class DogStatsDDatagramBuilderTest < Minitest::Test
+  def setup
+    @datagram_builder = StatsD::Instrument::DogStatsDDatagramBuilder.new
+  end
+
+  def test_raises_on_unsupported_metrics
+    assert_raises(NotImplementedError) { @datagram_builder.kv('foo', 10, nil, nil) }
+  end
+
+  def test_service_check
+    assert_equal '_sc|service|0', @datagram_builder._sc('service', :ok)
+    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
+  end
+
+  def test_event
+    assert_equal '_e{5,5}:hello|world', @datagram_builder._e('hello', "world")
+
+    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
+  end
+end

data/test/environment_test.rb

@@ -1,30 +1,31 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module Rails; end
 
 class EnvironmentTest < Minitest::Test
-
   def setup
     ENV['STATSD_ADDR'] = nil
     ENV['IMPLEMENTATION'] = nil
   end
 
-  def test_uses_logger_in_development_environment
+  def test_default_backend_uses_logger_in_development_environment
     StatsD::Instrument::Environment.stubs(:environment).returns('development')
     assert_instance_of StatsD::Instrument::Backends::LoggerBackend, StatsD::Instrument::Environment.default_backend
   end
 
-  def test_uses_null_backend_in_test_environment
+  def test_default_backend_uses_null_backend_in_test_environment
     StatsD::Instrument::Environment.stubs(:environment).returns('test')
     assert_instance_of StatsD::Instrument::Backends::NullBackend, StatsD::Instrument::Environment.default_backend
   end
 
-  def test_uses_udp_backend_in_production_environment
+  def test_default_backend_uses_udp_backend_in_production_environment
     StatsD::Instrument::Environment.stubs(:environment).returns('production')
     assert_instance_of StatsD::Instrument::Backends::UDPBackend, StatsD::Instrument::Environment.default_backend
   end
 
-  def test_uses_environment_variables_in_production_environment
+  def test_default_backend_uses_environment_variables_in_production_environment
     StatsD::Instrument::Environment.stubs(:environment).returns('production')
     ENV['STATSD_ADDR'] = '127.0.0.1:1234'
     ENV['STATSD_IMPLEMENTATION'] = 'datadog'
@@ -35,12 +36,78 @@ class EnvironmentTest < Minitest::Test
     assert_equal :datadog, backend.implementation
   end
 
-  def test_uses_env_when_rails_does_not_respond_to_env
-    assert_equal ENV['ENV'], StatsD::Instrument::Environment.environment
+  def test_environment_prefers_statsd_env_if_available
+    env = StatsD::Instrument::Environment.new(
+      'STATSD_ENV' => 'set_from_STATSD_ENV',
+      'RACK_ENV' => 'set_from_RACK_ENV',
+      'ENV' => 'set_from_ENV',
+    )
+    assert_equal 'set_from_STATSD_ENV', env.environment
   end
 
-  def test_uses_rails_env_when_rails_is_available
+  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
+  end
+
+  def test_environment_uses_rails_env_when_rails_is_available
     Rails.stubs(:env).returns('production')
     assert_equal 'production', StatsD::Instrument::Environment.environment
   end
+
+  def test_environment_defaults_to_development
+    env = StatsD::Instrument::Environment.new({})
+    assert_equal 'development', env.environment
+  end
+
+  def test_default_client_uses_log_sink_in_development_environment
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'development')
+    assert_kind_of StatsD::Instrument::LogSink, env.default_client.sink
+  end
+
+  def test_default_client_uses_null_sink_in_test_environment
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'test')
+    assert_kind_of StatsD::Instrument::NullSink, env.default_client.sink
+  end
+
+  def test_default_client_uses_udp_sink_in_staging_environment
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'staging')
+    assert_kind_of StatsD::Instrument::UDPSink, env.default_client.sink
+  end
+
+  def test_default_client_uses_udp_sink_in_production_environment
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'production')
+    assert_kind_of StatsD::Instrument::UDPSink, env.default_client.sink
+  end
+
+  def test_default_client_respects_statsd_environment_variables
+    env = StatsD::Instrument::Environment.new(
+      'STATSD_ENV' => 'production',
+      'STATSD_IMPLEMENTATION' => 'datadog',
+      'STATSD_ADDR' => 'foo:8125',
+      'STATSD_SAMPLE_RATE' => "0.1",
+      'STATSD_PREFIX' => "foo",
+      'STATSD_DEFAULT_TAGS' => "foo,bar:baz",
+    )
+
+    assert_equal StatsD::Instrument::DogStatsDDatagramBuilder, env.default_client.datagram_builder_class
+    assert_equal 'foo', env.default_client.sink.host
+    assert_equal 8125, env.default_client.sink.port
+    assert_equal 0.1, env.default_client.default_sample_rate
+    assert_equal "foo", env.default_client.prefix
+    assert_equal ["foo", "bar:baz"], env.default_client.default_tags
+  end
+
+  def test_default_client_has_sensible_defaults
+    env = StatsD::Instrument::Environment.new('STATSD_ENV' => 'production')
+
+    assert_equal StatsD::Instrument::StatsDDatagramBuilder, env.default_client.datagram_builder_class
+    assert_equal 'localhost', env.default_client.sink.host
+    assert_equal 8125, env.default_client.sink.port
+    assert_equal 1.0, env.default_client.default_sample_rate
+    assert_nil env.default_client.prefix
+    assert_nil env.default_client.default_tags
+  end
 end

data/test/helpers/rubocop_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RubocopHelper
+  attr_accessor :cop
+
+  private
+
+  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"
+  end
+
+  def assert_offense(source)
+    investigate(RuboCop::ProcessedSource.new(source, 2.3, 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
+  end
+
+  def autocorrect_source(source)
+    RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+    RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+    cop.instance_variable_get(:@options)[:auto_correct] = true
+
+    processed_source = RuboCop::ProcessedSource.new(source, 2.3, nil)
+    investigate(processed_source)
+
+    corrector = RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
+    corrector.rewrite
+  end
+
+  def investigate(processed_source)
+    forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
+      next unless cop.join_force?(klass)
+      instances << klass.new([cop])
+    end
+
+    commissioner = RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
+    commissioner.investigate(processed_source)
+    commissioner
+  end
+end

data/test/helpers_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class HelpersTest < Minitest::Test
@@ -21,4 +23,3 @@ class HelpersTest < Minitest::Test
     assert_equal 12, metrics[1].value
   end
 end
-

data/test/integration_test.rb

@@ -1,20 +1,44 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class IntegrationTest < Minitest::Test
-
   def setup
-    @old_backend, StatsD.backend = StatsD.backend, StatsD::Instrument::Backends::UDPBackend.new("localhost:31798")
+    @server = UDPSocket.new
+    @server.bind('localhost', 0)
+    port = @server.addr[1]
+
+    @old_backend = StatsD.backend
+    StatsD.backend = StatsD::Instrument::Backends::UDPBackend.new("localhost:#{port}")
   end
-  
+
   def teardown
+    @server.close
     StatsD.backend = @old_backend
   end
 
   def test_live_local_udp_socket
-    server = UDPSocket.new
-    server.bind('localhost', 31798)
-
     StatsD.increment('counter')
-    assert_equal "counter:1|c", server.recvfrom(100).first
+    assert_equal "counter:1|c", @server.recvfrom(100).first
+  end
+
+  def test_synchronize_in_exit_handler_handles_thread_error_and_exits_cleanly
+    pid = fork do
+      Signal.trap('TERM') do
+        StatsD.increment('exiting')
+        Process.exit!(0)
+      end
+
+      sleep 100
+    end
+
+    Process.kill('TERM', pid)
+    _, exit_status = Process.waitpid2(pid)
+
+    assert_equal 0, exit_status, "The foked process did not exit cleanly"
+    assert_equal "exiting:1|c", @server.recvfrom_nonblock(100).first
+
+  rescue NotImplementedError
+    pass("Fork is not implemented on #{RUBY_PLATFORM}")
   end
 end

data/test/log_sink_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class LogSinktest < Minitest::Test
+  def test_log_sink
+    logger = Logger.new(log = StringIO.new)
+    logger.formatter = proc do |severity, _datetime, _progname, msg|
+      "#{severity}: #{msg}\n"
+    end
+
+    log_sink = StatsD::Instrument::LogSink.new(logger)
+    log_sink << 'foo:1|c' << 'bar:1|c'
+
+    assert_equal <<~LOG, log.string
+      DEBUG: [StatsD] foo:1|c
+      DEBUG: [StatsD] bar:1|c
+    LOG
+  end
+
+  def test_log_sink_chomps_trailing_newlines
+    logger = Logger.new(log = StringIO.new)
+    logger.formatter = proc do |severity, _datetime, _progname, msg|
+      "#{severity}: #{msg}\n"
+    end
+
+    log_sink = StatsD::Instrument::LogSink.new(logger)
+    log_sink << "foo:1|c\n" << "bar:1|c\n"
+
+    assert_equal <<~LOG, log.string
+      DEBUG: [StatsD] foo:1|c
+      DEBUG: [StatsD] bar:1|c
+    LOG
+  end
+end

data/test/logger_backend_test.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class LoggerBackendTest < Minitest::Test
   def setup
     logger = Logger.new(@io = StringIO.new)
-    logger.formatter = lambda { |_,_,_, msg| "#{msg}\n" }
+    logger.formatter = lambda { |_, _, _, msg| "#{msg}\n" }
     @backend = StatsD::Instrument::Backends::LoggerBackend.new(logger)
-    @metric1 = StatsD::Instrument::Metric::new(type: :c, name: 'mock.counter', tags: { a: 'b', c: 'd'})
-    @metric2 = StatsD::Instrument::Metric::new(type: :ms, name: 'mock.measure', value: 123, sample_rate: 0.3)
+    @metric1 = StatsD::Instrument::Metric.new(type: :c, name: 'mock.counter', tags: { a: 'b', c: 'd' })
+    @metric2 = StatsD::Instrument::Metric.new(type: :ms, name: 'mock.measure', value: 123, sample_rate: 0.3)
   end
 
   def test_logs_metrics
     @backend.collect_metric(@metric1)
-    assert_equal @io.string, "[StatsD] increment mock.counter:1 #a:b #c:d\n"
-    @io.string = ""
-
     @backend.collect_metric(@metric2)
-    assert_equal @io.string, "[StatsD] measure mock.measure:123 @0.3\n"
+    assert_equal <<~LOG, @io.string
+      [StatsD] increment mock.counter:1 #a:b #c:d
+      [StatsD] measure mock.measure:123 @0.3
+    LOG
   end
-end
+end

data/test/matchers_test.rb

@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 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
@@ -31,72 +35,82 @@ class MatchersTest < Minitest::Test
   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 { StatsD.increment('counter', times: 3) }
+    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 {
-      StatsD.increment('counter', value: 2)
-      StatsD.increment('counter', value: 1)
-    }
+    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 {
-      StatsD.increment('counter', value: 2)
-      StatsD.increment('counter', value: 3)
-    }
+    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 {
-      StatsD.increment('counter', value: 1)
-      StatsD.increment('counter', value: 1)
-    }
+    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 {
-      StatsD.increment('counter', value: 1)
-      StatsD.increment('counter', value: 2)
-    }
+    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/metric_test.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class MetricTest < Minitest::Test
-
   def test_required_arguments
     assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(type: :c) }
     assert_raises(ArgumentError) { StatsD::Instrument::Metric.new(name: 'test') }
@@ -15,37 +16,32 @@ class MetricTest < Minitest::Test
     assert m.tags.nil?
   end
 
-  def test_name_prefix
-    StatsD.stubs(:prefix).returns('prefix')
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter')
-    assert_equal 'prefix.counter', m.name
-
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', no_prefix: true)
-    assert_equal 'counter', m.name
-
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', prefix: "foobar")
-    assert_equal 'foobar.counter', m.name
-
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', prefix: "foobar", no_prefix: true)
-    assert_equal 'counter', m.name
-  end
-
   def test_bad_metric_name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my:metric', no_prefix: true)
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'my:metric')
     assert_equal 'my_metric', m.name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my|metric', no_prefix: true)
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'my|metric')
     assert_equal 'my_metric', m.name
-    m = StatsD::Instrument::Metric.new(type: :c, name: 'my@metric', no_prefix: true)
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'my@metric')
     assert_equal 'my_metric', m.name
   end
 
   def test_handle_bad_tags
     assert_equal ['ignored'], StatsD::Instrument::Metric.normalize_tags(['igno|red'])
-    assert_equal ['lol::class:omg::lol'], StatsD::Instrument::Metric.normalize_tags({ :"lol::class" => "omg::lol" })
+    assert_equal ['lol::class:omg::lol'], StatsD::Instrument::Metric.normalize_tags("lol::class" => "omg::lol")
   end
 
   def test_rewrite_tags_provided_as_hash
-    assert_equal ['tag:value'], StatsD::Instrument::Metric.normalize_tags(:tag => 'value')
-    assert_equal ['tag:value', 'tag2:value2'], StatsD::Instrument::Metric.normalize_tags(:tag => 'value', :tag2 => 'value2')
+    assert_equal ['tag:value'], StatsD::Instrument::Metric.normalize_tags(tag: 'value')
+    assert_equal ['tag1:v1', 'tag2:v2'], StatsD::Instrument::Metric.normalize_tags(tag1: 'v1', tag2: 'v2')
+  end
+
+  def test_default_tags
+    StatsD.stubs(:default_tags).returns(['default_tag:default_value'])
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', tags: { tag: 'value' })
+    assert_equal ['tag:value', 'default_tag:default_value'], m.tags
+
+    StatsD.stubs(:default_tags).returns(['tag:value'])
+    m = StatsD::Instrument::Metric.new(type: :c, name: 'counter', tags: { tag: 'value' })
+    assert_equal ['tag:value', 'tag:value'], m.tags # we don't care about duplicates
   end
 end

data/test/null_sink_test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'statsd/instrument/client'
+
+class NullSinktest < Minitest::Test
+  def test_null_sink
+    null_sink = StatsD::Instrument::NullSink.new
+    null_sink << 'foo:1|c' << 'bar:1|c'
+    pass # We don't have anything to assert, except that no exception was raised
+  end
+end

data/test/rubocop/measure_as_dist_argument_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+module Rubocop
+  class MeasureAsDistArgumentTest < Minitest::Test
+    include RubocopHelper
+
+    def setup
+      @cop = RuboCop::Cop::StatsD::MeasureAsDistArgument.new
+    end
+
+    def test_ok_for_metric_method_without_as_dist_argument
+      assert_no_offenses("StatsD.measure('foo', 123)")
+      assert_no_offenses("StatsD.measure('foo', 123, sample_rate: 3)")
+      assert_no_offenses("StatsD.measure('foo') {}")
+    end
+
+    def test_ok_for_other_metric_methods
+      assert_no_offenses("StatsD.increment('foo', as_dist: true)")
+    end
+
+    def test_ok_for_metaprogramming_method_without_as_dist_argument
+      assert_no_offenses("statsd_measure(:method, 'metric_name', sample_rate: 1) {}")
+    end
+
+    def test_ok_for_other_metaprogramming_methods
+      assert_no_offenses("statsd_distribution(:method, 'metric_name', as_dist: true) {}")
+    end
+
+    def test_offense_when_using_as_dist_with_measure_metric_method
+      assert_offense("StatsD.measure('foo', 123, sample_rate: 1, as_dist: true, tags: ['foo'])")
+      assert_offense("StatsD.measure('foo', 123, as_dist: false)")
+      assert_offense("StatsD.measure('foo', as_dist: true, &block)")
+      assert_offense("StatsD.measure('foo', as_dist: true) { } ")
+    end
+
+    def test_offense_when_using_as_dist_with_measure_metaprogramming_method
+      assert_offense("statsd_measure(:method, 'foo', as_dist: true, &block)")
+      assert_offense("statsd_measure(:method, 'foo', as_dist: false) { } ")
+    end
+  end
+end

data/test/rubocop/metaprogramming_positional_arguments_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'statsd/instrument/rubocop'
+
+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