rhoconnect 3.4.5 → 4.0.0.beta.10

data/spec/store_spec.rb

@@ -3,56 +3,26 @@ require File.join(File.dirname(__FILE__),'spec_helper')
 describe "Store" do
   it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
     describe "store methods" do
-      it "should create db class method" do
-        if RUBY_VERSION =~ /1.9/
-          Store.db.class.name.should match(/ConnectionPool/)
-        else
-          Store.db.class.name.should match(/Redis/)
-        end
-      end
-
-      it "should set redis connection" do
-        Store.db = nil
-        Store.db = 'localhost:6379'
-        Store.db.client.host.should == 'localhost'
-        Store.db.client.port.should == 6379
-      end
-
-      it "should create default redis connection" do
-        Store.db = nil
-        if RUBY_VERSION =~ /1.9/
-          Store.db.class.name.should match(/ConnectionPool/)
-        else
-          Store.db.class.name.should match(/Redis/)
-        end
-      end
-
-      it "should assign redis to existing redis" do
-        Store.db = Redis.new(:timeout => 60)
-        Store.db.client.timeout.should == 60
+      it "should create proper connection class" do
+        Store.get_store(0).db.class.name.should match(/Redis/)
       end
 
       it "should create redis connection based on ENV" do
         ENV[REDIS_URL] = 'redis://localhost:6379'
-        if RUBY_VERSION =~ /1.9/  
-          Redis.should_receive(:connect).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).exactly(5).times.and_return { Redis.new }
-        else
-          Redis.should_receive(:connect).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).and_return { Redis.new }
-        end
-        Store.db = nil
-        Store.db.should_not == nil
+        Redis.should_receive(:connect).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).exactly(5).times.and_return { Redis.new }
+        Store.nullify
+        Store.num_stores.should == 0
+        Store.create
+        Store.get_store(0).db.should_not == nil
         ENV.delete(REDIS_URL)
       end
 
       it "should create redis connection based on REDISTOGO_URL ENV" do
         ENV[REDISTOGO_URL] = 'redis://localhost:6379'
-        if RUBY_VERSION =~ /1.9/
-          Redis.should_receive(:connect).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).exactly(5).times.and_return { Redis.new }
-        else
-          Redis.should_receive(:connect).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).and_return { Redis.new }
-        end
-        Store.db = nil
-        Store.db.should_not == nil
+        Redis.should_receive(:connect).with(:url => 'redis://localhost:6379', :thread_safe => true, :timeout => Rhoconnect.redis_timeout).exactly(5).times.and_return { Redis.new }
+        Store.nullify
+        Store.create
+        Store.get_store(0).db.should_not == nil
         ENV.delete(REDISTOGO_URL)
       end
 
@@ -87,8 +57,8 @@ describe "Store" do
         update_data = { '1' => {'attr1' => 'value2', 'new_attr' => 'new_val', 'hello' => 'world'},
                         '2' => {'whole_new_object' => 'new_value' } }
         Store.put_data('mydata', data)
-        Store.db.should_receive(:srem).exactly(1).times
-        Store.db.should_receive(:sadd).exactly(2).times
+        Store.get_store(0).db.should_receive(:srem).exactly(1).times
+        Store.get_store(0).db.should_receive(:sadd).exactly(2).times
         Store.update_objects('mydata', update_data)        
       end
       
@@ -98,12 +68,20 @@ describe "Store" do
         Store.delete_objects('mydata', ['1'])
         Store.get_data('mydata').should == {}
       end
+
+      it "should update_count and delete_value with simple integer data" do
+        Store.put_value('mydata', 21)
+        Store.update_count('mydata', -5)
+        Store.get_value('mydata').to_i.should == 16
+        Store.delete_value('mydata')
+        Store.exists?('mydata').should be_false
+      end
       
       it "should delete_objects with simple data and verify that srem is called only on affected fields" do
         data = { '1' => { 'hello' => 'world', "attr1" => 'value1' } }
         Store.put_data('mydata', data)
