cs 0.1.0beta3 → 0.1.0

data/lib/cs/time.rb

@@ -0,0 +1,45 @@
+# Wrapper class around time object. Wether it's Time, ActiveSupport::TimeWithZone, or TimeLord
+module CS
+  class Time
+    attr_reader :time
+
+    def initialize(time=nil)
+      if time.nil?
+        @time = ::Time.new
+      elsif time.instance_of?(::Time)
+        @time = time
+      elsif time.kind_of?(::Numeric)
+        @time = ::Time.at(time)
+      elsif time.class.to_s == "TimeLord::Period"
+        @time = ::Time.at(time.beginning)
+      else
+        @time = time.to_time
+      end
+    end
+
+    def self.at(epoch)
+      ::Time.at(epoch)
+    end
+
+    def self.now
+      ::Time.now
+    end
+
+    def to_f
+      @time.to_f.round(3)
+    end
+
+    def to_s
+      @time.to_s
+    end
+
+    def inspect
+      @time.inspect
+    end
+
+    private
+    def method_missing(method, *args, &block)
+      @time.send(method, *args, &block)
+    end
+  end
+end

data/lib/cs/version.rb

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

data/spec/features/sensor_management_spec.rb

@@ -1,17 +1,10 @@
 require 'spec_helper'
 require 'ostruct'
+require 'webmock/rspec'
 
 describe "Sensor Management" do
 
   describe "Manage Sensor" do
-    before(:all) do
-      @client = create_client
-      @client.login($username, $password)
-    end
-
-    after(:all) do
-      @client.sensors.each {|sensors| sensors.delete}
-    end
 
     let(:sensor_info) do
       {
@@ -20,86 +13,194 @@ describe "Sensor Management" do
         device_type: "BMA123",
         pager_type: "email",
         data_type: "json",
-        data_structure: {"x-axis" => "Float", "y-axis" => "Float", "z-axis" => "Float"}
+        data_structure: {"x-axis" => "Float", "y-axis" => "Float", "z-axis" => "Float"}.to_json
       }
     end
 
-    def compare_to_sensor_info(sensor)
-      sensor.name.should eq(sensor_info[:name])
-      sensor.display_name.should eq(sensor_info[:display_name])
-      sensor.display_name.should eq(sensor_info[:display_name])
-      sensor.pager_type.should eq(sensor_info[:pager_type])
-      sensor.data_type.should eq(sensor_info[:data_type])
-      sensor.data_structure.should eq(sensor_info[:data_structure])
+    let!(:logged_in_client) do
+      client = CS::Client.new(base_uri: base_uri)
+      client.session_id = '1234'
+      client
+    end
+
+    let(:response_list_sensors) do
+      {
+        sensors: [
+          {
+            id: "143353",
+            name: "light",
+            type: "1",
+            device_type: "CM3602 Light sensor",
+            pager_type: "",
+            display_name: "light",
+            use_data_storage: true,
+            data_type: "json",
+            data_structure: "{\"lux\":\"Integer\"}",
+            device: {
+              id: "5492",
+              type: "HTC One V",
+              uuid: "351816053990044"
+            }
+          },
+          {
+            id: "143354",
+            name: "noise_sensor",
+            type: "1",
+            device_type: "noise_sensor",
+            pager_type: "",
+            display_name: "noise",
+            use_data_storage: true,
+            data_type: "float",
+            data_structure: "",
+            device: {
+              id: "5492",
+              type: "HTC One V",
+              uuid: "351816053990044"
+            }
+          },
+          {
+            id: "143355",
+            name: "Availability",
+            type: "2",
+            device_type: "2",
+            pager_type: "",
+            display_name: "",
+            use_data_storage: true,
+            data_type: "string",
+            data_structure: ""
+          }
+        ],
+        total: 3
+      }
+    end
+
+    def compare_to_sensor_info(a, b)
+      a.name.should eq(b[:name])
+      a.display_name.should eq(b[:display_name])
+      a.display_name.should eq(b[:display_name])
+      a.pager_type.should eq(b[:pager_type])
+
+      parsed_structure = b[:data_structure]
+      if !b[:data_structure].empty?
+        parsed_structure = JSON.parse(parsed_structure)
+      end
+
+      a.data_structure.should eq(parsed_structure)
+      a.data_type.should eq(b[:data_type])
+    end
+
+    def stub_response_sensor_list
+      stub_request(:get, "http://api.dev.sense-os.local/sensors.json?page=0&per_page=1000").
+        with(:headers => {'Content-Type'=>'application/json', 'X-Session-Id'=>'1234'}).
+        to_return(:status => 200, :body => response_list_sensors.to_json, :headers => {
+          'Content-Type'=>'application/json'
+        })
     end
 
     it "create a new sensor" do
