test: Add lib/content/read.js tests

- Add test coverage to lib/content/read.js module
- Added coverage ignore lines to platform specific checks

PR-URL: #15
Credit: @ruyadorno
Close: #15
Reviewed-by: @isaacs

Author: ruyadorno

lib/content/read.js

@@ -127,6 +127,7 @@ function hasContent (cache, integrity) {
       return false
     }
     if (err.code === 'EPERM') {
+      /* istanbul ignore else */
       if (process.platform !== 'win32') {
         throw err
       } else {
@@ -151,6 +152,7 @@ function hasContentSync (cache, integrity) {
         return false
       }
       if (err.code === 'EPERM') {
+        /* istanbul ignore else */
         if (process.platform !== 'win32') {
           throw err
         } else {

test/content.read.js

@@ -4,6 +4,7 @@ const util = require('util')
 
 const fs = require('fs')
 const path = require('path')
+const requireInject = require('require-inject')
 const ssri = require('ssri')
 const Tacks = require('tacks')
 const { test } = require('tap')
@@ -16,7 +17,26 @@ const CacheContent = require('./util/cache-content')
 
 const read = require('../lib/content/read')
 
-test('read: returns a BB with cache content data', function (t) {
+// defines reusable errors
+const genericError = new Error('ERR')
+genericError.code = 'ERR'
+const permissionError = new Error('EPERM')
+permissionError.code = 'EPERM'
+
+// helpers
+const getRead = (opts) => requireInject('../lib/content/read', opts)
+const getReadLstatFailure = (err) => getRead({
+  'graceful-fs': Object.assign({}, require('graceful-fs'), {
+    lstat (path, cb) {
+      cb(err)
+    },
+    lstatSync () {
+      throw err
+    }
+  })
+})
+
+test('read: returns a Promise with cache content data', function (t) {
   const CONTENT = Buffer.from('foobarbaz')
   const INTEGRITY = ssri.fromData(CONTENT)
   const fixture = new Tacks(
@@ -176,6 +196,159 @@ test('read: errors if content size does not match size option', function (t) {
   })
 })
 
+test('read: error while parsing provided integrity data', function (t) {
+  const INTEGRITY = 'sha1-deadbeef'
+  const mockedRead = getRead({
+    ssri: {
+      parse (sri) {
+        throw genericError
+      }
+    }
+  })
+
+  t.plan(1)
+  return t.rejects(
+    mockedRead(CACHE, INTEGRITY),
+    genericError,
+    'should reject promise upon catching internal errors'
+  )
+})
+
+test('read: unknown error parsing nested integrity data', function (t) {
+  const INTEGRITY = 'sha1-deadbeef sha1-13371337'
+
+  // patches method in order to force a last error scenario
+  const mockedRead = getRead({
+    ssri: {
+      parse (sri) {
+        if (sri !== INTEGRITY) {
+          throw genericError
+        }
+        return ssri.parse(sri)
+      }
+    }
+  })
+
+  t.plan(1)
+  return t.rejects(
+    mockedRead(CACHE, INTEGRITY),
+    genericError,
+    'should throw unknown errors'
+  )
+})
+
+test('read: returns only first result if other hashes fails', function (t) {
+  // sets up a cache that has multiple entries under the
+  // same algorithm but then only one has real contents in the fs
+  const CONTENT = {
+    foo: Buffer.from('foo'),
+    bar: Buffer.from('bar')
+  }
+  const INTEGRITY = ssri.fromData(CONTENT.foo).concat(
+    ssri.fromData(CONTENT.bar)
+  )
+  const fixture = new Tacks(
+    CacheContent({
+      [INTEGRITY.sha512[1]]: CONTENT.bar
+    })
+  )
+  fixture.create(CACHE)
+
+  t.plan(1)
+  return t.resolveMatch(
+    read(CACHE, INTEGRITY),
+    CONTENT.bar,
+    'should return only the first valid result'
+  )
+})
+
+test('read: opening large files', function (t) {
+  const mockedRead = getRead({
+    'graceful-fs': Object.assign({}, require('graceful-fs'), {
+      lstat (path, cb) {
+        cb(null, { size: Number.MAX_SAFE_INTEGER })
+      }
+    }),
+    'fs-minipass': {
+      ReadStream: class {
+        constructor (path, opts) {
+          t.matches(
+            opts,
+            {
+              readSize: 64 * 1024 * 1024,
+              size: Number.MAX_SAFE_INTEGER
+            },
+            'should use fs-minipass interface'
+          )
+        }
+      }
+    },
+    'minipass-pipeline': Array
+  })
+
+  t.plan(1)
+  mockedRead(CACHE, 'sha1-deadbeef')
+})
+
+test('read.sync: unknown error parsing nested integrity data', (t) => {
+  const INTEGRITY = 'sha1-deadbeef sha1-13371337'
+
+  // patches method in order to force a last error scenario
+  const mockedRead = getRead({
+    ssri: {
+      parse (sri) {
+        if (sri !== INTEGRITY) {
+          throw genericError
+        }
+        return ssri.parse(sri)
+      }
+    }
+  })
+
+  t.throws(
+    () => mockedRead.sync(CACHE, INTEGRITY),
+    genericError,
+    'should throw last error found when parsing multiple hashes'
+  )
+  t.done()
+})
+
+test('read.sync: cache contains mismatching data', (t) => {
+  const CONTENT = Buffer.from('foobarbaz')
+  const INTEGRITY = ssri.fromData(CONTENT)
+  const fixture = new Tacks(
+    CacheContent({
+      [INTEGRITY]: CONTENT.slice(3)
+    })
+  )
+  fixture.create(CACHE)
+
+  t.throws(
+    () => read.sync(CACHE, INTEGRITY),
+    { code: 'EINTEGRITY' },
+    'should throw integrity error'
+  )
+  t.done()
+})
+
+test('read.sync: content size value does not match option', (t) => {
+  const CONTENT = Buffer.from('foobarbaz')
+  const INTEGRITY = ssri.fromData(CONTENT)
+  const fixture = new Tacks(
+    CacheContent({
+      [INTEGRITY]: CONTENT.slice(3)
+    })
+  )
+  fixture.create(CACHE)
+
+  t.throws(
+    () => read.sync(CACHE, INTEGRITY, { size: CONTENT.length }),
+    { code: 'EBADSIZE' },
+    'should throw size error'
+  )
+  t.done()
+})
+
 test('hasContent: tests content existence', (t) => {
   const fixture = new Tacks(
     CacheContent({
@@ -200,6 +373,37 @@ test('hasContent: tests content existence', (t) => {
   ])
 })
 
+test('hasContent: permission error', (t) => {
+  // setup a syntetic permission error
+  const mockedRead = getReadLstatFailure(permissionError)
+
+  t.plan(1)
+  t.rejects(
+    mockedRead.hasContent(CACHE, 'sha1-deadbeef sha1-13371337'),
+    permissionError,
+    'should reject on permission errors'
+  )
+})
+
+test('hasContent: generic error', (t) => {
+  const mockedRead = getReadLstatFailure(genericError)
+
+  t.plan(1)
+  t.resolves(
+    mockedRead.hasContent(CACHE, 'sha1-deadbeef sha1-13371337'),
+    'should not reject on generic errors'
+  )
+})
+
+test('hasContent: no integrity provided', (t) => {
+  t.resolveMatch(
+    read.hasContent(CACHE, ''),
+    false,
+    'should resolve with a value of false'
+  )
+  t.done()
+})
+
 test('hasContent.sync: checks content existence synchronously', (t) => {
   const fixture = new Tacks(
     CacheContent({
@@ -224,6 +428,36 @@ test('hasContent.sync: checks content existence synchronously', (t) => {
   t.done()
 })
 
+test('hasContent.sync: permission error', (t) => {
+  const mockedRead = getReadLstatFailure(permissionError)
+
+  t.throws(
+    () => mockedRead.hasContent.sync(CACHE, 'sha1-deadbeef sha1-13371337'),
+    permissionError,
+    'should throw on permission errors'
+  )
+  t.done()
+})
+
+test('hasContent.sync: generic error', (t) => {
+  const mockedRead = getReadLstatFailure(genericError)
+
+  t.notOk(
+    mockedRead.hasContent.sync(CACHE, 'sha1-deadbeef sha1-13371337'),
+    'should not throw on generic errors'
+  )
+  t.done()
+})
+
+test('hasContent.sync: no integrity provided', (t) => {
+  t.equal(
+    read.hasContent.sync(CACHE, ''),
+    false,
+    'should returns false if no integrity provided'
+  )
+  t.done()
+})
+
 test(
   'copy: copies content to a destination path',
   {
@@ -270,3 +504,14 @@ test(
     t.done()
   }
 )
+
+test('copyFile not supported by file system', (t) => {
+  const mockedRead = getRead({
+    'graceful-fs': Object.assign({}, require('graceful-fs'), {
+      copyFile: undefined
+    })
+  })
+
+  t.notOk(mockedRead.copy, 'should not define copy')
+  t.done()
+})