http-keeper/test/index.js

Basic offline keeper with fallback to fetching files via http

var fs = require('fs')
var http = require('http')
var path = require('path')
var parseUrl = require('url').parse
var test = require('tape')
var Q = require('q')
var rimraf = require('rimraf')
var Keeper = require('../')
var Offline = require('offline-keeper')
var Server = require('bitkeeper-server-js')
var testDir = path.resolve('./tmp')
var basePort = 53352

rimraf.sync(testDir)

test('flat vs github dir structure', function (t) {
  debugger
  var flat = new Keeper({
    storage: testDir,
    flat: true
  })

  var github = new Keeper({
    storage: testDir
  })

  var key = '64fe16cc8a0c61c06bc403e02f515ce5614a35f1'
  var a = flat.put(new Buffer('1'))
    .then(function () {
      fs.exists(path.join(testDir, key), t.ok)
    })

  var b = github.put(new Buffer('1'))
    .then(function () {
      debugger
      fs.exists(path.join(testDir, key.slice(0, 2), key.slice(2)), t.ok)
    })

  Q.all([a, b])
    .done(function () {
      rimraf.sync(testDir)
      t.end()
    })
})

test('test invalid keys', function (t) {
  t.plan(1)

  var keeper = new Keeper({
    storage: testDir
  })

  keeper.put('a', new Buffer('b'))
    .then(function () {
      t.fail()
    })
    .catch(function (err) {
      t.pass()
    })
    .done()
})

test('put, get', function (t) {
  t.plan(2)

  var keeper = new Keeper({
    storage: testDir
  })

  var k = [
    // infoHashes of values
    '64fe16cc8a0c61c06bc403e02f515ce5614a35f1',
    '0a745fb75a7818acf09f27de1db7a76081d22776',
    'bd45a097c00e557ea871233ea21d27a47f8f21a9'
  ]

  var v = ['1', '2', '3'].map(Buffer)
  keeper.putOne(k[0], v[0])
    .then(function () {
      return keeper.getOne(k[0])
    })
    .then(function (v0) {
      t.deepEqual(v0, v[0])
    })
    .then(function () {
      // keeper should derive key
      return keeper.putMany(v.slice(1))
    })
    .then(function () {
      return keeper.getMany(k)
    })
    .then(function (vals) {
      t.deepEqual(vals, v)
      rimraf.sync(testDir)
    })
    .done()
})

// test('timeout', function (t) {
//   var clientKeeper = new Keeper({
//     storage: testDir,
//     fallbacks: ['127.0.0.1:' + basePort]
//   })

//   var server = http.createServer(function (c) {
//     // hang
//   })

//   server.listen(basePort, function () {
//     clientKeeper.getOne('blah', 500)
//       .catch(function (err) {
//         t.ok(/time/.test(err.message))
//         server.close()
//         clientKeeper.close()
//         rimraf.sync(testDir)
//         t.end()
//       })
//       .done()
//   })
// })

test('put, get, fallback', function (t) {
  // each server only has one value
  var map = {
    "64fe16cc8a0c61c06bc403e02f515ce5614a35f1": new Buffer('1'),
    "0a745fb75a7818acf09f27de1db7a76081d22776": new Buffer('2'),
    "bd45a097c00e557ea871233ea21d27a47f8f21a9": new Buffer('3'),
    "de1ea0a4ec16e8c7b10cb1dde3bf644be2fb5c57": new Buffer('4'),
    e: new Buffer('5') // invalid
  }

  var keys = Object.keys(map).sort(function (a, b) {
    if (a < b) return -1
    if (a > b) return 1
    return 0
  })

  var vals = keys.map(function (k) {
    return k === 'e' ? undefined : map[k]
  })

  var togo = 0
  var serverKeepers = []
  var mkServers = keys.map(function (key, i) {
    togo++
    var serverKeeper = new Offline({
      storage: testDir + '/offline/' + i
    })

    serverKeepers.push(serverKeeper)
    return serverKeeper.put(key, map[key])
      .catch(function (err) {
        // one value is invalid
      })
      .then(function () {
        return Q.ninvoke(Server, 'create', {
          keeper: serverKeeper,
          port: basePort + i
        })
      })
  })

  var servers
  var clientKeeper
  Q.all(mkServers)
    .then(function (_servers) {
      servers = _servers
      clientKeeper = new Keeper({
        storeOnFetch: true,
        storage: testDir,
        fallbacks: servers.map(function (s, i) {
          return '127.0.0.1:' + (basePort + i)
        })
      })

      return clientKeeper.getMany(keys)
    })
    .then(function (v) {
      t.deepEqual(v, vals)
    })
    .then(function () {
      servers.forEach(function (server) {
        return server.close()
      })

      // should be stored
      return clientKeeper.getMany(keys)
    })
    .then(function (v) {
      t.deepEqual(v, vals)
      return clientKeeper.close()
    })
    .done(function () {
      rimraf.sync(testDir)
      t.end()
    })
})

test('put upload', function (t) {
  var serverKeeper = new Offline({
    storage: testDir + '/server'
  })

  var key = '64fe16cc8a0c61c06bc403e02f515ce5614a35f1'
  var val = new Buffer('1')
  var server
  var clientKeeper
  Q.ninvoke(Server, 'create', {
      keeper: serverKeeper,
      port: basePort
    })
    .then(function (_server) {
      server = _server
      clientKeeper = new Keeper({
        storage: testDir,
        fallbacks: [
          '127.0.0.1:' + basePort
        ]
      })

      return clientKeeper.putOne({
        key: key,
        value: val,
        push: true
      })
    })
    .then(function () {
      return serverKeeper.getOne(key)
    })
    .then(function (v) {
      t.deepEqual(v, val)
      t.end()
      server.close()
      return clientKeeper.close()
    })
    .done(function () {
      rimraf.sync(testDir)
    })
})