# coding: utf-8

require 'rspec'
require 'json'
require 'arangodb.rb'

describe ArangoDB do
  api = "/_api/replication"
  prefix = "api-replication"

  context "dealing with the replication interface:" do

################################################################################
## general
################################################################################

    context "dealing with general functions" do
      
      it "fetches the server id" do
        # fetch id
        cmd = api + "/server-id"
        doc = ArangoDB.log_get("#{prefix}-server-id", cmd)

        doc.code.should eq(200)
        doc.parsed_response['serverId'].should match(/^\d+$/)
      end

    end

################################################################################
## logger
################################################################################

    context "dealing with the logger" do

################################################################################
## state
################################################################################

      it "checks the state" do
        # fetch state
        cmd = api + "/logger-state"
        doc = ArangoDB.log_get("#{prefix}-logger-state", cmd, :body => "")

        doc.code.should eq(200)

        all = doc.parsed_response
        all.should have_key('state')
        all.should have_key('server')
        all.should have_key('clients')

        state = all['state']
        state['running'].should eq(true)
        state['lastLogTick'].should match(/^\d+$/)
        state['time'].should match(/^\d+-\d+-\d+T\d+:\d+:\d+Z$/)

        server = all['server']
        server['serverId'].should match(/^\d+$/)
        server.should have_key('version')
      end

################################################################################
## firstTick
################################################################################

      it "fetches the first available tick" do
        # fetch state
        cmd = api + "/logger-first-tick"
        doc = ArangoDB.log_get("#{prefix}-logger-first-tick", cmd, :body => "")

        doc.code.should eq(200)

        result = doc.parsed_response
        result.should have_key('firstTick')

        result['firstTick'].should match(/^\d+$/)
      end

################################################################################
## tickRanges
################################################################################

      it "fetches the available tick ranges" do
        # fetch state
        cmd = api + "/logger-tick-ranges"
        doc = ArangoDB.log_get("#{prefix}-logger-tick-ranges", cmd, :body => "")

        doc.code.should eq(200)

        result = doc.parsed_response
        result.size.should be > 0 
        
        result.each { |datafile|
          datafile.should have_key('datafile')
          datafile.should have_key('status')
          datafile.should have_key('tickMin')
          datafile.should have_key('tickMax')
          datafile['tickMin'].should match(/^\d+$/)
          datafile['tickMax'].should match(/^\d+$/)
        }
      end

