How to use the beamcoder.format function in beamcoder

test('GET a stream', async t => {
  try {
    t.ok(await flushdb(), 'database flushed OK.');

    t.comment('### Retrieve a stream');
    t.deepEqual(await redisio.storeFormat(testUtil.fmt), ['OK','OK','OK'],
      'test format stored.');
    let response = await request(server).get('/beams/test_url/stream_1').expect(200);
    t.ok(response.ok, 'response claims OK.');
    t.equal(response.type, 'application/json', 'response is JSON.');
    let fmt = beamcoder.format();
    let str = fmt.newStream(response.body);
    str.__index(response.body.index);
    t.deepEqual(str.toJSON(), testUtil.stream1, 'roundtrip equal.');

    t.comment('### Retrive a stream that does not exist.');
    response = await request(server).get('/beams/test_url/stream_42').expect(404);
    t.notOk(response.ok, 'response is not OK.');
    t.equal(response.type, 'application/json', 'response is JSON.');
    t.deepEqual(response.body, { statusCode: 404,
      error: 'Not Found',
      message: `Stream with name 'test_url:stream_42' was not found: Unable to retrieve a stream with key 'beamengine:test_url:stream_42'.` },  // eslint-disable-line
    'error message structure as expected.');

    t.comment('### Retrieve a stream by type - video');
    response = await request(server).get('/beams/test_url/video').expect(200);
    t.ok(response.ok, 'response claims OK.');

test('GET a format', async t => {
  try {
    t.ok(await flushdb(), 'database flushed OK.');

    t.comment('### Retrieve a format');
    t.deepEqual(await redisio.storeFormat(testUtil.fmt), ['OK','OK','OK'],
      'test format stored.');
    let response = await request(server).get('/beams/test_url').expect(200);
    t.ok(response.ok, 'response claims OK.');
    t.equal(response.type, 'application/json', 'response is JSON.');
    let fmt = beamcoder.format(response.body);
    t.deepEqual(stripNewStream(fmt), stripNewStream(testUtil.fmt), 'roundtrip equal.');

    t.comment('### Retrive a format that does not exist.');
    response = await request(server).get('/beams/wibble').expect(404);
    t.notOk(response.ok, 'response is not OK.');
    t.equal(response.type, 'application/json', 'response is JSON.');
    t.deepEqual(response.body, { statusCode: 404,
      error: 'Not Found',
      message: `Format with name 'wibble' was not found: Unable to retrieve a format with key 'beamengine:wibble'.` },  // eslint-disable-line
    'error message structure as expected.');

  } catch (err) {
    t.fail(err);
  }
  t.end();
});

test('Roundtrip a stream', async t => {
  let fmt = beamcoder.format();
  let s = fmt.newStream({
    name:'h264',
    side_data: { replaygain: Buffer.from('Magic Roundabout') },
    metadata: { jelly: 'plate' }
  });
  const redis = new Redis();
  await redis.del('beam:stream:test');

  //for ( let x = 0 ; x < 100 ; x++ ) {
  let start = process.hrtime();
  let sr = streamToRedis(s.toJSON());
  let end = process.hrtime(start);
  console.log('streamToRedis', end);
  start = process.hrtime();

  t.equal(await redis.hmset('beam:stream:test', sr), 'OK', 'reports set OK.');

test('Roundtrip format', async t => {
  let fmt = beamcoder.format({
    oformat: 'wav',
    url: 'this_is_my_name',
    priv_data: { peak_block_size: 192 },
    key: Buffer.from('Wibble wobble'),
    metadata: { jelly: 'plate' }
  });
  let redis = new Redis();
  await redis.del('beam:testing:format');

  let start = process.hrtime();
  let fmtr = formatToRedis(fmt.toJSON());
  console.log('formatToRedis', process.hrtime(start));

  start = process.hrtime();
  t.equal(await redis.hmset('beam:testing:format', fmtr), 'OK', 'redis set reports OK.');
  console.log('redis set', console.log(process.hrtime(start)));

let fmtr = formatToRedis(fmt.toJSON());
  console.log('formatToRedis', process.hrtime(start));

  start = process.hrtime();
  t.equal(await redis.hmset('beam:testing:format', fmtr), 'OK', 'redis set reports OK.');
  console.log('redis set', console.log(process.hrtime(start)));

  start = process.hrtime();
  let rfmtb = await redis.hgetallBuffer('beam:testing:format');
  console.log('redis get', process.hrtime(start));

  start = process.hrtime();
  let rfmto = formatFromRedis(rfmtb);
  console.log('formatFromRedis', process.hrtime(start));

  let rfmt = beamcoder.format(rfmto);
  t.ok(rfmt, 'roundtrip format is truthy.');

  t.equal(rfmt.oformat.name, 'wav', 'has WAV output format.');
  t.equal(rfmt.priv_data.peak_block_size, 192, 'has expected priv_data.peak_block_size.');
  t.equal(Buffer.compare(rfmt.key, Buffer.from('Wibble wobble')), 0, 'has expected key.');
  t.deepEqual(rfmt.metadata, { jelly: 'plate' }, 'has expected metadata.');

  await redis.quit();
  t.end();
});

test('List contents', async t => {
  try {
    let response = await request(server).get('/beams')
      .expect(200)
      .expect([]);
    t.ok(response.ok, 'empty response is OK.');
    t.equal(response.type, 'application/json', 'response is JSON.');

    let fmt = beamcoder.format({ url: 'test_url' });
    t.deepEqual(await redisio.storeFormat(fmt), ['OK'], 'stored test format.');
    response = await request(server).get('/beams')
      .expect(200)
      .expect([ 'test_url' ]);
    t.ok(response.ok, 'content now has the expected item.');

    t.comment('### Checking default range request.');
    t.ok(await flushdb(), 'database flushed OK.');
    for ( let x = 0 ; x < 100 ; x++ ) {
      fmt = beamcoder.format({ url: `test_url_${x}` });
      await redisio.storeFormat(fmt);
    }
    response = await request(server).get('/beams')
      .expect(200);
    t.ok(Array.isArray(response.body), 'response body is an array ...');
    t.equal(response.body.length, 10, '... of the default limit length of 10.');

get fmt() {
    let bfmt = beamcoder.format(fmt);
    bfmt.newStream(stream0);
    bfmt.newStream(stream1);
    return bfmt;
  },
  get pkt() {

.expect(200)
      .expect([]);
    t.ok(response.ok, 'empty response is OK.');
    t.equal(response.type, 'application/json', 'response is JSON.');

    let fmt = beamcoder.format({ url: 'test_url' });
    t.deepEqual(await redisio.storeFormat(fmt), ['OK'], 'stored test format.');
    response = await request(server).get('/beams')
      .expect(200)
      .expect([ 'test_url' ]);
    t.ok(response.ok, 'content now has the expected item.');

    t.comment('### Checking default range request.');
    t.ok(await flushdb(), 'database flushed OK.');
    for ( let x = 0 ; x < 100 ; x++ ) {
      fmt = beamcoder.format({ url: `test_url_${x}` });
      await redisio.storeFormat(fmt);
    }
    response = await request(server).get('/beams')
      .expect(200);
    t.ok(Array.isArray(response.body), 'response body is an array ...');
    t.equal(response.body.length, 10, '... of the default limit length of 10.');
    t.equal(response.body[0], 'test_url_0', 'first element as expected.');
    t.equal(response.body[9], 'test_url_9', 'last element as expected.');

    t.comment('### Limit and offset.');
    response = await request(server).get('/beams?offset=10&limit=42')
      .expect(200);
    t.ok(Array.isArray(response.body), 'response body is an array ...');
    t.equal(response.body.length, 42, '... of the set limit length of 42.');
    t.equal(response.body[0], 'test_url_10', 'first element as expected.');
    t.equal(response.body[41], 'test_url_51', 'last element as expected.');

async function createBeam (ctx) {
  console.log(ctx.request.type, ctx.request.body);
  if ((!ctx.request.body) || (ctx.request.type != 'application/json') ||
    (typeof ctx.request.body !== 'object')) {
    throw Boom.badRequest('Request body must be a JSON document describing a format.');
  }
  if ((ctx.request.body.type !== 'format') && (ctx.request.body.type !== 'muxer') &&
     (ctx.request.body.type !== 'demuxer')) {
    throw Boom.badRequest('Request body must be of format type.');
  }
  let fmt;
  try {
    ctx.request.body.streams.forEach(x => x.codecpar && delete x.codecpar.codec_tag);
    fmt = beamcoder.format(ctx.request.body);
    let storeResult = await redisio.storeFormat(fmt, false);
    if (!storeResult.every(x => x && x.startsWith('OK'))) {
      throw Boom.badGateway('Failure to store format into Redis.');
    }
  } catch (err) {
    if (err.message.indexOf('exists') >= 0)
      throw Boom.conflict(err.message);
    throw Boom.badImplementation(err.message);
  }
  ctx.set('Location', beamPath({ fmtSpec: fmt.url }));
  ctx.status = 201;
  ctx.body = fmt;
}

async function retrieveFormat(url) {
  let redisZero = await redisPool.use();
  let key = `${config.redis.prepend}:${url}`;
  let fmtb = await redisZero.hgetallBuffer(key);
  if ((!fmtb) || (Object.keys(fmtb).length === 0)) {
    redisPool.recycle(redisZero);
    throw new Error(`Unable to retrieve a format with key '${key}'.`);
  }
  let fmto = mappings.formatFromRedis(fmtb);
  let result = beamcoder.format(fmto);
  if (fmto.nb_streams > 0) {
    let redisProms = [ redisZero ];
    for ( let x = 1 ; x < fmto.nb_streams ; x++ ) {
      redisProms.push(redisPool.use());
    }
    let redis = await Promise.all(redisProms);
    let getWork = [];
    for ( let x = 0 ; x < redis.length ; x++ ) {
      getWork.push(redis[x].hgetallBuffer(`${key}:stream_${x}`));
    }
    let strs = await Promise.all(getWork);
    if (strs.some(x => x === null)) {
      redis.forEach(x => redisPool.recycle(x));
      throw new Error(`Cannot retrieve at least one of the streams '${strs.map(x => x ? '.' : 'X')}'.`);
    }
    for ( let x = 0 ; x < strs.length ; x++ ) {