rhoconnect 3.2.1 → 3.3.1.beta2

data/spec/document_spec.rb

@@ -16,15 +16,38 @@ describe "Document" do
 
     it "should flash_data for docname" do
       @c.put_data(:foo1,{'1'=>@product1})
+      docname = @c.docname(:foo1)
+      bucket_index = get_sha1('1')[0..1]
+      Store.db.keys(@c.docname('*')).sort.should == ["#{docname}:#{bucket_index}", "#{docname}:indices"].sort
+      @c.flash_data('*')
+      Store.db.keys(@c.docname(:foo)).should == []
+    end
+    
+    it "should flash_data for arrays" do
+      @c.put_list(:foo1,['1', '2', '3'])
       Store.db.keys(@c.docname('*')).should == [@c.docname(:foo1)]
       @c.flash_data('*')
       Store.db.keys(@c.docname(:foo)).should == []
     end
+    
+    it "should get_data for arrays" do
+      @c.put_list(:foo1,['1', '2', '3'])
+      Store.db.keys(@c.docname('*')).should == [@c.docname(:foo1)]
+      @c.get_data(:foo1, Array).should == ['1', '2', '3']
+    end
 
     it "should rename doc" do
       set_state(@c.docname(:key1) => @data)
       @c.rename(:key1,:key2)
       verify_result(@c.docname(:key1) => {}, @c.docname(:key2) => @data)
     end
+    
+    it "should operate with individual object" do
+      key = '1'
+      data = {'foo' => 'bar'}
+      @c.put_object(:md, key, data)
+      obj = @c.get_object(:md, key)
+      obj.should == data
+    end
   end
 end

data/spec/javascripts/doc_view_spec.js

@@ -30,7 +30,7 @@ describe("DocView", function(){
 		var title = this.docView.el.innerHTML.search('testkey');
 		expect(title).toBeGreaterThan(0);
 		
-		var change_btn = this.docView.el.innerHTML.search('Upload token string');
+		var change_btn = this.docView.el.innerHTML.search('Upload string');
 		expect(change_btn).toBeGreaterThan(0);
 	})
 });

data/spec/javascripts/home_view_spec.js

