pulse-meter 0.4.9 → 0.4.11

data/spec/pulse_meter/mixins/cmd_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-describe PulseMeter::Mixins::Cmd do
-  class CmdDummy
-    include PulseMeter::Mixins::Cmd
-
-    def initialize(redis)
-      @redis = redis
-    end
-
-    def create_redis
-      @redis
-    end
-  end
-
-  let(:redis){ MockRedis.new }
-  let(:dummy){ CmdDummy.new(redis) }
-  before{ PulseMeter.redis = redis }
-
-  describe "#fail!" do
-    it "prints given message and exits" do
-      STDOUT.should_receive(:puts).with(:msg)
-      lambda {dummy.fail!(:msg)}.should raise_error(SystemExit)
-    end
-  end
-
-  describe '#with_redis' do
-    it "initializes redies and yields a block" do
-      PulseMeter.redis = nil
-      dummy.with_redis do
-        PulseMeter.redis.should_not be_nil
-      end
-    end
-  end
-
-  describe "#with_safe_restore_of" do
-    it "restores sensor by name and passes it to block" do
-      sensor = PulseMeter::Sensor::Counter.new(:foo)
-      dummy.with_safe_restore_of(:foo) do |s|
-        s.should be_instance_of(sensor.class)
-      end
-    end
-
-    it "prints error and exits if sensor cannot be restored" do
-      STDOUT.should_receive(:puts).with("Sensor nonexistant is unknown or cannot be restored")
-      lambda {dummy.with_safe_restore_of(:nonexistant) {|s| s}}.should raise_error(SystemExit)
-    end
-  end
-
-  describe "#all_sensors" do
-    it "is just an alias to PulseMeter::Sensor::Timeline.list_objects" do
-      PulseMeter::Sensor::Timeline.should_receive(:list_objects)
-      dummy.all_sensors
-    end
-  end
-
-  describe "#all_sensors_table" do
-    before {PulseMeter.redis.flushall}
-    let(:init_values){ {:ttl => 1, :raw_data_ttl => 2, :interval => 3, :reduce_delay => 4} }
-    let!(:s1) {PulseMeter::Sensor::Counter.new(:s1)} 
-    let!(:s2) {PulseMeter::Sensor::Timelined::Counter.new(:s2, init_values)} 
-    let!(:table) {dummy.all_sensors_table}
-    let!(:csv) {dummy.all_sensors_table(:csv)}
-    let!(:parsed_csv) {CSV.parse(csv, col_sep: ";")}
-
-    def rows(format)
-      if "csv" == format.to_s
-        parsed_csv
-      else
-        table.rows.map do |row|
-          row.cells.map(&:to_s).map(&:strip)
-        end
-      end
-    end
-
-    def sensor_row(name, format)
-      rows(format).select {|row| row[0] == name}.first
-    end
-      
-    [:csv, :table].each do |format|
-      context "when format is #{format}" do
-
-        if "csv" == format.to_s
-          it "returns csv as string" do
-            csv.should be_instance_of(String)
-          end
-        else
-          it "returns Terminal::Table instance" do
-            table.should be_instance_of(Terminal::Table)
-          end
-        end
-
-        it "has title row" do
-          rows(format)[0].should == ["Name", "Class", "ttl", "raw data ttl", "interval", "reduce delay"]
-        end
-
-        it "has one row for each sensor (and a title)" do
-          rows(format).count.should == 3
-        end
-
-        it "can display timelined sensors" do
-          sensor_row("s2", format).should == [
-            s2.name, s2.class, s2.ttl, s2.raw_data_ttl, s2.interval, s2.reduce_delay
-          ].map(&:to_s)
-        end
-
-        it "can display static sensors" do
-          sensor_row("s1", format).should == [
-            s1.name, s1.class, "", "", "", ""
-          ].map(&:to_s)
-        end
-
-      end
-    end
-  end
-
-end

