pulse_meter_core 0.4.13

data/spec/pulse_meter/observer/extended_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe PulseMeter::Observer::Extended do
+  context "instance methods observation" do
+    let!(:dummy) {ObservedDummy.new}
+    let!(:sensor) {PulseMeter::Sensor::Counter.new(:foo)}
+    before do
+      [:incr, :error].each {|m| described_class.unobserve_method(ObservedDummy, m)}
+    end
+
+    describe ".observe_method" do
+      it "passes exended parameters to block in normal execution" do
+        Timecop.freeze do
+          parameters = {}
+
+          described_class.observe_method(ObservedDummy, :incr, sensor) do |params|
+            parameters = params
+          end
+
+          dummy.incr(40)
+
+          parameters[:self].should == dummy
+          parameters[:delta].should >= 1000
+          parameters[:result].should == 40
+          parameters[:exception].should be_nil
+          parameters[:args].should == [40]
+        end
+      end
+
+      it "passes exended parameters to block with exception" do
+        Timecop.freeze do
+          parameters = {}
+
+          described_class.observe_method(ObservedDummy, :error, sensor) do |params|
+            parameters = params
+          end
+
+          lambda { dummy.error }.should raise_error(RuntimeError)
+
+          parameters[:self].should == dummy
+          parameters[:result].should == nil
+          parameters[:exception].class.should == RuntimeError
+          parameters[:args].should == []
+        end
+      end
+    end
+  end
+
+  context "class methods observation" do
+    let!(:sensor) {PulseMeter::Sensor::Counter.new(:foo)}
+    before do
+      [:incr, :error].each {|m| described_class.unobserve_class_method(ObservedDummy, m)}
+    end
+
+    describe ".observe_class_method" do
+      it "passes exended parameters to block in normal execution" do
+        Timecop.freeze do
+          parameters = {}
+
+          described_class.observe_class_method(ObservedDummy, :incr, sensor) do |params|
+            parameters = params
+          end
+  
+          ObservedDummy.incr(40)
+
+          parameters[:self].should == ObservedDummy
+          parameters[:delta].should >= 1000
+          parameters[:result].should == 40
+          parameters[:exception].should be_nil
+          parameters[:args].should == [40]
+        end
+      end
+
+      it "passes exended parameters to block with exception" do
+        Timecop.freeze do
+          parameters = {}
+
+          described_class.observe_class_method(ObservedDummy, :error, sensor) do |params|
+            parameters = params
+          end
+  
+          lambda { ObservedDummy.error }.should raise_error(RuntimeError)
+
+          parameters[:self].should == ObservedDummy
+          parameters[:result].should == nil
+          parameters[:exception].class.should == RuntimeError
+          parameters[:args].should == []
+        end
+      end
+    end
+  end
+end

