librato-metrics 1.6.2 → 2.0.0.beta

data/spec/integration/metrics/middleware/count_requests_spec.rb

@@ -7,18 +7,18 @@ module Librato
       describe CountRequests do
         before(:all) { prep_integration_tests }
 
-        it "should count requests" do
+        it "counts requests" do
           CountRequests.reset
-          Metrics.submit :foo => 123
-          Metrics.submit :foo => 135
-          CountRequests.total_requests.should == 2
+          Metrics.submit foo: 123
+          Metrics.submit foo: 135
+          expect(CountRequests.total_requests).to eq(2)
         end
 
-        it "should be resettable" do
-          Metrics.submit :foo => 123
-          CountRequests.total_requests.should > 0
+        it "is resettable" do
+          Metrics.submit foo: 123
+          expect(CountRequests.total_requests).to be > 0
           CountRequests.reset
-          CountRequests.total_requests.should == 0
+          expect(CountRequests.total_requests).to eq(0)
         end
 
       end

data/spec/integration/metrics/queue_spec.rb

@@ -8,42 +8,42 @@ module Librato
       before(:each) { delete_all_metrics }
 
       context "with a large number of metrics" do
-        it "should submit them in multiple requests" do
+        it "submits them in multiple requests" do
           Middleware::CountRequests.reset
-          queue = Queue.new(:per_request => 3)
+          queue = Queue.new(per_request: 3)
           (1..10).each do |i|
             queue.add "gauge_#{i}" => 1
           end
           queue.submit
-          Middleware::CountRequests.total_requests.should == 4
+          expect(Middleware::CountRequests.total_requests).to eq(4)
         end
 
-        it "should persist all metrics" do
-          queue = Queue.new(:per_request => 2)
+        it "persists all metrics" do
+          queue = Queue.new(per_request: 2)
           (1..5).each do |i|
             queue.add "gauge_#{i}" => i
           end
           (1..3).each do |i|
-            queue.add "counter_#{i}" => {:type => :counter, :value => i}
+            queue.add "counter_#{i}" => {type: :counter, value: i}
           end
           queue.submit
 
-          metrics = Metrics.list
-          metrics.length.should == 8
-          counter = Metrics.get_measurements :counter_3, :count => 1
-          counter['unassigned'][0]['value'].should == 3
-          gauge = Metrics.get_measurements :gauge_5, :count => 1
-          gauge['unassigned'][0]['value'].should == 5
+          metrics = Metrics.metrics
+          expect(metrics.length).to eq(8)
+          counter = Metrics.get_measurements :counter_3, count: 1
+          expect(counter['unassigned'][0]['value']).to eq(3)
+          gauge = Metrics.get_measurements :gauge_5, count: 1
+          expect(gauge['unassigned'][0]['value']).to eq(5)
         end
 
-        it "should apply globals to each request" do
+        it "applies globals to each request" do
           source = 'yogi'
           measure_time = Time.now.to_i-3
           queue = Queue.new(
-            :per_request => 3,
-            :source => source,
-            :measure_time => measure_time,
-            :skip_measurement_times => true
+            per_request: 3,
+            source: source,
+            measure_time: measure_time,
+            skip_measurement_times: true
           )
           (1..5).each do |i|
             queue.add "gauge_#{i}" => 1
@@ -51,23 +51,23 @@ module Librato
           queue.submit
 
           # verify globals have persisted for all requests
-          gauge = Metrics.get_measurements :gauge_5, :count => 1
-          gauge[source][0]["value"].should eq(1.0)
-          gauge[source][0]["measure_time"].should eq(measure_time)
+          gauge = Metrics.get_measurements :gauge_5, count: 1
+          expect(gauge[source][0]["value"]).to eq(1.0)
+          expect(gauge[source][0]["measure_time"]).to eq(measure_time)
         end
       end
 
-      it "should respect default and individual sources" do
-        queue = Queue.new(:source => 'default')
-        queue.add :foo => 123
-        queue.add :bar => {:value => 456, :source => 'barsource'}
+      it "respects default and individual sources" do
+        queue = Queue.new(source: 'default')
+        queue.add foo: 123
+        queue.add bar: {value: 456, source: 'barsource'}
         queue.submit
 
-        foo = Metrics.get_measurements :foo, :count => 2
-        foo['default'][0]['value'].should == 123
+        foo = Metrics.get_measurements :foo, count: 2
+        expect(foo['default'][0]['value']).to eq(123)
 
