pulse-meter 0.4.9 → 0.4.11

data/spec/pulse_meter/observer/extended_spec.rb

@@ -1,92 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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