rhoconnect 3.4.5 → 4.0.0.beta.10

data/spec/client_sync_spec.rb

@@ -2,39 +2,21 @@ require File.join(File.dirname(__FILE__),'spec_helper')
 
 describe "ClientSync" do
   it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
-    it "should raise Argument error if no client is provided" do
-      lambda { ClientSync.new(@s,nil,2) }.should raise_error(ArgumentError,'Unknown client')
-    end
-
     it "should handle receive cud for dynamic adapter" do
+      Rhoconnect.appserver = "http://test.com"
       params = {'create'=>{'1'=>@product1}}
       @c.source_name = 'Product2'
-      @cs1 = ClientSync.new(@s2,@c,2)
+      # create handler
+      params = {:p_size => 2}
+      lv = lambda { @model.create(@params[:create_object]) }
+      @model = Rhoconnect::Model::Base.create(@s2)
+      @cs1 = Rhoconnect::Handler::Changes::Runner.new(['create'],@model,@c,lv,params)
       stub_request(:post, "http://test.com/rhoconnect/authenticate")
       stub_request(:post, "http://test.com/rhoconnect/create").with(:headers => {'Content-Type' => 'application/json'}).to_return(:body => {:id => 5})
-      @cs1.receive_cud(params)
-      verify_result(@cs1.client.docname(:create) => {},
-        @cs1.client.docname(:update) => {},
-        @cs1.client.docname(:delete) => {})
-    end
-    
-    it "should handle send cud for dynamic adapter" do
-      Rhoconnect.appserver = "http://test.com"
-      data = {'1'=>@product1}
-      expected = {'insert'=>data} 
-      stub_request(:post, "http://test.com/rhoconnect/authenticate")
-      stub_request(:post, "http://test.com/rhoconnect/query").with(:headers => {'Content-Type' => 'application/json'}).to_return(:status => 200, :body => data.to_json)
-       
-      @c.source_name = 'Product'
-      @cs1 = ClientSync.new(@s2,@c,2)
-      
-      @cs1.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{'token'=>@c.get_value(:page_token)},
-        {'count'=>data.size},{'progress_count'=>0},
-        {'total_count'=>data.size},expected]
-        
-      verify_result(@cs1.client.docname(:page) => data,
-        @cs1.client.docname(:delete_page) => {},
-        @cs1.client.docname(:cd) => data)
+      @cs1.run
+      verify_source_queue_data(@s2, {:create => [],
+                          :update => [],
+                          :delete => []})
     end
 
     let(:mock_schema) { {"property" => { "name" => "string", "brand" => "string" }, "version" => "1.0"} }
@@ -42,58 +24,105 @@ describe "ClientSync" do
             
     before(:each) do
       @s = Source.load(@s_fields[:name],@s_params)
-      @cs = ClientSync.new(@s,@c,2)
+      # CUD handler
+      rhcud = lambda { @model.send params[:operation].to_sym, params["#{params[:operation]}_object".to_sym] }
+      @model = Rhoconnect::Model::Base.create(@s)
+      @cud_handler = Rhoconnect::Handler::Changes::Runner.new(['create','update','delete'],@model,@c,rhcud,{})
+
+      # query handler
+      params = {:p_size => 2}
+      lv = lambda { @model.query(@params[:query]) }
+      @sync_handler = Rhoconnect::Handler::Query::Runner.new(@model,@c, lv, params)
     end
     
     it "should handle receive cud" do
-      params = {'create'=>{'1'=>@product1},'update'=>{'2'=>@product2},'delete'=>{'3'=>@product3}}
-      @cs.receive_cud(params)
-      verify_zresult(@s.docname(:create) => [],
-        @s.docname(:update) => [],
-        @s.docname(:delete) => [])
+      @cud_handler.params = {'create'=>{'1'=>@product1},'update'=>{'2'=>@product2},'delete'=>{'3'=>@product3}}
+      @cud_handler.run
+      verify_source_queue_data(@s, {:create => [],
+                          :update => [],
+                          :delete => []})
     end
     
     it "should handle receive cud that triggers processing of the previously queued data" do
       queued_create_data = {'1'=>@product1}
-      set_zstate({@s.docname(:create) => queued_create_data}, @c.id)
-      verify_zresult(@s.docname(:create) => [queued_create_data],
-        @cs.client.docname(:update) => [],
-        @cs.client.docname(:delete) => [])
-      @cs.receive_cud({:source_name => @s_fields[:name]})
-      verify_zresult(@s.docname(:create) => [],
-        @s.docname(:update) => [],
-        @s.docname(:delete) => [])
+      set_source_queue_state(@s, {:create => queued_create_data}, @c.id)
+      verify_source_queue_data(@s, {:create => [queued_create_data],
+                          :update => [],
+                          :delete => []})
+      @cud_handler.run
+      verify_source_queue_data(@s, {:create => [],
+                          :update => [],
+                          :delete => []})
     end
     
     it "should handle receive cud with pass through" do
       params = {'create'=>{'1'=>@product1},'update'=>{'2'=>@product2},'delete'=>{'3'=>@product3}}
       @s.pass_through = 'true'
-      @cs.receive_cud(params)
-      verify_zresult(@s.docname(:create) => [],
-        @s.docname(:update) => [],
-        @s.docname(:delete) => [])
+
+      rhcud = lambda { @model.send params[:operation].to_sym, params["#{params[:operation]}_object".to_sym] }
+      @cud_handler = Rhoconnect::Handler::Changes::PassThroughRunner.new(['create','update','delete'],@model,@c,rhcud,params)
+      @cud_handler.run
+      verify_source_queue_data(@s, {:create => [],
+                          :update => [],
+                          :delete => []})
     end
     
     it "should handle exeptions in receive cud with pass through" do
       params = {'create'=>{'1'=>@error},'update'=>{'2'=>@product2},'delete'=>{'3'=>@product3}}
       @s.pass_through = 'true'
