rhosync 2.0.0.beta1

data/spec/apps/rhotestapp/settings/settings.yml

@@ -0,0 +1,23 @@
+:sources:
+  SampleAdapter:
+    poll_interval: 300
+  SimpleAdapter:
+    poll_interval: 600
+    partition_type: app
+    
+:development:
+  :licensefile: settings/license.key
+  :iphonecertfile: settings/apple_fake_cert.pem
+  :iphonepassphrase: certpassword
+  :iphoneserver: gateway.sandbox.push.apple.com
+  :iphoneport: 2195
+  :redis: localhost:6379
+  :syncserver: http://localhost:9292/application/
+:test: 
+  :licensefile: settings/license.key
+  :redis: localhost:6379
+  :syncserver: http://localhost:9292/application/
+:production: 
+  :licensefile: settings/license.key
+  :redis: localhost:6379
+  :syncserver: http://localhost:9292/application/

data/spec/apps/rhotestapp/sources/base_adapter.rb

@@ -0,0 +1,9 @@
+class BaseAdapter < SourceAdapter
+  def initialize(source,credential)
+    super(source,credential)
+  end
+ 
+  def query(params=nil)
+    @result
+  end
+end

data/spec/apps/rhotestapp/sources/sample_adapter.rb

@@ -0,0 +1,66 @@
+class SampleAdapter < SourceAdapter
+  def initialize(source,credential)
+    super(source,credential)
+  end
+ 
+  def login
+    raise SourceAdapterLoginException.new('Error logging in') if _is_empty?(current_user.login)
+    true
+  end
+ 
+  def query(params=nil)
+    _read('query',params)
+  end
+  
+  def search(params=nil)
+    _read('search',params)
+  end
+ 
+  def sync
+    super
+  end
+ 
+  def create(name_value_list,blob=nil)
+    Store.put_data('test_create_storage',{name_value_list['_id']=>name_value_list},true)
+    raise SourceAdapterException.new("ID provided in name_value_list") if name_value_list['id']
+    _raise_exception(name_value_list) 
+    'backend_id' if name_value_list and name_value_list['link']
+  end
+ 
+  def update(name_value_list)
+    raise SourceAdapterException.new("No id provided in name_value_list") unless name_value_list['id']
+    Store.put_data('test_update_storage',{name_value_list['id']=>name_value_list},true)
+    _raise_exception(name_value_list) 
+  end
+ 
+  def delete(name_value_list)
+    raise SourceAdapterException.new("No id provided in name_value_list") unless name_value_list['id']
+    raise SourceAdapterServerErrorException.new("Error delete record") if name_value_list['id'] == ERROR
+    Store.put_data('test_delete_storage',{name_value_list['id']=>name_value_list},true)
+  end
+ 
+  def logoff
+    @result = Store.get_data('test_db_storage')
+    raise SourceAdapterLogoffException.new(@result[ERROR]['an_attribute']) if @result[ERROR] and 
+      @result[ERROR]['name'] == 'logoff error'
+  end
+  
+  private
+  def _is_empty?(str)
+    str.length <= 0
+  end
+  
+  def _raise_exception(name_value_list)
+    if name_value_list and name_value_list['name'] == 'wrongname' or name_value_list['id'] == 'error'
+      raise SourceAdapterServerErrorException.new(name_value_list['an_attribute']) 
+    end
+  end
+  
+  def _read(operation,params)
+    @result = Store.get_data('test_db_storage')
+    raise SourceAdapterServerErrorException.new(@result[ERROR]['an_attribute']) if @result[ERROR] and 
+      @result[ERROR]['name'] == "#{operation} error"
+    @result.reject! {|key,value| value['name'] != params['name']} if params
+    @result
+  end
+end

data/spec/apps/rhotestapp/sources/simple_adapter.rb

