cs 0.1.0beta3 → 0.1.0

data/spec/lib/cs/relation/group_relation_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module CS
+  module Relation
+    describe GroupRelation do
+
+      let(:relation) do
+        relation = GroupRelation.new
+        relation.stub("check_session!").and_return(true)
+        relation.stub("get_data").and_return(groups)
+        relation
+      end
+
+      let(:groups) do
+        {
+          "groups" =>  [
+          {
+            "accepted" => false,
+            "id" => "4765",
+            "name" => "Group 1",
+            "description" => "Group 1",
+            "public" => false
+          },
+            {
+            "accepted" => false,
+            "id" => "3155",
+            "name" => "Testgroep",
+            "description" => "",
+            "public" => true
+          },
+            {
+            "accepted" => true,
+            "id" => "6072",
+            "name" => "ahmy test group",
+            "description" => "ahmy test group",
+            "public" => true
+          }
+        ]
+      }
+      end
+
+      let(:relation) do
+        relation = GroupRelation.new
+        relation.stub("check_session!").and_return(true)
+        relation.stub("get_data!").and_return(groups)
+        relation
+      end
+
+      describe "get_data!" do
+        it "should fetch groups from commonSense" do
+          session = double('Session')
+          option = {page: 100, per_page: 99, public: 1, total:1, sort: "ASC", sort_field: "name"}
+          session.should_receive(:get).with("/groups.json", option)
+
+          relation = GroupRelation.new(session)
+          relation.get_data!(page: 100, per_page: 99, public:1, total:1, sort:"ASC", sort_field:"name")
+        end
+      end
+
+      describe "each" do
+        it "should get all users group  and yield each" do
+          session = double('Session')
+          relation = GroupRelation.new(session)
+          relation.stub("get_data!").and_return(groups)
+
+          expect { |b| relation.each(&b) }.to yield_successive_args(EndPoint::Group, EndPoint::Group, EndPoint::Group)
+        end
+
+        context "limit specified" do
+          it "should yield sensor at most specified by limit" do
+            relation.limit(1).to_a.count.should eq(1)
+          end
+        end
+      end
+
+      describe "count" do
+        it "should return the total number of record" do
+          relation.count.should eq(3)
+        end
+      end
+
+      describe "first" do
+        it "should return the first record" do
+          first = relation.first
+          first.should be_kind_of(EndPoint::Group)
+          first.name.should eq("Group 1")
+        end
+      end
+      
+      describe "last" do
+        it "should return the last record" do
+          relation = GroupRelation.new
+          relation.stub("count").and_return(3)
+          relation.should_receive("get_data").with(page:2, per_page:1, public:1, total:1, sort:'ASC', sort_field:'email').and_return({"groups" => [{"name" => "Group 1"}], "total" => 3})
+
+          first = relation.where(public: true, total: true, sort:'ASC', sort_field:'email').last
+          first.should be_kind_of(EndPoint::Group)
+          first.name.should eq("Group 1")
+        end
+      end
+    end
+  end
+end

