statsd-instrument 1.7.2 → 2.0.0

data/test/statsd_instrumentation_test.rb

@@ -47,13 +47,16 @@ end
 
 ActiveMerchant::Base.extend StatsD::Instrument
 
-class StatsDInstrumentationTest < Test::Unit::TestCase
+class StatsDInstrumentationTest < Minitest::Test
+  include StatsD::Instrument::Assertions
+
   def test_statsd_count_if
     ActiveMerchant::Gateway.statsd_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.if').once
-    ActiveMerchant::Gateway.new.purchase(true)
-    ActiveMerchant::Gateway.new.purchase(false)
+    assert_statsd_increment('ActiveMerchant.Gateway.if') do
+      ActiveMerchant::Gateway.new.purchase(true)
+      ActiveMerchant::Gateway.new.purchase(false)
+    end
 
     ActiveMerchant::Gateway.statsd_remove_count_if :ssl_post, 'ActiveMerchant.Gateway.if'
   end
@@ -63,9 +66,10 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result == 'true'
     end
 
-    StatsD.expects(:collect).with(:c, 'ActiveMerchant.Base.post_with_block', 1, {}).once
-    assert_equal 'true',  ActiveMerchant::Base.new.post_with_block { 'true' }
-    assert_equal 'false', ActiveMerchant::Base.new.post_with_block { 'false' }
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
+      assert_equal 'true',  ActiveMerchant::Base.new.post_with_block { 'true' }
+      assert_equal 'false', ActiveMerchant::Base.new.post_with_block { 'false' }
+    end
 
     ActiveMerchant::Base.statsd_remove_count_if :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
@@ -75,9 +79,10 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result[:success]
     end
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.block').once
-    ActiveMerchant::UniqueGateway.new.purchase(true)
-    ActiveMerchant::UniqueGateway.new.purchase(false)
+    assert_statsd_increment('ActiveMerchant.Gateway.block', times: 1) do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+      ActiveMerchant::UniqueGateway.new.purchase(false)
+    end
 
     ActiveMerchant::UniqueGateway.statsd_remove_count_if :ssl_post, 'ActiveMerchant.Gateway.block'
   end
@@ -85,11 +90,15 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   def test_statsd_count_success
     ActiveMerchant::Gateway.statsd_count_success :ssl_post, 'ActiveMerchant.Gateway', 0.5
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.success', 1, 0.5).once
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.failure', 1, 0.5).once
+    assert_statsd_increment('ActiveMerchant.Gateway.success', sample_rate: 0.5, times: 1) do
+      ActiveMerchant::Gateway.new.purchase(true)
+      ActiveMerchant::Gateway.new.purchase(false)
+    end
 
-    ActiveMerchant::Gateway.new.purchase(true)
-    ActiveMerchant::Gateway.new.purchase(false)
+    assert_statsd_increment('ActiveMerchant.Gateway.failure', sample_rate: 0.5, times: 1) do
+      ActiveMerchant::Gateway.new.purchase(false)
+      ActiveMerchant::Gateway.new.purchase(true)
+    end
 
     ActiveMerchant::Gateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
   end
@@ -99,11 +108,15 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result == 'successful'
     end
 
-    StatsD.expects(:collect).with(:c, 'ActiveMerchant.Base.post_with_block.success', 1, {}).once
-    StatsD.expects(:collect).with(:c, 'ActiveMerchant.Base.post_with_block.failure', 1, {}).once
-    
-    assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
-    assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block.success', times: 1) do
+      assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
+      assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
+    end
+
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block.failure', times: 1) do
+      assert_equal 'successful', ActiveMerchant::Base.new.post_with_block { 'successful' }
+      assert_equal 'not so successful', ActiveMerchant::Base.new.post_with_block { 'not so successful' }
+    end    
 
     ActiveMerchant::Base.statsd_remove_count_success :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
@@ -113,11 +126,13 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
       result[:success]
     end
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.success', 1)
-    ActiveMerchant::UniqueGateway.new.purchase(true)
+    assert_statsd_increment('ActiveMerchant.Gateway.success') do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.failure', 1)
-    ActiveMerchant::UniqueGateway.new.purchase(false)
+    assert_statsd_increment('ActiveMerchant.Gateway.failure') do
+      ActiveMerchant::UniqueGateway.new.purchase(false)
+    end
 
     ActiveMerchant::UniqueGateway.statsd_remove_count_success :ssl_post, 'ActiveMerchant.Gateway'
   end
@@ -125,8 +140,9 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   def test_statsd_count
     ActiveMerchant::Gateway.statsd_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.ssl_post', 1)
