pulse_meter_core 0.5.3 → 0.5.4

data/spec/pulse_meter/sensor/counter_spec.rb

@@ -6,48 +6,48 @@ describe PulseMeter::Sensor::Counter do
   let(:redis){ PulseMeter.redis }
 
   describe "#event" do
-    it "should increment sensor value by passed value" do
+    it "increments sensor value by passed value" do
       expect{ sensor.event(10) }.to change{ sensor.value }.from(0).to(10)
       expect{ sensor.event(15) }.to change{ sensor.value }.from(10).to(25)
     end
 
-    it "should truncate increment value" do
+    it "truncates increment value" do
       expect{ sensor.event(10.4) }.to change{ sensor.value }.from(0).to(10)
       expect{ sensor.event(15.1) }.to change{ sensor.value }.from(10).to(25)
     end
   end
 
   describe "#value_key" do
-    it "should be composed of sensor name and pulse_meter:value: prefix" do
-      sensor.value_key.should == "pulse_meter:value:#{name}"
+    it "is composed of sensor name and pulse_meter:value: prefix" do
+      expect(sensor.value_key).to eq("pulse_meter:value:#{name}")
     end
   end
 
   describe "#value" do
-    it "should have initial value 0" do
-      sensor.value.should == 0
+    it "has initial value 0" do
+      expect(sensor.value).to eq(0)
     end
 
-    it "should store stringified value by value_key" do
+    it "stores stringified value by value_key" do
       sensor.event(123)
-      sensor.value.should == 123
-      redis.get(sensor.value_key).should == '123'
+      expect(sensor.value).to eq(123)
+      expect(redis.get(sensor.value_key)).to eq('123')
     end
   end
 
   describe "#incr" do
-    it "should increment value by 1" do
+    it "increments value by 1" do
       expect{ sensor.incr }.to change{ sensor.value }.from(0).to(1)
       expect{ sensor.incr }.to change{ sensor.value }.from(1).to(2)
     end
   end
 
   describe "#cleanup" do
-    it "should remove all sensor data" do
+    it "removes all sensor data" do
       sensor.annotate("My Counter")
       sensor.event(123)
       sensor.cleanup
-      redis.keys('*').should be_empty
+      expect(redis.keys('*')).to be_empty
     end
   end
 

data/spec/pulse_meter/sensor/hashed_counter_spec.rb

@@ -6,35 +6,35 @@ describe PulseMeter::Sensor::HashedCounter do
   let(:redis){ PulseMeter.redis }
 
   describe "#event" do
-    it "should increment sensor value by passed value" do
+    it "increments sensor value by passed value" do
       expect{ sensor.event({"foo" => 10}) }.to change{ sensor.value["foo"] }.from(0).to(10)
       expect{ sensor.event({"foo" => 15}) }.to change{ sensor.value["foo"] }.from(10).to(25)
     end
 
-    it "should truncate increment value" do
+    it "truncates increment value" do
       expect{ sensor.event({"foo" => 10.4}) }.to change{ sensor.value["foo"] }.from(0).to(10)
       expect{ sensor.event({"foo" => 15.1}) }.to change{ sensor.value["foo"] }.from(10).to(25)
     end
 
-    it "should increment total value" do
+    it "increments total value" do
       expect{ sensor.event({"foo" => 1, "bar" => 2}) }.to change{sensor.value["total"]}.from(0).to(3)
     end
   end
 
   describe "#value" do
-    it "should have initial value 0" do
-      sensor.value["foo"].should == 0
+    it "has initial value 0" do
+      expect(sensor.value["foo"]).to eq(0)
     end
 
-    it "should store redis hash by value_key" do
+    it "stores redis hash by value_key" do
       sensor.event({"foo" => 1})