data/spec/pulse_meter/observer_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe PulseMeter::Observer do
+
+  context "instance methods observation" do
+    let!(:dummy) {ObservedDummy.new}
+    let!(:sensor) {PulseMeter::Sensor::Counter.new(:foo)}
+    before do
+      [:incr, :error].each {|m| described_class.unobserve_method(ObservedDummy, m)}
+    end
+
+    def create_observer(method = :incr, increment = 1)
+      described_class.observe_method(ObservedDummy, method, sensor) do |*args|
+        event(increment)
+      end
+    end
+
+    def remove_observer(method = :incr)
+      described_class.unobserve_method(ObservedDummy, method)
+    end
+
+    describe ".observe_method" 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
+      end
+      
+      it "passes arguments to observed method" do
+        create_observer
+        5.times {dummy.incr(10)}
+        dummy.count.should == 50
+      end
+
+      it "passes methods' params to block" do
+        described_class.observe_method(ObservedDummy, :incr, sensor) do |time, cnt|
+          event(cnt)
+        end
+
+        5.times {dummy.incr(10)}
+        sensor.value.should == 50
+      end
+
+      it "passes execution time in milliseconds to block" do
+        Timecop.freeze do
+          described_class.observe_method(ObservedDummy, :incr, sensor) do |time, cnt|
+            event(time)
+          end
+
+          dummy.incr
+          sensor.value.should >= 1000
+        end
+      end
+
+      it "does not break observed method even is observer raises error" do
+        described_class.observe_method(ObservedDummy, :incr, sensor) do |*args|
+          raise RuntimeError
+        end
+
+        lambda {dummy.incr}.should_not raise_error
+        dummy.count.should == 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
+      end
+
+      it "keeps observed methods' errors" do
+        create_observer(:error)
+        lambda {dummy.error}.should raise_error(RuntimeError)
+        sensor.value.should == 1
+      end
+
+      it "makes observed method return its value" do
+        create_observer
+        dummy.incr.should == 1
+      end
+
+      it "allows to pass blocks to observed method" do
+        create_observer
+        dummy.incr do
+          2
+        end
+        dummy.count.should == 3
+      end
+    end
+
+    describe ".unobserve_method" do
+      it "does nothing unless method is observed" do
+        lambda {remove_observer}.should_not raise_error
+      end
+
+      it "removes observation from observed method" do
+        create_observer
+        dummy.incr
+        remove_observer
+        dummy.incr
+        sensor.value.should == 1
+      end
+    end
+  end
+
+  context "class methods observation" do
+    let!(:dummy) {ObservedDummy}
+    let!(:sensor) {PulseMeter::Sensor::Counter.new(:foo)}
+    before do
+      dummy.reset
+      [:incr, :error].each {|m| described_class.unobserve_class_method(ObservedDummy, m)}
+    end
+
+    def create_observer(method = :incr, increment = 1)
+      described_class.observe_class_method(ObservedDummy, method, sensor) do |*args|
+        event(increment)
+      end
+    end
+
+    def remove_observer(method = :incr)
+      described_class.unobserve_class_method(ObservedDummy, method)
+    end
+
+    describe ".observe_class_method" 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
+      end
+      
+      it "passes arguments to observed method" do
+        create_observer
+        5.times {dummy.incr(10)}
+        dummy.count.should == 50
+      end
+
+      it "passes methods' params to block" do
+        described_class.observe_class_method(ObservedDummy, :incr, sensor) do |time, cnt|
+          event(cnt)
+        end
+
+        5.times {dummy.incr(10)}
+        sensor.value.should == 50
+      end
+
+      it "passes execution time in milliseconds to block" do
+        Timecop.freeze do
+          described_class.observe_class_method(ObservedDummy, :incr, sensor) do |time, cnt|
+            event(time)
+          end
+
+          dummy.incr
+          sensor.value.should == 1000
+        end
+      end
+
+      it "does not break observed method even is observer raises error" do
+        described_class.observe_class_method(ObservedDummy, :incr, sensor) do |*args|
+          raise RuntimeError
+        end
+
+        lambda {dummy.incr}.should_not raise_error
+        dummy.count.should == 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
+      end
+
+      it "keeps observed methods' errors" do
+        create_observer(:error)
+        lambda {dummy.error}.should raise_error(RuntimeError)
+        sensor.value.should == 1
+      end
+
+      it "makes observed method return its value" do
+        create_observer
+        dummy.incr.should == 1
+      end
+
+      it "allows to pass blocks to observed method" do
+        create_observer
+        dummy.incr do
+          2
+        end
+        dummy.count.should == 3
+      end
+    end
+
+    describe ".unobserve_class_method" do
+      it "does nothing unless method is observed" do
+        lambda {remove_observer}.should_not raise_error
+      end
+
+      it "removes observation from observed method" do
+        create_observer
+        dummy.incr
+        remove_observer
+        dummy.incr
+        sensor.value.should == 1
+      end
+    end
+  end
+end

