cs 0.1.0beta3 → 0.1.0

data/lib/commonsense-ruby-lib/session.rb

@@ -1,105 +0,0 @@
-module CommonSense
-  class Session
-    def initialize(opts={})
-      options = {
-        base_uri: 'https://api.sense-os.nl',
-        authentication: true
-      }.merge(opts)
-      @base_uri = options[:base_uri]
-      @auth_proxy = options[:authentication] ? nil : CommonSense::Auth::HTTP.new(@base_uri)
-    end
-
-    # login to commonsense 
-    # @return [String] session_id 
-    def login(username, password)
-      @auth_proxy = CommonSense::Auth::HTTP.new(@base_uri)
-      @auth_proxy.login(username, password)
-    end
-
-    def oauth(consumer_key, consumer_secret, access_token, access_token_secret)
-      @auth_proxy = CommonSense::Auth::OAuth.new(consumer_key, consumer_secret, 
-                                                 access_token, access_token_secret,
-                                                 @base_uri)
-    end
-
-    def session_id
-      auth_proxy.session_id
-    end
-
-    def session_id=(session_id)
-      @auth_proxy = CommonSense::Auth::HTTP.new(@base_uri)
-      @auth_proxy.session_id = session_id
-    end
-
-    def auth_proxy
-      raise 'The session is not logged in' unless @auth_proxy
-      @auth_proxy
-    end
-
-    def get(path, body = '', headers = {})
-      auth_proxy.get(path, body, headers)
-    end
-
-    def post(path, body = '', headers = {})
-      auth_proxy.post(path, body, headers = {})
-    end
-
-    def put(path, body = '', headers = {})
-      auth_proxy.put(path, body, headers)
-    end
-
-    def delete(path, body='', headers = {})
-      auth_proxy.delete(path, body, headers)
-    end
-
-    def head(path, headers = {})
-      auth_proxy.head(path, headers)
-    end
-
-    def response_code 
-      auth_proxy.response_code
-    end
-
-    def response_body
-      auth_proxy.response_body
-    end
-
-    def response_headers
-      auth_proxy.response_headers
-    end
-    
-    def errors
-      auth_proxy.errors
-    end
-
-    def base_uri=(uri = nil)
-      auth_proxy.base_uri = uri
-    end
-
-    def dump_to_text(path)
-      File.open(path, 'w') do |f|
-        f.write("Response Code: #{response_code}\n")
-        f.write("Response Headers: #{response_headers}\n")
-        f.write("Errors: #{errors}\n")
-        f.write("\n")
-        f.write(response_body)
-      end
-    end
-
-    def open_in_browser(path=nil)
-      require 'launchy'
-
-      path ||= "/tmp/common-sense-ruby-#{Time.now.to_i}.html"
-      dump_to_text(path)
-      ::Launchy::Browser.run(path)
-    end
-
-    def to_s
-      "\"#{self.session_id}\""
-    end
-
-    def inspect
-      auth_proxy.kind_of?(CommonSense::Auth::HTTP) ? to_s : "OAuth"
-    end
-  end
-end

data/lib/commonsense-ruby-lib/version.rb

@@ -1,3 +0,0 @@
-module CommonSense
-  VERSION = "0.1.0beta3"
-end

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

@@ -1,68 +0,0 @@
-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/relation/sensor_data_relation_spec.rb

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