-      sensor.value.should == {"foo" => 1, "total" => 1}
-      redis.hgetall(sensor.value_key).should == {"foo" => "1", "total" => "1"}
+      expect(sensor.value).to eq({"foo" => 1, "total" => 1})
+      expect(redis.hgetall(sensor.value_key)).to eq({"foo" => "1", "total" => "1"})
     end
   end
 
   describe "#incr" do
-    it "should increment key value by 1" do
+    it "increments key value by 1" do
       expect{ sensor.incr("foo") }.to change{ sensor.value["foo"] }.from(0).to(1)
       expect{ sensor.incr("foo") }.to change{ sensor.value["foo"] }.from(1).to(2)
     end

data/spec/pulse_meter/sensor/hashed_indicator_spec.rb

@@ -6,33 +6,33 @@ describe PulseMeter::Sensor::HashedIndicator do
   let(:redis){ PulseMeter.redis }
 
   describe "#event" do
-    it "should set sensor value to passed value" do
+    it "sets sensor value to passed value" do
       expect{ sensor.event("foo" => 10.4) }.to change{ sensor.value["foo"] }.from(0).to(10.4)
       expect{ sensor.event("foo" => 15.1) }.to change{ sensor.value["foo"] }.from(10.4).to(15.1)
     end
 
-    it "should take multiple events" do
+    it "takes multiple events" do
       data = {"foo" => 1.1, "boo" => 2.2}
       sensor.event(data)
-      sensor.value.should == data
+      expect(sensor.value).to eq(data)
     end
   end
 
   describe "#value_key" do
-    it "should be composed of sensor name and pulse_meter:value: prefix" do
-      sensor.value_key.should == "pulse_meter:value:#{name}"
+    it "is composed of sensor name and pulse_meter:value: prefix" do
+      expect(sensor.value_key).to eq("pulse_meter:value:#{name}")
     end
   end
 
   describe "#value" do
-    it "should have initial value 0" do
-      sensor.value["foo"].should == 0
+    it "has initial value 0" do
+      expect(sensor.value["foo"]).to eq(0)
     end
 
-    it "should store redis hash by value_key" do
+    it "stores redis hash by value_key" do
       sensor.event({"foo" => 1})
-      sensor.value.should == {"foo" => 1}
-      redis.hgetall(sensor.value_key).should == {"foo" => "1.0"}
+      expect(sensor.value).to eq({"foo" => 1})
+      expect(redis.hgetall(sensor.value_key)).to eq({"foo" => "1.0"})
     end
   end
 

data/spec/pulse_meter/sensor/indicator_spec.rb

@@ -6,36 +6,36 @@ describe PulseMeter::Sensor::Indicator do
   let(:redis){ PulseMeter.redis }
 
   describe "#event" do
-    it "should set sensor value to passed value" do
+    it "sets sensor value to passed value" do
       expect{ sensor.event(10.4) }.to change{ sensor.value }.from(0).to(10.4)
       expect{ sensor.event(15.1) }.to change{ sensor.value }.from(10.4).to(15.1)
     end
   end
 
   describe "#value_key" do
-    it "should be composed of sensor name and pulse_meter:value: prefix" do
-      sensor.value_key.should == "pulse_meter:value:#{name}"
+    it "is composed of sensor name and pulse_meter:value: prefix" do
+      expect(sensor.value_key).to eq("pulse_meter:value:#{name}")
     end
   end
 
   describe "#value" do
-    it "should have initial value 0" do
-      sensor.value.should == 0
+    it "has initial value 0" do
+      expect(sensor.value).to eq(0)
     end
 
-    it "should store stringified value by value_key" do
+    it "stores stringified value by value_key" do
       sensor.event(123)
-      sensor.value.should == 123
+      expect(sensor.value).to eq(123)
       redis.get(sensor.value_key) == '123'
     end
   end
 
   describe "#cleanup" do
-    it "should remove all sensor data" do
+    it "removes all sensor data" do
       sensor.annotate("My Indicator")
       sensor.event(123)
       sensor.cleanup