data/spec/pulse_meter/sensor/base_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Base do
+  let(:name){ :some_sensor }
+  let(:description) {"Le awesome description"}
+  let!(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe '#initialize' do
+    context 'when PulseMeter.redis is not initialized' do
+      it "should raise RedisNotInitialized exception" do
+        PulseMeter.redis = nil
+        expect{ described_class.new(:foo) }.to raise_exception(PulseMeter::RedisNotInitialized)
+      end
+    end
+
+    context 'when PulseMeter.redis is initialized' do
+
+      context 'when passed sensor name is bad' do
+        it "should raise 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
+        end
+      end
+
+      context 'when passed sensor name is valid' do
+        it "should successfully create object" do
+          described_class.new(:foo).should_not be_nil
+        end
+
+        it "should initialize attributes #redis and #name" do
+          sensor = described_class.new(:foo)
+          sensor.name.should == 'foo'
+          sensor.redis.should == 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)
+        end
+
+        it "should annotate object if annotation given" do
+          described_class.new(:foo, :annotation => "annotation")
+          sensor = described_class.restore(:foo)
+          sensor.annotation.should == "annotation"
+        end
+      end
+    end
+  end
+
+  describe '#annotate' do
+
+    it "should store sensor annotation in redis" do
+      expect {sensor.annotate(description)}.to change{redis.keys('*').count}.by(1)
+    end
+
+  end
+
+  describe '#annotation' do
+    context "when sensor was annotated" do
+      it "should return stored annotation" do
+        sensor.annotate(description)
+        sensor.annotation.should == description
+      end
+    end
+
+    context "when sensor was not annotated" do
+      it "should return nil" do
+        sensor.annotation.should be_nil
+      end
+    end
+
+    context "after sensor data was cleaned" do
+      it "should return nil" do
+        sensor.annotate(description)
+        sensor.cleanup
+        sensor.annotation.should be_nil
+      end
+    end
+  end
+
+  describe "#cleanup" do
+    it "should remove from redis all sensor data" do
+      sensor.event(123)
+      sensor.annotate(description)
+      sensor.cleanup
+      redis.keys('*').should 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_true
+      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 be_false
+      end
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/configuration_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe PulseMeter::Sensor::Configuration do
+  let(:counter_config) {
+    {
+      cnt: {
+        sensor_type: 'counter',
+        args: {
+          annotation: "MySensor"
+        }
+      },
+    }
+  }
+
+  describe "#add_sensor" do
+    let(:cfg) {described_class.new}
+
+    it "should create sensor available under passed name" do
+      cfg.has_sensor?(:foo).should be_false
+      cfg.add_sensor(:foo, sensor_type: 'counter')
+      cfg.has_sensor?(:foo).should_not be_true
+    end
+
+    it "should have 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.foo(321)
+    end
+    
+    it "should have 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)
+      end
+      cfg.foo_at(now, 321)
+    end
+
+    it "should create sensor with correct type" do
+      cfg.add_sensor(:foo, sensor_type: 'counter')
+      cfg.sensor(:foo){|s| s.should be_kind_of(PulseMeter::Sensor::Counter)}
+    end
+
+    it "should 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
+      cfg.add_sensor(:foo, sensor_type: 'counter', args: {annotation: "My Foo Counter"} )
+      cfg.sensor(:foo){|s| s.annotation.should == "My Foo Counter" }
+    end
+
+    it "should accept hashie-objects" do
+      class Dummy
+        def sensor_type
+          'counter'
+        end
+        def args
+          Hashie::Mash.new(annotation: "My Foo Counter")
+        end
+      end
+
+      cfg.add_sensor(:foo, Dummy.new)
+      cfg.sensor(:foo){|s| s.annotation.should == "My Foo Counter"}
+    end
+  end
+
+  describe ".new" do
+    it "should add passed sensor setting hash using keys as names" do
+      opts = {
+        cnt: {
+          sensor_type: 'counter'
+        },
+        ind: {
+          sensor_type: 'indicator'
+        }
+      }
+      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
+    end
+  end
+
+  describe "#sensor" do
+    it "should give 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" }
+    end
+  end
+
+  describe "#each_sensor" do
+    it "yields block for each name/sensor pair" do
+      cfg = described_class.new(counter_config)
+      sensors = {}
+      cfg.each {|s| sensors[s.name.to_sym] = s}
+      sensor = cfg.sensor(:cnt){|s| s}
+      sensors.should == {:cnt => sensor}
+    end
+  end
+end