librato-metrics 1.6.2 → 2.0.0.beta

data/spec/spec_helper.rb

@@ -11,6 +11,11 @@ require 'librato/metrics'
 
 RSpec.configure do |config|
 
+  # only accept expect syntax instead of should
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
   # purge all metrics from test account
   def delete_all_metrics
     connection = Librato::Metrics.client.connection
@@ -65,20 +70,11 @@ RSpec.configure do |config|
 
 end
 
-# Ex: 'foobar'.should start_with('foo') #=> true
-#
-RSpec::Matchers.define :start_with do |start_string|
-  match do |string|
-    start_length = start_string.length
-    string[0..start_length-1] == start_string
-  end
-end
-
 # Compares hashes of arrays by converting the arrays to
 # sets before comparision
 #
 # @example
-#   {:foo => [1,3,2]}.should equal_unordered({:foo => [1,2,3]})
+#   {foo: [1,3,2]}.should equal_unordered({foo: [1,2,3]})
 RSpec::Matchers.define :equal_unordered do |result|
   result.each do |key, value|
     result[key] = value.to_set if value.respond_to?(:to_set)

data/spec/unit/metrics/aggregator_spec.rb

@@ -6,174 +6,174 @@ module Librato
 
       before(:all) do
         @time = 1354720160 #Time.now.to_i
-        Aggregator.any_instance.stub(:epoch_time).and_return(@time)
+        allow_any_instance_of(Aggregator).to receive(:epoch_time).and_return(@time)
       end
 
       describe "initialization" do
         context "with specified client" do
-          it "should set to client" do
+          it "sets to client" do
             barney = Client.new
-            a = Aggregator.new(:client => barney)
-            a.client.should be barney
+            a = Aggregator.new(client: barney)
+            expect(a.client).to eq(barney)
           end
         end
 
         context "without specified client" do
-          it "should use Librato::Metrics client" do
+          it "uses Librato::Metrics client" do
             a = Aggregator.new
-            a.client.should be Librato::Metrics.client
+            expect(a.client).to eq(Librato::Metrics.client)
           end
         end
 
         context "with specified source" do
-          it "should set to source" do
-            a = Aggregator.new(:source => 'rubble')
-            a.source.should == 'rubble'
+          it "sets to source" do
+            a = Aggregator.new(source: 'rubble')
+            expect(a.source).to eq('rubble')
           end
         end
 
         context "without specified source" do
-          it "should not have a source" do
+          it "does not have a source" do
             a = Aggregator.new
-            a.source.should be_nil
+            expect(a.source).to be_nil
           end
         end
       end
 
       describe "#add" do
-        it "should allow chaining" do
-          subject.add(:foo => 1234).should == subject
+        it "allows chaining" do
+          expect(subject.add(foo: 1234)).to eq(subject)
         end
 
         context "with single hash argument" do
