diff --git a/.kokoro/build.sh b/.kokoro/build.sh
index 2740468dde..2d38c5f838 100755
--- a/.kokoro/build.sh
+++ b/.kokoro/build.sh
@@ -44,6 +44,7 @@ export SENDGRID_API_KEY=$(cat $KOKORO_GFILE_DIR/secrets-sendgrid-api-key.txt)
 # Configure GCF variables
 export FUNCTIONS_TOPIC=integration-tests-instance
 export FUNCTIONS_BUCKET=$GCLOUD_PROJECT
+export FUNCTIONS_DELETABLE_BUCKET=$GCLOUD_PROJECT-functions
 
 #  functions/speech-to-speech
 export OUTPUT_BUCKET=$FUNCTIONS_BUCKET
@@ -59,7 +60,7 @@ export RESULT_TOPIC=$FUNCTIONS_TOPIC
 export RESULT_BUCKET=$FUNCTIONS_BUCKET
 
 #  functions/imagemagick
-export BLURRED_BUCKET_NAME=$GCLOUD_PROJECT-functions
+export BLURRED_BUCKET_NAME=$GCLOUD_PROJECT-imagick
 
 # Configure IoT variables
 export NODEJS_IOT_EC_PUBLIC_KEY=${KOKORO_GFILE_DIR}/ec_public.pem
@@ -80,19 +81,6 @@ export GOOGLE_APPLICATION_CREDENTIALS=${KOKORO_GFILE_DIR}/secrets-key.json
 gcloud auth activate-service-account --key-file "$GOOGLE_APPLICATION_CREDENTIALS"
 gcloud config set project $GCLOUD_PROJECT
 