-        bar = Metrics.get_measurements :bar, :count => 2
-        bar['barsource'][0]['value'].should == 456
+        bar = Metrics.get_measurements :bar, count: 2
+        expect(bar['barsource'][0]['value']).to eq(456)
       end
 
     end

data/spec/integration/metrics_spec.rb

@@ -8,67 +8,67 @@ module Librato
       before(:all) { @annotator = Metrics::Annotator.new }
       before(:each) { delete_all_annotations }
 
-      it "should create new annotation" do
+      it "creates new annotation" do
         Metrics.annotate :deployment, "deployed v68"
-        annos = @annotator.fetch(:deployment, :start_time => Time.now.to_i-60)
-        annos["events"]["unassigned"].length.should == 1
-        annos["events"]["unassigned"][0]["title"].should == 'deployed v68'
+        annos = @annotator.fetch(:deployment, start_time: Time.now.to_i-60)
+        expect(annos["events"]["unassigned"].length).to eq(1)
+        expect(annos["events"]["unassigned"][0]["title"]).to eq('deployed v68')
       end
-      it "should support sources" do
-        Metrics.annotate :deployment, 'deployed v69', :source => 'box1'
-        annos = @annotator.fetch(:deployment, :start_time => Time.now.to_i-60)
-        annos["events"]["box1"].length.should == 1
+      it "supports sources" do
+        Metrics.annotate :deployment, 'deployed v69', source: 'box1'
+        annos = @annotator.fetch(:deployment, start_time: Time.now.to_i-60)
+        expect(annos["events"]["box1"].length).to eq(1)
         first = annos["events"]["box1"][0]
-        first['title'].should == 'deployed v69'
+        expect(first['title']).to eq('deployed v69')
       end
-      it "should support start and end times" do
+      it "supports start and end times" do
         start_time = Time.now.to_i-120
         end_time = Time.now.to_i-30
-        Metrics.annotate :deployment, 'deployed v70', :start_time => start_time,
-                    :end_time => end_time
-        annos = @annotator.fetch(:deployment, :start_time => Time.now.to_i-180)
-        annos["events"]["unassigned"].length.should == 1
+        Metrics.annotate :deployment, 'deployed v70', start_time: start_time,
+                    end_time: end_time
+        annos = @annotator.fetch(:deployment, start_time: Time.now.to_i-180)
+        expect(annos["events"]["unassigned"].length).to eq(1)
         first = annos["events"]["unassigned"][0]
-        first['title'].should == 'deployed v70'
-        first['start_time'].should == start_time
-        first['end_time'].should == end_time
+        expect(first['title']).to eq('deployed v70')
+        expect(first['start_time']).to eq(start_time)
+        expect(first['end_time']).to eq(end_time)
       end
-      it "should support description" do
-        Metrics.annotate :deployment, 'deployed v71', :description => 'deployed foobar!'
-        annos = @annotator.fetch(:deployment, :start_time => Time.now.to_i-180)
-        annos["events"]["unassigned"].length.should == 1
+      it "supports description" do
+        Metrics.annotate :deployment, 'deployed v71', description: 'deployed foobar!'
+        annos = @annotator.fetch(:deployment, start_time: Time.now.to_i-180)
+        expect(annos["events"]["unassigned"].length).to eq(1)
         first = annos["events"]["unassigned"][0]
-        first['title'].should == 'deployed v71'
-        first['description'].should == 'deployed foobar!'
+        expect(first['title']).to eq('deployed v71')
+        expect(first['description']).to eq('deployed foobar!')
       end
     end
 
     describe "#delete_metrics" do
       before(:each) { delete_all_metrics }
 
-      context 'by names' do
+      context 'with names' do
 
         context "with a single argument" do
-          it "should delete named metric" do
-            Metrics.submit :foo => 123
-            Metrics.metrics(:name => :foo).should_not be_empty
+          it "deletes named metric" do
+            Metrics.submit foo: 123
+            expect(Metrics.metrics(name: :foo)).not_to be_empty
             Metrics.delete_metrics :foo
-            Metrics.metrics(:name => :foo).should be_empty
+            expect(Metrics.metrics(name: :foo)).to be_empty
           end
         end
 
         context "with multiple arguments" do
-          it "should delete named metrics" do
-            Metrics.submit :foo => 123, :bar => 345, :baz => 567
+          it "deletes named metrics" do
+            Metrics.submit foo: 123, bar: 345, baz: 567
             Metrics.delete_metrics :foo, :bar