-      redis.keys('*').should be_empty
+      expect(redis.keys('*')).to be_empty
     end
   end
 

data/spec/pulse_meter/sensor/multi_spec.rb

@@ -34,19 +34,19 @@ describe PulseMeter::Sensor::Multi do
 
   describe "#factors" do
     it "returns factors passed to constructor" do
-      sensor.factors.should == factors
+      expect(sensor.factors).to eq(factors)
     end
   end
 
   describe "#configuration_options" do
     it "returns configuration option passed to constructor" do
-      sensor.configuration_options.should == configuration
+      expect(sensor.configuration_options).to eq(configuration)
     end
   end
 
   describe "#sensors" do
     it "returns PulseMeter::Sensor::Configuration instance" do
-      sensor.sensors.should be_instance_of(PulseMeter::Sensor::Configuration)
+      expect(sensor.sensors).to be_instance_of(PulseMeter::Sensor::Configuration)
     end
   end
 
@@ -67,19 +67,19 @@ describe PulseMeter::Sensor::Multi do
       it "assigns names based on factors' names and values" do
         sensor.event(factor_values, 1)
         names = sensor.sensors.to_a.map(&:name)
-        names.sort.should == [
+        expect(names.sort).to eq([
           "#{name}",
           "#{name}_f1_v1",
           "#{name}_f2_v2",
           "#{name}_f1_v1_f2_v2"
-        ].sort
+        ].sort)
       end
 
       it "creates sensors of given type with configuration options passed" do
         sensor.event(factor_values, 1)
         sensor.sensors.each do |s|
-          s.should be_instance_of(PulseMeter::Sensor::Counter)
-          s.annotation.should == annotation
+          expect(s).to be_instance_of(PulseMeter::Sensor::Counter)
+          expect(s.annotation).to eq(annotation)
         end
       end
     end
@@ -96,7 +96,7 @@ describe PulseMeter::Sensor::Multi do
         ["#{name}_f1_f1v2_f2_f2v1", 2]
       ].each do |sensor_name, sum|
         sensor.sensor(sensor_name) { |s|
-          s.value.should == sum
+          expect(s.value).to eq(sum)
         }
       end
     end
@@ -107,12 +107,12 @@ describe PulseMeter::Sensor::Multi do
       sensor.event({f1: :f1v1, f2: :f2v1}, 1)
       restored_sensor = PulseMeter::Sensor::Base.restore(name)
 
-      restored_sensor.to_a.map(&:name).sort.should == [
+      expect(restored_sensor.to_a.map(&:name).sort).to eq([
         "#{name}",
         "#{name}_f1_f1v1",
         "#{name}_f2_f2v1",
         "#{name}_f1_f1v1_f2_f2v1",
-      ].sort
+      ].sort)
     end
   end
 
@@ -120,8 +120,8 @@ describe PulseMeter::Sensor::Multi do
     context "when sensor has already been created" do
       it "yields block with sensor for given combination of factors and their values" do
         sensor.event({f1: :f1v1, f2: :f2v1}, 1)
-        sensor.sensor_for_factors([:f1, :f2], [:f1v1, :f2v1]){|s| s.name.should == "#{name}_f1_f1v1_f2_f2v1"}
-        sensor.sensor_for_factors([:f1], [:f1v1]){|s| s.name.should == "#{name}_f1_f1v1"}
+        sensor.sensor_for_factors([:f1, :f2], [:f1v1, :f2v1]){|s| expect(s.name).to eq("#{name}_f1_f1v1_f2_f2v1")}
+        sensor.sensor_for_factors([:f1], [:f1v1]){|s| expect(s.name).to eq("#{name}_f1_f1v1")}
       end
     end
 
@@ -129,7 +129,7 @@ describe PulseMeter::Sensor::Multi do
       it "does not yields block" do
         yielded = false
         sensor.sensor_for_factors([:foo], [:bar]){ yielded = true }
