moar playing around with promises and callbacks

moar-promises.js

'use strict'

const fs = require('fs')

// some tests
class Tests {

  // a test
  test_1 (testName, done) {
    const p1 = getPromiseResolves(1)
    const p2 = getPromiseResolves(2)
    const p3 = getPromiseRejects('3')

    const p4 = Promise.all([p1,p2,p3])

    promiseThenCB(p4, (err, val) => {
      if (err) {
        console.log(`${testName} passed: ${err}`)
      } else {
        console.log(`${testName} failed: ${val}`)
      }
      done()
    })
  }

// a test
  test_2 (testName, done) {
    const p1 = cbPromise()
    fs.readFile(__filename, 'utf8', p1.cb)
    p1
    .then((val) => {
      console.log(`${testName} passed: ${val.length} characters`)
      done()
    })
    .catch((err) => {
      console.log(`${testName} failed: ${err}`)
      done()
    })
  }

  // a test
  test_3 (testName, done) {
    const p1 = cbPromise()
    fs.readFile(__filename + 'XYZ', 'utf8', p1.cb)

    p1
    .then((val) => {
      console.log(`${testName} failed: ${val.length} characters`)
      done()
    })
    .catch((err) => {
      console.log(`${testName} passed: ${err}`)
      done()
    })

  }

}

// Returns a promise with a `cb` property which is a callback function
// that resolves or rejects the promise returned.
function cbPromise () {
  let resolve
  let reject

  const promise = new Promise( (_resolve, _reject) => {
    resolve = _resolve
    reject = _reject
  })

  promise.cb = (err, val) => {
    if (err) return reject(err)
    resolve(val)
  }

  return promise
}


// call a callback when promise resolves or rejects
function promiseThenCB (promise, cb) {
  return promise
    .then((val) => cb(null, val))
    .catch((err) => cb(err))
}

// get a promise that resolves to val after a timeout
function getPromiseResolves (val, ms) {
  if (val == null) val = true
  if (ms == null) ms = 100

  return new Promise( (resolve, reject) => {
    setTimeout(resolveIt, ms)
    function resolveIt () {
      resolve(val)
    }
  })
}

// get a promise that rejects with error after a timeout
function getPromiseRejects (msg, ms) {
  if (msg == null) msg = 'rejected!'
  if (ms == null) ms = 100

  return new Promise( (resolve, reject) => {
    setTimeout(rejectIt, ms)
    function rejectIt () {
      reject(new Error(msg))
    }
  })
}

// test runner
const tests = new Tests()

const testNames = Object.getOwnPropertyNames(Object.getPrototypeOf(tests))

// run one test, and schedule next one when it's done
function runTest () {
  if (testNames.length === 0) return

  let testName
  do {
    testName = testNames.shift()
  } while (testName === 'constructor')

  console.log('-----------------------------------------------------')
  console.log(`running ${testName}`)
  tests[testName](testName, done)

  function done () {
    console.log()
    setImmediate(runTest)
  }
}

// start running the tests
runTest()