-            Metrics.metrics(:name => :foo).should be_empty
-            Metrics.metrics(:name => :bar).should be_empty
-            Metrics.metrics(:name => :baz).should_not be_empty
+            expect(Metrics.metrics(name: :foo)).to be_empty
+            expect(Metrics.metrics(name: :bar)).to be_empty
+            expect(Metrics.metrics(name: :baz)).not_to be_empty
           end
         end
 
         context "with missing metric" do
-          it "should run cleanly" do
+          it "runs cleanly" do
             # the API currently returns success even if
             # the metric has already been deleted or is absent.
             Metrics.delete_metrics :missing
@@ -76,24 +76,24 @@ module Librato
         end
 
         context "with no arguments" do
-          it "should not make request" do
-            lambda {
+          it "does not make request" do
+            expect {
               Metrics.delete_metrics
-            }.should raise_error(Metrics::NoMetricsProvided)
+            }.to raise_error(Metrics::NoMetricsProvided)
           end
         end
 
       end
 
-      context 'by pattern' do
-        it "should filter properly" do
-          Metrics.submit :foo => 1, :foobar => 2, :foobaz => 3, :bar => 4
-          Metrics.delete_metrics :names => 'fo*', :exclude => ['foobar']
+      context 'with patterns' do
+        it "filters properly" do
+          Metrics.submit foo: 1, foobar: 2, foobaz: 3, bar: 4
+          Metrics.delete_metrics names: 'fo*', exclude: ['foobar']
 
           %w{foo foobaz}.each do |name|
-            lambda {
+            expect {
               Metrics.get_metric name
-            }.should raise_error(Librato::Metrics::NotFound)
+            }.to raise_error(Librato::Metrics::NotFound)
           end
 
           %w{foobar bar}.each do |name|
@@ -106,48 +106,48 @@ module Librato
     describe "#get_metric" do
       before(:all) do
         delete_all_metrics
-        Metrics.submit :my_counter => {:type => :counter, :value => 0, :measure_time => Time.now.to_i-60}
+        Metrics.submit my_counter: {type: :counter, value: 0, measure_time: Time.now.to_i-60}
         1.upto(2).each do |i|
           measure_time = Time.now.to_i - (5+i)
-          opts = {:measure_time => measure_time, :type => :counter}
-          Metrics.submit :my_counter => opts.merge(:value => i)
-          Metrics.submit :my_counter => opts.merge(:source => 'baz', :value => i+1)
+          opts = {measure_time: measure_time, type: :counter}
+          Metrics.submit my_counter: opts.merge(value: i)
+          Metrics.submit my_counter: opts.merge(source: 'baz', value: i+1)
         end
       end
 
       context "without arguments" do
-        it "should get metric attributes" do
+        it "gets metric attributes" do
           metric = Metrics.get_metric :my_counter
-          metric['name'].should == 'my_counter'
-          metric['type'].should == 'counter'
+          expect(metric['name']).to eq('my_counter')
+          expect(metric['type']).to eq('counter')
         end
       end
 
       context "with a start_time" do
-        it "should return entries since that time" do
+        it "returns entries since that time" do
           # 1 hr ago
-          metric = Metrics.get_metric :my_counter, :start_time => Time.now-3600
+          metric = Metrics.get_metric :my_counter, start_time: Time.now-3600
           data = metric['measurements']
-          data['unassigned'].length.should == 3
-          data['baz'].length.should == 2
+          expect(data['unassigned'].length).to eq(3)
+          expect(data['baz'].length).to eq(2)
         end
       end
 
       context "with a count limit" do
-        it "should return that number of entries per source" do
-          metric = Metrics.get_metric :my_counter, :count => 2
+        it "returns that number of entries per source" do
+          metric = Metrics.get_metric :my_counter, count: 2
           data = metric['measurements']
-          data['unassigned'].length.should == 2
-          data['baz'].length.should == 2
+          expect(data['unassigned'].length).to eq(2)
+          expect(data['baz'].length).to eq(2)
         end
       end
 
       context "with a source limit" do
-        it "should only return that source" do
-          metric = Metrics.get_metric :my_counter, :source => 'baz', :start_time => Time.now-3600
+        it "only returns that source" do
+          metric = Metrics.get_metric :my_counter, source: 'baz', start_time: Time.now-3600
           data = metric['measurements']
-          data['baz'].length.should == 2
-          data['unassigned'].should be_nil
+          expect(data['baz'].length).to eq(2)
+          expect(data['unassigned']).to be_nil
         end
       end
 
@@ -156,20 +156,20 @@ module Librato
     describe "#metrics" do
       before(:all) do
         delete_all_metrics