-    ActiveMerchant::Gateway.new.purchase(true)
+    assert_statsd_increment('ActiveMerchant.Gateway.ssl_post') do
+      ActiveMerchant::Gateway.new.purchase(true)
+    end
 
     ActiveMerchant::Gateway.statsd_remove_count :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
   end
@@ -135,8 +151,9 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
     metric_namer = lambda { |object, args| object.class.to_s.downcase + ".insert." + args.first.to_s }
     ActiveMerchant::Gateway.statsd_count(:ssl_post, metric_namer)
 
-    StatsD.expects(:increment).with('gatewaysubclass.insert.true', 1)
-    GatewaySubClass.new.purchase(true)
+    assert_statsd_increment('gatewaysubclass.insert.true') do
+      GatewaySubClass.new.purchase(true)
+    end
 
     ActiveMerchant::Gateway.statsd_remove_count(:ssl_post, metric_namer)
   end
@@ -144,35 +161,39 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
   def test_statsd_count_with_method_receiving_block
     ActiveMerchant::Base.statsd_count :post_with_block, 'ActiveMerchant.Base.post_with_block'
 
-    StatsD.expects(:collect).with(:c, 'ActiveMerchant.Base.post_with_block', 1, {})
-    assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    assert_statsd_increment('ActiveMerchant.Base.post_with_block') do
+      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    end
 
     ActiveMerchant::Base.statsd_remove_count :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
 
-  def test_statsd_measure_with_nested_modules
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+  def test_statsd_measure
+    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3
 
-    StatsD.expects(:measure).with('ActiveMerchant.Gateway.ssl_post', nil)
-    ActiveMerchant::UniqueGateway.new.purchase(true)
+    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post', sample_rate: 0.3) do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
 
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
   end
 
-  def test_statsd_measure
-    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post', 0.3
+  def test_statsd_measure_uses_normalized_metric_name
+    ActiveMerchant::UniqueGateway.statsd_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
 
-    StatsD.expects(:measure).with('ActiveMerchant.Gateway.ssl_post', nil, 0.3)
-    ActiveMerchant::UniqueGateway.new.purchase(true)
+    assert_statsd_measure('ActiveMerchant.Gateway.ssl_post') do
+      ActiveMerchant::UniqueGateway.new.purchase(true)
+    end
 
-    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant.Gateway.ssl_post'
+    ActiveMerchant::UniqueGateway.statsd_remove_measure :ssl_post, 'ActiveMerchant::Gateway.ssl_post'
   end
 
   def test_statsd_measure_with_method_receiving_block
     ActiveMerchant::Base.statsd_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
 
-    StatsD.expects(:collect).with(:ms, 'ActiveMerchant.Base.post_with_block', is_a(Float), {})
-    assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    assert_statsd_measure('ActiveMerchant.Base.post_with_block') do
+      assert_equal 'block called', ActiveMerchant::Base.new.post_with_block { 'block called' }
+    end
 
     ActiveMerchant::Base.statsd_remove_measure :post_with_block, 'ActiveMerchant.Base.post_with_block'
   end
@@ -181,18 +202,20 @@ class StatsDInstrumentationTest < Test::Unit::TestCase
     ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
     ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync'
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.sync', 1)
-    ActiveMerchant::Gateway.sync
+    assert_statsd_increment('ActiveMerchant.Gateway.sync') do
+      ActiveMerchant::Gateway.sync
+    end
 
     ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
   end
 
   def test_statsd_count_with_tags
     ActiveMerchant::Gateway.singleton_class.extend StatsD::Instrument
-    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync', :tags => ['t']
+    ActiveMerchant::Gateway.singleton_class.statsd_count :sync, 'ActiveMerchant.Gateway.sync', tags: { key: 'value' }
 
-    StatsD.expects(:increment).with('ActiveMerchant.Gateway.sync', 1, :tags => ['t'])
-    ActiveMerchant::Gateway.sync
+    assert_statsd_increment('ActiveMerchant.Gateway.sync', tags: ['key:value']) do
+      ActiveMerchant::Gateway.sync
+    end
 
     ActiveMerchant::Gateway.singleton_class.statsd_remove_count :sync, 'ActiveMerchant.Gateway.sync'
   end

data/test/statsd_test.rb

@@ -1,256 +1,104 @@
 require 'test_helper'
 
-class StatsDTest < Test::Unit::TestCase
+class StatsDTest < Minitest::Test
+  include StatsD::Instrument::Assertions
 