-        Store.db.should_receive(:srem).exactly(1).times
-        Store.db.should_receive(:sadd).exactly(0).times
+        Store.get_store(0).db.should_receive(:srem).exactly(1).times
+        Store.get_store(0).db.should_receive(:sadd).exactly(0).times
         Store.delete_objects('mydata', ['1'])        
       end
       
@@ -145,8 +123,8 @@ describe "Store" do
         Store.get_data(@s.docname(:md)).should == @data
 
         @product3['price'] = '59.99'
-        elem_3 = Store.send(:set_obj_element, '3', @product3)
-        keypairs_3 = Store.send(:get_obj_key_and_pairs, elem_3)
+        elem_3 = Store.get_store(0).send(:set_obj_element, '3', @product3)
+        keypairs_3 = Store.get_store(0).send(:get_obj_key_and_pairs, elem_3)
         expected = {elem_3 => keypairs_3}
         @data1,@data1['1'],@data1['2'],@data1['3'] = {},@product1,@product2,@product3
 
@@ -161,10 +139,10 @@ describe "Store" do
 
         mod_product2 = @product2.dup
         mod_product2['price'] = '59.99'
-        elem_2 = Store.send(:set_obj_element, '2', @data['2'])
-        elem_3 = Store.send(:set_obj_element, '3', @product3)
-        keypairs_2 = Store.send(:get_obj_key_and_pairs, elem_2)
-        keypairs_3 = Store.send(:get_obj_key_and_pairs, elem_3)
+        elem_2 = Store.get_store(0).send(:set_obj_element, '2', @data['2'])
+        elem_3 = Store.get_store(0).send(:set_obj_element, '3', @product3)
+        keypairs_2 = Store.get_store(0).send(:get_obj_key_and_pairs, elem_2)
+        keypairs_3 = Store.get_store(0).send(:get_obj_key_and_pairs, elem_3)
         expected = {elem_2 => keypairs_2, elem_3 => keypairs_3}
         @data1,@data1['1'],@data1['2'] = {},@product1,mod_product2
 
@@ -188,37 +166,37 @@ describe "Store" do
         Store.get_data(@s.docname(:md)).should == @data
       end
 
-      it "should flash_data" do
+      it "should flush_data" do
         Store.put_data(@s.docname(:md),@data)
-        Store.flash_data(@s.docname(:md))
+        Store.flush_data(@s.docname(:md))
         Store.get_data(@s.docname(:md)).should == {}
       end
       
-      it "should flash_data for all keys matching pattern" do
-        keys = ['test_flash_data1','test_flash_data2']
+      it "should flush_data for all keys matching pattern" do
+        keys = ['test_flush_data1','test_flush_data2']
         keys.each {|key| Store.put_data(key,@data)}
-        Store.flash_data('test_flash_data*')
+        Store.flush_data('test_flush_data*')
         keys.each {|key| Store.get_data(key).should == {} }
       end
 
-      it "should flash_data without calling KEYS when there aren't pattern matching characters in the provided keymask" do
-        key = 'test_flash_data'
+      it "should flush_data without calling KEYS when there aren't pattern matching characters in the provided keymask" do
+        key = 'test_flush_data'
         Store.put_data(key,@data)
-        Store.db.should_not_receive(:keys)
-        Store.db.should_receive(:del).once.with("#{key}:#{get_sha1('1')[0..1]}").and_return(true)
-        Store.db.should_receive(:del).once.with("#{key}:#{get_sha1('2')[0..1]}").and_return(true)
-        Store.db.should_receive(:del).once.with("#{key}:#{get_sha1('3')[0..1]}").and_return(true)
-        Store.db.should_receive(:del).once.with("#{key}:indices").and_return(true)
-        Store.flash_data(key)
+        Store.get_store(0).db.should_not_receive(:keys)
+        Store.get_store(0).db.should_receive(:del).once.with("#{key}:#{get_sha1('1')[0..1]}").and_return(true)
+        Store.get_store(0).db.should_receive(:del).once.with("#{key}:#{get_sha1('2')[0..1]}").and_return(true)
+        Store.get_store(0).db.should_receive(:del).once.with("#{key}:#{get_sha1('3')[0..1]}").and_return(true)
+        Store.get_store(0).db.should_receive(:del).once.with("#{key}:indices").and_return(true)
+        Store.flush_data(key)
       end
 
