pulse_meter_core 0.5.3 → 0.5.4

data/spec/pulse_meter/observer/extended_spec.rb

@@ -19,11 +19,11 @@ describe PulseMeter::Observer::Extended do
 
           dummy.incr(40)
 
-          parameters[:self].should == dummy
-          parameters[:delta].should >= 1000
-          parameters[:result].should == 40
-          parameters[:exception].should be_nil
-          parameters[:args].should == [40]
+          expect(parameters[:self]).to eq(dummy)
+          expect(parameters[:delta]).to be >= 1000
+          expect(parameters[:result]).to eq(40)
+          expect(parameters[:exception]).to be_nil
+          expect(parameters[:args]).to eq([40])
         end
       end
 
@@ -35,12 +35,12 @@ describe PulseMeter::Observer::Extended do
             parameters = params
           end
 
-          lambda { dummy.error }.should raise_error(RuntimeError)
+          expect { dummy.error }.to raise_error(RuntimeError)
 
-          parameters[:self].should == dummy
-          parameters[:result].should == nil
-          parameters[:exception].class.should == RuntimeError
-          parameters[:args].should == []
+          expect(parameters[:self]).to eq(dummy)
+          expect(parameters[:result]).to eq(nil)
+          expect(parameters[:exception].class).to eq(RuntimeError)
+          expect(parameters[:args]).to eq([])
         end
       end
     end
@@ -63,11 +63,11 @@ describe PulseMeter::Observer::Extended do
   
           ObservedDummy.incr(40)
 
-          parameters[:self].should == ObservedDummy
-          parameters[:delta].should >= 1000
-          parameters[:result].should == 40
-          parameters[:exception].should be_nil
-          parameters[:args].should == [40]
+          expect(parameters[:self]).to eq(ObservedDummy)
+          expect(parameters[:delta]).to be >= 1000
+          expect(parameters[:result]).to eq(40)
+          expect(parameters[:exception]).to be_nil
+          expect(parameters[:args]).to eq([40])
         end
       end
 
@@ -79,12 +79,12 @@ describe PulseMeter::Observer::Extended do
             parameters = params
           end
   
-          lambda { ObservedDummy.error }.should raise_error(RuntimeError)
+          expect { ObservedDummy.error }.to raise_error(RuntimeError)
 
-          parameters[:self].should == ObservedDummy
-          parameters[:result].should == nil
-          parameters[:exception].class.should == RuntimeError
-          parameters[:args].should == []
+          expect(parameters[:self]).to eq(ObservedDummy)
+          expect(parameters[:result]).to eq(nil)
+          expect(parameters[:exception].class).to eq(RuntimeError)
+          expect(parameters[:args]).to eq([])
         end
       end
     end

data/spec/pulse_meter/observer_spec.rb

@@ -23,13 +23,13 @@ describe PulseMeter::Observer do
       it "executes block in context of sensor each time specified method of given class called" do
         create_observer
         5.times {dummy.incr}
-        sensor.value.should == 5
+        expect(sensor.value).to eq(5)
       end
       
       it "passes arguments to observed method" do
         create_observer
         5.times {dummy.incr(10)}
-        dummy.count.should == 50
+        expect(dummy.count).to eq(50)
       end
 
       it "passes methods' params to block" do
@@ -38,7 +38,7 @@ describe PulseMeter::Observer do
         end
 
         5.times {dummy.incr(10)}
-        sensor.value.should == 50
+        expect(sensor.value).to eq(50)
       end
 
       it "passes execution time in milliseconds to block" do
@@ -48,7 +48,7 @@ describe PulseMeter::Observer do
           end
 
           dummy.incr
-          sensor.value.should >= 1000
+          expect(sensor.value).to be >= 1000
         end
       end
 
@@ -57,26 +57,26 @@ describe PulseMeter::Observer do
           raise RuntimeError
         end
 
-        lambda {dummy.incr}.should_not raise_error
-        dummy.count.should == 1
+        expect {dummy.incr}.not_to raise_error
+        expect(dummy.count).to eq(1)
       end
 
       it "uses first observer in case of double observation" do
         create_observer(:incr, 1)
         create_observer(:incr, 2)
         5.times {dummy.incr}