-  def setup
-    StatsD.stubs(:rand).returns(0.0)
-
-    UDPSocket.stubs(:new).returns(@socket = mock('socket'))
-    @socket.stubs(:connect)
-    @socket.stubs(:send)
-    StatsD.invalidate_socket
-
-    StatsD.stubs(:logger).returns(@logger = mock('logger'))
-    @logger.stubs(:info)
-    @logger.stubs(:error)
+  def test_statsd_passed_collections_to_backend
+    StatsD.backend.expects(:collect_metric).with(instance_of(StatsD::Instrument::Metric))
+    StatsD.increment('test')
   end
 
   def test_statsd_measure_with_explicit_value
-    StatsD.expects(:collect).with(:ms, 'values.foobar', 42, {})
-    StatsD.measure('values.foobar', 42)
+    result = nil
+    metric = capture_statsd_call { result = StatsD.measure('values.foobar', 42) }
+    assert_equal metric, result
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+    assert_equal :ms, metric.type
   end
 
   def test_statsd_measure_with_explicit_value_and_sample_rate
-    StatsD.expects(:collect).with(:ms, 'values.foobar', 42, :sample_rate => 0.1)
-    StatsD.measure('values.foobar', 42, :sample_rate => 0.1)
+    metric = capture_statsd_call { StatsD.measure('values.foobar', 42, :sample_rate => 0.1) }
+    assert_equal 0.1, metric.sample_rate
   end
 
-  def test_statsd_measure_with_benchmarked_value
-    Benchmark.stubs(:realtime).returns(1.12)
-    StatsD.expects(:collect).with(:ms, 'values.foobar', 1120.0, {})
-    StatsD.measure('values.foobar') do
-      #noop
+  def test_statsd_measure_with_benchmarked_duration
+    StatsD::Instrument.stubs(:duration).returns(1.12)
+    metric = capture_statsd_call do
+      StatsD.measure('values.foobar') { 'foo' }
     end
+    assert_equal 1120.0, metric.value
   end
 
-  def test_statsd_measure_with_benchmarked_value_and_options
-    Benchmark.stubs(:realtime).returns(1.12)
-    StatsD.expects(:collect).with(:ms, 'values.foobar', 1120.0, :sample_rate => 1.0)
-    StatsD.measure('values.foobar', :sample_rate => 1.0) do
-      #noop
-    end
+  def test_statsd_measure_returns_return_value_of_block
+    return_value = StatsD.measure('values.foobar') { 'sarah' }
+    assert_equal 'sarah', return_value
+  end
+
+  def test_statsd_increment
+    result = nil
+    metric = capture_statsd_call { result = StatsD.increment('values.foobar', 3) }
+    assert_equal metric, result
+    assert_equal :c, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 3, metric.value
   end
 
   def test_statsd_increment_with_hash_argument
-    StatsD.expects(:collect).with(:c, 'values.foobar', 1, :tags => ['test'])
-    StatsD.increment('values.foobar', :tags => ['test'])
+    metric = capture_statsd_call { StatsD.increment('values.foobar', :tags => ['test']) }
+    assert_equal StatsD.default_sample_rate, metric.sample_rate
+    assert_equal ['test'], metric.tags
+    assert_equal 1, metric.value
   end
 
   def test_statsd_increment_with_multiple_arguments
-    StatsD.expects(:collect).with(:c, 'values.foobar', 12, :sample_rate => nil, :tags => ['test'])
-    StatsD.increment('values.foobar', 12, nil, ['test'])
+    metric = capture_statsd_call { StatsD.increment('values.foobar', 12, nil, ['test']) }
+    assert_equal StatsD.default_sample_rate, metric.sample_rate
+    assert_equal ['test'], metric.tags
+    assert_equal 12, metric.value
   end
 
   def test_statsd_gauge
-    StatsD.expects(:collect).with(:g, 'values.foobar', 12, {})
-    StatsD.gauge('values.foobar', 12)
+    result = nil
+    metric = capture_statsd_call { result = StatsD.gauge('values.foobar', 12) }
+    assert_equal metric, result
+    assert_equal :g, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 12, metric.value
   end
 
   def test_statsd_set
