Use a coverage map for more targetted testing

map.js

@@ -0,0 +1,9 @@
+const {basename} = require('path')
+
+const map = test =>
+  test === 'index.js' || test === 'map.js' ? test
+  : test === 'unpack.js' ? ['lib/unpack.js', 'lib/mkdir.js']
+  : test === 'load-all.js' ? []
+  : `lib/${test}`
+
+module.exports = test => map(basename(test))

package.json

@@ -43,6 +43,7 @@
     "lib/"
   ],
   "tap": {
+    "coverage-map": "map.js",
     "check-coverage": true
   }
 }

test/header.js

@@ -557,3 +557,36 @@ t.test('dir with long body', t => {
   t.equal(h.size, 0)
   t.end()
 })
+
+t.test('null block, global extended header', t => {
+  const h = new Header(Buffer.alloc(512), 0, {
+    undef: undefined,
+    blerg: 'bloo',
+  }, {
+    path: '/global.path',
+    foo: 'global foo'
+  })
+  t.match(h, {
+    cksumValid: false,
+    needPax: false,
+    path: '',
+    type: 'File',
+    mode: null,
+    uid: null,
+    gid: null,
+    size: null,
+    mtime: null,
+    cksum: null,
+    linkpath: '',
+    uname: null,
+    gname: null,
+    devmaj: 0,
+    devmin: 0,
+    atime: null,
+    ctime: null,
+    nullBlock: true,
+    blerg: 'bloo',
+    foo: 'global foo',
+  })
+  t.end()
+})

test/index.js

@@ -0,0 +1,73 @@
+const t = require('tap')
+const tar = require('../')
+t.match(tar, {
+  create: Function,
+  c: Function,
+  replace: Function,
+  r: Function,
+  list: Function,
+  t: Function,
+  update: Function,
+  u: Function,
+  extract: Function,
+  x: Function,
+  Pack: Function,
+  Unpack: Function,
+  Parse: Function,
+  ReadEntry: Function,
+  WriteEntry: Function,
+  Header: Function,
+  Pax: Function,
+  types: {
+    name: new Map([
+      ['0', 'File'],
+      ['', 'OldFile'],
+      ['1', 'Link'],
+      ['2', 'SymbolicLink'],
+      ['3', 'CharacterDevice'],
+      ['4', 'BlockDevice'],
+      ['5', 'Directory'],
+      ['6', 'FIFO'],
+      ['7', 'ContiguousFile'],
+      ['g', 'GlobalExtendedHeader'],
+      ['x', 'ExtendedHeader'],
+      ['A', 'SolarisACL'],
+      ['D', 'GNUDumpDir'],
+      ['I', 'Inode'],
+      ['K', 'NextFileHasLongLinkpath'],
+      ['L', 'NextFileHasLongPath'],
+      ['M', 'ContinuationFile'],
+      ['N', 'OldGnuLongPath'],
+      ['S', 'SparseFile'],
+      ['V', 'TapeVolumeHeader'],
+      ['X', 'OldExtendedHeader'],
+    ]),
+    code: new Map([
+      ['File', '0'],
+      ['OldFile', ''],
+      ['Link', '1'],
+      ['SymbolicLink', '2'],
+      ['CharacterDevice', '3'],
+      ['BlockDevice', '4'],
+      ['Directory', '5'],
+      ['FIFO', '6'],
+      ['ContiguousFile', '7'],
+      ['GlobalExtendedHeader', 'g'],
+      ['ExtendedHeader', 'x'],
+      ['SolarisACL', 'A'],
+      ['GNUDumpDir', 'D'],
+      ['Inode', 'I'],
+      ['NextFileHasLongLinkpath', 'K'],
+      ['NextFileHasLongPath', 'L'],
+      ['ContinuationFile', 'M'],
+      ['OldGnuLongPath', 'N'],
+      ['SparseFile', 'S'],
+      ['TapeVolumeHeader', 'V'],
+      ['OldExtendedHeader', 'X'],
+    ]),
+  }
+})
+t.match(tar.Pack.Sync, Function)
+t.match(tar.WriteEntry.Sync, Function)
+t.match(tar.WriteEntry.Tar, Function)
+t.match(tar.Pax.parse, Function)

test/map.js

@@ -0,0 +1,7 @@
+const t = require('tap')
+const map = require('../map.js')
+t.equal(map('test/index.js'), 'index.js')
+t.same(map('test/unpack.js'), ['lib/unpack.js', 'lib/mkdir.js'])
+t.same(map('test/load-all.js'), [])
+t.equal(map(__filename), 'map.js')
+t.equal(map('test/asdf'), 'lib/asdf')

test/parse.js

@@ -172,6 +172,15 @@ t.test('onentry gets added to entry event', t => {
 })
 
 t.test('drain event timings', t => {
+  let sawOndone = false
+  const ondone = function () {
+    sawOndone = true
+    this.emit('prefinish')
+    this.emit('finish')
+    this.emit('end')
+    this.emit('close')
+  }
+
   // write 1 header and body, write 2 header, verify false return
   // wait for drain event before continuing.
   // write 2 body, 3 header and body, 4 header, verify false return
@@ -311,6 +320,7 @@ t.test('drain event timings', t => {
   let currentEntry
   let autoPipe = true
   const p = new Parse({
+    ondone,
     onentry: entry => {
       t.equal(entry.path, expect.shift())
       currentEntry = entry
@@ -361,6 +371,7 @@ t.test('drain event timings', t => {
   p.once('drain', go)
   p.on('end', _ => {
     clearInterval(interval)
+    t.ok(sawOndone)
     t.end()
   })
   go()