statsd-instrument 3.0.0.pre1 → 3.1.0

data/test/integration_test.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class IntegrationTest < Minitest::Test
   def setup
     @server = UDPSocket.new
-    @server.bind('localhost', 0)
+    @server.bind("localhost", 0)
 
     @env = StatsD::Instrument::Environment.new(
-      'STATSD_ADDR' => "#{@server.addr[2]}:#{@server.addr[1]}",
-      'STATSD_IMPLEMENTATION' => 'dogstatsd',
-      'STATSD_ENV' => 'production',
+      "STATSD_ADDR" => "#{@server.addr[2]}:#{@server.addr[1]}",
+      "STATSD_IMPLEMENTATION" => "dogstatsd",
+      "STATSD_ENV" => "production",
     )
 
     @old_client = StatsD.singleton_client
@@ -23,7 +23,7 @@ class IntegrationTest < Minitest::Test
   end
 
   def test_live_local_udp_socket
-    StatsD.increment('counter')
-    assert_equal "counter:1|c", @server.recvfrom(100).first
+    StatsD.increment("counter")
+    assert_equal("counter:1|c", @server.recvfrom(100).first)
   end
 end

data/test/log_sink_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class LogSinkTest < Minitest::Test
   def test_log_sink
@@ -10,9 +10,9 @@ class LogSinkTest < Minitest::Test
     end
 
     log_sink = StatsD::Instrument::LogSink.new(logger)
-    log_sink << 'foo:1|c' << 'bar:1|c'
+    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

@@ -1,116 +1,116 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/matchers'
+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
-    matcher_1 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['a'])
-    matcher_2 = StatsD::Instrument::Matchers::Increment.new(:c, 'counter', tags: ['b'])
+    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 {
-      StatsD.increment('counter', tags: ['a'])
-      StatsD.increment('counter', tags: ['b'])
-    }
+    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'])
+    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 {
-      StatsD.increment('counter', tags: ['a'])
-      StatsD.increment('counter', tags: ['a'])
-    }
+    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 {
-      StatsD.increment('counter', 2)
-      StatsD.increment('counter', 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', 2)
-      StatsD.increment('counter', 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', 1)
-      StatsD.increment('counter', 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', 1)
-      StatsD.increment('counter', 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/null_sink_test.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 class NullSinkTest < Minitest::Test
   def test_null_sink
     null_sink = StatsD::Instrument::NullSink.new
-    null_sink << 'foo:1|c' << 'bar:1|c'
+    null_sink << "foo:1|c" << "bar:1|c"
     pass # We don't have anything to assert, except that no exception was raised
   end
 
   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/measure_as_dist_argument_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/rubocop'
+require "test_helper"
+require "statsd/instrument/rubocop"
 
 module Rubocop
   class MeasureAsDistArgumentTest < Minitest::Test

data/test/rubocop/metaprogramming_positional_arguments_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/rubocop'
+require "test_helper"
+require "statsd/instrument/rubocop"
 
 module Rubocop
   class MetaprogrammingPositionalArgumentsTest < Minitest::Test

data/test/rubocop/metric_prefix_argument_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/rubocop'
+require "test_helper"
+require "statsd/instrument/rubocop"
 
 module Rubocop
   class MetricPrefixArgumentTest < Minitest::Test

data/test/rubocop/metric_return_value_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/rubocop'
+require "test_helper"
+require "statsd/instrument/rubocop"
 
 module Rubocop
   class MetricReturnValueTest < Minitest::Test
@@ -12,7 +12,7 @@ module Rubocop
     end
 
     def test_ok_for_non_metric_method
-      assert_no_offenses('backend = StatsD.backend')
+      assert_no_offenses("backend = StatsD.backend")
     end
 
     def test_ok_as_naked_statement
@@ -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/metric_value_keyword_argument_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/rubocop'
+require "test_helper"
+require "statsd/instrument/rubocop"
 
 module Rubocop
   class MetricValueKeywordArgumentTest < Minitest::Test
@@ -31,7 +31,7 @@ module Rubocop
     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', 'value' => 1)")
       assert_offense("StatsD.increment('foo', sample_rate: 0.1, value: 1, tags: ['foo'])")
       assert_offense("StatsD.increment('foo', value: 1, &block)")
     end

data/test/rubocop/positional_arguments_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/rubocop'
+require "test_helper"
+require "statsd/instrument/rubocop"
 
 module Rubocop
   class PositionalArgumentsTest < Minitest::Test
@@ -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

data/test/rubocop/singleton_configuration_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'test_helper'
-require 'statsd/instrument/rubocop'
+require "test_helper"
+require "statsd/instrument/rubocop"
 
 module Rubocop
   class SingletonConfigurationTest < Minitest::Test
@@ -13,7 +13,7 @@ module Rubocop
 
     def test_offense_statsd_backend
       assert_offense('StatsD.backend = "foo"')
-      assert_offense('old_backend = StatsD.backend')
+      assert_offense("old_backend = StatsD.backend")
     end
 
     def test_offense_statsd_prefix
@@ -23,21 +23,21 @@ module Rubocop
 
     def test_offense_statsd_default_tags
       assert_offense('StatsD.default_tags = ["foo"]')
-      assert_offense('StatsD.default_tags.empty?')
+      assert_offense("StatsD.default_tags.empty?")
     end
 
     def test_offense_statsd_default_sample_rate
-      assert_offense('StatsD.default_sample_rate = 1.0')
-      assert_offense('should_sample = StatsD.default_sample_rate > rand')
+      assert_offense("StatsD.default_sample_rate = 1.0")
+      assert_offense("should_sample = StatsD.default_sample_rate > rand")
     end
 
     def test_no_offense_for_other_methods
-      assert_no_offenses('StatsD.singleton_client = my_client')
+      assert_no_offenses("StatsD.singleton_client = my_client")
       assert_no_offenses('StatsD.logger.info("foo")')
     end
 
     def test_no_offense_for_constant_reference
-      assert_no_offenses('legacy_client = StatsD')
+      assert_no_offenses("legacy_client = StatsD")
     end
   end
 end