rhoconnect 3.4.5 → 4.0.0.beta.10

data/spec/server/server_spec.rb

@@ -9,20 +9,13 @@ describe "Server" do
 
   it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
     before(:each) do
-      require File.join(get_testapp_path,test_app_name)
-      Rhoconnect.bootstrap(get_testapp_path) do |rhoconnect|
-        rhoconnect.vendor_directory = File.join(rhoconnect.base_directory,'..','..','..','vendor')
-        rhoconnect.appserver = nil
-      end
-      Rhoconnect::Server.set :environment, :test
-      Rhoconnect::Server.set :run, false
       Rhoconnect::Server.set :secret, "secure!"
-      Rhoconnect::Server.use Rack::Static, :urls => ["/data"], 
+      Rhoconnect::Server.use Rack::Static, :urls => ["/data"],
         :root =>  File.expand_path(File.join(File.dirname(__FILE__),'..','apps','rhotestapp'))
     end
 
     def app
-      @app ||= Rhoconnect::Server.new
+      @app ||= Rack::URLMap.new Rhoconnect.url_map
     end
 
     it "should show status page" do
@@ -31,12 +24,12 @@ describe "Server" do
     end
 
     it "should login if content-type contains extra parameters" do
-      post "/rc/#{Rhoconnect::API_VERSION}/system/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 "/rc/#{Rhoconnect::API_VERSION}/system/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
 
@@ -44,34 +37,25 @@ describe "Server" do
       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, 
+        "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 if controller name is not specified" do
-      get "/app/"
-      last_response.status.should == 401
+    it "should respond with 404 if controller name is not specified" do
+      get "/app/#{Rhoconnect::API_VERSION}/"
+      last_response.status.should == 404
     end
 
     it "should have default session secret" do
@@ -92,7 +76,7 @@ describe "Server" do
       check_hsql_lib!
     end
 
-    describe "helpers" do 
+    describe "helpers" do
       before(:each) do
         do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
       end
@@ -108,13 +92,13 @@ describe "Server" do
         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 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'
@@ -152,15 +136,49 @@ describe "Server" do
         @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", {}
+      context "rps authenticate" do
+        it "should authenticate user with rps route" do
+          # RPS login should always come after normal login
+          do_post "/rc/#{Rhoconnect::API_VERSION}/app/login", "login" => @u.login, "password" => 'testpass'
+          authorize 'rpsuser', 'secret'
+          get "/rc/#{Rhoconnect::API_VERSION}/app/rps_login", {}
           last_response.status.should == 204
         end
       end
     end
 
+    describe "controller custom routes" do
+      before(:each) do
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
+      end
+
+      it "should register custom_route in DefaultServer and process it" do
+        Rhoconnect::Server.api4 '', "/my_custom_route", :get do
+          "Hello World!"
+        end
+
+        get "/my_custom_route", {}
+        last_response.body.should == "Hello World!"
+      end
+
+      it "should register custom_route in SimpleAdapter controller and process it" do
+        SimpleAdapterController.get '/my_custom_route', {:client_required => true, :source_required => true} do
+          "Hello World!"
+        end
+        get "/app/#{Rhoconnect::API_VERSION}/SimpleAdapter/my_custom_route", {}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        last_response.body.should == "Hello World!"
+      end
+
+      it "should register custom_route in SimpleAdapter controller, require client condition and return error if client is missing" do
+        SimpleAdapterController.get '/my_custom_route_with_client', {:client_required => true, :source_required => true} do
+          "Hello World!"
+        end
+        get "/app/#{Rhoconnect::API_VERSION}/SimpleAdapter/my_custom_route_with_client", {}
+        last_response.body.should == "Unknown client"
+        last_response.status.should == 500
+      end
+    end
+
     describe "client management routes" do
       before(:each) do
         do_post "/rc/#{Rhoconnect::API_VERSION}/app/login",  "login" => @u.login, "password" => 'testpass'
@@ -172,13 +190,13 @@ describe "Server" do
         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 == 
+        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
@@ -186,7 +204,7 @@ describe "Server" do
         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 == 
+        JSON.parse(last_response.body).should ==
           {"client"=>{"client_id"=>id}}
         c = Client.load(id,{:source_name => '*'})
         c.user_id.should == 'testuser'
