librato-metrics 1.6.2 → 2.0.0.beta

data/spec/unit/metrics/connection_spec.rb

@@ -7,42 +7,42 @@ module Librato
 
       describe "#api_endpoint" do
         context "when not provided" do
-          it "should be default" do
-            subject.api_endpoint.should == 'https://metrics-api.librato.com'
+          it "uses default" do
+            expect(subject.api_endpoint).to eq('https://metrics-api.librato.com')
           end
         end
 
         context "when provided" do
-          it "should be respected" do
-            connection = Connection.new(:api_endpoint => 'http://test.com/')
-            connection.api_endpoint.should == 'http://test.com/'
+          it "uses provided endpoint" do
+            connection = Connection.new(api_endpoint: 'http://test.com/')
+            expect(connection.api_endpoint).to eq('http://test.com/')
           end
         end
       end
 
       describe "#user_agent" do
         context "without an agent_identifier" do
-          it "should render standard string" do
-            connection = Connection.new(:client => Client.new)
-            connection.user_agent.should start_with('librato-metrics')
+          it "renders standard string" do
+            connection = Connection.new(client: Client.new)
+            expect(connection.user_agent).to start_with('librato-metrics')
           end
         end
 
         context "with an agent_identifier" do
-          it "should render agent_identifier first" do
+          it "renders agent_identifier first" do
             client = Client.new
             client.agent_identifier('foo', '0.5', 'bar')
-            connection = Connection.new(:client => client)
-            connection.user_agent.should start_with('foo/0.5')
+            connection = Connection.new(client: client)
+            expect(connection.user_agent).to start_with('foo/0.5')
           end
         end
 
         context "with a custom user agent set" do
-          it "should use custom user agent" do
+          it "uses custom user agent" do
             client = Client.new
             client.custom_user_agent = 'foo agent'
-            connection = Connection.new(:client => client)
-            connection.user_agent.should == 'foo agent'
+            connection = Connection.new(client: client)
+            expect(connection.user_agent).to eq('foo agent')
           end
         end
 
@@ -51,8 +51,8 @@ module Librato
 
       describe "network operations" do
         context "when missing client" do
-          it "should raise exception" do
-            lambda { subject.get 'metrics' }.should raise_error(NoClientProvided)
+          it "raises exception" do
+            expect { subject.get 'metrics' }.to raise_error(NoClientProvided)
           end
         end
 
@@ -64,32 +64,32 @@ module Librato
         end
 
         context "with 400 class errors" do
-          it "should not retry" do
+          it "does not retry" do
             Middleware::CountRequests.reset
             with_rackup('status.ru') do
-              lambda {
+              expect {
                 client.connection.transport.post 'not_found'
-              }.should raise_error(NotFound)
-              lambda {
+              }.to raise_error(NotFound)
+              expect {
                 client.connection.transport.post 'forbidden'
-              }.should raise_error(ClientError)
+              }.to raise_error(ClientError)
             end
-            Middleware::CountRequests.total_requests.should == 2 # no retries
+            expect(Middleware::CountRequests.total_requests).to eq(2) # no retries
           end
         end
 
         context "with 500 class errors" do
-          it "should retry" do
+          it "retries" do
             Middleware::CountRequests.reset
             with_rackup('status.ru') do
-              lambda {
+              expect {
                 client.connection.transport.post 'service_unavailable'
-              }.should raise_error(ServerError)
+              }.to raise_error(ServerError)
             end
-            Middleware::CountRequests.total_requests.should == 4 # did retries
+            expect(Middleware::CountRequests.total_requests).to eq(4) # did retries
           end
 
-          it "should send consistent body with retries" do
+          it "sends consistent body with retries" do
             Middleware::CountRequests.reset
             status = 0
             begin
@@ -102,12 +102,12 @@ module Librato
             rescue Exception => error
               status = error.response[:status].to_i
             end
