rhoconnect 3.0.0.beta1

data/spec/jobs/bulk_data_job_spec.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'support', 'shared_examples')
+
+describe "BulkDataJob" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
+
+    before(:each) do
+      Rhoconnect.blackberry_bulk_sync = true
+    end
+    after(:each) do
+      delete_data_directory
+    end
+    
+    let(:mock_schema) { {"property" => { "name" => "string", "brand" => "string" }, "version" => "1.0"} }
+
+    it "should create bulk data files from master document" do
+      set_state('test_db_storage' => @data)
+      docname = bulk_data_docname(@a.id,@u.id)
+      expected = { @s_fields[:name] => @data,
+        'FixedSchemaAdapter' => @data
+      }
+      data = BulkData.create(:name => docname,
+        :state => :inprogress,
+        :app_id => @a.id,
+        :user_id => @u.id,
+        :sources => [@s_fields[:name], 'FixedSchemaAdapter'])
+      BulkDataJob.perform("data_name" => data.name)
+      data = BulkData.load(docname)
+      data.completed?.should == true
+      verify_result(@s.docname(:md) => @data,@s.docname(:md_copy) => @data)
+      validate_db(data,expected).should == true
+      File.exists?(data.dbfile+'.rzip').should == true
+      File.exists?(data.dbfile+'.gzip').should == true
+      File.exists?(data.dbfile+'.hsqldb.data').should == true
+      File.exists?(data.dbfile+'.hsqldb.data.gzip').should == true
+      File.exists?(data.dbfile+'.hsqldb.script').should == true
+      File.exists?(data.dbfile+'.hsqldb.properties').should == true
+      path = File.join(File.dirname(data.dbfile),'tmp')
+      FileUtils.mkdir_p path
+      unzip_file("#{data.dbfile}.rzip",path)
+      data.dbfile = File.join(path,File.basename(data.dbfile))
+      validate_db(data,expected).should == true
+    end
+
+    it "should not create hsql db files if blackberry_bulk_sync is disabled" do
+      Rhoconnect.blackberry_bulk_sync = false
+      set_state('test_db_storage' => @data)
+      docname = bulk_data_docname(@a.id,@u.id)
+      data = BulkData.create(:name => docname,
+        :state => :inprogress,
+        :app_id => @a.id,
+        :user_id => @u.id,
+        :sources => [@s_fields[:name]])
+      BulkDataJob.perform("data_name" => data.name)
+      data = BulkData.load(docname)
+      data.completed?.should == true
+      verify_result(@s.docname(:md) => @data,@s.docname(:md_copy) => @data)
+      validate_db(data,@s.name => @data).should == true
+      File.exists?(data.dbfile+'.hsqldb.script').should == false
+      File.exists?(data.dbfile+'.hsqldb.properties').should == false
+    end
+
+    it "should create sqlite data with source metadata" do
+      set_state('test_db_storage' => @data)
+      mock_metadata_method([SampleAdapter]) do
+        docname = bulk_data_docname(@a.id,@u.id)
+        data = BulkData.create(:name => docname,
+          :state => :inprogress,
+          :app_id => @a.id,
+          :user_id => @u.id,
+          :sources => [@s_fields[:name]])
+        BulkDataJob.perform("data_name" => data.name)
+        data = BulkData.load(docname)
+        data.completed?.should == true
+        verify_result(@s.docname(:md) => @data,
+          @s.docname(:metadata) => {'foo'=>'bar'}.to_json,
+          @s.docname(:md_copy) => @data)
+        validate_db(data,@s.name => @data).should == true
+      end
+    end
+
+    it "should create sqlite data with source schema" do
+      set_state('test_db_storage' => @data)
+      mock_schema_method([SampleAdapter]) do
+        docname = bulk_data_docname(@a.id,@u.id)
+        data = BulkData.create(:name => docname,
+          :state => :inprogress,
+          :app_id => @a.id,
+          :user_id => @u.id,
+          :sources => [@s_fields[:name]])
+        BulkDataJob.perform("data_name" => data.name)
+        data = BulkData.load(docname)
+        data.completed?.should == true        
+        verify_result(@s.docname(:md) => @data, @s.docname(:md_copy) => @data)
+        JSON.parse(Store.get_value(@s.docname(:schema))).should == mock_schema          
+        validate_db(data,@s.name => @data).should == true
+      end
+    end
+
+    it "should raise exception if hsqldata fails" 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]])
+      lambda { BulkDataJob.create_hsql_data_file(data,Time.now.to_i.to_s) 
+        }.should raise_error(Exception,"Error running hsqldata")
+    end
+
+    it "should delete bulk data if exception is raised" do
+      lambda { BulkDataJob.perform("data_name" => 'broken') }.should raise_error(Exception)
+      Store.db.keys('bulk_data*').should == []
+    end
+
+    it "should delete bulk data if exception is raised" do
+      data = BulkData.create(:name => bulk_data_docname('broken',@u.id),
+        :state => :inprogress,
+        :app_id => 'broken',
+        :user_id => @u.id,
+        :sources => [@s_fields[:name]])
+      lambda { BulkDataJob.perform("data_name" => data.name) }.should raise_error(Exception)
+      Store.db.keys('bulk_data*').should == []
+    end
+  end  
+end

