@nraynaud/xo-vmdk-to-vhd/dist/vhd-write.spec.js

'use strict';

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _chai = require('chai');

var _chai2 = _interopRequireDefault(_chai);

var _chaiAsPromised = require('chai-as-promised');

var _chaiAsPromised2 = _interopRequireDefault(_chaiAsPromised);

var _fs = require('fs');

var _mocha = require('mocha');

var _childProcessPromise = require('child-process-promise');

var _fsPromise = require('fs-promise');

var _vhdWrite = require('./vhd-write');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_chai2.default.use(_chaiAsPromised2.default);


(0, _mocha.describe)('VHD writing', function () {
  (0, _mocha.it)('computeChecksum() is correct against some reference values', function () {
    // those values were taken from a file generated by qemu
    var testValue1 = '636F6E6563746978000000020001000000000000000002001F34DB9F71656D75000500035769326B0000000000019800000000000001980000030411000000030000000033B3A5E17F94433498376740246E5660';
    var expectedChecksum1 = 0xFFFFEFB2;
    var testValue2 = '6378737061727365FFFFFFFFFFFFFFFF0000000000000600000100000000000100200000';
    var expectedChecksum2 = 0xFFFFF476;
    _chai.assert.equal((0, _vhdWrite.computeChecksum)(new Buffer(testValue1, 'hex')), expectedChecksum1);
    _chai.assert.equal((0, _vhdWrite.computeChecksum)(new Buffer(testValue2, 'hex')), expectedChecksum2);
  });
  (0, _mocha.it)('createFooter() does not crash', function () {
    (0, _vhdWrite.createFooter)(104448, Math.floor(Date.now() / 1000), { cylinders: 3, heads: 4, sectorsPerTrack: 17 });
  });
  (0, _mocha.it)('createDynamicDiskHeader() does not crash', function () {
    (0, _vhdWrite.createDynamicDiskHeader)(1, 0x00200000);
  });
  (0, _mocha.it)('ReadableRawVHDStream does not crash', (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2() {
    var data, index, mockParser, stream, pipe;
    return _regenerator2.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            data = [{
              lbaBytes: 100,
              grain: new Buffer('azerzaerazeraze', 'ascii')
            }, {
              lbaBytes: 700,
              grain: new Buffer('gdfslkdfguer', 'ascii')
            }];
            index = 0;
            mockParser = {
              next: function () {
                var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
                  var result;
                  return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                      switch (_context.prev = _context.next) {
                        case 0:
                          if (!(index < data.length)) {
                            _context.next = 6;
                            break;
                          }

                          result = data[index];

                          index++;
                          return _context.abrupt('return', result);

                        case 6:
                          return _context.abrupt('return', null);

                        case 7:
                        case 'end':
                          return _context.stop();
                      }
                    }
                  }, _callee, undefined);
                }));

                function next() {
                  return _ref2.apply(this, arguments);
                }

                return next;
              }()
            };
            stream = new _vhdWrite.ReadableRawVHDStream(100000, mockParser);
            pipe = stream.pipe((0, _fs.createWriteStream)('outputStream'));
            _context2.next = 7;
            return new _promise2.default(function (resolve, reject) {
              pipe.on('finish', resolve);
              pipe.on('error', reject);
            });

          case 7:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, undefined);
  })));
  (0, _mocha.it)('ReadableRawVHDStream detects when blocks are out of order', (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4() {
    var data, index, mockParser;
    return _regenerator2.default.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            data = [{
              lbaBytes: 700,
              grain: new Buffer('azerzaerazeraze', 'ascii')
            }, {
              lbaBytes: 100,
              grain: new Buffer('gdfslkdfguer', 'ascii')
            }];
            index = 0;
            mockParser = {
              next: function () {
                var _ref4 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3() {
                  var result;
                  return _regenerator2.default.wrap(function _callee3$(_context3) {
                    while (1) {
                      switch (_context3.prev = _context3.next) {
                        case 0:
                          if (!(index < data.length)) {
                            _context3.next = 6;
                            break;
                          }

                          result = data[index];

                          index++;
                          return _context3.abrupt('return', result);

                        case 6:
                          return _context3.abrupt('return', null);

                        case 7:
                        case 'end':
                          return _context3.stop();
                      }
                    }
                  }, _callee3, undefined);
                }));

                function next() {
                  return _ref4.apply(this, arguments);
                }

                return next;
              }()
            };
            return _context4.abrupt('return', _chai.assert.isRejected(new _promise2.default(function (resolve, reject) {
              var stream = new _vhdWrite.ReadableRawVHDStream(100000, mockParser);
              stream.on('error', reject);
              var pipe = stream.pipe((0, _fs.createWriteStream)('outputStream'));
              pipe.on('finish', resolve);
              pipe.on('error', reject);
            })));

          case 4:
          case 'end':
            return _context4.stop();
        }
      }
    }, _callee4, undefined);
  })));
  (0, _mocha.it)('writing a known file with VHDFile is successful', (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee5() {
    var fileName, rawFilename, randomFileName, geometry, dataSize, buffer, f, splitPoint, fileContent, i;
    return _regenerator2.default.wrap(function _callee5$(_context5) {
      while (1) {
        switch (_context5.prev = _context5.next) {
          case 0:
            fileName = 'output.vhd';
            rawFilename = 'output.raw';
            randomFileName = 'random.raw';
            geometry = (0, _vhdWrite.computeGeometryForSize)(1024 * 1024 * 8);
            dataSize = geometry.actualSize;
            _context5.next = 7;
            return (0, _childProcessPromise.exec)('base64 /dev/urandom | head -c ' + dataSize + ' > ' + randomFileName);

          case 7:
            _context5.next = 9;
            return (0, _fsPromise.readFile)(randomFileName);

          case 9:
            buffer = _context5.sent;
            f = new _vhdWrite.VHDFile(buffer.length, 523557791);
            splitPoint = Math.floor(Math.random() * buffer.length);

            f.writeBuffer(buffer.slice(splitPoint), splitPoint);
            f.writeBuffer(buffer.slice(0, splitPoint), 0);
            f.writeBuffer(buffer.slice(splitPoint), splitPoint);
            _context5.next = 17;
            return f.writeFile(fileName);

          case 17:
            _context5.next = 19;
            return (0, _childProcessPromise.exec)('qemu-img convert -fvpc -Oraw ' + fileName + ' ' + rawFilename);

          case 19:
            _context5.next = 21;
            return (0, _fsPromise.readFile)(rawFilename);

          case 21:
            fileContent = _context5.sent;

            _chai.assert.equal(fileContent.length, dataSize);
            for (i = 0; i < fileContent.length; i++) {
              if (fileContent[i] !== buffer[i]) {
                _chai.assert.fail(fileContent[i], 0);
              }
            }

          case 24:
          case 'end':
            return _context5.stop();
        }
      }
    }, _callee5, undefined);
  })));
});
//# sourceMappingURL=vhd-write.spec.js.map