-            Middleware::CountRequests.total_requests.should == 4 # did retries
-            status.should be(502)#, 'body should be sent for retries'
+            expect(Middleware::CountRequests.total_requests).to eq(4) # did retries
+            expect(status).to eq(502) # body is sent for retries
           end
         end
       end
     end
 
   end
-end
+end

data/spec/unit/metrics/queue/autosubmission_spec.rb

@@ -8,50 +8,50 @@ module Librato
       let(:client) { Client.new.tap{ |c| c.persistence = :test } }
 
       context "with an autosubmit count" do
-        it "should submit when the max is reached" do
-          vol_queue = Queue.new(:client => client, :autosubmit_count => 2)
-          vol_queue.add :foo => 1
-          vol_queue.add :bar => 2
-          vol_queue.persister.persisted.should_not be_nil # sent
+        it "submits when the max is reached" do
+          vol_queue = Queue.new(client: client, autosubmit_count: 2)
+          vol_queue.add foo: 1
+          vol_queue.add bar: 2
+          expect(vol_queue.persister.persisted).not_to be_nil # sent
         end
 
-        it "should not submit if the max has not been reached" do
-          vol_queue = Queue.new(:client => client, :autosubmit_count => 5)
-          vol_queue.add :foo => 1
-          vol_queue.add :bar => 2
-          vol_queue.persister.persisted.should be_nil # nothing sent
+        it "does not submit if the max has not been reached" do
+          vol_queue = Queue.new(client: client, autosubmit_count: 5)
+          vol_queue.add foo: 1
+          vol_queue.add bar: 2
+          expect(vol_queue.persister.persisted).to be_nil # nothing sent
         end
 
-        it 'should submit when merging' do
-          queue = Queue.new(:client => client, :autosubmit_count => 5)
+        it 'submits when merging' do
+          queue = Queue.new(client: client, autosubmit_count: 5)
           (1..3).each {|i| queue.add "metric_#{i}" => 1 }
 
-          to_merge = Queue.new(:client => client)
+          to_merge = Queue.new(client: client)
           (1..5).each {|i| to_merge.add "metric_#{i}" => 1 }
 
           queue.merge!(to_merge)
 
-          queue.persister.persisted[:gauges].length.should == 8
-          queue.queued.should be_empty
+          expect(queue.persister.persisted[:gauges].length).to eq(8)
+          expect(queue.queued).to be_empty
         end
       end
 
       context "with an autosubmit interval" do
-        it "should not submit immediately" do
-          vol_queue = Queue.new(:client => client, :autosubmit_interval => 1)
-          vol_queue.add :foo => 1
-          vol_queue.persister.persisted.should be_nil # nothing sent
+        it "does not submit immediately" do
+          vol_queue = Queue.new(client: client, autosubmit_interval: 1)
+          vol_queue.add foo: 1
+          expect(vol_queue.persister.persisted).to be_nil # nothing sent
         end
 
-        it "should submit after interval" do
-          vol_queue = Queue.new(:client => client, :autosubmit_interval => 1)
-          vol_queue.add :foo => 1
+        it "submits after interval" do
+          vol_queue = Queue.new(client: client, autosubmit_interval: 1)
+          vol_queue.add foo: 1
           sleep 1
-          vol_queue.add :foo => 2
-          vol_queue.persister.persisted.should_not be_nil # sent
+          vol_queue.add foo: 2
+          expect(vol_queue.persister.persisted).not_to be_nil # sent
         end
       end
 
     end
   end
-end
+end

data/spec/unit/metrics/queue_spec.rb

@@ -7,170 +7,170 @@ module Librato
 
       before(:each) do
         @time = (Time.now.to_i - 1*60)
-        Queue.any_instance.stub(:epoch_time).and_return(@time)
+        allow_any_instance_of(Queue).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
-            queue = Queue.new(:client => barney)
-            queue.client.should be barney
+            queue = Queue.new(client: barney)
+            expect(queue.client).to eq(barney)
           end
         end
 
         context "without specified client" do
-          it "should use Librato::Metrics client" do
+          it "uses Librato::Metrics client" do
             queue = Queue.new
