aye-spy/lib/remoteActions.js

A visual regression tool

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.updateRemotePolicy = exports.archiveRemoteKeys = exports.uploadRemoteKeys = exports.resolveImagePath = exports.listRemoteKeys = exports.fetchRemoteKeys = exports.deleteRemoteBucket = exports.deleteRemoteKeys = exports.createRemote = undefined;

var _awsSdk = require('aws-sdk');

var _awsSdk2 = _interopRequireDefault(_awsSdk);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _logger = require('./logger');

var _logger2 = _interopRequireDefault(_logger);

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

const resolveImagePath = (key, config) => new Promise((resolve, reject) => {
  if (key === 'latest') resolve(_path2.default.resolve(config.latest));
  if (key === 'baseline') resolve(_path2.default.resolve(config.baseline));
  if (key === 'generatedDiffs') resolve(_path2.default.resolve(config.generatedDiffs));
  if (key === 'report') resolve(_path2.default.resolve(config.report));
  reject('The key did not match any of the available options');
});

const createRemote = config => {
  _awsSdk2.default.config.update({ region: config.remoteRegion });
  const s3 = new _awsSdk2.default.S3();

  const params = {
    Bucket: config.remoteBucketName,
    ACL: config.remoteBucketAccess === 'public' ? 'public-read-write' : 'private',
    CreateBucketConfiguration: {
      LocationConstraint: config.remoteRegion
    }
  };

  return s3.createBucket(params).promise().catch(err => {
    if (err.code === 'BucketAlreadyOwnedByYou') {
      return;
    } else {
      _logger2.default.error('remote-actions', err);
    }
  });
};

const updateRemotePolicy = config => {
  if (config.remote && config.remoteBucketAccess === 'public') {
    _awsSdk2.default.config.update({ region: config.remoteRegion });
    const s3 = new _awsSdk2.default.S3();
    const Policy = `{
      "Version": "2008-10-17",
      "Id": "AyeSpyPolicy",
      "Statement": [
          {
              "Sid": "Stmt1397633323327",
              "Effect": "Allow",
              "Principal": {
                  "AWS": "*"
              },
              "Action": "s3:GetObject",
              "Resource": "arn:aws:s3:::${config.remoteBucketName}/*"
          }
      ]
    }`;

    const params = {
      Bucket: config.remoteBucketName,
      Policy
    };

    return s3.putBucketPolicy(params).promise();
  }
};

function createDeletionParams(filteredResults, config) {
  const params = {
    Bucket: config.remoteBucketName,
    Delete: {
      Objects: [],
      Quiet: false
    }
  };

  for (let i = 0; i < filteredResults.length; i++) {
    const keyObject = { Key: filteredResults[i].Key };
    params.Delete.Objects.push(keyObject);
  }
  return params;
}

const deleteRemoteKeys = async (key, config) => {
  const filteredResults = await listRemoteKeys(key, config);

  _awsSdk2.default.config.update({ region: config.remoteRegion });
  const s3 = new _awsSdk2.default.S3();

  const params = createDeletionParams(filteredResults, config);

  if (filteredResults.length !== 0) {
    return s3.deleteObjects(params).promise().then(() => {
      return params.Delete.Objects;
    }).catch(err => _logger2.default.error('remote-actions', err));
  }
};

const deleteRemoteBucket = config => {
  _awsSdk2.default.config.update({ region: config.remoteRegion });
  const s3 = new _awsSdk2.default.S3();

  const params = {
    Bucket: config.remoteBucketName
  };

  return s3.deleteBucket(params).promise().catch(err => _logger2.default.error('remote-actions', err));
};

const fetchRemoteKeys = (config, key, imageName) => new Promise(async (resolve, reject) => {
  const imageDir = await resolveImagePath(key, config);
  const dir = key === 'baseline' ? `${config.browser}/default` : `${config.browser}/${config.branch}`;
  const remoteFileName = `${dir}/${key}/${imageName}`;
  const fileName = `${imageDir}/${imageName}`;
  const s3 = new _awsSdk2.default.S3();
  _awsSdk2.default.config.update({ region: config.remoteRegion });
  const params = { Bucket: config.remoteBucketName, Key: remoteFileName };

  s3.getObject(params, (error, data) => {
    if (error) return reject(`Unable to find remote Image: ${imageName}`);
    _fs2.default.writeFileSync(fileName, data.Body);
    resolve();
  });
});

