deploy_couch 0.0.1

data/spec/integration/delta_processor_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/database_populator'
+
+module DeployCouch
+  
+  describe DeltaProcessor, "integration" do  
+  
+    before :all do
+      DatabasePopulator.new("test").with_type("customer").with_records(30).build
+    end
+  
+      
+    it "integration load relavent documents and apply delta" do
+      config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+      repository = Repository.new(config)
+      map_function = "function map(doc){ doc.address = 'new address'; return 'update';}"
+      rollback_function = "function map(doc){ delete doc.address; return 'update';}"
+      delta = Delta.new(1,'file_name',"customer",map_function,rollback_function)
+      delta_processor = DeltaProcessor.new(1,config,delta,repository)
+      delta_processor.apply
+    
+      repository.get_documents("{\"map\":\"function (doc){if(doc.type=='customer'){emit(null,doc);}}\"}") do |row|
+        row['value']["address"].should == 'new address'
+      end
+    end
+    
+    it "integration load relavent documents apply delta and rollback" do
+      config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+      repository = Repository.new(config)
+      map_function = "function map(doc){ doc.address = 'new address'; return 'update';}"
+      rollback_function = "function map(doc){ delete doc.address; return 'update';}"
+      delta = Delta.new(1,'file_name',"customer",map_function,rollback_function)
+      delta_processor = DeltaProcessor.new(1,config,delta,repository)
+      delta_processor.apply
+    
+      repository.get_documents("{\"map\":\"function (doc){if(doc.type=='customer'){emit(null,doc);}}\"}") do |row|
+        row['value']["address"].should == 'new address'
+      end
+      
+      delta_processor.rollback
+      
+      repository.get_documents("{\"map\":\"function (doc){if(doc.type=='customer'){emit(null,doc);}}\"}") do |row|
+        row['value'].has_key?("address").should == false
+      end
+      
+      
+    end
+    
+  
+  end
+  
+end

data/spec/integration/deltas/11_update_phone_with_std_codes.yml

@@ -0,0 +1,13 @@
+type: customer
+map_function:
+    function map(doc)
+    {
+        doc.phone = '+91' + doc.phone;
+        return 'update';
+    }
+rollback_function:
+    function map(doc)
+    {
+        doc.phone = doc.phone.substring(3);
+        return 'update';
+    }

data/spec/integration/deltas/12_delete_customer_name_1.yml

@@ -0,0 +1,19 @@
+type: customer
+map_function:
+    function map(doc)
+    {
+        if(doc.name == 'name_1')
+            return 'delete';
+        return null;
+    }
+rollback_function:
+    function map(doc)
+    {
+        if(doc.name == 'name_2')
+        {
+            delete doc._id;
+            doc.name = 'name_1';
+            return 'create';
+        }
+        return null;
+    }

data/spec/integration/deltas/13_copy_and_create_new_customer.yml

@@ -0,0 +1,20 @@
+type: customer
+map_function:
+    function map(doc)
+    {
+        if(doc.name == 'name_2')
+        {
+            delete doc._id;
+            doc.name = 'new name';
+            return 'create';
+        }
+        return null;
+    }
+rollback_function:
+    function map(doc)
+    {
+        if(doc.name == 'new name')
+            return 'delete';
+        return null;
+    }
+    

data/spec/integration/deltas/1_add_address_to_customer.yml

@@ -0,0 +1,14 @@
+type: customer
+map_function:
+    function map(doc)
+    {
+        doc.address = "some address";
+        return 'update';
+    }
+rollback_function:
+    function map(doc)
+    {
+        delete doc.address;
+        return 'update';
+    }
+    

data/spec/integration/deltas/2_add_phone_to_customer.yml

@@ -0,0 +1,13 @@
+type: customer
+map_function:
+    function map(doc)
+    {
+        doc.phone = '897907979';
+        return 'update';
+    }
+rollback_function:
+    function map(doc)
+    {
+        delete doc.phone;
+        return 'update';
+    }

