pulse-meter 0.2.6 → 0.2.7

data/README.md

@@ -60,9 +60,12 @@ The following timeline sensors are available:
 
   * Average value
   * Counter
+  * Indicator
   * Hashed counter
+  * Hashed indicator
   * Max value
   * Min value
+  * Multifactor sensor
   * Median value
   * Percentile
   * Unique counter

data/lib/pulse-meter/mixins/cmd.rb

@@ -16,7 +16,11 @@ module Enumerable
       end
     else
       self.each_with_object(Terminal::Table.new) do |row, table|
-        table << row.map(&:to_s)
+        table << if row.respond_to?(:map)
+          row.map(&:to_s)
+        else
+          row
+        end
       end
     end
   end

data/lib/pulse-meter/mixins/utils.rb

@@ -15,6 +15,19 @@ module PulseMeter
         nil
       end
 
+      # Ensures that hash value specified by key is Array
+      # @param options [Hash] hash to be looked at
+      # @param key [Object] hash key
+      # @param default [Object] default value to be returned
+      # @raise [ArgumentError] unless value is Array
+      # @return [Array]
+      def assert_array!(options, key, default = nil)
+        value = options[key] || default
+        raise ArgumentError, "#{key} should be defined" unless value
+        raise ArgumentError, "#{key} should be array" unless value.is_a?(Array)
+        value
+      end
+
       # Ensures that hash value specified by key can be converted to positive integer.
       # In case it can makes in-place conversion and returns the value.
       # @param options [Hash] hash to be looked at
@@ -98,6 +111,18 @@ module PulseMeter
           item
         end
       end
+      
+      # Yields block for each subset of given array
+      # @param array [Array] given array
+      def each_subset(array)
+        subsets_of(array).each {|subset| yield(subset)}
+      end
+
+      # Returs all array's subsets
+      # @param array [Array]
+      def subsets_of(array)
+        0.upto(array.length).flat_map { |n| array.combination(n).to_a }
+      end
     end
   end
 end

data/lib/pulse-meter/sensor/configuration.rb

@@ -2,6 +2,9 @@ module PulseMeter
   module Sensor
     class Configuration
       include PulseMeter::Mixins::Utils
+      include Enumerable
+
+      attr_reader :sensors
 
       def initialize(opts = {})
         @sensors = {}
@@ -23,6 +26,12 @@ module PulseMeter
         @sensors[name.to_s]
       end
 
+      def each
+        @sensors.each_value do |sensor|
+          yield(sensor)
+        end
+      end
+
       def method_missing(name, *args)
         name = name.to_s
         if @sensors.has_key?(name)
@@ -43,7 +52,6 @@ module PulseMeter
         entries.unshift('PulseMeter::Sensor').join('::')
       end
 
-
     end
   end
 end

data/lib/pulse-meter/sensor/multi.rb

@@ -0,0 +1,93 @@
+module PulseMeter
+  module Sensor
+    class Multi < Base
+      include PulseMeter::Mixins::Utils
+      include Enumerable
+
+      attr_reader :name
+      attr_reader :factors
+      attr_reader :sensors
+      attr_reader :configuration_options
+
+      # TODO restore in initializer
+
+      def initialize(name, options)
+        @name = name
+        @factors = assert_array!(options, :factors)
+        @sensors = PulseMeter::Sensor::Configuration.new
+        @configuration_options = options[:configuration]
+        raise ArgumentError, "configuration option missing" unless @configuration_options
+      end
+
+      def sensor(name)
+        sensors.sensor(name)
+      end
+
+      def event(factors_hash, value)
+        ensure_valid_factors!(factors_hash)
+
+        each_factors_combination do |combination|
+          factor_values = factor_values_for_combination(combination, factors_hash)
+          sensor = get_or_create_sensor(combination, factor_values)
+          sensor.event(value)
+        end
+      end
+
+      def each
+        sensors.each {|s| yield(s)}
+      end
+
+      def sensor_for_factors(factor_names, factor_values)
+        sensor(
+           get_sensor_name(factor_names, factor_values)
+        )
+      end
+
+      protected
+
+      def is_subsensor?(sensor)
+        sensor.name.start_with?(get_sensor_name([], []).to_s)
+      end
+
+      def get_or_create_sensor(factor_names, factor_values)
+        name = get_sensor_name(factor_names, factor_values)
+        unless sensor(name)
+          sensors.add_sensor(name, configuration_options)
+          dump!(false)
+        end
+        sensor(name)
+      end
+
+      def ensure_valid_factors!(factors_hash)
+        factors.each do |factor_name|
+          unless factors_hash.has_key?(factor_name)
+            raise ArgumentError, "Value of factor #{factor_name} missing"
+          end
+        end
+      end
+
+      def each_factors_combination
+        each_subset(factors) do |combination|
+          yield(combination)
+        end
+      end
+
+      def factor_values_for_combination(combination, factors_hash)
+        combination.each_with_object([]) do |k, acc|
+          acc << factors_hash[k]
+        end
+      end
+
+      def get_sensor_name(factor_names, factor_values)
+        sensor_name = name.to_s
+        unless factor_names.empty?
+          factor_names.zip(factor_values).each do |n, v|
+            sensor_name << "_#{n}_#{v}"
+          end
+        end
+        sensor_name.to_sym
+      end
+
+    end
+  end
+end