data/spec/jobs/ping_job_spec.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'support', 'shared_examples')
+
+describe "PingJob" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
+    
+    it "should perform apple ping with integer parameters" do
+      params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => 5, "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
+
+      scrubbed_params = params.dup
+      scrubbed_params['vibrate'] = '5'
+
+      Apple.should_receive(:ping).once.with({'device_pin' => @c.device_pin,
+        'device_port' => @c.device_port}.merge!(scrubbed_params))
+      PingJob.perform(params)
+    end
+
+    it "should perform blackberry ping with integer parameters" do
+      params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => 5, "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
+
+      scrubbed_params = params.dup
+      scrubbed_params['vibrate'] = '5'
+
+      @c.device_type = 'blackberry'
+      Blackberry.should_receive(:ping).once.with({'device_pin' => @c.device_pin,
+        'device_port' => @c.device_port}.merge!(scrubbed_params))
+      PingJob.perform(params)
+    end
+      
+    it "should perform apple ping" do
+      params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
+      Apple.should_receive(:ping).once.with({'device_pin' => @c.device_pin,
+        'device_port' => @c.device_port}.merge!(params))
+      PingJob.perform(params)
+    end
+
+    it "should perform blackberry ping" do
+      params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
+      @c.device_type = 'blackberry'
+      Blackberry.should_receive(:ping).once.with({'device_pin' => @c.device_pin,
+        'device_port' => @c.device_port}.merge!(params))
+      PingJob.perform(params)
+    end
+
+    it "should skip ping for empty device_type" do
+      params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+      @c.device_type = nil
+      PingJob.should_receive(:log).once.with("Skipping ping for non-registered client_id '#{@c.id}'...")
+      lambda { PingJob.perform(params) }.should_not raise_error
+    end
+
+    it "should skip ping for empty device_pin" do
+      params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+      @c.device_type = 'blackberry'
+      @c.device_pin = nil
+      PingJob.should_receive(:log).once.with("Skipping ping for non-registered client_id '#{@c.id}'...")
+      lambda { PingJob.perform(params) }.should_not raise_error
+    end
+    
+    it "should drop ping if it's already in user's device pin list" do
+      params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',"phone_id"=>nil}
+      # another client with the same device pin ...
+      @c1 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+      # and yet another one ...
+      @c2 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+
+      Apple.should_receive(:ping).with({'device_pin' => @c.device_pin, 'device_port' => @c.device_port}.merge!(params))
+      PingJob.should_receive(:log).twice.with(/Dropping ping request for client/)
+      lambda { PingJob.perform(params) }.should_not raise_error
+    end
+    
+    it "should drop ping if it's already in user's phone id list and device pin is different" do
+      params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+      @c.phone_id = '3'
+      @c_fields.merge!(:phone_id => '3')
+      # another client with the same phone id..
+      @c1 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+      #  yet another...
+      @c2 = Client.create(@c_fields,{:source_name => @s_fields[:name]})
+
+      Apple.should_receive(:ping).with({'device_pin' => @c.device_pin, 'phone_id' => @c.phone_id, 'device_port' => @c.device_port}.merge!(params))
+      PingJob.should_receive(:log).twice.with(/Dropping ping request for client/)
+      lambda { PingJob.perform(params) }.should_not raise_error
+    end
+  end  
+end