-        yielded.should_not be
+        expect(yielded).not_to be
       end
     end
   end

data/spec/pulse_meter/sensor/timeline_spec.rb

@@ -21,36 +21,36 @@ describe PulseMeter::Sensor::Timeline do
     shared_examples_for "error raiser" do |value_names, bad_values|
       value_names.each do |value|
         bad_values.each do |bad_value|
-          it "should raise exception if a bad value #{bad_value.inspect} passed for #{value.inspect}" do
+          it "raises exception if a bad value #{bad_value.inspect} passed for #{value.inspect}" do
             expect{ described_class.new(name, good_init_values.merge(value => bad_value)) }.to raise_exception(ArgumentError)
           end
         end
       end
     end
 
-    it "should initialize #ttl #raw_data_ttl #interval and #name attributes" do
-      sensor.name.should == name.to_s
+    it "initializes #ttl #raw_data_ttl #interval and #name attributes" do
+      expect(sensor.name).to eq(name.to_s)
 
-      sensor.ttl.should == ttl
-      sensor.raw_data_ttl.should == raw_data_ttl
-      sensor.interval.should == interval
+      expect(sensor.ttl).to eq(ttl)
+      expect(sensor.raw_data_ttl).to eq(raw_data_ttl)
+      expect(sensor.interval).to eq(interval)
     end
 
     it_should_behave_like "error raiser", INIT_VALUE_NAMES[:without_defaults], [:bad, -1, nil]
     it_should_behave_like "error raiser", INIT_VALUE_NAMES[:with_defaults], [:bad, -1]
 
     INIT_VALUE_NAMES[:with_defaults].each do |value|
-      it "should not raise exception if #{value.inspect} is not defined" do
+      it "does not raise exception if #{value.inspect} is not defined" do
         values = good_init_values
         values.delete(value)
         expect {described_class.new(name, good_init_values)}.not_to raise_error
       end
 
-      it "should assign default value to #{value.inspect} if it is not defined" do
+      it "assigns default value to #{value.inspect} if it is not defined" do
         values = good_init_values
         values.delete(value)
         obj = described_class.new(name, good_init_values)
-        obj.send(value).should be_kind_of(Fixnum)
+        expect(obj.send(value)).to be_kind_of(Fixnum)
       end
     end
 
@@ -73,15 +73,15 @@ describe PulseMeter::Sensor::Timeline do
     let!(:bad_instance) { BadSubclass.new("bad", good_init_values) }
 
     it "preserves nil values" do
-      good_instance.deflate_safe(nil).should be_nil
+      expect(good_instance.deflate_safe(nil)).to be_nil
     end
 
     it "converts value as defined in subclass" do
-      good_instance.deflate_safe("10").should == 10
+      expect(good_instance.deflate_safe("10")).to eq(10)
     end
 
     it "returns nil if conversion fails" do
-      bad_instance.deflate_safe(:foo).should be_nil
+      expect(bad_instance.deflate_safe(:foo)).to be_nil
     end
   end
 

data/spec/pulse_meter/sensor/timelined/multi_percentile_spec.rb

@@ -8,11 +8,11 @@ describe PulseMeter::Sensor::Timelined::MultiPercentile do
   let(:init_values) {{:ttl => 1, :raw_data_ttl => 1, :interval => 1, :reduce_delay => 1}}
   let(:name) {"percentile"}
 
-  it "should raise exception when extra parameter is not array of percentiles" do
+  it "raises exception when extra parameter is not array of percentiles" do
     expect {described_class.new(name, init_values.merge({:p => :bad}))}.to raise_exception(ArgumentError)
   end
 
-  it "should raise exception when one of percentiles is not between 0 and 1" do
+  it "raises exception when one of percentiles is not between 0 and 1" do
     expect {described_class.new(name, init_values.merge({:p => [0.5, -1]}))}.to raise_exception(ArgumentError)
     expect {described_class.new(name, init_values.merge({:p => [0.5, 1.1]}))}.to raise_exception(ArgumentError)
     expect {described_class.new(name, init_values.merge({:p => [0.5, 0.1]}))}.not_to raise_exception