@@ -0,0 +1,39 @@
+class SimpleAdapter < SourceAdapter
+  def initialize(source,credential)
+    super(source,credential)
+  end
+ 
+  def login
+    unless _is_empty?(current_user.login)
+      true
+    else
+      raise SourceAdapterLoginException.new('Error logging in')
+    end
+  end
+ 
+  def query(params=nil)
+    @result
+  end
+  
+  def search(params=nil,txt='')
+    params[:foo] = 'bar'
+    if params['search'] == 'bar'
+      @result = {'obj'=>{'foo'=>'bar'}} 
+      params['name'] = 'iPhone'
+    end
+    @result
+  end
+ 
+  def sync
+    super
+  end
+ 
+  def create(name_value_list,blob=nil)
+    'obj4'
+  end
+  
+  private
+  def _is_empty?(str)
+    str.length <= 0
+  end
+end

data/spec/apps/rhotestapp/sources/sub_adapter.rb

@@ -0,0 +1,7 @@
+require 'base_adapter'
+
+class SubAdapter < BaseAdapter
+  def initialize(source,credential)
+    super(source,credential)
+  end
+end

data/spec/apps/rhotestapp/vendor/mygem-0.1.0/lib/mygem/mygem.rb

@@ -0,0 +1,8 @@
+module Mygem
+  VERSION = '0.1.0'
+  class Mygem
+    def self.version
+      VERSION
+    end
+  end
+end

data/spec/apps/rhotestapp/vendor/mygem-0.1.0/lib/mygem.rb

@@ -0,0 +1 @@
+require 'mygem/mygem'

data/spec/bulk_data/bulk_data_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe "BulkData" do
+  it_should_behave_like "SpecBootstrapHelper"
+  it_should_behave_like "SourceAdapterHelper"
+  
+  after(:each) do
+    delete_data_directory
+  end
+  
+  it "should return true if bulk data is completed" do
+    dbfile = create_datafile(File.join(@a.name,@u.id.to_s),@u.id.to_s)
+    data = BulkData.create(:name => bulk_data_docname(@a.id,@u.id),
+      :state => :completed,
+      :app_id => @a.id,
+      :user_id => @u.id,
+      :sources => [@s_fields[:name]])
+    data.dbfile = dbfile 
+    data.completed?.should == true
+  end
+  
+  it "should return false if bulk data isn't completed" do
+    data = BulkData.create(:name => bulk_data_docname(@a.id,@u.id),
+      :state => :inprogress,
+      :app_id => @a.id,
+      :user_id => @u.id,
+      :sources => [@s_fields[:name]])
+    data.completed?.should == false
+  end
+  
+  it "should enqueue sqlite db type" do
+    BulkData.enqueue
+    Resque.peek(:bulk_data).should == {"args"=>[{}], 
+      "class"=>"Rhosync::BulkDataJob"}
+  end
+  
+  it "should generate correct bulk data name for user partition" do
+    BulkData.get_name(:user,@c).should == File.join(@a_fields[:name],@u_fields[:login],@u_fields[:login])
+  end
+  
+  it "should generate correct bulk data name for app partition" do
+    BulkData.get_name(:app,@c).should == 
+      File.join(@a_fields[:name],@a_fields[:name])
+  end
+  
+  it "should process_sources for bulk data" do
+    current = Time.now.to_i
+    @s.read_state.refresh_time = current
+    data = BulkData.create(:name => bulk_data_docname(@a.id,@u.id),
+      :state => :inprogress,
+      :app_id => @a.id,
+      :user_id => @u.id,
+      :sources => [@s_fields[:name]])
+    data.process_sources
+    @s.read_state.refresh_time.should >= current + @s_fields[:poll_interval].to_i
+  end
+  
+  it "should delete source masterdoc copy on delete" do
+    set_state('test_db_storage' => @data)
+    data = BulkData.create(:name => bulk_data_docname(@a.id,@u.id),
+      :state => :inprogress,
+      :app_id => @a.id,
+      :user_id => @u.id,
+      :sources => [@s_fields[:name]])
+    data.process_sources
+    verify_result(@s.docname(:md_copy) => @data)
+    data.delete
+    verify_result(@s.docname(:md_copy) => {},
+      @s.docname(:md) => @data)
+  end
+end
+
+def create_datafile(dir,name)
+  dir = File.join(Rhosync.data_directory,dir)
+  FileUtils.mkdir_p(dir)
+  fname = File.join(dir,name+'.data')
+  File.open(fname,'wb') {|f| f.puts ''}
+  fname
+end