data/spec/lib/cs/relation/sensor_data_relation_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+module CS
+  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
+          date = 1
+          value = 1
+          sensor_data = SensorDataRelation.new(sensor_id).build(date: date, value: value)
+          sensor_data.should be_a_kind_of(EndPoint::SensorData)
+          sensor_data.sensor_id.should == sensor_id
+          sensor_data.date.to_f.should == date
+          sensor_data.value.should == value
+        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, sensor_id: sensor_id}
+          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 "each_batch" do
+        it "should yield data to with multiple pages" do
+          sensor_id = 1
+          session = double("Session")
+          relation = SensorDataRelation.new(sensor_id, session)
+          relation.should_receive(:get_data!).once.ordered.with({page: 0, per_page: 3, sensor_id: sensor_id})
+            .and_return (data)
+          relation.should_receive(:get_data!).once.ordered.with({page: 1, per_page: 3, sensor_id: sensor_id})
+            .and_return (data)
+          relation.should_receive(:get_data!).once.ordered.with({page: 2, per_page: 3, sensor_id: sensor_id})
+            .and_return ({ "data" => [] })
+
+          relation.page = 0
+          relation.per_page = 3
+          relation.each_batch {}
+        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
+
+        it "should return an sensor data with sensor_id" do
+          relation.each {|data| data.sensor_id.should == "1" }
+        end
+
+        context "limit specified" do
+          it "should yield sensor at most specified by limit" do
+            relation.limit(1).to_a.count.should eq(1)
+          end
+        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")
+          sensor_id = "1"
+          option = { page: 0, per_page: 1, sort: 'ASC', sensor_id: sensor_id}
+          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.to_f.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")
+          sensor_id = "1"
+          option = { page: 0, per_page: 1, sort: 'DESC', sensor_id: sensor_id}
+          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.to_f.should eq(1364257203.315)
+          last.month.should eq(3)
+          last.week.should eq(13)
+          last.year.should eq(2013)
+        end
+      end
+    end
+  end
+end