data/spec/pulse_meter/sensor/timelined/percentile_spec.rb

@@ -8,7 +8,7 @@ describe PulseMeter::Sensor::Timelined::Percentile do
   let(:init_values) {{:ttl => 1, :raw_data_ttl => 1, :interval => 1, :reduce_delay => 1}}
   let(:name) {"percentile"}
 
-  it "should raise exception when percentile is not between 0 and 1" do
+  it "raises exception when percentile is not between 0 and 1" do
     expect {described_class.new(name, init_values.merge({:p => -1}))}.to raise_exception(ArgumentError)
     expect {described_class.new(name, init_values.merge({:p => 1.1}))}.to raise_exception(ArgumentError)
     expect {described_class.new(name, init_values.merge({:p => 0.1}))}.not_to raise_exception

data/spec/pulse_meter/sensor/uniq_counter_spec.rb

@@ -6,7 +6,7 @@ describe PulseMeter::Sensor::UniqCounter do
   let(:redis){ PulseMeter.redis }
 
   describe "#event" do
-    it "should count unique values" do
+    it "counts unique values" do
       expect{ sensor.event(:first) }.to change{sensor.value}.to(1)
       expect{ sensor.event(:first) }.not_to change{sensor.value}
       expect{ sensor.event(:second) }.to change{sensor.value}.from(1).to(2)
@@ -14,14 +14,14 @@ describe PulseMeter::Sensor::UniqCounter do
   end
 
   describe "#value" do
-    it "should have initial value 0" do
-      sensor.value.should == 0
+    it "has initial value 0" do
+      expect(sensor.value).to eq(0)
     end
 
-    it "should return count of unique values" do
+    it "returns count of unique values" do
       data = (1..100).map {rand(200)}
       data.each {|e| sensor.event(e)}
-      sensor.value.should == data.uniq.count
+      expect(sensor.value).to eq(data.uniq.count)
     end
   end
 

data/spec/pulse_meter/udp_server_spec.rb

@@ -6,9 +6,9 @@ describe PulseMeter::UDPServer do
   let(:udp_sock){double(:socket)}
   let(:redis){PulseMeter.redis}
   before do
-    UDPSocket.should_receive(:new).and_return(udp_sock)
-    udp_sock.should_receive(:bind).with(host, port).and_return(nil)
-    udp_sock.should_receive("do_not_reverse_lookup=").with(true).and_return(nil)
+    expect(UDPSocket).to receive(:new).and_return(udp_sock)
+    expect(udp_sock).to receive(:bind).with(host, port).and_return(nil)
+    expect(udp_sock).to receive("do_not_reverse_lookup=").with(true).and_return(nil)
     @server = described_class.new(host, port)
   end
 
@@ -19,15 +19,15 @@ describe PulseMeter::UDPServer do
         ["set", "yyyy", "zzzz"]
       ].to_json
     }
-    it "should process proper incoming commands" do
-      udp_sock.should_receive(:recvfrom).with(described_class::MAX_PACKET).and_return(data)
+    it "processes proper incoming commands" do
+      expect(udp_sock).to receive(:recvfrom).with(described_class::MAX_PACKET).and_return(data)
       @server.start(1)
-      redis.get("xxxx").should == "zzzz"
-      redis.get("yyyy").should == "zzzz"
+      expect(redis.get("xxxx")).to eq("zzzz")
+      expect(redis.get("yyyy")).to eq("zzzz")
     end
 
-    it "should suppress JSON errors" do
-      udp_sock.should_receive(:recvfrom).with(described_class::MAX_PACKET).and_return("xxx")
+    it "suppresses JSON errors" do
+      expect(udp_sock).to receive(:recvfrom).with(described_class::MAX_PACKET).and_return("xxx")
       expect{ @server.start(1) }.not_to raise_exception
     end
   end