-      it "should flash_data and call KEYS when there are pattern matching characters in the provided keymask" do
-        keys = ['test_flash_data1','test_flash_data2']
+      it "should flush_data and call KEYS when there are pattern matching characters in the provided keymask" do
+        keys = ['test_flush_data1','test_flush_data2']
         keys.each {|key| Store.put_data(key,@data)}
-        docs = Store.db.keys("test_flash_data*")
-        Store.db.should_receive(:keys).exactly(1).times.with("test_flash_data*").and_return(docs)
-        Store.db.should_receive(:del).exactly(8).times.and_return(true)
-        Store.flash_data("test_flash_data*")
+        docs = Store.keys("test_flush_data*")
+        Store.get_store(0).db.should_receive(:keys).exactly(1).times.with("test_flush_data*").and_return(docs)
+        Store.get_store(0).db.should_receive(:del).exactly(8).times.and_return(true)
+        Store.flush_data("test_flush_data*")
       end
 
       it "should put_zdata and get_zdata" do
@@ -258,121 +236,35 @@ describe "Store" do
         zdocs.should == {}
       end
       
-      it "should put_multi_zdata and get_multi_zdata for transaction's queue" do
-        create_doc = {'1' => {'foo' => 'bar'}}
-        update_doc = {'2' => {'foo1' => 'bar1'}}
-        delete_doc = {'3' => {'foo2' => 'bar2'}}
-        sources_doc = {'source1' => {'create' => create_doc,
-                                      'delete' => delete_doc}}
-        sources_doc['source2'] = {'update' => update_doc}
-        sources = ['source2', 'source1']
-        assoc_key = 'my_assoc_key'
-        Store.put_multi_zdata('transactions',assoc_key,sources,sources_doc)
-        zdata,ordered_sources,keys = Store.get_multi_zdata('transactions')
-        zdata.should == [sources_doc]
-        ordered_sources.should == [sources]
-        keys.should == [assoc_key]
-      end
-      
-      it "should return empty list on non-existing get_multi_zdata" do
-        zdata,ordered_sources,keys = Store.get_multi_zdata('wrong_doc2')
-        zdata.should == []
-        ordered_sources.should == []
-        keys.should == []
-      end
-      
-      it "should append duplicate data in put_multi_zdata" do
-        create_doc = {'1' => {'foo' => 'bar'}}
-        update_doc = {'2' => {'foo1' => 'bar1'}}
-        delete_doc = {'3' => {'foo2' => 'bar2'}}
-        sources_doc = {'source1' => {'create' => create_doc,
-                                      'delete' => delete_doc}}
-        sources_doc['source2'] = {'update' => update_doc}
-        sources1 = ['source2', 'source1']
-        sources2 = ['source1', 'source2']
-        assoc_key = 'my_assoc_key'
-        Store.put_multi_zdata('doc1',assoc_key,sources1,sources_doc)
-        Store.put_multi_zdata('doc1',assoc_key,sources2,sources_doc, true)
-        zdata,ordered_sources,keys = Store.get_multi_zdata('doc1')
-        zdata.should == [sources_doc,sources_doc]
-        ordered_sources.should == [sources1, sources2]
-        keys.should == [assoc_key,assoc_key]
-      end
-      
-      it "should flush_multi_zdata and all its related documents" do
-        create_doc = {'1' => {'foo' => 'bar'}}
-        update_doc = {'2' => {'foo1' => 'bar1'}}
-        delete_doc = {'3' => {'foo2' => 'bar2'}}
-        sources_doc = {'source1' => {'create' => create_doc,
-                                      'delete' => delete_doc}}
-        sources_doc['source2'] = {'update' => update_doc}
-        sources1 = ['source2', 'source1']
-        sources2 = ['source1', 'source2']
-        assoc_key = 'my_assoc_key'
-        Store.put_multi_zdata('doc1',assoc_key,sources1,sources_doc)
-        Store.put_multi_zdata('doc1',assoc_key,sources2,sources_doc,true)
-        zsources1 = Store.get_data('doc1:1:my_assoc_key:sources',Array)
-        zsources1.should == sources1
-        zsources2 = Store.get_data('doc1:2:my_assoc_key:sources',Array)
-        zsources2.should == sources2
-        zdata_create1 = Store.get_data('doc1:1,my_assoc_key:source1:create')
-        zdata_create1.should == create_doc
-        zdata_update1 = Store.get_data('doc1:1,my_assoc_key:source2:update')
-        zdata_update1.should == update_doc
-        zdata_delete1 = Store.get_data('doc1:1,my_assoc_key:source1:delete')
-        zdata_delete1.should == delete_doc
-        zdata_create2 = Store.get_data('doc1:2,my_assoc_key:source1:create')
-        zdata_create2.should == create_doc
-        zdata_update2 = Store.get_data('doc1:2,my_assoc_key:source2:update')
-        zdata_update2.should == update_doc
-        zdata_delete2 = Store.get_data('doc1:2,my_assoc_key:source1:delete')
-        zdata_delete2.should == delete_doc
-        Store.flush_multi_zdata('doc1')
-        zdata,ordered_sources,keys = Store.get_multi_zdata('doc1')
-        zdata.should == []
-        ordered_sources.should == []
-        keys.should == []
-        zsources1 = Store.get_data('doc1:1:my_assoc_key:sources',Array)
-        zsources1.should == []
-        zsources2 = Store.get_data('doc1:2:my_assoc_key:sources',Array)
-        zsources2.should == []
-        zdata_create1 = Store.get_data('doc1:1,my_assoc_key:source1:create')
-        zdata_create1.should == {}
-        zdata_update1 = Store.get_data('doc1:1,my_assoc_key:source2:update')
-        zdata_update1.should == {}
-        zdata_delete1 = Store.get_data('doc1:1,my_assoc_key:source1:delete')
-        zdata_delete1.should == {}
-        zdata_create2 = Store.get_data('doc1:2,my_assoc_key:source1:create')
-        zdata_create2.should == {}
-        zdata_update2 = Store.get_data('doc1:2,my_assoc_key:source2:update')
-        zdata_update2.should == {}
-        zdata_delete2 = Store.get_data('doc1:2,my_assoc_key:source1:delete')
-        zdata_delete2.should == {}
-      end
-
       if defined?(JRUBY_VERSION)
         it "should lock document" do
           doc = "locked_data"