data/spec/lib/cs/relation/sensor_relation_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+require 'cs/end_point/sensor'
+
+module CS
+  module Relation
+    describe SensorRelation do
+      describe "build" do
+        it "should return a sensor object" do
+          SensorRelation.new.build.should be_a_kind_of(EndPoint::Sensor)
+        end
+      end
+
+      let(:sensors) {
+        {"sensors" => [{"name" => "sensor1"}, {"name" => "sensor2"}, {"name" => "sensor3"}], "total" => 3}
+      }
+
+      let(:relation) {
+        relation = SensorRelation.new
+        relation.stub("check_session!").and_return(true)
+        relation.stub("get_data!").and_return(sensors)
+        relation
+      }
+
+      describe "get_data!" do
+        it "should fetch sensor data from commonSense" do
+          session = double('Session')
+          option = {page: 100, per_page: 99, shared: 1, owned:1, physical: 1, details: "full"}
+          session.should_receive(:get).with("/sensors.json", option)
+
+          relation = SensorRelation.new(session)
+          relation.get_data!(page: 100, per_page: 99, shared:true, owned:true, physical:true, details:"full")
+        end
+      end
+
+      describe "each" do
+        it "should get all sensor and yield each" do
+          session = double('Session')
+          relation = SensorRelation.new(session)
+          relation.stub("get_data!").and_return(sensors)
+
+          expect { |b| relation.each(&b) }.to yield_successive_args(EndPoint::Sensor, EndPoint::Sensor, EndPoint::Sensor)
+        end
+
+        context "empty result" do
+          it "should not yield control" do
+            session = double('Session')
+            relation = SensorRelation.new(session)
+            relation.stub("get_data!").and_return({"sensors" => [], "total" => 0})
+
+            expect { |b| relation.each(&b) }.not_to yield_control
+          end
+        end
+
+        context "limit specified" do
+          it "should yield sensor at most specified by limit" do
+            relation.limit(1).to_a.count.should eq(1)
+          end
+        end
+      end
+
+      describe "count" do
+        it "should return the total number of record" do
+          relation.count.should eq(3)
+        end
+      end
+
+      describe "first" do
+        it "should return the first record" do
+          first = relation.first
+          first.should be_kind_of(EndPoint::Sensor)
+          first.name.should eq("sensor1")
+        end
+      end
+
+      describe "last" do
+        it "should return the last record" do
+          relation = SensorRelation.new
+          relation.stub("count").and_return(3)
+          relation.should_receive("get_data").with(page:2, per_page:1).and_return({"sensors" => [{"name" => "sensor3"}], "total" => 3})
+
+          first = relation.last
+          first.should be_kind_of(EndPoint::Sensor)
+          first.name.should eq("sensor3")
+        end
+
+        context "with parameters given" do
+          it "should return the last record with options" do
+            relation = SensorRelation.new
+            relation.stub("count").and_return(3)
+            relation.should_receive("get_data").with(page:2, per_page:1, shared:1, owned:1, physical:1, details:'full').and_return({"sensors" => [{"name" => "sensor3"}], "total" => 3})
+
+            first = relation.where(shared: true, owned: true, physical:true, details: 'full').last
+            first.should be_kind_of(EndPoint::Sensor)
+            first.name.should eq("sensor3")
+          end
+        end
+      end
+
+      describe "find_by_name" do
+        before(:each) do
+          @relation = SensorRelation.new
+          @relation.session = double('Session')
+          @relation.stub("count").and_return(3)
+          @relation.should_receive("get_data!").with(page:0, per_page:1000).and_return({"sensors" => [{"name" => "sensor11"}, {"name" => "sensor12"}, {"name" => "sensor2"}], "total" => 3})
+        end
+
+        it "should return an array of matching sensor name by string" do
+          sensors = @relation.find_by_name("sensor11")
+          sensors.should be_kind_of(Array)
+          sensors.size.should eq(1)
+          sensors[0].name.should eq("sensor11")
+        end
+
+        it "should return an array of matching sensor by regex" do
+          sensors = @relation.find_by_name(/.*sor1/)
+          sensors.should be_kind_of(Array)
+          sensors.size.should eq(2)
+          sensors[0].name.should eq("sensor11")
+          sensors[1].name.should eq("sensor12")
+        end
+      end
+
+      describe "find_or_new" do
+        context "there is already sensor matching criteria" do
+          it "should return that sensor" do
+            relation = SensorRelation.new
+            relation.session = double('Session')
+            relation.stub("count").and_return(1)
+            relation.should_receive("get_data!").with(page:0, per_page:1000).and_return({"sensors" => [{
+              id: "143353",
+              name: "sensor1",
+              type: "1",
+              device_type: "Android",
+              pager_type: "pager1",
+              display_name: "Sensor1",
+              data_type: "json",
+              data_structure: "{\"foo\": \"integer\"}"
+            }], "total" => 1})
+
+            attributes = {name: 'sensor1', display_name: 'Sensor1',
+              device_type: 'Android', pager_type: 'pager1',
+              data_type: 'json', data_structure: {"foo" => 'integer'}}
+
+            sensor = relation.find_or_new(attributes)
+            sensor.should be_kind_of(EndPoint::Sensor)
+            sensor.id.should_not be_nil
+            attributes.each do |key, value|
+              sensor.parameter(key).should eq(value)
+            end
+          end
+        end
+
+        context "there is no sensor matching criteria" do
+          it "should return new sensor object" do
+            attributes = {name: 'sensor1', display_name: 'Sensor1',
+              device_type: 'Android', pager_type: 'pager1',
+              data_type: 'json', data_structure: {"foo" => 'integer'}}
+
+            relation.session = double('session')
+            sensor = relation.find_or_new(attributes)
+            sensor.should be_kind_of(EndPoint::Sensor)
+            sensor.session.should_not be_nil
+            sensor.id.should be_nil
+            attributes.each do |key, value|
+              sensor.parameter(key).should eq(value)
+            end
+          end
+        end
+      end
+
+      describe "find_or_create" do
+        context "there is no sensor matching criteria" do
+          it "should return create sensor object" do
+            attributes = {name: 'sensor1', display_name: 'Sensor1',
+              device_type: 'Android', pager_type: 'pager1',
+              data_type: 'json', data_structure: {"foo" => 'integer'}}
+
+            expected = EndPoint::Sensor.new(attributes)
+            expected.should_receive(:save!)
+            relation.stub('find_or_new').and_return(expected)
+
+            sensor = relation.find_or_create!(attributes)
+            sensor.should be_kind_of(EndPoint::Sensor)
+            attributes.each do |key, value|
+              sensor.parameter(key).should eq(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end