-      @cs.receive_cud(params)
-      verify_zresult(@s.docname(:create) => [],
-        @s.docname(:update) => [],
-        @s.docname(:delete) => [])
+      rhcud = lambda { @model.send params[:operation].to_sym, params["#{params[:operation]}_object".to_sym] }
+      @cud_handler = Rhoconnect::Handler::Changes::PassThroughRunner.new(['create','update','delete'],@model,@c,rhcud,params)
+      @cud_handler.run
+      verify_source_queue_data(@s, {:create => [],
+                          :update => [],
+                          :delete => []})
     end
 
     it "should handle send cud" do
       data = {'1'=>@product1,'2'=>@product2}
       expected = {'insert'=>data}
       set_test_data('test_db_storage',data)
-      
-      @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{'token'=>@c.get_value(:page_token)},
+      @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>@c.get_value(:page_token)},
+        {'count'=>data.size},{'progress_count'=>0},
+        {'total_count'=>data.size},expected]
+      verify_doc_result(@sync_handler.client, {:page => data,
+                                     :delete_page => {},
+                                     :cd => data})
+    end
+
+    it "should handle send cud with page size 0" do
+      data = {'1'=>@product1,'2'=>@product2}
+      expected = {}
+      set_test_data('test_db_storage',data)
+      @sync_handler.p_size = 0
+      @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>''},
+        {'count'=>0},{'progress_count'=>0},
+        {'total_count'=>data.size},expected]
+      verify_doc_result(@sync_handler.client, {:page => expected,
+                                     :delete_page => {},
+                                     :cd => expected})
+    end
+
+    it "should handle send cud for dynamic adapter" do
+      Rhoconnect.appserver = "http://test.com"
+      data = {'1'=>@product1}
+      expected = {'insert'=>data} 
+      stub_request(:post, "http://test.com/rhoconnect/authenticate")
+      stub_request(:post, "http://test.com/rhoconnect/query").with(:headers => {'Content-Type' => 'application/json'}).to_return(:status => 200, :body => data.to_json)
+       
+      @c.source_name = 'Product2'
+      # query handler
+      lv = lambda { @model.query(params[:query]) }
+      params = { :p_size => 2 }
+      @model = Rhoconnect::Model::Base.create(@s2)
+      @cs1 = Rhoconnect::Handler::Query::Runner.new(@model,@c, lv, params)
+      @cs1.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>@c.get_value(:page_token)},
         {'count'=>data.size},{'progress_count'=>0},
         {'total_count'=>data.size},expected]
-      verify_result(@cs.client.docname(:page) => data,
-        @cs.client.docname(:delete_page) => {},
-        @cs.client.docname(:cd) => data)
+        
+      verify_doc_result(@cs1.client, {:page => data,
+          :delete_page => {},
+          :cd => data})
     end
       
     it "should handle send cud with pass_through" do
@@ -101,11 +130,14 @@ describe "ClientSync" do
       expected = {'insert'=>data}
       set_test_data('test_db_storage',data)
       @s.pass_through = 'true'
-      @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{'token'=>@c.get_value(:page_token)},
+      lv = lambda { @model.query(params[:query]) }
+      params = { :p_size => 2 }
+      @ptsync = Rhoconnect::Handler::Query::PassThroughRunner.new(@model, @c, lv, params)
+      @ptsync.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>@c.get_value(:page_token)},
         {'count'=>data.size},{'progress_count'=>0},
         {'total_count'=>data.size},expected]
-      verify_result(@cs.client.docname(:page) => {},
-      @cs.client.docname(:cd) => {})
+      verify_doc_result(@ptsync.client, {:page => {},
+                                     :cd => {}})
     end
     
     it "should handle send cud if with pass_through no data" do
@@ -113,24 +145,27 @@ describe "ClientSync" do
       expected = {}
       #set_test_data('test_db_storage',data)
       @s.pass_through = 'true'
-      @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{'token'=>""},
+      lv = lambda { @model.query(params[:query]) }
+      params = { :p_size => 2 }
+      @ptsync = Rhoconnect::Handler::Query::PassThroughRunner.new(@model, @c, lv, params)
+      @ptsync.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>""},
         {'count'=>data.size},{'progress_count'=>0},
         {'total_count'=>data.size},expected]
-      verify_result(@cs.client.docname(:page) => {},
-        @cs.client.docname(:cd) => {})
+      verify_doc_result(@ptsync.client, {:page => {},
+                                     :cd => {}})
     end
     
     it "should return read errors in send cud" do
       msg = "Error during query"
       data = {'1'=>@product1,'2'=>@product2}
       set_test_data('test_db_storage',data,msg,'query error')
-      @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0},{"total_count"=>0}, 
+      @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0},{"total_count"=>0}, 
         {"source-error"=>{"query-error"=>{"message"=>msg}}}]
     end
     
     it "should return login errors in send cud" do
       @u.login = nil
-      @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, 
+      @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, 
         {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
         {'source-error'=>{"login-error"=>{"message"=>"Error logging in"}}}]
     end
@@ -138,7 +173,7 @@ describe "ClientSync" do
     it "should return logoff errors in send cud" do
       msg = "Error logging off"
       set_test_data('test_db_storage',{},msg,'logoff error')