+          threads = []
           m_lock = Store.get_lock(doc)
-          t = Thread.new do
-            Store.db = Redis.new
+          threads << Thread.new do
             t_lock = Store.get_lock(doc)
             Store.put_data(doc,{'1'=>@product1},true)
-            Store.release_lock(doc,t_lock) 
+            Store.release_lock(doc,t_lock)
+          end
+          threads << Thread.new do
+            t_lock = Store.get_lock(doc)
+            Store.put_data(doc,{'3'=>@product3},true)
+            Store.release_lock(doc,t_lock)
           end
           Store.put_data(doc,{'2'=>@product2},true)
           Store.get_data(doc).should == {'2'=>@product2}
           Store.release_lock(doc,m_lock)
-          t.join
+          threads.each { |t| t.join }
           m_lock = Store.get_lock(doc)
-          Store.get_data(doc).should == {'1'=>@product1,'2'=>@product2}
+          Store.get_data(doc).should == {'1'=>@product1,'2'=>@product2,'3'=>@product3}
         end
       else
         it "should lock document" do
           doc = "locked_data"
           m_lock = Store.get_lock(doc)
           pid = Process.fork do
-            Store.db = Redis.new
+            Store.nullify
+            Store.create
             t_lock = Store.get_lock(doc)
             Store.put_data(doc,{'1'=>@product1},true)
             Store.release_lock(doc,t_lock) 
@@ -390,12 +282,13 @@ describe "Store" do
       it "should lock key for timeout" do
         doc = "locked_data"
         lock = Time.now.to_i+3