-      sensor = @client.sensors.build
+      body = {sensor: sensor_info}
+
+      stub_request(:post, base_uri + "/sensors.json").
+        with(:body => body,
+             :headers => {'Content-Type'=>'application/json', 'X-Session-Id'=>'1234'}).
+        to_return(:status => 201, :body => "", :headers => {
+               location: base_uri + '/sensors/1'
+             })
+
+      sensor = logged_in_client.sensors.build
       sensor.name = sensor_info[:name]
       sensor.display_name = sensor_info[:display_name]
-      sensor.device_type = sensor_info[:display_name]
+      sensor.device_type = sensor_info[:device_type]
       sensor.pager_type = sensor_info[:pager_type]
       sensor.data_type = sensor_info[:data_type]
       sensor.data_structure = sensor_info[:data_structure]
-      sensor.save!
+      sensor.save!.should be_true
+
+      sensor.id.should == "1"
     end
 
     it "get list of sensor from commonSense" do
-      sensor = @client.sensors.build(sensor_info)
-      sensor.save!
 
-      @client.sensors.all.should_not be_empty
+      stub_response_sensor_list
+      logged_in_client.sensors.all.should_not be_empty
 
-      # there could be another Virtual sensor that is automatically created
-      @client.sensors.count.should be > 1
+      logged_in_client.sensors.count.should == 3
 
-      @client.sensors.each do |sensor|
-        compare_to_sensor_info(sensor)
-        break
+      i = 0
+      logged_in_client.sensors.each do |sensor|
+        compare_to_sensor_info(sensor, response_list_sensors[:sensors][i])
+        i += 1;
       end
     end
 
     it "get first sensor data" do
-      sensor = @client.sensors.build(sensor_info)
-      sensor.save!
-      sensor = @client.sensors.first
+      stub_response_sensor_list
+
+      sensor = logged_in_client.sensors.first
 
       sensor.should_not be nil
-      compare_to_sensor_info(sensor)
+      compare_to_sensor_info(sensor, response_list_sensors[:sensors][0])
     end
 
     it "get sensor data by id" do
-      sensor = @client.sensors.build(sensor_info)
-      sensor.save!
+      first = response_list_sensors[:sensors][0]
+
+      body = { sensor: response_list_sensors[:sensors][0] }
 
-      first = @client.sensors.first
+      stub_request(:get, base_uri + "/sensors/143353.json?").
+        with(:headers => {'Content-Type'=>'application/json', 'X-Session-Id'=>'1234'}).
+        to_return(:status => 200, :body => body.to_json, :headers => {'Content-Type'=>'application/json'})
 
-      sensor = @client.sensors.find(first.id)
+      sensor = logged_in_client.sensors.find!(first[:id])
       sensor.should_not be_nil
+      compare_to_sensor_info(sensor, response_list_sensors[:sensors][0])
     end
 
 
     it "filter sensor data" do
-      sensor = @client.sensors.build(sensor_info)
-      sensor.save!
-      sensors = @client.sensors.where(page: 0, per_page: 1, owned: true , details: "full")
-      sensors.to_a.should_not be_empty
+      stub_request(:get, base_uri + "/sensors.json?details=full&owned=1&page=0&per_page=1").
+        with(:headers => {'Content-Type'=>'application/json', 'X-Session-Id'=>'1234'}).
+        to_return(:status => 200, :body => response_list_sensors.to_json, :headers => {'Content-Type'=>'application/json'})
+
+      sensors = logged_in_client.sensors.where(page: 0, per_page: 1, owned: true , details: "full")
+      result = sensors.to_a
+      result.should_not be_empty
+
+      i = 0
+      result.each do |sensor|
+        compare_to_sensor_info(sensor, response_list_sensors[:sensors][i])
+        i += 1;
+      end
     end
 
     it "should handle pagination" do
-      2.times do
-        sensor = @client.sensors.build(sensor_info)
-        sensor.save!
+      client = logged_in_client
+
+      # stub page 0-2
+      for i in 0..2
+        response = {
+          sensors: [ response_list_sensors[:sensors][i] ],
+          total: 3
+        }
+        stub_request(:get, base_uri + "/sensors.json?page=#{i}&per_page=1").
+           with(:headers => {'Content-Type'=>'application/json', 'X-Session-Id'=>'1234'}).
+           to_return(:status => 200, :body => response.to_json, :headers => {'Content-Type'=>'application/json'})
       end
 
-      count = @client.sensors.count
+      # last page, empty response
+      response = { sensors: [], total: 3 }
+      stub_request(:get, base_uri + "/sensors.json?page=3&per_page=1").
+         with(:headers => {'Content-Type'=>'application/json', 'X-Session-Id'=>'1234'}).
+         to_return(:status => 200, :body => response.to_json, :headers => {'Content-Type'=>'application/json'})
+
 
       i = 0;