-            queue.client.should be Librato::Metrics.client
+            expect(queue.client).to eq(Librato::Metrics.client)
           end
         end
       end
 
       describe "#add" do
-        it "should allow chaining" do
-          subject.add(:foo => 123).should == subject
+        it "allows chaining" do
+          expect(subject.add(foo: 123)).to eq(subject)
         end
 
         context "with single hash argument" do
-          it "should record a key-value gauge" do
-            expected = {:gauges => [{:name => 'foo', :value => 3000, :measure_time => @time}]}
-            subject.add :foo => 3000
-            subject.queued.should equal_unordered(expected)
+          it "records a key-value gauge" do
+            expected = {gauges: [{name: 'foo', value: 3000, measure_time: @time}]}
+            subject.add foo: 3000
+            expect(subject.queued).to equal_unordered(expected)
           end
         end
 
         context "with specified metric type" do
-          it "should record counters" do
-            subject.add :total_visits => {:type => :counter, :value => 4000}
-            expected = {:counters => [{:name => 'total_visits', :value => 4000, :measure_time => @time}]}
-            subject.queued.should equal_unordered(expected)
+          it "records counters" do
+            subject.add total_visits: {type: :counter, value: 4000}
+            expected = {counters: [{name: 'total_visits', value: 4000, measure_time: @time}]}
+            expect(subject.queued).to equal_unordered(expected)
           end
 
-          it "should record gauges" do
-            subject.add :temperature => {:type => :gauge, :value => 34}
-            expected = {:gauges => [{:name => 'temperature', :value => 34, :measure_time => @time}]}
-            subject.queued.should equal_unordered(expected)
+          it "records gauges" do
+            subject.add temperature: {type: :gauge, value: 34}
+            expected = {gauges: [{name: 'temperature', value: 34, measure_time: @time}]}
+            expect(subject.queued).to equal_unordered(expected)
           end
 
-          it "should accept type key as string or a symbol" do
-            subject.add :total_visits => {"type" => "counter", :value => 4000}
-            expected = {:counters => [{:name => 'total_visits', :value => 4000, :measure_time => @time}]}
-            subject.queued.should equal_unordered(expected)
+          it "accepts type key as string or a symbol" do
+            subject.add total_visits: {type: "counter", value: 4000}
+            expected = {counters: [{name: 'total_visits', value: 4000, measure_time: @time}]}
+            expect(subject.queued).to equal_unordered(expected)
           end
         end
 
         context "with extra attributes" do
-          it "should record" do
+          it "records" do
             measure_time = Time.now
-            subject.add :disk_use => {:value => 35.4, :period => 2,
-              :description => 'current disk utilization', :measure_time => measure_time,
-              :source => 'db2'}
-            expected = {:gauges => [{:value => 35.4, :name => 'disk_use', :period => 2,
-              :description => 'current disk utilization', :measure_time => measure_time.to_i,
-              :source => 'db2'}]}
-            subject.queued.should equal_unordered(expected)
+            subject.add disk_use: {value: 35.4, period: 2,
+              description: 'current disk utilization', measure_time: measure_time,
+              source: 'db2'}
+            expected = {gauges: [{value: 35.4, name: 'disk_use', period: 2,
+              description: 'current disk utilization', measure_time: measure_time.to_i,
+              source: 'db2'}]}
+            expect(subject.queued).to equal_unordered(expected)
           end
 
           context "with a prefix set" do
-            it "should auto-prepend names" do
-              subject = Queue.new(:prefix => 'foo')
-              subject.add :bar => 1
-              subject.add :baz => {:value => 23}
-              expected = {:gauges => [{:name =>'foo.bar', :value => 1, :measure_time => @time},
-                                      {:name => 'foo.baz', :value => 23, :measure_time => @time}]}
-              subject.queued.should equal_unordered(expected)
+            it "auto-prepends names" do
+              subject = Queue.new(prefix: 'foo')
+              subject.add bar: 1
+              subject.add baz: {value: 23}
+              expected = {gauges: [{name:'foo.bar', value: 1, measure_time: @time},
+                                      {name: 'foo.baz', value: 23, measure_time: @time}]}
+              expect(subject.queued).to equal_unordered(expected)
             end
           end
 
           context "when dynamically changing prefix" do