-        Store.db.set "lock:#{doc}", lock
-        Store.should_receive(:sleep).at_least(:once).with(1).and_return { sleep 1; Store.release_lock(doc,lock); }
+        Store.get_store(0).db.set "lock:#{doc}", lock
+        Store.get_store(0).should_receive(:sleep).at_least(:once).with(1).and_return { sleep 1; Store.release_lock(doc,lock); }
         Store.get_lock(doc,4)
       end
 
       it "should raise exception if lock expires" do
+
         doc = "locked_data"
         Store.get_lock(doc)
         lambda { sleep 2; Store.get_lock(doc,4,true) }.should raise_error(StoreLockException,"Lock \"lock:locked_data\" expired before it was released")
@@ -420,7 +313,7 @@ describe "Store" do
         doc = "locked_data"
         Rhoconnect.lock_duration = 2
        	Store.get_lock(doc)
-       	Store.should_receive(:sleep).at_least(1).times.with(1).and_return { sleep 1 }
+       	Store.get_store(0).should_receive(:sleep).at_least(1).times.with(1).and_return { sleep 1 }
         Store.get_lock(doc)
        	Rhoconnect.lock_duration = nil
       end
@@ -447,8 +340,8 @@ describe "Store" do
 
       it "should not fail to rename if key doesn't exist" do
         Store.rename('key1','key2')
-        Store.db.exists('key1').should be_false
-        Store.db.exists('key2').should be_false      
+        Store.exists?('key1').should be_false
+        Store.exists?('key2').should be_false      
       end
 
       it "should raise ArgumentError on put_data with invalid data" do
@@ -467,12 +360,12 @@ describe "Store" do
         docindex2 = get_sha1(key2)[0..1]
         Store.put_object(:md, key1, data1)
         Store.put_object(:md, key2, data2)
-        Store.db.exists(:md).should be_false
-        Store.db.exists("#{:md}:#{docindex1}").should be_true
-        Store.db.exists("#{:md}:#{docindex2}").should be_true
-        Store.db.exists("#{:md}:indices").should be_true
-        Store.db.hkeys("#{:md}:indices").should == ["#{docindex1}", "#{docindex2}"]
-        Store.db.hvals("#{:md}:indices").should == ["#{:md}:#{docindex1}", "#{:md}:#{docindex2}"]
+        Store.keys(:md).should == []
+        Store.exists?("#{:md}:#{docindex1}").should be_true
+        Store.exists?("#{:md}:#{docindex2}").should be_true
+        Store.exists?("#{:md}:indices").should be_true
+        Store.get_store(0).db.hkeys("#{:md}:indices").should == ["#{docindex1}", "#{docindex2}"]
+        Store.get_store(0).db.hvals("#{:md}:indices").should == ["#{:md}:#{docindex1}", "#{:md}:#{docindex2}"]
       end
       
       it "should get_object from the bucketed md" do
@@ -487,6 +380,93 @@ describe "Store" do
         obj2 = Store.get_object(:md, key2)
         obj2.should == data2
       end