-        sensor.value.should == 5
+        expect(sensor.value).to eq(5)
       end
 
       it "keeps observed methods' errors" do
         create_observer(:error)
-        lambda {dummy.error}.should raise_error
-        sensor.value.should == 1
+        expect {dummy.error}.to raise_error
+        expect(sensor.value).to eq(1)
       end
 
       it "makes observed method return its value" do
         create_observer
-        dummy.incr.should == 1
+        expect(dummy.incr).to eq(1)
       end
 
       it "allows to pass blocks to observed method" do
@@ -84,13 +84,13 @@ describe PulseMeter::Observer do
         dummy.incr do
           2
         end
-        dummy.count.should == 3
+        expect(dummy.count).to eq(3)
       end
     end
 
     describe ".unobserve_method" do
       it "does nothing unless method is observed" do
-        lambda {remove_observer}.should_not raise_error
+        expect {remove_observer}.not_to raise_error
       end
 
       it "removes observation from observed method" do
@@ -98,7 +98,7 @@ describe PulseMeter::Observer do
         dummy.incr
         remove_observer
         dummy.incr
-        sensor.value.should == 1
+        expect(sensor.value).to eq(1)
       end
     end
   end
@@ -125,13 +125,13 @@ describe PulseMeter::Observer do
       it "executes block in context of sensor each time specified method of given class called" do
         create_observer
         5.times {dummy.incr}
-        sensor.value.should == 5
+        expect(sensor.value).to eq(5)
       end
       
       it "passes arguments to observed method" do
         create_observer
         5.times {dummy.incr(10)}
-        dummy.count.should == 50
+        expect(dummy.count).to eq(50)
       end
 
       it "passes methods' params to block" do
@@ -140,7 +140,7 @@ describe PulseMeter::Observer do
         end
 
         5.times {dummy.incr(10)}
-        sensor.value.should == 50
+        expect(sensor.value).to eq(50)
       end
 
       it "passes execution time in milliseconds to block" do
@@ -150,7 +150,7 @@ describe PulseMeter::Observer do
           end
 
           dummy.incr
-          sensor.value.should == 1000
+          expect(sensor.value).to eq(1000)
         end
       end
 
@@ -159,26 +159,26 @@ describe PulseMeter::Observer do
           raise RuntimeError
         end
 
-        lambda {dummy.incr}.should_not raise_error
-        dummy.count.should == 1
+        expect {dummy.incr}.not_to raise_error
+        expect(dummy.count).to eq(1)
       end
 
       it "uses first observer in case of double observation" do
         create_observer(:incr, 1)
         create_observer(:incr, 2)
         5.times {dummy.incr}
-        sensor.value.should == 5
+        expect(sensor.value).to eq(5)
       end
 
       it "keeps observed methods' errors" do
         create_observer(:error)
-        lambda {dummy.error}.should raise_error
-        sensor.value.should == 1
+        expect {dummy.error}.to raise_error
+        expect(sensor.value).to eq(1)
       end
 
       it "makes observed method return its value" do
         create_observer
-        dummy.incr.should == 1
+        expect(dummy.incr).to eq(1)
       end
 
       it "allows to pass blocks to observed method" do
@@ -186,13 +186,13 @@ describe PulseMeter::Observer do
         dummy.incr do
           2
         end
-        dummy.count.should == 3
+        expect(dummy.count).to eq(3)
       end
     end
 
     describe ".unobserve_class_method" do
       it "does nothing unless method is observed" do
-        lambda {remove_observer}.should_not raise_error
+        expect {remove_observer}.not_to raise_error
       end
 
       it "removes observation from observed method" do
@@ -200,7 +200,7 @@ describe PulseMeter::Observer do
         dummy.incr
         remove_observer
         dummy.incr
-        sensor.value.should == 1
+        expect(sensor.value).to eq(1)
       end
     end
   end

data/spec/pulse_meter/sensor/base_spec.rb

@@ -8,7 +8,7 @@ describe PulseMeter::Sensor::Base do
 
   describe '#initialize' do
     context 'when PulseMeter.redis is not initialized' do
-      it "should raise RedisNotInitialized exception" do
+      it "raises RedisNotInitialized exception" do
         PulseMeter.redis = nil
         expect{ described_class.new(:foo) }.to raise_exception(PulseMeter::RedisNotInitialized)
       end