@@ -194,19 +212,19 @@ describe "Server" do
       end
 
       it "should respond to clientregister" do
-        do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{@c.id}/register", 
+        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'
         @c.id.length.should == 32
       end
-      
+
       it "should respond to clientregister without clientcreate" do
-        Store.flash_data("client*")
+        Store.flush_data("client*")
         client_id = @c.id.clone
         @c = nil
-        do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{client_id}/register", 
+        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 => '*'})
@@ -216,30 +234,30 @@ describe "Server" do
       end
 
       it "should respond to clientreset" do
-        set_state(@c.docname(:cd) => @data)
+        set_doc_state(@c, :cd => @data)
         do_post "/rc/#{Rhoconnect::API_VERSION}/clients/#{@c.id}/reset", {}
-        verify_result(@c.docname(:cd) => {})
+        verify_doc_result(@c, :cd => {})
       end
-      
+
       it "should respond to clientreset with old route and deprecation warning" do
-        set_state(@c.docname(:cd) => @data)
+        set_doc_state(@c, :cd => @data)
         get "/application/clientreset", 'client_id' => @c.id
         last_response.headers["Warning"].index('deprecated').should_not == nil
-        verify_result(@c.docname(:cd) => {})
+        verify_doc_result(@c, :cd => {})
       end
-      
+
       it "should respond to clientreset with individual adapters" do
         @c.source_name = 'SimpleAdapter'
-        set_state(@c.docname(:cd) => @data)
+        set_doc_state(@c, :cd => @data)
         @c.source_name = 'SampleAdapter'
-        set_state(@c.docname(:cd) => @data)
+        set_doc_state(@c, :cd => @data)
         sources = [{'name' => 'SimpleAdapter'}]
         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)
+        verify_doc_result(@c, :cd => @data)
         @c.source_name = 'SimpleAdapter'
-        verify_result(@c.docname(:cd) => {})
+        verify_doc_result(@c, :cd => {})
       end
 
       it "should switch client user if client user_id doesn't match session user" do
@@ -252,7 +270,7 @@ describe "Server" do
         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 "/app/#{Rhoconnect::API_VERSION}/#{@s.name}",{}, {Rhoconnect::CLIENT_ID_HEADER => "BrokenClient"}
         last_response.body.should == "Unknown client"
@@ -281,19 +299,19 @@ describe "Server" do
         last_response.body.should == ''
         verify_result("test_update_storage" => {'1'=>@product1})
       end
-      
+
       it "should post records for update using the old route and have the deprecation warning" do
         params = {'update'=>{'1'=>@product1},:client_id => @c.id,:source_name => @s.name,
-          :version => ClientSync::VERSION}
+          :version => Rhoconnect::SYNC_VERSION}
         do_post "/application", params
         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})
       end
-      
+
       it "should post records for delete" do
-        set_state(@c.docname(:cd) => @data)
+        set_doc_state(@c, :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 == ''
@@ -302,7 +320,7 @@ describe "Server" 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}
+          :version => Rhoconnect::SYNC_VERSION}
         do_post "/api/application/queue_updates", params
         last_response.should be_ok
         last_response.headers["Warning"].index('deprecated').should_not == nil
@@ -323,43 +341,74 @@ describe "Server" do
         last_response.body.should == "Unable to authenticate ''"
       end
 
+      it "should resend page if page exists and no token provided" do
+        expected = {'1'=>@product1}
+        set_test_data('test_db_storage',{'1'=>@product1,'2'=>@product2,'4'=>@product4})
+        params = {'name' => 'iPhone'}
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:query => params}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        last_response.should be_ok
+        last_response.content_type.should =~ /application\/json/
+        token = @c.get_value(:page_token)
+        last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token
+        last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 1.to_s
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION}, {"token"=>token},
+          {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},{'insert'=>expected}]
+        # this should re-send the page
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:query => params}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        last_response.should be_ok
+        last_response.content_type.should =~ /application\/json/
+        token1 = @c.get_value(:page_token)
+        token1.should == token
+        last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token1
+        last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 1.to_s
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION}, {"token"=>token1},
+          {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},{'insert'=>expected}]
+        # this should ack_token
+        get "/app/#{Rhoconnect::API_VERSION}/#{@s.name}", {:token => token, :query => params}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        last_response.should be_ok
+        last_response.content_type.should =~ /application\/json/
+        last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == ""
+        last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 0.to_s
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION}, {"token"=>""},
+          {"count"=>0}, {"progress_count"=>0},{"total_count"=>1},{}]
+        @c.get_data(:page).should == {}
+        @c.get_value(:page_token).should be_nil
+      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 "/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::SYNC_VERSION}, {"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION}, {"token"=>token},
           {"count"=>2}, {"progress_count"=>0},{"total_count"=>2},{'insert'=>data}]
       end