+
+      it "should make temporary document and restore it to permanent with rename" do
+        key1 = '1'
+        data1 = {'foo' => 'bar'}
+        key2 = '2'
+        data2 = {'one' => 'two', 'three' => 'four'}
+        docindex1 = get_sha1(key1)[0..1]
+        docindex2 = get_sha1(key2)[0..1]
+        Store.put_tmp_data(:md, {key1 => data1})
+        Store.put_tmp_data(:md, {key2 => data2}, true)
+        
+        Store.exists?("#{:md}:#{docindex1}").should be_true
+        Store.exists?("#{:md}:#{docindex2}").should be_true
+        Store.exists?("#{:md}:indices").should be_true
+        Store.get_store(0).db.ttl("#{:md}:#{docindex1}").should == Rhoconnect.store_key_ttl
+        Store.get_store(0).db.ttl("#{:md}:#{docindex2}").should == Rhoconnect.store_key_ttl
+        Store.get_store(0).db.ttl("#{:md}:indices").should == Rhoconnect.store_key_ttl
+
+        Store.rename_tmp_data(:md, :md_perm)
+        Store.exists?("#{:md}:#{docindex1}").should be_false
+        Store.exists?("#{:md}:#{docindex2}").should be_false
+        Store.exists?("#{:md}:indices").should be_false
+        Store.exists?("#{:md_perm}:#{docindex1}").should be_true
+        Store.exists?("#{:md_perm}:#{docindex2}").should be_true
+        Store.exists?("#{:md_perm}:indices").should be_true
+        Store.get_store(0).db.ttl("#{:md_perm}:#{docindex1}").should == -1
+        Store.get_store(0).db.ttl("#{:md_perm}:#{docindex2}").should == -1
+        Store.get_store(0).db.ttl("#{:md_perm}:indices").should == -1
+      end
+
+      describe "multiple redis clustering" do
+        before(:all) do   
+          # start 2 redis instances in addition to default 6379
+          system("redis-server --port 6380 &")
+          system("redis-server --port 6381 &")
+          sleep(1)
+          Store.nullify
+          Store.create(['localhost:6379', 'localhost:6380', 'localhost:6381'])
+
+        end
+
+        after(:all) do
+          # shutdown 2 additional redis instances (leave default one as is)
+          Store.get_store(1).send(:db).shutdown
+          Store.get_store(2).send(:db).shutdown
+          Store.nullify
+        end
+
+        it "should list number of stores" do
+          Store.num_stores.should == 3
+        end
+
+        it "data for Source and Client docs should be on the same instance" do
+          source_index = @s.store_index(:md)
+          client_index = @c.store_index(:cd)
+          # for this source and user , index should be computed to 2
+          source_index.should == 2
+          source_index.should == client_index
+        end
+
+        it "data for app-parttion should go to system Redis (with index 0)" do
+          @c.source_name = @s3.name
+          source_index = @s3.store_index(:md)
+          client_index = @c.store_index(:cd)
+          # for this source and user , index should be compured to 0
+          source_index.should == 0
+          source_index.should == client_index
+        end
+
+        it "should set and flush the data only in appropriate instance" do
+          key1 = '1'
+          data1 = {'foo' => 'bar'}
+          key2 = '2'
+          data2 = {'foo1' => 'bar1'}
+          @s.put_data(:md, {key1 => data1})
+          Store.get_store(2).get_data(@s.docname(:md)).should == {key1 => data1}
+          # data in store 1 should not be accessible through Source documents
+          # because this combination of user and source should index to instance #2
+          Store.get_store(1).put_data(@s.docname(:md), {key2 => data2})
+          Store.get_store(1).get_data(@s.docname(:md)).should == {key2 => data2}
+          
+          @s.get_data(:md).should == {key1 => data1}
+          Store.get_store(2).flush_data(@s.docname(:md))
+          @s.get_data(:md).should == {}
+          Store.get_store(1).get_data(@s.docname(:md)).should == {key2 => data2}
+        end
+      end
     end
   end  
 end

data/spec/support/shared_examples.rb

@@ -1,36 +1,36 @@
-# When shared examples are called as  
+# When shared examples are called as
 #   it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false
 # then :rhoconnect_data group (@product1, ..., @data) skipped.
 # To enable this group call examples as
 #   it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true
 shared_examples_for "SharedRhoconnectHelper" do |params|
-  include TestHelpers      
+  include TestHelpers
   # "TestappHelper"
-  let(:test_app_name) { 'application' }  
-  # "RhoconnectHelper"
-  before(:all) do
+  let(:test_app_name) { 'application' }
+
+  before(:each) do
+    # "RhoconnectHelper"
+    Store.create
+    Store.flush_all
+    Rhoconnect.use_node = false
+    Rhoconnect::Server.set :environment, :test
+
     Rhoconnect.bootstrap(get_testapp_path) do |rhoconnect|
       rhoconnect.vendor_directory = File.join(File.dirname(__FILE__), '..', '..', 'vendor')
     end
-  end
-  
-  before(:each) do
-    # "RhoconnectHelper" 
-    Store.create
-    Store.db.flushdb
-        
+
     # "DBObjectsHelper"
     @a_fields = { :name => test_app_name }
     @a = (App.load(test_app_name) || App.create(@a_fields))
     @u_fields = {:login => 'testuser'}
