cs 0.1.0beta3

data/spec/lib/commonsense-ruby-lib/end_point/sensor_data_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module CommonSense
+  module EndPoint
+    describe SensorData do
+
+      let!(:value) do
+        {"x-axis" => 1.0, "y-axis" => 2.0, "z-axis" => 3.0}
+      end
+
+      let!(:now) do
+        Time.now.to_f
+      end
+
+      describe "Initiating new data point" do
+        it "should assign the data point property on initialize" do
+          data = SensorData.new(sensor_id: 1, date: now, value: value)
+
+          data.sensor_id.should eq(1)
+          data.date.should eq(now)
+          data.value.should eq(value)
+        end
+      end
+
+      describe "Creating" do
+        it "should create a new data point" do
+          data = SensorData.new(sensor_id: 1, date: now, value: value)
+
+          session = double("CommonSense::Session")
+          session.should_receive(:post).with("/sensors/1/data.json", {data: [{date: now, value: value.to_json}]})
+          session.stub(:response_headers => {"location" => "http://foo.bar/sensors/1/data/1"})
+          session.stub(:response_code => 201)
+          data.session = session
+
+          data.create!.should be_true
+        end
+      end
+
+      describe "Get specific data point" do
+        it "should request data point from commonSense" do
+          data = SensorData.new
+          expect { data.retrieve!.should }.to raise_error(Error::NotImplementedError)
+        end
+      end
+
+      describe "Update specific data point" do
+        it "should request data point from commonSense" do
+          data = SensorData.new
+          expect { data.retrieve!.should }.to raise_error(Error::NotImplementedError)
+        end
+      end
+
+      describe "Delete specific data point" do
+        it "should perform DELETE request to commonSense" do
+          data = SensorData.new(sensor_id: 1, id: "abcdef")
+
+          session = double("CommonSense::Session")
+          session.should_receive(:delete).with("/sensors/1/data/abcdef.json")
+          session.stub(:response_code => 200)
+          data.session = session
+
+          data.delete!.should be_true
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/commonsense-ruby-lib/end_point/sensor_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+module CommonSense
+  module EndPoint
+    describe SensorData do
+
+      let(:sensor_info) do
+        {
+          name: "accelerometer",
+          display_name: "Accelerometer",
+          device_type: "BMA123",
+          pager_type: "email",
+          data_type: "json",
+          data_structure: {"x-axis" => "Float", "y-axis" => "Float", "z-axis" => "Float"}
+        }
+      end
+
+      describe "Initiating new sensor" do
+        it "should assign the data point property on initialize" do
+          info = sensor_info
+          info[:id] = 1
+          sensor = Sensor.new(info)
+          sensor.id.should eq(1)
+          sensor.name.should eq(info[:name])
+          sensor.display_name.should eq(info[:display_name])
+          sensor.device_type.should eq(info[:device_type])
+          sensor.pager_type.should eq(info[:pager_type])
+          sensor.data_type.should eq(info[:data_type])
+          sensor.data_structure.should eq(info[:data_structure])
+        end
+      end
+
+      describe "Creating" do
+        it "should POST to /sensors.json" do
+          sensor = Sensor.new(sensor_info)
+
+          session = double("CommonSense::Session")
+          expected = {sensor: sensor_info }
+          expected[:sensor][:data_structure] = (sensor_info[:data_structure].to_json)
+          session.should_receive(:post).with("/sensors.json", expected)
+          session.stub(:response_headers => {"location" => "http://foo.bar/sensors/1"})
+          session.stub(:response_code => 201)
+          sensor.session = session
+
+          sensor.save!.should be_true
+        end
+      end
+
+      describe "Get specific data point" do
+        it "should request GET to /sensors/:id.json" do
+          sensor = Sensor.new(sensor_info)
+          sensor_id = 1
+          sensor.id = sensor_id
+
+          session = double("CommonSense::Session")
+          session.should_receive(:get).with("/sensors/#{sensor_id}.json")
+          session.stub(:response_code => 200)
+          sensor.session = session
+
+          sensor.retrieve!.should be_true
+        end
+      end
+
+      describe "Update specific data point" do
+        it "should request data point from commonSense" do
+          sensor = Sensor.new(sensor_info)
+          sensor_id = 1
+          sensor.id = sensor_id
+
+          session = double("CommonSense::Session")
+          expected = {sensor: sensor_info }
+          expected[:sensor][:data_structure] = (sensor_info[:data_structure].to_json)
+          expected[:sensor][:id] = 1
+          session.should_receive(:put).with("/sensors/#{sensor_id}.json", expected)
+          session.stub(:response_code => 200)
+          sensor.session = session
+
+          sensor.save!.should be_true
+        end
+      end
+
+      describe "Delete specific data point" do
+        it "should perform DELETE request to commonSense" do
+          sensor = Sensor.new(sensor_info)
+          sensor_id = 1
+          sensor.id = sensor_id
+
+          session = double("CommonSense::Session")
+          session.should_receive(:delete).with("/sensors/#{sensor_id}.json")
+          session.stub(:response_code => 200)
+          sensor.session = session
+
+          sensor.delete!.should be_true
+        end
+      end
+    end
+  end
+end