@@ -17,7 +17,7 @@ describe PulseMeter::Sensor::Base do
     context 'when PulseMeter.redis is initialized' do
 
       context 'when passed sensor name is bad' do
-        it "should raise BadSensorName exception" do
+        it "raises BadSensorName exception" do
           ['name with whitespace', 'name|with|bad|characters'].each do |bad_name|
             expect{ described_class.new(bad_name) }.to raise_exception(PulseMeter::BadSensorName)
           end
@@ -25,24 +25,24 @@ describe PulseMeter::Sensor::Base do
       end
 
       context 'when passed sensor name is valid' do
-        it "should successfully create object" do
-          described_class.new("foo_@").should_not be_nil
+        it "successfully creates object" do
+          expect(described_class.new("foo_@")).not_to be_nil
         end
 
-        it "should initialize attributes #redis and #name" do
+        it "initializes attributes #redis and #name" do
           sensor = described_class.new(:foo)
-          sensor.name.should == 'foo'
-          sensor.redis.should == PulseMeter.redis
+          expect(sensor.name).to eq('foo')
+          expect(sensor.redis).to eq(PulseMeter.redis)
         end
 
-        it "should save dump to redis automatically to let the object be restored by name" do
-          described_class.restore(name).should be_instance_of(described_class)
+        it "saves dump to redis automatically to let the object be restored by name" do
+          expect(described_class.restore(name)).to be_instance_of(described_class)
         end
 
-        it "should annotate object if annotation given" do
+        it "annotates object if annotation given" do
           described_class.new(:foo, :annotation => "annotation")
           sensor = described_class.restore(:foo)
-          sensor.annotation.should == "annotation"
+          expect(sensor.annotation).to eq("annotation")
         end
       end
     end
@@ -50,7 +50,7 @@ describe PulseMeter::Sensor::Base do
 
   describe '#annotate' do
 
-    it "should store sensor annotation in redis" do
+    it "stores sensor annotation in redis" do
       expect {sensor.annotate(description)}.to change{redis.keys('*').count}.by(1)
     end
 
@@ -58,47 +58,47 @@ describe PulseMeter::Sensor::Base do
 
   describe '#annotation' do
     context "when sensor was annotated" do
-      it "should return stored annotation" do
+      it "returns stored annotation" do
         sensor.annotate(description)
-        sensor.annotation.should == description
+        expect(sensor.annotation).to eq(description)
       end
     end
 
     context "when sensor was not annotated" do
-      it "should return nil" do
-        sensor.annotation.should be_nil
+      it "returns nil" do
+        expect(sensor.annotation).to be_nil
       end
     end
 
     context "after sensor data was cleaned" do
-      it "should return nil" do
+      it "returns nil" do
         sensor.annotate(description)
         sensor.cleanup
-        sensor.annotation.should be_nil
+        expect(sensor.annotation).to be_nil
       end
     end
   end
 
   describe "#cleanup" do
-    it "should remove from redis all sensor data" do
+    it "removes from redis all sensor data" do
       sensor.event(123)
       sensor.annotate(description)
       sensor.cleanup
-      redis.keys('*').should be_empty
+      expect(redis.keys('*')).to be_empty
     end
   end
 
   describe "#event" do
     context "when everything is ok" do
-      it "should do nothing and return true" do
-        sensor.event(nil).should be
+      it "does nothing and return true" do
+        expect(sensor.event(nil)).to be
       end
     end
 
     context "when an error occures while processing event" do
-      it "should catch StandardErrors and return false" do
-        sensor.stub(:process_event) {raise StandardError}
-        sensor.event(nil).should_not be
+      it "catches StandardErrors and return false" do
+        allow(sensor).to receive(:process_event) {raise StandardError}
+        expect(sensor.event(nil)).not_to be
       end
     end
   end

data/spec/pulse_meter/sensor/configuration_spec.rb

@@ -15,43 +15,43 @@ describe PulseMeter::Sensor::Configuration do
   describe "#add_sensor" do
     let(:cfg) {described_class.new}
 