-      
+
       it "should get inserts json with the old 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 "/application",:client_id => @c.id,:source_name => @s.name,:version => ClientSync::SYNC_VERSION
+        get "/application",:client_id => @c.id,:source_name => @s.name,:version => Rhoconnect::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::SYNC_VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_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 "/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::SYNC_VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token},
           {"count"=>2}, {"progress_count"=>0}, {"total_count"=>2},{'insert'=>data}]
         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::SYNC_VERSION},{"token"=>''}, 
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>''},
           {"count"=>0}, {"progress_count"=>0}, {"total_count"=>2},{}]
       end
 
@@ -375,7 +424,6 @@ describe "Server" do
 
       it "should get deletes json" do
         @s = Source.load(@s_fields[:name],@s_params)
-        cs = ClientSync.new(@s,@c,1)
         data = {'1'=>@product1,'2'=>@product2}
         set_test_data('test_db_storage',data)
 
@@ -384,46 +432,44 @@ describe "Server" do
         token = @c.get_value(:page_token)
         last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token
         last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 2.to_s
-        JSON.parse(last_response.body).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::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      
+        Store.flush_data('test_db_storage')
+        @s.read_state.refresh_time = Time.now.to_i
 
         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)
         last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token
         last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 2.to_s
-        JSON.parse(last_response.body).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
+        JSON.parse(last_response.body).should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token},
           {"count"=>2}, {"progress_count"=>0}, {"total_count"=>0},{'delete'=>data}]
       end
 
       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)
         params = {:client_id => @c.id,:sources => sources,:search => {'name' => 'iPhone'},
-          :version => ClientSync::VERSION}
+          :version => Rhoconnect::SYNC_VERSION}
         get "/api/application/search",params
         last_response.headers['Warning'].index('deprecated').should_not == nil
         last_response.content_type.should =~ /application\/json/
         token = @c.get_value(:search_token)
         last_response.headers[Rhoconnect::PAGE_TOKEN_HEADER].should == token
         last_response.headers[Rhoconnect::PAGE_OBJECT_COUNT_HEADER].should == 1.to_s