data/spec/integration/deploy_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/database_populator'
+
+module DeployCouch
+
+  describe Deploy, "load and execute deltas" do
+    before :all do
+      config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+      default_schema = {"_id"=>"schema__schema_document_key__",config.doc_type_field=>"__schema__", 'applied_deltas'=>[1,11], "type_versions"=>{'customer'=>3}}
+      DatabasePopulator.new("test").with_type("customer").with_schema(default_schema).with_records(30).build
+    end
+  
+  
+    it "load and execute deltas" do    
+      config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+      deploy = Deploy.new(config)
+      deltas = deploy.run
+      deltas.count.should == 2
+      deltas[0].file_name.should == "12_delete_customer_name_1.yml"
+      
+    end
+  end
+  
+  describe Deploy, "load and execute deltas first database" do
+  
+    before :all do
+      DatabasePopulator.new("test").with_type("customer").with_records(30).build
+    end
+  
+    it "load and execute deltas" do    
+      config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+      deploy = Deploy.new(config)
+      deltas = deploy.run
+      deltas.count.should == 5
+      deltas[0].file_name.should == "1_add_address_to_customer.yml"    
+    end
+  end
+
+  describe Deploy, "execute deltas and rollback all deltas" do
+  
+    before :all do
+      DatabasePopulator.new("test").with_type("customer").with_records(30).build
+    end
+  
+    it "load and execute deltas" do    
+      config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+      deploy = Deploy.new(config)
+      deploy.run      
+      deltas = deploy.rollback
+      deltas.count.should == 5
+      deltas[0].file_name.should == "13_copy_and_create_new_customer.yml"    
+    end
+  end
+
+
+end

data/spec/integration/repository_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/database_populator'
+
+module DeployCouch
+  describe Repository, "execute a delta" do
+  
+    before :all do
+      DatabasePopulator.new("db").with_type("customer").with_records(2).build
+    end
+  
+  
+    it "hit couchdb and load relavent documents to apply delta" do
+        map_function = '{"map":"function(doc) {emit(doc._id,doc);}"}'
+        config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+        config.merge_config({"database"=>"db"})
+        repository = Repository.new(config)
+        rows = []
+        repository.get_documents(map_function) do |row|
+          rows.push(row)
+        end
+        rows.count.should == 2
+      end
+    
+       it "create schema document if it does not exist and get schema to verify" do
+         config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+         config.merge_config({"database"=>"db"})
+         schema =  {"_id"=>"schema__schema_document_key__","type"=>"__schema__", 'applied_deltas'=>[], "type_versions"=>{}}
+         repository = Repository.new(config)
+         rows = []
+         repository.create_schema(schema)
+         schema_doc = repository.get_schema
+         schema_doc['_id'].should == schema['_id']
+         schema_doc['type'].should == schema['type']
+         schema_doc['applied_deltas'].should == schema['applied_deltas']
+         schema_doc['type_versions'].should == schema['type_versions']
+        end
+
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rspec'
+require File.dirname(__FILE__) + '/../lib/deploy_couch'
+
+
+  def get_couchdb_config
+    DeployCouch::Config.new({"hostname"=>"localhost","port"=>1234,"database"=>"db",'delta_path'=>"path/to/deltas","config_folder_path" => "/somefolder","doc_type_field"=>"type","type_version_field" => 'type_version' })
+  end
+  
+  def create_json_response(total_rows,num_of_records,offset=0)
+    h = {"total_rows"=> total_rows,"offset" => offset, "rows" => []}
+    (1..num_of_records).each do |x|
+      h["rows"].push({"id"=>x})
+    end
+    JSON.generate(h)
+  end
+

