error-handling-tests.js

'use strict'

var helper = require('./test-helper')
var util = require('util')

var pg = helper.pg
const Client = pg.Client

var createErorrClient = function () {
  var client = helper.client()
  client.once('error', function (err) {
    assert.fail('Client shoud not throw error during query execution')
  })
  client.on('drain', client.end.bind(client))
  return client
}

const suite = new helper.Suite('error handling')

suite.test('sending non-array argument as values causes an error callback', (done) => {
  const client = new Client()
  client.connect(() => {
    client.query('select $1::text as name', 'foo', (err) => {
      assert(err instanceof Error)
      client.query('SELECT $1::text as name', ['foo'], (err, res) => {
        assert.equal(res.rows[0].name, 'foo')
        client.end(done)
      })
    })
  })
})

suite.test('re-using connections results in error callback', (done) => {
  const client = new Client()
  client.connect(() => {
    client.connect(err => {
      assert(err instanceof Error)
      client.end(done)
    })
  })
})

suite.test('re-using connections results in promise rejection', (done) => {
  const client = new Client()
  client.connect().then(() => {
    client.connect().catch(err => {
      assert(err instanceof Error)
      client.end().then(done)
    })
  })
})

suite.test('using a client after closing it results in error', (done) => {
  const client = new Client()
  client.connect(() => {
    client.end(assert.calls(() => {
      client.query('SELECT 1', assert.calls((err) => {
        assert.equal(err.message, 'Client was closed and is not queryable')
        done()
      }))
    }))
  })
})

suite.test('query receives error on client shutdown', function (done) {
  var client = new Client()
  client.connect(assert.success(function () {
    const config = {
      text: 'select pg_sleep(5)',
      name: 'foobar'
    }
    let queryError
    client.query(new pg.Query(config), assert.calls(function (err, res) {
      assert(err instanceof Error)
      queryError = err
    }))
    setTimeout(() => client.end(), 50)
    client.once('end', () => {
      assert(queryError instanceof Error)
      done()
    })
  }))
})

var ensureFuture = function (testClient, done) {
  var goodQuery = testClient.query(new pg.Query('select age from boom'))
  assert.emits(goodQuery, 'row', function (row) {
    assert.equal(row.age, 28)
    done()
  })
}

suite.test('when query is parsing', (done) => {
  var client = createErorrClient()

  var q = client.query({ text: 'CREATE TEMP TABLE boom(age integer); INSERT INTO boom (age) VALUES (28);' })

    // this query wont parse since there isn't a table named bang
  var query = client.query(new pg.Query({
    text: 'select * from bang where name = $1',
    values: ['0']
  }))

  assert.emits(query, 'error', function (err) {
    ensureFuture(client, done)
  })
})

suite.test('when a query is binding', function (done) {
  var client = createErorrClient()

  var q = client.query({ text: 'CREATE TEMP TABLE boom(age integer); INSERT INTO boom (age) VALUES (28);' })

  var query = client.query(new pg.Query({
    text: 'select * from boom where age = $1',
    values: ['asldkfjasdf']
  }))

  assert.emits(query, 'error', function (err) {
    assert.equal(err.severity, 'ERROR')
    ensureFuture(client, done)
  })
})

suite.test('non-query error with callback', function (done) {
  var client = new Client({
    user: 'asldkfjsadlfkj'
  })
  client.connect(assert.calls(function (error, client) {
    assert(error instanceof Error)
    done()
  }))
})

suite.test('non-error calls supplied callback', function (done) {
  var client = new Client({
    user: helper.args.user,
    password: helper.args.password,
    host: helper.args.host,
    port: helper.args.port,
    database: helper.args.database
  })

  client.connect(assert.calls(function (err) {
    assert.ifError(err)
    client.end(done)
  }))
})

suite.test('when connecting to an invalid host with callback', function (done) {
  var client = new Client({
    user: 'very invalid username'
  })
  client.on('error', () => {
    assert.fail('unexpected error event when connecting')
  })
  client.connect(function (error, client) {
    assert(error instanceof Error)
    done()
  })
})

suite.test('when connecting to invalid host with promise', function (done) {
  var client = new Client({
    user: 'very invalid username'
  })
  client.on('error', () => {
    assert.fail('unexpected error event when connecting')
  })
  client.connect().catch((e) => done())
})

suite.test('non-query error', function (done) {
  var client = new Client({
    user: 'asldkfjsadlfkj'
  })
  client.connect()
    .catch(e => {
      assert(e instanceof Error)
      done()
    })
})

suite.test('within a simple query', (done) => {
  var client = createErorrClient()

  var query = client.query(new pg.Query("select eeeee from yodas_dsflsd where pixistix = 'zoiks!!!'"))

  assert.emits(query, 'error', function (error) {
    assert.equal(error.severity, 'ERROR')
    done()
  })
})

suite.test('connected, idle client error', (done) => {
  const client = new Client()
  client.connect((err) => {
    if (err) {
      throw new Error('Should not receive error callback after connection')
    }
    setImmediate(() => {
      (client.connection || client.native).emit('error', new Error('expected'))
    })
  })
  client.on('error', (err) => {
    assert.equal(err.message, 'expected')
    client.end(done)
  })
})

suite.test('cannot pass non-string values to query as text', (done) => {
  const client = new Client()
  client.connect()
  client.query({ text: { } }, (err) => {
    assert(err)
    client.query({ }, (err) => {
      client.on('drain', () => {
        client.end(done)
      })
    })
  })
})