################################################################################
## follow
################################################################################
      
      it "fetches the empty follow log" do
        while 1
          cmd = api + "/logger-state"
          doc = ArangoDB.log_get("#{prefix}-follow-empty", cmd, :body => "")
          doc.code.should eq(200)
          doc.parsed_response["state"]["running"].should eq(true)
          fromTick = doc.parsed_response["state"]["lastLogTick"]

          cmd = api + "/logger-follow?from=" + fromTick
          doc = ArangoDB.log_get("#{prefix}-follow-empty", cmd, :body => "", :format => :plain)

          if doc.code != 204
            # someone else did something else
            doc.code.should eq(200)
            # sleep for a second and try again
            sleep 1
          else
            doc.code.should eq(204)

            doc.headers["x-arango-replication-checkmore"].should eq("false")
            doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
            doc.headers["x-arango-replication-lastincluded"].should eq("0")
            doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")
         
            body = doc.response.body
            body.should eq(nil)
            break
          end
        end
      end
      
      it "fetches a create collection action from the follow log" do
        ArangoDB.drop_collection("UnitTestsReplication")
        
        sleep 1

        cmd = api + "/logger-state"
        doc = ArangoDB.log_get("#{prefix}-follow-create-collection", cmd, :body => "")
        doc.code.should eq(200)
        doc.parsed_response["state"]["running"].should eq(true)
        fromTick = doc.parsed_response["state"]["lastLogTick"]

        cid = ArangoDB.create_collection("UnitTestsReplication")

        sleep 1
        cmd = api + "/logger-follow?from=" + fromTick
        doc = ArangoDB.log_get("#{prefix}-follow-create-collection", cmd, :body => "", :format => :plain)
        doc.code.should eq(200)

        doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
        doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")
         
        body = doc.response.body
        
        while 1
          position = body.index("\n")

          break if position == nil

          part = body.slice(0, position)
          document = JSON.parse(part)
          
          if document["type"] == 2000 and document["cid"] == cid
            document.should have_key("tick") 
            document.should have_key("type") 
            document.should have_key("cid") 
            document.should have_key("collection") 

            document["tick"].should match(/^\d+$/)
            document["tick"].to_i.should >= fromTick.to_i
            document["type"].should eq(2000) 
            document["cid"].should eq(cid) 

            c = document["collection"]
            c.should have_key("version")
            c["type"].should eq(2)
            c["cid"].should eq(cid)
            c["deleted"].should eq(false)
            c["doCompact"].should eq(true)
            c.should have_key("maximalSize")
            c["maximalSize"].should be_kind_of(Integer)
            c["name"].should eq("UnitTestsReplication")
            c["isVolatile"].should eq(false)
            c["waitForSync"].should eq(true)
          end

          body = body.slice(position + 1, body.length)
        end
         
      end

      it "fetches some collection operations from the follow log" do
        ArangoDB.drop_collection("UnitTestsReplication")
        
        sleep 1

        cmd = api + "/logger-state"
        doc = ArangoDB.log_get("#{prefix}-follow-collection", cmd, :body => "")
        doc.code.should eq(200)
        doc.parsed_response["state"]["running"].should eq(true)
        fromTick = doc.parsed_response["state"]["lastLogTick"]

        # create collection 
        cid = ArangoDB.create_collection("UnitTestsReplication")

        # create document 
        cmd = "/_api/document?collection=UnitTestsReplication"
        body = "{ \"_key\" : \"test\", \"test\" : false }"
        doc = ArangoDB.log_post("#{prefix}-follow-collection", cmd, :body => body) 
        doc.code.should eq(201)
        
        # delete document 
        cmd = "/_api/document/UnitTestsReplication/test"
        doc = ArangoDB.log_delete("#{prefix}-follow-collection", cmd) 
        doc.code.should eq(200)

        # drop collection
        cmd = "/_api/collection/UnitTestsReplication"
        doc = ArangoDB.log_delete("#{prefix}-follow-collection", cmd) 
        doc.code.should eq(200)
        
        sleep 1

        cmd = api + "/logger-follow?from=" + fromTick
        doc = ArangoDB.log_get("#{prefix}-follow-create-collection", cmd, :body => "", :format => :plain)
        doc.code.should eq(200)

        doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
        doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")
        
        
        body = doc.response.body
        i = 0
        while 1
          position = body.index("\n")

          break if position == nil

          part = body.slice(0, position)
          document = JSON.parse(part)
          
          if i == 0
            if document["type"] == 2000 and document["cid"] == cid
              # create collection
              document.should have_key("tick") 
              document.should have_key("type") 
              document.should have_key("cid") 
              document.should have_key("collection") 

              document["tick"].should match(/^\d+$/)
              document["tick"].to_i.should >= fromTick.to_i
              document["type"].should eq(2000) 
              document["cid"].should eq(cid) 

              c = document["collection"]
              c.should have_key("version")
              c["type"].should eq(2)
              c["cid"].should eq(cid)
              c["deleted"].should eq(false)
              c["doCompact"].should eq(true)
              c.should have_key("maximalSize")
              c["maximalSize"].should be_kind_of(Integer)
              c["name"].should eq("UnitTestsReplication")
              c["isVolatile"].should eq(false)
              c["waitForSync"].should eq(true)
          
              i = i + 1
            end

          elsif i == 1 and document["type"] == 2300 and document["cid"] == cid
            # create document
            document.should have_key("tick") 
            document.should have_key("type") 
            document.should have_key("cid") 
            document.should have_key("key") 
            document.should have_key("rev") 
            
            document["tick"].should match(/^\d+$/)
            document["tick"].to_i.should >= fromTick.to_i
            document["type"].should eq(2300) 
            document["cid"].should eq(cid) 
            document["key"].should eq("test") 
            rev = document["rev"]

            rev.should match(/^\d+$/)
            rev.should_not eq("0")
            
            document["data"]["_key"].should eq("test") 
            document["data"]["_rev"].should eq(rev)
            document["data"]["test"].should eq(false)
              
            i = i + 1
          elsif i == 2 and document["type"] == 2302 and document["cid"] == cid
            # delete document
            document.should have_key("tick") 
            document.should have_key("type") 
            document.should have_key("cid") 
            document.should have_key("key") 
            document.should have_key("rev") 

            document["tick"].should match(/^\d+$/)
            document["tick"].to_i.should >= fromTick.to_i
            document["type"].should eq(2302) 
            document["cid"].should eq(cid) 
            document["key"].should eq("test") 
            document["rev"].should match(/^\d+$/)
            document["rev"].should_not eq(rev)
              
            i = i + 1
          elsif i == 3 and document["type"] == 2001 and document["cid"] == cid
            # drop collection
            document.should have_key("tick") 
            document.should have_key("type") 
            document.should have_key("cid") 
            
            document["tick"].should match(/^\d+$/)
            document["tick"].to_i.should >= fromTick.to_i
            document["type"].should eq(2001) 
            document["cid"].should eq(cid) 
              
            i = i + 1
          end

          body = body.slice(position + 1, body.length)
        end
         
      end

    end

