| 1 | const test = require('tap').test
|
| 2 | const through = require('through2')
|
| 3 | const bl = require('bl')
|
| 4 |
|
| 5 | const proxy = () => through(function (data, enc, cb) {
|
| 6 | this.push(data)
|
| 7 | cb()
|
| 8 | })
|
| 9 |
|
| 10 | module.exports = (name, store) => {
|
| 11 | test(`${name}: set Buffer, get Buffer`, t => {
|
| 12 | t.plan(3)
|
| 13 | let x = Buffer.from('asdf')
|
| 14 | store.set(x, (err, hash) => {
|
| 15 | t.error(err)
|
| 16 | store.getBuffer(hash, (err, buff) => {
|
| 17 | t.error(err)
|
| 18 | t.deepEquals(x, buff)
|
| 19 | })
|
| 20 | })
|
| 21 | })
|
| 22 |
|
| 23 | test(`${name}: set Stream, get Stream`, t => {
|
| 24 | t.plan(3)
|
| 25 | let p = proxy()
|
| 26 | let x = Buffer.from('asdf')
|
| 27 | store.set(p, (err, hash) => {
|
| 28 | t.error(err)
|
| 29 | let stream = store.getStream(hash)
|
| 30 | stream.on('error', err => { throw err })
|
| 31 | stream.pipe(bl((err, buff) => {
|
| 32 | t.error(err)
|
| 33 | t.deepEquals(x, buff)
|
| 34 | }))
|
| 35 | })
|
| 36 | p.write(x)
|
| 37 | p.end()
|
| 38 | })
|
| 39 |
|
| 40 | test(`${name}: consistent hashing w/ set API`, t => {
|
| 41 | t.plan(3)
|
| 42 | let buff = Buffer.from('asldkfjalskdjflkasdjf')
|
| 43 | store.set(buff, (err, hash) => {
|
| 44 | t.error(err)
|
| 45 | store.set(buff, (err, _hash) => {
|
| 46 | t.error(err)
|
| 47 | t.equals(hash, _hash)
|
| 48 | })
|
| 49 | })
|
| 50 | })
|
| 51 |
|
| 52 | test(`${name}: consistent hashing w/ hash API, Buffer`, t => {
|
| 53 | t.plan(3)
|
| 54 | let buff = Buffer.from('asldkfjalskdjfldddkasdjf')
|
| 55 | store.hash(buff, (err, hash) => {
|
| 56 | t.error(err)
|
| 57 | store.hash(buff, (err, _hash) => {
|
| 58 | t.error(err)
|
| 59 | t.equals(hash, _hash)
|
| 60 | })
|
| 61 | })
|
| 62 | })
|
| 63 |
|
| 64 | test(`${name}: consistent hashing w/ hash API, Stream`, t => {
|
| 65 | t.plan(3)
|
| 66 | let buff = Buffer.from('asldkfjalskdjfldddkasdjf')
|
| 67 | let stream = bl()
|
| 68 | store.hash(stream, (err, hash) => {
|
| 69 | t.error(err)
|
| 70 | stream = bl()
|
| 71 | store.hash(buff, (err, _hash) => {
|
| 72 | t.error(err)
|
| 73 | t.equals(hash, _hash)
|
| 74 | })
|
| 75 | stream.write(buff)
|
| 76 | stream.end()
|
| 77 | })
|
| 78 | stream.write(buff)
|
| 79 | stream.end()
|
| 80 | })
|
| 81 |
|
| 82 | test(`${name}: get Buffer from key that has not been stored`, t => {
|
| 83 | t.plan(1)
|
| 84 | store.getBuffer('notfound', (err, buff) => {
|
| 85 | t.type(err, 'Error')
|
| 86 | if (buff) throw new Error('Got buffer from key not stored.')
|
| 87 | })
|
| 88 | })
|
| 89 |
|
| 90 | test(`${name}: get Stream from key that has not been stored`, t => {
|
| 91 | let stream = store.getStream('notfound')
|
| 92 | t.plan(1)
|
| 93 | stream.on('error', err => t.type(err, 'Error'))
|
| 94 | stream.on('data', chunk => { throw new Error('Got data from key not stored.') })
|
| 95 | })
|
| 96 |
|
| 97 | test(`${name}: set Buffer, get Stream, validate identical`, t => {
|
| 98 | t.plan(3)
|
| 99 | let buff = Buffer.allocUnsafe(1024 * 1000 * 50)
|
| 100 | store.set(buff, (err, hash) => {
|
| 101 | t.error(err)
|
| 102 | let b = bl((err, _buff) => {
|
| 103 | t.error(err)
|
| 104 | t.deepEquals(_buff.slice(), buff)
|
| 105 | })
|
| 106 | let stream = store.getStream(hash)
|
| 107 | stream.pipe(b)
|
| 108 | })
|
| 109 | })
|
| 110 |
|
| 111 | test(`${name}: set invalid values`, t => {
|
| 112 | t.plan(4)
|
| 113 | store.set({}, err => t.type(err, 'Error'))
|
| 114 | store.set(null, err => t.type(err, 'Error'))
|
| 115 | store.set('asdf', err => t.type(err, 'Error'))
|
| 116 | store.set(1123454, err => t.type(err, 'Error'))
|
| 117 | })
|
| 118 |
|
| 119 | test(`${name}: hash invalid values`, t => {
|
| 120 | t.plan(4)
|
| 121 | store.hash({}, err => t.type(err, 'Error'))
|
| 122 | store.hash(null, err => t.type(err, 'Error'))
|
| 123 | store.hash('asdf', err => t.type(err, 'Error'))
|
| 124 | store.hash(1123454, err => t.type(err, 'Error'))
|
| 125 | })
|
| 126 | }
|