pulse_meter_core 0.4.13

data/spec/pulse_meter/sensor/counter_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Counter do
+  let(:name){ :some_counter }
+  let(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe "#event" do
+    it "should increment 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
+      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}"
+    end
+  end
+
+  describe "#value" do
+    it "should have initial value 0" do
+      sensor.value.should == 0
+    end
+
+    it "should store stringified value by value_key" do
+      sensor.event(123)
+      sensor.value.should == 123
+      redis.get(sensor.value_key).should == '123'
+    end
+  end
+
+  describe "#incr" do
+    it "should increment 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
+      sensor.annotate("My Counter")
+      sensor.event(123)
+      sensor.cleanup
+      redis.keys('*').should be_empty
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/hashed_counter_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::HashedCounter do
+  let(:name){ :some_counter }
+  let(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe "#event" do
+    it "should increment 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
+      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
+      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
+    end
+
+    it "should store 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"}
+    end
+  end
+
+  describe "#incr" do
+    it "should increment 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
+  end
+
+end

data/spec/pulse_meter/sensor/hashed_indicator_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::HashedIndicator do
+  let(:name){ :some_counter }
+  let(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe "#event" do
+    it "should set 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
+      data = {"foo" => 1.1, "boo" => 2.2}
+      sensor.event(data)
+      sensor.value.should == 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}"
+    end
+  end
+
+  describe "#value" do
+    it "should have initial value 0" do
+      sensor.value["foo"].should == 0
+    end
+
+    it "should store redis hash by value_key" do
+      sensor.event({"foo" => 1})
+      sensor.value.should == {"foo" => 1}
+      redis.hgetall(sensor.value_key).should == {"foo" => "1.0"}
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/indicator_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Indicator do
+  let(:name){ :some_value }
+  let(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe "#event" do
+    it "should set 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}"
+    end
+  end
+
+  describe "#value" do
+    it "should have initial value 0" do
+      sensor.value.should == 0
+    end
+
+    it "should store stringified value by value_key" do
+      sensor.event(123)
+      sensor.value.should == 123
+      redis.get(sensor.value_key) == '123'
+    end
+  end
+
+  describe "#cleanup" do
+    it "should remove all sensor data" do
+      sensor.annotate("My Indicator")
+      sensor.event(123)
+      sensor.cleanup
+      redis.keys('*').should be_empty
+    end
+  end
+
+end
+

data/spec/pulse_meter/sensor/multi_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Multi do
+  let(:name){ :foo }
+  let(:annotation) { "Multi sensor" }
+  let(:type) {'counter'}
+  let(:factors) {[:f1, :f2]}
+  let(:configuration) {
+    {
+      sensor_type: type,
+      args: {
+        annotation: annotation
+      }
+    }
+  }
+  let(:init_values) { { factors: factors, configuration: configuration } }
+  let!(:sensor) { described_class.new(name, init_values) }
+  let!(:redis){ PulseMeter.redis }
+
+  describe '#initialize' do
+    context "when factors are not corretly passed" do
+      it "raises ArgumentError" do
+        expect {described_class.new(name, {factors: :not_array, configuration: configuration})}.to raise_exception(ArgumentError)
+        expect {described_class.new(name, {configuration: configuration})}.to raise_exception(ArgumentError)
+      end
+    end
+
+    context "when configuration missing" do
+      it "raises ArgumentError" do
+        expect {described_class.new(name, {factors: factors})}.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe "#factors" do
+    it "returns factors passed to constructor" do
+      sensor.factors.should == factors
+    end
+  end
+
+  describe "#configuration_options" do
+    it "returns configuration option passed to constructor" do
+      sensor.configuration_options.should == configuration
+    end
+  end
+
+  describe "#sensors" do
+    it "returns PulseMeter::Sensor::Configuration instance" do
+      sensor.sensors.should be_instance_of(PulseMeter::Sensor::Configuration)
+    end
+  end
+
+  describe "#event" do
+
+    it "raises ArgumentError unless all factors' values given" do
+      expect {sensor.event({f1: :v1}, 1)}.to raise_exception(ArgumentError)
+    end
+
+
+    context "when sensors must be created" do
+      let(:factor_values) { {f1: :v1, f2: :v2} }
+
+      it "implicitly creates them" do
+        expect {sensor.event(factor_values, 1)}.to change{sensor.sensors.to_a.count}
+      end
+
+      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 == [
+          "#{name}",
+          "#{name}_f1_v1",
+          "#{name}_f2_v2",
+          "#{name}_f1_v1_f2_v2"
+        ].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
+        end
+      end
+    end
+
+    it "sends event to all combinations of factors and values" do
+      sensor.event({f1: :f1v1, f2: :f2v1}, 1)
+      sensor.event({f1: :f1v2, f2: :f2v1}, 2)
+      [
+        ["#{name}", 3],
+        ["#{name}_f1_f1v1", 1],
+        ["#{name}_f1_f1v2", 2],
+        ["#{name}_f2_f2v1", 3],
+        ["#{name}_f1_f1v1_f2_f2v1", 1],
+        ["#{name}_f1_f1v2_f2_f2v1", 2]
+      ].each do |sensor_name, sum|
+        sensor.sensor(sensor_name) { |s|
+          s.value.should == sum
+        }
+      end
+    end
+  end
+
+  describe "#each" do
+    it "when used by Enumerable it lists all ever created subsensors of multisensor" do
+      sensor.event({f1: :f1v1, f2: :f2v1}, 1)
+      restored_sensor = PulseMeter::Sensor::Base.restore(name)
+
+      restored_sensor.to_a.map(&:name).sort.should == [
+        "#{name}",
+        "#{name}_f1_f1v1",
+        "#{name}_f2_f2v1",
+        "#{name}_f1_f1v1_f2_f2v1",
+      ].sort
+    end
+  end
+
+  describe "#sensor_for_factors" 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"}
+      end
+    end
+
+    context "when such a sensor was not created" do
+      it "does not yields block" do
+        yielded = false
+        sensor.sensor_for_factors([:foo], [:bar]){ yielded = true }
+        yielded.should be_false
+      end
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/timeline_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timeline do
+  let(:name){ :some_value_with_history }
+  let(:ttl){ 100 }
+  let(:raw_data_ttl){ 10 }
+  let(:interval){ 5 }
+  let(:reduce_delay){ 3 }
+  let(:good_init_values){ {:ttl => ttl, :raw_data_ttl => raw_data_ttl, :interval => interval, :reduce_delay => reduce_delay} }
+  let(:sensor){ described_class.new(name, good_init_values) }
+  let(:redis){ PulseMeter.redis }
+
+  it_should_behave_like "timeline sensor"
+
+  describe '#new' do
+    INIT_VALUE_NAMES = {
+      :with_defaults => [:raw_data_ttl, :reduce_delay],
+      :without_defaults => [:ttl, :interval]
+    }
+
+    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
+            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
+
+      sensor.ttl.should == ttl
+      sensor.raw_data_ttl.should == raw_data_ttl
+      sensor.interval.should == 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
+        values = good_init_values
+        values.delete(value)
+        expect {described_class.new(name, good_init_values)}.not_to raise_exception(ArgumentError)
+      end
+
+      it "should assign 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)
+      end
+    end
+
+  end
+
+  describe "#deflate_safe" do
+    class GoodSubclass < described_class
+      def deflate(value)
+        value.to_i
+      end
+    end
+
+    class BadSubclass < described_class
+      def deflate(value)
+        raise "Any conversion error"
+      end
+    end
+
+    let!(:good_instance) { GoodSubclass.new("good", good_init_values) }
+    let!(:bad_instance) { BadSubclass.new("bad", good_init_values) }
+
+    it "preserves nil values" do
+      good_instance.deflate_safe(nil).should be_nil
+    end
+
+    it "converts value as defined in subclass" do
+      good_instance.deflate_safe("10").should == 10
+    end
+
+    it "returns nil if conversion fails" do
+      bad_instance.deflate_safe(:foo).should be_nil
+    end
+  end
+
+end

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

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::Average do
+  it_should_behave_like "timeline sensor"
+  it_should_behave_like "timelined subclass", [1, 2], 1.5
+end

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

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::Counter do
+  it_should_behave_like "timeline sensor"
+  it_should_behave_like "timelined subclass", [1, 2], 3
+end

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

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::HashedCounter do
+  it_should_behave_like "timeline sensor", {}, {:foo => 1}
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => 2}], {:foo => 3, :total => 3}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => :bad_value}], {:foo => 1, :total => 1}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:boo => 2}], {:foo => 1, :boo => 2, :total => 3}.to_json
+end

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

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::HashedIndicator do
+  it_should_behave_like "timeline sensor", {}, {:foo => 1}
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => 2}], {:foo => 2}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:foo => :bad_value}], {:foo => 1}.to_json
+  it_should_behave_like "timelined subclass", [{:foo => 1}, {:boo => 2}], {:foo => 1, :boo => 2}.to_json
+end