################################################################################
## inventory / dump 
################################################################################

    context "dealing with the initial dump" do

      before do
        ArangoDB.drop_collection("UnitTestsReplication")
        ArangoDB.drop_collection("UnitTestsReplication2")

      end

      after do
        ArangoDB.put(api + "/logger-stop", :body => "")
        ArangoDB.drop_collection("UnitTestsReplication")
        ArangoDB.drop_collection("UnitTestsReplication2")
      end

################################################################################
## inventory
################################################################################

      it "checks the initial inventory" do
        cmd = api + "/inventory?includeSystem=false"
        doc = ArangoDB.log_get("#{prefix}-inventory", cmd, :body => "")

        doc.code.should eq(200)
        all = doc.parsed_response
        all.should have_key('collections')
        all.should have_key('state')
        
        collections = all["collections"]
        filtered = [ ]
        collections.each { |collection|
          if [ "UnitTestsReplication", "UnitTestsReplication2" ].include? collection["parameters"]["name"]
            filtered.push collection
          end
        }
        filtered.should eq([ ])
        state = all['state']
        state['running'].should eq(true)
        state['lastLogTick'].should match(/^\d+$/)
        state['time'].should match(/^\d+-\d+-\d+T\d+:\d+:\d+Z$/)
      end
      
      it "checks the initial inventory for non-system collections" do
        cmd = api + "/inventory?includeSystem=false"
        doc = ArangoDB.log_get("#{prefix}-inventory-system", cmd, :body => "")

        doc.code.should eq(200)
        all = doc.parsed_response
        all.should have_key('collections')
        all.should have_key('state')
        
        collections = all["collections"]
        collections.each { |collection|
          collection["parameters"]["name"].should_not match(/^_/)
        }
      end
      
      it "checks the initial inventory for system collections" do
        cmd = api + "/inventory?includeSystem=true"
        doc = ArangoDB.log_get("#{prefix}-inventory-system", cmd, :body => "")

        doc.code.should eq(200)
        all = doc.parsed_response
        all.should have_key('collections')
        all.should have_key('state')
        
        collections = all["collections"]
        systemCollections = 0
        collections.each { |collection|
          if collection["parameters"]["name"].match(/^_/)
            systemCollections = systemCollections + 1
          end
        }

        systemCollections.should_not eq(0)
      end
     
      it "checks the inventory after creating collections" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)
        cid2 = ArangoDB.create_collection("UnitTestsReplication2", true, 3)
       
        cmd = api + "/inventory?includeSystem=false"
        doc = ArangoDB.log_get("#{prefix}-inventory-create", cmd, :body => "")
        doc.code.should eq(200)
        
        all = doc.parsed_response
        all.should have_key('collections')
        all.should have_key('state')
        
        state = all['state']
        state['running'].should eq(true)
        state['lastLogTick'].should match(/^\d+$/)
        state['time'].should match(/^\d+-\d+-\d+T\d+:\d+:\d+Z$/)

        collections = all['collections']
        filtered = [ ]
        collections.each { |collection|
          if [ "UnitTestsReplication", "UnitTestsReplication2" ].include? collection["parameters"]["name"]
            filtered.push collection
          end
        }
        filtered.length.should eq(2)
        
        # first collection
        c = filtered[0]
        c.should have_key("parameters")
        c.should have_key("indexes")

        parameters = c['parameters']
        parameters.should have_key("version")
        parameters["version"].should be_kind_of(Integer)
        parameters["type"].should be_kind_of(Integer)
        parameters["type"].should eq(2)
        parameters["cid"].should eq(cid)
        parameters["deleted"].should eq(false)
        parameters["doCompact"].should eq(true)
        parameters.should have_key("maximalSize")
        parameters["maximalSize"].should be_kind_of(Integer)
        parameters["name"].should eq("UnitTestsReplication")
        parameters["isVolatile"].should eq(false)
        parameters["waitForSync"].should eq(false)

        c['indexes'].should eq([ ])

        # second collection
        c = filtered[1]
        c.should have_key("parameters")
        c.should have_key("indexes")

        parameters = c['parameters']
        parameters.should have_key("version")
        parameters["version"].should be_kind_of(Integer)
        parameters["type"].should be_kind_of(Integer)
        parameters["type"].should eq(3)
        parameters["cid"].should eq(cid2)
        parameters["deleted"].should eq(false)
        parameters["doCompact"].should eq(true)
        parameters.should have_key("maximalSize")
        parameters["maximalSize"].should be_kind_of(Integer)
        parameters["name"].should eq("UnitTestsReplication2")
        parameters["isVolatile"].should eq(false)
        parameters["waitForSync"].should eq(true)

        c['indexes'].should eq([ ])
      end
      
      it "checks the inventory with indexes" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)
        cid2 = ArangoDB.create_collection("UnitTestsReplication2", false)

        # create indexes for first collection
        body = "{ \"type\" : \"cap\", \"size\" : 9991 }"
        doc = ArangoDB.log_post("#{prefix}-inventory2", "/_api/index?collection=UnitTestsReplication", :body => body)
        doc.code.should eq(201)
        
        body = "{ \"type\" : \"hash\", \"unique\" : false, \"fields\" : [ \"a\", \"b\" ] }"
        doc = ArangoDB.log_post("#{prefix}-inventory2", "/_api/index?collection=UnitTestsReplication", :body => body)
        doc.code.should eq(201)
        
        body = "{ \"type\" : \"skiplist\", \"unique\" : false, \"fields\" : [ \"c\" ] }"
        doc = ArangoDB.log_post("#{prefix}-inventory2", "/_api/index?collection=UnitTestsReplication", :body => body)
        doc.code.should eq(201)
        
        # create indexes for second collection
        body = "{ \"type\" : \"geo\", \"unique\" : false, \"fields\" : [ \"a\", \"b\" ] }"
        doc = ArangoDB.log_post("#{prefix}-inventory2", "/_api/index?collection=UnitTestsReplication2", :body => body)
        doc.code.should eq(201)
        
        body = "{ \"type\" : \"skiplist\", \"unique\" : true, \"fields\" : [ \"d\" ] }"
        doc = ArangoDB.log_post("#{prefix}-inventory2", "/_api/index?collection=UnitTestsReplication2", :body => body)
        doc.code.should eq(201)
        
        body = "{ \"type\" : \"fulltext\", \"minLength\" : 8, \"fields\" : [ \"ff\" ] }"
        doc = ArangoDB.log_post("#{prefix}-inventory2", "/_api/index?collection=UnitTestsReplication2", :body => body)
        doc.code.should eq(201)
        
        body = "{ \"type\" : \"cap\", \"byteSize\" : 1048576 }"
        doc = ArangoDB.log_post("#{prefix}-inventory2", "/_api/index?collection=UnitTestsReplication2", :body => body)
        doc.code.should eq(201)
        
        cmd = api + "/inventory"
        doc = ArangoDB.log_get("#{prefix}-inventory2", cmd, :body => "")
        doc.code.should eq(200)
        
        all = doc.parsed_response
        all.should have_key('collections')
        all.should have_key('state')
        
        state = all['state']
        state['running'].should eq(true)
        state['lastLogTick'].should match(/^\d+$/)
        state['time'].should match(/^\d+-\d+-\d+T\d+:\d+:\d+Z$/)

        collections = all['collections']
        filtered = [ ]
        collections.each { |collection|
          if [ "UnitTestsReplication", "UnitTestsReplication2" ].include? collection["parameters"]["name"]
            filtered.push collection
          end
        }
        filtered.length.should eq(2)
        
        # first collection
        c = filtered[0]
        c.should have_key("parameters")
        c.should have_key("indexes")

        parameters = c['parameters']
        parameters.should have_key("version")
        parameters["version"].should be_kind_of(Integer)
        parameters["type"].should be_kind_of(Integer)
        parameters["type"].should eq(2)
        parameters["cid"].should eq(cid)
        parameters["deleted"].should eq(false)
        parameters["doCompact"].should eq(true)
        parameters.should have_key("maximalSize")
        parameters["maximalSize"].should be_kind_of(Integer)
        parameters["name"].should eq("UnitTestsReplication")
        parameters["isVolatile"].should eq(false)
        parameters["waitForSync"].should eq(false)

        indexes = c['indexes']
        indexes.length.should eq(3)
        
        idx = indexes[0]
        idx["id"].should match(/^\d+$/)
        idx["type"].should eq("cap")
        idx["size"].should eq(9991)
        idx["byteSize"].should eq(0)
        
        idx = indexes[1]
        idx["id"].should match(/^\d+$/)
        idx["type"].should eq("hash")
        idx["unique"].should eq(false)
        idx["fields"].should eq([ "a", "b" ])
        
        idx = indexes[2]
        idx["id"].should match(/^\d+$/)
        idx["type"].should eq("skiplist")
        idx["unique"].should eq(false)
        idx["fields"].should eq([ "c" ])
        
        # second collection
        c = filtered[1]
        c.should have_key("parameters")
        c.should have_key("indexes")

        parameters = c['parameters']
        parameters.should have_key("version")
        parameters["version"].should be_kind_of(Integer)
        parameters["type"].should be_kind_of(Integer)
        parameters["type"].should eq(2)
        parameters["cid"].should eq(cid2)
        parameters["deleted"].should eq(false)
        parameters["doCompact"].should eq(true)
        parameters.should have_key("maximalSize")
        parameters["maximalSize"].should be_kind_of(Integer)
        parameters["name"].should eq("UnitTestsReplication2")
        parameters["isVolatile"].should eq(false)
        parameters["waitForSync"].should eq(false)
        
        indexes = c['indexes']
        indexes.length.should eq(4)
        
        idx = indexes[0]
        idx["id"].should match(/^\d+$/)
        idx["type"].should eq("geo2")
        idx["unique"].should eq(false)
        idx["fields"].should eq([ "a", "b" ])

        idx = indexes[1]
        idx["id"].should match(/^\d+$/)
        idx["type"].should eq("skiplist")
        idx["unique"].should eq(true)
        idx["fields"].should eq([ "d" ])
        
        idx = indexes[2]
        idx["id"].should match(/^\d+$/)
        idx["type"].should eq("fulltext")
        idx["unique"].should eq(false)
        idx["minLength"].should eq(8)
        idx["fields"].should eq([ "ff" ])

        idx = indexes[3]
        idx["id"].should match(/^\d+$/)
        idx["type"].should eq("cap")
        idx["size"].should eq(0)
        idx["byteSize"].should eq(1048576)
      end

