statsd-instrument 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18047951724aa18b3d78beeb6f41dc4de83af59c
-  data.tar.gz: aca4e756c32bfeb9564e485cd95406d11028cc05
+  metadata.gz: 46fc4b2306e65ec55ec96d05f26653460d43ece8
+  data.tar.gz: c4657dafe04761702c5464de9b277f77e1106530
 SHA512:
-  metadata.gz: d14651044e4b148c3caefaac65f7d4c7b49471ddf769c8124d9e9a5f0034eb4069c1139ea0ccb772e0ad78c1378599b0b5fae56f64c85d289df69c780096578b
-  data.tar.gz: e4187bb6b8d76a86e7fb0e46800fe5d2a7625234bb54cdb3630165590834fe5a27555367cb6148ae67a9993883bfa6be7decf6ad18abe50cf476d077cfb43ac3
+  metadata.gz: 2e450334ecc746a8066b86975a208a5bf9d0bec99d6117080aa407106909cc3636321fd49e6663f847bce8d40da7a19e3bfd945087420c8ad04b70032f029c45
+  data.tar.gz: a080a4c6497edd7881a9abd20f955e2796b08c9524c246cfbbd62cc6d7a66e8d03a4978c4c8dcd544110b5e7c07365dbae89b7f8748f5916eaf95d038a08c6da

data/lib/statsd/instrument.rb

@@ -399,5 +399,6 @@ require 'statsd/instrument/backend'
 require 'statsd/instrument/environment'
 require 'statsd/instrument/helpers'
 require 'statsd/instrument/assertions'
+require 'statsd/instrument/metric_expectation'
 require 'statsd/instrument/matchers' if defined?(::RSpec)
 require 'statsd/instrument/railtie' if defined?(Rails)

data/lib/statsd/instrument/assertions.rb

@@ -31,41 +31,51 @@ module StatsD::Instrument::Assertions
     assert_statsd_call(:kv, metric_name, options, &block)
   end
 
-  private
-
-  def assert_statsd_call(metric_type, metric_name, options = {}, &block)
-    options[:times] ||= 1
+  # @private
+  def assert_statsd_calls(expected_metrics, &block)
     metrics = capture_statsd_calls(&block)
-    metrics = metrics.select { |m| m.type == metric_type && m.name == metric_name }
-    assert metrics.length > 0, "No StatsD calls for metric #{metric_name} were made."
-    assert options[:times] === metrics.length, "The amount of StatsD calls for metric #{metric_name} was unexpected. Expected #{options[:times].inspect}, found #{metrics.length}"
-
-    metrics.each do |metric|
-
-      assert within_numeric_range?(metric.sample_rate), "Unexpected sample rate type for metric #{metric_name}, must be numeric"
-      assert_equal options[:sample_rate], metric.sample_rate, "Unexpected StatsD sample rate for metric #{metric_name}" if options[:sample_rate]
-      assert_equal options[:value], metric.value, "Unexpected value submitted for StatsD metric #{metric_name}" if options[:value]
-
-      if options[:tags]
-
-        expected_tags = Set.new(StatsD::Instrument::Metric.normalize_tags(options[:tags]))
-        actual_tags = Set.new(metric.tags)
-
-        if options[:ignore_tags]
-          ignored_tags = Set.new(StatsD::Instrument::Metric.normalize_tags(options[:ignore_tags])) - expected_tags
-          actual_tags -= ignored_tags
-
-          if options[:ignore_tags].is_a?(Array)
-            actual_tags.delete_if{ |key| options[:ignore_tags].include?(key.split(":").first) }
+    matched_expected_metrics = []
+
+    expected_metrics.each do |expected_metric|
+      expected_metric_times = expected_metric.times
+      expected_metric_times_remaining = expected_metric.times
+      filtered_metrics = metrics.select { |m| m.type == expected_metric.type && m.name == expected_metric.name }
+      assert filtered_metrics.length > 0,
+        "No StatsD calls for metric #{expected_metric.name} of type #{expected_metric.type} were made."
+
+      filtered_metrics.each do |metric|
+        assert within_numeric_range?(metric.sample_rate),
+          "Unexpected sample rate type for metric #{metric.name}, must be numeric"
+        if expected_metric.matches(metric)
+          assert expected_metric_times_remaining > 0,
+            "Unexpected StatsD call; number of times this metric was expected exceeded: #{expected_metric.inspect}"
+          expected_metric_times_remaining -= 1
+          metrics.delete(metric)
+          if expected_metric_times_remaining == 0
+            matched_expected_metrics << expected_metric
           end
         end