data/spec/jobs/source_job_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'support', 'shared_examples')
+
+describe "SourceJob" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
+    before(:each) do
+      @s = Source.load(@s_fields[:name],@s_params)
+    end
+    
+    it "should perform process_query" do
+      set_state('test_db_storage' => @data)  
+      SourceJob.perform('query',@s.id,@s.app_id,@s.user_id,nil,nil)
+      verify_result(@s.docname(:md) => @data,
+        @s.docname(:md_size) => @data.size.to_s)
+    end
+
+    it "should perform process_cud" do
+      expected = {'backend_id'=>@product1}
+      @product1['link'] = 'abc'
+      set_state(@c.docname(:create) => {'1'=>@product1})
+      SourceJob.perform('cud',@s.id,@s.app_id,@s.user_id,@c.id,nil)
+      verify_result(@s.docname(:md) => expected,
+        @s.docname(:md_size) => expected.size.to_s,
+        @c.docname(:cd) => expected,
+        @c.docname(:cd_size) => expected.size.to_s,
+        @c.docname(:create) => {})
+    end
+  end  
+end

data/spec/license_spec.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__), 'support', 'shared_examples')
+
+describe "License" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
+    before(:each) do
+      Store.put_value(License::CLIENT_DOCKEY,nil)
+    end
+
+    it "should decrypt license" do
+      license = License.new
+      license.rhoconnect_version.should == 'Version 1'
+      license.licensee.should == 'Rhomobile'
+      license.seats.should == 10
+      license.issued.should == 'Fri Apr 23 17:20:13 -0700 2010'
+    end
+
+    it "should raise exception on license load error" do
+      Rhoconnect.stub!(:get_config).and_return({Rhoconnect.environment.to_sym => {}})
+      lambda { License.new }.should raise_error(LicenseException, "Error verifying license.")
+    end
+
+    it "should verify # of seats before adding" do
+      License.new.check_and_use_seat
+      Store.get_value(License::CLIENT_DOCKEY).to_i.should == 1
+    end
+
+    it "should raise exception when seats are exceeded" do
+      Store.put_value(License::CLIENT_DOCKEY,10)
+      lambda { License.new.check_and_use_seat }.should raise_error(
+        LicenseSeatsExceededException, "WARNING: Maximum # of devices exceeded for this license."
+      )
+    end
+
+    it "should free license seat" do
+      Store.put_value(License::CLIENT_DOCKEY,5)
+      License.new.free_seat
+      Store.get_value(License::CLIENT_DOCKEY).to_i.should == 4
+    end
+
+    it "should get # of available seats" do
+      license = License.new
+      license.check_and_use_seat
+      license.available.should == 9
+    end
+
+    it "should use RHOCONNECT_LICENSE env var" do
+      ENV['RHOCONNECT_LICENSE'] = 'b749cbe6e029400e688360468624388e2cb7f6a1e72c91d4686a1b8c9d37b72c3e1872ec9f369d481220e10759c18e16'
+      license = License.new
+      license.licensee.should == 'Rhohub'
+      license.seats.should == 5
+      license.issued.should == 'Tue Aug 10 16:14:24 -0700 2010'
+      ENV.delete('RHOCONNECT_LICENSE')
+    end
+    
+    it "should use RHOSYNC_LICENSE env var" do
+      ENV['RHOSYNC_LICENSE'] = 'b749cbe6e029400e688360468624388e2cb7f6a1e72c91d4686a1b8c9d37b72c3e1872ec9f369d481220e10759c18e16'
+      license = License.new
+      license.licensee.should == 'Rhohub'
+      license.seats.should == 5
+      license.issued.should == 'Tue Aug 10 16:14:24 -0700 2010'
+      ENV.delete('RHOSYNC_LICENSE')
+    end
+  end
+
+end

data/spec/model_spec.rb