-            it "should auto-append names" do
-              subject.add :bar => 12
+            it "auto-appends names" do
+              subject.add bar: 12
               subject.prefix = 'foo' # with string
-              subject.add :bar => 23
+              subject.add bar: 23
               subject.prefix = :foo  # with symbol
-              subject.add :bar => 34
+              subject.add bar: 34
               subject.prefix = nil   # unsetting
-              subject.add :bar => 45
-              expected = {:gauges => [
-                {:name => 'bar', :value => 12, :measure_time => @time},
-                {:name => 'foo.bar', :value => 23, :measure_time => @time},
-                {:name => 'foo.bar', :value => 34, :measure_time => @time},
-                {:name => 'bar', :value => 45, :measure_time => @time}]}
-              subject.queued.should equal_unordered(expected)
+              subject.add bar: 45
+              expected = {gauges: [
+                {name: 'bar', value: 12, measure_time: @time},
+                {name: 'foo.bar', value: 23, measure_time: @time},
+                {name: 'foo.bar', value: 34, measure_time: @time},
+                {name: 'bar', value: 45, measure_time: @time}]}
+              expect(subject.queued).to equal_unordered(expected)
             end
           end
         end
 
         context "with multiple metrics" do
-          it "should record" do
-            subject.add :foo => 123, :bar => 345, :baz => 567
-            expected = {:gauges=>[{:name=>"foo", :value=>123, :measure_time => @time},
-                                  {:name=>"bar", :value=>345, :measure_time => @time},
-                                  {:name=>"baz", :value=>567, :measure_time => @time}]}
-            subject.queued.should equal_unordered(expected)
+          it "records" do
+            subject.add foo: 123, bar: 345, baz: 567
+            expected = {gauges:[{name:"foo", value:123, measure_time: @time},
+                                  {name:"bar", value:345, measure_time: @time},
+                                  {name:"baz", value:567, measure_time: @time}]}
+            expect(subject.queued).to equal_unordered(expected)
           end
         end
 
         context "with a measure_time" do
-          it "should accept time objects" do
+          it "accepts time objects" do
             time = Time.now-5
-            subject.add :foo => {:measure_time => time, :value => 123}
-            subject.queued[:gauges][0][:measure_time].should == time.to_i
+            subject.add foo: {measure_time: time, value: 123}
+            expect(subject.queued[:gauges][0][:measure_time]).to eq(time.to_i)
           end
 
-          it "should accept integers" do
+          it "accepts integers" do
             time = @time.to_i
-            subject.add :foo => {:measure_time => time, :value => 123}
-            subject.queued[:gauges][0][:measure_time].should == time
+            subject.add foo: {measure_time: time, value: 123}
+            expect(subject.queued[:gauges][0][:measure_time]).to eq(time)
           end
 
-          it "should accept strings" do
+          it "accepts strings" do
             time = @time.to_s
-            subject.add :foo => {:measure_time => time, :value => 123}
-            subject.queued[:gauges][0][:measure_time].should == time.to_i
+            subject.add foo: {measure_time: time, value: 123}
+            expect(subject.queued[:gauges][0][:measure_time]).to eq(time.to_i)
           end
 
-          it "should raise exception in invalid time" do
-            lambda {
-              subject.add :foo => {:measure_time => '12', :value => 123}
-            }.should raise_error(InvalidMeasureTime)
+          it "raises exception in invalid time" do
+            expect {
+              subject.add foo: {measure_time: '12', value: 123}
+            }.to raise_error(InvalidMeasureTime)
           end
         end
       end
 
       describe "#counters" do