data/spec/lib/commonsense-ruby-lib/end_point/user_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'commonsense-ruby-lib/error'
+
+module CommonSense
+  module EndPoint
+    describe User do
+      def valid_user
+        {
+          id: 1, email: "foo@bar.com", username: "foo@bar.com", name: "foo",
+          surname: "bar", address: "foo", zipcode: "12345", country: "NL",
+          mobile: "12345", uuid: "12345", openid: "12345"
+        }
+      end
+
+      describe "current_user" do
+        it "should return current logged in user" do
+          user = User.new
+          session = double("CommonSense::Session")
+          session.stub(:get).with("/users/current.json").and_return({"user" => valid_user}) 
+
+          user.stub(:session).and_return(session);
+
+          user.current_user.should_not be_nil
+          valid_user.each {|key, value| user.send(key).should eq(value) }
+        end
+      end
+
+
+      describe "save" do
+
+        describe "with id specified" do
+        end
+      end
+    end
+  end
+end

data/spec/lib/commonsense-ruby-lib/end_point_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+module CommonSense
+  describe EndPoint do
+    before(:each) do
+      class FooEndPoint
+        include EndPoint
+        attribute :attribute1, :attribute2
+        resources :foos
+        resource :foo
+      end
+    end
+
+    let(:valid_foo) do
+      {
+        id: 1,
+        attribute1: "attribute1",
+        attribute2: "attribute2"
+      }
+    end
+
+    let(:valid_foo_response) do
+      {
+        "id" => 1,
+        "attribute1" => "attribute1",
+        "attribute2" => "attribute2"
+      }
+    end
+
+    describe "save!" do
+      describe "without a session" do
+        it "should raise Error::SessionException" do
+          expect {
+            foo = FooEndPoint.new
+            foo.save!
+          }.to raise_error(Error::SessionEmptyError)
+        end
+      end
+
+      describe "without id" do
+        it "should call create" do
+          foo = FooEndPoint.new
+          foo.session = double("CommonSense::Session")
+          foo.should_receive(:create!)
+          foo.save!
+        end
+      end
+
+      describe "with id" do
+        it "should call update" do
+          foo = FooEndPoint.new
+          foo.session = double("CommonSense::Session")
+          foo.id = 1
+          foo.should_receive(:update!)
+          foo.save!
+        end
+      end
+    end
+
+    describe "save" do
+      it "should not raise error" do
+        foo = FooEndPoint.new
+        foo.session = double("CommonSense::Session")
+        foo.should_receive(:create!).and_return { raise Error }
+        foo.save.should be_false
+      end
+    end
+
+    describe "create!" do
+      it "should POST resource to CommonSense" do
+        foo_data = valid_foo
+        foo_data.delete(:id)
+        foo = FooEndPoint.new(foo_data)
+        session = double("CommonSense::Session")
+        session.should_receive(:post).with("/foos.json", {foo: foo_data}).and_return({"foo" => valid_foo})
+        session.stub(:response_headers => {"location" => "http://foo.bar/foos/1"})
+        session.stub(:response_code => 201)
+        foo.stub(:session).and_return(session);
+
+        foo.create!.should be_true
+        foo.id.should eq("1")
+      end
+
+      it "should raise exception where recive error (not 201) from commonSense" do
+        expect {
+          foo = FooEndPoint.new
+          session = double("CommonSense::Session")
+          session.stub(:post)
+          session.stub(response_code: 409)
+          session.stub(:errors)
+          foo.session = session
+          foo.create!
+        }.to raise_error(Error::ResponseError)
+      end
+    end
+
+    describe "create" do
+      it "should not raise exception" do
+        foo = FooEndPoint.new
+        foo.stub(:create!).and_return { raise Error }
+        foo.create.should be_false
+      end
+    end
+
+    describe "retrive!" do
+      it "should raise exception with no id" do
+        expect {
+          foo = FooEndPoint.new
+          foo.session = double("CommonSense::Session")
+          foo.retrieve!
+        }.to raise_error(Error::ResourceIdError)
+      end
+
+      it "should GET Resource from CommonSense" do
+        foo = FooEndPoint.new(id: 1)
+        session = double("CommonSense::Session")
+        session.should_receive(:get).with("/foos/1.json").and_return({"foo" => valid_foo})
+        session.stub(:response_code => 200)
+        foo.session = session
+
+        result = foo.retrieve!
+        result.should be_true
+        foo.id.should eq(1)
+        foo.attribute1.should eq("attribute1")
+        foo.attribute2.should eq("attribute2")
+      end
+    end
+
+    describe "retrieve" do
+      it "should not raise error" do
+        foo = FooEndPoint.new
+        foo.stub(:retrieve!).and_return { raise Error }
+        foo.retrieve.should be_false
+      end
+    end
+
+    describe "update!" do
+      it "should PUT Resource to CommonSense" do
+        foo_data = valid_foo
+        foo = FooEndPoint.new(foo_data)
+        session = double("CommonSense::Session")
+        session.should_receive(:put).with("/foos/1.json", {foo: foo_data}).and_return({"foo" => valid_foo})
+        session.stub(:response_code => 200)
+        foo.session = session
+
+        foo.update!.should be_true
+      end
+    end
+
+    describe "update" do
+      it "should not raise error" do
+        foo = FooEndPoint.new
+        foo.stub(:update!).and_return { raise Error }
+        foo.update.should be_false
+      end
+    end
+
+    describe "delete!" do
+      it "should raise exception with no id" do
+        expect {
+          foo = FooEndPoint.new
+          foo.session = double("CommonSense::Session")
+          foo.delete!
+        }.to raise_error(Error::ResourceIdError)
+
+      end
+
+      it "should DELETE Resource from CommonSense" do
+        foo = FooEndPoint.new(id: 1)
+        session = double("CommonSense::Session")
+        session.should_receive(:delete).with("/foos/1.json")
+        session.stub(:response_code => 200)
+        foo.session = session
+
+        result = foo.delete!
+        result.should be_true
+        foo.id.should be_nil
+      end
+    end
+
+    describe "delete" do
+      it "should not raise error" do
+        foo = FooEndPoint.new
+        foo.session = double("CommonSense::Session")
+        foo.stub(:delete!).and_return { raise Error }
+        foo.delete.should be_false
+      end
+    end
+  end
+end