@@ -0,0 +1,273 @@
+# Taken from http://github.com/voloko/redis-model
+require File.join(File.dirname(__FILE__),'spec_helper')
+
+describe Rhoconnect::Model do
+  
+  context "DSL" do
+    class TestDSL < Rhoconnect::Model
+      field :foo
+      list  :bar
+      set   :sloppy
+    end
+  
+    before(:each) do
+      @x = TestDSL.with_key(1)
+    end
+  
+    it "should define rw accessors for field" do
+      @x.should respond_to(:foo)
+      @x.should respond_to(:foo=)
+    end
+  
+    it "should define r accessor for list" do
+      @x.should respond_to(:bar)
+    end
+  
+    it "should define r accessor for set" do
+      @x.should respond_to(:sloppy)
+    end
+  
+    it "should raise error on invalid type" do
+      lambda do
+        class TestInvalidType < Rhoconnect::Model
+          field :invalid, :invalid_type
+        end
+      end.should raise_error(ArgumentError, 'Unknown type invalid_type for field invalid')
+    end
+  end
+  
+  context "field type cast" do
+    class TestType < Rhoconnect::Model
+      field :foo_string, :string
+      field :foo_json,   :json
+      field :foo_date,   :datetime
+      field :foo_int,    :int
+      field :foo_float,  :float
+      
+      list  :list_date,  :datetime
+      set   :set_date,   :datetime      
+    end
+    
+    class TestValidateType < Rhoconnect::Model
+      field :v_field, :string
+      validates_presence_of :v_field
+    end
+    
+    class TestLoadType < Rhoconnect::Model
+      field :something, :string
+      attr_accessor :foo
+    end
+  
+    before(:each) do
+      @xRedisMock = RSpec::Mocks::Mock.new
+      @yRedisMock = RSpec::Mocks::Mock.new
+      @x = TestType.with_key(1)
+      @y = TestType.with_key(1)
+      @x.stub!(:redis).and_return(@xRedisMock)
+      @y.stub!(:redis).and_return(@yRedisMock)
+    end
+    
+    it "should create with string id" do
+      @x = TestType.create(:id => 'test')
+      @x.id.should == 'test'
+    end
+    
+    it "should create with auto-increment id" do
+      @x = TestType.create
+      @x1 = TestType.create
+      @x1.id.should == @x.id + 1
+    end
+    
+    it "should raise ArgumentError on create with duplicate id" do
+      @x = TestType.create(:id => 'test1')
+      lambda { TestType.create(:id => 'test1') }.should 
+        raise_error(ArgumentError, "Record already exists for 'test1'")
+    end
+    
+    it "should validate_presence_of v_field" do
+      lambda { TestValidateType.create(:id => 'test2') }.should
+        raise_error(ArgumentError, "Missing required field 'v_field'")
+    end
+    
+    it "should load with attributes set" do
+      TestLoadType.create(:id => 'test2')
+      @x = TestLoadType.load('test2',{:foo => 'bar'})
+      @x.foo.should == 'bar'
+    end
+  
+    it "should save string as is" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_string', 'xxx')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_string').and_return('xxx')
+      @x.foo_string = 'xxx'
+      @y.foo_string.should be_instance_of(String)
+    end
+  
+    it "should marshal integer fields" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_int', '12')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_int').and_return('12')
+      @x.foo_int = 12
+      @y.foo_int.should be_kind_of(Integer)
+      @y.foo_int.should == 12
+    end
+  
+    it "should marshal float fields" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_float', '12.1')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_float').and_return('12.1')
+      @x.foo_float = 12.1
+      @y.foo_float.should be_kind_of(Float)
+      @y.foo_float.should == 12.1
+    end
+  
+    it "should marshal datetime fields" do
+      time = DateTime.now
+      str  = time.strftime('%FT%T%z')
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_date', str)
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_date').and_return(str)
+      @x.foo_date = time
+      @y.foo_date.should be_kind_of(DateTime)
+      @y.foo_date.should.to_s == time.to_s
+    end
+  
+    it "should marshal json structs" do
+      data = {'foo' => 'bar', 'x' => 2}
+      str  = JSON.dump(data)
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_json', str)
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_json').and_return(str)
+      @x.foo_json = data
+      @y.foo_json.should be_kind_of(Hash)
+      @y.foo_json.should.inspect == data.inspect
+    end
+    
+    it "should return nil for empty fields" do
+      @xRedisMock.should_receive(:[]).with('test_type:1:foo_date').and_return(nil)
+      @x.foo_date.should be_nil
+    end
+    
+    it "should marshal list values" do
+      data = DateTime.now
+      str  = data.strftime('%FT%T%z')
+      
+      @xRedisMock.should_receive('rpush').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lset').with('test_type:1:list_date', 1, str)
+      @xRedisMock.should_receive('exists').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lrem').with('test_type:1:list_date', 0, str)
+      @xRedisMock.should_receive('lpush').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lrange').with('test_type:1:list_date', 0, 1).and_return([str])
+      @xRedisMock.should_receive('rpop').with('test_type:1:list_date').and_return(str)
+      @xRedisMock.should_receive('lpop').with('test_type:1:list_date').and_return(str)
+      @xRedisMock.should_receive('lindex').with('test_type:1:list_date', 0).and_return(str)
+      @x.list_date << data
+      @x.list_date[1] = data
+      @x.list_date.include?(data)
+      @x.list_date.remove(0, data)
+      @x.list_date.push_head(data)
+      @x.list_date[0].should be_kind_of(DateTime)
+      @x.list_date[0, 1][0].should be_kind_of(DateTime)
+      @x.list_date.pop_tail.should be_kind_of(DateTime)
+      @x.list_date.pop_head.should be_kind_of(DateTime)
+    end
+    
+    it "should marshal set values" do
+      data = DateTime.now
+      str  = data.strftime('%FT%T%z')
+
+      @xRedisMock.should_receive('sadd').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('srem').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('sismember').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('smembers').with('test_type:1:set_date').and_return([str])
+      @xRedisMock.should_receive('sinter').with('test_type:1:set_date', 'x').and_return([str])
+      @xRedisMock.should_receive('sunion').with('test_type:1:set_date', 'x').and_return([str])
+      @xRedisMock.should_receive('sdiff').with('test_type:1:set_date', 'x', 'y').and_return([str])
+      @x.set_date << data
+      @x.set_date.delete(data)
+      @x.set_date.include?(data)
+      @x.set_date.members[0].should be_kind_of(DateTime)
+      @x.set_date.intersect('x')[0].should be_kind_of(DateTime)
+      @x.set_date.union('x')[0].should be_kind_of(DateTime)
+      @x.set_date.diff('x', 'y')[0].should be_kind_of(DateTime)
+    end
+
+    it "should handle empty members" do
+      @xRedisMock.stub!(:smembers).and_return(nil)
+      @x.set_date.members.should == []
+    end
+  end
+  
+  context "increment/decrement" do
+    class TestIncrements < Rhoconnect::Model
+      field :foo, :integer
+      field :bar, :string
+      field :baz, :float
+    end
+    
+    before do
+      @redisMock = RSpec::Mocks::Mock.new
+      @x = TestIncrements.with_key(1)
+      @x.stub!(:redis).and_return(@redisMock)
+    end
+    
+    it "should send INCR when #increment! is called on an integer" do
+      @redisMock.should_receive(:incr).with("test_increments:1:foo", 1)
+      @x.increment!(:foo)
+    end
+    
+    it "should send DECR when #decrement! is called on an integer" do
+      @redisMock.should_receive(:decr).with("test_increments:1:foo", 1)
+      @x.decrement!(:foo)
+    end
+    
+    it "should raise an ArgumentError when called on non-integers" do
+      [:bar, :baz].each do |f|
+        lambda{@x.increment!(f)}.should raise_error(ArgumentError)
+        lambda{@x.decrement!(f)}.should raise_error(ArgumentError)
+      end
+    end
+  end
+  
+  context "redis commands" do
+    class TestCommands < Rhoconnect::Model
+      field :foo
+      list  :bar
+      set   :sloppy
+    end
+    
+    before(:each) do
+      @redisMock = RSpec::Mocks::Mock.new
+      @x = TestCommands.with_key(1)
+      @x.stub!(:redis).and_return(@redisMock)
+    end
+  
+    it "should send GET on field read" do
+      @redisMock.should_receive(:[]).with('test_commands:1:foo')
+      @x.foo
+    end
+  
+    it "should send SET on field write" do
+      @redisMock.should_receive(:[]=).with('test_commands:1:foo', 'bar')
+      @x.foo = 'bar'
+    end
+  
+    it "should send RPUSH on list <<" do
+      @redisMock.should_receive(:rpush).with('test_commands:1:bar', 'bar')
+      @x.bar << 'bar'
+    end
+  
+    it "should send SADD on set <<" do
+      @redisMock.should_receive(:sadd).with('test_commands:1:sloppy', 'bar')
+      @x.sloppy << 'bar'
+    end
+    
+    it "should delete separate fields" do
+      @redisMock.should_receive(:del).with('test_commands:1:foo')
+      @x.delete :foo
+    end
+    
+    it "should delete all field" do
+      @redisMock.should_receive(:del).with('test_commands:1:foo')
+      @redisMock.should_receive(:del).with('test_commands:1:rho__id')
+      @redisMock.should_receive(:del).with('test_commands:1:bar')
+      @redisMock.should_receive(:del).with('test_commands:1:sloppy')
+      @x.delete
+    end
+  end
+end

