cs 0.1.0beta3 → 0.1.0

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

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'cs/end_point/user'
+
+module CS
+  module Relation
+    describe UserRelation do
+      let(:users) {
+        {"users" => [{"name" => "user1"}, {"name" => "user2"}, {"name" => "user3"}], "total" => 3}
+      }
+
+      let(:relation) {
+        relation = UserRelation.new
+        relation.stub("check_session!").and_return(true)
+        relation.stub("get_data!").and_return(users)
+        relation
+      }
+
+      describe "get_data!" do
+        it "should fetch sensor data from commonSense" do
+          session = double('Session')
+          option = {page: 100, per_page: 99}
+          session.should_receive(:get).with("/users.json", option)
+
+          relation = UserRelation.new(session)
+          relation.get_data!(page: 100, per_page: 99)
+        end
+      end
+
+      describe "each" do
+        it "should get all user and yield each" do
+          session = double('Session')
+          relation = UserRelation.new(session)
+          relation.stub("get_data!").and_return(users)
+
+          expect { |b| relation.each(&b) }.to yield_successive_args(EndPoint::User, EndPoint::User, EndPoint::User)
+        end
+
+        context "empty result" do
+          it "should not yield control" do
+            session = double('Session')
+            relation = UserRelation.new(session)
+            relation.stub("get_data!").and_return({"users" => [], "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 "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
+    end
+  end
+end

data/spec/lib/cs/relation_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+module CS
+  describe Relation do
+
+    let(:relation) {
+      class Model
+        include Relation
+        parameter :number, Integer
+        parameter :page, Integer, default: 0
+        parameter :per_page, Integer, default: 1000, maximum: 1000
+        parameter :start_date, Time
+        parameter :end_date, Time
+        parameter :date, Time
+        parameter :last, Boolean
+        parameter :sort, String, valid_values: ["ASC", "DESC"]
+        parameter :interval, Integer, valid_values: [604800, 86400, 3600, 1800, 600, 300, 60]
+        parameter :sensor_id, String
+        parameter_alias :from, :start_date
+        parameter_alias :to, :end_date
+      end
+
+      Model.new
+    }
+
+    describe "parameter" do
+
+      context "Integer parameter with default" do
+        it "should assign default parameter" do
+          relation.page.should eq(0)
+        end
+
+        it "should update the parameter" do
+          relation.where(page: 2)
+          relation.page.should eq(2)
+        end
+
+        it "should set only to a maximum number" do
+          relation.where(per_page: 2000)
+          relation.per_page.should eq(1000)
+        end
+
+        it "should raise exception if not a number given" do
+          expect {
+            relation.where(number: 'a')
+          }.to raise_error(ArgumentError, "Received non Integer value for parameter 'number'")
+        end
+      end
+
+      context  "Integer with default value" do
+        describe "valid parameter given" do
+          it "should update the  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
+
+      context "Time parameter given" 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
+
+      context "Boolean parameter given" 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 value not boolean given, should assign true" do
+          it "should assign true" do
+            relation.where(last: 'a')
+            relation.parameter(:last).should be_true
+          end
+        end
+      end
+
+      context "String parameter with valid value" 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
+    end
+
+    describe "get_options" do
+      it "return parameter that have default value" do
+        options = relation.get_options({})
+        options[:page].should eq(0)
+        options[:per_page].should eq(1000)
+      end
+
+      it "should return aliases" do
+        option = relation.where(start_date: 1).get_options
+        option[:start_date].should eq(1)
+      end
+    end
+  end
+end

data/spec/lib/cs/session_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'logger'
+require 'webmock/rspec'
+
+describe "session" do
+
+  let!(:user) do
+    username = "user1@tester.com"
+
+    client = CS::Client.new(base_uri: base_uri)
+    user = client.new_user
+    user.username = username
+    user.email = user.username
+    user.password = 'password'
+    user.name = 'Jan'
+    user.surname = 'jagger'
+    user.address = 'Lloydstraat 5'
+    user.zipcode = '3024ea'
+    user.country = 'NETHERLANDS'
+    user.mobile = '123456789'
+    user
+  end
+
+  describe "login" do
+    describe "with corrent username and password" do
+      it "should create new session" do
+        client = create_client
+        CS::Auth::HTTP.any_instance.stub(login: "1234")
+        session_id = client.login!(user.username, 'password')
+        session_id.should_not be_nil
+        client.session.should_not be_nil
+      end
+    end
+
+    describe "with incorrect username or password" do
+      it "should create new session" do
+        client = create_client
+        CS::Auth::HTTP.any_instance.stub(login: false)
+        session_id = client.login(user.username, "foo")
+        session_id.should be_false
+        client.session.should_not be_nil
+      end
+    end
+  end
+
+  describe "logger" do
+    context "Debug level given" do
+      it "should write to logger (STDOUT)" do
+        client = create_client
+        client.login(user.username, 'password')
+
+        CS::Auth::HTTP.any_instance.stub(get: "")
+
+        session = client.session
+        logger = double().as_null_object
+        session.logger = logger
+        logger.should_receive("info").with("").ordered
+        logger.should_receive("info").with("GET /users/current.json").ordered
+        logger.should_receive("debug").with("headers: {}").ordered
+        session.get('/users/current.json', '',{})
+      end
+    end
+  end
+
+  describe "oauth" do
+    describe "with correct access token" do
+       it "should create new session with oauth" do
+         client = create_client
+         CS::Auth::OAuth.should_receive(:new).with('CS_CONSUMER_KEY', 'CS_CONSUMER_SECRET',
+                                'CS_ACCESS_TOKEN', 'CS_ACCESS_TOKEN_SECRET', base_uri)
+         client.oauth('CS_CONSUMER_KEY', 'CS_CONSUMER_SECRET',
+                                'CS_ACCESS_TOKEN', 'CS_ACCESS_TOKEN_SECRET')
+       end
+    end
+  end
+
+  describe "API_KEY" do
+    it "should append API key in the url" do
+      client = create_client
+      client.api_key = '123456'
+      CS::Auth::HTTP.should_receive(:get).
+        with("/sensors.json?API_KEY=123456",
+             {:query=>{:page=>0, :per_page=>1000},
+              :headers=>{"Content-Type"=>"application/json"}}
+            )
+
+      result = client.sensors
+      result.to_a
+    end
+  end
+end

data/spec/lib/cs/time_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+module CS
+  describe Time do
+
+    context "Initialize with nill" do
+
+      it "should return current time" do
+        ::Time.should_receive(:new).with(no_args())
+
+        Time.new
+      end
+
+    end
+
+    context "initialize with Time object" do
+
+      it "should set date as time" do
+        time = ::Time.new
+        Time.new(time).time.should be_instance_of(::Time)
+      end
+
+    end
+
+    context "initialize with number" do
+
+      it "should set data based on that time" do
+        epoch = 0
+        time = Time.new(epoch)
+        time.should be_instance_of(Time)
+        time.time.to_i.should == 0
+      end
+
+    end
+
+    context "initialize with TimeLord" do
+
+      it "should set time property as ruby Time Object" do
+        require 'time-lord'
+        period = 1.hours.ago
+        period.should be_instance_of(TimeLord::Period)
+        time = Time.new(period)
+        expected = ::Time.new.to_i - 3600
+        time.time.to_i.should be_within(1).of(expected)
+      end
+
+    end
+
+    context "given an object" do
+
+      it "should get the time by calling to_time on that object" do
+        mock = double()
+        t = ::Time.new
+        mock.should_receive(:to_time).and_return(t)
+
+        time = Time.new(mock)
+        time.time.should == t
+
+      end
+
+    end
+
+    it "should proxy object to date" do
+      subject = ::Time.new
+
+      subject.should_receive(:to_f).and_return(3.33333)
+
+      time = Time.new(subject).to_f
+    end
+  end
+end

data/spec/lib/cs_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'webmock/rspec'
+
+module CS
+  describe Client do
+    describe "client with authentication" do
+      let(:client) do
+        create_client
+      end
+
+      let!(:logged_in_client) do
+        client = CS::Client.new(base_uri: base_uri)
+        client.session_id = '123499'
+        client
+      end
+
+      describe "current_user" do
+        it "should return current user information" do
+          user = EndPoint::User.new
+          EndPoint::User.any_instance.stub(current_user: user)
+          current_user = client.current_user
+          current_user.should == user
+          current_user.to_h.should be_kind_of Hash
+        end
+      end
+
+      describe "current_groups" do
+        it "should return groups that current user belongs to" do
+          groups = [ EndPoint::Group.new ]
+          EndPoint::Group.any_instance.stub(current_groups: groups)
+          groups = logged_in_client.current_groups
+          groups.should_not be_empty
+        end
+      end
+
+      describe "sensors" do
+        it "should return Sensors relation" do
+          client.sensors.should be_a_kind_of(CS::Relation::SensorRelation)
+        end
+      end
+
+      describe "logger" do
+        context "when login using user & password" do
+          it "should assign the new session" do
+            logger = double()
+            Session.any_instance.stub(login: '1234')
+            client.logger = logger
+            client.login('foo', 'bar')
+            client.session.logger.should == logger
+          end
+        end
+
+        context "when login using oauth" do
+          it "should assign logger" do
+            logger = double()
+            client.logger = logger
+            client.oauth('', '', '', '')
+            client.session.logger.should == logger
+          end
+        end
+
+        context "when specifying session_id" do
+          it "should assign logger" do
+            logger = double()
+            client.logger = logger
+            client.session_id = '1234'
+            client.session.logger.should == logger
+          end
+        end
+
+        context "setting logger" do
+          it "it should set logger to existing session" do
+            logger = double()
+            client.session_id = '1234'
+            client.logger = logger
+            client.session.logger.should == logger
+            client.logger = nil
+            client.session.logger.should be_nil
+          end
+        end
+      end
+
+    end
+  end
+end