-          it "should record a single aggregate" do
-            subject.add :foo => 3000
-            expected = { #:measure_time => @time, TODO: support specific time
-                :gauges => [
-                { :name => 'foo',
-                  :count => 1,
-                  :sum => 3000.0,
-                  :min => 3000.0,
-                  :max => 3000.0}
+          it "records a single aggregate" do
+            subject.add foo: 3000
+            expected = { #measure_time: @time, TODO: support specific time
+                gauges: [
+                { name: 'foo',
+                  count: 1,
+                  sum: 3000.0,
+                  min: 3000.0,
+                  max: 3000.0}
                 ]
             }
-            subject.queued.should equal_unordered(expected)
+            expect(subject.queued).to equal_unordered(expected)
           end
 
-          it "should aggregate multiple measurements" do
-            subject.add :foo => 1
-            subject.add :foo => 2
-            subject.add :foo => 3
-            subject.add :foo => 4
-            subject.add :foo => 5
-            expected = { :gauges => [
-                { :name => 'foo',
-                  :count => 5,
-                  :sum => 15.0,
-                  :min => 1.0,
-                  :max => 5.0}
+          it "aggregates multiple measurements" do
+            subject.add foo: 1
+            subject.add foo: 2
+            subject.add foo: 3
+            subject.add foo: 4
+            subject.add foo: 5
+            expected = { gauges: [
+                { name: 'foo',
+                  count: 5,
+                  sum: 15.0,
+                  min: 1.0,
+                  max: 5.0}
                 ]
             }
-            subject.queued.should equal_unordered(expected)
+            expect(subject.queued).to equal_unordered(expected)
           end
 
-          it "should respect source argument" do
-            subject.add :foo => {:source => 'alpha', :value => 1}
-            subject.add :foo => 5
-            subject.add :foo => {:source => :alpha, :value => 6}
-            subject.add :foo => 10
-            expected = { :gauges => [
-              { :name => 'foo', :source => 'alpha', :count => 2,
-                :sum => 7.0, :min => 1.0, :max => 6.0 },
-              { :name => 'foo', :count => 2,
-                :sum => 15.0, :min => 5.0, :max => 10.0 }
+          it "respects source argument" do
+            subject.add foo: {source: 'alpha', value: 1}
+            subject.add foo: 5
+            subject.add foo: {source: :alpha, value: 6}
+            subject.add foo: 10
+            expected = { gauges: [
+              { name: 'foo', source: 'alpha', count: 2,
+                sum: 7.0, min: 1.0, max: 6.0 },
+              { name: 'foo', count: 2,
+                sum: 15.0, min: 5.0, max: 10.0 }
             ]}
-            subject.queued.should equal_unordered(expected)
+            expect(subject.queued).to equal_unordered(expected)
           end
 
           context "with a prefix set" do
-            it "should auto-prepend names" do
-              subject = Aggregator.new(:prefix => 'foo')
-              subject.add :bar => 1
-              subject.add :bar => 12
-              expected = {:gauges => [
-                { :name =>'foo.bar',
-                  :count => 2,
-                  :sum => 13.0,
-                  :min => 1.0,
-                  :max => 12.0
+            it "auto-prepends names" do
+              subject = Aggregator.new(prefix: 'foo')
+              subject.add bar: 1
+              subject.add bar: 12
+              expected = {gauges: [
+                { name:'foo.bar',
+                  count: 2,
+                  sum: 13.0,
+                  min: 1.0,
+                  max: 12.0
                   }
                 ]
               }
-              subject.queued.should equal_unordered(expected)
+              expect(subject.queued).to equal_unordered(expected)
             end
           end
         end
 
         context "with multiple hash arguments" do
-          it "should record a single aggregate" do
-            subject.add :foo => 3000
-            subject.add :bar => 30
+          it "records a single aggregate" do
+            subject.add foo: 3000
+            subject.add bar: 30
             expected = {
-              #:measure_time => @time, TODO: support specific time
-              :gauges => [
-                { :name => 'foo',
-                  :count => 1,
-                  :sum => 3000.0,
-                  :min => 3000.0,
-                  :max => 3000.0},
-                { :name => 'bar',
-                  :count => 1,
-                  :sum => 30.0,
-                  :min => 30.0,
-                  :max => 30.0},
+              #measure_time: @time, TODO: support specific time
+              gauges: [
+                { name: 'foo',
+                  count: 1,
+                  sum: 3000.0,
+                  min: 3000.0,
+                  max: 3000.0},
+                { name: 'bar',
+                  count: 1,
+                  sum: 30.0,
+                  min: 30.0,
+                  max: 30.0},
                 ]
             }
-            subject.queued.should equal_unordered(expected)
+            expect(subject.queued).to equal_unordered(expected)
           end
 
-          it "should aggregate multiple measurements" do
-            subject.add :foo => 1
-            subject.add :foo => 2
-            subject.add :foo => 3
-            subject.add :foo => 4
-            subject.add :foo => 5
-
-            subject.add :bar => 6
-            subject.add :bar => 7
-            subject.add :bar => 8
-            subject.add :bar => 9
-            subject.add :bar => 10
-            expected = { :gauges => [
-                { :name => 'foo',
-                  :count => 5,
-                  :sum => 15.0,
-                  :min => 1.0,
-                  :max => 5.0},
-                { :name => 'bar',
-                  :count => 5,
-                  :sum => 40.0,
-                  :min => 6.0,
-                  :max => 10.0}
+          it "aggregates multiple measurements" do
+            subject.add foo: 1
+            subject.add foo: 2
+            subject.add foo: 3
+            subject.add foo: 4
+            subject.add foo: 5
+
+            subject.add bar: 6
+            subject.add bar: 7
+            subject.add bar: 8
+            subject.add bar: 9
+            subject.add bar: 10
+            expected = { gauges: [
+                { name: 'foo',
+                  count: 5,
+                  sum: 15.0,
+                  min: 1.0,
+                  max: 5.0},
+                { name: 'bar',
+                  count: 5,
+                  sum: 40.0,
+                  min: 6.0,
+                  max: 10.0}
                 ]
             }
-            subject.queued.should equal_unordered(expected)
+            expect(subject.queued).to equal_unordered(expected)
           end
         end
       end
 
       describe "#queued" do
-        it "should include global source if set" do
-          a = Aggregator.new(:source => 'blah')
-          a.add :foo => 12
-          a.queued[:source].should == 'blah'
+        it "includes global source if set" do
+          a = Aggregator.new(source: 'blah')
+          a.add foo: 12
+          expect(a.queued[:source]).to eq('blah')
         end
 
-        it "should include global measure_time if set" do
+        it "includes global measure_time if set" do
           measure_time = (Time.now-1000).to_i
-          a = Aggregator.new(:measure_time => measure_time)
-          a.add :foo => 12
-          a.queued[:measure_time].should == measure_time
+          a = Aggregator.new(measure_time: measure_time)
+          a.add foo: 12
+          expect(a.queued[:measure_time]).to eq(measure_time)
         end
       end
 
@@ -184,44 +184,44 @@ module Librato
         end
 
         context "when successful" do
-          it "should flush queued metrics and return true" do
-            subject.add :steps => 2042, :distance => 1234
-            subject.submit.should be_true
-            subject.empty?.should be_true
+          it "flushes queued metrics and return true" do
+            subject.add steps: 2042, distance: 1234
+            expect(subject.submit).to be true
+            expect(subject.empty?).to be true
           end
         end
 
         context "when failed" do
-          it "should preserve queue and return false" do
-            subject.add :steps => 2042, :distance => 1234
+          it "preserves queue and return false" do
+            subject.add steps: 2042, distance: 1234
             subject.persister.return_value(false)
-            subject.submit.should be_false
-            subject.empty?.should be_false
+            expect(subject.submit).to be false
+            expect(subject.empty?).to be false
           end
         end
       end
 
       describe "#time" do
         context "with metric name only" do
-          it "should queue metric with timed value" do
+          it "queues metric with timed value" do
             1.upto(5) do
               subject.time :sleeping do
                 sleep 0.1
               end
             end
             queued = subject.queued[:gauges][0]
-            queued[:name].should == 'sleeping'
-            queued[:count].should be 5
-            queued[:sum].should be >= 500.0
-            queued[:sum].should be_within(150).of(500)
+            expect(queued[:name]).to eq('sleeping')
+            expect(queued[:count]).to eq(5)
+            expect(queued[:sum]).to be >= 500.0
+            expect(queued[:sum]).to be_within(150).of(500)
           end
 
-          it "should return the result of the block" do
+          it "returns the result of the block" do
             result = subject.time :returning do
               :hi_there
             end
 
-            result.should == :hi_there
+            expect(result).to eq(:hi_there)
           end
         end
       end
@@ -233,18 +233,18 @@ module Librato
           client
         end
 
-        it "should not submit immediately" do
-          timed_agg = Aggregator.new(:client => client, :autosubmit_interval => 1)
-          timed_agg.add :foo => 1
-          timed_agg.persister.persisted.should be_nil # nothing sent
+        it "does not submit immediately" do
+          timed_agg = Aggregator.new(client: client, autosubmit_interval: 1)
+          timed_agg.add foo: 1
+          expect(timed_agg.persister.persisted).to be_nil # nothing sent
         end
 
-        it "should submit after interval" do
-          timed_agg = Aggregator.new(:client => client, :autosubmit_interval => 1)
-          timed_agg.add :foo => 1
+        it "submits after interval" do
+          timed_agg = Aggregator.new(client: client, autosubmit_interval: 1)
+          timed_agg.add foo: 1
           sleep 1
-          timed_agg.add :foo => 2
-          timed_agg.persister.persisted.should_not be_nil # sent
+          timed_agg.add foo: 2
+          expect(timed_agg.persister.persisted).not_to be_nil # sent
         end
       end
 

data/spec/unit/metrics/client_spec.rb

@@ -7,43 +7,43 @@ module Librato
 
       describe "#agent_identifier" do
         context "when given a single string argument" do
-          it "should set agent_identifier" do
+          it "sets agent_identifier" do
             subject.agent_identifier 'mycollector/0.1 (dev_id:foo)'
-            subject.agent_identifier.should == 'mycollector/0.1 (dev_id:foo)'
+            expect(subject.agent_identifier).to eq('mycollector/0.1 (dev_id:foo)')
           end
         end
 
         context "when given three arguments" do
-          it "should compose an agent string" do
+          it "composes an agent string" do
             subject.agent_identifier('test_app', '0.5', 'foobar')
-            subject.agent_identifier.should == 'test_app/0.5 (dev_id:foobar)'
+            expect(subject.agent_identifier).to eq('test_app/0.5 (dev_id:foobar)')
           end
 
           context "when given an empty string" do
-            it "should set to empty" do
+            it "sets to empty" do
               subject.agent_identifier ''
-              subject.agent_identifier.should == ''
+              expect(subject.agent_identifier).to be_empty
             end
           end
         end
 
         context "when given two arguments" do
-          it "should raise error" do
-            lambda { subject.agent_identifier('test_app', '0.5') }.should raise_error(ArgumentError)
+          it "raises error" do
+            expect { subject.agent_identifier('test_app', '0.5') }.to raise_error(ArgumentError)
           end
         end
       end
 
       describe "#api_endpoint" do
-        it "should default to metrics" do
-          subject.api_endpoint.should == 'https://metrics-api.librato.com'
+        it "defaults to metrics" do
+          expect(subject.api_endpoint).to eq('https://metrics-api.librato.com')
         end
       end
 
       describe "#api_endpoint=" do
-        it "should set api_endpoint" do
+        it "sets api_endpoint" do
           subject.api_endpoint = 'http://test.com/'
-          subject.api_endpoint.should == 'http://test.com/'
+          expect(subject.api_endpoint).to eq('http://test.com/')
         end
 
         # TODO:
@@ -53,71 +53,71 @@ module Librato
 
       describe "#authenticate" do
         context "when given two arguments" do
-          it "should store them as email and api_key" do
+          it "stores them as email and api_key" do
             subject.authenticate 'test@librato.com', 'api_key'
-            subject.email.should == 'test@librato.com'
-            subject.api_key.should == 'api_key'
+            expect(subject.email).to eq('test@librato.com')
+            expect(subject.api_key).to eq('api_key')
           end
         end
       end
 
       describe "#connection" do
-        it "should raise exception without authentication" do
+        it "raises exception without authentication" do
           subject.flush_authentication
-          lambda{ subject.connection }.should raise_error(Librato::Metrics::CredentialsMissing)
+          expect { subject.connection }.to raise_error(Librato::Metrics::CredentialsMissing)
         end
       end
-      
+
       describe "#faraday_adapter" do
-        it "should default to Metrics default adapter" do
+        it "defaults to Metrics default adapter" do
           Metrics.faraday_adapter = :typhoeus
-          Client.new.faraday_adapter.should == Metrics.faraday_adapter
+          expect(Client.new.faraday_adapter).to eq(Metrics.faraday_adapter)
           Metrics.faraday_adapter = nil
         end
       end
-   
+
       describe "#faraday_adapter=" do
-        it "should allow setting of faraday adapter" do
+        it "allows setting of faraday adapter" do
           subject.faraday_adapter = :excon
-          subject.faraday_adapter.should == :excon
+          expect(subject.faraday_adapter).to eq(:excon)
           subject.faraday_adapter = :patron
-          subject.faraday_adapter.should == :patron
+          expect(subject.faraday_adapter).to eq(:patron)
         end
       end
 
       describe "#new_queue" do
-        it "should return a new queue with client set" do
+        it "returns a new queue with client set" do
           queue = subject.new_queue
-          queue.client.should be subject
+          expect(queue.client).to eq(subject)
         end
       end
 
       describe "#persistence" do
-        it "should default to direct" do
+        it "defaults to direct" do
           subject.send(:flush_persistence)
-          subject.persistence.should == :direct
+          expect(subject.persistence).to eq(:direct)
         end
 
-        it "should allow configuration of persistence method" do
+        it "allows configuration of persistence method" do
           subject.persistence = :fake
-          subject.persistence.should == :fake
+          expect(subject.persistence).to eq(:fake)
         end
       end
 
       describe "#submit" do
-        it "should persist metrics immediately" do
+        it "persists metrics immediately" do
           subject.authenticate 'me@librato.com', 'foo'
           subject.persistence = :test
-          subject.submit(:foo => 123).should eql true
-          subject.persister.persisted.should == {:gauges => [{:name => 'foo', :value => 123}]}
+          expect(subject.submit(foo: 123)).to be true
+          expect(subject.persister.persisted).to eq({gauges: [{name: 'foo', value: 123}]})
         end
 
-        it "should tolerate muliple metrics" do
+        it "tolerates muliple metrics" do
           subject.authenticate 'me@librato.com', 'foo'
           subject.persistence = :test
-          lambda{ subject.submit :foo => 123, :bar => 456 }.should_not raise_error
-          expected = {:gauges => [{:name => 'foo', :value => 123}, {:name => 'bar', :value => 456}]}
-          subject.persister.persisted.should equal_unordered(expected)
+          expect { subject.submit foo: 123, bar: 456 }.not_to raise_error
+          expected = {gauges: [{name: 'foo', value: 123}, {name: 'bar', value: 456}]}
+          expect(subject.persister.persisted).to equal_unordered(expected)
         end
       end