Adds functioning tests

Author: flovilmart

.travis.yml

@@ -0,0 +1,6 @@
+branches:
+  only:
+    - master
+language: node_js
+node_js:
+  - "4.3"

index.js

@@ -0,0 +1,152 @@
+'use strict';
+// S3Adapter
+//
+// Stores Parse files in AWS S3.
+
+var AWS = require('aws-sdk');
+const DEFAULT_S3_REGION = "us-east-1";
+
+function requiredOrFromEnvironment(options, key, env) {
+  options[key] = options[key] || process.env[env];
+  if (!options[key]) {
+    throw `S3Adapter requires option '${key}' or env. variable ${env}`;
+  }
+  return options;
+}
+
+function fromEnvironmentOrDefault(options, key, env, defaultValue) {
+  options[key] = options[key] || process.env[env] || defaultValue;
+  return options;
+}
+
+function optionsFromArguments(args) {
+  let options = {};
+  let accessKeyOrOptions = args[0];
+  if (typeof accessKeyOrOptions == 'string') {
+    options.accessKey = accessKeyOrOptions;
+    options.secretKey = args[1];
+    options.bucket = args[2];
+    let otherOptions = args[3];
+    if (otherOptions) {
+      options.bucketPrefix = otherOptions.bucketPrefix;
+      options.directAccess = otherOptions.directAccess;
+    }
+  } else {
+    options = accessKeyOrOptions || {};
+  }
+  options = requiredOrFromEnvironment(options, 'accessKey', 'S3_ACCESS_KEY');
+  options = requiredOrFromEnvironment(options, 'secretKey', 'S3_SECRET_KEY');
+  options = requiredOrFromEnvironment(options, 'bucket', 'S3_BUCKET');
+  options = fromEnvironmentOrDefault(options, 'bucketPrefix', 'S3_BUCKET_PREFIX', '');
+  options = fromEnvironmentOrDefault(options, 'region', 'S3_REGION', false);
+  options = fromEnvironmentOrDefault(options, 'directAccess', 'S3_DIRECT_ACCESS', false);
+  return options;
+}
+
+// Creates an S3 session.
+// Providing AWS access, secret keys and bucket are mandatory
+// Region will use sane defaults if omitted
+function S3Adapter() {
+  var options = optionsFromArguments(arguments);
+  this._region = options.region;
+  this._bucket = options.bucket;
+  this._bucketPrefix = options.bucketPrefix;
+  this._directAccess = options.directAccess;
+
+  let s3Options = {
+    accessKeyId: options.accessKey,
+    secretAccessKey: options.secretKey,
+    params: { Bucket: this._bucket }
+  };
+  AWS.config._region = this._region;
+  this._s3Client = new AWS.S3(s3Options);
+  this._hasBucket = false;
+}
+
+S3Adapter.prototype.createBucket = function() {
+  var promise;
+  if (this._hasBucket) {
+    promise = Promise.resolve();
+  } else {
+    promise = new Promise((resolve, reject) => {
+      this._s3Client.createBucket(() => {
+        this._hasBucket = true;
+        resolve();
+      });
+    });
+  }
+  return promise;
+}
+
+// For a given config object, filename, and data, store a file in S3
+// Returns a promise containing the S3 object creation response
+S3Adapter.prototype.createFile = function(filename, data, contentType) {
+  let params = {
+    Key: this._bucketPrefix + filename,
+    Body: data
+  };
+  if (this._directAccess) {
+    params.ACL = "public-read"
+  }
+  if (contentType) {
+    params.ContentType = contentType;
+  }
+  return this.createBucket().then(() => {
+    return new Promise((resolve, reject) => {
+      this._s3Client.upload(params, (err, data) => {
+        if (err !== null) {
+          return reject(err);
+        }
+        resolve(data);
+      });
+    });
+  });
+}
+
+S3Adapter.prototype.deleteFile = function(filename) {
+  return this.createBucket().then(() => {
+    return new Promise((resolve, reject) => {
+      let params = {
+        Key: this._bucketPrefix + filename
+      };
+      this._s3Client.deleteObject(params, (err, data) =>{
+        if(err !== null) {
+          return reject(err);
+        }
+        resolve(data);
+      });
+    });
+  });
+}
+
+// Search for and return a file if found by filename
+// Returns a promise that succeeds with the buffer result from S3
+S3Adapter.prototype.getFileData = function(filename) {
+  let params = {Key: this._bucketPrefix + filename};
+  return this.createBucket().then(() => {
+    return new Promise((resolve, reject) => {
+      this._s3Client.getObject(params, (err, data) => {
+        if (err !== null) {
+          return reject(err);
+        }
+        // Something happend here...
+        if (data && !data.Body) {
+          return reject(data);
+        }
+        resolve(data.Body);
+      });
+    });
+  });
+}
+
+// Generates and returns the location of a file stored in S3 for the given request and filename
+// The location is the direct S3 link if the option is set, otherwise we serve the file through parse-server
+S3Adapter.prototype.getFileLocation = function(config, filename) {
+  if (this._directAccess) {
+    return `https://${this._bucket}.s3.amazonaws.com/${this._bucketPrefix + filename}`;
+  }
+  return (config.mount + '/files/' + config.applicationId + '/' + encodeURIComponent(filename));
+}
+
+module.exports = S3Adapter;
+module.exports.default = S3Adapter;