data/lib/pulse-meter/sensor/timelined/hashed_indicator.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Saves last registered values for multiple flags per interval.
+      # Good replacement for multiple indicators to be visualized together
+      class HashedIndicator < Timeline
+        def aggregate_event(key, data)
+          data.each_pair do |k, v|
+            redis.hset(key, k, v) if v.respond_to?(:to_f)
+          end
+        end
+
+        def summarize(key)
+          redis.
+            hgetall(key).
+            inject({}) {|h, (k, v)| h[k] = v.to_f; h}.
+            to_json
+        end
+
+        private
+
+        def deflate(value)
+          JSON.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/pulse-meter/sensor/timelined/indicator.rb

@@ -0,0 +1,23 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Saves last registered flag float value for each interval
+      class Indicator < Timeline
+        def aggregate_event(key, value)
+          redis.set(key, value.to_f)
+        end
+
+        def summarize(key)
+          redis.get(key)
+        end
+
+        private
+
+        def deflate(value)
+          value.to_f
+        end
+
+      end
+    end
+  end
+end

data/lib/pulse-meter/sensor.rb

@@ -1,14 +1,17 @@
 require 'pulse-meter/sensor/base'
+require 'pulse-meter/sensor/configuration'
 require 'pulse-meter/sensor/counter'
 require 'pulse-meter/sensor/indicator'
 require 'pulse-meter/sensor/hashed_counter'
 require 'pulse-meter/sensor/hashed_indicator'
-require 'pulse-meter/sensor/remote'
+require 'pulse-meter/sensor/multi'
 require 'pulse-meter/sensor/uniq_counter'
 require 'pulse-meter/sensor/timeline'
 require 'pulse-meter/sensor/timelined/average'
 require 'pulse-meter/sensor/timelined/counter'
+require 'pulse-meter/sensor/timelined/indicator'
 require 'pulse-meter/sensor/timelined/hashed_counter'
+require 'pulse-meter/sensor/timelined/hashed_indicator'
 require 'pulse-meter/sensor/timelined/min'
 require 'pulse-meter/sensor/timelined/max'
 require 'pulse-meter/sensor/timelined/percentile'

data/lib/pulse-meter/version.rb

@@ -1,3 +1,3 @@
 module PulseMeter
-  VERSION = "0.2.6"
+  VERSION = "0.2.7"
 end

data/spec/pulse_meter/mixins/utils_spec.rb

@@ -72,6 +72,36 @@ describe PulseMeter::Mixins::Utils do
     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
@@ -136,6 +166,19 @@ describe PulseMeter::Mixins::Utils 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
 end

data/spec/pulse_meter/sensor/configuration_spec.rb

@@ -1,6 +1,17 @@
 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}
 
@@ -52,8 +63,6 @@ describe PulseMeter::Sensor::Configuration do
       cfg.add_sensor(:foo, Dummy.new)
       cfg.sensor(:foo).annotation.should == "My Foo Counter"
     end
-
-
   end
 
   describe ".new" do
@@ -75,17 +84,25 @@ describe PulseMeter::Sensor::Configuration do
 
   describe "#sensor" do
     it "should give access to added sensors" do
-      opts = {
-        cnt: {
-          sensor_type: 'counter',
-          args: {
-            annotation: "MySensor"
-          }
-        },
-      }
-      cfg = described_class.new(opts)
+      cfg = described_class.new(counter_config)
       cfg.sensor(:cnt).annotation.should == "MySensor"
       cfg.sensor("cnt").annotation.should == "MySensor"
     end
   end
+
+  describe "#sensors" do
+    it "returns hash of sensors" do
+      cfg = described_class.new(counter_config)
+      cfg.sensors.should == {"cnt" => cfg.sensor(:cnt)}
+    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}
+      sensors.should == {:cnt => cfg.sensor(:cnt)}
+    end
+  end
 end