-        JSON.parse(last_response.body).should == [[{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
+        JSON.parse(last_response.body).should == [[{'version'=>Rhoconnect::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},
+        JSON.parse(last_response.body).should == [[{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
           {'source'=>sources[0][:name]},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
       end
 
@@ -433,8 +479,9 @@ describe "Server" do
         error = set_test_data('test_db_storage',@data,msg,'search error')
         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]},
+        JSON.parse(last_response.body).should == [[{'version'=>Rhoconnect::SYNC_VERSION},{'source'=>sources[0][:name]},
               {'search-error'=>{'search-error'=>{'message'=>msg}}}]]
+        verify_doc_result(@c, :search => {})
       end
 
       it "should get multiple source search results" do
@@ -447,10 +494,66 @@ describe "Server" do
         @c.source_name = 'SampleAdapter'
         token = @c.get_value(:search_token)
         JSON.parse(last_response.body).should == [
-          [{'version'=>ClientSync::SYNC_VERSION},{'token'=>token1},{"source"=>"SimpleAdapter"}, 
+          [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token1},{"source"=>"SimpleAdapter"},
            {"count"=>1}, {"insert"=>{'obj'=>{'foo'=>'bar'}}}],
-          [{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},{"source"=>"SampleAdapter"}, 
+          [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},{"source"=>"SampleAdapter"},
            {"count"=>1}, {"insert"=>{'1'=>@product1}}]]
+        verify_doc_result(@c, {:search => {'1'=>@product1},
+                               :search_errors => {}})
+      end
+
+      it "should handle search for pass through" do
+        sources = [{'name'=>'SampleAdapter'}]
+        set_state('test_db_storage' => @data)
+        @s.pass_through = 'true'
+        params = {:sources => sources, :search => {'name' => 'iPhone'}}
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        token = @c.get_value(:search_token)
+        JSON.parse(last_response.body).should == [[{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
+          {'source'=>sources[0]['name']},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
+        verify_doc_result(@c, {:search => {},
+                               :search_errors => {}})
+      end
+
+      it "should handle multiple source search with one source returning nothing" do
+        set_test_data('test_db_storage',@data)
+        sources = [{'name'=>'SimpleAdapter'},{'name'=>'SampleAdapter'}]
+        params = {:sources => sources,:search => {'name' => 'iPhone'}}
+        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)
+        token1.should be_nil
+        @c.source_name = 'SampleAdapter'
+        token = @c.get_value(:search_token)
+        JSON.parse(last_response.body).should == [[],[{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
+          {"source"=>"SampleAdapter"},{"count"=>1},{"insert"=>{'1'=>@product1}}]]
+      end
+
+      it "should handle search and ack of search results" do
+        set_test_data('test_db_storage',@data)
+        sources = [{'name'=>'SimpleAdapter'},{'name'=>'SampleAdapter'}]
+        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'
+        token = @c.get_value(:search_token)
+        token.should_not be_nil
+        sources[0]['token'] = token
+        @c.get_data(:search).should == {'obj'=>{'foo'=>'bar'}}
+        @c.source_name = 'SampleAdapter'
+        token1 = @c.get_value(:search_token)
+        token1.should_not be_nil
+        sources[1]['token'] = token1
+        @c.get_data(:search).should == {'1'=>@product1}
+        # do ack on multiple sources
+        do_post "/rc/#{Rhoconnect::API_VERSION}/app/search", params, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        @c.source_name = 'SimpleAdapter'
+        token = @c.get_value(:search_token)
+        token.should be_nil
+        @c.get_data(:search).should == {}
+        @c.source_name = 'SampleAdapter'
+        token1 = @c.get_value(:search_token)
+        token1.should be_nil
+        @c.get_data(:search).should == {}
       end
     end
 
@@ -463,15 +566,18 @@ describe "Server" do
         delete_data_directory
       end
 
-      it "should make initial bulk data request and receive wait (and no deprecation warning)" do
+      it "should make initial bulk data request (which creates Resque job) and receive wait (and no deprecation warning)" do
         set_state('test_db_storage' => @data)
         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']
         warning_header.should == nil or warning_header.index('deprecated').should == nil
+        Resque.peek(:bulk_data).should == {"args"=>
+          [{"data_name"=>File.join(@a_fields[:name],@u_fields[:login],@u_fields[:login])}],
+            "class"=>"Rhoconnect::BulkDataJob"}
       end
-      
+
       it "should make old-way initial bulk data request and receive wait along with deprecation warning" do
         set_state('test_db_storage' => @data)
         get "/application/bulk_data", :partition => :user, :client_id => @c.id
@@ -479,7 +585,7 @@ describe "Server" do
         last_response.body.should == {:result => :wait}.to_json
         last_response.headers['Warning'].index('deprecated').should_not == nil
       end
-      
+
       it "should make old-way initial bulk data request and receive wait along with deprecation warning (Sources sent as String)" do
         set_state('test_db_storage' => @data)
         get "/application/bulk_data?sources=FixedSchemaAdapter,SampleAdapter", :partition => :user, :client_id => @c.id
@@ -495,7 +601,7 @@ describe "Server" do
         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, 
+        last_response.body.should == {:result => :url,
           :url => data.url}.to_json
         validate_db(data,{@s.name => @data, 'FixedSchemaAdapter' => @data})
       end
@@ -505,11 +611,16 @@ describe "Server" do
         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))
         post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        JSON.parse(last_response.body).should == {'result' => 'url',
+                                                  'url' => BulkData.load(bulk_data_docname(@a.id,@u.id)).url}
         get JSON.parse(last_response.body)["url"]
         last_response.should be_ok
         File.open('test.data','wb') {|f| f.puts last_response.body}
         validate_db_file('test.data',[@s.name,'FixedSchemaAdapter'],{@s.name => @data, 'FixedSchemaAdapter' => @data})
         File.delete('test.data')
+        verify_doc_result(@c, :cd => @data)
+        verify_doc_result(@s, {:md => @data,
+                              :md_copy => @data})
       end
 
       it "should receive nop when no sources are available for partition" do
@@ -520,6 +631,72 @@ describe "Server" do
         last_response.should be_ok
         last_response.body.should == {:result => :nop}.to_json
       end
+
+      it "should create bulk data job app partition with partition sources" do
+        @s.partition = :app
+        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 => :wait}.to_json
+        warning_header = last_response.headers['Warning']
+        warning_header.should == nil or warning_header.index('deprecated').should == nil
+        Resque.peek(:bulk_data).should == {"args"=>
+          [{"data_name"=>File.join(@a_fields[:name],@a_fields[:name])}],
+            "class"=>"Rhoconnect::BulkDataJob"}
+      end
+
+      it "should return empty bulk data url if there are errors in query" do
+        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))
+        operation = 'query'
+        @s.lock(:errors) do
+          @s.put_data(:errors,{"#{operation}-error"=>{'message'=>"Some exception message"}}, true)
+        end
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        JSON.parse(last_response.body).should == {'result' => 'url', 'url' => ''}
+      end
+
+      it "should return bulk data url for completed bulk data app partition" do
+        set_state('test_db_storage' => @data)
+        @s.partition = :app
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        do_bulk_data_job("data_name" => bulk_data_docname(@a.id,"*"))
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :app}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        JSON.parse(last_response.body).should == {'result' => 'url',
+          'url' => BulkData.load(bulk_data_docname(@a.id,"*")).url}
+        @c.source_name = @s.name
+        verify_doc_result(@c, :cd => @data)
+        verify_doc_result(@s, {:md => @data,
+                              :md_copy => @data})
+      end
+
+      it "should return bulk data url for completed bulk data with bulk_sync_only source" do
+        set_state('test_db_storage' => @data)
+        @s.sync_type = :bulk_sync_only
+        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))
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        JSON.parse(last_response.body).should == {'result' => 'url',
+          'url' => BulkData.load(bulk_data_docname(@a.id,@u.id)).url}
+        @c.source_name = @s.name
+        verify_doc_result(@c, :cd => {})
+        verify_doc_result(@s, {:md => @data,
+                               :md_copy => {}})
+      end
+
+      it "should create bulk data job if no file exists" do
+        set_state('test_db_storage' => @data)
+        Rhoconnect.blackberry_bulk_sync = true
+        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))
+        data = BulkData.load(bulk_data_docname(@a.id,@u.id))
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        JSON.parse(last_response.body).should == {'result' => 'url', 'url' => data.url}
+        File.delete(data.dbfile)
+        post "/rc/#{Rhoconnect::API_VERSION}/app/bulk_data",  {:partition => :user}, {Rhoconnect::CLIENT_ID_HEADER => @c.id}
+        JSON.parse(last_response.body).should == {'result' => 'wait'}
+        Resque.peek(:bulk_data).should == {"args"=>
+          [{"data_name"=>bulk_data_docname(@a.id,@u.id)}], "class"=>"Rhoconnect::BulkDataJob"}
+      end
     end
 
     describe "blob sync" do
@@ -535,9 +712,9 @@ describe "Server" do
         cud = {'create'=>{'1'=>@product1,'2'=>@product2},
           :blob_fields => ['txtfile-rhoblob']}.to_json
         post "/app/#{Rhoconnect::API_VERSION}/#{@s.name}",
-          {:cud => cud,'txtfile-rhoblob-1' => 
+          {:cud => cud,'txtfile-rhoblob-1' =>
             Rack::Test::UploadedFile.new(File.join(File.dirname(__FILE__),'..','testdata',file1), "application/octet-stream"),
-            'txtfile-rhoblob-2' => 
+            'txtfile-rhoblob-2' =>
               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')