package.json

@@ -0,0 +1,29 @@
+{
+  "name": "parse-server-s3-adapter",
+  "version": "1.0.0",
+  "description": "AWS S3 adapter for parse-server",
+  "main": "index.js",
+  "scripts": {
+    "test": "jasmine"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/parse-server-modules/parse-server-s3-adapter.git"
+  },
+  "keywords": [
+    "parse-server",
+    "AWS",
+    "S3"
+  ],
+  "author": "Parse",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/parse-server-modules/parse-server-s3-adapter/issues"
+  },
+  "homepage": "https://github.com/parse-server-modules/parse-server-s3-adapter#readme",
+  "dependencies": {
+    "aws-sdk": "^2.2.46",
+    "jasmine": "^2.4.1",
+    "parse-server-conformance-tests": "^1.0.0"
+  }
+}

spec/support/jasmine.json

@@ -0,0 +1,6 @@
+{
+  "spec_dir": "spec",
+  "spec_files": [
+    "test.spec.js"
+  ]
+}

spec/test.spec.js

@@ -0,0 +1,48 @@
+'use strict';
+let filesAdapterTests = require('parse-server-conformance-tests').files;
+
+let S3Adapter = require('../index.js');
+
+describe('S3Adapter tests', () => {
+
+  it('should throw when not initialized properly', () => {
+    expect(() => {
+      var s3 = new S3Adapter();
+    }).toThrow("S3Adapter requires option 'accessKey' or env. variable S3_ACCESS_KEY")
+
+    expect(() => {
+      var s3 = new S3Adapter('accessKey');
+    }).toThrow("S3Adapter requires option 'secretKey' or env. variable S3_SECRET_KEY")
+
+    expect(() => {
+      var s3 = new S3Adapter('accessKey', 'secretKey');
+    }).toThrow("S3Adapter requires option 'bucket' or env. variable S3_BUCKET")
+
+    expect(() => {
+      var s3 = new S3Adapter({ accessKey: 'accessKey'});
+    }).toThrow("S3Adapter requires option 'secretKey' or env. variable S3_SECRET_KEY")
+    expect(() => {
+      var s3 = new S3Adapter({ accessKey: 'accessKey' , secretKey: 'secretKey'});
+    }).toThrow("S3Adapter requires option 'bucket' or env. variable S3_BUCKET")
+  })
+
+  it('should not throw when initialized properly', () => {
+    expect(() => {
+      var s3 = new S3Adapter('accessKey', 'secretKey', 'bucket');
+    }).not.toThrow()
+
+    expect(() => {
+      var s3 = new S3Adapter({ accessKey: 'accessKey' , secretKey: 'secretKey', bucket: 'bucket'});
+    }).not.toThrow()
+  })
+
+  if (process.env.TEST_S3_ACCESS_KEY && process.env.TEST_S3_SECRET_KEY && process.env.TEST_S3_BUCKET) {
+    // Should be initialized from the env
+    let s3 = new S3Adapter({
+      accessKey: process.env.TEST_S3_ACCESS_KEY,
+      secretKey: process.env.TEST_S3_SECRET_KEY,
+      bucket: process.env.TEST_S3_BUCKET
+    });
+    filesAdapterTests.testAdapter("S3Adapter", s3);
+  }
+})