-      @client.sensors.where(per_page: 1).each do
+      client.sensors.where(per_page: 1).each do |sensor|
+        compare_to_sensor_info(sensor, response_list_sensors[:sensors][i])
         i += 1
       end
 
-      i.should eq(count)
+      i.should == 3
     end
   end
 end

data/spec/features/user_management_spec.rb

@@ -1,25 +1,98 @@
 require 'spec_helper'
+require 'webmock/rspec'
 
 describe "User management" do
 
   describe "Manage user" do
 
     let!(:user) do
-      $user
+      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
+
+    let!(:logged_in_client) do
+      client = CS::Client.new(base_uri: base_uri)
+      client.session_id = '123488'
+      client
+    end
+
+    def get_attribute(user)
+      {
+        email: user.email,
+        username: user.username,
+        name: user.name,
+        surname: user.surname,
+        address: user.address,
+        zipcode: user.zipcode,
+        country: user.country,
+        mobile: user.mobile,
+        password: user.password
+      }
     end
 
     it "create new user" do
       current_user = user
+      body = {user: get_attribute(current_user)}
+      stub_request(:post, base_uri + '/users.json').
+                 with(:body => body).
+                 to_return(:status => 201, :body => "", :headers => {
+                   location: base_uri + '/users/1'
+                 })
+
+      user.save!.should be_true
+      user.id.should == "1"
       current_user.id.should_not be_nil
     end
 
+    it "should login the user" do
+      client = create_client
+      current_user = user
+      stub_request(:post, base_uri + "/login.json").
+                 with(:body => {username: current_user.username, password: current_user.password},
+                      :headers => {'Content-Type'=>'application/json'}).
+                 to_return(:status => 200, :body => {session_id: "1"}.to_json, :headers => {'Content-Type' => 'application/json'})
+
+      session_id = client.login!(user.username, 'password')
+      session_id.should == "1"
+    end
+
     it "get user data from commonSense" do
-      attributes = user.to_h
+      current_user = user
+      attributes = get_attribute(current_user)
+
+      body = {
+        user: {
+          id: "3357",
+            email: current_user.email,
+            username: current_user.username,
+            name: current_user.name,
+            surname: current_user.surname,
+            address: current_user.address,
+            zipcode: current_user.zipcode,
+            country: current_user.country,
+            mobile: current_user.mobile,
+            UUID: "203a8-aa54-11e1-85e6-da0007d04f45",
+            openid: nil
+          }
+      }
 
-      client = create_client
-      session_id = client.login(user.username, 'password')
-      session_id.should_not be_nil
+      stub_request(:get, "http://api.dev.sense-os.local/users/current.json?").
+        with(:headers => {'Content-Type'=>'application/json', 'X-Session-Id'=>'123488'}).
+        to_return(:status => 200, :body => body.to_json, :headers => {'Content-Type'=>'application/json'})
 
+      client = logged_in_client
       current_user = client.current_user
 
       attributes.each do |key, value|
@@ -29,15 +102,9 @@ describe "User management" do
     end
 
     it "update user" do
-      current_time = Time.now.to_f
-      client = create_client
-      username = "user-#{current_time}@tester.com"
-      current_user = client.new_user(username: username, email: username, password: 'password')
-      current_user.save!
-      current_user.id.should_not be_nil
-
-      expected = { username: "user-edit-#{current_time}@tester.com",
-        email: "user-edit-#{current_time}@tester.com",
+      expected = {
+        email: "user-edit-1@tester.com",
+        username: "user-edit-1@tester.com",
         name: "Jan Edit",
         surname: "jagger edit",
         address: 'Looydstraat 5 edit',
@@ -46,20 +113,25 @@ describe "User management" do
         mobile: '987654321'
       }
 
-      client = create_client
-      client.session.should be_nil
-      session_id = client.login(current_user.username, 'password')
-      session_id.should_not be_nil
-      client.session.should_not be_nil
+      client = logged_in_client
+      current_user = user
+      current_user.id = "1"
+
+      body = {user: expected}
+      body[:user][:password] = current_user.password
+      body[:user][:id] = current_user.id
+
+      stub_request(:put, "http://api.dev.sense-os.local/users/1.json").
+        with(:body => body,
+             :headers => {'Content-Type'=>'application/json'}).
+        to_return(:status => 200, :body => "", :headers => {})
 
-      current_user = client.current_user
 
       expected.each do |key, value|
-        current_user.send("#{key}=".to_sym, value)
+        current_user.send("#{key}=".to_sym, value) unless key == :password
       end
 
       current_user.save!
-      current_user.reload
 
       expected.each do |key,value|
         current_user.send(key).should eq(value)