-npm install -g @google-cloud/functions-framework
-
-# Start functions emulator, if appropriate
-if [[ $PROJECT == functions/* ]] && grep --quiet functions-emulator package.json; then
-  export BASE_URL="http://localhost:8010/${GCLOUD_PROJECT}/${GCF_REGION}"
-
-  export FUNCTIONS_LOG_PATH=$(pwd)/logs/cloud-functions-emulator.log
-  npm install -g @google-cloud/functions-emulator
-  touch "$FUNCTIONS_LOG_PATH"
-  functions config set logFile "$FUNCTIONS_LOG_PATH"
-  functions-emulator start
-fi
-
 npm test
 
 exit $?
diff --git a/.kokoro/functions/common.cfg b/.kokoro/functions/common.cfg
index 8ca89d179a..a0ffd6fe31 100644
--- a/.kokoro/functions/common.cfg
+++ b/.kokoro/functions/common.cfg
@@ -12,5 +12,11 @@ build_file: "nodejs-docs-samples/.kokoro/trampoline.sh"
 # Configure the docker image for kokoro-trampoline.
 env_vars: {
     key: "TRAMPOLINE_IMAGE"
-    value: "gcr.io/cloud-docs-samples/nodejs"
+    value: "gcr.io/cloud-devrel-kokoro-resources/node:8-user"
+}
+
+# Configure the base URL of the function hosting platform
+env_vars: {
+    key: "BASE_URL"
+    value: "http://localhost:8080"
 }
\ No newline at end of file
diff --git a/.kokoro/functions/helloworld.cfg b/.kokoro/functions/helloworld.cfg
index bb7659b39d..033acbf735 100644
--- a/.kokoro/functions/helloworld.cfg
+++ b/.kokoro/functions/helloworld.cfg
@@ -10,4 +10,10 @@ env_vars: {
 env_vars: {
     key: "TRAMPOLINE_BUILD_FILE"
     value: "github/nodejs-docs-samples/.kokoro/build.sh"
-}
+}
+
+# Configure the base URL of the function hosting platform
+env_vars: {
+    key: "BASE_URL"
+    value: "http://us-central1-nodejs-docs-samples-tests.cloudfunctions.net"
+}
\ No newline at end of file
diff --git a/functions/helloworld/README.md b/functions/helloworld/README.md
index 26aef63c1c..b79c036da6 100644
--- a/functions/helloworld/README.md
+++ b/functions/helloworld/README.md
@@ -14,6 +14,14 @@ See:
 
 See the [Cloud Functions Hello World tutorial][tutorial].
 
+**Note:** in order for the tests to run properly, you'll have to deploy some of the sample functions:
+
+```
+gcloud functions deploy helloHttp --runtime nodejs8 --trigger-http
+gcloud functions deploy helloPubSub --trigger-topic $FUNCTIONS_TOPIC --runtime nodejs8
+gcloud functions deploy helloGCS --runtime nodejs8 --trigger-resource $FUNCTIONS_DELETABLE_BUCKET --trigger-event providers/cloud.storage/eventTypes/object.change
+```
+
 ## Run the tests
 
 1. Read and follow the [prerequisites](../../../../#prerequisites).
@@ -31,7 +39,7 @@ See the [Cloud Functions Hello World tutorial][tutorial].
 
         export GCF_REGION=us-central1
         export FUNCTIONS_TOPIC=[YOUR_PUBSUB_TOPIC]
-        export FUNCTIONS_BUCKET=[YOUR_CLOUD_STORAGE_BUCKET]
+        export FUNCTIONS_DELETABLE_BUCKET=[YOUR_CLOUD_STORAGE_BUCKET]  # will be deleted by tests!
 
 1. Run the tests:
 
diff --git a/functions/helloworld/index.js b/functions/helloworld/index.js
index 5d5cfdb6c9..87be5a8371 100644
--- a/functions/helloworld/index.js
+++ b/functions/helloworld/index.js
@@ -57,8 +57,8 @@ exports.helloHttp = (req, res) => {
  * @param {object} event The Cloud Functions event.
  * @param {function} callback The callback function.
  */
-exports.helloBackground = (event, callback) => {
-  callback(null, `Hello ${event.data.name || 'World'}!`);
+exports.helloBackground = (data, context, callback) => {
+  callback(null, `Hello ${data.name || 'World'}!`);
 };
 // [END functions_helloworld_background]
 
@@ -68,18 +68,16 @@ exports.helloBackground = (event, callback) => {
  * This function is exported by index.js, and executed when
  * the trigger topic receives a message.
  *
- * @param {object} event The Cloud Functions event.
- * @param {function} callback The callback function.
+ * @param {object} data The event payload.
+ * @param {object} context The event metadata.
  */
-exports.helloPubSub = (event, callback) => {
-  const pubsubMessage = event.data;
-  const name = pubsubMessage.data
-    ? Buffer.from(pubsubMessage.data, 'base64').toString()
+exports.helloPubSub = (data, context) => {
+  const pubSubMessage = data;
+  const name = pubSubMessage.data
+    ? Buffer.from(pubSubMessage.data, 'base64').toString()
     : 'World';
 
   console.log(`Hello, ${name}!`);
-
-  callback();
 };
 // [END functions_helloworld_pubsub]
 
@@ -87,23 +85,20 @@ exports.helloPubSub = (event, callback) => {
 /**
  * Background Cloud Function to be triggered by Cloud Storage.
  *
- * @param {object} event The Cloud Functions event.
- * @param {function} callback The callback function.
+ * @param {object} data The event payload.
+ * @param {object} context The event metadata.
  */
-exports.helloGCS = (event, callback) => {
-  const file = event.data;
-
+exports.helloGCS = (data, context) => {
+  const file = data;
   if (file.resourceState === 'not_exists') {
     console.log(`File ${file.name} deleted.`);
   } else if (file.metageneration === '1') {
     // metageneration attribute is updated on metadata changes.
-    // value is 1 if file was newly created or overwritten
+    // on create value is 1
     console.log(`File ${file.name} uploaded.`);
   } else {
     console.log(`File ${file.name} metadata updated.`);
   }
-
-  callback();
 };
 // [END functions_helloworld_storage]
 
@@ -114,11 +109,11 @@ exports.helloGCS = (event, callback) => {
  * @param {object} event The Cloud Functions event.
  * @param {function} callback The callback function.
  */
-exports.helloGCSGeneric = (event, callback) => {
-  const file = event.data;
+exports.helloGCSGeneric = (data, context, callback) => {
+  const file = data;
 
-  console.log(`  Event: ${event.eventId}`);
-  console.log(`  Event Type: ${event.eventType}`);
+  console.log(`  Event: ${context.eventId}`);
+  console.log(`  Event Type: ${context.eventType}`);
   console.log(`  Bucket: ${file.bucket}`);
   console.log(`  File: ${file.name}`);
   console.log(`  Metageneration: ${file.metageneration}`);
@@ -136,7 +131,7 @@ exports.helloGCSGeneric = (event, callback) => {
  * @param {function} callback The callback function.
  */
 
-exports.helloError = (event, callback) => {
+exports.helloError = (data, context, callback) => {
   // [START functions_helloworld_error]
   // These WILL be reported to Stackdriver Error Reporting
   console.error(new Error('I failed you'));
@@ -154,7 +149,7 @@ exports.helloError = (event, callback) => {
  */
 /* eslint-disable no-throw-literal */
 
-exports.helloError2 = (event, callback) => {
+exports.helloError2 = (data, context, callback) => {
   // [START functions_helloworld_error]
   // These will NOT be reported to Stackdriver Error Reporting
   console.info(new Error('I failed you')); // Logging an Error object at the info level
@@ -171,7 +166,7 @@ exports.helloError2 = (event, callback) => {
  * @param {function} callback The callback function.
  */
 /* eslint-disable */
-exports.helloError3 = (event, callback) => {
+exports.helloError3 = (data, context, callback) => {
   // This will NOT be reported to Stackdriver Error Reporting
   // [START functions_helloworld_error]
   callback('I failed you');
diff --git a/functions/helloworld/package.json b/functions/helloworld/package.json
index 9b8c1edd93..6e6d157c32 100644
--- a/functions/helloworld/package.json
+++ b/functions/helloworld/package.json
@@ -12,24 +12,31 @@
     "node": ">=8.0.0"
   },
   "scripts": {
-    "e2e-test": "export FUNCTIONS_CMD='gcloud functions' && sh test/updateFunctions.sh && BASE_URL=\"https://$GCP_REGION-$GCLOUD_PROJECT.cloudfunctions.net/\" mocha test/*.test.js --timeout=60000 --exit",
-    "test": "export FUNCTIONS_CMD='functions-emulator' && sh test/updateFunctions.sh && export BASE_URL=\"http://localhost:8010/$GCLOUD_PROJECT/$GCF_REGION\" && mocha test/*.test.js --timeout=60000 --exit",
-    "system-test": "export FUNCTIONS_CMD='functions-emulator' && sh test/updateFunctions.sh && export BASE_URL=\"http://localhost:8010/$GCLOUD_PROJECT/$GCF_REGION\" && mocha test/*.test.js --timeout=60000 --exit"
+    "unit-test": "mocha test/index.test.js test/*unit*test.js test/*integration*test.js --timeout=2000 --exit",
+    "system-test": "mocha test/*system*test.js --timeout=60000 --exit",
+    "test": "npm run unit-test && npm run system-test"
   },
   "dependencies": {
     "@google-cloud/debug-agent": "^4.0.0",
     "escape-html": "^1.0.3",
-    "pug": "^2.0.3"
+    "pug": "^2.0.3",
+    "supertest": "^4.0.2"
   },
   "devDependencies": {
+    "@google-cloud/functions-framework": "^1.1.1",
     "@google-cloud/nodejs-repo-tools": "^3.3.0",
-    "@google-cloud/pubsub": "^0.28.0",
+    "@google-cloud/pubsub": "^0.30.0",
     "@google-cloud/storage": "^3.0.0",
-    "mocha": "^6.0.0",
+    "child-process-promise": "^2.2.1",
+    "delay": "^4.3.0",
     "express": "^4.16.3",
+    "mocha": "^6.1.4",
+    "moment": "^2.24.0",
+    "promise-retry": "^1.1.1",
     "proxyquire": "^2.1.0",
+    "request": "^2.88.0",
+    "requestretry": "^4.0.0",
     "sinon": "^7.0.0",
-    "supertest": "^4.0.0",
     "uuid": "^3.1.0",
     "yargs": "^14.0.0"
   },
diff --git a/functions/helloworld/shim.js b/functions/helloworld/shim.js
deleted file mode 100644
index bd510180f0..0000000000
--- a/functions/helloworld/shim.js
+++ /dev/null
@@ -1,153 +0,0 @@
-/**
- * Copyright 2018, Google, Inc.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const httpShim = PORT => {
-  // [START functions_testing_shim_http]
-  // Import dependencies
-  const gcfCode = require('./index.js');
-  const express = require('express');
-
-  // TODO(developer): specify the port to use
-  // const PORT = 3000;
-
-  // Start local HTTP server
-  const app = express();
-  const server = require(`http`).createServer(app);
-  server.on('connection', socket => socket.unref());
-  server.listen(PORT);
-
-  // Register HTTP handlers
-  Object.keys(gcfCode).forEach(gcfFn => {
-    // Handle a single HTTP request
-    const handler = (req, res) => {
-      gcfCode[gcfFn](req, res);
-      server.close();
-    };
-
-    app.get(`/${gcfFn}`, handler);
-    app.post(`/${gcfFn}`, handler);
-  });
-  // [END functions_testing_shim_http]
-};
-
-const pubsubShim = (gcfFn, topicName, subscriptionName) => {
-  // [START functions_testing_shim_pubsub]
-  // Import dependencies
-  const {PubSub} = require('@google-cloud/pubsub');
-  const pubsub = new PubSub();
-
-  // TODO(developer): specify a function to test
-  // const gcfCode = require('./index.js');
-  // const gcfFn = gcfCode.YOUR_FUNCTION;
-
-  // TODO(developer): specify an existing topic and subscription to use
-  // const topicName = process.env.TOPIC || 'YOUR_TOPIC';
-  // const subscriptionName = process.env.SUBSCRIPTION || 'YOUR_SUBSCRIPTION';
-
-  // Subscribe to Pub/Sub topic
-  const subscription = pubsub.topic(topicName).subscription(subscriptionName);
-
-  // Handle a single Pub/Sub message
-  const messageHandler = msg => {
-    gcfFn({data: msg}, () => {
-      msg.ack();
-      subscription.removeListener(`message`, messageHandler);
-    });
-  };
-  subscription.on(`message`, messageHandler);
-  // [END functions_testing_shim_pubsub]
-};
-
-const storageShim = (gcfFn, bucketName, topicName, subscriptionName) => {
-  // [START functions_testing_shim_storage]
-  // Import dependencies
-  const {PubSub} = require('@google-cloud/pubsub');
-  const {Storage} = require(`@google-cloud/storage`);
-  const pubsub = new PubSub();
-  const storage = new Storage();
-
-  // TODO(developer): specify a function to test
-  // const gcfCode = require('./index.js');
-  // const gcfFn = gcfCode.YOUR_FUNCTION;
-
-  // TODO(developer): specify a Cloud Storage bucket to monitor
-  // const bucketName = 'YOUR_GCS_BUCKET'
-
-  // TODO(developer): specify an existing topic and subscription to use
-  // const topicName = process.env.TOPIC || 'YOUR_TOPIC';
-  // const subscriptionName = process.env.SUBSCRIPTION || 'YOUR_SUBSCRIPTION';
-
-  // Create notification on target bucket
-  // Further info: https://cloud.google.com/storage/docs/reporting-changes
-  const bucket = storage.bucket(bucketName);
-  return bucket
-    .createNotification(topicName)
-    .then(data => data[0])
-    .then(
-      notification =>
-        new Promise(resolve => {
-          // Subscribe to Pub/Sub topic
-          const subscription = pubsub
-            .topic(topicName)
-            .subscription(subscriptionName);
-
-          // Handle a single Pub/Sub message
-          const messageHandler = msg => {
-            const data = JSON.parse(Buffer.from(msg.data, 'base64').toString());
-            gcfFn({data: data}, () => {
-              msg.ack();
-              subscription.removeListener(`message`, messageHandler);
-              resolve(notification);
-            });
-          };
-          subscription.on(`message`, messageHandler);
-        })
-    )
-    .then(notification => notification.delete()); // Delete notification
-  // [END functions_testing_shim_storage]
-};
-
-const gcfCodeGlobal = require('./index.js');
-require(`yargs`) // eslint-disable-line
-  .demandCommand(1)
-  .command('http <port>', 'HTTP-triggered-function shim', {}, opts =>
-    httpShim(opts.port)
-  )
-  .command(
-    'pubsub <functionName> <topic> <subscription>',
-    'PubSub-triggered-function shim',
-    {},
-    opts =>
-      pubsubShim(
-        gcfCodeGlobal[opts.functionName],
-        opts.topic,
-        opts.subscription
-      )
-  )
-  .command(
-    'storage <functionName> <bucket> <topic> <subscription>',
-    'Storage-triggered-function shim',
-    {},
-    opts =>
-      storageShim(
-        gcfCodeGlobal[opts.functionName],
-        opts.bucket,
-        opts.topic,
-        opts.subscription
-      )
-  )
-  .wrap(120)
-  .help()
-  .strict().argv;
diff --git a/functions/helloworld/test/index.test.js b/functions/helloworld/test/index.test.js
index 373807728e..3388a2119f 100644
--- a/functions/helloworld/test/index.test.js
+++ b/functions/helloworld/test/index.test.js
@@ -16,256 +16,234 @@
 const path = require('path');
 const assert = require('assert');
 const tools = require('@google-cloud/nodejs-repo-tools');
-const supertest = require('supertest');
+const requestRetry = require('requestretry');
 const uuid = require('uuid');
+const sinon = require('sinon');
+const execPromise = require('child-process-promise').exec;
+
+const program = require('..');
 
 const {PubSub} = require('@google-cloud/pubsub');
 const pubsub = new PubSub();
 const {Storage} = require('@google-cloud/storage');
 const storage = new Storage();
 
-const baseCmd = process.env.FUNCTIONS_CMD;
 const topicName = process.env.FUNCTIONS_TOPIC;
 
 const localFileName = 'test.txt';
 const fileName = `test-${uuid.v4()}.txt`;
 
-const {BASE_URL} = process.env;
-
 const bucketName = process.env.FUNCTIONS_BUCKET;
 const bucket = storage.bucket(bucketName);
 
-before('Must specify BASE_URL', () => {
-  assert.ok(BASE_URL);
-  tools.checkCredentials();
-});
+const startFF = (target, signature, port) => {
+  const cwd = path.join(__dirname, '..');
+  // exec's 'timeout' param won't kill children of "shim" /bin/sh process
+  // Workaround: include "& sleep <TIMEOUT>; kill $!" in executed command
+  return execPromise(
+    `functions-framework --target=${target} --signature-type=${signature} --port=${port} & sleep 1; kill $!`,
+    {shell: true, cwd}
+  );
+};
+
+const httpInvocation = (fnUrl, port, body) => {
+  const baseUrl = `http://localhost:${port}`;
+
+  if (body) {
+    // POST request
+    return requestRetry.post({
+      url: `${baseUrl}/${fnUrl}`,
+      retryDelay: 400,
+      body: body,
+      json: true,
+    });
+  } else {
+    // GET request
+    return requestRetry.get({
+      url: `${baseUrl}/${fnUrl}`,
+      retryDelay: 400,
+    });
+  }
+};
+
+describe('index.test.js', () => {
+  before(tools.checkCredentials);
 
-it('helloGET: should print hello world', async () => {
-  await supertest(BASE_URL)
-    .get('/helloGET')
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text, 'Hello World!');
+  describe('helloGET', () => {
+    const PORT = 8081;
+    let ffProc;
+
+    before(() => {
+      ffProc = startFF('helloGET', 'http', PORT);
     });
-});
 
-it('helloHttp: should print a name via GET', async () => {
-  await supertest(BASE_URL)
-    .get('/helloHttp?name=John')
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text, 'Hello John!');
+    after(async () => {
+      await ffProc;
     });
-});
 
-it('helloHttp: should print a name via POST', async () => {
-  await supertest(BASE_URL)
-    .post('/helloHttp')
-    .send({name: 'John'})
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text, 'Hello John!');
+    it('helloGET: should print hello world', async () => {
+      const response = await httpInvocation('helloGET', PORT);
+
+      assert.strictEqual(response.statusCode, 200);
+      assert.strictEqual(response.body, 'Hello World!');
     });
-});
+  });
+
+  describe('helloHttp', () => {
+    const PORT = 8082;
+    let ffProc;
 
-it('helloHttp: should print hello world', async () => {
-  await supertest(BASE_URL)
-    .get('/helloHttp')
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text, 'Hello World!');
+    before(() => {
+      ffProc = startFF('helloHttp', 'http', PORT);
     });
-});
 
-it('helloHttp: should escape XSS', async () => {
-  await supertest(BASE_URL)
-    .post('/helloHttp')
-    .send({name: '<script>alert(1)</script>'})
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text.includes('<script>'), false);
+    after(async () => {
+      await ffProc;
     });
-});
 
-it.only('helloBackground: should print a name', async () => {
-  const data = JSON.stringify({name: 'John'});
-  const output = await tools.runAsync(
-    `${baseCmd} call helloBackground --data '${data}'`
-  );
+    it('helloHttp: should print a name via GET', async () => {
+      const response = await httpInvocation('helloHttp?name=John', PORT);
 
-  assert.strictEqual(output.includes('Hello John!'), true);
-});
+      assert.strictEqual(response.statusCode, 200);
+      assert.strictEqual(response.body, 'Hello John!');
+    });
 
-it('helloBackground: should print hello world', async () => {
-  const output = await tools.runAsync(
-    `${baseCmd} call helloBackground --data '{}'`
-  );
+    it('helloHttp: should print a name via POST', async () => {
+      const response = await httpInvocation('helloHttp', PORT, {name: 'John'});
 
-  assert.strictEqual(output.includes('Hello World!'), true);
-});
+      assert.strictEqual(response.statusCode, 200);
+      assert.strictEqual(response.body, 'Hello John!');
+    });
+
+    it('helloHttp: should print hello world', async () => {
+      const response = await httpInvocation('helloHttp', PORT);
 
-it('helloPubSub: should print a name', async () => {
-  const startTime = new Date(Date.now()).toISOString();
-  const name = uuid.v4();
+      assert.strictEqual(response.statusCode, 200);
+      assert.strictEqual(response.body, 'Hello World!');
+    });
 
-  // Publish to pub/sub topic
-  const topic = pubsub.topic(topicName);
-  await topic.publish(Buffer.from(name));
+    it('helloHttp: should escape XSS', async () => {
+      const response = await httpInvocation('helloHttp', PORT, {
+        name: '<script>alert(1)</script>',
+      });
 
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloPubSub --start-time ${startTime}`
-    );
-    assert.strictEqual(logs.includes(`Hello, ${name}!`), true);
+      assert.strictEqual(response.statusCode, 200);
+      assert.strictEqual(response.body.includes('<script>'), false);
+    });
   });
-});
 
-it('helloPubSub: should print hello world', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+  describe('helloBackground', () => {
+    const PORT = 8083;
+    let ffProc;
 
-  // Publish to pub/sub topic
-  const topic = pubsub.topic(topicName);
-  await topic.publish(Buffer.from(''), {a: 'b'});
+    before(() => {
+      ffProc = startFF('helloBackground', 'event', PORT);
+    });
 
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloPubSub --start-time ${startTime}`
-    );
-    assert.strictEqual(logs.includes('Hello, World!'), true);
-  });
-});
+    after(async () => {
+      await ffProc;
+    });
 
-it('helloGCS: should print uploaded message', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+    it('helloBackground: should print a name', async () => {
+      const data = {data: {name: 'John'}};
 
-  // Upload file
-  const filepath = path.join(__dirname, localFileName);
-  await bucket.upload(filepath, {
-    destination: fileName,
-  });
+      const response = await httpInvocation('helloBackground', PORT, data);
 
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloGCS --start-time ${startTime}`
-    );
-    assert.strictEqual(logs.includes(`File ${fileName} uploaded`), true);
-  });
-});
+      assert.ok(response.body.includes('Hello John!'));
+    });
 
-it('helloGCS: should print metadata updated message', async () => {
-  const startTime = new Date(Date.now()).toISOString();
-
-  // Update file metadata
-  await bucket.setMetadata(fileName, {foo: 'bar'});
-
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloGCS --start-time ${startTime}`
-    );
-    assert.strictEqual(
-      logs.includes(`File ${fileName} metadata updated`),
-      true
-    );
-  });
-});
+    it('helloBackground: should print hello world', async () => {
+      const data = {data: {}};
+
+      const response = await httpInvocation('helloBackground', PORT, data);
 
-it('helloGCSGeneric: should print event details', async () => {
-  const startTime = new Date(Date.now()).toISOString();
-
-  // Update file metadata
-  await bucket.setMetadata(fileName, {foo: 'baz'});
-
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloGCSGeneric --start-time ${startTime}`
-    );
-    assert.strictEqual(logs.includes(`Bucket: ${bucketName}`), true);
-    assert.strictEqual(logs.includes(`File: ${fileName}`), true);
-    assert.strictEqual(
-      logs.includes('Event type: google.storage.object.metadataUpdate'),
-      true
-    );
+      assert.ok(response.body.includes('Hello World!'));
+    });
   });
-});
 
-it('helloGCS: should print deleted message', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+  describe('helloPubSub', () => {
+    /* See sample.integration.pubsub.test.js */
+  });
 
-  // Delete file
-  bucket.deleteFiles();
+  describe('helloGCS', () => {
+    /* See sample.integration.storage.test.js */
+  });
 
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloGCS --start-time ${startTime}`
-    );
-    assert.strictEqual(logs.includes(`File ${fileName} deleted`), true);
+  describe('helloGCSGeneric', () => {
+    it('helloGCSGeneric: should print event details', async () => {
+      const PORT = 8084;
+      const ffProc = startFF('helloGCSGeneric', 'event', PORT);
+
+      // Update file metadata
+      const data = {
+        name: fileName,
+        resourceState: 'exists',
+        metageneration: '2',
+        bucket: bucketName,
+        timeCreated: new Date(),
+        updated: new Date(),
+      };
+      const context = {
+        eventId: '12345',
+        eventType: 'google.storage.object.metadataUpdate',
+      };
+
+      const response = await httpInvocation('helloGCSGeneric', PORT, {
+        data,
+        context,
+      });
+      const {stdout} = await ffProc;
+
+      assert.ok(stdout.includes(`Bucket: ${bucketName}`));
+      assert.ok(stdout.includes(`File: ${fileName}`));
+      assert.ok(
+        stdout.includes('Event Type: google.storage.object.metadataUpdate')
+      );
+    });
   });
-});
 
-it('helloError: should throw an error', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+  describe('Error handling (unit tests)', () => {
+    // Silence dummy console calls in the samples
+    before(tools.stubConsole);
+    after(tools.restoreConsole);
 
-  // Publish to pub/sub topic
-  const topic = pubsub.topic(topicName);
-  await topic.publish(Buffer.from(''), {a: 'b'});
+    it('helloError: should throw an error', () => {
+      assert.throws(program.helloError, 'I failed you');
+    });
 
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloError --start-time ${startTime}`
-    );
-    assert.strictEqual(logs.includes('Error: I failed you'), true);
-  });
-});
+    it('helloError2: should throw a value', () => {
+      assert.throws(program.helloError2, '1');
+    });
 
-it('helloError2: should throw a value', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+    it('helloError3: callback should return an errback value', () => {
+      const cb = sinon.stub();
 
-  // Publish to pub/sub topic
-  const topic = pubsub.topic(topicName);
-  await topic.publish(Buffer.from(''), {a: 'b'});
+      program.helloError3(null, null, cb);
 
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloError2 --start-time ${startTime}`
-    );
-    assert.strictEqual(logs.includes(' 1\n'), true);
+      assert.ok(cb.calledOnce);
+      assert.ok(cb.calledWith('I failed you'));
+    });
   });
-});
 
-it('helloError3: callback should return an errback value', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+  describe('helloTemplate', () => {
+    const PORT = 8085;
+    let ffProc;
 
-  // Publish to pub/sub topic
-  const topic = pubsub.topic(topicName);
-  await topic.publish(Buffer.from(''), {a: 'b'});
+    before(() => {
+      ffProc = startFF('helloTemplate', 'http', PORT);
+    });
 
-  // Check logs
-  await tools.tryTest(async assert => {
-    const logs = await tools.runAsync(
-      `${baseCmd} logs read helloError3 --start-time ${startTime}`
-    );
-    assert.strictEqual(logs.includes(' I failed you\n'), true);
-  });
-});
+    after(async () => {
+      await ffProc;
+    });
+
+    it('helloTemplate: should render the html', async () => {
+      const response = await httpInvocation('helloTemplate', PORT);
 
-it('helloTemplate: should render the html', async () => {
-  await supertest(BASE_URL)
-    .get('/helloTemplate')
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(
-        new RegExp(/<h1>Cloud Functions Template Sample<\/h1>/).test(
-          response.text
-        ),
-        true
+      assert.strictEqual(response.statusCode, 200);
+      assert.ok(
+        response.body.includes('<h1>Cloud Functions Template Sample</h1>')
       );
     });
+  });
 });
diff --git a/functions/helloworld/test/sample.integration.http.test.js b/functions/helloworld/test/sample.integration.http.test.js
index f8168bf24b..e46e313d82 100644
--- a/functions/helloworld/test/sample.integration.http.test.js
+++ b/functions/helloworld/test/sample.integration.http.test.js
@@ -15,25 +15,64 @@
 
 // [START functions_http_integration_test]
 const assert = require('assert');
-const Supertest = require('supertest');
-const supertest = Supertest(process.env.BASE_URL);
-
-it('helloHttp: should print a name', async () => {
-  await supertest
-    .post('/helloHttp')
-    .send({name: 'John'})
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text, 'Hello John!');
+const execPromise = require('child-process-promise').exec;
+const path = require('path');
+const requestRetry = require('requestretry');
+const uuid = require('uuid');
+
+const PORT = 9010;
+const BASE_URL = `http://localhost:${PORT}`;
+const cwd = path.join(__dirname, '..');
+
+// [END functions_http_integration_test]
+
+describe('HTTP integration test', () => {
+  // [START functions_http_integration_test]
+  let ffProc;
+
+  // Run the functions-framework instance to host functions locally
+  before(() => {
+    // exec's 'timeout' param won't kill children of "shim" /bin/sh process
+    // Workaround: include "& sleep <TIMEOUT>; kill $!" in executed command
+    ffProc = execPromise(
+      `functions-framework --target=helloHttp --signature-type=http --port ${PORT} & sleep 2; kill $!`,
+      {shell: true, cwd}
+    );
+  });
+
+  after(async () => {
+    // Wait for the functions framework to stop
+    await ffProc;
+  });
+
+  it('helloHttp: should print a name', async () => {
+    const name = uuid.v4();
+
+    const response = await requestRetry({
+      url: `${BASE_URL}/helloHttp`,
+      method: 'POST',
+      body: {name},
+      retryDelay: 200,
+      json: true,
     });
-});
 
-it('helloHttp: should print hello world', async () => {
-  await supertest
-    .get('/helloHttp')
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text, 'Hello World!');
+    assert.strictEqual(response.statusCode, 200);
+    assert.strictEqual(response.body, `Hello ${name}!`);
+  });
+  // [END functions_http_integration_test]
+
+  it('helloHttp: should print hello world', async () => {
+    const response = await requestRetry({
+      url: `${BASE_URL}/helloHttp`,
+      method: 'POST',
+      body: {},
+      retryDelay: 200,
+      json: true,
     });
+
+    assert.strictEqual(response.statusCode, 200);
+    assert.strictEqual(response.body, `Hello World!`);
+  });
+  // [START functions_http_integration_test]
 });
 // [END functions_http_integration_test]
diff --git a/functions/helloworld/test/sample.integration.pubsub.test.js b/functions/helloworld/test/sample.integration.pubsub.test.js
index a59df42639..06e2ab5f7d 100644
--- a/functions/helloworld/test/sample.integration.pubsub.test.js
+++ b/functions/helloworld/test/sample.integration.pubsub.test.js
@@ -14,38 +14,78 @@
  */
 
 // [START functions_pubsub_integration_test]
-const childProcess = require('child_process');
 const assert = require('assert');
+const execPromise = require('child-process-promise').exec;
+const path = require('path');
+const requestRetry = require('requestretry');
 const uuid = require('uuid');
 
-it('helloPubSub: should print a name', done => {
-  const startTime = new Date(Date.now()).toISOString();
-  const name = uuid.v4();
-
-  // Mock Pub/Sub call, as the emulator doesn't listen to Pub/Sub topics
-  const encodedName = Buffer.from(name).toString('base64');
-  const data = JSON.stringify({data: encodedName});
-  childProcess.execSync(`functions call helloPubSub --data ${data}`);
-
-  // Check the emulator's logs
-  const logs = childProcess
-    .execSync(`functions logs read helloPubSub --start-time ${startTime}`)
-    .toString();
-  assert.strictEqual(logs.includes(`Hello, ${name}!`), true);
-  done();
-});
+const cwd = path.join(__dirname, '..');
+
+// [END functions_pubsub_integration_test]
+
+describe('Pub/Sub integration test', () => {
+  // [START functions_pubsub_integration_test]
+  it('helloPubSub: should print a name', async () => {
+    const name = uuid.v4();
+    const PORT = 8088; // Each running framework instance needs a unique port
+
+    const encodedName = Buffer.from(name).toString('base64');
+    const pubsubMessage = {data: {data: encodedName}};
+
+    // exec's 'timeout' param won't kill children of "shim" /bin/sh process
+    // Workaround: include "& sleep <TIMEOUT>; kill $!" in executed command
+    const proc = execPromise(
+      `functions-framework --target=helloPubSub --signature-type=event --port=${PORT} & sleep 1; kill $!`,
+      {shell: true, cwd}
+    );
+
+    // Send HTTP request simulating Pub/Sub message
+    // (GCF translates Pub/Sub messages to HTTP requests internally)
+    const response = await requestRetry({
+      url: `http://localhost:${PORT}/`,
+      method: 'POST',
+      body: pubsubMessage,
+      retryDelay: 200,
+      json: true,
+    });
+
+    assert.strictEqual(response.statusCode, 204);
+
+    // Wait for the functions framework to stop
+    const {stdout} = await proc;
+
+    assert(stdout.includes(`Hello, ${name}!`));
+  });
+  // [END functions_pubsub_integration_test]
+
+  it('helloPubSub: should print hello world', async () => {
+    const pubsubMessage = {data: {}};
+    const PORT = 8089; // Each running framework instance needs a unique port
+
+    // exec's 'timeout' param won't kill children of "shim" /bin/sh process
+    // Workaround: include "& sleep <TIMEOUT>; kill $!" in executed command
+    const proc = execPromise(
+      `functions-framework --target=helloPubSub --signature-type=event --port=${PORT} & sleep 1; kill $!`,
+      {shell: true, cwd}
+    );
 
-it('helloPubSub: should print hello world', done => {
-  const startTime = new Date(Date.now()).toISOString();
+    // Send HTTP request simulating Pub/Sub message
+    // (GCF translates Pub/Sub messages to HTTP requests internally)
+    const response = await requestRetry({
+      url: `http://localhost:${PORT}/`,
+      method: 'POST',
+      body: pubsubMessage,
+      retryDelay: 200,
+      json: true,
+    });
 
-  // Mock Pub/Sub call, as the emulator doesn't listen to Pub/Sub topics
-  childProcess.execSync('functions call helloPubSub --data {}');
+    assert.strictEqual(response.statusCode, 204);
 
-  // Check the emulator's logs
-  const logs = childProcess
-    .execSync(`functions logs read helloPubSub --start-time ${startTime}`)
-    .toString();
-  assert.strictEqual(logs.includes('Hello, World!'), true);
-  done();
+    // Wait for functions-framework process to exit
+    const {stdout, stderr} = await proc;
+    assert(stdout.includes('Hello, World!'));
+  });
+  // [START functions_pubsub_integration_test]
 });
 // [END functions_pubsub_integration_test]
diff --git a/functions/helloworld/test/sample.integration.storage.test.js b/functions/helloworld/test/sample.integration.storage.test.js
index 3daf38c4b8..ea9c5f671e 100644
--- a/functions/helloworld/test/sample.integration.storage.test.js
+++ b/functions/helloworld/test/sample.integration.storage.test.js
@@ -14,69 +14,129 @@
  */
 
 // [START functions_storage_integration_test]
-const childProcess = require('child_process');
 const assert = require('assert');
+const execPromise = require('child-process-promise').exec;
+const path = require('path');
 const uuid = require('uuid');
 
-it('helloGCS: should print uploaded message', done => {
-  const startTime = new Date(Date.now()).toISOString();
-  const filename = uuid.v4(); // Use a unique filename to avoid conflicts
+const requestRetry = require('requestretry');
+const cwd = path.join(__dirname, '..');
 
-  // Mock GCS call, as the emulator doesn't listen to GCS buckets
-  const data = JSON.stringify({
-    name: filename,
-    resourceState: 'exists',
-    metageneration: '1',
-  });
+// [END functions_storage_integration_test]
 
-  childProcess.execSync(`functions-emulator call helloGCS --data '${data}'`);
+describe('GCS integration test', () => {
+  // [START functions_storage_integration_test]
+  it('helloGCS: should print uploaded message', async () => {
+    const filename = uuid.v4(); // Use a unique filename to avoid conflicts
+    const PORT = 9000; // Each running framework instance needs a unique port
 
-  // Check the emulator's logs
-  const logs = childProcess
-    .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
-    .toString();
-  assert.ok(logs.includes(`File ${filename} uploaded.`));
-  done();
-});
+    const data = {
+      data: {
+        name: filename,
+        resourceState: 'exists',
+        metageneration: '1',
+      },
+    };
+
+    // Run the functions-framework instance to host functions locally
+    //   exec's 'timeout' param won't kill children of "shim" /bin/sh process
+    //   Workaround: include "& sleep <TIMEOUT>; kill $!" in executed command
+    const proc = execPromise(
+      `functions-framework --target=helloGCS --signature-type=event --port=${PORT} & sleep 1; kill $!`,
+      {shell: true, cwd}
+    );
 
-it('helloGCS: should print metadata updated message', done => {
-  const startTime = new Date(Date.now()).toISOString();
-  const filename = uuid.v4(); // Use a unique filename to avoid conflicts
+    // Send HTTP request simulating GCS change notification
+    // (GCF translates GCS notifications to HTTP requests internally)
+    const response = await requestRetry({
+      url: `http://localhost:${PORT}/`,
+      method: 'POST',
+      body: data,
+      retryDelay: 200,
+      json: true,
+    });
 
-  // Mock GCS call, as the emulator doesn't listen to GCS buckets
-  const data = JSON.stringify({
-    name: filename,
-    resourceState: 'exists',
-    metageneration: '2',
+    assert.strictEqual(response.statusCode, 204);
+
+    // Wait for functions-framework process to exit
+    const {stdout} = await proc;
+    assert.ok(stdout.includes(`File ${filename} uploaded.`));
   });
+  // [END functions_storage_integration_test]
 
-  childProcess.execSync(`functions-emulator call helloGCS --data '${data}'`);
+  it('helloGCS: should print metadata updated message', async () => {
+    const filename = uuid.v4(); // Use a unique filename to avoid conflicts
+    const PORT = 9001; // Each running framework instance needs a unique port
 
-  // Check the emulator's logs
-  const logs = childProcess
-    .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
-    .toString();
-  assert.ok(logs.includes(`File ${filename} metadata updated.`));
-  done();
-});
+    const data = {
+      data: {
+        name: filename,
+        resourceState: 'exists',
+        metageneration: '2',
+      },
+    };
+
+    // Run the functions-framework instance to host functions locally
+    //   exec's 'timeout' param won't kill children of "shim" /bin/sh process
+    //   Workaround: include "& sleep <TIMEOUT>; kill $!" in executed command
+    const proc = execPromise(
+      `functions-framework --target=helloGCS --signature-type=event --port=${PORT} & sleep 1; kill $!`,
+      {shell: true, cwd}
+    );
 
-it('helloGCS: should print deleted message', done => {
-  const startTime = new Date(Date.now()).toISOString();
-  const filename = uuid.v4(); // Use a unique filename to avoid conflicts
+    // Send HTTP request simulating GCS change notification
+    // (GCF translates GCS notifications to HTTP requests internally)
+    const response = await requestRetry({
+      url: `http://localhost:${PORT}/`,
+      method: 'POST',
+      body: data,
+      retryDelay: 200,
+      json: true,
+    });
 
-  // Mock GCS call, as the emulator doesn't listen to GCS buckets
-  const data = JSON.stringify({
-    name: filename,
-    resourceState: 'not_exists',
-    metageneration: '3',
+    assert.strictEqual(response.statusCode, 204);
+
+    // Wait for functions-framework process to exit
+    const {stdout} = await proc;
+    assert.ok(stdout.includes(`File ${filename} metadata updated.`));
   });
 
-  childProcess.execSync(`functions-emulator call helloGCS --data '${data}'`);
+  it('helloGCS: should print deleted message', async () => {
+    const filename = uuid.v4(); // Use a unique filename to avoid conflicts
+    const PORT = 9002; // Each running framework instance needs a unique port
+
+    const data = {
+      data: {
+        name: filename,
+        resourceState: 'not_exists',
+        metageneration: '3',
+      },
+    };
+
+    // Run the functions-framework instance to host functions locally
+    //   exec's 'timeout' param won't kill children of "shim" /bin/sh process
+    //   Workaround: include "& sleep <TIMEOUT>; kill $!" in executed command
+    const proc = execPromise(
+      `functions-framework --target=helloGCS --signature-type=event --port=${PORT} & sleep 1; kill $!`,
+      {shell: true, cwd}
+    );
 
-  // Check the emulator's logs
-  const logs = childProcess
-    .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
-    .toString();
-  assert.ok(logs.includes(`File ${filename} deleted.`));
+    // Send HTTP request simulating GCS change notification
+    // (GCF translates GCS notifications to HTTP requests internally)
+    const response = await requestRetry({
+      url: `http://localhost:${PORT}/`,
+      method: 'POST',
+      body: data,
+      retryDelay: 200,
+      json: true,
+    });
+
+    assert.strictEqual(response.statusCode, 204);
+
+    // Wait for functions-framework process to exit
+    const {stdout} = await proc;
+    assert.ok(stdout.includes(`File ${filename} deleted.`));
+  });
+  // [START functions_storage_integration_test]
 });
 // [END functions_storage_integration_test]
diff --git a/functions/helloworld/test/sample.system.http.test.js b/functions/helloworld/test/sample.system.http.test.js
index 966fec7a8b..209796e80e 100644
--- a/functions/helloworld/test/sample.system.http.test.js
+++ b/functions/helloworld/test/sample.system.http.test.js
@@ -18,22 +18,24 @@ const assert = require('assert');
 const Supertest = require('supertest');
 const supertest = Supertest(process.env.BASE_URL);
 
-it('helloHttp: should print a name', async () => {
-  await supertest
-    .post('/helloHttp')
-    .send({name: 'John'})
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text, 'Hello John!');
-    });
-});
+describe('system tests', () => {
+  it('helloHttp: should print a name', async () => {
+    await supertest
+      .post('/helloHttp')
+      .send({name: 'John'})
+      .expect(200)
+      .expect(response => {
+        assert.strictEqual(response.text, 'Hello John!');
+      });
+  });
+  // [END functions_http_system_test]
 
-it('helloHttp: should print hello world', async () => {
-  await supertest
-    .get('/helloHttp')
-    .expect(200)
-    .expect(response => {
-      assert.strictEqual(response.text, 'Hello World!');
-    });
+  it('helloHttp: should print hello world', async () => {
+    await supertest
+      .get('/helloHttp')
+      .expect(200)
+      .expect(response => {
+        assert.strictEqual(response.text, 'Hello World!');
+      });
+  });
 });
-// [END functions_http_system_test]
diff --git a/functions/helloworld/test/sample.system.pubsub.test.js b/functions/helloworld/test/sample.system.pubsub.test.js
index 2aa48087bb..2ddd287b5e 100644
--- a/functions/helloworld/test/sample.system.pubsub.test.js
+++ b/functions/helloworld/test/sample.system.pubsub.test.js
@@ -15,50 +15,66 @@
 
 // [START functions_pubsub_system_test]
 const childProcess = require('child_process');
+const delay = require('delay');
 const assert = require('assert');
 const uuid = require('uuid');
 const {PubSub} = require('@google-cloud/pubsub');
-const pubsub = new PubSub();
+const moment = require('moment');
+const promiseRetry = require('promise-retry');
 
-process.env.FUNCTIONS_TOPIC =
-  'projects/grass-clump-479/topics/gcloud-logging-test0165b071-1325-11e9-bc58-d3b6d1def78e';
+const pubsub = new PubSub();
 const topicName = process.env.FUNCTIONS_TOPIC;
 const baseCmd = 'gcloud functions';
 
-it('helloPubSub: should print a name', async () => {
-  const startTime = new Date(Date.now()).toISOString();
-  const name = uuid.v4();
+describe('system tests', () => {
+  it('helloPubSub: should print a name', async () => {
+    const name = uuid.v4();
 
-  // Publish to pub/sub topic
-  const topic = pubsub.topic(topicName);
-  const publisher = topic.publisher();
-  await publisher.publish(Buffer.from(name));
+    // Subtract time to work-around local-GCF clock difference
+    const startTime = moment()
+      .subtract(4, 'minutes')
+      .toISOString();
 
-  // Wait for logs to become consistent
-  await new Promise(resolve => setTimeout(resolve, 15000));
+    // Publish to pub/sub topic
+    const topic = pubsub.topic(topicName);
+    await topic.publish(Buffer.from(name));
 
-  // Check logs after a delay
-  const logs = childProcess
-    .execSync(`${baseCmd} logs read helloPubSub --start-time ${startTime}`)
-    .toString();
-  assert.ok(logs.includes(`Hello, ${name}!`));
-});
+    // Wait for logs to become consistent
+    await promiseRetry(retry => {
+      const logs = childProcess
+        .execSync(`${baseCmd} logs read helloPubSub --start-time ${startTime}`)
+        .toString();
+
+      try {
+        assert.ok(logs.includes(`Hello, ${name}!`));
+      } catch (err) {
+        retry(err);
+      }
+    });
+  });
+  // [END functions_pubsub_system_test]
 
-it('helloPubSub: should print hello world', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+  it('helloPubSub: should print hello world', async () => {
+    // Subtract time to work-around local-GCF clock difference
+    const startTime = moment()
+      .subtract(4, 'minutes')
+      .toISOString();
 
-  // Publish to pub/sub topic
-  const topic = pubsub.topic(topicName);
-  const publisher = topic.publisher();
-  await publisher.publish(Buffer.from(''), {a: 'b'});
+    // Publish to pub/sub topic
+    const topic = pubsub.topic(topicName);
+    await topic.publish(Buffer.from(''), {a: 'b'});
 
-  // Wait for logs to become consistent
-  await new Promise(resolve => setTimeout(resolve, 15000));
+    // Wait for logs to become consistent
+    await promiseRetry(retry => {
+      const logs = childProcess
+        .execSync(`${baseCmd} logs read helloPubSub --start-time ${startTime}`)
+        .toString();
 
-  // Check logs after a delay
-  const logs = childProcess
-    .execSync(`${baseCmd} logs read helloPubSub --start-time ${startTime}`)
-    .toString();
-  assert.ok(logs.includes('Hello, World!'));
+      try {
+        assert.ok(logs.includes(`Hello, World!`));
+      } catch (err) {
+        retry(err);
+      }
+    });
+  });
 });
-// [END functions_pubsub_system_test]
diff --git a/functions/helloworld/test/sample.system.storage.test.js b/functions/helloworld/test/sample.system.storage.test.js
index 484cf48ec4..7de340062f 100644
--- a/functions/helloworld/test/sample.system.storage.test.js
+++ b/functions/helloworld/test/sample.system.storage.test.js
@@ -20,64 +20,90 @@ const uuid = require('uuid');
 const assert = require('assert');
 const path = require('path');
 const childProcess = require('child_process');
-const localFileName = 'test.txt';
+const delay = require('delay');
+const moment = require('moment');
+const promiseRetry = require('promise-retry');
 
 // Use unique GCS filename to avoid conflicts between concurrent test runs
 const gcsFileName = `test-${uuid.v4()}.txt`;
 
-const bucketName = process.env.FUNCTIONS_BUCKET;
+const localFileName = 'test.txt';
+const bucketName = process.env.FUNCTIONS_DELETABLE_BUCKET;
 const bucket = storage.bucket(bucketName);
 const baseCmd = 'gcloud functions';
 
-it('helloGCS: should print uploaded message', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+describe('system tests', () => {
+  it('helloGCS: should print uploaded message', async () => {
+    // Subtract time to work-around local-GCF clock difference
+    const startTime = moment()
+      .subtract(2, 'minutes')
+      .toISOString();
 
-  // Upload file
-  const filepath = path.join(__dirname, localFileName);
-  await bucket.upload(filepath, {
-    destination: gcsFileName,
-  });
+    // Upload file
+    const filepath = path.join(__dirname, localFileName);
+    await bucket.upload(filepath, {
+      destination: gcsFileName,
+    });
 
-  // Wait for consistency
-  await new Promise(resolve => setTimeout(resolve, 15000));
+    // Wait for logs to become consistent
+    await promiseRetry(retry => {
+      const logs = childProcess
+        .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
+        .toString();
 
-  // Check logs
-  const logs = childProcess
-    .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
-    .toString();
-  assert.ok(logs.includes(`File ${gcsFileName} uploaded`));
-});
+      try {
+        assert.ok(logs.includes(`File ${gcsFileName} uploaded`));
+      } catch (err) {
+        retry(err);
+      }
+    });
+  });
+  // [END functions_storage_system_test]
 
-it('helloGCS: should print metadata updated message', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+  it('helloGCS: should print metadata updated message', async () => {
+    // Subtract time to work-around local-GCF clock difference
+    const startTime = moment()
+      .subtract(2, 'minutes')
+      .toISOString();
 
-  // Update file metadata
-  const file = bucket.file(gcsFileName);
-  await file.setMetadata(gcsFileName, {foo: 'bar'});
+    // Update file metadata
+    const file = bucket.file(gcsFileName);
+    await file.setMetadata(gcsFileName, {foo: 'bar'});
 
-  // Wait for consistency
-  await new Promise(resolve => setTimeout(resolve, 15000));
+    // Wait for logs to become consistent
+    await promiseRetry(retry => {
+      const logs = childProcess
+        .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
+        .toString();
 
-  // Check logs
-  const logs = childProcess
-    .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
-    .toString();
-  assert.strictEqual(logs.ok(`File ${gcsFileName} metadata updated`));
-});
+      try {
+        assert.ok(logs.includes(`File ${gcsFileName} metadata updated`));
+      } catch (err) {
+        retry(err);
+      }
+    });
+  });
 
-it('helloGCS: should print deleted message', async () => {
-  const startTime = new Date(Date.now()).toISOString();
+  it('helloGCS: should print deleted message', async () => {
+    // Subtract time to work-around local-GCF clock difference
+    const startTime = moment()
+      .subtract(2, 'minutes')
+      .toISOString();
 
-  // Delete file
-  bucket.deleteFiles();
+    // Delete file
+    bucket.deleteFiles();
 
-  // Wait for consistency
-  await new Promise(resolve => setTimeout(resolve, 15000));
+    // Wait for logs to become consistent
+    await promiseRetry(retry => {
+      const logs = childProcess
+        .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
+        .toString();
 
-  // Check logs
-  const logs = childProcess
-    .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
-    .toString();
-  assert.ok(logs.includes(`File ${gcsFileName} deleted`));
+      try {
+        assert.ok(logs.includes(`File ${gcsFileName} deleted`));
+      } catch (err) {
+        retry(err);
+      }
+    });
+  });
 });
-// [END functions_storage_system_test]
diff --git a/functions/helloworld/test/sample.unit.http.test.js b/functions/helloworld/test/sample.unit.http.test.js
index b5ceb31d78..1c423bfd8c 100644
--- a/functions/helloworld/test/sample.unit.http.test.js
+++ b/functions/helloworld/test/sample.unit.http.test.js
@@ -24,6 +24,7 @@ it('helloHttp: should print a name', () => {
   // Mock ExpressJS 'req' and 'res' parameters
   const name = uuid.v4();
   const req = {
+    query: {},
     body: {
       name: name,
     },
@@ -37,10 +38,12 @@ it('helloHttp: should print a name', () => {
   assert.ok(res.send.calledOnce);
   assert.deepStrictEqual(res.send.firstCall.args, [`Hello ${name}!`]);
 });
+// [END functions_http_unit_test]
 
 it('helloHttp: should print hello world', () => {
   // Mock ExpressJS 'req' and 'res' parameters
   const req = {
+    query: {},
     body: {},
   };
   const res = {send: sinon.stub()};
@@ -52,4 +55,3 @@ it('helloHttp: should print hello world', () => {
   assert.ok(res.send.calledOnce);
   assert.deepStrictEqual(res.send.firstCall.args, ['Hello World!']);
 });
-// [END functions_http_unit_test]
diff --git a/functions/helloworld/test/sample.unit.pubsub.test.js b/functions/helloworld/test/sample.unit.pubsub.test.js
index 7f21cd9702..6b38d6245c 100644
--- a/functions/helloworld/test/sample.unit.pubsub.test.js
+++ b/functions/helloworld/test/sample.unit.pubsub.test.js
@@ -23,32 +23,24 @@ const {helloPubSub} = require('..');
 beforeEach(utils.stubConsole);
 afterEach(utils.restoreConsole);
 
-it('helloPubSub: should print a name', done => {
-  // Initialize mocks
+it('helloPubSub: should print a name', () => {
+  // Create mock Pub/Sub event
   const name = uuid.v4();
   const event = {
-    data: {
-      data: Buffer.from(name).toString('base64'),
-    },
+    data: Buffer.from(name).toString('base64'),
   };
 
   // Call tested function and verify its behavior
-  helloPubSub(event, () => {
-    assert.ok(console.log.calledWith(`Hello, ${name}!`));
-    done();
-  });
+  helloPubSub(event);
+  assert.ok(console.log.calledWith(`Hello, ${name}!`));
 });
+// [END functions_pubsub_unit_test]
 
-it('helloPubSub: should print hello world', done => {
-  // Initialize mocks
-  const event = {
-    data: {},
-  };
+it('helloPubSub: should print hello world', () => {
+  // Create mock Pub/Sub event
+  const event = {};
 
   // Call tested function and verify its behavior
-  helloPubSub(event, () => {
-    assert.ok(console.log.calledWith('Hello, World!'));
-    done();
-  });
+  helloPubSub(event);
+  assert.ok(console.log.calledWith('Hello, World!'));
 });
-// [END functions_pubsub_unit_test]
diff --git a/functions/helloworld/test/sample.unit.storage.test.js b/functions/helloworld/test/sample.unit.storage.test.js
index 1817bdf31b..c48871076b 100644
--- a/functions/helloworld/test/sample.unit.storage.test.js
+++ b/functions/helloworld/test/sample.unit.storage.test.js
@@ -23,57 +23,45 @@ const {helloGCS} = require('..');
 beforeEach(utils.stubConsole);
 afterEach(utils.restoreConsole);
 
-it('helloGCS: should print uploaded message', done => {
+it('helloGCS: should print uploaded message', () => {
   // Initialize mocks
   const filename = uuid.v4();
   const event = {
-    data: {
-      name: filename,
-      resourceState: 'exists',
-      metageneration: '1',
-    },
+    name: filename,
+    resourceState: 'exists',
+    metageneration: '1',
   };
 
   // Call tested function and verify its behavior
-  helloGCS(event, () => {
-    assert.ok(console.log.calledWith(`File ${filename} uploaded.`));
-    done();
-  });
+  helloGCS(event);
+  assert.ok(console.log.calledWith(`File ${filename} uploaded.`));
 });
+// [END functions_storage_unit_test]
 
-it('helloGCS: should print metadata updated message', done => {
+it('helloGCS: should print metadata updated message', () => {
   // Initialize mocks
   const filename = uuid.v4();
   const event = {
-    data: {
-      name: filename,
-      resourceState: 'exists',
-      metageneration: '2',
-    },
+    name: filename,
+    resourceState: 'exists',
+    metageneration: '2',
   };
 
   // Call tested function and verify its behavior
-  helloGCS(event, () => {
-    assert.ok(console.log.calledWith(`File ${filename} metadata updated.`));
-    done();
-  });
+  helloGCS(event);
+  assert.ok(console.log.calledWith(`File ${filename} metadata updated.`));
 });
 
-it('helloGCS: should print deleted message', done => {
+it('helloGCS: should print deleted message', () => {
   // Initialize mocks
   const filename = uuid.v4();
   const event = {
-    data: {
-      name: filename,
-      resourceState: 'not_exists',
-      metageneration: '3',
-    },
+    name: filename,
+    resourceState: 'not_exists',
+    metageneration: '3',
   };
 
   // Call tested function and verify its behavior
-  helloGCS(event, () => {
-    assert.ok(console.log.calledWith(`File ${filename} deleted.`));
-    done();
-  });
+  helloGCS(event);
+  assert.ok(console.log.calledWith(`File ${filename} deleted.`));
 });
-// [END functions_storage_unit_test]
diff --git a/functions/helloworld/test/shim.test.js b/functions/helloworld/test/shim.test.js
deleted file mode 100644
index 4a671a4d07..0000000000
--- a/functions/helloworld/test/shim.test.js
+++ /dev/null
@@ -1,130 +0,0 @@
-/**
- * Copyright 2018, Google, Inc.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const assert = require('assert');
-const Supertest = require('supertest');
-const tools = require('@google-cloud/nodejs-repo-tools');
-const {PubSub} = require('@google-cloud/pubsub');
-const pubsub = new PubSub();
-const {Storage} = require('@google-cloud/storage');
-const storage = new Storage();
-const uuid = require('uuid');
-const path = require('path');
-
-const PORT = process.env.PORT || 3000;
-const supertest = Supertest(`http://localhost:${PORT}`);
-const topicName = `gcf-shim-topic-${uuid.v4()}`;
-const subscriptionName = `gcf-shim-sub-${uuid.v4()}`;
-const bucketName = `gcf-shim-bucket-${uuid.v4()}`;
-
-const cmd = 'node shim.js';
-const cwd = path.join(__dirname, '..');
-
-const bucket = storage.bucket(bucketName);
-let topic;
-let subscription;
-
-// Helper function
-const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
-
-// Create test resources
-before(() => {
-  return bucket
-    .create()
-    .then(() => {
-      return pubsub.createTopic(topicName);
-    })
-    .then(data => {
-      topic = data[0];
-      return topic.createSubscription(subscriptionName);
-    })
-    .then(data => {
-      subscription = data[0];
-      return delay(500);
-    })
-    .catch(console.error);
-});
-
-// Tear down test resources
-after(() => {
-  return bucket
-    .deleteFiles({force: true})
-    .then(subscription.delete())
-    .then(topic.delete())
-    .then(() => {
-      try {
-        return bucket.delete();
-      } catch (ex) {
-        return bucket.delete();
-      }
-    })
-    .catch(console.error);
-});
-
-it('shim: should handle HTTP', async () => {
-  const shim = tools.runAsync(`${cmd} http ${PORT}`, cwd);
-  await delay(1000)
-    .then(() => {
-      // Send HTTP request
-      return supertest
-        .get('/helloGET')
-        .expect(200)
-        .expect(response => {
-          assert.strictEqual(response.text, 'Hello World!');
-        });
-    })
-    .then(() => {
-      return shim;
-    }); // Stop shim
-});
-
-it('shim: should handle PubSub', async () => {
-  const name = uuid.v4();
-  const publisher = topic.publisher();
-  const shim = tools.runAsync(
-    `${cmd} pubsub helloPubSub "${topicName}" "${subscriptionName}"`,
-    cwd
-  );
-
-  // Publish to topic
-  await publisher
-    .publish(Buffer.from(name))
-    .then(delay(1000))
-    .then(() => {
-      return shim;
-    })
-    .then(output => {
-      assert.ok(output.includes(`Hello, ${name}!`));
-    });
-});
-
-it('shim: should handle GCS', async () => {
-  const shim = tools.runAsync(
-    `${cmd} storage helloGCS "${bucketName}" "${topicName}" "${subscriptionName}"`,
-    cwd
-  );
-
-  // Upload file to bucket
-  await delay(10000)
-    .then(() => {
-      return bucket.upload(path.join(cwd, 'test/test.txt'));
-    })
-    .then(() => {
-      return shim;
-    })
-    .then(output => {
-      assert.ok(output.includes('File test.txt uploaded.'));
-    });
-});
diff --git a/functions/helloworld/test/updateFunctions.sh b/functions/helloworld/test/updateFunctions.sh
deleted file mode 100644
index 594005811a..0000000000
--- a/functions/helloworld/test/updateFunctions.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-# Shell script to emulate/deploy all Cloud Functions in the file
-
-${FUNCTIONS_CMD} deploy helloGET --trigger-http
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloHttp --trigger-http
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloBackground --trigger-topic $FUNCTIONS_TOPIC
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloPubSub --trigger-topic $FUNCTIONS_TOPIC
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloGCS --trigger-bucket $FUNCTIONS_BUCKET
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloGCSGeneric --trigger-bucket $FUNCTIONS_BUCKET
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloError --trigger-topic $FUNCTIONS_TOPIC
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloError2 --trigger-topic $FUNCTIONS_TOPIC
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloError3 --trigger-topic $FUNCTIONS_TOPIC
-echo '-----------------------------'
-${FUNCTIONS_CMD} deploy helloTemplate --trigger-http
\ No newline at end of file
diff --git a/functions/pubsub/package.json b/functions/pubsub/package.json
index d763d56d75..8eaae6f046 100644
--- a/functions/pubsub/package.json
+++ b/functions/pubsub/package.json
@@ -18,6 +18,7 @@
     "@google-cloud/pubsub": "^0.28.1"
   },
   "devDependencies": {
+    "@google-cloud/functions-framework": "^1.3.2",
     "@google-cloud/nodejs-repo-tools": "^3.3.0",
     "child-process-promise": "^2.2.1",
     "mocha": "^6.0.0",
diff --git a/functions/pubsub/test/index.test.js b/functions/pubsub/test/index.test.js
index 05f45809fa..a1390f30f6 100644
--- a/functions/pubsub/test/index.test.js
+++ b/functions/pubsub/test/index.test.js
@@ -22,7 +22,8 @@ const path = require('path');
 const execPromise = require('child-process-promise').exec;
 const requestRetry = require('requestretry');
 
-const BASE_URL = process.env.BASE_URL || 'http://localhost:8080';
+const PORT = 9020;
+const BASE_URL = `http://localhost:${PORT}`;
 const cwd = path.join(__dirname, '..');
 
 const TOPIC = process.env.FUNCTIONS_TOPIC;
@@ -35,23 +36,16 @@ describe('functions/pubsub', () => {
   let ffProc;
 
   before(() => {
+    // exec's 'timeout' param won't kill children of "shim" /bin/sh process
+    // Workaround: include "& sleep <TIMEOUT>; kill $!" in executed command
     ffProc = execPromise(
-      `functions-framework --target=publish --signature-type=http`,
-      {timeout: 1000, shell: true, cwd}
+      `functions-framework --target=publish --signature-type=http --port=${PORT} & sleep 1; kill $!`,
+      {shell: true, cwd}
     );
   });
 
   after(async () => {
-    try {
-      await ffProc;
-    } catch (err) {
-      // Timeouts always cause errors on Linux, so catch them
-      if (err.name && err.name === 'ChildProcessError') {
-        return;
-      }
-
-      throw err;
-    }
+    await ffProc;
   });
 
   it('publish fails without parameters', async () => {