-    it "should create sensor available under passed name" do
-      cfg.has_sensor?(:foo).should_not be
+    it "creates sensor available under passed name" do
+      expect(cfg.has_sensor?(:foo)).not_to be
       cfg.add_sensor(:foo, sensor_type: 'counter')
-      cfg.has_sensor?(:foo).should_not be
+      expect(cfg.has_sensor?(:foo)).not_to be
     end
 
-    it "should have event shortcut for the sensor" do
+    it "has event shortcut for the sensor" do
       cfg.add_sensor(:foo, sensor_type: 'counter')
       puts cfg.to_yaml
-      cfg.sensor(:foo){|s| s.should_receive(:event).with(321)}
+      cfg.sensor(:foo){|s| expect(s).to receive(:event).with(321)}
       cfg.foo(321)
     end
-    
-    it "should have event_at shortcut for the sensor" do
+
+    it "has event_at shortcut for the sensor" do
       cfg.add_sensor(:foo, sensor_type: 'counter')
       now = Time.now
       cfg.sensor(:foo) do |sensor|
-        sensor.should_receive(:event_at).with(now, 321)
+        expect(sensor).to receive(:event_at).with(now, 321)
       end
       cfg.foo_at(now, 321)
     end
 
-    it "should create sensor with correct type" do
+    it "creates sensor with correct type" do
       cfg.add_sensor(:foo, sensor_type: 'counter')
-      cfg.sensor(:foo){|s| s.should be_kind_of(PulseMeter::Sensor::Counter)}
+      cfg.sensor(:foo){|s| expect(s).to be_kind_of(PulseMeter::Sensor::Counter)}
     end
 
-    it "should not raise exception if sensor type is bad" do
+    it "does not raise exception if sensor type is bad" do
       expect{ cfg.add_sensor(:foo, sensor_type: 'baaaar') }.not_to raise_exception
     end
 
-    it "should pass args to created sensor" do
+    it "passes args to created sensor" do
       cfg.add_sensor(:foo, sensor_type: 'counter', args: {annotation: "My Foo Counter"} )
-      cfg.sensor(:foo){|s| s.annotation.should == "My Foo Counter" }
+      cfg.sensor(:foo){|s| expect(s.annotation).to eq("My Foo Counter") }
     end
 
-    it "should accept hashie-objects" do
+    it "accepts hashie-objects" do
       class Dummy
         def sensor_type
           'counter'
@@ -62,12 +62,12 @@ describe PulseMeter::Sensor::Configuration do
       end
 
       cfg.add_sensor(:foo, Dummy.new)
-      cfg.sensor(:foo){|s| s.annotation.should == "My Foo Counter"}
+      cfg.sensor(:foo){|s| expect(s.annotation).to eq("My Foo Counter")}
     end
   end
 
   describe ".new" do
-    it "should add passed sensor setting hash using keys as names" do
+    it "adds passed sensor setting hash using keys as names" do
       opts = {
         cnt: {
           sensor_type: 'counter'
@@ -79,15 +79,15 @@ describe PulseMeter::Sensor::Configuration do
       cfg1 = described_class.new(opts)
       cfg2 = described_class.new
       opts.each{|k,v| cfg2.add_sensor(k, v)}
-      cfg1.sensors.to_yaml.should == cfg2.sensors.to_yaml
+      expect(cfg1.sensors.to_yaml).to eq(cfg2.sensors.to_yaml)
     end
   end
 
   describe "#sensor" do
-    it "should give access to added sensors via block" do
+    it "gives access to added sensors via block" do
       cfg = described_class.new(counter_config)
-      cfg.sensor(:cnt){ |s| s.annotation.should == "MySensor" }
-      cfg.sensor("cnt"){ |s| s.annotation.should == "MySensor" }
+      cfg.sensor(:cnt){ |s| expect(s.annotation).to eq("MySensor") }
+      cfg.sensor("cnt"){ |s| expect(s.annotation).to eq("MySensor") }
     end
   end
 
@@ -97,7 +97,7 @@ describe PulseMeter::Sensor::Configuration do
       sensors = {}
       cfg.each {|s| sensors[s.name.to_sym] = s}
       sensor = cfg.sensor(:cnt){|s| s}
-      sensors.should == {:cnt => sensor}
+      expect(sensors).to eq({:cnt => sensor})
     end
   end
 end