cleanup Stdin for boosting test coverage

Author: isaacs

lib/base.js

@@ -185,6 +185,7 @@ Base.prototype.debug = (/\btap\b/i.test(process.env.NODE_DEBUG || ''))
 
 function nodebug () {}
 
+/* istanbul ignore next */
 function debug () {
   var prefix = 'TAP ' + process.pid + ' ' + this.name + ': '
   var msg = util.format.apply(util, arguments).trim()

lib/clean-yaml-object.js

@@ -47,6 +47,7 @@ function yamlFilter (propertyName, isRoot, source, target) {
 
   return !(propertyName === 'todo' ||
   /^_?tapChild/.test(propertyName) ||
+  /^tapStream/.test(propertyName) ||
   /^tapMochaTest/.test(propertyName) ||
   propertyName === 'cb' ||
   propertyName === 'name' ||

lib/parse-test-args.js

@@ -42,13 +42,19 @@ module.exports = function (name_, extra_, cb_, defaultName) {
   if (!cb)
     extra.todo = true
 
+  if (!name && extra.name)
+    name = extra.name
+
   if (!name && cb && cb.name)
     name = cb.name
 
   name = name || defaultName
   extra.name = name
-  extra.cb = cb || function () {
-    throw new Error('callback called for TODO test')
-  }
+  extra.cb = cb || todoCb
   return extra
 }
+
+/* istanbul ignore next */
+function todoCb () {
+  throw new Error('callback called for TODO test')
+}

lib/point.js

@@ -9,6 +9,9 @@ function TestPoint (ok, message, extra) {
   if (typeof ok !== 'boolean')
     throw new TypeError('ok must be boolean')
 
+  if (!(this instanceof TestPoint))
+    return new TestPoint(ok, message, extra)
+
   this.ok = ok ? 'ok ' : 'not ok '
   this.message = tpMessage(message, extra)
 }

lib/spawn.js

@@ -20,18 +20,17 @@ function Spawn (options) {
   Base.call(this, options)
 
   this.command = options.command
-  if (!this.command) {
+
+  if (!this.command)
     throw new TypeError('no command provided')
-  }
 
   this.args = options.args
   // stdout must be a pipe
   if (options.stdio) {
-    if (typeof options.stdio === 'string') {
+    if (typeof options.stdio === 'string')
       this.stdio = [ options.stdio, 'pipe', options.stdio ]
-    } else {
+    else
       this.stdio = options.stdio.slice(0)
-    }
   } else
     this.stdio = [ 0, 'pipe', 2 ]
 

lib/stdin.js

@@ -16,13 +16,15 @@ function Stdin (options) {
   Base.call(this, options)
 
   // This has to be here for node 0.10's wonky streams
-  process.stdin.pause()
+  this.stream = ownOr(options, 'tapStream', process.stdin)
+  this.stream.pause()
 }
 
 Stdin.prototype.main = function (cb) {
-  this.domain.add(process.stdin)
+  this.domain.add(this.stream)
   this.setTimeout(this.options.timeout)
-  process.stdin.pipe(this.parser)
+  this.stream.pipe(this.parser)
+  this.stream.resume()
   this.once('end', cb)
 }
 

lib/tap.js

@@ -1,4 +1,6 @@
 var Test = require('./test.js')
+var Stdin = require('./stdin.js')
+var Spawn = require('./spawn.js')
 var util = require('util')
 var objToYaml = require('./obj-to-yaml.js')
 var yaml = require('js-yaml')
@@ -59,6 +61,8 @@ process.on('exit', function (code) {
 })
 
 tap.Test = Test
+tap.Spawn = Spawn
+tap.Stdin = Stdin
 tap.synonyms = require('./synonyms.js')
 
 // SIGTERM means being forcibly killed, almost always by timeout

test/runner-read-stdin.js

@@ -143,4 +143,3 @@ t.test('read from stdin', { skip: process.platform === 'win32' && 'skip stdin te
 
   t.end()
 })
-

test/test-args.js

@@ -4,12 +4,18 @@ var parseTestArgs = require('../lib/parse-test-args.js')
 
 function namedFunction () {}
 var fn = function () {}
+function clone (o) {
+  return Object.keys(o).reduce(function (c, k) {
+    c[k] = o[k]
+    return c
+  }, {})
+}
 var obj = { thisIsMyObject: true }
+var cobj = clone.bind(null, obj)
 var objTodo = { thisIsMyObject: true, todo: true }
+var cobjTodo = clone.bind(null, objTodo)
 
 function runTest (args, expect) {
-  delete obj.todo
-
   var result = parseTestArgs.apply(null, args)
   t.match(result, expect)
 }
@@ -22,30 +28,30 @@ function c (obj, props) {
   }, props)
 }
 
-runTest(['name', obj, fn], c(obj, {name: 'name', cb: fn}))
+runTest(['name', cobj(), fn], c(cobj(), {name: 'name', cb: fn}))
 runTest(['name', fn], { name: 'name', cb: fn })
-runTest([obj, fn], c(obj, { name: /\(unnamed test\)|fn/, cb: fn }))
-runTest([obj, namedFunction], c(obj, { name: 'namedFunction', cb: namedFunction }))
-runTest(['name', obj], c(objTodo, { name: 'name' }))
+runTest([cobj(), fn], c(cobj(), { name: /\(unnamed test\)|fn/, cb: fn }))
+runTest([cobj(), namedFunction], c(cobj(), { name: 'namedFunction', cb: namedFunction }))
+runTest(['name', cobj()], c(cobjTodo(), { name: 'name' }))
 runTest(['name'], { name: 'name', todo: true })
-runTest([obj], c(objTodo, { name: /\(unnamed test\)|fn/ }))
+runTest([cobj()], c(cobjTodo(), { name: /\(unnamed test\)|fn/ }))
 runTest([fn], {name: /\(unnamed test\)|fn/, cb: fn})
 runTest([namedFunction], { name: 'namedFunction', cb: namedFunction })
 runTest([], { name: /\(unnamed test\)|fn/, todo: true })
 
 var dn = 'defaultName'
 var _ = undefined
-runTest(['name', obj, fn, dn], c(obj, {name: 'name', cb: fn}))
+runTest(['name', cobj(), fn, dn], c(cobj(), {name: 'name', cb: fn}))
 runTest(['name', fn, _, dn], { name: 'name', cb: fn })
-runTest([obj, fn, _, dn], c(obj, { name: /defaultName|fn/, cb: fn }))
-runTest([obj, namedFunction, _, dn], c(obj, { name: 'namedFunction', cb: namedFunction }))
-runTest(['name', obj, _, dn], c(objTodo, { name: 'name' }))
+runTest([cobj(), fn, _, dn], c(cobj(), { name: /defaultName|fn/, cb: fn }))
+runTest([cobj(), namedFunction, _, dn], c(cobj(), { name: 'namedFunction', cb: namedFunction }))
+runTest(['name', cobj(), _, dn], c(cobjTodo(), { name: 'name' }))
 runTest(['name', _, _, dn], { name: 'name', todo: true })
-runTest([obj, _, _, dn], c(objTodo, { name: /defaultName|fn/ }))
+runTest([cobj(), _, _, dn], c(cobjTodo(), { name: /defaultName|fn/ }))
 runTest([fn, _, _, dn], {name: /defaultName|fn/, cb: fn})
 runTest([namedFunction, _, _, dn], { name: 'namedFunction', cb: namedFunction })
 runTest([_, _, _, dn], { name: /defaultName|fn/, todo: true })
 
 t.throws(function () {
-  runTest(['name', obj, 99], {})
+  runTest(['name', cobj(), 99], {})
 })

test/test-test.js

@@ -1,8 +1,7 @@
-var tap = require('../')
-var test = tap.test
-var Test = tap.Test
+var t = require('../')
+var Test = t.Test
 
-test('testing the test object', function (t) {
+t.test('testing the test object', function (t) {
   t.isa(t, Test, 'test object should be instanceof Test')
 
   // now test all the methods.
@@ -80,7 +79,7 @@ test('testing the test object', function (t) {
   t.end()
 })
 
-test('plan stuff', function (t) {
+t.test('plan stuff', function (t) {
   t.throws(function () {
     var tt = new Test({ buffered: false })
     tt.plan(1)
@@ -98,20 +97,7 @@ test('plan stuff', function (t) {
   t.end()
 })
 
-test('subtest with name and function', function (t) {
-  var tt = new Test({ buffered: false })
-  var out = ''
-  tt.on('data', function (c) {
-    out += c
-  })
-  tt.test('name', function (t){t.end()})
-  tt.end()
-
-  t.equal(out, 'TAP version 13\n# Subtest: name\n    1..0\nok 1 - name\n\n1..1\n');
-  t.end()
-})
-
-test('invalid test arguments', function (t) {
+t.test('invalid test arguments', function (t) {
   t.throws(function () {
     var tt = new Test({ buffered: false })
     tt.test('name', { skip: false }, 'not a function')
@@ -120,7 +106,7 @@ test('invalid test arguments', function (t) {
   t.end()
 })
 
-test('throws type', function (t)  {
+t.test('throws type', function (t)  {
   t.throws(function() {
     throw new TypeError('some type error');
   }, TypeError, 'should throw a TypeError');
@@ -144,3 +130,29 @@ test('throws type', function (t)  {
 
   t.end()
 })
+
+t.test('test-point', function (t) {
+  var TestPoint = require('../lib/point.js')
+  t.throws(function () {
+    new TestPoint(100, 'century!', { flerg: 'blooze' })
+  }, new TypeError('ok must be boolean'))
+
+  var tp = TestPoint(true, 'msg', { a: 1 })
+  t.isa(tp, TestPoint)
+  t.match(tp, {
+    ok: 'ok ',
+    message: '- msg\n'
+  })
+
+  t.match(TestPoint(true, 'msg', { a: 1, diagnostic: true }), {
+    ok: 'ok ',
+    message: ' - msg\n  ---\n  a: 1\n  ...\n\n'
+  })
+
+  t.match(TestPoint(true, 'msg', { a: 1, tapChildBuffer: 'subtest output' }), {
+    ok: 'ok ',
+    message: ' - msg {\nsubtest output\n}\n\n'
+  })
+
+  t.end()
+})