-      @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>@c.get_value(:page_token)}, 
+      @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>@c.get_value(:page_token)}, 
         {"count"=>1}, {"progress_count"=>0}, {"total_count"=>1}, 
         {"source-error"=>{"logoff-error"=>{"message"=>msg}}, 
         "insert"=>{ERROR=>{"name"=>"logoff error", "an_attribute"=>msg}}}]
@@ -153,25 +188,25 @@ describe "ClientSync" do
         data = {'1'=>@product1,'2'=>@product2}
         expected = {'insert'=>data}
         set_test_data('test_db_storage',data)
-        @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{'token'=>@c.get_value(:page_token)},
+        @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>@c.get_value(:page_token)},
           {'count'=>data.size},{'progress_count'=>0},
           {'total_count'=>data.size},expected]
-        verify_result(@cs.client.docname(:page) => data,
-          @cs.client.docname(:delete_page) => {},
-          @cs.client.docname(:cd) => data)
+        verify_doc_result(@sync_handler.client, {:page => data,
+                                   :delete_page => {},
+                                   :cd => data})
       end
 
       it "should return read errors in send cud" do
         msg = "Error during query"
         data = {'1'=>@product1,'2'=>@product2}
         set_test_data('test_db_storage',data,msg,'query error')
-        @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0},{"total_count"=>0}, 
+        @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0},{"total_count"=>0}, 
           {"source-error"=>{"query-error"=>{"message"=>msg}}}]
       end
 
       it "should return login errors in send cud" do
         @u.login = nil
-        @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, 
+        @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, 
           {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
           {'source-error'=>{"login-error"=>{"message"=>"Error logging in"}}}]
       end
@@ -179,7 +214,7 @@ describe "ClientSync" do
       it "should return logoff errors in send cud" do
         msg = "Error logging off"
         set_test_data('test_db_storage',{},msg,'logoff error')
-        @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>@c.get_value(:page_token)}, 
+        @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>@c.get_value(:page_token)}, 
           {"count"=>1}, {"progress_count"=>0}, {"total_count"=>1}, 
           {"source-error"=>{"logoff-error"=>{"message"=>msg}}, 
           "insert"=>{ERROR=>{"name"=>"logoff error", "an_attribute"=>msg}}}]
@@ -192,7 +227,7 @@ describe "ClientSync" do
 
         it "should handle update errors" do
           broken_object = { ERROR => { 'price' => '99.99' } }
-          set_state(@c.docname(:cd) => broken_object)
+          set_doc_state(@c, :cd => broken_object)
           set_test_data('test_db_storage',broken_object)
           receive_and_send_cud('update')
         end
@@ -201,8 +236,9 @@ describe "ClientSync" do
           msg = "Error delete record"
           error_objs = add_error_object({},"Error delete record")
           op_data = {'delete'=>error_objs}
-          @cs.receive_cud(op_data)
-          @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
+          @cud_handler.params = op_data
+          @cud_handler.run
+          @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
             {"delete-error"=>{"#{ERROR}-error"=>{"message"=>msg},ERROR=>error_objs[ERROR]}}]      
         end
 
@@ -210,64 +246,39 @@ describe "ClientSync" do
           msg = "Error delete record"
           error_objs = add_error_object({},"Error delete record")
           op_data = {'delete'=>error_objs}
-          @cs.receive_cud(op_data)
-          @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
+          @cud_handler.params = op_data
+          @cud_handler.run
+          @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
             {"delete-error"=>{"#{ERROR}-error"=>{"message"=>msg},ERROR=>error_objs[ERROR]}}]
           verify_result(@c.docname(:delete_errors) => {})
-          @cs.send_cud.should ==   [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},{}]
+          @sync_handler.run.should ==   [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},{}]
         end
 
         
       end
       
       it "should handle receive_cud" do
-        set_state(@s.docname(:md) => {'3'=>@product3},
-          @c.docname(:cd) => {'3'=>@product3})
+        set_doc_state(@s, :md => {'3'=>@product3})
+        set_doc_state(@c, :cd => {'3'=>@product3})
         params = {'create'=>{'1'=>@product1},
           'update'=>{'2'=>@product2},'delete'=>{'3'=>@product3}}
-        @cs.receive_cud(params)
-        verify_zresult(@s.docname(:create) => [],
-          @s.docname(:update) => [],
-          @s.docname(:delete) => [])
-        verify_result(
-          @s.docname(:md) => {},
-          @c.docname(:cd) => {})
+        @cud_handler.params = params
+        @cud_handler.run
+        verify_source_queue_data(@s, {:create => [],
+                            :update => [],
+                            :delete => []})
+        verify_doc_result(@s, :md => {})
+        verify_doc_result(@c, :cd => {})
       end
 
       it "should handle send_cud with query_params" do
         expected = {'1'=>@product1}
         set_state('test_db_storage' => {'1'=>@product1,'2'=>@product2,'4'=>@product4})
         params = {'name' => 'iPhone'}