data/spec/pulse_meter/sensor/multi_spec.rb

@@ -0,0 +1,134 @@
+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|
+        s = sensor.sensor(sensor_name)
+        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 "returns 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]).name.should == "#{name}_f1_f1v1_f2_f2v1"
+        sensor.sensor_for_factors([:f1], [:f1v1]).name.should == "#{name}_f1_f1v1"
+      end
+    end
+
+    context "when such a sensor was not created" do
+      it "returns nil" do
+        sensor.sensor_for_factors([:foo], [:bar]).should be_nil
+      end
+    end
+  end
+
+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

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pulse-meter
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-20 00:00:00.000000000 Z
+date: 2012-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gon-sinatra
@@ -343,11 +343,13 @@ files:
 - lib/pulse-meter/sensor/hashed_counter.rb
 - lib/pulse-meter/sensor/hashed_indicator.rb
 - lib/pulse-meter/sensor/indicator.rb
-- lib/pulse-meter/sensor/remote.rb
+- lib/pulse-meter/sensor/multi.rb
 - lib/pulse-meter/sensor/timeline.rb
 - lib/pulse-meter/sensor/timelined/average.rb
 - lib/pulse-meter/sensor/timelined/counter.rb
 - lib/pulse-meter/sensor/timelined/hashed_counter.rb
+- lib/pulse-meter/sensor/timelined/hashed_indicator.rb
+- lib/pulse-meter/sensor/timelined/indicator.rb
 - lib/pulse-meter/sensor/timelined/max.rb
 - lib/pulse-meter/sensor/timelined/median.rb
 - lib/pulse-meter/sensor/timelined/min.rb
@@ -411,11 +413,13 @@ files:
 - spec/pulse_meter/sensor/hashed_counter_spec.rb
 - spec/pulse_meter/sensor/hashed_indicator_spec.rb
 - spec/pulse_meter/sensor/indicator_spec.rb
-- spec/pulse_meter/sensor/remote_spec.rb
+- spec/pulse_meter/sensor/multi_spec.rb
 - spec/pulse_meter/sensor/timeline_spec.rb
 - spec/pulse_meter/sensor/timelined/average_spec.rb
 - spec/pulse_meter/sensor/timelined/counter_spec.rb
 - spec/pulse_meter/sensor/timelined/hashed_counter_spec.rb
+- spec/pulse_meter/sensor/timelined/hashed_indicator_spec.rb
+- spec/pulse_meter/sensor/timelined/indicator_spec.rb
 - spec/pulse_meter/sensor/timelined/max_spec.rb
 - spec/pulse_meter/sensor/timelined/median_spec.rb
 - spec/pulse_meter/sensor/timelined/min_spec.rb
@@ -468,7 +472,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2459703575174503606
+      hash: -450227772948230282
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -485,11 +489,13 @@ test_files:
 - spec/pulse_meter/sensor/hashed_counter_spec.rb
 - spec/pulse_meter/sensor/hashed_indicator_spec.rb
 - spec/pulse_meter/sensor/indicator_spec.rb
-- spec/pulse_meter/sensor/remote_spec.rb
+- spec/pulse_meter/sensor/multi_spec.rb
 - spec/pulse_meter/sensor/timeline_spec.rb
 - spec/pulse_meter/sensor/timelined/average_spec.rb
 - spec/pulse_meter/sensor/timelined/counter_spec.rb
 - spec/pulse_meter/sensor/timelined/hashed_counter_spec.rb
+- spec/pulse_meter/sensor/timelined/hashed_indicator_spec.rb
+- spec/pulse_meter/sensor/timelined/indicator_spec.rb
 - spec/pulse_meter/sensor/timelined/max_spec.rb
 - spec/pulse_meter/sensor/timelined/median_spec.rb
 - spec/pulse_meter/sensor/timelined/min_spec.rb

data/lib/pulse-meter/sensor/remote.rb