-
-        assert_equal expected_tags, actual_tags,
-                     "Unexpected StatsD tags for metric #{metric_name}. Expected: #{expected_tags.inspect}, actual: #{actual_tags.inspect}"
       end
 
-      metric
+      assert expected_metric_times_remaining == 0,
+          "Metric expected #{expected_metric_times} times but seen"\
+          " #{expected_metric_times-expected_metric_times_remaining}"\
+          " times: #{expected_metric.inspect}"
     end
+    expected_metrics -= matched_expected_metrics
+
+    assert expected_metrics.empty?,
+      "Unexpected StatsD calls; the following metric expectations were not satisfied: #{expected_metrics.inspect}"
+  end
+
+  private
+
+  def assert_statsd_call(metric_type, metric_name, options = {}, &block)
+    options[:name] = metric_name
+    options[:type] = metric_type
+    options[:times] ||= 1
+    expected_metric = StatsD::Instrument::MetricExpectation.new(options)
+    assert_statsd_calls([expected_metric], &block)
   end
 
   def within_numeric_range?(object)

data/lib/statsd/instrument/metric_expectation.rb

@@ -0,0 +1,67 @@
+# @private
+class StatsD::Instrument::MetricExpectation
+
+  attr_accessor :times, :type, :name, :value, :sample_rate, :tags
+  attr_reader :ignore_tags
+
+  def initialize(options = {})
+    @type = options[:type] or raise ArgumentError, "Metric :type is required."
+    @name = options[:name] or raise ArgumentError, "Metric :name is required."
+    @name = StatsD.prefix ? "#{StatsD.prefix}.#{@name}" : @name unless options[:no_prefix]
+    @tags = StatsD::Instrument::Metric.normalize_tags(options[:tags])
+    @times = options[:times] or raise ArgumentError, "Metric :times is required."
+    @sample_rate = options[:sample_rate]
+    @value = options[:value]
+    @ignore_tags = StatsD::Instrument::Metric.normalize_tags(options[:ignore_tags])
+  end
+
+  def matches(actual_metric)
+    return false if sample_rate && sample_rate != actual_metric.sample_rate
+    return false if value && value != actual_metric.value
+
+    if tags
+
+      expected_tags = Set.new(tags)
+      actual_tags = Set.new(actual_metric.tags)
+
+      if ignore_tags
+        ignored_tags = Set.new(ignore_tags) - expected_tags
+        actual_tags -= ignored_tags
+
+        if ignore_tags.is_a?(Array)
+          actual_tags.delete_if{ |key| ignore_tags.include?(key.split(":").first) }
+        end
+      end
+
+      return expected_tags.subset?(actual_tags)
+    end
+    true
+  end
+
+  def default_value
+    case type
+      when :c; 1
+    end
+  end
+
+  TYPES = {
+      c:  'increment',
+      ms: 'measure',
+      g:  'gauge',
+      h:  'histogram',
+      kv: 'key/value',
+      s:  'set',
+  }
+
+  def to_s
+    str = "#{TYPES[type]} #{name}:#{value}"
+    str << " @#{sample_rate}" if sample_rate != 1.0
+    str << " " << tags.map { |t| "##{t}"}.join(' ') if tags
+    str << " times:#{times}" if times > 1
+    str
+  end
+
+  def inspect
+    "#<StatsD::Instrument::MetricExpectation #{self.to_s}>"
+  end
+end