-        @cs.send_cud(nil,params)
-        verify_result(@s.docname(:md) => expected,
-          @cs.client.docname(:page) => expected)
-      end
-    end
-
-    describe "reset" do
-      it "should handle reset" do
-        set_state(@c.docname(:cd) => @data)
-        ClientSync.reset(@c)
-        verify_result(@c.docname(:cd) => {})
-        Client.load(@c.id,{:source_name => @s.name}).should_not be_nil
-      end
-      
-      it "should handle reset on individual source adapters" do
-        @c.source_name = 'SampleAdapter'
-        set_state(@c.docname(:cd) => @data)
-        verify_result(@c.docname(:cd) => @data)
-        
-        @c.source_name = 'SimpleAdapter'
-        set_state(@c.docname(:cd) => @data)
-        verify_result(@c.docname(:cd) => @data)
-        
-        sources = [{'name'=>'SimpleAdapter'}]
-        ClientSync.reset(@c, {:sources => sources})
-        
-        @c.source_name = 'SampleAdapter'
-        verify_result(@c.docname(:cd) => @data)
-        @c.source_name = 'SimpleAdapter'
-        verify_result(@c.docname(:cd) => {})
+        @sync_handler.engine.params = {:query => params}
+        @sync_handler.run
+        verify_doc_result(@s, :md => expected)
+        verify_doc_result(@sync_handler.client, :cd => expected)
       end
     end
     
@@ -277,13 +288,18 @@ describe "ClientSync" do
         @c_fields.delete(:id)
         @c1 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
         @s1 = Source.create(@s_fields,@s_params)
-        @cs1 = ClientSync.new(@s1,@c1,2)
+        search_handler = lambda { @model.search(params[:search]) }
+        @model1 = Rhoconnect::Model::Base.create(@s2)
+        @cs = Rhoconnect::Handler::Search::Runner.new(@model, @c, search_handler, {})
+        @cs1 = Rhoconnect::Handler::Search::Runner.new(@model1,@c1, search_handler, { :p_size => 2 })
       end
 
       def search_and_verify_res(params)
-        res = @cs.search(params)
+        @cs.params = params
+        @cs.engine.params = params
+        res = @cs.run
         token = @c.get_value(:search_token)
-        res[0]['version'].should == ClientSync::SYNC_VERSION
+        res[0]['version'].should == Rhoconnect::SYNC_VERSION
         res[1]['token'].should == token
         res[2]['source'].should == @s.name
         res[3]['count'].should == 1
@@ -293,23 +309,24 @@ describe "ClientSync" do
       it "should handle search" do
         params = {:search => {'name' => 'iPhone'}}
         set_state('test_db_storage' => @data)
-        res = @cs.search(params)
+        @cs.engine.params = params
+        res = @cs.run
         token = @c.get_value(:search_token)
-        res.should == [{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
+        res.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
           {'source'=>@s.name},{'count'=>1},{'insert'=>{'1'=>@product1}}]
-        verify_result(@c.docname(:search) => {'1'=>@product1},
-          @c.docname(:search_errors) => {})
+        verify_doc_result(@c, {:search => {'1'=>@product1},
+                               :search_errors => {}})
       end
 
       it "should handle search with no params" do
         @cs.p_size = @data.size
         set_state('test_db_storage' => @data)
-        res = @cs.search(nil)
+        res = @cs.run
         token = @c.get_value(:search_token)
-        res.should == [{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
+        res.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},
           {'source'=>@s.name},{'count'=>@data.size},{'insert'=>@data}]
-        verify_result(@c.docname(:search) => @data,
-          @c.docname(:search_errors) => {})
+        verify_doc_result(@c, {:search => @data,
+                               :search_errors => {}})
       end
 
       it "should handle search with more than one page" do
@@ -319,188 +336,107 @@ describe "ClientSync" do
         @data['4'] = product4
         set_state('test_db_storage' => @data)
         inserts = search_and_verify_res(params)
-        verify_result(@c.docname(:search) => {'1'=>@product1,'4'=>product4},
-          @c.docname(:cd_size) => '1',
-          @s.docname(:md_size) => '1',
-          @c.docname(:cd) => @c.get_data(:search_page),
-          @s.docname(:md) => @c.get_data(:search_page),
-          @c.docname(:search_errors) => {})
-
+        verify_doc_result(@c, {:search => {'1'=>@product1,'4'=>product4},
+                           :cd_size => '1',
+                           :cd => @c.get_data(:search_page),
+                           :search_errors => {}})
+        verify_doc_result(@s, {:md_size => '1',
+                               :md => @c.get_data(:search_page)})
+          
         # ack the token
         params[:token] = @c.get_value(:search_token)
         new_inserts = search_and_verify_res(params)
         inserts.merge!(new_inserts)
-        verify_result(@c.docname(:search) => {'1'=>@product1,'4'=>product4},
-          @c.docname(:cd) => inserts,
-          @s.docname(:md) => inserts,
-          @c.docname(:search_errors) => {})
+        verify_doc_result(@c, {:search => {'1'=>@product1,'4'=>product4},
+                            :cd => inserts,
+                            :search_errors => {}})
+        verify_doc_result(@s, :md => inserts)
         @c.get_data(:search_page).size.should == 1
 
         # ack the last token
         params[:token] = @c.get_value(:search_token)
-        @cs.search(params).should == []
-        verify_result(@c.docname(:search) => {},
-          @c.docname(:cd) => inserts,
-          @s.docname(:md) => inserts,
-          @c.docname(:search_errors) => {},
-          @c.docname(:search_page) => {},
-          @cs.client.docname(:search_token) => nil)
+        @cs.params = params
+        @cs.run.should == []
+        verify_doc_result(@c, {:search => {},
+                          :cd => inserts,
+                          :search_errors => {},
+                          :search_page => {},
+                          :search_token => nil})
+        verify_doc_result(@s, :md => inserts)
       end
 
       it "should handle search with nil result" do
         params = {:search => {'name' => 'foo'}}
         set_state('test_db_storage' => @data)
-        @cs.search(params).should == []
-        verify_result(@c.docname(:search) => {},
-          @c.docname(:search_errors) => {})
+        @cs.engine.params = params
+        @cs.run.should == []
+        verify_doc_result(@c, {:search => {},
+                              :search_errors => {}})
       end
 
       it "should resend search by search_token" do
         @source = @s
-        set_state({@c.docname(:search_page) => {'1'=>@product1}})
-        token = compute_token @cs.client.docname(:search_token)
-        @cs.search({:resend => true,:token => token}).should == [{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},{'source'=>@s.name},{'count'=>1},{'insert'=>{'1'=>@product1}}]
-        verify_result(@c.docname(:search_page) => {'1'=>@product1},
-          @c.docname(:search_errors) => {},
-          @cs.client.docname(:search_token) => token)
+        set_doc_state(@c, :search_page => {'1'=>@product1})
+        token = @cs.client.compute_token(:search_token)
+        @cs.params = {:resend => true,:token => token}
+        @cs.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'token'=>token},{'source'=>@s.name},{'count'=>1},{'insert'=>{'1'=>@product1}}]
+        verify_doc_result(@c, {:search_page => {'1'=>@product1},
+          :search_errors => {},
+          :search_token => token})
       end
 
       it "should handle search ack" do