data/spec/perf/bulk_data_perf_spec.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__),'perf_spec_helper')
+
+describe "BulkData Performance" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
+    before(:each) do
+      basedir = File.join(File.dirname(__FILE__),'..','apps','rhotestapp')
+      Rhoconnect.bootstrap(basedir) do |rhoconnect|
+        rhoconnect.vendor_directory = File.join(basedir,'..','vendor')
+      end
+    end
+
+    after(:each) do
+      delete_data_directory
+    end
+
+    it "should generate sqlite bulk data for 1000 objects (6000 attributes)" do
+      start = start_timer
+      @data = get_test_data(1000)
+      start = lap_timer('generate data',start)
+      set_state('test_db_storage' => @data)
+      start = lap_timer('set_state masterdoc',start)
+      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]])
+      BulkDataJob.perform("data_name" => data.name)
+      lap_timer('BulkDataJob.perform duration',start)
+    end
+  end  
+
+end

data/spec/perf/perf_spec_helper.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'support', 'shared_examples')
+require 'ffaker'
+
+def get_test_data(num=1000)
+  file = File.join("spec","testdata","#{num}-data.txt")
+  data = nil
+  if File.exists?(file)
+    data = open(file, 'r') {|f| Marshal.load(f)}
+  else
+    data = generate_fake_data(num)
+    f = File.new(file, 'w')
+    f.write Marshal.dump(data)
+    f.close
+  end
+  data
+end
+
+private
+
+PREFIX = ["Account", "Administrative", "Advertising", "Assistant", "Banking", "Business Systems", 
+  "Computer", "Distribution", "IT", "Electronics", "Environmental", "Financial", "General", "Head", 
+  "Laboratory", "Maintenance", "Medical", "Production", "Quality Assurance", "Software", "Technical", 
+  "Chief", "Senior"] unless defined? PREFIX
+SUFFIX = ["Clerk", "Analyst", "Manager", "Supervisor", "Plant Manager", "Mechanic", "Technician", "Engineer", 
+  "Director", "Superintendent", "Specialist", "Technologist", "Estimator", "Scientist", "Foreman", "Nurse", 
+  "Worker", "Helper", "Intern", "Sales", "Mechanic", "Planner", "Recruiter", "Officer", "Superintendent",
+  "Vice President", "Buyer", "Production Supervisor", "Chef", "Accountant", "Executive"] unless defined? SUFFIX
+
+def title
+  prefix = PREFIX[rand(PREFIX.length)]
+  suffix = SUFFIX[rand(SUFFIX.length)]
+
+  "#{prefix} #{suffix}"
+end
+
+def generate_fake_data(num=1000)
+  res = {}
+  num.times do |n|
+    res[n.to_s] = {
+      "FirstName" => Faker::Name.first_name,
+      "LastName" => Faker::Name.last_name,
+      "Email" =>  Faker::Internet.free_email,
+      "Company" => Faker::Company.name,
+      "JobTitle" => title,
+      "Phone1" => Faker::PhoneNumber.phone_number
+    }
+  end
+  res
+end