-    StatsD.expects(:collect).with(:s, 'values.foobar', 12, {})
-    StatsD.set('values.foobar', 12)
-  end
-
-  def test_statsd_histogram_on_datadog
-    StatsD.stubs(:implementation).returns(:datadog)
-    StatsD.expects(:collect).with(:h, 'values.hg', 12.33, :sample_rate => 0.2, :tags => ['tag_123', 'key-name:value123'])
-    StatsD.histogram('values.hg', 12.33, :sample_rate => 0.2, :tags => ['tag_123', 'key-name:value123'])
-  end
-
-  def test_raise_when_using_histograms_and_not_on_datadog
-    StatsD.stubs(:implementation).returns(:other)
-    assert_raises(NotImplementedError) { StatsD.histogram('foohg', 3.33) }
-  end
-
-  def test_collect_respects_enabled
-    StatsD.stubs(:enabled).returns(false)
-    StatsD.expects(:write_packet).never
-    StatsD.increment('counter')
-  end
-
-  def test_collect_respects_sampling_rate
-    StatsD.expects(:write_packet).once
-
-    StatsD.stubs(:rand).returns(0.6)
-    StatsD.increment('counter', 1, 0.5)
-
-    StatsD.stubs(:rand).returns(0.4)
-    StatsD.increment('counter', 1, 0.5)    
-  end
-
-  def test_support_counter_syntax
-    StatsD.expects(:write_packet).with('counter:1|c')
-    StatsD.increment('counter')
-
-    StatsD.expects(:write_packet).with('counter:10|c|@0.5')
-    StatsD.increment('counter', 10, 0.5)
-  end
-
-  def test_supports_gauge_syntax
-    StatsD.expects(:write_packet).with('fooy:1.23|g')
-    StatsD.gauge('fooy', 1.23)
-
-    StatsD.expects(:write_packet).with('fooy:42|g|@0.01')
-    StatsD.gauge('fooy', 42, 0.01)
-  end
-
-  def test_supports_set_syntax
-    StatsD.expects(:write_packet).with('unique:10.0.0.10|s')
-    StatsD.set('unique', '10.0.0.10')
-
-    StatsD.expects(:write_packet).with('unique:10.0.0.10|s|@0.01')
-    StatsD.set('unique', '10.0.0.10', 0.01)
-  end
-
-  def test_support_timing_syntax
-    StatsD.expects(:write_packet).with('duration:1.23|ms')
-    StatsD.measure('duration', 1.23)
-
-    StatsD.expects(:write_packet).with('duration:0.42|ms|@0.01')
-    StatsD.measure('duration', 0.42, 0.01)
-  end
-
-  def test_histogram_syntax_on_datadog
-    StatsD.stubs(:implementation).returns(:datadog)
-
-    StatsD.expects(:write_packet).with('fooh:42.4|h')
-    StatsD.histogram('fooh', 42.4)
-  end
-
-  def test_support_tags_syntax_on_datadog
-    StatsD.stubs(:implementation).returns(:datadog)
-
-    StatsD.expects(:write_packet).with("fooc:3|c|#topic:foo,bar")
-    StatsD.increment('fooc', 3, 1.0, ['topic:foo', 'bar'])
-  end
-
-  def test_raise_when_using_tags_and_not_on_datadog
-    StatsD.stubs(:implementation).returns(:other)
-    assert_raises(ArgumentError) { StatsD.increment('fooc', 3, 1.0, ['nonempty']) }
-  end
-
-  def test_rewrite_shitty_tags
-    StatsD.stubs(:implementation).returns(:datadog)
-
-    assert_equal ['igno_red'], StatsD.send(:clean_tags, ['igno,red'])
-    assert_equal ['igno_red'], StatsD.send(:clean_tags, ['igno  red'])
-    assert_equal ['test:test_test'], StatsD.send(:clean_tags, ['test:test:test'])
-
-    assert_equal ['tag:value'], StatsD.send(:clean_tags, { :tag => 'value' })
-    assert_equal Set['tag:value', 'tag2:value2'], Set.new(StatsD.send(:clean_tags, { :tag => 'value', :tag2 => 'value2' }))
-
-    StatsD.expects(:write_packet).with("fooc:3|c|#topic:foo_foo,bar_")
-    StatsD.increment('fooc', 3, 1.0, ['topic:foo : foo', 'bar '])
-
-    StatsD.expects(:write_packet).with("foot:1|c|#foo:bar")
-    StatsD.increment('foot', :tags => { :foo => 'bar' })
-  end
-
-  def test_supports_key_value_syntax_on_statsite
-    StatsD.stubs(:implementation).returns(:statsite)
-
-    StatsD.expects(:write_packet).with("fooy:42|kv\n")
-    StatsD.key_value('fooy', 42)
-  end
-
-  def test_supports_key_value_with_timestamp_on_statsite
-    StatsD.stubs(:implementation).returns(:statsite)
-
-    StatsD.expects(:write_packet).with("fooy:42|kv|@123456\n")
-    StatsD.key_value('fooy', 42, 123456)
-  end
-
-  def test_raise_when_using_key_value_and_not_on_statsite
-    StatsD.stubs(:implementation).returns(:other)
-    assert_raises(NotImplementedError) { StatsD.key_value('fookv', 3.33) }
-  end
-
-  def test_support_key_prefix
-    StatsD.expects(:write_packet).with('prefix.counter:1|c').once
-    StatsD.expects(:write_packet).with('counter:1|c').once
-
-    StatsD.stubs(:prefix).returns('prefix')
-    StatsD.increment('counter')
-    StatsD.stubs(:prefix).returns(nil)
-    StatsD.increment('counter')
-  end
-
-  def test_development_mode_uses_logger
-    StatsD.stubs(:mode).returns(:development)
-
-    @logger.expects(:info).with(regexp_matches(/\A\[StatsD\] /))
-    StatsD.increment('counter')
-  end  
-
-  def test_production_mode_uses_udp_socket
-    StatsD.stubs(:mode).returns(:production)
-    StatsD.server = "localhost:9815"
-
-    @socket.expects(:connect).with('localhost', 9815).once
-    @socket.expects(:send).with(is_a(String), 0).twice
-    StatsD.increment('counter')
-    StatsD.increment('counter')
-  end
-
-  def test_changing_host_or_port_should_create_new_socket
-    @socket.expects(:connect).with('localhost', 1234).once
-    @socket.expects(:connect).with('localhost', 2345).once
-    @socket.expects(:connect).with('127.0.0.1', 2345).once
-
-    StatsD.server = "localhost:1234"
-    StatsD.send(:socket)
-    
-    StatsD.port = 2345
-    StatsD.send(:socket)
-
-    StatsD.host = '127.0.0.1'
-    StatsD.send(:socket)
-  end
-
-  def test_socket_error_should_not_raise_but_log
-    StatsD.stubs(:mode).returns(:production)
-    @socket.stubs(:connect).raises(SocketError)
-    
-    @logger.expects(:error).with(instance_of(SocketError))
-    StatsD.measure('values.foobar', 42)
-  end
-
-  def test_system_call_error_should_not_raise_but_log
-    StatsD.stubs(:mode).returns(:production)
-    @socket.stubs(:send).raises(Errno::ETIMEDOUT)
-    
-    @logger.expects(:error).with(instance_of(Errno::ETIMEDOUT))
-    StatsD.measure('values.foobar', 42)
-  end
-
-  def test_io_error_should_not_raise_but_log
-    StatsD.stubs(:mode).returns(:production)
-    @socket.stubs(:send).raises(IOError)
-
-    @logger.expects(:error).with(instance_of(IOError))
-    StatsD.measure('values.foobar', 42)
-  end
-
-  def test_live_local_udp_socket
-    UDPSocket.unstub(:new)
-
-    StatsD.stubs(:mode).returns(:production)
-    StatsD.server = "localhost:31798"
-
-    server = UDPSocket.new
-    server.bind('localhost', 31798)
-
-    StatsD.increment('counter')
-    assert_equal "counter:1|c", server.recvfrom(100).first
+    result = nil
+    metric = capture_statsd_call { result = StatsD.set('values.foobar', 'unique_identifier') }
+    assert_equal metric, result
+    assert_equal :s, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 'unique_identifier', metric.value
+  end
+
+  def test_statsd_histogram
+    result = nil
+    metric = capture_statsd_call { result = StatsD.histogram('values.foobar', 42) }
+    assert_equal metric, result
+    assert_equal :h, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+  end
+
+  def test_statsd_key_value
+    result = nil
+    metric = capture_statsd_call { result = StatsD.key_value('values.foobar', 42) }
+    assert_equal metric, result
+    assert_equal :kv, metric.type
+    assert_equal 'values.foobar', metric.name
+    assert_equal 42, metric.value
+  end
+
+  protected
+
+  def capture_statsd_call(&block)
+    metrics = capture_statsd_calls(&block)
+    assert_equal 1, metrics.length
+    metrics.first
   end
 end

data/test/test_helper.rb

@@ -1,8 +1,10 @@
-require 'rubygems'
-require 'statsd-instrument'
-require 'test/unit'
+ENV['ENV'] = 'test'
+
+require 'minitest/autorun'
+require 'minitest/pride'
 require 'mocha/setup'
 require 'set'
 require 'logger'
+require 'statsd-instrument'
 
 StatsD.logger = Logger.new('/dev/null')