-        @source = @s
-        set_state({@c.docname(:search) => {'1'=>@product1}})
-        set_state({@c.docname(:cd) => {'1'=>@product1}})
-        token = compute_token @cs.client.docname(:search_token)
-        @cs.search({:token => token}).should == []
-        verify_result(@c.docname(:search) => {},
-          @c.docname(:search_errors) => {},
-          @cs.client.docname(:search_token) => nil)
+        set_doc_state(@c, {:search => {'1'=>@product1}})
+        set_doc_state(@c, {:cd => {'1'=>@product1}})
+        token = @cs.client.compute_token(:search_token)
+        @cs.params = {:token => token}
+        @cs.run.should == []
+        verify_doc_result(@c, {:search => {},
+          :search_errors => {},
+          :search_token => nil})
       end
 
       it "should return error on invalid ack token" do
-        set_state({@c.docname(:search_page) => {'1'=>@product1}})
-        set_state({@c.docname(:search_token) => 'validtoken'})
-        @cs.search(
-          {:token => 'abc',
-          :search => {'name' => 'iPhone'}}
-        ).should == [{'version'=>ClientSync::SYNC_VERSION},{'source'=>@s.name},{'search-error'=>{'search-error'=>
+        set_doc_state(@c, {:search_page => {'1'=>@product1}})
+        set_doc_state(@c, :search_token => 'validtoken')
+        params = {:token => 'abc',
+                  :search => {'name' => 'iPhone'}}
+        @cs.params = params
+        @cs.engine.params = params
+        @cs.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'source'=>@s.name},{'search-error'=>{'search-error'=>
           {'message'=>"Search error - invalid token"}}}]
-        verify_result(@c.docname(:search) => {},
-          @c.docname(:search_errors) => {},
-          @cs.client.docname(:search_token) => nil)
-      end
-
-      it "should handle search all" do
-        sources = [{'name'=>'SampleAdapter'}]
-        set_state('test_db_storage' => @data)
-        res = ClientSync.search_all(@c,{:sources => sources,:search => {'name' => 'iPhone'}})
-        token = Store.get_value(@cs.client.docname(:search_token))
-        res.should == [[{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
-          {'source'=>sources[0]['name']},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
-        verify_result(@c.docname(:search) => {'1'=>@product1},
-          @c.docname(:search_errors) => {})
-      end
-      
-      it "should handle search all for pass through" do
-        sources = [{'name'=>'SampleAdapter'}]
-        set_state('test_db_storage' => @data)
-        @s.pass_through = 'true'
-        res = ClientSync.search_all(@c,{:sources => sources,:search => {'name' => 'iPhone'}})
-        token = Store.get_value(@cs.client.docname(:search_token))
-        res.should == [[{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
-          {'source'=>sources[0]['name']},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
-        verify_result(@c.docname(:search) => {},
-          @c.docname(:search_errors) => {})
-      end
-
-      it "should handle search all error" do
-        sources = [{'name'=>'SampleAdapter'}]
-        msg = "Error during search"
-        error = set_test_data('test_db_storage',@data,msg,'search error')
-        res = ClientSync.search_all(@c,{:sources => sources,:search => {'name' => 'iPhone'}})
-        token = Store.get_value(@cs.client.docname(:search_token))
-        res.should == [[{'version'=>ClientSync::SYNC_VERSION},{'source'=>sources[0]['name']},{'search-error'=>{'search-error'=>{'message'=>msg}}}]]
-        verify_result(@c.docname(:search) => {})
+        verify_doc_result(@c, {:search => {},
+                               :search_errors => {},
+                               :search_token => nil})
       end
 
-      it "should handle search all login error" do
+      it "should handle search login error" do
         @u.login = nil
-        sources = [{'name'=>'SampleAdapter'}]
         msg = "Error logging in"
         error = set_test_data('test_db_storage',@data,msg,'search error')
-        ClientSync.search_all(@c,{:sources => sources,:search => {'name' => 'iPhone'}}).should == [
-          [{'version'=>ClientSync::SYNC_VERSION},{'source'=>sources[0]['name']},
-          {'search-error'=>{'login-error'=>{'message'=>msg}}}]]
-        verify_result(@c.docname(:search) => {},
-          @c.docname(:search_token) => nil)
+        @cs.engine.params = {:search => {'name' => 'iPhone'}}
+        @cs.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{'source'=>@s.name},
+          {'search-error'=>{'login-error'=>{'message'=>msg}}}]
+        verify_doc_result(@c, {:search => {},
+                              :search_token => nil})
       end
-
-      it "should handle multiple source search all" do
-        set_test_data('test_db_storage',@data)
-        sources = [{'name'=>'SimpleAdapter'},{'name'=>'SampleAdapter'}]
-        res = ClientSync.search_all(@c,{:sources => sources,:search => {'name' => 'iPhone'}})
-        @c.source_name = 'SampleAdapter'
-        token = Store.get_value(@c.docname(:search_token))
-        res.sort.should == [[{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
-          {"source"=>"SampleAdapter"},{"count"=>1},{"insert"=>{'1'=>@product1}}],[]].sort
-      end
-
-      it "should handle search and accumulate params" do
-        set_test_data('test_db_storage',@data)
-        sources = [{'name'=>'SimpleAdapter'},{'name'=>'SampleAdapter'}]
-        res = ClientSync.search_all(@c,{:sources => sources,:search => {'search'=>'bar'}})
-        @c.source_name = 'SimpleAdapter'
-        token = Store.get_value(@c.docname(:search_token))
-        @c.source_name = 'SampleAdapter'
-        token1 = Store.get_value(@c.docname(:search_token))
-        res.should == [[{'version'=>ClientSync::SYNC_VERSION},{'token'=>token},
-          {"source"=>"SimpleAdapter"},{"count"=>1},{"insert"=>{'obj'=>{'foo'=>'bar'}}}],
-          [{'version'=>ClientSync::SYNC_VERSION},{'token'=>token1},{"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'}]
-        ClientSync.search_all(@c,{:sources => sources,:search => {'search'=>'bar'}})
-        @c.source_name = 'SimpleAdapter'
-        token = Store.get_value(@c.docname(:search_token))
-        token.should_not be_nil
-        sources[0]['token'] = token
-        Store.get_data(@c.docname(:search)).should == {'obj'=>{'foo'=>'bar'}}
-        @c.source_name = 'SampleAdapter'
-        token1 = Store.get_value(@c.docname(:search_token))
-        token1.should_not be_nil
-        sources[1]['token'] = token1
-        Store.get_data(@c.docname(:search)).should == {'1'=>@product1}
-        # do ack on multiple sources
-        res = ClientSync.search_all(@c,{:sources => sources,:search => {'search'=>'bar'}})
-        @c.source_name = 'SimpleAdapter'
-        token = Store.get_value(@c.docname(:search_token))
-        token.should be_nil
-        Store.get_data(@c.docname(:search)).should == {}
-        @c.source_name = 'SampleAdapter'
-        token1 = Store.get_value(@c.docname(:search_token))
-        token1.should be_nil
-        Store.get_data(@c.docname(:search)).should == {}
-      end
-
     end
 
     describe "page methods" do
       it "should return diffs between master documents and client documents limited by page size" do
-        Store.put_data(@s.docname(:md),@data).should == true
-        Store.get_data(@s.docname(:md)).should == @data
-        Store.put_value(@s.docname(:md_size),@data.size)
+        @s.put_data(:md,@data).should == true
+        @s.get_data(:md).should == @data
+        @s.put_value(:md_size,@data.size)
 
-        total_count, res = @cs.compute_page
+        total_count, res = @sync_handler.compute_page
         total_count.to_i.should == 3
         res.each do |key, value|
           @data.has_key?(key).should == true
           @data[key].should == value
         end
 
-        Store.get_value(@cs.client.docname(:cd_size)).to_i.should == 0
-        Store.get_data(@cs.client.docname(:page)).each do |key, value|
+        @sync_handler.client.get_value(:cd_size).to_i.should == 0
+        @sync_handler.client.get_data(:page).each do |key, value|
           @data.has_key?(key).should == true
           @data[key].should == value
         end
@@ -508,41 +444,43 @@ describe "ClientSync" do
 
       it "appends diff to the client document" do
         @cd = {'3'=>@product3}  
-        Store.put_data(@c.docname(:cd),@cd)
-        Store.get_data(@c.docname(:cd)).should == @cd
+        @c.put_data(:cd,@cd)
+        @c.get_data(:cd).should == @cd
 
         @page = {'1'=>@product1,'2'=>@product2}
         @expected = {'1'=>@product1,'2'=>@product2,'3'=>@product3}
 
-        Store.put_data(@c.docname(:cd),@page,true).should == true
-        Store.get_data(@c.docname(:cd)).should == @expected
+        @c.put_data(:cd,@page,true).should == true
+        @c.get_data(:cd).should == @expected
       end
 
       it "should delete objects from the client document and return deleted objects in the page" do
-        Store.put_data(@s.docname(:md),@data).should == true
-        Store.get_data(@s.docname(:md)).should == @data
+        @s.put_data(:md,@data).should == true
+        @s.get_data(:md).should == @data
 
         @cd = {'1'=>@product1,'2'=>@product2,'3'=>@product3,'4'=>@product4}  
-        Store.put_data(@cs.client.docname(:cd),@cd)
-        Store.get_data(@cs.client.docname(:cd)).should == @cd
+        @sync_handler.client.put_data(:cd,@cd)
+        @sync_handler.client.get_data(:cd).should == @cd
 
         @expected = {'4'=>@product4}
-        @cs.send_new_page
-        Store.get_data(@cs.client.docname(:delete_page)).should == @expected
-        Store.get_data(@cs.client.docname(:cd)).should == @data
+        @sync_handler.send_new_page
+        @sync_handler.client.get_data(:delete_page).should == @expected
+        @sync_handler.client.get_data(:cd).should == @data
       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'}
-        @cs.send_cud(nil,params)
+        @sync_handler.engine.params = {:query => params}
+        @sync_handler.run
         token = @c.get_value(:page_token)
-        @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
+        @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token}, 
           {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},{'insert' => expected}]
-        @cs.send_cud(token).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, 
+        @sync_handler.params[:token] = token
+        @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, 
           {"count"=>0}, {"progress_count"=>0}, {"total_count"=>1}, {}]
-        Store.get_data(@cs.client.docname(:page)).should == {}              
+        @sync_handler.client.get_data(:page).should == {}              
         @c.get_value(:page_token).should be_nil
       end
 
@@ -551,9 +489,9 @@ describe "ClientSync" do
         set_state('test_db_storage' => expected)
         metadata = "{\"foo\":\"bar\"}"
         mock_metadata_method([SampleAdapter]) do
-          result = @cs.send_cud
+          result = @sync_handler.run
           token = @c.get_value(:page_token)
-          result.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
+          result.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token}, 
             {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},
             {'metadata'=>metadata,'insert'=>expected}]
           @c.get_value(:metadata_page).should == metadata
@@ -564,9 +502,9 @@ describe "ClientSync" do
         expected = {'1'=>@product1}
         set_state('test_db_storage' => expected)
         mock_metadata_method([SampleAdapter]) do
-          result = @cs.send_cud
+          result = @sync_handler.run
           token = @c.get_value(:page_token)
-          @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
+          @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token}, 
             {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},
             {'metadata'=>"{\"foo\":\"bar\"}",'insert'=>expected}] 
         end
@@ -576,9 +514,10 @@ describe "ClientSync" do
         expected = {'1'=>@product1}
         set_state('test_db_storage' => expected)
         mock_metadata_method([SampleAdapter]) do
-          result = @cs.send_cud
+          result = @sync_handler.run
           token = @c.get_value(:page_token)
-          @cs.send_cud(token).should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, 
+          @sync_handler.params[:token] = token
+          @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, 
             {"count"=>0}, {"progress_count"=>0},{"total_count"=>1},{}]
           @c.get_value(:metadata_page).should be_nil
         end
@@ -588,9 +527,9 @@ describe "ClientSync" do
         expected = {'1'=>@product1}
         set_state('test_db_storage' => expected)
         mock_schema_method([SampleAdapter]) do
-          result = @cs.send_cud
+          result = @sync_handler.run
           token = @c.get_value(:page_token)
-          result.should ==  [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
+          result.should ==  [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token}, 
             {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},{'insert'=>expected}]
           @c.get_value(:schema_sha1).should == sha1
         end
@@ -599,9 +538,9 @@ describe "ClientSync" do
       it "should send schema-changed instead of page" do
         mock_schema_method([SampleAdapter]) do
           @c.put_value(:schema_sha1,'foo')
-          result = @cs.send_cud
+          result = @sync_handler.run
           token = @c.get_value(:page_token)
-          result.should ==  [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
+          result.should ==  [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token}, 
             {"count"=>0}, {"progress_count"=>0},{"total_count"=>0},{'schema-changed'=>'true'}]
           @c.get_value(:schema_page).should == sha1
           @c.get_value(:schema_sha1).should == sha1
@@ -611,9 +550,9 @@ describe "ClientSync" do
       it "should re-send schema-changed if no token sent" do
         mock_schema_method([SampleAdapter]) do
           @c.put_value(:schema_sha1,'foo')
-          result = @cs.send_cud
+          result = @sync_handler.run
           token = @c.get_value(:page_token)
-          @cs.send_cud.should ==  [{'version'=>ClientSync::SYNC_VERSION},{"token"=>token}, 
+          @sync_handler.run.should ==  [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>token}, 
             {"count"=>0}, {"progress_count"=>0},{"total_count"=>0},{'schema-changed'=>'true'}]
           @c.get_value(:schema_page).should == sha1
           @c.get_value(:schema_sha1).should == sha1
@@ -623,9 +562,10 @@ describe "ClientSync" do
       it "should ack schema-changed with token" do
         mock_schema_method([SampleAdapter]) do
           @c.put_value(:schema_sha1,'foo')
-          result = @cs.send_cud
+          result = @sync_handler.run
           token = @c.get_value(:page_token)
-          @cs.send_cud(token).should ==  [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, 
+          @sync_handler.params[:token] = token
+          @sync_handler.run.should ==  [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, 
             {"count"=>0}, {"progress_count"=>0},{"total_count"=>0},{}]
           @c.get_value(:schema_page).should be_nil
           @c.get_value(:schema_sha1).should == sha1
@@ -642,9 +582,10 @@ describe "ClientSync" do
         data.refresh_time = Time.now.to_i + 600
         mock_schema_method([SampleAdapter]) do
           @c.put_value(:schema_sha1,'foo')
-          result = @cs.send_cud
+          result = @sync_handler.run
           token = @c.get_value(:page_token)
-          @cs.send_cud(token).should ==  [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, 
+          @sync_handler.params[:token] = token
+          @sync_handler.run.should ==  [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, 
             {"count"=>0}, {"progress_count"=>0},{"total_count"=>0},{}]
           @c.get_value(:schema_page).should be_nil
           @c.get_value(:schema_sha1).should == sha1
@@ -653,123 +594,20 @@ describe "ClientSync" do
         end 
       end
     end
-
-    describe "bulk data" do
-      after(:each) do
-        delete_data_directory
-      end
-
-      it "should create bulk data job user parition if none exists" do
-        ClientSync.bulk_data(:user,@c).should == {:result => :wait}
-        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 create bulk data job app partition if none exists and no partition sources" do
-        @s2.delete
-        @a.sources.delete("SimpleAdapter")
-        @a.sources.delete("OtherAdapter")
-        ClientSync.bulk_data(:app,@c).should == {:result => :nop}
-        Resque.peek(:bulk_data).should == nil
-      end
-
-      it "should create bulk data job app partition with partition sources" do
-        @s.partition = :app
-        ClientSync.bulk_data(:app,@c).should == {:result => :wait}
-        Resque.peek(:bulk_data).should == {"args"=>
-          [{"data_name"=>File.join(@a_fields[:name],@a_fields[:name])}], 
-            "class"=>"Rhoconnect::BulkDataJob"}
-      end
-
-      it "should return bulk data url for completed bulk data user partition" do
-        set_state('test_db_storage' => @data)
-        ClientSync.bulk_data(:user,@c)
-        do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-        ClientSync.bulk_data(:user,@c).should == {:result => :url,
-          :url => BulkData.load(bulk_data_docname(@a.id,@u.id)).url}
-        verify_result(
-          "client:#{@a_fields[:name]}:#{@u_fields[:login]}:#{@c.id}:#{@s_fields[:name]}:cd" => @data,
-          "source:#{@a_fields[:name]}:#{@u_fields[:login]}:#{@s_fields[:name]}:md" => @data,
-          "source:#{@a_fields[:name]}:#{@u_fields[:login]}:#{@s_fields[:name]}:md_copy" => @data)
-      end
-
-      it "should return empty bulk data url if there are errors in query" do
-        ClientSync.bulk_data(:user,@c)
-        do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-        errordoc = @s.docname(:errors) # source SampleAdapter
-        operation = 'query'
-        Store.lock(errordoc) do
-          Store.put_data(errordoc,{"#{operation}-error"=>{'message'=>"Some exception message"}}, true)
-        end
-        ClientSync.bulk_data(:user,@c).should == {:result => :url, :url => ''}
-      end
-
-      it "should escape bulk data url" do
-        name = 'a b'
-        data = BulkData.create(:name => bulk_data_docname(@a.id,name),
-          :state => :inprogress,
-          :app_id => @a.id,
-          :user_id => name,
-          :sources => [@s_fields[:name]])
-        do_bulk_data_job("data_name" => bulk_data_docname(@a.id,name))
-        data = BulkData.load(bulk_data_docname(@a.id,name))
-        data.url.should match /a%20b/
-        data.delete
-      end
-
-      it "should return bulk data url for completed bulk data app partition" do
-        set_state('test_db_storage' => @data)
-        @s.partition = :app
-        ClientSync.bulk_data(:app,@c)
-        do_bulk_data_job("data_name" => bulk_data_docname(@a.id,"*"))
-        ClientSync.bulk_data(:app,@c).should == {:result => :url,
-          :url => BulkData.load(bulk_data_docname(@a.id,"*")).url}
-        verify_result(
-          "client:#{@a_fields[:name]}:#{@u_fields[:login]}:#{@c.id}:#{@s_fields[:name]}:cd" => @data,
-          "source:#{@a_fields[:name]}:__shared__:#{@s_fields[:name]}:md" => @data,
-          "source:#{@a_fields[:name]}:__shared__:#{@s_fields[:name]}: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
-        ClientSync.bulk_data(:user,@c)
-        do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-        ClientSync.bulk_data(:user,@c).should == {:result => :url,
-          :url => BulkData.load(bulk_data_docname(@a.id,@u.id)).url}
-        verify_result(
-          "client:#{@a_fields[:name]}:#{@u_fields[:login]}:#{@c.id}:#{@s_fields[:name]}:cd" => {},
-          "source:#{@a_fields[:name]}:#{@u_fields[:login]}:#{@s_fields[:name]}:md" => @data,
-          "source:#{@a_fields[:name]}:#{@u_fields[:login]}:#{@s_fields[:name]}: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
-        ClientSync.bulk_data(:user,@c)
-        do_bulk_data_job("data_name" => bulk_data_docname(@a.id,@u.id))
-        data = BulkData.load(bulk_data_docname(@a.id,@u.id))
-        ClientSync.bulk_data(:user,@c).should == {:result => :url, :url => data.url}
-        File.delete(data.dbfile)
-        ClientSync.bulk_data(:user,@c).should == {:result => :wait}
-        Resque.peek(:bulk_data).should == {"args"=>
-          [{"data_name"=>bulk_data_docname(@a.id,@u.id)}], "class"=>"Rhoconnect::BulkDataJob"}
-      end
-     end
   end
   def receive_and_send_cud(operation)
     msg = "Error #{operation} record"
     op_data = {operation=>{ERROR=>{'an_attribute'=>msg,'name'=>'wrongname'}}}
-    @cs.receive_cud(op_data) 
+    @cud_handler.params = op_data
+    @cud_handler.run 
     if operation == 'update'
-      @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>1},
+      @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>1},
         {
           "update-rollback"=>{"0_broken_object_id"=>{"price"=>"99.99"}},
           "#{operation}-error"=>{"#{ERROR}-error"=>{"message"=>msg},ERROR=>op_data[operation][ERROR]}
         }]
     else
-      @cs.send_cud.should == [{'version'=>ClientSync::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
+      @sync_handler.run.should == [{'version'=>Rhoconnect::SYNC_VERSION},{"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
         {"#{operation}-error"=>{"#{ERROR}-error"=>{"message"=>msg},ERROR=>op_data[operation][ERROR]}}]
     end
   end