-        it "should return currently queued counters" do
-          subject.add :transactions => {:type => :counter, :value => 12345},
-                      :register_cents => {:type => :gauge, :value => 211101}
-          subject.counters.should eql [{:name => 'transactions', :value => 12345, :measure_time => @time}]
+        it "returns currently queued counters" do
+          subject.add transactions: {type: :counter, value: 12345},
+                      register_cents: {type: :gauge, value: 211101}
+          expect(subject.counters).to eq([{name: 'transactions', value: 12345, measure_time: @time}])
         end
 
-        it "should return [] when no queued counters" do
-          subject.counters.should eql []
+        it "returns [] when no queued counters" do
+          expect(subject.counters).to be_empty
         end
       end
 
       describe "#empty?" do
-        it "should return true when nothing queued" do
-          subject.empty?.should be_true
+        it "returns true when nothing queued" do
+          expect(subject.empty?).to be true
         end
 
-        it "should return false with queued items" do
-          subject.add :foo => {:type => :gauge, :value => 121212}
-          subject.empty?.should be_false
+        it "returns false with queued items" do
+          subject.add foo: {type: :gauge, value: 121212}
+          expect(subject.empty?).to be false
         end
       end
 
       describe "#gauges" do
-        it "should return currently queued gauges" do
-          subject.add :transactions => {:type => :counter, :value => 12345},
-                        :register_cents => {:type => :gauge, :value => 211101}
-          subject.gauges.should eql [{:name => 'register_cents', :value => 211101, :measure_time => @time}]
+        it "returns currently queued gauges" do
+          subject.add transactions: {type: :counter, value: 12345},
+                        register_cents: {type: :gauge, value: 211101}
+          expect(subject.gauges).to eq([{name: 'register_cents', value: 211101, measure_time: @time}])
         end
 
-        it "should return [] when no queued gauges" do
-          subject.gauges.should eql []
+        it "returns [] when no queued gauges" do
+          expect(subject.gauges).to be_empty
         end
       end
 
@@ -180,144 +180,143 @@ module Librato
           Librato::Metrics.persistence = :test
         end
 
-        it "should default to nil" do
-          subject.last_submit_time.should be_nil
+        it "defaults to nil" do
+          expect(subject.last_submit_time).to be_nil
         end
 
-        it "should store last submission time" do
+        it "stores last submission time" do
           prior = Time.now
-          subject.add :foo => 123
+          subject.add foo: 123
           subject.submit
-          subject.last_submit_time.should >= prior
+          expect(subject.last_submit_time).to be >= prior
         end
       end
 
       describe "#merge!" do
         context "with another queue" do
-          it "should merge gauges" do
+          it "merges gauges" do
             q1 = Queue.new
-            q1.add :foo => 123, :bar => 456
+            q1.add foo: 123, bar: 456
             q2 = Queue.new
-            q2.add :baz => 678
+            q2.add baz: 678
             q2.merge!(q1)
-            expected = {:gauges=>[{:name=>"foo", :value=>123, :measure_time => @time},
-                                  {:name=>"bar", :value=>456, :measure_time => @time},
-                                  {:name=>"baz", :value=>678, :measure_time => @time}]}
-            q2.queued.should equal_unordered(expected)
+            expected = {gauges:[{name:"foo", value:123, measure_time: @time},
+                                  {name:"bar", value:456, measure_time: @time},
+                                  {name:"baz", value:678, measure_time: @time}]}
+            expect(q2.queued).to equal_unordered(expected)
           end
 
-          it "should merge counters" do
+          it "merges counters" do
             q1 = Queue.new
-            q1.add :users => {:type => :counter, :value => 1000}
-            q1.add :sales => {:type => :counter, :value => 250}
+            q1.add users: {type: :counter, value: 1000}
+            q1.add sales: {type: :counter, value: 250}
             q2 = Queue.new
-            q2.add :signups => {:type => :counter, :value => 500}
+            q2.add signups: {type: :counter, value: 500}
             q2.merge!(q1)