-    @u = User.create(@u_fields) 
+    @u = User.create(@u_fields)
     @u.password = 'testpass'
     @c_fields = {
       :device_type => 'Apple',
       :device_pin => 'abcd',
       :device_port => '3333',
       :user_id => @u.id,
-      :app_id => @a.id 
+      :app_id => @a.id
     }
     @s_fields = {
       :name => 'SampleAdapter',
@@ -55,7 +55,7 @@ shared_examples_for "SharedRhoconnectHelper" do |params|
     @s1 = Source.create(@s1_fields,@s_params)
     @s2 = Source.create({:name=> 'Product2'},@s_params)
     @s3 = Source.create({:name=> 'SimpleAdapter',:partition_type=> 'app'},@s_params)
-    @s1.belongs_to = [{'brand' => 'SampleAdapter'}].to_json    
+    @s1.belongs_to = [{'brand' => 'SampleAdapter'}].to_json
     config = Rhoconnect.source_config('FixedSchemaAdapter')
     @s1.update(config)
     @r = @s.read_state
@@ -64,9 +64,9 @@ shared_examples_for "SharedRhoconnectHelper" do |params|
     @a.sources << @s3.id
     Source.update_associations(@a.sources)
     @a.users << @u.id
-      
-    # "RhoconnectDataHelper"  
-    if params && params[:rhoconnect_data] 
+
+    # "RhoconnectDataHelper"
+    if params && params[:rhoconnect_data]
       @source = 'Product'
       @user_id = 5
       @client_id = 1
@@ -84,7 +84,7 @@ end
 shared_examples_for "BenchSpecHelper" do
   before(:each) do
     Store.create
-    Store.db.flushdb
+    Store.flush_all
 
     @product1 = { 'name' => 'iPhone', 'brand' => 'Apple', 'price' => '199.99' }
     @product2 = { 'name' => 'G2', 'brand' => 'Android', 'price' => '99.99' }
@@ -98,15 +98,23 @@ end
 shared_examples_for "ApiHelper" do
   include Rack::Test::Methods
   include Rhoconnect
-  include TestHelpers    
+  include TestHelpers
 
   let(:test_app_name) { 'application' }
-  
+
+  def app
+    Rhoconnect::Server.set :stats, false
+    Rhoconnect.stats = false
+    @app ||= Rack::URLMap.new Rhoconnect.url_map
+  end
+
   before(:each) do
+    Rhoconnect.connection_pool_timeout = 30
+    Rhoconnect.connection_pool_size = 5
     Store.create
-    Store.db.flushdb
+    Store.flush_all
 
-    require File.join(get_testapp_path, test_app_name)
+    Rhoconnect.use_node = false
     Rhoconnect.bootstrap(get_testapp_path) do |rhoconnect|
       rhoconnect.vendor_directory = File.join(rhoconnect.base_directory,'..','..','..','vendor')
     end
@@ -118,14 +126,14 @@ shared_examples_for "ApiHelper" do
     @a_fields = { :name => test_app_name }
     @a = (App.load(test_app_name) || App.create(@a_fields))
     @u_fields = {:login => 'testuser'}
-    @u = User.create(@u_fields) 
+    @u = User.create(@u_fields)
     @u.password = 'testpass'
     @c_fields = {
       :device_type => 'Apple',
       :device_pin => 'abcd',
       :device_port => '3333',
       :user_id => @u.id,
-      :app_id => @a.id 
+      :app_id => @a.id
     }
     @s_fields = {
       :name => 'SampleAdapter',
@@ -149,7 +157,7 @@ shared_examples_for "ApiHelper" do
     @s = Source.create(@s_fields,@s_params)
     @s1 = Source.create(@s1_fields,@s_params)
     @s2 = Source.create({:name=> 'Product2'},@s_params)
-    @s1.belongs_to = [{'brand' => 'SampleAdapter'}].to_json    
+    @s1.belongs_to = [{'brand' => 'SampleAdapter'}].to_json
     config = Rhoconnect.source_config('FixedSchemaAdapter')
     @s1.update(config)
     @r = @s.read_state
@@ -169,4 +177,5 @@ shared_examples_for "ApiHelper" do
 
     @data = {'1'=>@product1,'2'=>@product2,'3'=>@product3}
   end
-end
+end
+