-        Metrics.submit :foo => 123, :bar => 345, :baz => 678, :foo_2 => 901
+        Metrics.submit foo: 123, bar: 345, baz: 678, foo_2: 901
       end
 
       context "without arguments" do
-        it "should list all metrics" do
+        it "lists all metrics" do
           metric_names = Metrics.metrics.map { |metric| metric['name'] }
-          metric_names.sort.should == %w{foo bar baz foo_2}.sort
+          expect(metric_names.sort).to eq(%w{foo bar baz foo_2}.sort)
         end
       end
 
       context "with a name argument" do
-        it "should list metrics that match" do
-          metric_names = Metrics.metrics(:name => 'foo').map { |metric| metric['name'] }
-          metric_names.sort.should == %w{foo foo_2}.sort
+        it "lists metrics that match" do
+          metric_names = Metrics.metrics(name: 'foo').map { |metric| metric['name'] }
+          expect(metric_names.sort).to eq(%w{foo foo_2}.sort)
         end
       end
 
@@ -180,18 +180,18 @@ module Librato
       context "with a gauge" do
         before(:all) do
           delete_all_metrics
-          Metrics.submit :foo => 123
+          Metrics.submit foo: 123
         end
 
-        it "should create the metrics" do
+        it "creates the metrics" do
           metric = Metrics.metrics[0]
-          metric['name'].should == 'foo'
-          metric['type'].should == 'gauge'
+          expect(metric['name']).to eq('foo')
+          expect(metric['type']).to eq('gauge')
         end
 
-        it "should store their data" do
-          data = Metrics.get_measurements :foo, :count => 1
-          data.should_not be_empty
+        it "stores their data" do
+          data = Metrics.get_measurements :foo, count: 1
+          expect(data).not_to be_empty
           data['unassigned'][0]['value'] == 123.0
         end
       end
@@ -199,31 +199,31 @@ module Librato
       context "with a counter" do
         before(:all) do
           delete_all_metrics
-          Metrics.submit :bar => {:type => :counter, :source => 'baz', :value => 456}
+          Metrics.submit bar: {type: :counter, source: 'baz', value: 456}
         end
 
-        it "should create the metrics" do
+        it "creates the metrics" do
           metric = Metrics.metrics[0]
-          metric['name'].should == 'bar'
-          metric['type'].should == 'counter'
+          expect(metric['name']).to eq('bar')
+          expect(metric['type']).to eq('counter')
         end
 
-        it "should store their data" do
-          data = Metrics.get_measurements :bar, :count => 1
-          data.should_not be_empty
+        it "stores their data" do
+          data = Metrics.get_measurements :bar, count: 1
+          expect(data).not_to be_empty
           data['baz'][0]['value'] == 456.0
         end
       end
 
-      it "should not retain errors" do
+      it "does not retain errors" do
         delete_all_metrics
-        Metrics.submit :foo => {:type => :counter, :value => 12}
-        lambda {
-          Metrics.submit :foo => 15 # submitting as gauge
-        }.should raise_error
-        lambda {
-          Metrics.submit :foo => {:type => :counter, :value => 17}
-        }.should_not raise_error
+        Metrics.submit foo: {type: :counter, value: 12}
+        expect {
+          Metrics.submit foo: 15 # submitting as gauge
+        }.to raise_error
+        expect {
+          Metrics.submit foo: {type: :counter, value: 17}
+        }.not_to raise_error
       end
 
     end
@@ -234,46 +234,46 @@ module Librato
         context "with an existing metric" do
           before do
             delete_all_metrics
-            Metrics.submit :foo => 123
+            Metrics.submit foo: 123
           end
 