data/spec/pulse_meter_spec.rb

@@ -2,71 +2,71 @@ require 'spec_helper'
 
 describe PulseMeter do
   describe "::redis=" do
-    it "should store redis" do
+    it "stores redis" do
       PulseMeter.redis = 'redis'
-      PulseMeter.redis.should == 'redis'
+      expect(PulseMeter.redis).to eq('redis')
     end
   end
   describe "::redis" do
-    it "should retrieve redis" do
+    it "retrieves redis" do
       PulseMeter.redis = 'redis'
-      PulseMeter.redis.should == 'redis'
+      expect(PulseMeter.redis).to eq('redis')
     end
   end
   describe "::command_aggregator=" do
     context "when :async passed" do
-      it "should set async command_aggregator to be used" do
+      it "sets async command_aggregator to be used" do
         PulseMeter.command_aggregator = :async
-        PulseMeter.command_aggregator.should be_kind_of(PulseMeter::CommandAggregator::Async)
+        expect(PulseMeter.command_aggregator).to be_kind_of(PulseMeter::CommandAggregator::Async)
       end
     end
     context "when :sync passed" do
-      it "should set sync command_aggregator to be used" do
+      it "sets sync command_aggregator to be used" do
         PulseMeter.command_aggregator = :sync
-        PulseMeter.command_aggregator.should be_kind_of(PulseMeter::CommandAggregator::Sync)
+        expect(PulseMeter.command_aggregator).to be_kind_of(PulseMeter::CommandAggregator::Sync)
       end
     end
     context "otherwise" do
-      it "should set command_aggregator to the passed value" do
+      it "sets command_aggregator to the passed value" do
         PulseMeter.command_aggregator = :xxx
-        PulseMeter.command_aggregator.should == :xxx
+        expect(PulseMeter.command_aggregator).to eq(:xxx)
       end
     end
   end
 
   describe "::command_aggregator" do
-    it "should return current command_aggregator" do
+    it "returns current command_aggregator" do
       PulseMeter.command_aggregator = :async
-      PulseMeter.command_aggregator.should be_kind_of(PulseMeter::CommandAggregator::Async)
+      expect(PulseMeter.command_aggregator).to be_kind_of(PulseMeter::CommandAggregator::Async)
       PulseMeter.command_aggregator = :sync
-      PulseMeter.command_aggregator.should be_kind_of(PulseMeter::CommandAggregator::Sync)
+      expect(PulseMeter.command_aggregator).to be_kind_of(PulseMeter::CommandAggregator::Sync)
     end
 
-    it "should always return the same command_aggregator for each type" do
+    it "always returns the same command_aggregator for each type" do
       PulseMeter.command_aggregator = :async
       ca1 = PulseMeter.command_aggregator
       PulseMeter.command_aggregator = :sync
       PulseMeter.command_aggregator = :async
       ca2 = PulseMeter.command_aggregator
-      ca1.should == ca2
+      expect(ca1).to eq(ca2)
     end
   end
 
   describe "::logger" do
-    it "should return PulseMeter logger" do
+    it "returns PulseMeter logger" do
       PulseMeter.logger = 123
-      PulseMeter.logger.should == 123
+      expect(PulseMeter.logger).to eq(123)
     end
 
-    it "should return default logger" do
+    it "returns default logger" do
       PulseMeter.logger = nil
-      PulseMeter.logger.should be_kind_of(Logger)
+      expect(PulseMeter.logger).to be_kind_of(Logger)
     end
   end
 
   describe "::error" do
-    it "should delegate error message to logger" do
-      PulseMeter.logger.should_receive(:error)
+    it "delegates error message to logger" do
+      expect(PulseMeter.logger).to receive(:error)
       PulseMeter.error("foo")
     end
   end