################################################################################
## dump
################################################################################

      it "checks the dump for an empty collection" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)

        doc = ArangoDB.log_put("#{prefix}-deleted", "/_admin/wal/flush?waitForSync=true&waitForCollector=true", :body => "")
        doc.code.should eq(200)

        cmd = api + "/dump?collection=UnitTestsReplication"
        doc = ArangoDB.log_get("#{prefix}-dump-empty", cmd, :body => "")

        doc.code.should eq(204)

        doc.headers["x-arango-replication-checkmore"].should eq("false")
        doc.headers["x-arango-replication-lastincluded"].should eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")
        doc.response.body.should eq(nil)
      end
      
      it "checks the dump for a non-empty collection" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)

        (0...100).each{|i|
          body = "{ \"_key\" : \"test" + i.to_s + "\", \"test\" : " + i.to_s + " }"
          doc = ArangoDB.post("/_api/document?collection=UnitTestsReplication", :body => body)
          doc.code.should eq(202)
        }

        cmd = api + "/dump?collection=UnitTestsReplication"
        doc = ArangoDB.log_get("#{prefix}-dump-non-empty", cmd, :body => "", :format => :plain)

        doc.code.should eq(200)

        doc.headers["x-arango-replication-checkmore"].should eq("false")
        doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
        doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")

        body = doc.response.body
        i = 0
        while 1
          position = body.index("\n")

          break if position == nil

          part = body.slice(0, position)

          doc = JSON.parse(part)
          doc['type'].should eq(2300)
          doc['key'].should eq("test" + i.to_s)
          doc['rev'].should match(/^\d+$/)
          doc['data']['_key'].should eq("test" + i.to_s)
          doc['data']['_rev'].should match(/^\d+$/)
          doc['data']['test'].should eq(i)

          body = body.slice(position + 1, body.length)
          i = i + 1
        end

        i.should eq(100)
      end

      it "checks the dump for a non-empty collection, small chunkSize" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)

        (0...100).each{|i|
          body = "{ \"_key\" : \"test" + i.to_s + "\", \"test\" : " + i.to_s + " }"
          doc = ArangoDB.post("/_api/document?collection=UnitTestsReplication", :body => body)
          doc.code.should eq(202)
        }

        doc = ArangoDB.log_put("#{prefix}-deleted", "/_admin/wal/flush?waitForSync=true&waitForCollector=true", :body => "")
        doc.code.should eq(200)

        cmd = api + "/dump?collection=UnitTestsReplication&chunkSize=1024"
        doc = ArangoDB.log_get("#{prefix}-dump-non-empty", cmd, :body => "", :format => :plain)

        doc.code.should eq(200)

        doc.headers["x-arango-replication-checkmore"].should eq("true")
        doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
        doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")

        body = doc.response.body
        i = 0
        while 1
          position = body.index("\n")

          break if position == nil

          part = body.slice(0, position)

          doc = JSON.parse(part)
          doc['type'].should eq(2300)
          doc['key'].should eq("test" + i.to_s)
          doc['rev'].should match(/^\d+$/)
          doc['data']['_key'].should eq("test" + i.to_s)
          doc['data']['_rev'].should match(/^\d+$/)
          doc['data']['test'].should eq(i)

          body = body.slice(position + 1, body.length)
          i = i + 1
        end

        i.should be < 100
      end

      
      it "checks the dump for an edge collection" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)
        cid2 = ArangoDB.create_collection("UnitTestsReplication2", false, 3)

        (0...100).each{|i|
          body = "{ \"_key\" : \"test" + i.to_s + "\", \"test1\" : " + i.to_s + ", \"test2\" : false, \"test3\" : [ ], \"test4\" : { } }"
          doc = ArangoDB.post("/_api/edge?collection=UnitTestsReplication2&from=UnitTestsReplication/foo&to=UnitTestsReplication/bar", :body => body)
          doc.code.should eq(202)
        }

        doc = ArangoDB.log_put("#{prefix}-deleted", "/_admin/wal/flush?waitForSync=true&waitForCollector=true", :body => "")
        doc.code.should eq(200)

        cmd = api + "/dump?collection=UnitTestsReplication2&chunkSize=65536"
        doc = ArangoDB.log_get("#{prefix}-dump-edge", cmd, :body => "", :format => :plain)

        doc.code.should eq(200)

        doc.headers["x-arango-replication-checkmore"].should eq("false")
        doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
        doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")

        body = doc.response.body
        i = 0
        while 1
          position = body.index("\n")

          break if position == nil

          part = body.slice(0, position)

          document = JSON.parse(part)
          document['type'].should eq(2301)
          document['key'].should eq("test" + i.to_s)
          document['rev'].should match(/^\d+$/)
          document['data']['_key'].should eq("test" + i.to_s)
          document['data']['_rev'].should match(/^\d+$/)
          document['data']['_from'].should eq("UnitTestsReplication/foo")
          document['data']['_to'].should eq("UnitTestsReplication/bar")
          document['data']['test1'].should eq(i)
          document['data']['test2'].should eq(false)
          document['data']['test3'].should eq([ ])
          document['data']['test4'].should eq({ })

          body = body.slice(position + 1, body.length)
          i = i + 1
        end

        i.should eq(100)
      end

      it "checks the dump for an edge collection, small chunkSize" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)
        cid2 = ArangoDB.create_collection("UnitTestsReplication2", false, 3)

        (0...100).each{|i|
          body = "{ \"_key\" : \"test" + i.to_s + "\", \"test1\" : " + i.to_s + ", \"test2\" : false, \"test3\" : [ ], \"test4\" : { } }"
          doc = ArangoDB.post("/_api/edge?collection=UnitTestsReplication2&from=UnitTestsReplication/foo&to=UnitTestsReplication/bar", :body => body)
          doc.code.should eq(202)
        }

        doc = ArangoDB.log_put("#{prefix}-deleted", "/_admin/wal/flush?waitForSync=true&waitForCollector=true", :body => "")
        doc.code.should eq(200)

        cmd = api + "/dump?collection=UnitTestsReplication2&chunkSize=1024"
        doc = ArangoDB.log_get("#{prefix}-dump-edge", cmd, :body => "", :format => :plain)

        doc.code.should eq(200)

        doc.headers["x-arango-replication-checkmore"].should eq("true")
        doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
        doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")

        body = doc.response.body
        i = 0
        while 1
          position = body.index("\n")

          break if position == nil

          part = body.slice(0, position)

          document = JSON.parse(part)
          document['type'].should eq(2301)
          document['key'].should eq("test" + i.to_s)
          document['rev'].should match(/^\d+$/)
          document['data']['_key'].should eq("test" + i.to_s)
          document['data']['_rev'].should match(/^\d+$/)
          document['data']['_from'].should eq("UnitTestsReplication/foo")
          document['data']['_to'].should eq("UnitTestsReplication/bar")
          document['data']['test1'].should eq(i)
          document['data']['test2'].should eq(false)
          document['data']['test3'].should eq([ ])
          document['data']['test4'].should eq({ })

          body = body.slice(position + 1, body.length)
          i = i + 1
        end

        i.should be < 100
      end
      
      it "checks the dump for a collection with deleted documents" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)

        doc = ArangoDB.log_put("#{prefix}-deleted", "/_admin/wal/flush?waitForSync=true&waitForCollector=true", :body => "")
        doc.code.should eq(200)

        (0...10).each{|i|
          body = "{ \"_key\" : \"test" + i.to_s + "\", \"test\" : " + i.to_s + " }"
          doc = ArangoDB.post("/_api/document?collection=UnitTestsReplication", :body => body)
          doc.code.should eq(202)
          
          doc = ArangoDB.delete("/_api/document/UnitTestsReplication/test" + i.to_s, :body => body)
          doc.code.should eq(202)
        }

        doc = ArangoDB.log_put("#{prefix}-deleted", "/_admin/wal/flush?waitForSync=true&waitForCollector=true", :body => "")
        doc.code.should eq(200)

        cmd = api + "/dump?collection=UnitTestsReplication"
        doc = ArangoDB.log_get("#{prefix}-deleted", cmd, :body => "", :format => :plain)
        doc.code.should eq(200)

        doc.headers["x-arango-replication-checkmore"].should eq("false")
        doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
        doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")

        body = doc.response.body
        i = 0
        while 1
          position = body.index("\n")

          break if position == nil

          part = body.slice(0, position)

          document = JSON.parse(part)

          document['type'].should eq(2302)
          document['key'].should eq("test" + i.floor.to_s)

          body = body.slice(position + 1, body.length)
          i = i + 1
        end

        i.should eq(10)
      end
      
      it "checks the dump for a truncated collection" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)

        (0...10).each{|i|
          body = "{ \"_key\" : \"test" + i.to_s + "\", \"test\" : " + i.to_s + " }"
          doc = ArangoDB.post("/_api/document?collection=UnitTestsReplication", :body => body)
          doc.code.should eq(202)
        }

        # truncate
        cmd = "/_api/collection/UnitTestsReplication/truncate"
        doc = ArangoDB.log_put("#{prefix}-truncated", cmd, :body => "", :format => :plain)
        doc.code.should eq(200)

        doc = ArangoDB.log_put("#{prefix}-deleted", "/_admin/wal/flush?waitForSync=true&waitForCollector=true", :body => "")
        doc.code.should eq(200)

        cmd = api + "/dump?collection=UnitTestsReplication"
        doc = ArangoDB.log_get("#{prefix}-truncated", cmd, :body => "", :format => :plain)
        doc.code.should eq(200)

        doc.headers["x-arango-replication-checkmore"].should eq("false")
        doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
        doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
        doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")

        body = doc.response.body
        i = 0
        while 1
          position = body.index("\n")

          break if position == nil

          part = body.slice(0, position)

          document = JSON.parse(part)

          document['type'].should eq(2302)
          # truncate order is undefined
          document['key'].should match(/^test\d+$/)
          document['rev'].should match(/^\d+$/)

          body = body.slice(position + 1, body.length)
          i = i + 1
        end

        i.should eq(10)
      end
      
      it "fetches incremental parts of a collection dump" do
        cid = ArangoDB.create_collection("UnitTestsReplication", false)

        (0...10).each{|i|
          body = "{ \"_key\" : \"test" + i.to_s + "\", \"test\" : " + i.to_s + " }"
          doc = ArangoDB.post("/_api/document?collection=UnitTestsReplication", :body => body)
          doc.code.should eq(202)
        }

        doc = ArangoDB.log_put("#{prefix}-deleted", "/_admin/wal/flush?waitForSync=true&waitForCollector=true", :body => "")
        doc.code.should eq(200)

        fromTick = "0"

        (0...10).each{|i|
          cmd = api + "/dump?collection=UnitTestsReplication&from=" + fromTick + "&chunkSize=1"
          doc = ArangoDB.log_get("#{prefix}-incremental", cmd, :body => "", :format => :plain)
          doc.code.should eq(200)

          if i == 9
            doc.headers["x-arango-replication-checkmore"].should eq("false")
          else
            doc.headers["x-arango-replication-checkmore"].should eq("true")
          end 

          doc.headers["x-arango-replication-lastincluded"].should match(/^\d+$/)
          doc.headers["x-arango-replication-lastincluded"].should_not eq("0")
          doc.headers["x-arango-replication-lastincluded"].to_i.should >= fromTick.to_i
          doc.headers["content-type"].should eq("application/x-arango-dump; charset=utf-8")
          
          fromTick = doc.headers["x-arango-replication-lastincluded"]

          body = doc.response.body
          document = JSON.parse(body)

          document['type'].should eq(2300)
          document['key'].should eq("test" + i.to_s)
          document['rev'].should match(/^\d+$/)
          document['data']['_key'].should eq("test" + i.to_s)
          document['data']['_rev'].should match(/^\d+$/)
          document['data']['test'].should eq(i)
        }
      end

    end

  end

end