node-postgres/packages/pg-cursor/test/index.js

const assert = require('assert');
const Cursor = require('../');
const pg = require('pg');

const text = 'SELECT generate_series as num FROM generate_series(0, 5)';

describe('cursor', function () {
  beforeEach(function (done) {
    const client = (this.client = new pg.Client());
    client.connect(done);

    this.pgCursor = function (text, values) {
      return client.query(new Cursor(text, values || []));
    };
  });

  afterEach(function () {
    this.client.end();
  });

  it('fetch 6 when asking for 10', function (done) {
    const cursor = this.pgCursor(text);
    cursor.read(10, function (err, res) {
      assert.ifError(err);
      assert.strictEqual(res.length, 6);
      done();
    });
  });

  it('end before reading to end', function (done) {
    const cursor = this.pgCursor(text);
    cursor.read(3, function (err, res) {
      assert.ifError(err);
      assert.strictEqual(res.length, 3);
      done();
    });
  });

  it('callback with error', function (done) {
    const cursor = this.pgCursor('select asdfasdf');
    cursor.read(1, function (err) {
      assert(err);
      done();
    });
  });

  it('read a partial chunk of data', function (done) {
    const cursor = this.pgCursor(text);
    cursor.read(2, function (err, res) {
      assert.ifError(err);
      assert.strictEqual(res.length, 2);
      cursor.read(3, function (err, res) {
        assert(!err);
        assert.strictEqual(res.length, 3);
        cursor.read(1, function (err, res) {
          assert(!err);
          assert.strictEqual(res.length, 1);
          cursor.read(1, function (err, res) {
            assert(!err);
            assert.ifError(err);
            assert.strictEqual(res.length, 0);
            done();
          });
        });
      });
    });
  });

  it('read return length 0 past the end', function (done) {
    const cursor = this.pgCursor(text);
    cursor.read(2, function (err) {
      assert(!err);
      cursor.read(100, function (err, res) {
        assert(!err);
        assert.strictEqual(res.length, 4);
        cursor.read(100, function (err, res) {
          assert(!err);
          assert.strictEqual(res.length, 0);
          done();
        });
      });
    });
  });

  it('read huge result', function (done) {
    this.timeout(10000);
    const text = 'SELECT generate_series as num FROM generate_series(0, 100000)';
    const values = [];
    const cursor = this.pgCursor(text, values);
    let count = 0;
    const read = function () {
      cursor.read(100, function (err, rows) {
        if (err) return done(err);
        if (!rows.length) {
          assert.strictEqual(count, 100001);
          return done();
        }
        count += rows.length;
        if (count % 10000 === 0) {
          // console.log(count)
        }
        setImmediate(read);
      });
    };
    read();
  });

  it('normalizes parameter values', function (done) {
    const text = 'SELECT $1::json me';
    const values = [{ name: 'brian' }];
    const cursor = this.pgCursor(text, values);
    cursor.read(1, function (err, rows) {
      if (err) return done(err);
      assert.strictEqual(rows[0].me.name, 'brian');
      cursor.read(1, function (err, rows) {
        assert(!err);
        assert.strictEqual(rows.length, 0);
        done();
      });
    });
  });

  it('returns result along with rows', function (done) {
    const cursor = this.pgCursor(text);
    cursor.read(1, function (err, rows, result) {
      assert.ifError(err);
      assert.strictEqual(rows.length, 1);
      assert.strictEqual(rows, result.rows);
      assert.deepStrictEqual(
        result.fields.map((f) => f.name),
        ['num']
      );
      done();
    });
  });

  it('emits row events', function (done) {
    const cursor = this.pgCursor(text);
    cursor.read(10);
    cursor.on('row', (row, result) => result.addRow(row));
    cursor.on('end', (result) => {
      assert.strictEqual(result.rows.length, 6);
      done();
    });
  });

  it('emits row events when cursor is closed manually', function (done) {
    const cursor = this.pgCursor(text);
    cursor.on('row', (row, result) => result.addRow(row));
    cursor.on('end', (result) => {
      assert.strictEqual(result.rows.length, 3);
      done();
    });

    cursor.read(3, () => cursor.close());
  });

  it('emits error events', function (done) {
    const cursor = this.pgCursor('select asdfasdf');
    cursor.on('error', function (err) {
      assert(err);
      done();
    });
  });

  it('returns rowCount on insert', function (done) {
    const pgCursor = this.pgCursor;
    this.client
      .query('CREATE TEMPORARY TABLE pg_cursor_test (foo VARCHAR(1), bar VARCHAR(1))')
      .then(function () {
        const cursor = pgCursor('insert into pg_cursor_test values($1, $2)', ['a', 'b']);
        cursor.read(1, function (err, rows, result) {
          assert.ifError(err);
          assert.strictEqual(rows.length, 0);
          assert.strictEqual(result.rowCount, 1);
          done();
        });
      })
      .catch(done);
  });
});