pulse-meter 0.4.9 → 0.4.11

data/spec/pulse_meter/sensor/counter_spec.rb

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

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

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

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

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

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

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

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

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

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

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

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