-            expected = {:counters=>[{:name=>"users", :value=>1000, :measure_time => @time},
-                                    {:name=>"sales", :value=>250, :measure_time => @time},
-                                    {:name=>"signups", :value=>500, :measure_time => @time}]}
-            q2.queued.should equal_unordered(expected)
+            expected = {counters:[{name:"users", value:1000, measure_time: @time},
+                                    {name:"sales", value:250, measure_time: @time},
+                                    {name:"signups", value:500, measure_time: @time}]}
+            expect(q2.queued).to equal_unordered(expected)
           end
 
-          it "should maintain specified sources" do
+          it "maintains specified sources" do
             q1 = Queue.new
-            q1.add :neo => {:source => 'matrix', :value => 123}
-            q2 = Queue.new(:source => 'red_pill')
+            q1.add neo: {source: 'matrix', value: 123}
+            q2 = Queue.new(source: 'red_pill')
             q2.merge!(q1)
-            q2.queued[:gauges][0][:source].should == 'matrix'
+            expect(q2.queued[:gauges][0][:source]).to eq('matrix')
           end
 
-          it "should not change default source" do
-            q1 = Queue.new(:source => 'matrix')
-            q1.add :neo => 456
-            q2 = Queue.new(:source => 'red_pill')
+          it "does not change default source" do
+            q1 = Queue.new(source: 'matrix')
+            q1.add neo: 456
+            q2 = Queue.new(source: 'red_pill')
             q2.merge!(q1)
-            q2.queued[:source].should == 'red_pill'
+            expect(q2.queued[:source]).to eq('red_pill')
           end
 
-          it "should track previous default source" do
-            q1 = Queue.new(:source => 'matrix')
-            q1.add :neo => 456
-            q2 = Queue.new(:source => 'red_pill')
-            q2.add :morpheus => 678
+          it "tracks previous default source" do
+            q1 = Queue.new(source: 'matrix')
+            q1.add neo: 456
+            q2 = Queue.new(source: 'red_pill')
+            q2.add morpheus: 678
             q2.merge!(q1)
             q2.queued[:gauges].each do |gauge|
               if gauge[:name] == 'neo'
-                gauge[:source].should == 'matrix'
+                expect(gauge[:source]).to eq('matrix')
               end
             end
           end
 
-          it "should handle empty cases" do
+          it "handles empty cases" do
             q1 = Queue.new
-            q1.add :foo => 123, :users => {:type => :counter, :value => 1000}
+            q1.add foo: 123, users: {type: :counter, value: 1000}
             q2 = Queue.new
             q2.merge!(q1)
-            expected = {:counters => [{:name=>"users", :value=>1000, :measure_time => @time}],
-                        :gauges => [{:name=>"foo", :value=>123, :measure_time => @time}]}
-            q2.queued.should == expected
+            expected = {counters: [{name:"users", value:1000, measure_time: @time}],
+                        gauges: [{name:"foo", value:123, measure_time: @time}]}
+            expect(q2.queued).to eq(expected)
           end
         end
 
         context "with an aggregator" do
-          it "should merge" do
-            aggregator = Aggregator.new(:source => 'aggregator')
-            aggregator.add :timing => 102
-            aggregator.add :timing => 203
-            queue = Queue.new(:source => 'queue')
-            queue.add :gauge => 42
+          it "merges" do
+            aggregator = Aggregator.new(source: 'aggregator')
+            aggregator.add timing: 102
+            aggregator.add timing: 203
+            queue = Queue.new(source: 'queue')
+            queue.add gauge: 42
             queue.merge!(aggregator)
-            expected = {:gauges=>[{:name=>"gauge", :value=>42, :measure_time=>@time},
-                                  {:name=>"timing", :count=>2, :sum=>305.0, :min=>102.0, :max=>203.0, :source=>"aggregator"}],
-                        :source=>'queue'}
-            queue.queued.should equal_unordered(expected)
-
+            expected = {gauges:[{name:"gauge", value:42, measure_time:@time},
+                                  {name:"timing", count:2, sum:305.0, min:102.0, max:203.0, source:"aggregator"}],
+                        source:'queue'}
+            expect(queue.queued).to equal_unordered(expected)
           end
         end
 
         context "with a hash" do