data/spec/client_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+
+describe "Client" do
+  it_should_behave_like "SpecBootstrapHelper"
+  it_should_behave_like "SourceAdapterHelper"
+  
+  it "should create client with fields" do
+    @c.id.length.should == 32
+    @c.device_type.should == @c_fields[:device_type]
+  end
+  
+  it "should update_fields for a client" do
+    @c.update_fields({:device_type => 'android',:device_port => 100})
+    @c.device_type.should == 'android'
+    @c.device_port.should == '100'
+  end
+  
+  it "should create client with user_id" do
+    @c.id.length.should == 32
+    @c.user_id.should == @c_fields[:user_id]
+    @u.clients.members.should == [@c.id]
+  end
+  
+  it "should raise exception if source_name is nil" do
+    @c.source_name = nil
+    lambda { 
+      @c.doc_suffix('foo') 
+    }.should raise_error(InvalidSourceNameError, 'Invalid Source Name For Client')
+  end
+  
+  it "should raise exception if license seats exceeded" do
+    Store.put_value(License::CLIENT_DOCKEY,100)
+    lambda { Client.create(@c_fields,{}) }.should raise_error(
+      LicenseSeatsExceededException, "WARNING: Maximum # of clients exceeded for this license."
+    )
+  end
+  
+  it "should free seat when client is deleted" do
+    current = Store.get_value(License::CLIENT_DOCKEY).to_i
+    @c.delete
+    Store.get_value(License::CLIENT_DOCKEY).to_i.should == current - 1
+  end
+
+  it "should delete client and all associated documents" do
+    docname = @c.docname(:cd)
+    set_state(docname => @data)    
+    @c.delete
+    verify_result(docname => {})
+  end
+  
+  it "should create cd as masterdoc clone" do
+    set_state(@s.docname(:md_copy) => @data,
+      @c.docname(:cd) => {'foo' => {'bar' => 'abc'}})
+    @c.update_clientdoc([@s_fields[:name]])
+    verify_result(@c.docname(:cd) => @data,
+      @s.docname(:md_copy) => @data)
+  end
+end

data/spec/client_sync_spec.rb

