
'use strict';

var adapters = ['http', 'local'];

adapters.forEach(function (adapter) {

  describe('test.changes.js-' + adapter, function () {

    var dbs = {};

    // if it exists, return the single element
    // which has the specific id. Else retun null.
    // useful for finding elements within a _changes feed
    function findById(array, id) {
      var result = array.filter(function (i) {
        return i.id === id;
      });

      //
      if (result.length === 1) {
        return result[0];
      }
    }

    beforeEach(function (done) {
      dbs.name = testUtils.adapterUrl(adapter, 'testdb');
      dbs.remote = testUtils.adapterUrl(adapter, 'test_repl_remote');
      testUtils.cleanup([dbs.name, dbs.remote], done);
    });

    after(function (done) {
      testUtils.cleanup([dbs.name, dbs.remote], done);
    });

    it('All changes', function (done) {
      var db = new PouchDB(dbs.name);
      db.post({ test: 'somestuff' }, function () {
        var promise = db.changes({
          }).on('change', function (change) {
            change.should.not.have.property('doc');
            change.should.have.property('seq');
            done();
          });
        should.exist(promise);
        promise.cancel.should.be.a('function');
      });
    });

    it('Promise resolved when changes cancelled', function (done) {
      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3},
        {_id: '4', integer: 4},
        {_id: '5', integer: 5},
        {_id: '6', integer: 6},
        {_id: '7', integer: 7},
        {_id: '8', integer: 9},
        {_id: '9', integer: 9},
        {_id: '10', integer: 10}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs }, function () {
        var changeCount = 0;
        var promise = db.changes().on('change', function handler() {
          changeCount++;
          if (changeCount === 5) {
            promise.cancel();
            promise.removeListener('change', handler);
          }
        });
        should.exist(promise);
        should.exist(promise.then);
        promise.then.should.be.a('function');
        promise.then(
        function (result) {
          changeCount.should.equal(5, 'changeCount');
          should.exist(result);
          result.should.deep.equal({status: 'cancelled'});
          done();
        }, function (err) {
          changeCount.should.equal(5, 'changeCount');
          should.exist(err);
          done();
        });
      });
    });

    it('Changes Since', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3},
        {_id: '4', integer: 4},
        {_id: '5', integer: 5},
        {_id: '6', integer: 6},
        {_id: '7', integer: 7},
        {_id: '8', integer: 9},
        {_id: '9', integer: 9},
        {_id: '10', integer: 10},
        {_id: '11', integer: 11}
      ];
      var db = new PouchDB(dbs.name);

      db.bulkDocs({ docs: docs1 }, function () {
        db.info(function (err, info) {
          var update_seq = info.update_seq;

          var docs2 = [
            {_id: '12', integer: 12},
            {_id: '13', integer: 13}
          ];

          db.bulkDocs({ docs: docs2 }, function () {
            var promise = db.changes({
              since: update_seq
            }).on('complete', function (results) {
              results.results.length.should.be.at.least(2);
              done();
            });
            should.exist(promise);
            promise.cancel.should.be.a('function');
          });
        });
      });
    });

    it('Changes Since and limit limit 1', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs1 }, function () {
        db.info(function (err, info) {
          var update_seq = info.update_seq;

          var docs2 = [
            {_id: '3', integer: 3},
            {_id: '4', integer: 4}
          ];

          db.bulkDocs({ docs: docs2 }, function () {
            db.changes({
              since: update_seq,
              limit: 1
            }).on('complete', function (results) {
              results.results.length.should.equal(1);
              done();
            });
          });
        });
      });
    });

    it('Changes Since and limit limit 0', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs1 }, function () {
        db.info(function (err, info) {
          var update_seq = info.update_seq;

          var docs2 = [
            {_id: '3', integer: 3},
            {_id: '4', integer: 4}
          ];

          db.bulkDocs({ docs: docs2 }, function () {
            db.changes({
              since: update_seq,
              limit: 0
            }).on('complete', function (results) {
              results.results.length.should.equal(1);
              done();
            });
          });
        });
      });
    });

    it('Changes limit', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var docs2 = [
        {_id: '2', integer: 11},
        {_id: '3', integer: 12}
      ];
      var db = new PouchDB(dbs.name);
      // we use writeDocs since bulkDocs looks to have undefined
      // order of doing insertions
      testUtils.writeDocs(db, docs1, function (err, info) {
        docs2[0]._rev = info[2].rev;
        docs2[1]._rev = info[3].rev;

        db.info(function (err, info) {
          var update_seq = info.update_seq;

          db.put(docs2[0], function (err, info) {
            docs2[0]._rev = info.rev;
            db.put(docs2[1], function (err, info) {
              docs2[1]._rev = info.rev;
              db.changes({
                limit: 2,
                since: update_seq,
                include_docs: true
              }).on('complete', function (results) {
                results = results.results;
                results.length.should.equal(2);

                // order is not guaranteed
                var first = results[0];
                var second = results[1];
                if (first.id === '3') {
                  second = first;
                  first = results[1];
                }
                first.id.should.equal('2');
                first.doc.integer.should.equal(docs2[0].integer);
                first.doc._rev.should.equal(docs2[0]._rev);
                second.id.should.equal('3');
                second.doc.integer.should.equal(docs2[1].integer);
                second.doc._rev.should.equal(docs2[1]._rev);
                done();
              });
            });
          });
        });
      });
    });

    it('Changes with filter not present in ddoc', function (done) {
      this.timeout(15000);
      var docs = [
        {_id: '1', integer: 1},
        { _id: '_design/foo',
          integer: 4,
          filters: { even: 'function (doc) { return doc.integer % 2 === 1; }' }
        }
      ];
      var db = new PouchDB(dbs.name);
      testUtils.writeDocs(db, docs, function () {
        db.changes({
          filter: 'foo/odd',
          limit: 2,
          include_docs: true
        }).on('error', function (err) {
          err.name.should.equal('not_found');
          err.status.should.equal(testUtils.errors.MISSING_DOC.status,
                                  'correct error status returned');
          done();
        });
      });
    });

    it('Changes with `filters` key not present in ddoc', function (done) {
      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {
          _id: '_design/foo',
          integer: 4,
          views: {
            even: {
              map: 'function (doc) { if (doc.integer % 2 === 1)' +
               ' { emit(doc._id, null) }; }'
            }
          }
        }
      ];
      var db = new PouchDB(dbs.name);
      testUtils.writeDocs(db, docs, function () {
        db.changes({
          filter: 'foo/even',
          limit: 2,
          include_docs: true
        }).on('error', function (err) {
          err.status.should.equal(testUtils.errors.MISSING_DOC.status,
                                  'correct error status returned');
          err.name.should.equal('not_found');
          done();
        });
      });
    });

    it('Changes limit and filter', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2}
      ];
      var db = new PouchDB(dbs.name);

      var docs2 = [
        {_id: '3', integer: 3},
        {_id: '4', integer: 4},
        {_id: '5', integer: 5},
        {
          _id: '_design/foo',
          integer: 4,
          filters: { even: 'function (doc) { return doc.integer % 2 === 1; }' }
        }
      ];

      db.bulkDocs({ docs: docs1 }, function () {
        db.info(function (err, info) {
          var update_seq = info.update_seq;

          testUtils.writeDocs(db, docs2, function () {
            var promise = db.changes({
              filter: 'foo/even',
              limit: 2,
              since: update_seq,
              include_docs: true
            }).on('complete', function (results) {
              results.results.length.should.equal(2);
              var three = findById(results.results, '3');
              three.doc.integer.should.equal(3);
              var five = findById(results.results, '5');
              five.doc.integer.should.equal(5);
              done();
            }).on('error', done);
            should.exist(promise);
            promise.cancel.should.be.a('function');
          });
        });
      });
    });

    it('Changes with shorthand function name', function (done) {
      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {
          _id: '_design/even',
          integer: 3,
          filters: { even: 'function (doc) { return doc.integer % 2 === 0; }' }
        }
      ];
      var db = new PouchDB(dbs.name);

      db.bulkDocs({ docs: docs }, function () {
        var promise = db.changes({
          filter: 'even',
          include_docs: true
        }).on('complete', function (results) {
          results.results.length.should.equal(2);
          var zero = findById(results.results, '0');
          zero.doc.integer.should.equal(0);
          var two = findById(results.results, '2');
          two.doc.integer.should.equal(2);
          done();
        }).on('error', done);
        should.exist(promise);
        promise.cancel.should.be.a('function');
      });
    });

    it('Changes with filter from nonexistent ddoc', function (done) {
      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1}
      ];
      var db = new PouchDB(dbs.name);
      testUtils.writeDocs(db, docs, function () {
        db.changes({
          filter: 'foobar/odd'
        }).on('error', function (err) {
          should.exist(err);
          done();
        });
      });
    });

    it('Changes with view not present in ddoc', function (done) {
      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {
          _id: '_design/foo',
          integer: 4,
          views:
            { even:
              { map: 'function (doc) { if (doc.integer % 2 === 1) { ' +
                     'emit(doc._id, null) }; }' } }
        }
      ];
      var db = new PouchDB(dbs.name);
      testUtils.writeDocs(db, docs, function () {
        db.changes({
          filter: '_view',
          view: 'foo/odd'
        }).on('error', function (err) {
          err.status.should.equal(testUtils.errors.MISSING_DOC.status,
                                  'correct error status returned');
          err.name.should.equal('not_found');
          done();
        });
      });
    });

    it('Changes with `views` key not present in ddoc', function (done) {
      var docs = [
        {_id: '1', integer: 1},
        {
          _id: '_design/foo',
          integer: 4,
          filters: { even: 'function (doc) { return doc.integer % 2 === 1; }' }
        }
      ];
      var db = new PouchDB(dbs.name);
      testUtils.writeDocs(db, docs, function () {
        db.changes({
          filter: '_view',
          view: 'foo/even'
        }).on('error', function (err) {
          err.status.should.equal(testUtils.errors.MISSING_DOC.status,
                                  'correct error status returned');
          err.name.should.equal('not_found');
          done();
        });
      });
    });

    it('#4451 Changes with invalid view filter', function (done) {
      var docs = [
        {_id: '1', integer: 1},
        {
          _id: '_design/foo',
          filters: { even: 'function (doc) { return doc.integer % 2 === 1; }' }
        }
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs(docs).then(function () {
        db.changes({filter: 'a/b/c'}).on('error', function () {
          done('should not be called');
        }).on('complete', function () {
          done();
        });
      });
    });

    it('3356 throw inside a filter', function (done) {
      var db = new PouchDB(dbs.name);
      db.put({
        _id: "_design/test",
        filters: {
          test: function () {
            throw new Error(); // syntaxerrors can't be caught either.
          }.toString()
        }
      }).should.eventually.be.fulfilled.then(function () {
        return db.changes({filter: 'test/test'}).should.eventually.be.rejected;
      }).then(function () {
        done();
      }).catch(function (err) {
        done('We had an error - ' + err);
      });
    });

    it('Changes with missing param `view` in request', function (done) {
      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {
          _id: '_design/foo',
          integer: 4,
          views: { even: { map: 'function (doc) { if (doc.integer % 2 === 1) ' +
                           '{ emit(doc._id, null) }; }' } }
        }
      ];
      var db = new PouchDB(dbs.name);
      testUtils.writeDocs(db, docs, function () {
        db.changes({
          filter: '_view'
        }).on('error', function (err) {
          err.status.should.equal(testUtils.errors.BAD_REQUEST.status,
                                  'correct error status returned');
          err.name.should.equal('bad_request');
          done();
        });
      });
    });

    it('Changes limit and view instead of filter', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs1 }, function () {
        db.info(function (err, info) {
          var update_seq = info.update_seq;

          var docs2 = [
            {_id: '3', integer: 3},
            {_id: '4', integer: 4},
            {_id: '5', integer: 5},
            {
              _id: '_design/foo',
              integer: 4,
              views: { even: { map: 'function (doc) ' +
                '{ if (doc.integer % 2 === 1) ' +
                '{ emit(doc._id, null) }; }'
                }
              }
            }
          ];

          db.bulkDocs({ docs: docs2 }, function () {

            db.changes({
              filter: '_view',
              view: 'foo/even',
              limit: 2,
              since: update_seq,
              include_docs: true
            }).on('complete', function (results) {
              var changes = results.results;
              changes.length.should.equal(2);

              findById(changes, '3')
                .doc.integer.should.equal(3);

              findById(changes, '5')
                .doc.integer.should.equal(5);

              done();
            }).on('error', done);
          });
        });
      });
    });

    it('#3609 view option implies filter: _view', function () {
      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '_design/foo', integer: 3,
         views: {
           even: {
             map: 'function (doc) { if (doc.integer % 2 === 1) ' +
               '{ emit(doc._id, null) }; }'
           }
         }
        }
      ];

      var db = new PouchDB(dbs.name);
      return db.bulkDocs(docs).then(function () {
        return db.changes({view: 'foo/even'});
      }).then(function (changes) {
        changes.results.length.should.equal(2);
      });
    });

    it('Changes last_seq', function (done) {
      // this test doesn't really make sense for clustered
      // CouchDB because changes is unordered and last_seq might
      // not equal the last seq in the _changes feed (although it
      // should evaluate to the same thing on the server).
      if (testUtils.isCouchMaster()) {
        return done();
      }

      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3},
        {
          _id: '_design/foo',
          integer: 4,
          filters: { even: 'function (doc) { return doc.integer % 2 === 1; }' }
        }
      ];
      var db = new PouchDB(dbs.name);
      db.changes().on('complete', function (results) {
        results.last_seq.should.equal(0);
        db.bulkDocs({ docs: docs }, function () {
          db.changes().on('complete', function (results) {
            results.last_seq.should.equal(5);
            db.changes({
              filter: 'foo/even'
            }).on('complete', function (results) {
              results.last_seq.should.equal(5);
              results.results.length.should.equal(2);
              done();
            }).on('error', done);
          }).on('error', done);
        });
      }).on('error', done);
    });

    it('Immediately cancel changes', function () {
      // fixes code coverage by ensuring the changes() listener
      // emits 'complete' even if the db's task queue isn't
      // ready yet
      return new testUtils.Promise(function (resolve, reject) {
        var db = new PouchDB(dbs.name);
        var changes = db.changes({live: true});
        changes.on('error', reject);
        changes.on('complete', resolve);
        changes.cancel();
      });
    });

    it('Changes with invalid ddoc view name', function () {
      return new testUtils.Promise(function (resolve, reject) {
        var db = new PouchDB(dbs.name);
        db.post({});
        var changes = db.changes({live: true, filter: '_view', view: ''});
        changes.on('error', resolve);
        changes.on('change', reject);
      });
    });

    it('Changes with invalid ddoc view name 2', function () {
      return new testUtils.Promise(function (resolve, reject) {
        var db = new PouchDB(dbs.name);
        db.post({});
        var changes = db.changes({live: true, filter: '_view', view: 'a/b/c'});
        changes.on('error', resolve);
        changes.on('change', reject);
      });
    });

    if (adapter === 'local') {
      // This test crashes due to an invalid JSON response from CouchDB:
      // https://issues.apache.org/jira/browse/COUCHDB-2765
      // We could remove the "if" check and put a try/catch in our
      // JSON parsing, but since this is a super-rare bug it may not be
      // worth our time. This test does increase code coverage for our
      // own local code, though.
      it('Changes with invalid ddoc with no map function', function () {
        // CouchDB 2.X does not allow saving of invalid design docs,
        // so this test is not valid
        if (testUtils.isCouchMaster()) {
          return testUtils.Promise.resolve();
        }

        var db = new PouchDB(dbs.name);
        return db.put({
          _id: '_design/name',
          views: {
            name: {
              empty: 'sad face'
            }
          }
        }).then(function () {
          return new testUtils.Promise(function (resolve, reject) {
            var changes = db.changes({
              live: true,
              filter: '_view',
              view: 'name/name'
            });
            changes.on('error', resolve);
            changes.on('change', reject);
          });
        });
      });
    }

    it('Changes with invalid ddoc with no filter function', function () {
      // CouchDB 2.X does not allow saving of invalid design docs,
      // so this test is not valid
      if (testUtils.isCouchMaster()) {
        return testUtils.Promise.resolve();
      }

      var db = new PouchDB(dbs.name);
      return db.put({
        _id: '_design/name',
        views: {
          name: {
            empty: 'sad face'
          }
        }
      }).then(function () {
        return new testUtils.Promise(function (resolve, reject) {
          var changes = db.changes({
            live: true,
            filter: 'name/name'
          });
          changes.on('error', resolve);
          changes.on('change', reject);
        });
      });
    });

    it('Changes last_seq with view instead of filter', function (done) {
      // this test doesn't really make sense for clustered
      // CouchDB because changes is unordered and last_seq might
      // not equal the last seq in the _changes feed (although it
      // should evaluate to the same thing on the server).
      if (testUtils.isCouchMaster()) {
        return done();
      }

      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3},
        {
          _id: '_design/foo',
          integer: 4,
          views:
            { even:
              { map: 'function (doc) { if (doc.integer % 2 === 1) { ' +
                     'emit(doc._id, null) }; }' } }
        }
      ];
      var db = new PouchDB(dbs.name);
      db.changes().on('complete', function (results) {
        results.last_seq.should.equal(0);
        db.bulkDocs({ docs: docs }, function () {
          db.changes().on('complete', function (results) {
            results.last_seq.should.equal(5);
            db.changes({
              filter: '_view',
              view: 'foo/even'
            }).on('complete', function (results) {
              results.last_seq.should.equal(5);
              results.results.length.should.equal(2);
              done();
            }).on('error', done);
          }).on('error', done);
        });
      }).on('error', done);
    });

    it('Changes with style = all_docs', function (done) {
      var simpleTree = [
        [{_id: 'foo', _rev: '1-a', value: 'foo a'},
         {_id: 'foo', _rev: '2-b', value: 'foo b'},
         {_id: 'foo', _rev: '3-c', value: 'foo c'}],
        [{_id: 'foo', _rev: '1-a', value: 'foo a'},
         {_id: 'foo', _rev: '2-d', value: 'foo d'},
         {_id: 'foo', _rev: '3-e', value: 'foo e'},
         {_id: 'foo', _rev: '4-f', value: 'foo f'}],
        [{_id: 'foo', _rev: '1-a', value: 'foo a'},
         {_id: 'foo', _rev: '2-g', value: 'foo g', _deleted: true}]
      ];
      var db = new PouchDB(dbs.name);
      testUtils.putTree(db, simpleTree, function () {
        db.changes().on('complete', function (res) {
          res.results[0].changes.length.should.equal(1);
          res.results[0].changes[0].rev.should.equal('4-f');
          db.changes({
            style: 'all_docs'
          }).on('complete', function (res) {
            res.results[0].changes.length.should.equal(3);
            var changes = res.results[0].changes;
            changes.sort(function (a, b) {
              return a.rev < b.rev;
            });
            changes[0].rev.should.equal('4-f');
            changes[1].rev.should.equal('3-c');
            changes[2].rev.should.equal('2-g');
            done();
          }).on('error', done);
        }).on('error', done);
      });
    });

    it('Changes with style = all_docs and a callback for complete',
      function (done) {
      var simpleTree = [
        [{_id: 'foo', _rev: '1-a', value: 'foo a'},
         {_id: 'foo', _rev: '2-b', value: 'foo b'},
         {_id: 'foo', _rev: '3-c', value: 'foo c'}],
        [{_id: 'foo', _rev: '1-a', value: 'foo a'},
         {_id: 'foo', _rev: '2-d', value: 'foo d'},
         {_id: 'foo', _rev: '3-e', value: 'foo e'},
         {_id: 'foo', _rev: '4-f', value: 'foo f'}],
        [{_id: 'foo', _rev: '1-a', value: 'foo a'},
         {_id: 'foo', _rev: '2-g', value: 'foo g', _deleted: true}]
      ];
      var db = new PouchDB(dbs.name);
      testUtils.putTree(db, simpleTree, function () {
        db.changes(function (err, res) {
          res.results[0].changes.length.should.equal(1);
          res.results[0].changes[0].rev.should.equal('4-f');
          db.changes({
            style: 'all_docs'
          }, function (err, res) {
            should.not.exist(err);
            res.results[0].changes.length.should.equal(3);
            var changes = res.results[0].changes;
            changes.sort(function (a, b) {
              return a.rev < b.rev;
            });
            changes[0].rev.should.equal('4-f');
            changes[1].rev.should.equal('3-c');
            changes[2].rev.should.equal('2-g');
            done();
          });
        });
      });
    });

    it('Changes limit = 0', function (done) {
      var docs = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs }, function () {
        db.changes({
          limit: 0
        }).on('complete', function (results) {
          results.results.length.should.equal(1);
          done();
        }).on('error', done);
      });
    });

    // Note for the following test that CouchDB's implementation of /_changes
    // with `descending=true` ignores any `since` parameter.
    it('Descending changes', function (done) {
      // _changes in CouchDB 2.0 does not guarantee order
      // so skip this test
      if (testUtils.isCouchMaster()) {
        return done();
      }
      var db = new PouchDB(dbs.name);
      db.post({_id: '0', test: 'ing'}, function () {
        db.post({_id: '1', test: 'ing'}, function () {
          db.post({_id: '2', test: 'ing'}, function () {
            db.changes({
              descending: true,
              since: 1
            }).on('complete', function (results) {
              results.results.length.should.equal(3);
              var ids = ['2', '1', '0'];
              results.results.forEach(function (row, i) {
                row.id.should.equal(ids[i]);
              });
              done();
            }).on('error', done);
          });
        });
      });
    });

    it('Changes doc', function (done) {
      var db = new PouchDB(dbs.name);
      db.post({ test: 'somestuff' }, function () {
        db.changes({
          include_docs: true
        }).on('change', function (change) {
          change.doc._id.should.equal(change.id);
          change.doc._rev.should
            .equal(change.changes[change.changes.length - 1].rev);
          done();
        });
      });
    });

    // Note for the following test that CouchDB's implementation of /_changes
    // with `descending=true` ignores any `since` parameter.
    it('Descending many changes', function (done) {
      var db = new PouchDB(dbs.name);
      var docs = [];
      var num = 100;
      for (var i = 0; i < num; i++) {
        docs.push({
          _id: 'doc_' + i,
          foo: 'bar_' + i
        });
      }
      var changes = 0;
      db.bulkDocs({ docs: docs }, function (err) {
        if (err) {
          return done(err);
        }
        db.changes({
          descending: true
        }).on('change', function () {
          changes++;
        }).on('complete', function () {
          changes.should.equal(num, 'correct number of changes');
          done();
        }).on('error', function (err) {
          done(err);
        });
      });
    });

    it('changes w/ many modifications of same doc', function () {
      var db = new PouchDB(dbs.name);
      var promise = testUtils.Promise.resolve();
      var doc = {_id: '1'};
      function modifyDoc() {
        return db.put(doc).then(function (res) {
          doc._rev = res.rev;
        });
      }
      for (var i  = 0; i < 5; i++) {
        promise = promise.then(modifyDoc);
      }
      return promise.then(function () {
        return db.bulkDocs([
          {_id: '2'},
          {_id: '3'},
          {_id: '4'},
          {_id: '5'}
        ]);
      }).then(function () {
        return db.changes({since: 0, limit: 3}).then(function (res) {
          res.results.map(function (x) {
            delete x.changes;
            delete x.seq;
            return x;
          }).should.deep.equal([
            { "id": "1" },
            { "id": "2" },
            { "id": "3" }
          ]);
        });
      });
    });

    it('live-changes', function (done) {
      var db = new PouchDB(dbs.name);
      var count = 0;
      var changes = db.changes({
        live: true
      }).on('complete', function () {
        count.should.equal(1);
        done();
      }).on('change', function (change) {
        count += 1;
        change.should.not.have.property('doc');
        count.should.equal(1);
        changes.cancel();
      });
      db.post({ test: 'adoc' });
    });

    it('Multiple watchers', function (done) {
      var db = new PouchDB(dbs.name);
      var count = 0;
      var changes1Complete = false;
      var changes2Complete = false;
      function checkCount() {
        if (changes1Complete && changes2Complete) {
          count.should.equal(2);
          done();
        }
      }
      var changes1 = db.changes({
        live: true
      }).on('complete', function () {
        changes1Complete = true;
        checkCount();
      }).on('change', function () {
        count += 1;
        changes1.cancel();
        changes1 = null;
      }).on('error', done);
      var changes2 = db.changes({
        live: true
      }).on('complete', function () {
        changes2Complete = true;
        checkCount();
      }).on('change', function () {
        count += 1;
        changes2.cancel();
        changes2 = null;
      }).on('error', done);
      db.post({test: 'adoc'});
    });

    it('Continuous changes doc', function (done) {
      var db = new PouchDB(dbs.name);
      var changes = db.changes({
        live: true,
        include_docs: true
      }).on('complete', function (result) {
        result.status.should.equal('cancelled');
        done();
      }).on('change', function (change) {
        change.should.have.property('doc');
        change.doc.should.have.property('_rev');
        changes.cancel();
      }).on('error', done);
      db.post({ test: 'adoc' });
    });

    it('Cancel changes', function (done) {
      var db = new PouchDB(dbs.name);
      var count = 0;
      var interval;
      var docPosted = false;

      // We want to wait for a period of time after the final
      // document was posted to ensure we didnt see another
      // change
      function waitForDocPosted() {
        if (!docPosted) {
          return;
        }
        clearInterval(interval);
        setTimeout(function () {
          count.should.equal(1);
          done();
        }, 200);
      }

      var changes = db.changes({
        live: true
      }).on('complete', function (result) {
        result.status.should.equal('cancelled');
        // This setTimeout ensures that once we cancel a change we dont recieve
        // subsequent callbacks, so it is needed
        interval = setInterval(waitForDocPosted, 100);
      }).on('change', function () {
        count += 1;
        if (count === 1) {
          changes.cancel();
          db.post({ test: 'another doc' }, function (err) {
            if (err) {
              return done(err);
            }
            docPosted = true;
          });
        }
      });
      db.post({ test: 'adoc' });
    });


    it("#3579 changes firing 1 too many times", function () {
      var db = new PouchDB(dbs.name);
      var Promise = testUtils.Promise;
      return db.bulkDocs([{}, {}, {}]).then(function () {
        var changes = db.changes({
          since: 'now',
          live: true,
          include_docs: true
        });
        return Promise.all([
          new Promise(function (resolve, reject) {
            changes.on('error', reject);
            changes.on('change', function (change) {
              changes.cancel();
              resolve(change);
            });
          }),
          new Promise(function (resolve) {
            setTimeout(resolve, 50);
          }).then(function () {
              return db.put({_id: 'foobar'});
            })
        ]);
      }).then(function (result) {
        var change = result[0];
        change.id.should.equal('foobar');
        change.doc._id.should.equal('foobar');
      });
    });

    it('Kill database while listening to live changes', function (done) {
      var db = new PouchDB(dbs.name);

      db.changes({live: true})
        .on('error', function () { done(); })
        .on('complete', function () { done(); })
        .on('change', function () { db.destroy().catch(done); });

      db.post({ test: 'adoc' });
    });

    it('#3136 style=all_docs', function () {

      var db = new PouchDB(dbs.name);

      var chain = testUtils.Promise.resolve();

      var docIds = ['b', 'c', 'a', 'z', 'd', 'e'];

      docIds.forEach(function (docId) {
        chain = chain.then(function () {
          return db.put({_id: docId});
        });
      });

      return chain.then(function () {
        return db.changes({style: 'all_docs'});
      }).then(function (res) {
        var ids = res.results.map(function (x) {
          return x.id;
        });
        ids.should.include.members(docIds);
      });
    });

    it('#4191 revs_diff causes endless loop', function () {
      var db = new PouchDB(dbs.name, {auto_compaction: false});
      return db.bulkDocs({
        "new_edits": false,
        "docs": [{"_id": "799","_rev":"1-d22"}
        ]}).then(function () {
        return db.bulkDocs({
          "new_edits": false,
          "docs": [{"_id": "3E1", "_rev": "1-ab5"}]
        });
      }).then(function () {
        return db.bulkDocs(
          { new_edits: false,
            docs:
              [ { _id: 'FB3', _rev: '1-363' },
                { _id: '27C', _rev: '1-4c3' },
                { _id: 'BD6', _rev: '1-de0' },
                { _id: '1E9', _rev: '1-451' } ] }
        );
      }).then(function () {
        return db.changes({style: 'all_docs', limit: 100});
      }).then(function (res) {
        var lastSeq = res.last_seq;
        return db.changes({since: lastSeq, style: 'all_docs', limit: 100});
      }).then(function (res) {
        res.results.should.have.length(0);
      });
    });

    it('#3136 style=all_docs & include_docs', function () {

      var db = new PouchDB(dbs.name);

      var chain = testUtils.Promise.resolve();

      var docIds = ['b', 'c', 'a', 'z', 'd', 'e'];

      docIds.forEach(function (docId) {
        chain = chain.then(function () {
          return db.put({_id: docId});
        });
      });

      return chain.then(function () {
        return db.changes({
          style: 'all_docs',
          include_docs: true
        });
      }).then(function (res) {
        var ids = res.results.map(function (x) {
          return x.id;
        });
        ids.should.include.members(docIds);
      });
    });

    it('#3136 tricky changes, limit/descending', function () {
      if (testUtils.isCouchMaster()) {
        return true;
      }

      var db = new PouchDB(dbs.name);

      var docs = [
        {
          _id: 'alpha',
          _rev: '1-a',
          _revisions: {
            start: 1,
            ids: ['a']
          }
        }, {
          _id: 'beta',
          _rev: '1-b',
          _revisions: {
            start: 1,
            ids: ['b']
          }
        }, {
          _id: 'gamma',
          _rev: '1-b',
          _revisions: {
            start: 1,
            ids: ['b']
          }
        }, {
          _id: 'alpha',
          _rev: '2-d',
          _revisions: {
            start: 2,
            ids: ['d', 'a']
          }
        }, {
          _id: 'beta',
          _rev: '2-e',
          _revisions: {
            start: 2,
            ids: ['e', 'b']
          }
        }, {
          _id: 'beta',
          _rev: '3-f',
          _deleted: true,
          _revisions: {
            start: 3,
            ids: ['f', 'e', 'b']
          }
        }
      ];

      var chain = testUtils.Promise.resolve();
      var seqs = [];

      docs.forEach(function (doc) {
        chain = chain.then(function () {
          return db.bulkDocs([doc], {new_edits: false}).then(function () {
            return db.changes({doc_ids: [doc._id]});
          }).then(function (res) {
            seqs.push(res.results[0].seq);
          });
        });
      });

      function normalizeResult(result) {
        // order of changes doesn't matter
        result.results.forEach(function (ch) {
          ch.changes = ch.changes.sort(function (a, b) {
            return a.rev < b.rev ? -1 : 1;
          });
        });
      }

      return chain.then(function () {
        return db.changes();
      }).then(function (result) {
        normalizeResult(result);
        result.should.deep.equal({
          "results": [
            {
              "seq": seqs[2],
              "id": "gamma",
              "changes": [{ "rev": "1-b"}
              ]
            },
            {
              "seq": seqs[3],
              "id": "alpha",
              "changes": [{ "rev": "2-d"}
              ]
            },
            {
              "seq": seqs[5],
              "id": "beta",
              "deleted": true,
              "changes": [{ "rev": "3-f"}
              ]
            }
          ],
          "last_seq": seqs[5]
        });
        return db.changes({limit: 0});
      }).then(function (result) {
        normalizeResult(result);
        result.should.deep.equal({
          "results": [{
            "seq": seqs[2],
            "id": "gamma",
            "changes": [{"rev": "1-b"}]
          }],
          "last_seq": seqs[2]
        }, '1:' + JSON.stringify(result));
        return db.changes({limit: 1});
      }).then(function (result) {
        normalizeResult(result);
        result.should.deep.equal({
          "results": [{
            "seq": seqs[2],
            "id": "gamma",
            "changes": [{"rev": "1-b"}]
          }],
          "last_seq": seqs[2]
        }, '2:' + JSON.stringify(result));
        return db.changes({limit: 2});
      }).then(function (result) {
        normalizeResult(result);
        result.should.deep.equal({
          "results": [{
            "seq": seqs[2],
            "id": "gamma",
            "changes": [{"rev": "1-b"}]
          }, {"seq": seqs[3], "id": "alpha", "changes": [{"rev": "2-d"}]}],
          "last_seq": seqs[3]
        }, '3:' + JSON.stringify(result));
        return db.changes({limit: 1, descending: true});
      }).then(function (result) {
        normalizeResult(result);
        result.should.deep.equal({
          "results": [{
            "seq": seqs[5],
            "id": "beta",
            "changes": [{"rev": "3-f"}],
            "deleted": true
          }],
          "last_seq": seqs[5]
        }, '4:' + JSON.stringify(result));
        return db.changes({limit: 2, descending: true});
      }).then(function (result) {
        normalizeResult(result);
        var expected = {
          "results": [{
            "seq": seqs[5],
            "id": "beta",
            "changes": [{"rev": "3-f"}],
            "deleted": true
          }, {"seq": seqs[3], "id": "alpha", "changes": [{"rev": "2-d"}]}],
          "last_seq": seqs[3]
        };
        result.should.deep.equal(expected, '5:' + JSON.stringify(result) +
        ', shoulda got: ' + JSON.stringify(expected));
        return db.changes({descending: true});
      }).then(function (result) {
        normalizeResult(result);
        var expected = {
          "results": [{
            "seq": seqs[5],
            "id": "beta",
            "changes": [{"rev": "3-f"}],
            "deleted": true
          }, {"seq": seqs[3], "id": "alpha", "changes": [{"rev": "2-d"}]}, {
            "seq": seqs[2],
            "id": "gamma",
            "changes": [{"rev": "1-b"}]
          }],
          "last_seq": seqs[2]
        };
        result.should.deep.equal(expected, '6:' + JSON.stringify(result) +
        ', shoulda got: ' + JSON.stringify(expected));
      });
    });

    it('#3176 winningRev has a lower seq, descending', function () {
      if (testUtils.isCouchMaster()) {
        return true;
      }

      var db = new PouchDB(dbs.name);
      var tree = [
        [
          {
            _id: 'foo',
            _rev: '1-a',
            _revisions: {start: 1, ids: ['a']}
          },
          {
            _id: 'foo',
            _rev: '2-e',
            _deleted: true,
            _revisions: {start: 2, ids: ['e', 'a']}
          },
          {
            _id: 'foo',
            _rev: '3-g',
            _revisions: {start: 3, ids: ['g', 'e', 'a']}
          }
        ],
        [
          {
            _id: 'foo',
            _rev: '1-a',
            _revisions: {start: 1, ids: ['a']}
          },
          {
            _id: 'foo',
            _rev: '2-b',
            _revisions: {start: 2, ids: ['b', 'a']}
          },
          {
            _id: 'foo',
            _rev: '3-c',
            _revisions: {start: 3, ids: ['c', 'b', 'a']}
          }
        ]
      ];

      var chain = testUtils.Promise.resolve();
      var seqs = [0];

      function getExpected(i) {
        var expecteds = [
          {
            "results": [
              {
                "seq": seqs[1],
                "id": "foo",
                "changes": [{"rev": "3-g"}]
              }
            ],
            "last_seq" : seqs[1]
          },
          {
            "results": [
              {
                "seq": seqs[2],
                "id": "foo",
                "changes": [{"rev": "3-g"}]
              }
            ],
            "last_seq" : seqs[2]
          }
        ];
        return expecteds[i];
      }

      function normalizeResult(result) {
        // order of changes doesn't matter
        result.results.forEach(function (ch) {
          ch.changes = ch.changes.sort(function (a, b) {
            return a.rev < b.rev ? -1 : 1;
          });
        });
      }

      tree.forEach(function (docs, i) {
        chain = chain.then(function () {
          return db.bulkDocs(docs, {new_edits: false}).then(function () {
            return db.changes({
              descending: true
            });
          }).then(function (result) {
            seqs.push(result.last_seq);
            var expected = getExpected(i);
            normalizeResult(result);
            result.should.deep.equal(expected,
            i + ': should get: ' + JSON.stringify(expected) +
            ', but got: ' + JSON.stringify(result));
          });
        });
      });
      return chain;
    });

    it('#3136 winningRev has a lower seq, style=all_docs', function () {
      if (testUtils.isCouchMaster()) {
        return true;
      }

      var db = new PouchDB(dbs.name);
      var tree = [
        [
          {
            _id: 'foo',
            _rev: '1-a',
            _revisions: {start: 1, ids: ['a']}
          },
          {
            _id: 'foo',
            _rev: '2-e',
            _deleted: true,
            _revisions: {start: 2, ids: ['e', 'a']}
          },
          {
            _id: 'foo',
            _rev: '3-g',
            _revisions: {start: 3, ids: ['g', 'e', 'a']}
          }
        ],
        [
          {
            _id: 'foo',
            _rev: '1-a',
            _revisions: {start: 1, ids: ['a']}
          },
          {
            _id: 'foo',
            _rev: '2-b',
            _revisions: {start: 2, ids: ['b', 'a']}
          },
          {
            _id: 'foo',
            _rev: '3-c',
            _revisions: {start: 3, ids: ['c', 'b', 'a']}
          }
        ],
        [
          {
            _id: 'foo',
            _rev: '1-a',
            _revisions: {start: 1, ids: ['a']}
          },
          {
            _id: 'foo',
            _rev: '2-d',
            _revisions: {start: 2, ids: ['d', 'a']}
          },
          {
            _id: 'foo',
            _rev: '3-h',
            _revisions: {start: 3, ids: ['h', 'd', 'a']}
          },
          {
            _id: 'foo',
            _rev: '4-f',
            _revisions: {start: 4, ids: ['f', 'h', 'd', 'a']}
          }
        ]
      ];

      var chain = testUtils.Promise.resolve();
      var seqs = [0];

      function getExpected(i) {
        var expecteds = [
          {
            "results": [
              {
                "seq": seqs[1],
                "id": "foo",
                "changes": [{"rev": "3-g"}],
                "doc": {"_id": "foo", "_rev": "3-g"}
              }
            ],
            "last_seq" : seqs[1]
          },
          {
            "results": [
              {
                "seq": seqs[2],
                "id": "foo",
                "changes": [{"rev": "3-c"}, {"rev": "3-g"}],
                "doc": {"_id": "foo", "_rev": "3-g"}
              }
            ],
            "last_seq" : seqs[2]
          },
          {
            "results": [
              {
                "seq": seqs[3],
                "id": "foo",
                "changes": [{"rev": "3-c"}, {"rev": "3-g"}, {"rev": "4-f"}],
                "doc": {"_id": "foo", "_rev": "4-f"}
              }
            ],
            "last_seq" : seqs[3]
          }
        ];
        return expecteds[i];
      }

      function normalizeResult(result) {
        // order of changes doesn't matter
        result.results.forEach(function (ch) {
          ch.changes = ch.changes.sort(function (a, b) {
            return a.rev < b.rev ? -1 : 1;
          });
        });
      }

      tree.forEach(function (docs, i) {
        chain = chain.then(function () {
          return db.bulkDocs(docs, {new_edits: false}).then(function () {
            return db.changes({
              style: 'all_docs',
              since: seqs[seqs.length - 1],
              include_docs: true
            });
          }).then(function (result) {
            seqs.push(result.last_seq);
            var expected = getExpected(i);
            normalizeResult(result);
            result.should.deep.equal(expected,
            i + ': should get: ' + JSON.stringify(expected) +
            ', but got: ' + JSON.stringify(result));
          });
        });
      });
      return chain;
    });

    it('#3136 winningRev has a lower seq, style=all_docs 2', function () {
      if (testUtils.isCouchMaster()) {
        return true;
      }

      var db = new PouchDB(dbs.name);
      var tree = [
        [
          {
            _id: 'foo',
            _rev: '1-a',
            _revisions: {start: 1, ids: ['a']}
          },
          {
            _id: 'foo',
            _rev: '2-e',
            _deleted: true,
            _revisions: {start: 2, ids: ['e', 'a']}
          },
          {
            _id: 'foo',
            _rev: '3-g',
            _revisions: {start: 3, ids: ['g', 'e', 'a']}
          }
        ], [
          {
            _id: 'foo',
            _rev: '1-a',
            _revisions: {start: 1, ids: ['a']}
          },
          {
            _id: 'foo',
            _rev: '2-b',
            _revisions: {start: 2, ids: ['b', 'a']}
          },
          {
            _id: 'foo',
            _rev: '3-c',
            _revisions: {start: 3, ids: ['c', 'b', 'a']}
          }
        ], [
          {
            _id: 'bar',
            _rev: '1-z',
            _revisions: {start: 1, ids: ['z']}
          }
        ]
      ];

      var chain = testUtils.Promise.resolve();
      var seqs = [0];

      tree.forEach(function (docs) {
        chain = chain.then(function () {
          return db.bulkDocs(docs, {new_edits: false}).then(function () {
            return db.changes();
          }).then(function (result) {
            seqs.push(result.last_seq);
          });
        });
      });

      return chain.then(function () {

        var expecteds = [
          {
            "results": [{
              "seq": seqs[2],
              "id": "foo",
              "changes": [{"rev": "3-c"}, {"rev": "3-g"}]
            }, {"seq": seqs[3], "id": "bar", "changes": [{"rev": "1-z"}]}],
            "last_seq": seqs[3]
          },
          {
            "results": [{
              "seq": seqs[2],
              "id": "foo",
              "changes": [{"rev": "3-c"}, {"rev": "3-g"}]
            }, {"seq": seqs[3], "id": "bar", "changes": [{"rev": "1-z"}]}],
            "last_seq": seqs[3]
          },
          {
            "results": [{"seq": seqs[3], "id": "bar",
              "changes": [{"rev": "1-z"}]}],
            "last_seq": seqs[3]
          },
          {"results": [], "last_seq": seqs[3]}
        ];

        var chain2 = testUtils.Promise.resolve();

        function normalizeResult(result) {
          // order of changes doesn't matter
          result.results.forEach(function (ch) {
            ch.changes = ch.changes.sort(function (a, b) {
              return a.rev < b.rev ? -1 : 1;
            });
          });
        }

        seqs.forEach(function (seq, i) {
          chain2 = chain2.then(function () {
            return db.changes({
              since: seq,
              style: 'all_docs'
            }).then(function (res) {
              normalizeResult(res);
              res.should.deep.equal(expecteds[i], 'since=' + seq +
              ': got: ' +
              JSON.stringify(res) +
              ', shoulda got: ' +
              JSON.stringify(expecteds[i]));
            });
          });
        });
        return chain2;
      });
    });

    it('#3136 winningRev has a higher seq, using limit', function () {
      if (testUtils.isCouchMaster()) {
        return true;
      }

      var db = new PouchDB(dbs.name);
      var tree = [
        [
          {
            _id: 'foo',
            _rev: '1-a',
            _revisions: {start: 1, ids: ['a']}
          }
        ], [
          {
            _id: 'foo',
            _rev: '2-b',
            _revisions: {start: 2, ids: ['b', 'a']}
          }
        ], [
          {
            _id: 'bar',
            _rev: '1-x',
            _revisions: {start: 1, ids: ['x']}
          }
        ], [
          {
            _id: 'foo',
            _rev: '2-c',
            _deleted: true,
            _revisions: {start: 2, ids: ['c', 'a']}
          }
        ]
      ];

      var chain = testUtils.Promise.resolve();
      var seqs = [0];

      tree.forEach(function (docs) {
        chain = chain.then(function () {
          return db.bulkDocs(docs, {new_edits: false}).then(function () {
            return db.changes().then(function (result) {
              seqs.push(result.last_seq);
            });
          });
        });
      });

      return chain.then(function () {

        var expecteds = [{
          "results": [{
            "seq": seqs[3],
            "id": "bar",
            "changes": [{"rev": "1-x"}],
            "doc": {"_id": "bar", "_rev": "1-x"}
          }],
          "last_seq": seqs[3]
        },
          {
            "results": [{
              "seq": seqs[3],
              "id": "bar",
              "changes": [{"rev": "1-x"}],
              "doc": {"_id": "bar", "_rev": "1-x"}
            }],
            "last_seq": seqs[3]
          },
          {
            "results": [{
              "seq": seqs[3],
              "id": "bar",
              "changes": [{"rev": "1-x"}],
              "doc": {"_id": "bar", "_rev": "1-x"}
            }],
            "last_seq": seqs[3]
          },
          {
            "results": [{
              "seq": seqs[4],
              "id": "foo",
              "changes": [{"rev": "2-b"}, {"rev": "2-c"}],
              "doc": {"_id": "foo", "_rev": "2-b"}
            }],
            "last_seq": seqs[4]
          },
          {"results": [], "last_seq": seqs[4]}
        ];

        var chain2 = testUtils.Promise.resolve();

        function normalizeResult(result) {
          // order of changes doesn't matter
          result.results.forEach(function (ch) {
            ch.changes = ch.changes.sort(function (a, b) {
              return a.rev < b.rev ? -1 : 1;
            });
          });
        }

        seqs.forEach(function (seq, i) {
          chain2 = chain2.then(function () {
            return db.changes({
              style: 'all_docs',
              since: seq,
              limit: 1,
              include_docs: true
            });
          }).then(function (result) {
            normalizeResult(result);
            result.should.deep.equal(expecteds[i],
              i + ': got: ' + JSON.stringify(result) +
              ', shoulda got: ' + JSON.stringify(expecteds[i]));
          });
        });
        return chain2;
      });
    });

    it('changes-filter', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var docs2 = [
        {_id: '4', integer: 4},
        {_id: '5', integer: 5},
        {_id: '6', integer: 6},
        {_id: '7', integer: 7}
      ];
      var db = new PouchDB(dbs.name);
      var count = 0;
      db.bulkDocs({ docs: docs1 }, function () {
        var changes = db.changes({
          filter: function (doc) {
            return doc.integer % 2 === 0;
          },
          live: true
        }).on('complete', function (result) {
          result.status.should.equal('cancelled');
          done();
        }).on('change', function () {
          count += 1;
          if (count === 4) {
            changes.cancel();
          }
        }).on('error', done);
        db.bulkDocs({ docs: docs2 });
      });
    });

    it('changes-filter with query params', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var docs2 = [
        {_id: '4', integer: 4},
        {_id: '5', integer: 5},
        {_id: '6', integer: 6},
        {_id: '7', integer: 7}
      ];
      var params = { 'abc': true };
      var db = new PouchDB(dbs.name);
      var count = 0;
      db.bulkDocs({ docs: docs1 }, function () {
        var changes = db.changes({
          filter: function (doc, req) {
            if (req.query.abc) {
              return doc.integer % 2 === 0;
            }
          },
          query_params: params,
          live: true
        }).on('complete', function (result) {
          result.status.should.equal('cancelled');
          done();
        }).on('change', function () {
          count += 1;
          if (count === 4) {
            changes.cancel();
          }
        }).on('error', done);
        db.bulkDocs({ docs: docs2 });
      });
    });

    it('Non-live changes filter', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs1 }, function () {
        db.changes().on('complete', function (allChanges) {
          db.changes({
            filter: function (doc) {
              return doc.integer % 2 === 0;
            }
          }).on('complete', function (filteredChanges) {
            // Should get docs 0 and 2 if the filter
            // has been applied correctly.
            filteredChanges.results.length.should.equal(2);
            filteredChanges.last_seq.should.deep.equal(allChanges.last_seq);
            done();
          }).on('error', done);
        }).on('error', done);
      });
    });

    it('Non-live changes filter, descending', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs1 }, function () {
        db.changes({
          descending: true
        }).on('complete', function (allChanges) {
          db.changes({
            descending: true,
            filter: function (doc) {
              return doc.integer > 2;
            }
          }).on('complete', function (filteredChanges) {
            // Should get docs 2 and 3 if the filter
            // has been applied correctly.
            filteredChanges.results.length.should.equal(1);
            filteredChanges.last_seq.should.deep.equal(allChanges.last_seq);
            done();
          }).on('error', done);
        }).on('error', done);
      });
    });

    it('#2569 Non-live doc_ids filter', function () {
      var docs = [
        {_id: '0'},
        {_id: '1'},
        {_id: '2'},
        {_id: '3'}
      ];
      var db = new PouchDB(dbs.name);
      return db.bulkDocs(docs).then(function () {
        return db.changes({
          doc_ids: ['1', '3']
        });
      }).then(function (changes) {
        var ids = changes.results.map(function (x) {
          return x.id;
        });
        ids.sort().should.deep.equal(['1', '3']);
      });
    });

    it('#2569 Big non-live doc_ids filter', function () {
      var docs = [];
      for (var i = 0; i < 5; i++) {
        var id = '';
        for (var j = 0; j < 50; j++) {
          // make a huge id
          id += testUtils.btoa(Math.random().toString());
        }
        docs.push({_id: id});
      }
      var db = new PouchDB(dbs.name);
      return db.bulkDocs(docs).then(function () {
        return db.changes({
          doc_ids: [docs[1]._id, docs[3]._id]
        });
      }).then(function (changes) {
        var ids = changes.results.map(function (x) {
          return x.id;
        });
        var expectedIds = [docs[1]._id, docs[3]._id];
        ids.sort().should.deep.equal(expectedIds.sort());
      });
    });

    it('#2569 Live doc_ids filter', function () {
      var docs = [
        {_id: '0'},
        {_id: '1'},
        {_id: '2'},
        {_id: '3'}
      ];
      var db = new PouchDB(dbs.name);
      return db.bulkDocs(docs).then(function () {
        return new testUtils.Promise(function (resolve, reject) {
          var retChanges = [];
          var changes = db.changes({
            doc_ids: ['1', '3'],
            live: true
          }).on('change', function (change) {
            retChanges.push(change);
            if (retChanges.length === 2) {
              changes.cancel();
              resolve(retChanges);
            }
          }).on('error', reject);
        });
      }).then(function (changes) {
        var ids = changes.map(function (x) {
          return x.id;
        });
        var expectedIds = ['1', '3'];
        ids.sort().should.deep.equal(expectedIds);
      });
    });

    it('#2569 Big live doc_ids filter', function () {
      var docs = [];
      for (var i = 0; i < 5; i++) {
        var id = '';
        for (var j = 0; j < 50; j++) {
          // make a huge id
          id += testUtils.btoa(Math.random().toString());
        }
        docs.push({_id: id});
      }
      var db = new PouchDB(dbs.name);
      return db.bulkDocs(docs).then(function () {
        return new testUtils.Promise(function (resolve, reject) {
          var retChanges = [];
          var changes = db.changes({
            doc_ids: [docs[1]._id, docs[3]._id],
            live: true
          }).on('change', function (change) {
            retChanges.push(change);
            if (retChanges.length === 2) {
              changes.cancel();
              resolve(retChanges);
            }
          }).on('error', reject);
        });
      }).then(function (changes) {
        var ids = changes.map(function (x) {
          return x.id;
        });
        var expectedIds = [docs[1]._id, docs[3]._id];
        ids.sort().should.deep.equal(expectedIds.sort());
      });
    });

    it('#2569 Non-live doc_ids filter with filter=_doc_ids', function () {
      var docs = [
        {_id: '0'},
        {_id: '1'},
        {_id: '2'},
        {_id: '3'}
      ];
      var db = new PouchDB(dbs.name);
      return db.bulkDocs(docs).then(function () {
        return db.changes({
          filter: '_doc_ids',
          doc_ids: ['1', '3']
        });
      }).then(function (changes) {
        var ids = changes.results.map(function (x) {
          return x.id;
        });
        ids.sort().should.deep.equal(['1', '3']);
      });
    });

    it('#2569 Live doc_ids filter with filter=_doc_ids', function () {
      var docs = [
        {_id: '0'},
        {_id: '1'},
        {_id: '2'},
        {_id: '3'}
      ];
      var db = new PouchDB(dbs.name);
      return db.bulkDocs(docs).then(function () {
        return db.changes({
          filter: '_doc_ids',
          doc_ids: ['1', '3']
        });
      }).then(function (changes) {
        var ids = changes.results.map(function (x) {
          return x.id;
        });
        ids.sort().should.deep.equal(['1', '3']);
      });
    });

    it('Changes to same doc are grouped', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var docs2 = [
        {_id: '2', integer: 11},
        {_id: '3', integer: 12}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs1 }, function (err, info) {
        docs2[0]._rev = info[2].rev;
        docs2[1]._rev = info[3].rev;
        db.put(docs2[0], function () {
          db.put(docs2[1], function () {
            db.changes({
              include_docs: true
            }).on('complete', function (changes) {
              changes.results.length.should.equal(4);

              var second = findById(changes.results, '2');
              second.changes.length.should.equal(1);
              second.doc.integer.should.equal(11);
              done();
            }).on('error', done);
          });
        });
      });
    });

    it('Changes with conflicts are handled correctly', function (testDone) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var docs2 = [
        {_id: '2', integer: 11},
        {_id: '3', integer: 12}
      ];
      var localdb = new PouchDB(dbs.name);
      var remotedb = new PouchDB(dbs.remote);
      localdb.bulkDocs({ docs: docs1 }).then(function (info) {
        docs2[0]._rev = info[2].rev;
        docs2[1]._rev = info[3].rev;
        return localdb.put(docs2[0]).then(function () {
          return localdb.put(docs2[1]).then(function (info) {
            var rev2 = info.rev;
            return PouchDB.replicate(localdb, remotedb).then(function () {
              // update remote once, local twice, then replicate from
              // remote to local so the remote losing conflict is later in
              // the tree
              return localdb.put({
                _id: '3',
                _rev: rev2,
                integer: 20
              }).then(function (resp) {
                var rev3Doc = {
                  _id: '3',
                  _rev: resp.rev,
                  integer: 30
                };
                return localdb.put(rev3Doc).then(function (resp) {
                  var rev4local = resp.rev;
                  var rev4Doc = {
                    _id: '3',
                    _rev: rev2,
                    integer: 100
                  };
                  return remotedb.put(rev4Doc).then(function (resp) {
                    var remoterev = resp.rev;
                    return PouchDB.replicate(remotedb, localdb).then(
                      function () {
                        return localdb.changes({
                          include_docs: true,
                          style: 'all_docs',
                          conflicts: true
                        }).on('error', testDone)
                          .then(function (changes) {
                            changes.results.length.should.equal(4);
                            var ch = findById(changes.results, '3');
                            ch.changes.length.should.equal(2);
                            ch.doc.integer.should.equal(30);
                            ch.doc._rev.should.equal(rev4local);
                            ch.changes.should.deep.equal([
                              { rev: rev4local },
                              { rev: remoterev }
                            ]);

                            ch.doc.should.have.property('_conflicts');
                            ch.doc._conflicts.length.should.equal(1);
                            ch.doc._conflicts[0].should.equal(remoterev);
                          });
                      });
                  });
                });
              });
            });
          });
        }).then(function () {
          testDone();
        }, testDone);
      });
    });

    it('Change entry for a deleted doc', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs1 }, function (err, info) {
        var rev = info[3].rev;
        db.remove({
          _id: '3',
          _rev: rev
        }, function () {
          db.changes({
            include_docs: true
          }).on('complete', function (changes) {
            changes.results.length.should.equal(4);
            var ch = findById(changes.results, '3');
            // sequence numbers are not incremental in CouchDB 2.0
            if (!testUtils.isCouchMaster()) {
              ch.seq.should.equal(5);
            }
            ch.deleted.should.equal(true);
            done();
          }).on('error', done);
        });
      });
    });

    it('changes large number of docs', function (done) {
      var docs = [];
      var num = 30;
      for (var i = 0; i < num; i++) {
        docs.push({
          _id: 'doc_' + i,
          foo: 'bar_' + i
        });
      }
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs }, function () {
        db.changes().on('complete', function (res) {
          res.results.length.should.equal(num);
          done();
        }).on('error', done);
      });
    });

    it('Calling db.changes({since: \'now\'})', function (done) {
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: [{ foo: 'bar' }] }, function () {
        db.info(function (err, info) {
          var api = db.changes({
            since: 'now'
          }).on('complete', function (res) {
            // last_seq and update_seq might be encoded differently
            // in clustered CouchDB - they cannot be reliably compared.
            if (!testUtils.isCouchMaster()) {
              res.last_seq.should.equal(info.update_seq);
            }
            done();
          }).on('error', done);
          api.should.be.an('object');
          api.cancel.should.be.an('function');
        });
      });
    });

    //Duplicate to make sure both api options work.
    it('Calling db.changes({since: \'latest\'})', function (done) {
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: [{ foo: 'bar' }] }, function () {
        db.info(function (err, info) {
          var api = db.changes({
            since: 'latest'
          }).on('complete', function (res) {
            // last_seq and update_seq might be encoded differently
            // in clustered CouchDB - they cannot be reliably compared.
            if (!testUtils.isCouchMaster()) {
              res.last_seq.should.equal(info.update_seq);
            }
            done();
          }).on('error', done);
          api.should.be.an('object');
          api.cancel.should.be.an('function');
        });
      });
    });

    it('Closing db does not cause a crash if changes cancelled',
      function (done) {
      var db = new PouchDB(dbs.name);
      var called = 0;
      function checkDone() {
        called++;
        if (called === 2) {
          done();
        }
      }
      db.bulkDocs({ docs: [{ foo: 'bar' }] }, function () {
        var changes = db.changes({
          live: true
        }).on('complete', function (result) {
          result.status.should.equal('cancelled');
          checkDone();
        });
        should.exist(changes);
        changes.cancel.should.be.a('function');
        changes.cancel();
        db.close(function (error) {
          should.not.exist(error);
          checkDone();
        });
      });
    });

    it('fire-complete-on-cancel', function (done) {
      var db = new PouchDB(dbs.name);
      var cancelled = false;
      var changes = db.changes({
        live: true
      }).on('complete', function (result) {
        cancelled.should.equal(true);
        should.exist(result);
        if (result) {
          result.status.should.equal('cancelled');
        }
        done();
      }).on('error', done);
      should.exist(changes);
      changes.cancel.should.be.a('function');
      setTimeout(function () {
        cancelled = true;
        changes.cancel();
      }, 100);
    });

    it('changes are not duplicated', function (done) {
      var db = new PouchDB(dbs.name);
      var called = 0;
      var changes = db.changes({
        live: true
      }).on('change', function () {
        called++;
        if (called === 1) {
          setTimeout(function () {
            changes.cancel();
          }, 1000);
        }
      }).on('complete', function () {
        called.should.equal(1);
        done();
      });
      db.post({key: 'value'});
    });

    it('supports return_docs=false', function (done) {
      var db = new PouchDB(dbs.name);
      var docs = [];
      var num = 10;
      for (var i = 0; i < num; i++) {
        docs.push({ _id: 'doc_' + i});
      }
      var changes = 0;
      db.bulkDocs({ docs: docs }, function (err) {
        if (err) {
          return done(err);
        }
        db.changes({
          descending: true,
          return_docs: false
        }).on('change', function () {
          changes++;
        }).on('complete', function (results) {
          results.results.should.have.length(0, '0 results returned');
          changes.should.equal(num, 'correct number of changes');
          done();
        }).on('error', function (err) {
          done(err);
        });
      });
    });

    // TODO: Remove 'returnDocs' in favor of 'return_docs' in a future release
    it('supports returnDocs=false', function (done) {
      var db = new PouchDB(dbs.name);
      var docs = [];
      var num = 10;
      for (var i = 0; i < num; i++) {
        docs.push({ _id: 'doc_' + i});
      }
      var changes = 0;
      db.bulkDocs({ docs: docs }, function (err) {
        if (err) {
          return done(err);
        }
        db.changes({
          descending: true,
          returnDocs: false
        }).on('change', function () {
          changes++;
        }).on('complete', function (results) {
          results.results.should.have.length(0, '0 results returned');
          changes.should.equal(num, 'correct number of changes');
          done();
        }).on('error', function (err) {
          done(err);
        });
      });
    });

    it('should respects limit', function (done) {
      var docs1 = [
        {_id: '_local/foo'},
        {_id: 'a', integer: 0},
        {_id: 'b', integer: 1},
        {_id: 'c', integer: 2},
        {_id: 'd', integer: 3}
      ];
      var called = 0;
      var db = new PouchDB(dbs.name);
      db.bulkDocs({ docs: docs1 }, function () {
        db.changes({
          limit: 1
        }).on('change', function () {
          (called++).should.equal(0);
        }).on('complete', function () {
          setTimeout(function () {
            done();
          }, 50);
        });
      });
    });

    it('doesn\'t throw if opts.complete is undefined', function (done) {
      var db = new PouchDB(dbs.name);
      db.put({_id: 'foo'}).then(function () {
        db.changes().on('change', function () {
          done();
        }).on('error', function (err) {
          done(err);
        });
      }, done);
    });

    it('it handles a bunch of individual changes in live replication',
      function (done) {
      var db = new PouchDB(dbs.name);
      var len = 80;
      var called = 0;
      var changesDone = false;
      var changesWritten = 0;
      var changes = db.changes({live: true});

      changes.on('change', function () {
        called++;
        if (called === len) {
          changes.cancel();
        }
      }).on('error', done).on('complete', function () {
        changesDone = true;
        maybeDone();
      });

      var i = -1;

      function maybeDone() {
        if (changesDone && changesWritten === len) {
          done();
        }
      }

      function after() {
        changesWritten++;
        db.listeners('destroyed').should.have.length.lessThan(5);
        maybeDone();
      }

      while (++i < len) {
        db.post({}).then(after).catch(done);
      }

    });

    it('changes-filter without filter', function (done) {
      var docs1 = [
        {_id: '0', integer: 0},
        {_id: '1', integer: 1},
        {_id: '2', integer: 2},
        {_id: '3', integer: 3}
      ];
      var docs2 = [
        {_id: '4', integer: 4},
        {_id: '5', integer: 5},
        {_id: '6', integer: 6},
        {_id: '7', integer: 7}
      ];
      var db = new PouchDB(dbs.name);
      var count = 0;
      db.bulkDocs({ docs: docs1 }, function () {
        var changes = db.changes({
          live: true
        }).on('complete', function (result) {
          result.status.should.equal('cancelled');
          done();
        }).on('change', function () {
          count += 1;
          if (count === 8) {
            changes.cancel();
          }
        }).on('error', done);
        db.bulkDocs({ docs: docs2 });
      });
    });


    it('#3539 - Exception in changes is fine', function (done) {

      var db = new PouchDB(dbs.name);
      var count = 0;

      var changes = db.changes({live: true});

      changes.on('change', function () {
        ++count;
        if (count === 1) {
          throw new Error('an error');
        } else if (count === 3) {
          changes.cancel();
        }
      });

      changes.on('complete', function () {
        done();
      });

      db.post({ test: 'some stuff' }).then(function () {
        return db.post({ test: 'more stuff' });
      }).then(function () {
        db.post({ test: 'and more stuff' });
      });
    });

  });
});

describe('changes-standalone', function () {

  it('Changes reports errors', function (done) {
    this.timeout(2000);
    var db = new PouchDB('http://infiniterequest.com', { skipSetup: true });
    db.changes({
      timeout: 1000
    }).on('error', function (err) {
      should.exist(err);
      done();
    });
  });

});