-          it "should update the metric" do
-            Metrics.update_metric :foo, :display_name => "Foo Metric",
-                                        :period => 15,
-                                        :attributes => {
-                                          :display_max => 1000
+          it "updates the metric" do
+            Metrics.update_metric :foo, display_name: "Foo Metric",
+                                        period: 15,
+                                        attributes: {
+                                          display_max: 1000
                                         }
             foo = Metrics.get_metric :foo
-            foo['display_name'].should == 'Foo Metric'
-            foo['period'].should == 15
-            foo['attributes']['display_max'].should == 1000
+            expect(foo['display_name']).to eq('Foo Metric')
+            expect(foo['period']).to eq(15)
+            expect(foo['attributes']['display_max']).to eq(1000)
           end
         end
 
         context "without an existing metric" do
-          it "should create the metric if type specified" do
+          it "creates the metric if type specified" do
             delete_all_metrics
-            Metrics.update_metric :foo, :display_name => "Foo Metric",
-                                        :type => 'gauge',
-                                        :period => 15,
-                                        :attributes => {
-                                        :display_max => 1000
+            Metrics.update_metric :foo, display_name: "Foo Metric",
+                                        type: 'gauge',
+                                        period: 15,
+                                        attributes: {
+                                        display_max: 1000
                                       }
             foo = Metrics.get_metric :foo
-            foo['display_name'].should == 'Foo Metric'
-            foo['period'].should == 15
-            foo['attributes']['display_max'].should == 1000
+            expect(foo['display_name']).to eq('Foo Metric')
+            expect(foo['period']).to eq(15)
+            expect(foo['attributes']['display_max']).to eq(1000)
           end
 
-          it "should raise error if no type specified" do
+          it "raises error if no type specified" do
             delete_all_metrics
-            lambda {
-              Metrics.update_metric :foo, :display_name => "Foo Metric",
-                                          :period => 15,
-                                          :attributes => {
-                                            :display_max => 1000
+            expect {
+              Metrics.update_metric :foo, display_name: "Foo Metric",
+                                          period: 15,
+                                          attributes: {
+                                            display_max: 1000
                                           }
-            }.should raise_error
+            }.to raise_error
           end
         end
 
@@ -285,27 +285,27 @@ module Librato
           Metrics.submit 'my.1' => 1, 'my.2' => 2, 'my.3' => 3, 'my.4' => 4
         end
 
-        it "should support named list" do
+        it "supports named list" do
           names = ['my.1', 'my.3']
-          Metrics.update_metrics :names => names, :period => 60
+          Metrics.update_metrics names: names, period: 60
 
           names.each do |name|
              metric = Metrics.get_metric name
-             metric['period'].should == 60
+             expect(metric['period']).to eq(60)
            end
         end
 
-        it "should support patterns" do
-          Metrics.update_metrics :names => 'my.*', :exclude => ['my.3'],
-            :display_max => 100
+        it "supports patterns" do
+          Metrics.update_metrics names: 'my.*', exclude: ['my.3'],
+            display_max: 100
 
           %w{my.1 my.2 my.4}.each do |name|
             metric = Metrics.get_metric name
-            metric['attributes']['display_max'].should == 100
+            expect(metric['attributes']['display_max']).to eq(100)
           end
 
           excluded = Metrics.get_metric 'my.3'
-          excluded['attributes']['display_max'].should_not == 100
+          expect(excluded['attributes']['display_max']).not_to eq(100)
         end
       end
     end
@@ -316,45 +316,45 @@ module Librato
       end
 
       describe "#sources" do
-        it "should work" do
+        it "works" do
           sources = Metrics.sources
-          sources.should be_an(Array)
+          expect(sources).to be_an(Array)
           test_source = sources.detect { |s| s["name"] == "sources_api_test" }
-          test_source["display_name"].should == "Sources Api Test"
+          expect(test_source["display_name"]).to eq("Sources Api Test")
         end
 
-        it "should allow filtering by name" do
+        it "allows filtering by name" do
           sources = Metrics.sources name: 'sources_api_test'
-          sources.all? {|s| s['name'] =~ /sources_api_test/}.should be_true
+          expect(sources.all? {|s| s['name'] =~ /sources_api_test/}).to be_truthy
         end
       end
 
       describe "#get_source" do
-        it "should work" do
+        it "works" do
           test_source = Metrics.get_source("sources_api_test")
-          test_source["display_name"].should == "Sources Api Test"
+          expect(test_source["display_name"]).to eq("Sources Api Test")
         end
       end
 
       describe "#update_source" do
-        it "should update an existing source" do
+        it "updates an existing source" do
           Metrics.update_source("sources_api_test", display_name: "Updated Source Name")
 
           test_source = Metrics.get_source("sources_api_test")
-          test_source["display_name"].should == "Updated Source Name"
+          expect(test_source["display_name"]).to eq("Updated Source Name")
         end
 
-        it "should create new sources" do
+        it "creates new sources" do
           source_name = "sources_api_test_#{Time.now.to_f}"
-          lambda {
+          expect {
             no_source = Metrics.get_source(source_name)
-          }.should raise_error(Librato::Metrics::NotFound)
+          }.to raise_error(Librato::Metrics::NotFound)
 
           Metrics.update_source(source_name, display_name: "New Source")
 
           test_source = Metrics.get_source(source_name)
-          test_source.should_not be_nil
-          test_source["display_name"].should == "New Source"
+          expect(test_source).not_to be_nil
+          expect(test_source["display_name"]).to eq("New Source")
         end
       end