@@ -5,13 +5,18 @@ describe("Home", function(){
 		session.setAuthenticated('true');
 		session.setApiKey('testtoken');
 	    source = new Source();
-	
-		sinon.stub(source,'fetch')
+	  
+		sinon.stub(source,'fetch');
 		sinon.stub(source,'save');
+		
+		adapter = new Adapter();
+		sinon.stub(adapter, 'set_adapter');
+		sinon.stub(adapter, 'get_adapter');
+		
 	    confirmStub = sinon.stub(window, 'confirm');
 		confirmStub.returns(true);
-		
-		this.homeView = new App.Views.Home({model : source});
+		sinon.stub(jQuery,'ajax');
+		this.homeView = new App.Views.Home({model : source, model2 : adapter});
 	});
 	
 	afterEach(function(){
@@ -19,6 +24,7 @@ describe("Home", function(){
 		session.setAuthenticated('false');
 		session.setApiKey(null);
 		confirmStub.restore();
+		jQuery.ajax.restore();
 	});
 	
 	it("should have render initial html",function(){
@@ -34,6 +40,5 @@ describe("Home", function(){
 		
 		var reset = this.homeView.el.innerHTML.search('Sync Server URL');
 		expect(reset).toBeGreaterThan(0);
-		
 	})
 });

data/spec/javascripts/index_view_spec.js

@@ -1,7 +1,7 @@
 describe("Index", function(){
 	
 	beforeEach(function(){
-		this.indexView = new App.Views.Index;	
+		this.indexView = new App.Views.Index;
 	});
 	
 	afterEach(function(){

data/spec/jobs/ping_job_spec.rb

@@ -175,5 +175,31 @@ describe "PingJob" do
       end
       exception_raised.should == true
     end
+    
+    it "should skip ping for unknown user or user with no clients" do
+      params = {"user_id" => [ 'fake_user' ], "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3', 'phone_id' => nil }
+      PingJob.should_receive(:log).once.with(/Skipping ping for unknown user 'fake_user' or 'fake_user' has no registered clients.../)
+      PingJob.perform(params)
+    end
+
+    it "should process ping for device_push_type if available" do
+      @c.device_push_type = 'rhoconnect_push'
+      @c.device_port = nil
+      params = {
+        'user_id'  => @u.id, 
+        'message'  => 'hello world',
+        'device_port' => '',
+        'vibrate'  => '',
+        'phone_id' => nil
+      }
+      scrubbed_params = params.dup
+
+      RhoconnectPush.should_receive(:ping).once.with(
+        {'device_pin' => @c.device_pin}.merge!(scrubbed_params)
+      )
+      PingJob.perform(params)
+    end
   end  
 end

data/spec/perf/store_perf_spec.rb

@@ -19,7 +19,7 @@ describe "Rhoconnect Performance" do
       Store.put_data('mdoc',@data).should == true
       Store.put_data('cdoc',@data1).should == true
       start = start_timer
-      Store.get_diff_data('mdoc','cdoc').should == [expected,1]
+      Store.get_diff_data('mdoc','cdoc').should == expected
       lap_timer('get_diff_data duration', start)
     end
   end

data/spec/ping/android_spec.rb

@@ -2,13 +2,6 @@ require File.join(File.dirname(__FILE__),'..','spec_helper')
 
 describe "Ping Android" do
   it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
-    def setup_post_yield(response)
-      if RUBY_VERSION =~ /1.9/ or defined?(JRUBY_VERSION)
-        RestClient.stub!(:post).and_yield(response, nil, nil)
-      else
-        RestClient.stub!(:post).and_yield(response)
-      end
-    end
     
     before do
       @params = {"device_pin" => @c.device_pin,

data/spec/ping/apple_spec.rb

@@ -65,5 +65,12 @@ describe "Ping Apple" do
       Apple.should_receive(:log).once.with("Error while sending ping: #{error}")
       lambda { Apple.ping(@params) }.should raise_error(SocketError,error)
     end
+    
+    it "should do nothing if no cert or host or port" do
+       Rhoconnect::Apple.stub!(:get_config).and_return({:test => {:iphonecertfile=>"none"}})
+       Rhoconnect::Apple.should_receive(:get_config).once
+       OpenSSL::SSL::SSLContext.should_receive(:new).exactly(0).times
+       Apple.ping(@params)
+     end
   end  
 end

data/spec/ping/blackberry_spec.rb

@@ -24,10 +24,20 @@ describe "Ping Blackberry" do
 
     it "should ping blackberry with connection error" do
       error = 'Connection refused'
+      Rhoconnect::Blackberry.stub!(:get_config).and_return({:test => {:mdsserver=>'testserver',:mdsserverport=>'testport'}})
+      Rhoconnect::Blackberry.should_receive(:get_config).once
       @http.stub!(:request).and_return { raise SocketError.new(error) }
       Blackberry.should_receive(:log).once.with("Error while sending ping: #{error}")
       lambda { Blackberry.ping(@params) }.should raise_error(SocketError,error)
     end
+    
+    it "should do nothing if no host and port" do
+      error = 'Connection refused'
+      Rhoconnect::Blackberry.stub!(:get_config).and_return({:test => {}})
+      Rhoconnect::Blackberry.should_receive(:get_config).once
+      Net::HTTP.should_receive(:new).exactly(0).times
+      Blackberry.ping(@params) 
+    end
 
     it "should compute pap_message" do
       expected = <<PAP

data/spec/ping/rhoconnect_push_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe "Ping using RhoConnect push" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
+    
+    before do
+      @params = {"device_pin" => @c.device_pin,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+      @response = mock('response')
+
+    end
+
+    it "should ping rhoconnect push successfully" do
+      result = ''
+      @response.stub!(:code).and_return(204)
+      @response.stub!(:body).and_return(result)
+      @response.stub!(:return!).and_return(@response)
+      RestClient.stub!(:post).and_return(@response)
+      res = RhoconnectPush.ping(@params)
+      res.body.should == result
+      res.code.should == 204
+    end
+
+    it "should ping rhoconnect push with missing push_server property" do
+      RhoconnectPush.stub!(:get_config).and_return({:test => {}})
+      lambda { RhoconnectPush.ping(@params) }.should raise_error(
+        RhoconnectPush::InvalidPushServer, "Missing or invalid `:push_server` in settings/settings.yml."
+      )
+    end
+    
+
+    it "should ping rhoconnect push with 400 response" do
+      result = ''
+      @response.stub!(:code).and_return(400)
+      @response.stub!(:body).and_return(result)
+      @response.stub!(:return!).and_return(@response)
+      setup_post_yield(@response)
+      lambda { RhoconnectPush.ping(@params) }.should raise_error(
+        RhoconnectPush::InvalidPushRequest, "Invalid push request."
+      )
+    end
+
+    it "should compute push_message" do
+      expected = {
+        'collapseId' => 5,
+        'data' => { 
+          'do_sync' => [@s.name],
+          'message' => "hello world",
+          'vibrate' => '5',
+          'sound' => "hello.mp3"
+        }
+      }
+      actual = RhoconnectPush.push_message(@params)
+      JSON.parse(actual).should == expected
+    end
+  end  
+end

data/spec/server/cors_spec.rb

@@ -1,4 +1,4 @@
-require 'rhoconnect/cors'
+require 'rhoconnect/middleware/cors'
 require File.join(File.dirname(__FILE__),'..','spec_helper')
 
 require "cgi"

data/spec/server/server_spec.rb

@@ -31,22 +31,46 @@ describe "Server" do
     end
 
     it "should login if content-type contains extra parameters" do
-      post "/api/admin/login", {"login" => 'rhoadmin', "password" => ''}.to_json, {'CONTENT_TYPE'=>'application/json; charset=UTF-8'}       
+      post "/rc/#{Rhoconnect::API_VERSION}/system/login", {"login" => 'rhoadmin', "password" => ''}.to_json, {'CONTENT_TYPE'=>'application/json; charset=UTF-8'}       
       last_response.should be_ok
     end
 
     it "should fail to login if wrong content-type" do
-      post "/api/admin/login", {"login" => 'rhoadmin', "password" => ''}.to_json, {'CONTENT_TYPE'=>'application/x-www-form-urlencoded'} 
+      post "/rc/#{Rhoconnect::API_VERSION}/system/login", {"login" => 'rhoadmin', "password" => ''}.to_json, {'CONTENT_TYPE'=>'application/x-www-form-urlencoded'} 
       last_response.should_not be_ok
     end
 
     it "should login as rhoadmin user" do
-      post "/api/admin/login", "login" => 'rhoadmin', "password" => ''
+      post "/rc/#{Rhoconnect::API_VERSION}/system/login", "login" => 'rhoadmin', "password" => ''
       last_response.should be_ok
     end
+    
+    it "should extract api token from the header" do
+      post "/rc/#{Rhoconnect::API_VERSION}/system/login", "login" => 'rhoadmin', "password" => ''
+      last_response.should be_ok
+      api_token = last_response.body
+      
+      get "/rc/#{Rhoconnect::API_VERSION}/system/license", {}, {Rhoconnect::API_TOKEN_HEADER => api_token}
+      last_response.should be_ok
+      JSON.parse(last_response.body).should == {
+        "available" => 9, 
+        "issued" => "Fri Apr 23 17:20:13 -0700 2010", 
+        "seats" => 10, 
+        "rhoconnect_version" => "Version 1",
+        "licensee" => "Rhomobile" }
+    end
+    
+    it "should register custom_route and process it" do
+      Rhoconnect::Server.api4 :my_custom_route, :get, "/my_custom_route", false, nil do |params,user,server|
+        "Hello World!"
+      end
+      
+      get "/my_custom_route", {}
+      last_response.body.should == "Hello World!"
+    end
 
-    it "should respond with 401 to /:app_name" do
-      get "/api/application/query"
+    it "should respond with 401 if controller name is not specified" do
+      get "/app/"
       last_response.status.should == 401
     end
 
@@ -70,67 +94,95 @@ describe "Server" do
 
     describe "helpers" do 
       before(:each) do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'testpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
       end
 
       it "should return nil if params[:source_name] is missing" do
-        get "/api/application/query"
+        get "/application"
         last_response.status.should == 500
       end
     end
 
     describe "auth routes" do
       it "should login user with correct username,password" do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'testpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
         last_response.should be_ok
       end
       
-      it "should login user with correct username,password if backend servcie defined" do
+      it "should login user with correct username,password old route and deprecation warning" do
+        do_post "/application/clientlogin", "login" => @u.login, "password" => 'testpass'
+        last_response.should be_ok
+        last_response.headers["Warning"].index('deprecated').should_not == nil
+      end
+      
+      it "should login user with correct username,password if backend service defined" do
         stub_request(:post, "http://test.com/rhoconnect/authenticate").to_return(:body => "lucas")
         Rhoconnect.appserver = 'http://test.com'
-        do_post "/api/application/clientlogin", "login" => 'lucas', "password" => 'testpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => 'lucas', "password" => 'testpass'
         last_response.should be_ok
       end
 
       it "should return 401 and LoginException messsage from authenticate" do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'wrongpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'wrongpass'
         last_response.status.should == 401
         last_response.body.should == 'login exception'
       end
 
       it "should return 500 and Exception messsage from authenticate" do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'server error'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'server error'
         last_response.status.should == 500
         last_response.body.should == 'server error'
       end
 
       it "should return 401 and no messsage from authenticate if no exception raised" do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'wrongpassnomsg'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'wrongpassnomsg'
         last_response.status.should == 401
-        last_response.body.should == ''
+        last_response.body.should == "Unable to authenticate '#{@u.login}'"
       end
 
       it "should create unknown user through delegated authentication" do
-        do_post "/api/application/clientlogin", "login" => 'newuser', "password" => 'testpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => 'newuser', "password" => 'testpass'
         User.is_exist?('newuser').should == true
         @a.users.members.sort.should == ['newuser','testuser']
       end
 
       it "should create a different username through delegated authentication" do
-        do_post "/api/application/clientlogin", "login" => 'newuser', "password" => 'diffuser'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => 'newuser', "password" => 'diffuser'
         User.is_exist?('different').should == true
         @a.users.members.sort.should == ['different','testuser']
       end
+
+      context "ans authenticate" do
+        it "should authenticate user with ans route" do
+          authorize 'ansuser', 'secret'
+          get "/rc/#{Rhoconnect::API_VERSION}/app/ans_login", {}
+          last_response.status.should == 204
+        end
+      end
     end
 
     describe "client management routes" do
       before(:each) do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'testpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
       end
 
       it "should respond to clientcreate" do
-        get "/api/application/clientcreate?device_type=blackberry"
+        do_post "/rc/#{Rhoconnect::API_VERSION}/clients", 'device_type' => 'blackberry'
+        last_response.should be_ok
+        last_response.content_type.should =~ /application\/json/
+        id = JSON.parse(last_response.body)['client']['client_id']
+        id.length.should == 32
+        JSON.parse(last_response.body).should == 
+          {"client"=>{"client_id"=>id}}
+        c = Client.load(id,{:source_name => '*'})
+        c.user_id.should == 'testuser'
+        c.device_type.should == 'blackberry'
+      end
+      
+      it "should respond to clientcreate with old route and deprecation warning" do
+        get "/application/clientcreate?device_type=blackberry"
         last_response.should be_ok
+        last_response.headers["Warning"].index('deprecated').should_not == nil
         last_response.content_type.should =~ /application\/json/
         id = JSON.parse(last_response.body)['client']['client_id']
         id.length.should == 32
@@ -142,8 +194,8 @@ describe "Server" do
       end
 
       it "should respond to clientregister" do
-        do_post "/api/application/clientregister", 
-          "device_type" => "iPhone", "device_pin" => 'abcd', "client_id" => @c.id
+        do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{@c.id}/register", 
+          "device_type" => "iPhone", "device_pin" => 'abcd'
         last_response.should be_ok
         @c.device_type.should == 'Apple'
         @c.device_pin.should == 'abcd'
@@ -154,8 +206,8 @@ describe "Server" do
         Store.flash_data("client*")
         client_id = @c.id.clone
         @c = nil
-        do_post "/api/application/clientregister", 
-          "device_type" => "iPhone", "device_pin" => 'abcd', "client_id" => client_id
+        do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{client_id}/register", 
+          "device_type" => "iPhone", "device_pin" => 'abcd'
         last_response.should be_ok
         @c = Client.load(client_id, {:source_name => '*'})
         @c.device_type.should == 'iPhone'
@@ -165,7 +217,14 @@ describe "Server" do
 
       it "should respond to clientreset" do
         set_state(@c.docname(:cd) => @data)
-        get "/api/application/clientreset", :client_id => @c.id,:version => ClientSync::VERSION
+        do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{@c.id}/reset", {}
+        verify_result(@c.docname(:cd) => {})
+      end
+      
+      it "should respond to clientreset with old route and deprecation warning" do
+        set_state(@c.docname(:cd) => @data)
+        get "/application/clientreset", 'client_id' => @c.id
+        last_response.headers["Warning"].index('deprecated').should_not == nil
         verify_result(@c.docname(:cd) => {})
       end
       
@@ -175,7 +234,7 @@ describe "Server" do
         @c.source_name = 'SampleAdapter'
         set_state(@c.docname(:cd) => @data)
         sources = [{'name' => 'SimpleAdapter'}]
-        get "/api/application/clientreset", :client_id => @c.id,:version => ClientSync::VERSION, :sources => sources
+        do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{@c.id}/reset", 'sources' => sources
         last_response.should be_ok
         @c.source_name = 'SampleAdapter'
         verify_result(@c.docname(:cd) => @data)
@@ -185,17 +244,17 @@ describe "Server" do
 
       it "should switch client user if client user_id doesn't match session user" do
         set_test_data('test_db_storage',@data)
-        get "/api/application/query",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         JSON.parse(last_response.body).last['insert'].should == @data
-        do_post "/api/application/clientlogin", "login" => 'user2', "password" => 'testpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => 'user2', "password" => 'testpass'
         data = {'1'=>@product1,'2'=>@product2}
         set_test_data('test_db_storage',data)
-        get "/api/application/query",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         JSON.parse(last_response.body).last['insert'].should == data
       end
       
       it "should return error on routes if client doesn't exist" do
-        get "/api/application/query",:client_id => "missingclient",:source_name => @s.name,:version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}",{}, {Rhoconnect::CLIENT_ID_HEADER => "BrokenClient"}
         last_response.body.should == "Unknown client"
         last_response.status.should == 500
       end
@@ -203,29 +262,21 @@ describe "Server" do
 
     describe "source routes" do
       before(:each) do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'testpass'
-      end
-
-      it "should return 404 message with version < 3" do
-        get "/api/application/query",:source_name => @s.name,:version => 2
-        last_response.status.should == 404
-        last_response.body.should == "Server supports version 3 or higher of the protocol."
+       do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
       end
 
       it "should post records for create" do
         @product1['_id'] = '1'
-        params = {'create'=>{'1'=>@product1},:client_id => @c.id,:source_name => @s.name,
-          :version => ClientSync::VERSION}
-        do_post "/api/application/queue_updates", params
+        params = {'create'=>{'1'=>@product1}}
+        do_post "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         last_response.body.should == ''
         verify_result("test_create_storage" => {'1'=>@product1})
       end
 
       it "should post records for update" do
-        params = {'update'=>{'1'=>@product1},:client_id => @c.id,:source_name => @s.name,
-          :version => ClientSync::VERSION}
-        do_post "/api/application/queue_updates", params
+        params = {'update' => @product1}
+        do_put "/app/#{Rhoconnect::API_VERSION}/#{@s.name}/1", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         last_response.body.should == ''
         verify_result("test_update_storage" => {'1'=>@product1})
@@ -241,47 +292,46 @@ describe "Server" do
         verify_result("test_update_storage" => {'1'=>@product1})
       end
       
-      it "should post records for update using the /api/application route and have the deprecation warning" do
-        params = {'update'=>{'1'=>@product1},:client_id => @c.id,:source_name => @s.name,
-          :version => ClientSync::VERSION}
-        do_post "/api/application", params
+      it "should post records for delete" do
+        set_state(@c.docname(:cd) => @data)
+        delete "/app/#{Rhoconnect::API_VERSION}/#{@s.name}/1", {}, { Rhoconnect::CLIENT_ID_HEADER => @c.id }
         last_response.should be_ok
         last_response.body.should == ''
-        last_response.headers["Warning"].index('deprecated').should_not == nil
-        verify_result("test_update_storage" => {'1'=>@product1})
+        verify_result("test_delete_storage" => {'1'=>@product1})
       end
 
-      it "should post records for delete" do
+      it "should post records for delete using the old route with deprecation warning" do
         params = {'delete'=>{'1'=>@product1},:client_id => @c.id,:source_name => @s.name,
           :version => ClientSync::VERSION}
         do_post "/api/application/queue_updates", params
         last_response.should be_ok
+        last_response.headers["Warning"].index('deprecated').should_not == nil
         last_response.body.should == ''
         verify_result("test_delete_storage" => {'1'=>@product1})
       end
 
       it "should handle client posting broken json" do
         broken_json = "{\"foo\":\"bar\"\"}"
-        post "/api/application/queue_updates", broken_json, {'CONTENT_TYPE'=>'application/json'}
+        do_post "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", broken_json, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.status.should == 500
         last_response.body.should == "Server error while processing client data"
       end
 
       it "should not login if login is empty" do
-        post "/api/application/clientlogin", ''
+        post "/rc/#{Rhoconnect::API_VERSION}/app/login",  ''
         last_response.status.should == 401
-        last_response.body.should == ""
+        last_response.body.should == "Unable to authenticate ''"
       end
 
       it "should get inserts json" do
         cs = ClientSync.new(@s,@c,1)
         data = {'1'=>@product1,'2'=>@product2}
         set_test_data('test_db_storage',data)
-        get "/api/application/query",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         last_response.content_type.should =~ /application\/json/
         token = @c.get_value(:page_token)
-        JSON.parse(last_response.body).should == [{"version"=>ClientSync::VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>ClientSync::SYNC_VERSION}, {"token"=>token}, 
           {"count"=>2}, {"progress_count"=>0},{"total_count"=>2},{'insert'=>data}]
       end
       
@@ -289,46 +339,37 @@ describe "Server" do
         cs = ClientSync.new(@s,@c,1)
         data = {'1'=>@product1,'2'=>@product2}
         set_test_data('test_db_storage',data)
-        get "/application",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::VERSION
+        get "/application",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::SYNC_VERSION
         last_response.should be_ok
         last_response.headers["Warning"].index('deprecated').should_not == nil
         last_response.content_type.should =~ /application\/json/
         token = @c.get_value(:page_token)
-        JSON.parse(last_response.body).should == [{"version"=>ClientSync::VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
           {"count"=>2}, {"progress_count"=>0},{"total_count"=>2},{'insert'=>data}]
       end
       
-      it "should get inserts json with the /api/application route and show deprecation warning" do
-        cs = ClientSync.new(@s,@c,1)
-        data = {'1'=>@product1,'2'=>@product2}
-        set_test_data('test_db_storage',data)
-        get "/api/application",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::VERSION
-        last_response.should be_ok
-        last_response.headers["Warning"].index('deprecated').should_not == nil
-        last_response.content_type.should =~ /application\/json/
-        token = @c.get_value(:page_token)
-        JSON.parse(last_response.body).should == [{"version"=>ClientSync::VERSION},{"token"=>token}, 
-          {"count"=>2}, {"progress_count"=>0},{"total_count"=>2},{'insert'=>data}]
-      end
-
       it "should get inserts json and confirm token" do
         cs = ClientSync.new(@s,@c,1)
         data = {'1'=>@product1,'2'=>@product2}
         set_test_data('test_db_storage',data)
-        get "/api/application/query",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         token = @c.get_value(:page_token)
-        JSON.parse(last_response.body).should == [{"version"=>ClientSync::VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
           {"count"=>2}, {"progress_count"=>0}, {"total_count"=>2},{'insert'=>data}]
-        get "/api/application/query",:client_id => @c.id,:source_name => @s.name,:token => token,
-          :version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:token => token}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
-        JSON.parse(last_response.body).should == [{"version"=>ClientSync::VERSION},{"token"=>''}, 
-          {"count"=>0}, {"progress_count"=>2}, {"total_count"=>2},{}]
+        JSON.parse(last_response.body).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>''}, 
+          {"count"=>0}, {"progress_count"=>0}, {"total_count"=>2},{}]
       end
 
       it "should create source for dynamic adapter if source_name is unknown" do
-        get "/api/application/query",:client_id => @c.id,:source_name => 'Broken',:version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/Broken", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        last_response.status.should == 200
+      end
+
+      it "should create source for dynamic adapter if source_name is unknown using the old route" do
+        get "/api/application/query", {:source_name => @s_fields[:name], :client_id => @c.id}
         last_response.status.should == 200
       end
 
@@ -338,24 +379,23 @@ describe "Server" do
         data = {'1'=>@product1,'2'=>@product2}
         set_test_data('test_db_storage',data)
 
-        get "/api/application/query",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         token = @c.get_value(:page_token)
-        JSON.parse(last_response.body).should == [{"version"=>ClientSync::VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
           {"count"=>2}, {"progress_count"=>0}, {"total_count"=>2},{'insert'=>data}]
 
         Store.flash_data('test_db_storage')
         @s.read_state.refresh_time = Time.now.to_i      
 
-        get "/api/application/query",:client_id => @c.id,:source_name => @s.name,:token => token,
-          :version => ClientSync::VERSION
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}",{:token => token}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         token = @c.get_value(:page_token)
-        JSON.parse(last_response.body).should == [{"version"=>ClientSync::VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
           {"count"=>2}, {"progress_count"=>0}, {"total_count"=>0},{'delete'=>data}]
       end
 
-      it "should get search results" do
+      it "should get search results using the old route with deprecation warning" do
         sources = [{:name=>'SampleAdapter'}]
         cs = ClientSync.new(@s,@c,1)
         Store.put_data('test_db_storage',@data)
@@ -364,7 +404,19 @@ describe "Server" do
         get "/api/application/search",params
         last_response.content_type.should =~ /application\/json/
         token = @c.get_value(:search_token)
-        JSON.parse(last_response.body).should == [[{'version'=>ClientSync::VERSION},{'token'=>token},
+        JSON.parse(last_response.body).should == [[{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
+          {'source'=>sources[0][:name]},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
+      end
+      
+      it "should get search results" do
+        sources = [{:name=>'SampleAdapter'}]
+        cs = ClientSync.new(@s,@c,1)
+        Store.put_data('test_db_storage',@data)
+        params = {:sources => sources,:search => {'name' => 'iPhone'}}
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/search",params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        last_response.content_type.should =~ /application\/json/
+        token = @c.get_value(:search_token)
+        JSON.parse(last_response.body).should == [[{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
           {'source'=>sources[0][:name]},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
       end
 
@@ -372,34 +424,32 @@ describe "Server" do
         sources = [{:name=>'SampleAdapter'}]
         msg = "Error during search"
         error = set_test_data('test_db_storage',@data,msg,'search error')
-        params = {:client_id => @c.id,:sources => sources,:search => {'name' => 'iPhone'},
-          :version => ClientSync::VERSION}
-        get "/api/application/search",params
-        JSON.parse(last_response.body).should == [[{'version'=>ClientSync::VERSION},
-          {'source'=>sources[0][:name]},{'search-error'=>{'search-error'=>{'message'=>msg}}}]]
+        params = {:sources => sources,:search => {'name' => 'iPhone'}}
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        JSON.parse(last_response.body).should == [[{'version'=>ClientSync::SYNC_VERSION},{'source'=>sources[0][:name]},
+              {'search-error'=>{'search-error'=>{'message'=>msg}}}]]
       end
 
       it "should get multiple source search results" do
         Store.put_data('test_db_storage',@data)
         sources = [{:name=>'SimpleAdapter'},{:name=>'SampleAdapter'}]
-        params = {:client_id => @c.id,:sources => sources,:search => {'search' => 'bar'},
-          :version => ClientSync::VERSION}
-        get "/api/application/search",params
+        params = {:sources => sources,:search => {'search' => 'bar'}}
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         @c.source_name = 'SimpleAdapter'
         token1 = @c.get_value(:search_token)
         @c.source_name = 'SampleAdapter'
         token = @c.get_value(:search_token)
         JSON.parse(last_response.body).should == [
-          [{"version"=>ClientSync::VERSION},{'token'=>token1},{"source"=>"SimpleAdapter"}, 
+          [{'version'=>ClientSync::SYNC_VERSION},{'token'=>token1},{"source"=>"SimpleAdapter"}, 
            {"count"=>1}, {"insert"=>{'obj'=>{'foo'=>'bar'}}}],
-          [{"version"=>ClientSync::VERSION},{'token'=>token},{"source"=>"SampleAdapter"}, 
+          [{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},{"source"=>"SampleAdapter"}, 
            {"count"=>1}, {"insert"=>{'1'=>@product1}}]]
       end
     end
 
     describe "bulk data routes" do
       before(:each) do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'testpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
       end
 
       after(:each) do
@@ -408,7 +458,7 @@ describe "Server" do
 
       it "should make initial bulk data request and receive wait (and no deprecation warning)" do
         set_state('test_db_storage' => @data)
-        get "/api/application/bulk_data", :partition => :user, :client_id => @c.id
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data", {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         last_response.body.should == {:result => :wait}.to_json
         warning_header = last_response.headers['Warning']
@@ -425,9 +475,9 @@ describe "Server" do
 
       it "should receive url when bulk data is available" do
         set_state('test_db_storage' => @data)
-        get "/api/application/bulk_data", :partition => :user, :client_id => @c.id
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-        get "/api/application/bulk_data", :partition => :user, :client_id => @c.id
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         data = BulkData.load(bulk_data_docname(@a.id,@u.id))
         last_response.body.should == {:result => :url, 
@@ -437,9 +487,9 @@ describe "Server" do
 
       it "should download bulk data file" do
         set_state('test_db_storage' => @data)
-        get "/api/application/bulk_data", :partition => :user, :client_id => @c.id
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-        get "/api/application/bulk_data", :partition => :user, :client_id => @c.id
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         get JSON.parse(last_response.body)["url"]
         last_response.should be_ok
         File.open('test.data','wb') {|f| f.puts last_response.body}
@@ -451,7 +501,7 @@ describe "Server" do
         set_state('test_db_storage' => @data)
         Source.load('SimpleAdapter',@s_params).partition = :user
         @a.sources.delete('OtherAdapter')
-        get "/api/application/bulk_data", :partition => :app, :client_id => @c.id
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         last_response.body.should == {:result => :nop}.to_json
       end
@@ -459,7 +509,7 @@ describe "Server" do
 
     describe "blob sync" do
       before(:each) do
-        do_post "/api/application/clientlogin", "login" => @u.login, "password" => 'testpass'
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
       end
       it "should upload blob in multipart post" do
         file1,file2 = 'upload1.txt','upload2.txt'
@@ -468,14 +518,12 @@ describe "Server" do
         @product2['txtfile-rhoblob'] = file2
         @product2['_id'] = 'tempobj2'
         cud = {'create'=>{'1'=>@product1,'2'=>@product2},
-          :client_id => @c.id,:source_name => @s.name,
-          :version => ClientSync::VERSION,
           :blob_fields => ['txtfile-rhoblob']}.to_json
-        post "/api/application/queue_updates", 
+        post "/app/#{Rhoconnect::API_VERSION}/#{@s.name}",
           {:cud => cud,'txtfile-rhoblob-1' => 
             Rack::Test::UploadedFile.new(File.join(File.dirname(__FILE__),'..','testdata',file1), "application/octet-stream"),
             'txtfile-rhoblob-2' => 
-              Rack::Test::UploadedFile.new(File.join(File.dirname(__FILE__),'..','testdata',file2), "application/octet-stream")}
+              Rack::Test::UploadedFile.new(File.join(File.dirname(__FILE__),'..','testdata',file2), "application/octet-stream")}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
         last_response.should be_ok
         data = Store.get_data('test_create_storage')
         data.size.should == 2