aws-sdk 2.288.0 → 2.292.0

package/lib/core.js

@@ -20,7 +20,7 @@ AWS.util.update(AWS, {
   /**
    * @constant
    */
-  VERSION: '2.288.0',
+  VERSION: '2.292.0',
 
   /**
    * @api private

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aws-sdk",
   "description": "AWS SDK for JavaScript",
-  "version": "2.288.0",
+  "version": "2.292.0",
   "author": {
     "name": "Amazon Web Services",
     "email": "",
@@ -121,7 +121,7 @@
     "waf"
   ],
   "scripts": {
-    "test": "npm -s run-script lint && npm -s run-script unit && npm -s run-script buildertest && npm -s run-script browsertest && npm -s run-script react-native-test && npm -s run-script tstest && ([ -f configuration ] && npm -s run-script integration || true)",
+    "test": "node ./scripts/composite-test.js && ([ -f configuration ] && npm -s run-script integration || true)",
     "unit": "mocha -- test test/json test/model test/protocol test/query test/services test/signers test/xml test/s3 test/cloudfront test/dynamodb test/polly test/rds test/event-stream",
     "coverage": "istanbul cover ./node_modules/mocha/bin/_mocha --reporter=lcovonly -- test test/json test/model test/protocol test/query test/services test/signers test/xml test/s3 test/cloudfront test/dynamodb test/polly test/rds test/event-stream",
     "browsertest": "rake browser:test && karma start",
@@ -140,6 +140,7 @@
     "react-native-test": "npm -s run-script build-react-native && rake reactnative:test && karma start",
     "region-check": "node ./scripts/region-checker/index.js",
     "translate-api-test": "mocha scripts/lib/translate-api.spec.js",
-    "typings-generator-test": "mocha scripts/lib/prune-shapes.spec.js"
+    "typings-generator-test": "mocha scripts/lib/prune-shapes.spec.js",
+    "helper-test": "mocha scripts/lib/test-helper.spec.js"
   }
 }

package/scripts/composite-test.js

@@ -0,0 +1,36 @@
+const {execute, executeLongProcess} = require('./lib/test-helper');
+
+async function run() {
+  const EXEC = {
+    'execute': execute,
+    'executeLongProcess': executeLongProcess,
+  }
+  const scripts = [
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'helper-test'], retryCount: 1 },
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'lint']},
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'unit'] },
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'buildertest'] },
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'tstest'] },
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'region-check'] },
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'translate-api-test'] },
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'typings-generator-test'] },
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'browsertest'] },
+    { execute: 'executeLongProcess', command: ['npm', 'run', 'react-native-test'] },
+  ];
+  for (const { execute, command, execOptions, retryCount } of scripts) {
+    try {
+      await EXEC[execute](command, execOptions, retryCount);
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+(async () => {
+  try {
+    await run();
+  } catch (e) {
+    console.log(e);
+    process.exit(1);
+  }
+})();

package/scripts/lib/test-helper.js

@@ -0,0 +1,85 @@
+const { exec, spawn } = require('child_process');
+
+/**
+ * wrap child_process.exec with retry. Will throw immediately when return
+ * code not 0; Used for trivial commands since error detail won't be printed.
+ * @param {string} command 
+ * @param {structure} execOptoins 
+ * @param {number} retryCount 
+ */
+async function executeCommand(command, execOptoins = {}, retryCount = 1) {
+  try {
+    const execCommand = command.join(' ');
+    const { stderr, stdout } = await execute(execCommand, execOptoins);
+    if (stderr) process.stderr.write(stderr.toString());
+    if (stdout) process.stderr.write(stdout.toString());
+  } catch (error) {
+    if (retryCount > 0) {
+      await executeCommand(command, execOptoins, --retryCount);
+    } else {
+      throw error;
+    }
+  }
+}
+
+function execute(command, options) {
+  return new Promise((resolve, reject) => {
+    exec(command, options, (err, stdout, stderr) => {
+      if (err) {
+          reject(err);
+      } else {
+          resolve({
+              stdout: stdout,
+              stderr: stderr
+          });
+      }
+  });
+  })
+}
+
+/**
+ * wrap child_process.spawn with retry
+ * @param {string} command 
+ * @param {structure} execOptions 
+ * @param {number} retryCount 
+ */
+async function executeLongProcessCommand(command, execOptions = {}, retryCount = 1) {
+  try {
+    const firstCommand = command[0];
+    const options = command.slice(1);
+    await promisifiedSpawn(firstCommand, options, execOptions);
+  } catch (error) {
+    if (retryCount > 0) {
+      await executeLongProcessCommand(command, execOptions, --retryCount);
+    } else {
+      throw error;
+    }
+  }
+}
+
+function promisifiedSpawn(command, options, execOptions) {
+  return new Promise((resolve, reject) => {
+    const subProcess = spawn(command, options, execOptions);
+    subProcess.stdout.on('data', (data) => {
+      process.stdout.write(data.toString());
+    });
+    subProcess.stderr.on('data', (data) => {
+      process.stderr.write(data.toString());
+    });
+    subProcess.on('error', (err) => {
+      console.error('spawn error: ', err);
+    });
+    subProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(`"${command} ${options.join(' ')}" exited with code: ${code}`);
+      }
+    });
+  });
+}
+
+module.exports = {
+  execute: executeCommand,
+  executeLongProcess: executeLongProcessCommand,
+}

package/scripts/lib/test-helper.spec.js

@@ -0,0 +1,51 @@
+const {execute, executeLongProcess} = require('./test-helper');
+const {expect} = require('chai');
+
+describe('execute command', (done) => {
+  it('doesn\'t retry if succeed', async() => {
+    let error;
+    try {
+      await execute(['exit 0'], {}, 2);
+    } catch (e) {
+     error = e;
+    } finally {
+      expect(error).eql(undefined);
+    }
+  });
+
+  it('can retry command', async () => {
+    let error;
+    try {
+      await execute(['exit 1'], {}, 2);
+    } catch (e) {
+     error = e;
+    } finally {
+      expect(error).not.undefined;
+      expect(typeof error.message).eql('string');
+    }
+  })
+});
+
+describe('executeLongProcess command', (done) => {
+  it('doesn\'t retry if succeed', async() => {
+    let error;
+    try {
+      await executeLongProcess(['exit 0'], {shell: true}, 2);
+    } catch (e) {
+     error = e;
+    } finally {
+      expect(error).eql(undefined);
+    }
+  });
+
+  it('can retry command', async () => {
+    let error;
+    try {
+      await executeLongProcess(['echo \'a\' && exit 1'], {shell: true}, 2);
+    } catch (e) {
+     error = e;
+    } finally {
+      expect(error).not.undefined;
+    }
+  })
+});