data/spec/lib/commonsense-ruby-lib/relation/sensor_data_relation_spec.rb

@@ -0,0 +1,444 @@
+require 'spec_helper'
+
+module CommonSense
+  module Relation
+    describe SensorDataRelation do
+
+      let(:relation) do
+        relation = SensorDataRelation.new
+        relation.stub("check_session!").and_return(true)
+        relation.stub("get_data").and_return(sensors)
+        relation
+      end
+
+      let(:data) do
+        {
+          "data" => [{
+            "id" => "5150e509b4b735f6290238d3",
+            "sensor_id" => "1",
+            "value" => "{\"x-axis\":0.259,\"y-axis\":-0.15,\"z-axis\":-9.807}",
+            "date" => 1364256004.651,
+            "month" => 3,
+            "week" => 13,
+            "year" => 2013
+          },
+          {
+            "id" => "5150e760b4b735fa29027b27",
+            "sensor_id" => "1",
+            "value" => "{\"x-axis\":0.191,\"y-axis\":0.069,\"z-axis\":-9.875}",
+            "date" => 1364256603.675,
+            "month" => 3,
+            "week" => 13,
+            "year" => 2013
+          },
+          {
+            "id" => "5150e9b7b4b735d04e010ed9",
+            "sensor_id" => "1",
+            "value" => "{\"x-axis\":0.191,\"y-axis\":-0.028,\"z-axis\":-9.766}",
+            "date" => 1364257203.315,
+            "month" => 3,
+            "week" => 13,
+            "year" => 2013
+          }]
+        }
+      end
+
+      let(:relation) do
+        sensor_id = "1"
+        relation = SensorDataRelation.new(sensor_id)
+        relation.stub("check_session!").and_return(true)
+        relation.stub("get_data!").and_return(data)
+        relation
+      end
+
+      describe "build" do
+        it "should return a sensorData object" do
+          sensor_id = 1
+          SensorDataRelation.new(sensor_id).build.should be_a_kind_of(EndPoint::SensorData)
+        end
+      end
+
+      describe "get_data!" do
+        it "should fetch the data point from commonSense" do
+          sensor_id = 1
+          session = double("Session")
+          option = { page: 100, per_page: 99, start_date: 1365278885,
+            end_date: 1365278886, last: 1, sort: 'ASC', interval: 300 }
+          session.should_receive(:get).with("/sensors/#{sensor_id}/data.json", option)
+
+          relation = SensorDataRelation.new(sensor_id, session)
+          relation.get_data!(page:100, per_page: 99, start_date: 1365278885,
+                             end_date: 1365278886, last: true, sort: 'ASC', interval: 300)
+        end
+      end
+
+      describe "get_data" do
+        it "call get_data! and not throw exception" do
+          sensor_id = 1
+          relation = SensorDataRelation.new(sensor_id)
+          relation.stub(:get_data!).and_return { raise Error }
+
+          expect { relation.get_data }.to_not raise_error
+          relation.get_data.should be_nil
+        end
+      end
+
+      describe "each" do
+        it "should get all sensor data based on the criteria and yield" do
+          expect { |b| relation.each(&b) }.to yield_successive_args(EndPoint::SensorData, EndPoint::SensorData, EndPoint::SensorData)
+        end
+      end
+
+      describe "count" do
+        it "should return the total number of sensor data match with criteria" do
+          relation.count.should eq(3)
+        end
+      end
+
+      describe "first" do
+        it "should return the first record" do
+          session = double("Session")
+          option = { page: 0, per_page: 1, sort: 'ASC'}
+          sensor_id = "1"
+          response = {
+            "data" => [{
+              "id" => "5150e509b4b735f6290238d3",
+              "sensor_id" => sensor_id,
+              "value" => "{\"x-axis\":0.259,\"y-axis\":-0.15,\"z-axis\":-9.807}",
+              "date" => 1364256004.651,
+              "month" => 3,
+              "week" => 13,
+              "year" => 2013
+            }]
+          }
+
+          session.should_receive(:get).with("/sensors/#{sensor_id}/data.json", option).and_return(response)
+          relation = SensorDataRelation.new(sensor_id, session)
+
+          first = relation.first
+          first.id.should eq("5150e509b4b735f6290238d3")
+          first.sensor_id.should eq("1")
+          first.value.should eq("{\"x-axis\":0.259,\"y-axis\":-0.15,\"z-axis\":-9.807}")
+          first.date.should eq(1364256004.651)
+          first.month.should eq(3)
+          first.week.should eq(13)
+          first.year.should eq(2013)
+        end
+      end
+
+      describe "last" do
+        it "should return the last record" do
+          session = double("Session")
+          option = { page: 0, per_page: 1, sort: 'DESC'}
+          sensor_id = "1"
+          response = {
+            "data" => [{
+              "id" => "5150e9b7b4b735d04e010ed9",
+              "sensor_id" => sensor_id,
+              "value" => "{\"x-axis\":0.191,\"y-axis\":-0.028,\"z-axis\":-9.766}",
+              "date" => 1364257203.315,
+              "month" => 3,
+              "week" => 13,
+              "year" => 2013
+            }]
+          }
+          session.should_receive(:get).with("/sensors/#{sensor_id}/data.json", option).and_return(response)
+          relation = SensorDataRelation.new(sensor_id, session)
+
+          last = relation.last
+          last.id.should eq("5150e9b7b4b735d04e010ed9")
+          last.sensor_id.should eq("1")
+          last.value.should eq("{\"x-axis\":0.191,\"y-axis\":-0.028,\"z-axis\":-9.766}")
+          last.date.should eq(1364257203.315)
+          last.month.should eq(3)
+          last.week.should eq(13)
+          last.year.should eq(2013)
+        end
+      end
+
+      describe "where" do
+        before(:each) do
+          sensor_id = 1
+          @relation = SensorDataRelation.new(sensor_id)
+          @relation.stub("check_session!").and_return(true)
+        end
+
+        describe "page" do
+          it "should update page" do
+            @relation.where(page: 2)
+            @relation.page.should eq(2)
+          end
+        end
+
+        describe "per_page" do
+          it "should update per_page" do
+            @relation.where(per_page: 99)
+            @relation.per_page.should eq(99)
+          end
+        end
+
+        describe "start_date" do
+          describe "number given" do
+            it "should update the start_date" do
+              @relation.where(start_date: 2)
+              @relation.start_date.to_f.should eq(2.0)
+              @relation.start_date.should be_kind_of(Time)
+            end
+          end
+
+          describe "Time given" do
+            it "should update the start_date" do
+              @relation.where(start_date: Time.at(19))
+              @relation.start_date.to_f.should eq(19)
+            end
+          end
+
+          describe "Object that respond to 'to_time` given" do
+            it "should update the start_date" do
+              double = double()
+              double.should_receive(:to_time).and_return (Time.at(2))
+              @relation.where(start_date: double)
+              @relation.start_date.to_f.should eq(2.0)
+              @relation.start_date.should be_kind_of(Time)
+            end
+          end
+
+          describe "Object that not respond to 'to_time' given" do
+            it "should raise error" do
+              expect { @relation.where(end_date: 'foo') }.to raise_error(NoMethodError)
+            end
+          end
+        end
+
+
+        describe "end_date" do
+          describe "number given" do
+            it "should update the end_date" do
+              @relation.where(end_date: 2)
+              @relation.end_date.to_f.should eq(2.0)
+              @relation.end_date.should be_kind_of(Time)
+            end
+          end
+
+          describe "Time given" do
+            it "should update the end_date" do
+              @relation.where(end_date: Time.at(19))
+              @relation.end_date.to_f.should eq(19)
+            end
+          end
+
+          describe "Object that respond to 'to_time` given" do
+            it "should update the end_date" do
+              double = double()
+              double.should_receive(:to_time).and_return (Time.at(2))
+              @relation.where(end_date: double)
+              @relation.end_date.to_f.should eq(2.0)
+              @relation.end_date.should be_kind_of(Time)
+            end
+          end
+
+          describe "Object that not respond to 'to_time' given" do
+            it "should raise error" do
+              expect { @relation.where(end_date: 'foo') }.to raise_error(NoMethodError)
+            end
+          end
+        end
+
+        describe "last" do
+          describe "with boolean value" do
+            it "should update the last parameter" do
+              [true, false].each do |value|
+                @relation.where(last: value)
+                @relation.parameter(:last).should be_true
+              end
+            end
+          end
+
+          describe "with invalid parameter" do
+            it "should assign true" do
+              @relation.where(last: 'a')
+              @relation.parameter(:last).should be_true
+            end
+          end
+        end
+
+        describe "sort" do
+          describe "valid parameter given" do
+            it "should update the sort parameter" do
+              @relation.where(sort: 'ASC')
+              @relation.parameter(:sort).should eq('ASC')
+
+              @relation.where(sort: 'DESC')
+              @relation.parameter(:sort).should eq('DESC')
+            end
+          end
+
+          describe "invalid parameter given" do
+            it "should set parameter to nil" do
+              expect { @relation.where(sort: 'foo') }.to raise_error(ArgumentError)
+            end
+          end
+        end
+
+        describe "interval" do
+          describe "valid parameter given" do
+            it "should update the sort parameter" do
+              [604800, 86400, 3600, 1800, 600, 300, 60].each do |interval|
+                @relation.where(interval: interval)
+                @relation.interval.should eq(interval)
+              end
+            end
+          end
+
+          describe "invalid parameter given" do
+            it "should set the parameter to nil" do
+              expect { @relation.where(interval: 10) }.to raise_error(ArgumentError)
+              expect { @relation.where(interval: 'a') }.to raise_error(ArgumentError)
+            end
+          end
+        end
+
+        describe "from" do
+          describe "number given" do
+            it "should update the end_date" do
+              @relation.where(from: 2)
+              @relation.start_date.to_f.should eq(2.0)
+              @relation.start_date.should be_kind_of(Time)
+            end
+          end
+
+          describe "Time given" do
+            it "should update the end_date" do
+              @relation.where(from: Time.at(19))
+              @relation.start_date.to_f.should eq(19)
+            end
+          end
+
+          describe "Object that respond to 'to_time` given" do
+            it "should update the end_date" do
+              double = double()
+              double.should_receive(:to_time).and_return (Time.at(2))
+              @relation.where(from: double)
+              @relation.start_date.to_f.should eq(2.0)
+              @relation.start_date.should be_kind_of(Time)
+            end
+          end
+
+          describe "Object that not respond to 'to_time' given" do
+            it "should raise error" do
+              expect { @relation.where(from: 'foo') }.to raise_error(NoMethodError)
+            end
+          end
+        end
+
+        describe "to" do
+          describe "number given" do
+            it "should update the end_date" do
+              @relation.where(to: 2)
+              @relation.end_date.to_f.should eq(2.0)
+              @relation.end_date.should be_kind_of(Time)
+            end
+          end
+
+          describe "Time given" do
+            it "should update the end_date" do
+              @relation.where(to: Time.at(19))
+              @relation.end_date.to_f.should eq(19)
+            end
+          end
+
+          describe "Object that respond to 'to_time` given" do
+            it "should update the end_date" do
+              double = double()
+              double.should_receive(:to_time).and_return (Time.at(2))
+              @relation.where(to: double)
+              @relation.end_date.to_f.should eq(2.0)
+              @relation.end_date.should be_kind_of(Time)
+            end
+          end
+
+          describe "Object that not respond to 'to_time' given" do
+            it "should raise error" do
+              expect { @relation.where(to: 'foo') }.to raise_error(NoMethodError)
+            end
+          end
+        end
+      end
+
+      describe "from" do
+        describe "number given" do
+          it "should update the end_date" do
+            relation.from(2)
+            relation.start_date.to_f.should eq(2.0)
+            relation.start_date.should be_kind_of(Time)
+          end
+        end
+
+        describe "Time given" do
+          it "should update the end_date" do
+            relation.from(Time.at(19))
+            relation.start_date.to_f.should eq(19)
+          end
+        end
+
+        describe "Object that respond to 'to_time` given" do
+          it "should update the end_date" do
+            double = double()
+            double.should_receive(:to_time).and_return (Time.at(2))
+            relation.from(double)
+            relation.start_date.to_f.should eq(2.0)
+            relation.start_date.should be_kind_of(Time)
+          end
+        end
+
+        describe "Object that not respond to 'to_time' given" do
+          it "should raise error" do
+            expect { relation.from('foo') }.to raise_error(NoMethodError)
+          end
+        end
+      end
+
+      describe "to" do
+        describe "number given" do
+          it "should update the end_date" do
+            relation.to(2)
+            relation.end_date.to_f.should eq(2.0)
+            relation.end_date.should be_kind_of(Time)
+          end
+        end
+
+        describe "Time given" do
+          it "should update the end_date" do
+            relation.to(Time.at(19))
+            relation.end_date.to_f.should eq(19)
+          end
+        end
+
+        describe "Object that respond to 'to_time` given" do
+          it "should update the end_date" do
+            double = double()
+            double.should_receive(:to_time).and_return (Time.at(2))
+            relation.to(double)
+            relation.end_date.to_f.should eq(2.0)
+            relation.end_date.should be_kind_of(Time)
+          end
+        end
+
+        describe "Object that not respond to 'to_time' given" do
+          it "should raise error" do
+            expect { relation.to('foo') }.to raise_error(NoMethodError)
+          end
+        end
+      end
+
+      describe "all" do
+        it "return array of all matching sensor data" do
+          data = relation.to_a
+          data.should be_a_kind_of(Array)
+          data.size.should eq(3)
+          data[0].should be_a_kind_of(EndPoint::SensorData)
+        end
+      end
+    end
+  end
+end