@@ -1,60 +0,0 @@
-require 'socket'
-require 'json'
-
-module PulseMeter
-  module Sensor
-
-    # Remote sensor, i.e. a simple UDP proxy for sending data without
-    # taking in account backend performance issues
-    class Remote < Base
-
-      DEFAULT_PORT = 27182
-      DEFAULT_HOST = 'localhost'
-
-      # @!attribute [r] name
-      #   @return [String] sensor name
-      attr_reader :name
-
-      # Initializes sensor and creates UDP socket
-      # @param name [String] sensor name
-      # @option options [Symbol] :host host for remote pulse-meter daemon
-      # @option options [Symbol] :port port for remote pulse-meter daemon
-      # @raise [BadSensorName] if sensor name is malformed
-      # @raise [ConnectionError] if invalid host or port are provided
-      def initialize(name, options={})
-        @name = name.to_s
-        raise BadSensorName, @name unless @name =~ /\A\w+\z/
-        @host = options[:host].to_s || DEFAULT_HOST
-        @port = options[:port].to_i || DEFAULT_PORT
-        @socket = UDPSocket.new
-      end
-
-      # Send value to remote sensor
-      # @param value value for remote sensor
-      # @raise [ConnectionError] if remote daemon is not available
-      # @raise [MessageTooLarge] if event data is too large to be serialized into a UDP datagram
-      def event(value)
-        events(name => value)
-      end
-
-      # Send values to multiple remote sensors
-      # @param event_data hash with remote sensor names as keys end event value for each value as sensor
-      def events(event_data)
-        raise ArgumentError unless event_data.is_a?(Hash)
-        socket_action do
-          @socket.send(event_data.to_json, 0, @host, @port)
-        end
-      end
-
-      private
-
-      def socket_action
-        yield
-      rescue SocketError, Errno::EADDRNOTAVAIL, Errno::EINVAL => exc
-        raise PulseMeter::Remote::ConnectionError, exc.to_s
-      rescue Errno::EMSGSIZE => exc
-        raise PulseMeter::Remote::MessageTooLarge, exc.to_s
-      end
-    end
-  end
-end

data/spec/pulse_meter/sensor/remote_spec.rb

@@ -1,86 +0,0 @@
-require "spec_helper"
-
-describe PulseMeter::Sensor::Remote do
-
-  def data_sent_to(host, port)
-    socket = UDPSocket.new
-    socket.bind(host, port)
-    yield
-    data, _ = socket.recvfrom(65000)
-    socket.close
-    data
-  end
-
-  let(:host){'localhost'}
-  let(:port){56789}
-  let(:sensor){described_class.new(:some_remote_sensor, host: host, port: port)}
-
-  describe "#new" do
-    it "should raise exception if sensor name is bad" do
-      expect{described_class.new("aa bb")}.to raise_exception(PulseMeter::BadSensorName)
-    end
-  end
-
-  describe "#event" do
-    it "should send event data to remote host and port" do
-      data_sent_to(host, port) {
-        sensor.event(123)
-      }.should_not be_empty
-    end
-
-    it "should use sensor name as a single key and sent data as its value" do
-      data = data_sent_to(host, port) do
-        sensor.event(123)
-      end
-      JSON.parse(data).should == {sensor.name => 123}
-    end
-
-    it "should raise MessageTooLarge if message is too long" do
-      expect{ sensor.event("123" * 100000) }.to raise_exception(PulseMeter::Remote::MessageTooLarge)
-    end
-
-
-    it "should raise PulseMeter::Remote::ConnectionError if remote host is invalid" do
-      expect{described_class.new("xxx", host: "bad host").event(123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
-    end
-
-    it "should raise PulseMeter::Remote::ConnectionError if remote port is invalid" do
-      expect{described_class.new("xxx", port: -123).event(123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
-      expect{described_class.new("xxx", port: 'bad port').event(123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
-    end
-
-  end
-
-  describe "#events" do
-    it "should send event data to remote host and port" do
-      data_sent_to(host, port) {
-        sensor.events(a: 1, b: 2)
-      }.should_not be_empty
-    end
-
-    it "should use sensor name as a single key and sent data as its value" do
-      data = data_sent_to(host, port) do
-        sensor.events(a: 1, b: 2)
-      end
-      JSON.parse(data).should == {"a" => 1, "b" => 2}
-    end
-
-    it "should raise ArgumentError if argument is not a hash" do
-      expect{ sensor.events(1213) }.to raise_exception(ArgumentError)
-    end
-
-    it "should raise MessageTooLarge if message is too long" do
-      expect{ sensor.events(a: "x" * 100000) }.to raise_exception(PulseMeter::Remote::MessageTooLarge)
-    end
-
-    it "should raise PulseMeter::Remote::ConnectionError if remote host is invalid" do
-      expect{described_class.new("xxx", host: "bad host").events(a: 123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
-    end
-
-    it "should raise PulseMeter::Remote::ConnectionError if remote port is invalid" do
-      expect{described_class.new("xxx", port: -123).events(a: 123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
-      expect{described_class.new("xxx", port: 'bad port').events(a: 123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
-    end
-  end
-
-end