-          it "should merge" do
-            to_merge = {:gauges=>[{:name => 'foo', :value => 123}],
-                        :counters=>[{:name => 'bar', :value => 456}]}
+          it "merges" do
+            to_merge = {gauges:[{name: 'foo', value: 123}],
+                        counters:[{name: 'bar', value: 456}]}
             q = Queue.new
             q.merge!(to_merge)
-            q.gauges.length.should == 1
-            q.counters.length.should == 1
+            expect(q.gauges.length).to eq(1)
+            expect(q.counters.length).to eq(1)
           end
         end
       end
 
       describe "#per_request" do
-        it "should default to 500" do
-          subject.per_request.should == 500
+        it "defaults to 500" do
+          expect(subject.per_request).to eq(500)
         end
       end
 
       describe "#queued" do
-        it "should include global source if set" do
-          q = Queue.new(:source => 'blah')
-          q.add :foo => 12
-          q.queued[:source].should == 'blah'
+        it "includes global source if set" do
+          q = Queue.new(source: 'blah')
+          q.add foo: 12
+          expect(q.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
-          q = Queue.new(:measure_time => measure_time)
-          q.add :foo => 12
-          q.queued[:measure_time].should == measure_time
+          q = Queue.new(measure_time: measure_time)
+          q.add foo: 12
+          expect(q.queued[:measure_time]).to eq(measure_time)
         end
       end
 
       describe "#size" do
-        it "should return empty if gauges and counters are emtpy" do
-          subject.size.should eq 0
+        it "returns empty if gauges and counters are emtpy" do
+          expect(subject.size).to be_zero
         end
-        it "should return count of gauges and counters if added" do
-          subject.add :transactions => {:type => :counter, :value => 12345},
-              :register_cents => {:type => :gauge, :value => 211101}
-          subject.add :transactions => {:type => :counter, :value => 12345},
-                      :register_cents => {:type => :gauge, :value => 211101}
-          subject.size.should eql 4
+        it "returns count of gauges and counters if added" do
+          subject.add transactions: {type: :counter, value: 12345},
+              register_cents: {type: :gauge, value: 211101}
+          subject.add transactions: {type: :counter, value: 12345},
+                      register_cents: {type: :gauge, value: 211101}
+          expect(subject.size).to eq(4)
         end
       end
 
@@ -328,47 +327,47 @@ 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.queued.should be_empty
+          it "flushes queued metrics and return true" do
+            subject.add steps: 2042, distance: 1234
+            expect(subject.submit).to be true
+            expect(subject.queued).to be_empty
           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.queued.should_not be_empty
+            expect(subject.submit).to be false
+            expect(subject.queued).not_to be_empty
           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
             subject.time :sleeping do
               sleep 0.1
             end
             queued = subject.queued[:gauges][0]
-            queued[:name].should == 'sleeping'
-            queued[:value].should be >= 100
-            queued[:value].should be_within(30).of(100)
+            expect(queued[:name]).to eq('sleeping')
+            expect(queued[:value]).to be >= 100
+            expect(queued[:value]).to be_within(30).of(100)
           end
         end
 
         context "with metric and options" do
-          it "should queue metric with value and options" do
-            subject.time :sleep_two, :source => 'app1', :period => 2 do
+          it "queues metric with value and options" do
+            subject.time :sleep_two, source: 'app1', period: 2 do
               sleep 0.05
             end
             queued = subject.queued[:gauges][0]
-            queued[:name].should == 'sleep_two'
-            queued[:period].should == 2
-            queued[:source].should == 'app1'
-            queued[:value].should be >= 50
-            queued[:value].should be_within(30).of(50)
+            expect(queued[:name]).to eq('sleep_two')
+            expect(queued[:period]).to eq(2)
+            expect(queued[:source]).to eq('app1')
+            expect(queued[:value]).to be >= 50
+            expect(queued[:value]).to be_within(30).of(50)
           end
         end
       end