const listRemoteKeys = (key, config) => {
  _awsSdk2.default.config.update({ region: config.remoteRegion });
  const s3 = new _awsSdk2.default.S3();
  const params = { Bucket: config.remoteBucketName };
  const dir = key === 'baseline' ? `${config.browser}/default` : `${config.browser}/${config.branch}`;

  return s3.listObjectsV2(params).promise().then(result => {
    return result.Contents.filter(item => item.Key.includes(`${dir}/${key}`));
  }).catch(err => _logger2.default.error('remote-actions', err));
};

const uploadRemoteKeys = async (key, config) => {
  const imageDir = await resolveImagePath(key, config);
  _awsSdk2.default.config.update({
    region: config.remoteRegion
  });
  const s3 = new _awsSdk2.default.S3();
  const files = _fs2.default.readdirSync(imageDir).map(file => `${imageDir}/${file}`);

  if (files.length !== 0) {
    _logger2.default.info('remote-actions', `${files.length} images to be uploaded to bucket: ${key}`);
  }

  return Promise.all(files.map(file => {
    const fileStream = _fs2.default.createReadStream(file);

    fileStream.on('error', err => {
      _logger2.default.error('remote-actions', err);
    });

    const contentType = key === 'report' ? 'text/html' : 'image/png';

    const dir = key === 'baseline' ? `${config.browser}/default` : `${config.browser}/${config.branch}`;

    _logger2.default.info('remote-actions', `Uploading to S3: ${dir}/${key}/${_path2.default.basename(file)}`);

    const uploadParams = {
      Bucket: config.remoteBucketName,
      Key: `${dir}/${key}/${_path2.default.basename(file)}`,
      Body: fileStream,
      ContentType: contentType
    };

    return s3.putObject(uploadParams).promise();
  })).catch(err => _logger2.default.error('remote-actions', err));
};

const archiveRemoteKeys = async (key, config) => {
  const imageDir = await resolveImagePath(key, config);
  _awsSdk2.default.config.update({
    region: config.remoteRegion
  });
  const s3 = new _awsSdk2.default.S3();
  const files = _fs2.default.readdirSync(imageDir).map(file => `${imageDir}/${file}`);
  const options = {
    weekday: 'long',
    year: 'numeric',
    month: 'long',
    day: 'numeric',
    hour: 'numeric',
    minute: 'numeric'
  };
  const date = new Date().toLocaleDateString('default', options);

  if (files.length !== 0) {
    _logger2.default.info('remote-actions', `${files.length} images to be archived to bucket: archive/${date}/${key}`);
  }

  return Promise.all(files.map(file => {
    const fileStream = _fs2.default.createReadStream(file);

    fileStream.on('error', err => {
      _logger2.default.error('remote-actions', err);
    });

    const dir = `${config.browser}/default/archive/${date}`;

    _logger2.default.info('remote-actions', `Uploading to S3: ${dir}/${key}/${_path2.default.basename(file)}`);

    const uploadParams = {
      Bucket: config.remoteBucketName,
      Key: `${dir}/${key}/${_path2.default.basename(file)}`,
      Body: fileStream,
      ContentType: 'image/png'
    };

    return s3.putObject(uploadParams).promise();
  })).catch(err => _logger2.default.error('remote-actions', err));
};

exports.createRemote = createRemote;
exports.deleteRemoteKeys = deleteRemoteKeys;
exports.deleteRemoteBucket = deleteRemoteBucket;
exports.fetchRemoteKeys = fetchRemoteKeys;
exports.listRemoteKeys = listRemoteKeys;
exports.resolveImagePath = resolveImagePath;
exports.uploadRemoteKeys = uploadRemoteKeys;
exports.archiveRemoteKeys = archiveRemoteKeys;
exports.updateRemotePolicy = updateRemotePolicy;