/*jshint globalstrict:false, strict:false, maxlen: 5000 */
/*global describe, beforeEach, afterEach, it */
'use strict';

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2016 ArangoDB GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///     http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Max Neunhoeffer
////////////////////////////////////////////////////////////////////////////////

const expect = require('chai').expect;

const arangodb = require("@arangodb");
const request = require('@arangodb/request');

const ERRORS = arangodb.errors;
const db = arangodb.db;
const wait = require("internal").wait;
const extend = require('lodash').extend;

const errorHeader = "x-arango-error-codes";
const uniqueCode = ERRORS.ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED.code;
const invalidCode = ERRORS.ERROR_ARANGO_DOCUMENT_TYPE_INVALID.code;
const keyBadCode = ERRORS.ERROR_ARANGO_DOCUMENT_KEY_BAD.code;

let endpoint = {};

describe('babies collection document', function() {
  const cn = "UnitTestsCollectionBasics";
  let collection = null;

  beforeEach(function() {
    db._drop(cn);
    collection = db._create(cn, {
      waitForSync: false
    });
  });

  afterEach(function() {
    if (collection) {
      collection.unload();
      collection.drop();
      collection = null;
    }

    wait(0.0);
  });

  describe('basics', function() {
    it('insert remove multi (few)', function() {
      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify([{}, {}, {}])
      }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(3);

      let result = JSON.parse(req.rawBody);
      let ids = result.map(function(x) {
        return x._key;
      });

      req = request.put("/_api/simple/remove-by-keys", extend(endpoint, {
        body: JSON.stringify({
          keys: ids,
          collection: cn
        })
      }));

      expect(req.statusCode).to.equal(200);
      expect(collection.count()).to.equal(0);
    });

    it('insert remove multi by DELETE (few)', function() {
      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify([{}, {}, {}])
      }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(3);

      let result = JSON.parse(req.rawBody);
      let ids = result.map(function(x) {
        return x._key;
      });

      req = request["delete"]("/_api/document/" + cn,
          extend(endpoint, { body: JSON.stringify(ids) }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(0);
    });

    it('insert remove multi (many)', function() {
      let l = [];

      for (let i = 0; i < 10000; i++) {
        l.push({
          value: i
        });
      }

      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l)
      }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l.length);

      let result = JSON.parse(req.rawBody);
      let ids = result.map(function(x) {
        return x._key;
      });

      req = request.put("/_api/simple/remove-by-keys", extend(endpoint, {
        body: JSON.stringify({
          keys: ids,
          collection: cn
        })
      }));

      expect(req.statusCode).to.equal(200);
      expect(collection.count()).to.equal(0);
    });

    it('insert remove multi (many) by DELETE', function() {
      let l = [];

      for (let i = 0; i < 10000; i++) {
        l.push({
          value: i
        });
      }

      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l)
      }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l.length);

      let result = JSON.parse(req.rawBody);
      let ids = result.map(function(x) {
        return x._key;
      });

      req = request["delete"]("/_api/document/" + cn,
          extend(endpoint, { body: JSON.stringify(ids) }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(0);
    });

    it('insert with key remove multi (few)', function() {
      let l = [{
        _key: "a"
      }, {
        _key: "b"
      }, {
        _key: "c"
      }];

      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l)
      }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l.length);

      let result = JSON.parse(req.rawBody);
      let ids = result.map(function(x) {
        return x._key;
      });

      req = request.put("/_api/simple/remove-by-keys", extend(endpoint, {
        body: JSON.stringify({
          keys: ids,
          collection: cn
        })
      }));

      expect(req.statusCode).to.equal(200);
      expect(collection.count()).to.equal(0);
    });

    it('insert with key remove multi (few) by DELETE', function() {
      let l = [{
        _key: "a"
      }, {
        _key: "b"
      }, {
        _key: "c"
      }];

      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l)
      }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l.length);

      let result = JSON.parse(req.rawBody);
      let ids = result.map(function(x) {
        return x._key;
      });

      req = request["delete"]("/_api/document/" + cn,
          extend(endpoint, { body: JSON.stringify(ids) }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(0);
    });

    it('insert with key remove multi (many)', function() {
      let l = [];

      for (let i = 0; i < 10000; i++) {
        l.push({
          _key: "K" + i,
          value: i
        });
      }

      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l)
      }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l.length);

      let result = JSON.parse(req.rawBody);
      let ids = result.map(function(x) {
        return x._key;
      });

      req = request.put("/_api/simple/remove-by-keys", extend(endpoint, {
        body: JSON.stringify({
          keys: ids,
          collection: cn
        })
      }));

      expect(req.statusCode).to.equal(200);
      expect(collection.count()).to.equal(0);
    });

    it('insert with key remove multi (many) by DELETE', function() {
      let l = [];

      for (let i = 0; i < 10000; i++) {
        l.push({
          _key: "K" + i,
          value: i
        });
      }

      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l)
      }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l.length);

      let result = JSON.parse(req.rawBody);
      let ids = result.map(function(x) {
        return x._key;
      });

      req = request["delete"]("/_api/document/" + cn,
          extend(endpoint, { body: JSON.stringify(ids) }));

      expect(req.statusCode).to.equal(202);
      expect(collection.count()).to.equal(0);
    });

    it('insert error unique constraint', function() {
      collection.insert([{
        _key: "a"
      }]);

      let l = [{
        _key: "b" // new
      }, {
        _key: "a" // already there
      }];

      let req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l)
      }));

      expect(req.statusCode).to.equal(202);

      let b = JSON.parse(req.rawBody);

      expect(b).to.be.an("array");
      expect(b.length).to.equal(2);
      expect(b[0]._key).to.equal("b");
      expect(b[1].error).to.equal(true);
      expect(b[1].errorNum).to.equal(uniqueCode);

      // Check header error codes
      let headers = req.headers;
      expect(headers).to.have.property(errorHeader);
      let errorCodes = JSON.parse(headers[errorHeader]);
      expect(errorCodes).to.have.property(uniqueCode);
      expect(errorCodes[uniqueCode], 1);

      expect(collection.count()).to.equal(2);

      l = [{
        _key: "a" // already there
      }, {
        _key: "c" // new
      }];

      req = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l)
      }));

      expect(req.statusCode).to.equal(202);

      b = JSON.parse(req.rawBody);

      expect(b).to.be.an("array");
      expect(b.length).to.equal(2);
      expect(b[0].error).to.equal(true);
      expect(b[0].errorNum).to.equal(uniqueCode);
      expect(b[1]._key).to.equal("c");
      expect(collection.count()).to.equal(3);

      // Check header error codes
      headers = req.headers;
      expect(headers).to.have.property(errorHeader);
      errorCodes = JSON.parse(headers[errorHeader]);
      expect(errorCodes).to.have.property(uniqueCode);
      expect(errorCodes[uniqueCode], 1);

    });

    it('insert error bad key', function() {
      let l = [null, false, true, 1, -1, {},
        []
      ];

      l.forEach(function(k) {
        let m = [{
          _key: "a"
        }, {
          _key: k
        }, {
          _key: "b"
        }];

        let req = request.post("/_api/document/" + cn, extend(endpoint, {
          body: JSON.stringify(m)
        }));

        expect(req.statusCode).to.equal(202);

        let b = JSON.parse(req.rawBody);
        expect(b).to.be.an("array");
        expect(b.length).to.equal(3);
        // The first and the last should work
        expect(b[0]._key).to.equal("a");
        expect(b[2]._key).to.equal("b");

        // The second should fail
        expect(b[1].error).to.equal(true);
        expect(b[1].errorNum).to.equal(keyBadCode);

        // Check header error codes
        let headers = req.headers;
        expect(headers).to.have.property(errorHeader);
        let errorCodes = JSON.parse(headers[errorHeader]);
        expect(errorCodes).to.have.property(keyBadCode);
        expect(errorCodes[keyBadCode], 1);


        expect(collection.count()).to.equal(2);

        collection.remove("a");
        collection.remove("b");
      });

      expect(collection.count()).to.equal(0);
    });

    it('replace multi', function() {
      let l1 = [{
        value: 1
      }, {
        value: 1
      }, {
        value: 1
      }];

      let req1 = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l1)
      }));

      expect(req1.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l1.length);

      let b1 = JSON.parse(req1.rawBody);

      let l2 = [{
        value: 2
      }, {
        value: 2
      }, {
        value: 2
      }];

      for (let i = 0; i < l1.length; ++i) {
        l2[i]._key = b1[i]._key;
        l2[i]._rev = b1[i]._rev;
      }

      let req2 = request.put("/_api/document/" + cn + "?ignoreRevs=false",
        extend(endpoint, {
          body: JSON.stringify(l2)
        }));

      expect(req2.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l1.length);

      let b2 = JSON.parse(req2.rawBody);

      let docs3 = collection.toArray();

      expect(docs3.length).to.equal(l1.length);

      for (let i = 0; i < docs3.length; i++) {
        expect(docs3[i].value).to.equal(2);
      }

      let docs4 = collection.remove(b1);
      expect(docs4.length).to.equal(3);
      for (let i = 0; i < docs3.length; i++) {
        expect(docs4[i].error).to.equal(true);
        expect(docs4[i].errorNum).to.equal(ERRORS.ERROR_ARANGO_CONFLICT.code);
      }

      expect(collection.count()).to.equal(3);
      collection.remove(b2);
      expect(collection.count()).to.equal(0);
    });

    it('update multi', function() {
      let l1 = [{
        value: 1
      }, {
        value: 1
      }, {
        value: 1
      }];

      let req1 = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l1)
      }));

      expect(req1.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l1.length);

      let b1 = JSON.parse(req1.rawBody);

      let l2 = [{
        value: 2
      }, {
        value: 2
      }, {
        value: 2
      }];

      for (let i = 0; i < l1.length; ++i) {
        l2[i]._key = b1[i]._key;
        l2[i]._rev = b1[i]._rev;
      }

      let req2 = request.patch("/_api/document/" + cn + "?ignoreRevs=false",
        extend(endpoint, {
          body: JSON.stringify(l2)
        }));

      expect(req2.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l1.length);

      let b2 = JSON.parse(req2.rawBody);

      let docs3 = collection.toArray();

      expect(docs3.length).to.equal(l1.length);

      for (let i = 0; i < docs3.length; i++) {
        expect(docs3[i].value).to.equal(2);
      }

      let docs4 = collection.remove(b1);
      expect(docs4.length).to.equal(3);
      for (let i = 0; i < docs3.length; i++) {
        expect(docs4[i].error).to.equal(true);
        expect(docs4[i].errorNum).to.equal(ERRORS.ERROR_ARANGO_CONFLICT.code);
      }

      expect(collection.count()).to.equal(3);
      collection.remove(b2);
      expect(collection.count()).to.equal(0);
    });

    it('replace multi precondition', function() {
      let l1 = [{
        value: 1
      }, {
        value: 2
      }, {
        value: 3
      }];

      let req1 = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l1)
      }));

      expect(req1.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l1.length);

      let b1 = JSON.parse(req1.rawBody);

      let l2 = [{
        value: 4
      }, {
        value: 5
      }, {
        value: 6
      }];

      for (let i = 0; i < l1.length; ++i) {
        l2[i]._key = b1[i]._key;
        l2[i]._rev = b1[i]._rev;
      }

      let req2 = request.put("/_api/document/" + cn + "?ignoreRevs=false",
        extend(endpoint, {
          body: JSON.stringify(l2)
        }));

      expect(req2.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l1.length);

      JSON.parse(req2.rawBody);

      let l3 = [{
        value: 7
      }, {
        value: 8
      }, {
        value: 9
      }];

      for (let i = 0; i < l1.length; ++i) {
        l3[i]._key = b1[i]._key;
        l3[i]._rev = b1[i]._rev;
      }

      let req3 = request.put("/_api/document/" + cn + "?ignoreRevs=false",
        extend(endpoint, {
          body: JSON.stringify(l3)
        }));
      // Babies only have positive result codes
      expect(req3.statusCode).to.equal(202);

      let b3 = JSON.parse(req3.rawBody);
      for (let i = 0; i < l3.length; ++i) {
        expect(b3[i].error).to.equal(true);
        expect(b3[i].errorNum).to.equal(ERRORS.ERROR_ARANGO_CONFLICT.code);
      }

      expect(collection.count()).to.equal(l1.length);
    });

    it('update multi precondition', function() {
      let l1 = [{
        value: 1
      }, {
        value: 2
      }, {
        value: 3
      }];

      let req1 = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify(l1)
      }));

      expect(req1.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l1.length);

      let b1 = JSON.parse(req1.rawBody);

      let l2 = [{
        value: 4
      }, {
        value: 5
      }, {
        value: 6
      }];

      for (let i = 0; i < l1.length; ++i) {
        l2[i]._key = b1[i]._key;
        l2[i]._rev = b1[i]._rev;
      }

      let req2 = request.patch("/_api/document/" + cn + "?ignoreRevs=false",
        extend(endpoint, {
          body: JSON.stringify(l2)
        }));

      expect(req2.statusCode).to.equal(202);
      expect(collection.count()).to.equal(l1.length);

      JSON.parse(req2.rawBody);

      let l3 = [{
        value: 7
      }, {
        value: 8
      }, {
        value: 9
      }];

      for (let i = 0; i < l1.length; ++i) {
        l3[i]._key = b1[i]._key;
        l3[i]._rev = b1[i]._rev;
      }

      let req3 = request.patch("/_api/document/" + cn + "?ignoreRevs=false",
        extend(endpoint, {
          body: JSON.stringify(l3)
        }));

      // Babies only have positive result codes
      expect(req3.statusCode).to.equal(202);

      let b3 = JSON.parse(req3.rawBody);
      for (let i = 0; i < l3.length; ++i) {
        expect(b3[i].error).to.equal(true);
        expect(b3[i].errorNum).to.equal(ERRORS.ERROR_ARANGO_CONFLICT.code);
      }
      expect(collection.count()).to.equal(l1.length);
    });

    it('invalid document type', function() {
      let values1 = [null, false, true, 1, "abc", [],
        [1, 2, 3]
      ];

      values1.forEach(function(x) {
        let req1 = request.post("/_api/document/" + cn, extend(endpoint, {
          body: JSON.stringify([x])
        }));

        expect(req1.statusCode).to.equal(202);

        let b = JSON.parse(req1.rawBody);
        expect(b).to.be.an("array");
        expect(b.length).to.equal(1);

        expect(b[0].errorNum).to.equal(invalidCode);
        expect(b[0].error).to.equal(true);

        // Check header error codes
        let headers = req1.headers;
        expect(headers).to.have.property(errorHeader);
        let errorCodes = JSON.parse(headers[errorHeader]);
        expect(errorCodes).to.have.property(invalidCode);
        expect(errorCodes[invalidCode], 1);
      });

    });

    it('multiple errors', function() {
      collection.save({_key: "a"});

      let req1 = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify([{
          _key: "b" // valid
        }, 
        true, // type invalid
        {
          _key: "a" // unique violated
        }, {
          _key: "c" // valid
        }, {
          _key: "b" // unique violated
        }, [
          // type invalid
        ], {
          _key: "d" // valid
        } ])
      }));

      expect(req1.statusCode).to.equal(202);

      let b = JSON.parse(req1.rawBody);
      expect(b).to.be.an("array");
      expect(b.length).to.equal(7);
      // Check the valid ones
      expect(b[0]._key).to.equal("b");
      expect(b[3]._key).to.equal("c");
      expect(b[6]._key).to.equal("d");

      // Check type invalid
      expect(b[1].error).to.equal(true);
      expect(b[1].errorNum).to.equal(invalidCode);
      expect(b[5].error).to.equal(true);
      expect(b[5].errorNum).to.equal(invalidCode);

      // Check unique violated 
      expect(b[2].error).to.equal(true);
      expect(b[2].errorNum).to.equal(uniqueCode);
      expect(b[4].error).to.equal(true);
      expect(b[4].errorNum).to.equal(uniqueCode);

      expect(collection.count()).to.equal(4);

      // Check header error codes
      let headers = req1.headers;
      expect(headers).to.have.property(errorHeader);
      let errorCodes = JSON.parse(headers[errorHeader]);
      expect(errorCodes).to.have.property(invalidCode);
      expect(errorCodes[invalidCode], 2);

      expect(errorCodes).to.have.property(uniqueCode);
      expect(errorCodes[uniqueCode], 2);
    });

  });

  describe('old and new', function() {
    it('create multi, return new', function() {
      let req1 = request.post("/_api/document/" + cn, extend(endpoint, {
        body: JSON.stringify([{
          "Hallo": 12
        }])
      }));

      expect(req1.statusCode).to.equal(202);

      let b1 = JSON.parse(req1.rawBody);

      expect(b1).to.be.instanceof(Array);
      expect(b1).to.have.lengthOf(1);
      expect(b1[0]).to.be.a('object');
      expect(Object.keys(b1[0])).to.have.lengthOf(3);
      expect(b1[0]._id).to.be.a('string');
      expect(b1[0]._key).to.be.a('string');
      expect(b1[0]._rev).to.be.a('string');

      let req2 = request.post("/_api/document/" + cn + "?returnNew=true",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 12
          }])
        }));

      expect(req2.statusCode).to.equal(202);

      let b2 = JSON.parse(req2.rawBody);

      expect(b2).to.be.instanceof(Array);
      expect(b2).to.have.lengthOf(1);
      expect(b2[0]).to.be.a('object');
      expect(Object.keys(b2[0])).to.have.lengthOf(4);
      expect(b2[0]._id).to.be.a('string');
      expect(b2[0]._key).to.be.a('string');
      expect(b2[0]._rev).to.be.a('string');
      expect(b2[0]["new"]).to.be.a('object');
      expect(Object.keys(b2[0]["new"])).to.have.lengthOf(4);
      expect(b2[0]["new"].Hallo).to.equal(12);

      let req3 = request.post("/_api/document/" + cn + "?returnNew=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 12
          }])
        }));

      expect(req3.statusCode).to.equal(202);

      let b3 = JSON.parse(req3.rawBody);

      expect(b3).to.be.instanceof(Array);
      expect(b3).to.have.lengthOf(1);
      expect(b3[0]).to.be.a('object');
      expect(Object.keys(b3[0])).to.have.lengthOf(3);
      expect(b3[0]._id).to.be.a('string');
      expect(b3[0]._key).to.be.a('string');
      expect(b3[0]._rev).to.be.a('string');
    });

    it('replace multi, return old and new', function() {
      var res = collection.insert({
        "Hallo": 12
      });

      let req1 = request.put("/_api/document/" + cn + "?ignoreRevs=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 13,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req1.statusCode).to.equal(202);

      let b1 = JSON.parse(req1.rawBody);

      expect(b1).to.be.instanceof(Array);
      expect(b1).to.have.lengthOf(1);
      expect(b1[0]).to.be.a('object');
      expect(Object.keys(b1[0])).to.have.lengthOf(4);
      expect(b1[0]._id).to.be.a('string');
      expect(b1[0]._key).to.be.a('string');
      expect(b1[0]._rev).to.be.a('string');
      expect(b1[0]._oldRev).to.be.a('string');

      res = collection.insert({
        "Hallo": 12
      });

      let req2 = request.put("/_api/document/" + cn + "?returnOld=true",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 13,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req2.statusCode).to.equal(202);

      let b2 = JSON.parse(req2.rawBody);

      expect(b2).to.be.instanceof(Array);
      expect(b2).to.have.lengthOf(1);
      expect(b2[0]).to.be.a('object');
      expect(Object.keys(b2[0])).to.have.lengthOf(5);
      expect(b2[0]._id).to.be.a('string');
      expect(b2[0]._key).to.be.a('string');
      expect(b2[0]._rev).to.be.a('string');
      expect(b2[0]._oldRev).to.be.a('string');
      expect(b2[0].old).to.be.a('object');
      expect(Object.keys(b2[0].old)).to.have.lengthOf(4);
      expect(b2[0].old.Hallo).to.equal(12);

      res = collection.insert({
        "Hallo": 12
      });

      let req3 = request.put("/_api/document/" + cn + "?returnOld=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 14,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req3.statusCode).to.equal(202);

      let b3 = JSON.parse(req3.rawBody);

      expect(b3).to.be.instanceof(Array);
      expect(b3).to.have.lengthOf(1);
      expect(b3[0]).to.be.a('object');
      expect(Object.keys(b3[0])).to.have.lengthOf(4);
      expect(b3[0]._id).to.be.a('string');
      expect(b3[0]._key).to.be.a('string');
      expect(b3[0]._rev).to.be.a('string');
      expect(b3[0]._oldRev).to.be.a('string');

      res = collection.insert({
        "Hallo": 12
      });

      let req4 = request.put("/_api/document/" + cn + "?returnNew=true",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 14,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req4.statusCode).to.equal(202);

      let b4 = JSON.parse(req4.rawBody);

      expect(b4).to.be.instanceof(Array);
      expect(b4).to.have.lengthOf(1);
      expect(b4[0]).to.be.a('object');
      expect(Object.keys(b4[0])).to.have.lengthOf(5);
      expect(b4[0]._id).to.be.a('string');
      expect(b4[0]._key).to.be.a('string');
      expect(b4[0]._rev).to.be.a('string');
      expect(b4[0]._oldRev).to.be.a('string');
      expect(b4[0]["new"]).to.be.a('object');
      expect(Object.keys(b4[0]["new"])).to.have.lengthOf(4);
      expect(b4[0]["new"].Hallo).to.equal(14);

      res = collection.insert({
        "Hallo": 12
      });

      let req5 = request.put("/_api/document/" + cn + "?returnNew=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 15,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req5.statusCode).to.equal(202);

      let b5 = JSON.parse(req5.rawBody);

      expect(b5).to.be.instanceof(Array);
      expect(b5).to.have.lengthOf(1);
      expect(b5[0]).to.be.a('object');
      expect(Object.keys(b5[0])).to.have.lengthOf(4);
      expect(b5[0]._id).to.be.a('string');
      expect(b5[0]._key).to.be.a('string');
      expect(b5[0]._rev).to.be.a('string');
      expect(b5[0]._oldRev).to.be.a('string');

      res = collection.insert({
        "Hallo": 12
      });

      let req6 = request.put("/_api/document/" + cn + "?returnNew=true&returnOld=true",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 16,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req6.statusCode).to.equal(202);

      let b6 = JSON.parse(req6.rawBody);

      expect(b6).to.be.instanceof(Array);
      expect(b6).to.have.lengthOf(1);
      expect(b6[0]).to.be.a('object');
      expect(Object.keys(b6[0])).to.have.lengthOf(6);
      expect(b6[0]._id).to.be.a('string');
      expect(b6[0]._key).to.be.a('string');
      expect(b6[0]._rev).to.be.a('string');
      expect(b6[0]._oldRev).to.be.a('string');
      expect(b6[0].old).to.be.a('object');
      expect(Object.keys(b6[0])).to.have.lengthOf(6);
      expect(b6[0].old.Hallo).to.equal(12);
      expect(b6[0]["new"]).to.be.a('object');
      expect(Object.keys(b6[0]["new"])).to.have.lengthOf(4);
      expect(b6[0]["new"].Hallo).to.equal(16);

      res = collection.insert({
        "Hallo": 12
      });

      let req7 = request.put("/_api/document/" + cn + "?returnNew=false&returnOld=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 17,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req7.statusCode).to.equal(202);

      let b7 = JSON.parse(req2.rawBody);

      expect(b7).to.be.instanceof(Array);
      expect(b7).to.have.lengthOf(1);
      expect(b7[0]).to.be.a('object');
      expect(Object.keys(b7[0])).to.have.lengthOf(5);
      expect(b7[0]._id).to.be.a('string');
      expect(b7[0]._key).to.be.a('string');
      expect(b7[0]._rev).to.be.a('string');
      expect(b7[0]._oldRev).to.be.a('string');
    });

    it('update multi, return old and new', function() {
      var res = collection.insert({
        "Hallo": 12
      });

      let req1 = request.patch("/_api/document/" + cn + "?ignoreRevs=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 13,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req1.statusCode).to.equal(202);

      let b1 = JSON.parse(req1.rawBody);

      expect(b1).to.be.instanceof(Array);
      expect(b1).to.have.lengthOf(1);
      expect(b1[0]).to.be.a('object');
      expect(Object.keys(b1[0])).to.have.lengthOf(4);
      expect(b1[0]._id).to.be.a('string');
      expect(b1[0]._key).to.be.a('string');
      expect(b1[0]._rev).to.be.a('string');
      expect(b1[0]._oldRev).to.be.a('string');

      res = collection.insert({
        "Hallo": 12
      });

      let req2 = request.patch("/_api/document/" + cn + "?returnOld=true",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 13,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req2.statusCode).to.equal(202);

      let b2 = JSON.parse(req2.rawBody);

      expect(b2).to.be.instanceof(Array);
      expect(b2).to.have.lengthOf(1);
      expect(b2[0]).to.be.a('object');
      expect(Object.keys(b2[0])).to.have.lengthOf(5);
      expect(b2[0]._id).to.be.a('string');
      expect(b2[0]._key).to.be.a('string');
      expect(b2[0]._rev).to.be.a('string');
      expect(b2[0]._oldRev).to.be.a('string');
      expect(b2[0].old).to.be.a('object');
      expect(Object.keys(b2[0].old)).to.have.lengthOf(4);
      expect(b2[0].old.Hallo).to.equal(12);

      res = collection.insert({
        "Hallo": 12
      });

      let req3 = request.patch("/_api/document/" + cn + "?returnOld=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 14,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req3.statusCode).to.equal(202);

      let b3 = JSON.parse(req3.rawBody);

      expect(b3).to.be.instanceof(Array);
      expect(b3).to.have.lengthOf(1);
      expect(b3[0]).to.be.a('object');
      expect(Object.keys(b3[0])).to.have.lengthOf(4);
      expect(b3[0]._id).to.be.a('string');
      expect(b3[0]._key).to.be.a('string');
      expect(b3[0]._rev).to.be.a('string');
      expect(b3[0]._oldRev).to.be.a('string');

      res = collection.insert({
        "Hallo": 12
      });

      let req4 = request.patch("/_api/document/" + cn + "?returnNew=true",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 14,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req4.statusCode).to.equal(202);

      let b4 = JSON.parse(req4.rawBody);

      expect(b4).to.be.instanceof(Array);
      expect(b4).to.have.lengthOf(1);
      expect(b4[0]).to.be.a('object');
      expect(Object.keys(b4[0])).to.have.lengthOf(5);
      expect(b4[0]._id).to.be.a('string');
      expect(b4[0]._key).to.be.a('string');
      expect(b4[0]._rev).to.be.a('string');
      expect(b4[0]._oldRev).to.be.a('string');
      expect(b4[0]["new"]).to.be.a('object');
      expect(Object.keys(b4[0]["new"])).to.have.lengthOf(4);
      expect(b4[0]["new"].Hallo).to.equal(14);

      res = collection.insert({
        "Hallo": 12
      });

      let req5 = request.patch("/_api/document/" + cn + "?returnNew=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 15,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req5.statusCode).to.equal(202);

      let b5 = JSON.parse(req5.rawBody);

      expect(b5).to.be.instanceof(Array);
      expect(b5).to.have.lengthOf(1);
      expect(b5[0]).to.be.a('object');
      expect(Object.keys(b5[0])).to.have.lengthOf(4);
      expect(b5[0]._id).to.be.a('string');
      expect(b5[0]._key).to.be.a('string');
      expect(b5[0]._rev).to.be.a('string');
      expect(b5[0]._oldRev).to.be.a('string');

      res = collection.insert({
        "Hallo": 12
      });

      let req6 = request.patch("/_api/document/" + cn + "?returnNew=true&returnOld=true",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 16,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req6.statusCode).to.equal(202);

      let b6 = JSON.parse(req6.rawBody);

      expect(b6).to.be.instanceof(Array);
      expect(b6).to.have.lengthOf(1);
      expect(b6[0]).to.be.a('object');
      expect(Object.keys(b6[0])).to.have.lengthOf(6);
      expect(b6[0]._id).to.be.a('string');
      expect(b6[0]._key).to.be.a('string');
      expect(b6[0]._rev).to.be.a('string');
      expect(b6[0]._oldRev).to.be.a('string');
      expect(b6[0].old).to.be.a('object');
      expect(Object.keys(b6[0])).to.have.lengthOf(6);
      expect(b6[0].old.Hallo).to.equal(12);
      expect(b6[0]["new"]).to.be.a('object');
      expect(Object.keys(b6[0]["new"])).to.have.lengthOf(4);
      expect(b6[0]["new"].Hallo).to.equal(16);

      res = collection.insert({
        "Hallo": 12
      });

      let req7 = request.patch("/_api/document/" + cn + "?returnNew=false&returnOld=false",
        extend(endpoint, {
          body: JSON.stringify([{
            "Hallo": 17,
            "_key": res._key,
            "_rev": res._rev
          }])
        }));

      expect(req7.statusCode).to.equal(202);

      let b7 = JSON.parse(req2.rawBody);

      expect(b7).to.be.instanceof(Array);
      expect(b7).to.have.lengthOf(1);
      expect(b7[0]).to.be.a('object');
      expect(Object.keys(b7[0])).to.have.lengthOf(5);
      expect(b7[0]._id).to.be.a('string');
      expect(b7[0]._key).to.be.a('string');
      expect(b7[0]._rev).to.be.a('string');
      expect(b7[0]._oldRev).to.be.a('string');
    });
  });
});