data/spec/unit/db_schema_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DeployCouch
+  
+  describe DbSchema, "Manage Schema" do
+
+    it "load schema document" do
+      repository = mock(Repository)
+      repository.should_receive(:get_schema).and_return({"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[1,2], "type_versions"=>{"customer"=>10}})
+      schema = DbSchema.load_or_create(get_couchdb_config,repository)
+      schema.applied_deltas.should == [1,2]
+      schema.type_versions.should == {"customer"=> 10}
+    end
+  
+    it "create if schema document does not exist" do
+      repository = mock(Repository)
+      repository.should_receive(:get_schema).ordered
+      repository.should_receive(:create_schema).ordered
+      repository.should_receive(:get_schema).ordered.and_return({"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[], "type_versions"=>{}})
+      schema = DbSchema.load_or_create(get_couchdb_config,repository)
+      schema.applied_deltas.should == []
+      schema.type_versions.should == {}
+    end
+
+    it "on completion update schema document" do
+      schema_doc = {"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[], "type_versions"=>{}}
+      updated_schema_doc = {"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[1], "type_versions"=>{'type'=>1}}
+      repository = mock(Repository)
+      repository.should_receive(:put_document).ordered.with(updated_schema_doc)    
+      repository.should_receive(:get_schema).ordered.and_return(updated_schema_doc)    
+      schema = DbSchema.new(schema_doc,repository)
+      schema.completed(Delta.new(1,'file_name','type','map_function','rollback_function'))
+      schema.applied_deltas.should == [1]
+      schema.type_versions.should == {'type'=>1}
+    end
+
+    it "on rollback update schema document" do
+      schema_doc = {"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[1], "type_versions"=>{'type'=>1}}
+      updated_schema_doc = {"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[], "type_versions"=>{'type'=>0}}
+      repository = mock(Repository)
+      repository.should_receive(:put_document).ordered.with(updated_schema_doc)
+      repository.should_receive(:get_schema).ordered.and_return(updated_schema_doc)    
+      schema = DbSchema.new(schema_doc,repository)
+      schema.rollback(Delta.new(1,'file_name','type','map_function','rollback_function'))
+      schema.applied_deltas.should == []
+      schema.type_versions.should == {'type'=>0}
+    end
+
+
+
+    it "should get next type version for a given type" do
+      schema_doc = {"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[], "type_versions"=>{'customer'=> 20}}
+      repository = mock(Repository)    
+      schema = DbSchema.new(schema_doc,repository)
+      schema.get_next_type_version_for('customer').should == 21
+    end
+
+    it "should get next type version for a given type for non-existing schema" do
+      schema_doc = {"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[], "type_versions"=>{}}
+      repository = mock(Repository)
+      schema = DbSchema.new(schema_doc,repository)
+      schema.get_next_type_version_for('customer').should == 1
+    end
+  
+  end
+end

data/spec/unit/delta_processor_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DeployCouch
+  
+  describe DeltaProcessor, "execute a delta" do
+    it "load relavent documents and apply delta" do
+      mock_repository = mock(Repository)
+      map_function = <<-JSON
+        {
+         "map":"function(doc){if(doc.type=='customer' && (!doc.type_version  || doc.type_version < 1)){new_doc = eval(uneval(doc)); var method = map(new_doc); if(method) emit(method,new_doc);}}
+        function map(doc){ doc.address = 'new address';}"
+        }
+      JSON
+      h={'key'=> 'update' , 'value'=>{'id'=>"1",'name'=>"name_1", 'address'=>'new address'}}
+      mock_repository.should_receive(:get_documents_to_modify).with(map_function).and_yield(h)
+      mock_repository.should_receive(:put_document).with(h['value'].merge({'type_version' => 1}))
+      delta = Delta.new(1,'file_name',"customer","function map(doc){ doc.address = 'new address';}",'rollback_function')
+      next_type_version = 1
+      delta_processor = DeltaProcessor.new(next_type_version,get_couchdb_config,delta,mock_repository)
+      delta_processor.apply
+    end
+
+    it "load relavent documents and apply delta" do
+      mock_repository = mock(Repository)
+      map_function = <<-JSON
+        {
+         "map":"function(doc){if(doc.type=='customer' && (!doc.type_version  || doc.type_version < 11)){new_doc = eval(uneval(doc)); var method = map(new_doc); if(method) emit(method,new_doc);}}
+        function map(doc){ doc.address = 'new address';}"
+        }
+      JSON
+      h={'key'=> 'delete' , 'value'=>{'id'=>"1",'name'=>"name_1", 'address'=>'new address'}}
+      mock_repository.should_receive(:get_documents_to_modify).with(map_function).and_yield(h)
+      mock_repository.should_receive(:delete_document).with(h['value'])
+      delta = Delta.new(1,'file_name',"customer","function map(doc){ doc.address = 'new address';}",'rollback_function')
+      next_type_version = 11
+      delta_processor = DeltaProcessor.new(next_type_version,get_couchdb_config,delta,mock_repository)
+      delta_processor.apply
+    end
+
+    it "load relavent documents and rollback delta" do
+      mock_repository = mock(Repository)
+      map_function = <<-JSON
+        {
+         "map":"function(doc){if(doc.type=='customer' && (doc.type_version >= 10)){new_doc = eval(uneval(doc)); var method = map(new_doc); if(method) emit(method,new_doc);}}
+        function map(doc){ delete doc.address; return 'update';}"
+        }
+      JSON
+      h={'key'=> 'update' , 'value'=>{'id'=>"1",'name'=>"name_1", 'address'=>'new address'}}
+      mock_repository.should_receive(:get_documents_to_modify).with(map_function).and_yield(h)
+      mock_repository.should_receive(:put_document).with(h['value'].merge({'type_version' => 9}))
+      delta = Delta.new(1,'file_name',"customer","function map(doc){ doc.address = 'new address';}","function map(doc){ delete doc.address; return 'update';}")
+      next_type_version = 11
+      delta_processor = DeltaProcessor.new(next_type_version,get_couchdb_config,delta,mock_repository)
+      delta_processor.rollback
+    end
+
+
+
+  end
+
+end

data/spec/unit/deploy_spec.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DeployCouch
+  describe Deploy, "load and execute deltas" do
+    it "load and execute deltas in correct order" do
+      config = get_couchdb_config
+      delta = Delta.new(1,'file_name','type','map function','rollback_function')
+      delta2 = Delta.new(10,'file_name2','type','map function','rollback_function')
+      deltas_map = {1=>delta,10=>delta2}
+    
+      mock_delta_loader = mock(DeltaLoader)
+      DeltaLoader.should_receive(:new).with("/somefolder/path/to/deltas").and_return(mock_delta_loader)
+      mock_delta_loader.should_receive(:get_deltas).and_return(deltas_map)
+    
+      mock_repository = mock(Repository)
+      Repository.should_receive(:new).with(config).and_return(mock_repository)
+    
+      mock_delta_processor = mock(DeltaProcessor)
+      DeltaProcessor.should_receive(:new).with(1,config,delta,mock_repository).ordered.and_return(mock_delta_processor)    
+      mock_delta_processor.should_receive(:apply)
+    
+      mock_delta_processor2 = mock(DeltaProcessor)
+      DeltaProcessor.should_receive(:new).with(2,config,delta2,mock_repository).ordered.and_return(mock_delta_processor2)    
+      mock_delta_processor2.should_receive(:apply)
+    
+      mock_couch_db_schema = mock(DbSchema)
+      mock_couch_db_schema.should_receive(:applied_deltas).and_return([])
+      DbSchema.should_receive(:load_or_create).with(config,mock_repository).ordered.and_return(mock_couch_db_schema) 
+      mock_couch_db_schema.should_receive(:get_next_type_version_for).with('type').ordered.and_return(1)   
+      mock_couch_db_schema.should_receive(:completed).ordered.with(delta)
+      mock_couch_db_schema.should_receive(:get_next_type_version_for).with('type').ordered.and_return(2)
+      mock_couch_db_schema.should_receive(:completed).ordered.with(delta2)
+    
+      deploy = Deploy.new(config)
+      deploy.run
+    end
+      
+    it "executes unapplied deltas only in correct order" do
+      config = get_couchdb_config
+      delta = Delta.new(1,'file_name','type','map function','rollback_function')
+      delta2 = Delta.new(10,'file_name2','type','map function','rollback_function')
+      deltas_map = {1=>delta,10=>delta2}
+    
+      mock_delta_loader = mock(DeltaLoader)
+      DeltaLoader.should_receive(:new).with("/somefolder/path/to/deltas").and_return(mock_delta_loader)
+      mock_delta_loader.should_receive(:get_deltas).and_return(deltas_map)
+    
+      mock_repository = mock(Repository)
+      Repository.should_receive(:new).with(config).and_return(mock_repository)
+    
+      mock_delta_processor = mock(DeltaProcessor)
+      DeltaProcessor.should_receive(:new).with(1,config,delta2,mock_repository).and_return(mock_delta_processor)    
+      mock_delta_processor.should_receive(:apply)
+    
+      mock_couch_db_schema = mock(DbSchema)
+      mock_couch_db_schema.should_receive(:applied_deltas).and_return([1])
+      DbSchema.should_receive(:load_or_create).with(config,mock_repository).ordered.and_return(mock_couch_db_schema)    
+      mock_couch_db_schema.should_receive(:get_next_type_version_for).with('type').ordered.and_return(1)   
+      mock_couch_db_schema.should_receive(:completed).with(delta2)
+    
+      deploy = Deploy.new(config)
+      deploy.run
+    end
+    
+    it "executes rollback deltas" do
+      config = get_couchdb_config
+      delta = Delta.new(1,'file_name','type','map function','rollback_function')
+      delta2 = Delta.new(10,'file_name2','type','map function','rollback_function')
+      deltas_map = {1=>delta,10=>delta2}
+    
+      mock_delta_loader = mock(DeltaLoader)
+      DeltaLoader.should_receive(:new).with("/somefolder/path/to/deltas").and_return(mock_delta_loader)
+      mock_delta_loader.should_receive(:get_deltas).and_return(deltas_map)
+
+      mock_repository = mock(Repository)
+      Repository.should_receive(:new).with(config).and_return(mock_repository)
+
+      mock_delta_processor = mock(DeltaProcessor)
+      DeltaProcessor.should_receive(:new).with(2,config,delta,mock_repository).and_return(mock_delta_processor)    
+      mock_delta_processor.should_receive(:rollback)
+
+      mock_couch_db_schema = mock(DbSchema)
+      mock_couch_db_schema.should_receive(:applied_deltas).and_return([1])
+      DbSchema.should_receive(:load_or_create).with(config,mock_repository).ordered.and_return(mock_couch_db_schema)    
+      mock_couch_db_schema.should_receive(:get_next_type_version_for).with('type').ordered.and_return(2)   
+      mock_couch_db_schema.should_receive(:rollback).with(delta)
+    
+      deploy = Deploy.new(config)
+      deploy.rollback
+    end
+    
+    
+  end
+end

data/spec/unit/repository_spec.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DeployCouch
+  
+  describe Repository, "execute a delta" do
+    it "load relavent documents" do
+       map_function = "{'map':'function(doc){emit(null,doc);}'}"
+       mock_server = mock(Server)
+       Server.should_receive(:new).with("localhost",1234).and_return(mock_server)
+       mock_response = mock(Net::HTTPResponse)
+       mock_server.should_receive(:post).with("/db/_temp_view?limit=10&skip=0",map_function).and_return(mock_response)
+       json = create_json_response(1,1)
+       mock_response.should_receive(:body).and_return(json)
+     
+       repository = Repository.new(get_couchdb_config)
+       rows = []
+       repository.get_documents(map_function) do |row|
+         rows.push(row)
+       end
+       rows.count.should == 1
+     end
+   
+     it "load relavent documents" do
+        map_function = "{'map':'function(doc){emit(null,doc);}'}"
+        mock_server = mock(Server)
+        Server.should_receive(:new).with("localhost",1234).and_return(mock_server)
+        mock_response = mock(Net::HTTPResponse)
+        mock_server.should_receive(:post).with("/db/_temp_view?limit=10&skip=0",map_function).and_return(mock_response)
+        json = create_json_response(15,10)
+        mock_response.should_receive(:body).and_return(json)
+
+        mock_response = mock(Net::HTTPResponse)
+        mock_server.should_receive(:post).with("/db/_temp_view?limit=10&skip=10",map_function).and_return(mock_response)
+        json = create_json_response(15,5,10)
+        mock_response.should_receive(:body).and_return(json)
+
+      
+        repository = Repository.new(get_couchdb_config)
+        rows = []
+        repository.get_documents(map_function) do |row|
+          rows.push(row)
+        end
+        rows.count.should == 15
+      end
+
+      it "put document to update document" do
+         json = {"_id"=> 1757, "name" => "name_1"}
+         mock_server = mock(Server)
+         Server.should_receive(:new).with("localhost",1234).and_return(mock_server)
+         mock_response = mock(Net::HTTPResponse)
+         mock_server.should_receive(:put).with("/db/#{json['_id']}",json.to_json).and_return(mock_response)
+
+         repository = Repository.new(get_couchdb_config)
+         rows = []
+         repository.put_document(json)
+       end
+
+       it "delete document" do
+          json = {"_id"=> 1757, "name" => "name_1","_rev"=> 10}
+          mock_server = mock(Server)
+          Server.should_receive(:new).with("localhost",1234).and_return(mock_server)
+          mock_response = mock(Net::HTTPResponse)
+          mock_server.should_receive(:delete).with("/db/#{json['_id']}?rev=10").and_return(mock_response)
+
+          repository = Repository.new(get_couchdb_config)
+          rows = []
+          repository.delete_document(json)
+        end
+
+        it "get schema document" do
+           json = {"_id"=> 1757, "name" => "name_1","_rev"=> 10}
+           mock_server = mock(Server)
+           Server.should_receive(:new).with("localhost",1234).and_return(mock_server)
+           mock_response = mock(Net::HTTPResponse)
+           schema =  {"_id"=>"special_key","type"=>"__schema__", 'applied_deltas'=>[1,2], "type_versions"=>{"customer"=>10}}
+           mock_response.should_receive(:body).and_return(schema.to_json)
+           mock_response.should_receive(:kind_of?).with(Net::HTTPSuccess).and_return(true)
+           mock_server.should_receive(:get).with("/db/schema__schema_document_key__", {:suppress_exceptions=>true}).and_return(mock_response)
+
+           repository = Repository.new(get_couchdb_config)
+           rows = []
+           repository.get_schema.should == schema
+         
+         end
+
+         it "load relavent documents to apply delta with paging" do
+            map_function = "{'map':'function(doc){emit(null,doc);}'}"
+            mock_server = mock(Server)
+            Server.should_receive(:new).with("localhost",1234).and_return(mock_server)
+            mock_response = mock(Net::HTTPResponse)
+            mock_server.should_receive(:post).with("/db/_temp_view?limit=10",map_function).and_return(mock_response)
+            json = create_json_response(15,10)
+            mock_response.should_receive(:body).and_return(json)
+
+            mock_response = mock(Net::HTTPResponse)
+            mock_server.should_receive(:post).with("/db/_temp_view?limit=10",map_function).and_return(mock_response)
+            json = create_json_response(5,5,0)
+            mock_response.should_receive(:body).and_return(json)
+
+
+            repository = Repository.new(get_couchdb_config)
+            rows = []
+            repository.get_documents_to_modify(map_function) do |row|
+              rows.push(row)
+            end
+            rows.count.should == 15
+          end
+
+          it "load relavent documents to apply delta with paging for page size rows" do
+             map_function = "{'map':'function(doc){emit(null,doc);}'}"
+             mock_server = mock(Server)
+             Server.should_receive(:new).with("localhost",1234).and_return(mock_server)
+             mock_response = mock(Net::HTTPResponse)
+             mock_server.should_receive(:post).with("/db/_temp_view?limit=10",map_function).and_return(mock_response)
+             json = create_json_response(10,10)
+             mock_response.should_receive(:body).and_return(json)
+
+             repository = Repository.new(get_couchdb_config)
+             rows = []
+             repository.get_documents_to_modify(map_function) do |row|
+               rows.push(row)
+             end
+             rows.count.should == 10
+           end
+
+  end
+  
+end