data/spec/pulse_meter/mixins/dumper_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-
-describe PulseMeter::Mixins::Dumper do
-  class Base
-    include PulseMeter::Mixins::Dumper
-  end
-
-  class Bad < Base; end
-
-  class Good < Base
-    attr_accessor :some_value
-    attr_accessor :name
-
-    def redis; PulseMeter.redis; end
-
-    def initialize(name)
-      @name = name.to_s
-      @some_value = name
-    end
-  end
-
-  class GoodButAnother < Good; end
-
-  let(:bad_obj){ Bad.new }
-  let(:good_obj){ Good.new(:foo) }
-  let(:another_good_obj){ Good.new(:bar) }
-  let(:good_obj_of_another_type){ GoodButAnother.new(:quux) }
-  let(:redis){ PulseMeter.redis }
-
-  describe '#dump' do
-    context "when class violates dump contract" do
-      context "when it has no name attribute" do
-        it "should raise exception" do
-          def bad_obj.redis; PulseMeter.redis; end
-          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
-        end
-      end
-
-      context "when it has no redis attribute" do
-        it "should raise exception" do
-          def bad_obj.name; :foo; end
-          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
-        end
-      end
-
-      context "when redis is not avalable" do
-        it "should raise exception" do
-          def bad_obj.name; :foo; end
-          def bad_obj.redis; nil; end
-          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
-        end
-      end
-    end
-
-    context "when class follows dump contract" do
-      it "should not raise dump exception" do
-        expect {good_obj.dump!}.not_to raise_exception(PulseMeter::DumpError)
-      end
-
-      it "should save dump to redis" do
-        expect {good_obj.dump!}.to change {redis.hlen(Good::DUMP_REDIS_KEY)}.by(1)
-      end
-    end
-
-    context "when dump is safe" do
-      it "should not overwrite stored objects of the same type" do
-        good_obj.some_value = 123
-        good_obj.dump!
-        good_obj.some_value = 321
-        good_obj.dump!
-        Base.restore(good_obj.name).some_value.should == 123
-      end
-
-      it "should raise DumpConflictError exception if sensor with the same name but different type already exists" do
-        good_obj.name = "duplicate_name"
-        good_obj_of_another_type.name = "duplicate_name"
-        good_obj.dump!
-        expect{good_obj_of_another_type.dump!}.to raise_exception(PulseMeter::DumpConflictError)
-      end
-    end
-  end
-
-  describe ".restore" do
-    context "when object has never been dumped" do
-      it "should raise exception" do
-        expect{ Base.restore(:nonexistant) }.to raise_exception(PulseMeter::RestoreError)
-      end
-    end
-
-    context "when object was dumped" do
-      before do
-        good_obj.dump!
-      end
-
-      it "should keep object class" do
-        Base.restore(good_obj.name).should be_instance_of(good_obj.class)
-      end
-
-      it "should restore object data" do
-        restored = Base.restore(good_obj.name)
-        restored.some_value.should == good_obj.some_value
-      end
-
-      it "should restore last dumped object" do
-        good_obj.some_value = :bar
-        good_obj.dump!(false)
-        restored = Base.restore(good_obj.name)
-        restored.some_value.should == :bar
-      end
-    end
-  end
-
-  describe ".list_names" do
-    context "when redis is not available" do
-      before do
-        PulseMeter.stub(:redis).and_return(nil)
-      end
-
-      it "should raise exception" do
-        expect {Base.list_names}.to raise_exception(PulseMeter::RestoreError)
-      end
-    end
-
-    context "when redis if fine" do
-      it "should return empty list if nothing is registered" do
-        Base.list_names.should == []
-      end
-
-      it "should return list of registered objects" do
-        good_obj.dump!(false)
-        another_good_obj.dump!(false)
-        Base.list_names.should =~ [good_obj.name, another_good_obj.name]
-      end
-    end
-  end
-
-  describe ".list_objects" do
-    before do
-      good_obj.dump!
-      another_good_obj.dump!
-    end
-
-    it "should return restored objects" do
-      objects = Base.list_objects
-      objects.map(&:name).should =~ [good_obj.name, another_good_obj.name]
-    end
-
-    it "should skip unrestorable objects" do
-      Base.stub(:list_names).and_return([good_obj.name, "scoundrel", another_good_obj.name])
-      objects = Base.list_objects
-      objects.map(&:name).should =~ [good_obj.name, another_good_obj.name]
-    end
-  end
-
-  describe "#cleanup_dump" do
-    it "should remove data from redis" do
-      good_obj.dump!
-      another_good_obj.dump!
-      expect {good_obj.cleanup_dump}.to change{good_obj.class.list_names.count}.by(-1)
-    end
-  end
-end