@@ -0,0 +1,377 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+
+describe "ClientSync" do
+  it_should_behave_like "SpecBootstrapHelper"
+  it_should_behave_like "SourceAdapterHelper"
+  
+  it "should raise Argument error if no client or source is provided" do
+    lambda { ClientSync.new(@s,nil,2) }.should raise_error(ArgumentError,'Missing required attribute client')
+    lambda { ClientSync.new(nil,@c,2) }.should raise_error(ArgumentError,'Missing required attribute source')
+  end
+  
+  before(:each) do
+    @cs = ClientSync.new(@s,@c,2)
+  end
+  
+  describe "cud methods" do
+    it "should handle receive cud" do
+      params = {'create'=>{'1'=>@product1},'update'=>{'2'=>@product2},'delete'=>{'3'=>@product3}}
+      @cs.receive_cud(params)
+      verify_result(@cs.client.docname(:create) => {},
+        @cs.client.docname(:update) => {},
+        @cs.client.docname(: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::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)
+    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::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::VERSION},{"token"=>""}, 
+        {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
+        {'source-error'=>{"login-error"=>{"message"=>"Error logging in"}}}]
+    end
+    
+    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::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}}}]
+    end
+    
+    describe "send errors in send_cud" do
+      it "should handle create errors" do
+        receive_and_send_cud('create')
+      end
+      
+      it "should handle update errors" do
+        receive_and_send_cud('update')
+      end
+      
+      it "should handle delete errors" 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::VERSION},
+          {"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
+          {"delete-error"=>{"#{ERROR}-error"=>{"message"=>msg},ERROR=>error_objs[ERROR]}}]      
+      end
+      
+      it "should send cud errors only once" 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::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::VERSION},
+          {"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},{}]
+      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)
+        @cs.send_cud.should == [{"version"=>ClientSync::VERSION},
+          {"token"=>""}, {"count"=>0}, {"progress_count"=>0}, {"total_count"=>0},
+          {"#{operation}-error"=>{"#{ERROR}-error"=>{"message"=>msg},ERROR=>op_data[operation][ERROR]}}]
+      end
+    end
+  
+    it "should handle receive_cud" do
+      set_state(@s.docname(:md) => {'3'=>@product3},
+        @c.docname(:cd) => {'3'=>@product3})
+      params = {'create'=>{'1'=>@product1},
+        'update'=>{'2'=>@product2},'delete'=>{'3'=>@product3}}
+      @cs.receive_cud(params)
+      verify_result(@cs.client.docname(:create) => {},
+        @cs.client.docname(:update) => {},
+        @cs.client.docname(:delete) => {},
+        @s.docname(:md) => {},
+        @c.docname(:cd) => {})
+    end
+    
+    it "should handle blob upload in receive_cud" do
+      pending
+    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
+  end
+  
+  describe "search" do
+    before(:each) do
+      @s_fields[:name] = 'SimpleAdapter'
+      @c1 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+      @s1 = Source.create(@s_fields,@s_params)
+      @cs1 = ClientSync.new(@s1,@c1,2)
+    end
+    
+    it "should handle search" do
+      params = {:search => {'name' => 'iPhone'}}
+      set_state('test_db_storage' => @data)
+      res = @cs.search(params)
+      token = @c.get_value(:search_token)
+      res.should == [{'version'=>ClientSync::VERSION},{'search_token'=>token},
+        {'source'=>@s.name},{'count'=>1},{'insert'=>{'1'=>@product1}}]
+      verify_result(@c.docname(:search) => {'1'=>@product1},
+        @c.docname(:search_errors) => {})
+    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) => {})
+    end
+    
+    it "should resend search by search_token" do
+      @source = @s
+      set_state({@c.docname(:search) => {'1'=>@product1}})
+      token = compute_token @cs.client.docname(:search_token)
+      @cs.search({:resend => true,:search_token => token}).should == [{'version'=>ClientSync::VERSION},
+        {'search_token'=>token},{'source'=>@s.name},{'count'=>1},{'insert'=>{'1'=>@product1}}]
+      verify_result(@c.docname(:search) => {'1'=>@product1},
+        @c.docname(:search_errors) => {},
+        @cs.client.docname(:search_token) => token)
+    end
+    
+    it "should handle search ack" do
+      @source = @s
+      set_state({@c.docname(:search) => {'1'=>@product1}})
+      token = compute_token @cs.client.docname(:search_token)
+      @cs.search({:search_token => token}).should == []
+      verify_result(@c.docname(:search) => {},
+        @c.docname(:search_errors) => {},
+        @cs.client.docname(:search_token) => nil)
+    end
+    
+    it "should handle search all" do
+      sources = ['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::VERSION},{'search_token'=>token},
+        {'source'=>sources[0]},{'count'=>1},{'insert'=>{'1'=>@product1}}]]
+      verify_result(@c.docname(:search) => {'1'=>@product1},
+        @c.docname(:search_errors) => {})
+    end
+    
+    it "should handle search all error" do
+      sources = ['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::VERSION},
+        {'source'=>sources[0]},{'search-error'=>{'search-error'=>{'message'=>msg}}}]]
+      verify_result(@c.docname(:search) => {},
+        @c.docname(:search_errors) => {'search-error'=>{'message'=>msg}})
+    end
+    
+    it "should handle search all login error" do
+      @u.login = nil
+      sources = ['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::VERSION},{'source'=>sources[0]},
+        {'search-error'=>{'login-error'=>{'message'=>msg}}}]]
+      verify_result(@c.docname(:search) => {},
+        @c.docname(:search_errors) => {'login-error'=>{'message'=>msg}},
+        @c.docname(:search_token) => nil)
+    end
+    
+    it "should handle multiple source search all" do
+      set_test_data('test_db_storage',@data)
+      sources = ['SampleAdapter','SimpleAdapter']
+      res = ClientSync.search_all(@c,{:sources => sources,:search => {'name' => 'iPhone'}})
+      @c.source_name = 'SampleAdapter'
+      token = Store.get_value(@c.docname(:search_token))
+      res.should == [[{"version"=>ClientSync::VERSION},{'search_token'=>token},
+        {"source"=>"SampleAdapter"},{"count"=>1},{"insert"=>{'1'=>@product1}}],[]]
+    end
+    
+    it "should handle search and accumulate params" do
+      set_test_data('test_db_storage',@data)
+      sources = ['SimpleAdapter','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::VERSION}, {'search_token'=>token},
+        {"source"=>"SimpleAdapter"},{"count"=>1},{"insert"=>{'obj'=>{'foo'=>'bar'}}}],
+        [{"version"=>ClientSync::VERSION},{'search_token'=>token1},{"source"=>"SampleAdapter"}, 
+         {"count"=>1}, {"insert"=>{'1'=>@product1}}]]      
+    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)
+      @expected = {'1'=>@product1,'2'=>@product2}
+      @cs.compute_page.should == [0,3,@expected]
+      Store.get_value(@cs.client.docname(:cd_size)).to_i.should == 0
+      Store.get_data(@cs.client.docname(:page)).should == @expected      
+    end
+
+    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
+
+      @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
+    end
+
+    it "should return deleted objects in the client document" do
+      Store.put_data(@s.docname(:md),@data).should == true
+      Store.get_data(@s.docname(: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
+
+      @expected = {'4'=>@product4}
+      @cs.compute_deleted_page.should == @expected
+      Store.get_data(@cs.client.docname(:delete_page)).should == @expected
+    end  
+
+    it "should delete objects from client document" do
+      Store.put_data(@s.docname(:md),@data).should == true
+      Store.get_data(@s.docname(: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
+
+      Store.delete_data(@cs.client.docname(:cd),@cs.compute_deleted_page).should == true
+      Store.get_data(@cs.client.docname(: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)
+      token = @c.get_value(:page_token)
+      @cs.send_cud.should == [{"version"=>ClientSync::VERSION},{"token"=>token}, 
+        {"count"=>1}, {"progress_count"=>0},{"total_count"=>1},{'insert' => expected}]
+      @cs.send_cud(token).should == [{"version"=>ClientSync::VERSION},{"token"=>""}, 
+        {"count"=>0}, {"progress_count"=>1}, {"total_count"=>1}, {}]
+      Store.get_data(@cs.client.docname(:page)).should == {}              
+      @c.get_value(:page_token).should be_nil
+    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"=>"Rhosync::BulkDataJob"}
+    end
+    
+    it "should create bulk data job app partition if none exists and no parition sources" do
+      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"=>"Rhosync::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)
+      BulkDataJob.perform("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)).dbfile}
+      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 bulk data url for completed bulk data app partition" do
+      set_state('test_db_storage' => @data)
+      @s.partition = :app
+      ClientSync.bulk_data(:app,@c)
+      BulkDataJob.perform("data_name" => bulk_data_docname(@a.id,"*"))
+      ClientSync.bulk_data(:app,@c).should == {:result => :url,
+        :url => BulkData.load(bulk_data_docname(@a.id,"*")).dbfile}
+      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)
+      BulkDataJob.perform("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)).dbfile}
+      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
+  end
+end