data/lib/statsd/instrument/version.rb

@@ -1,5 +1,5 @@
 module StatsD
   module Instrument
-    VERSION = "2.1.0"
+    VERSION = "2.1.1"
   end
 end

data/test/assertions_test.rb

@@ -124,7 +124,7 @@ class AssertionsTest < Minitest::Test
       end
     end
 
-    assert_assertion_triggered do
+    assert_no_assertion_triggered do
       @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: { a: 1 }, ignore_tags: { b: 2 }) do
         StatsD.increment('counter', sample_rate: 0.5, tags: { a: 1, b: 3 })
       end
@@ -149,6 +149,102 @@ class AssertionsTest < Minitest::Test
     end
   end
 
+  def test_tags_will_match_subsets
+    assert_no_assertion_triggered do
+      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: { a: 1 }) do
+        StatsD.increment('counter', sample_rate: 0.5, tags: { a: 1, b: 2 })
+      end
+    end
+
+    assert_assertion_triggered do
+      @test_case.assert_statsd_increment('counter', sample_rate: 0.5, tags: { a: 1, b: 3 }) do
+        StatsD.increment('counter', sample_rate: 0.5, tags: { a: 1, b: 2, c: 4 })
+      end
+    end
+  end
+
+  def test_multiple_metrics_are_not_order_dependent
+    assert_no_assertion_triggered do
+      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
+      @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 2 })
+      end
+    end
+
+    assert_no_assertion_triggered do
+      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
+      @test_case.assert_statsd_calls([foo_2_metric, foo_1_metric]) do
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 2 })
+      end
+    end
+
+    assert_no_assertion_triggered do
+      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
+      @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 2 })
+      end
+    end
+
+    assert_no_assertion_triggered do
+      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
+      @test_case.assert_statsd_calls([foo_2_metric, foo_1_metric]) do
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 2 })
+      end
+    end
+
+    assert_no_assertion_triggered do
+      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
+      @test_case.assert_statsd_calls([foo_2_metric, foo_1_metric]) do
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 2 })
+        StatsD.increment('counter', tags: { foo: 1 })
+      end
+    end
+  end
+
+  def test_assert_multiple_statsd_calls
+    assert_assertion_triggered do
+      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
+      @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 2 })
+      end
+    end
+
+    assert_assertion_triggered do
+      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
+      @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 2 })
+        StatsD.increment('counter', tags: { foo: 2 })
+      end
+    end
+
+    assert_no_assertion_triggered do
+      foo_1_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 2, tags: ['foo:1'])
+      foo_2_metric = StatsD::Instrument::MetricExpectation.new(type: :c, name: 'counter', times: 1, tags: ['foo:2'])
+      @test_case.assert_statsd_calls([foo_1_metric, foo_2_metric]) do
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 1 })
+        StatsD.increment('counter', tags: { foo: 2 })
+      end
+    end
+  end
+
   def test_assert_statsd_call_with_tags
     assert_no_assertion_triggered do
       @test_case.assert_statsd_increment('counter', tags: ['a:b', 'c:d']) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statsd-instrument
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Jesse Storimer
@@ -10,90 +10,90 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-16 00:00:00.000000000 Z
+date: 2016-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A StatsD client for Ruby apps. Provides metaprogramming methods to inject
@@ -104,8 +104,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .travis.yml
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -124,6 +124,7 @@ files:
 - lib/statsd/instrument/helpers.rb
 - lib/statsd/instrument/matchers.rb
 - lib/statsd/instrument/metric.rb
+- lib/statsd/instrument/metric_expectation.rb
 - lib/statsd/instrument/railtie.rb
 - lib/statsd/instrument/version.rb
 - shipit.rubygems.yml
@@ -151,17 +152,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: A StatsD client for Ruby apps