data/spec/pulse_meter/mixins/utils_spec.rb

@@ -1,212 +0,0 @@
-require 'spec_helper'
-
-describe PulseMeter::Mixins::Utils do
-  class Dummy
-    include PulseMeter::Mixins::Utils
-  end
-
-  let(:dummy){ Dummy.new }
-
-  describe '#constantize' do
-    context "when argument is a string with a valid class name" do
-      it "should return class" do
-        dummy.constantize("PulseMeter::Mixins::Utils").should == PulseMeter::Mixins::Utils
-      end
-    end
-    context "when argument is a string with invalid class name" do
-      it "should return nil" do
-        dummy.constantize("Pumpkin::Eater").should be_nil
-      end
-    end
-    context "when argument is not a string" do
-      it "should return nil" do
-        dummy.constantize({}).should be_nil
-      end
-    end
-  end
-
-  describe "#assert_positive_integer!" do
-    it "should extract integer value from hash by passed key" do
-      dummy.assert_positive_integer!({:val => 4}, :val).should == 4
-    end
-
-    context "when no default value given" do
-      context "when the value by the passed key is not integer" do
-        it "should convert non-integers to integers" do
-          dummy.assert_positive_integer!({:val => 4.4}, :val).should == 4
-        end
-
-        it "should change the original value to the obtained integer" do
-          h = {:val => 4.4}
-          dummy.assert_positive_integer!(h, :val).should == 4
-          h[:val].should == 4
-        end
-
-        it "should raise exception if the original value cannot be converted to integer"do
-          expect{ dummy.assert_positive_integer!({:val => :bad_int}, :val) }.to raise_exception(ArgumentError)
-        end
-      end
-
-      it "should raise exception if the value is not positive" do
-        expect{ dummy.assert_positive_integer!({:val => -1}, :val) }.to raise_exception(ArgumentError)
-      end
-
-      it "should raise exception if the value is not defined" do
-        expect{ dummy.assert_positive_integer!({}, :val) }.to raise_exception(ArgumentError)
-      end
-    end
-
-    context "when default value given" do
-      it "should prefer value from options to default" do
-        dummy.assert_positive_integer!({:val => 4}, :val, 22).should == 4
-      end
-
-      it "should use default value when there is no one in options" do
-        dummy.assert_positive_integer!({}, :val, 22).should == 22
-      end
-
-      it "should check default value if it is to be used" do
-        expect{dummy.assert_positive_integer!({}, :val, :bad)}.to raise_exception(ArgumentError)
-        expect{dummy.assert_positive_integer!({}, :val, -1)}.to raise_exception(ArgumentError)
-      end
-    end
-  end
-
-  describe "#assert_array!" do
-    it "should extract value from hash by passed key" do
-      dummy.assert_array!({:val => [:foo]}, :val).should == [:foo]
-    end
-
-    context "when no default value given" do
-      it "should raise exception if th value is not an Array" do
-        expect{ dummy.assert_array!({:val => :bad}, :val) }.to raise_exception(ArgumentError)
-      end
-
-      it "should raise exception if the value is not defined" do
-        expect{ dummy.assert_array!({}, :val) }.to raise_exception(ArgumentError)
-      end
-    end
-
-    context "when default value given" do
-      it "should prefer value from options to default" do
-        dummy.assert_array!({:val => [:foo]}, :val, []).should == [:foo]
-      end
-
-      it "should use default value when there is no one in options" do
-        dummy.assert_array!({}, :val, []).should == []
-      end
-
-      it "should check default value if it is to be used" do
-        expect{dummy.assert_array!({}, :val, :bad)}.to raise_exception(ArgumentError)
-      end
-    end
-  end
-
-  describe "#assert_ranged_float!" do
-
-    it "should extract float value from hash by passed key" do
-      dummy.assert_ranged_float!({:val => 4}, :val, 0, 100).should be_generally_equal(4)
-    end
-
-    context "when the value by the passed key is not float" do
-      it "should convert non-floats to floats" do
-        dummy.assert_ranged_float!({:val => "4.0000"}, :val, 0, 100).should be_generally_equal(4)
-      end
-
-      it "should change the original value to the obtained float" do
-        h = {:val => "4.000"}
-        dummy.assert_ranged_float!(h, :val, 0, 100).should be_generally_equal(4)
-        h[:val].should be_generally_equal(4)
-      end
-
-      it "should raise exception if the original value cannot be converted to float" do
-        expect{ dummy.assert_ranged_float!({:val => :bad_float}, :val, 0, 100) }.to raise_exception(ArgumentError)
-      end
-    end
-
-    it "should raise exception if the value is not within range" do
-      expect{ dummy.assert_ranged_float!({:val => -0.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
-      expect{ dummy.assert_ranged_float!({:val => 100.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
-    end
-
-    it "should raise exception if the value is not defined" do
-      expect{ dummy.assert_ranged_float!({}, :val) }.to raise_exception(ArgumentError)
-    end
-  end
-
-  describe "#uniqid" do
-    it "should return uniq strings" do
-      uniq_values = (1..1000).map{|_| dummy.uniqid}
-      uniq_values.uniq.count.should == uniq_values.count
-    end
-  end
-
-  describe "#titleize" do
-    it "should convert identificator to title" do
-      dummy.titleize("aaa_bbb").should == 'Aaa Bbb'
-      dummy.titleize(:aaa_bbb).should == 'Aaa Bbb'
-      dummy.titleize("aaa bbb").should == 'Aaa Bbb'
-    end
-  end
-
-  describe "#camelize" do
-    it "should camelize string" do
-      dummy.camelize("aa_bb_cc").should == "aaBbCc"
-      dummy.camelize("aa_bb_cc", true).should == "AaBbCc"
-    end
-  end
-
-  describe "#underscore" do
-    it "should underscore string" do
-      dummy.underscore("aaBbCc").should == "aa_bb_cc"
-      dummy.underscore("AaBbCc").should == "aa_bb_cc"
-      dummy.underscore("aaBb::Cc").should == "aa_bb/cc"
-    end
-  end
-
-  describe "#camelize_keys" do
-    it "should deeply camelize keys in hashes" do
-      dummy.camelize_keys({ :aa_bb_cc => [ { :dd_ee => 123 }, 456 ] }).should =={ 'aaBbCc' => [ { 'ddEe' => 123 }, 456 ] }
-    end
-  end
-
-  describe "#symbolize_keys" do
-    it "should convert symbolizable keys to symbols" do
-      dummy.symbolize_keys({"a" => 5, 6 => 7}).should == {a: 5, 6 => 7}
-    end
-  end
-
-  describe "#subsets_of" do
-    it "returns all subsets of given array" do
-      dummy.subsets_of([1, 2]).sort.should == [[], [1], [2], [1, 2]].sort
-    end
-  end
-
-  describe "#each_subset" do
-    it "iterates over each subset" do
-      subsets = []
-      dummy.each_subset([1, 2]) {|s| subsets << s}
-      subsets.sort.should == [[], [1], [2], [1, 2]].sort
-    end
-  end
-
-  describe '#parse_time' do
-    context "when argument is a valid YYYYmmddHHMMSS string" do
-      it "should correct Time object" do
-        t = dummy.parse_time("19700101000000")
-        t.should be_kind_of(Time)
-        t.to_i.should == 0
-      end
-    end
-    context "when argument is an invalid YYYYmmddHHMMSS string" do
-      it "should raise ArgumentError" do
-        expect{ dummy.parse_time("19709901000000") }.to raise_exception(ArgumentError)
-      end
-    end
-    context "when argument is not a YYYYmmddHHMMSS string" do
-      it "should raise ArgumentError" do
-        expect{ dummy.parse_time("197099010000000") }.to raise_exception(ArgumentError)
-      end
-    end
-  end
-end