diff --git a/functions/background/test/index.test.js b/functions/background/test/index.test.js
index 2ac797cfaa..c71f4f4841 100644
--- a/functions/background/test/index.test.js
+++ b/functions/background/test/index.test.js
@@ -67,23 +67,25 @@ it('should make a promise request', async () => {
   assert.ok(response.body.includes(`Example Domain`));
 });
 
-it('should return synchronously', () => {
-  assert.strictEqual(
-    program.helloSynchronous({
-      something: true,
-    }),
-    'Something is true!'
-  );
-});
-
-it('should throw an error', () => {
-  assert.throws(
-    () => {
+describe('functions_background_synchronous', () => {
+  it('should return synchronously', () => {
+    assert.strictEqual(
       program.helloSynchronous({
-        something: false,
-      });
-    },
-    Error,
-    'Something was not true!'
-  );
+        something: true,
+      }),
+      'Something is true!'
+    );
+  });
+
+  it('should throw an error', () => {
+    assert.throws(
+      () => {
+        program.helloSynchronous({
+          something: false,
+        });
+      },
+      Error,
+      'Something was not true!'
+    );
+  });
 });
diff --git a/functions/billing/test/index.test.js b/functions/billing/test/index.test.js
index f78a39dccb..18a428aa22 100644
--- a/functions/billing/test/index.test.js
+++ b/functions/billing/test/index.test.js
@@ -69,23 +69,28 @@ describe('functions/billing tests', () => {
       await handleLinuxFailures(ffProc);
     });
 
-    it('should notify Slack when budget is exceeded', async () => {
-      const jsonData = {costAmount: 500, budgetAmount: 400};
-      const encodedData = Buffer.from(JSON.stringify(jsonData)).toString(
-        'base64'
-      );
-      const pubsubMessage = {data: encodedData, attributes: {}};
-
-      const response = await requestRetry({
-        url: `${BASE_URL}/notifySlack`,
-        method: 'POST',
-        body: {data: pubsubMessage},
-        retryDelay: 200,
-        json: true,
+    describe('functions_billing_slack', () => {
+      it('should notify Slack when budget is exceeded', async () => {
+        const jsonData = {costAmount: 500, budgetAmount: 400};
+        const encodedData = Buffer.from(JSON.stringify(jsonData)).toString(
+          'base64'
+        );
+        const pubsubMessage = {data: encodedData, attributes: {}};
+
+        const response = await requestRetry({
+          url: `${BASE_URL}/notifySlack`,
+          method: 'POST',
+          body: {data: pubsubMessage},
+          retryDelay: 200,
+          json: true,
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        assert.strictEqual(
+          response.body,
+          'Slack notification sent successfully'
+        );
       });
-
-      assert.strictEqual(response.statusCode, 200);
-      assert.strictEqual(response.body, 'Slack notification sent successfully');
     });
   });
 
@@ -105,60 +110,64 @@ describe('functions/billing tests', () => {
       await handleLinuxFailures(ffProc);
     });
 
-    it('should disable billing when budget is exceeded', async () => {
-      // Use functions framework to ensure sample follows GCF specification
-      // (Invoking it directly works too, but DOES NOT ensure GCF compatibility)
+    describe('functions_billing_stop', () => {
+      it('should disable billing when budget is exceeded', async () => {
+        // Use functions framework to ensure sample follows GCF specification
+        // (Invoking it directly works too, but DOES NOT ensure GCF compatibility)
+        const jsonData = {costAmount: 500, budgetAmount: 400};
+        const encodedData = Buffer.from(JSON.stringify(jsonData)).toString(
+          'base64'
+        );
+        const pubsubMessage = {data: encodedData, attributes: {}};
+
+        const response = await requestRetry({
+          url: `${BASE_URL}/stopBilling`,
+          method: 'POST',
+          body: {data: pubsubMessage},
+          retryDelay: 200,
+          json: true,
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        assert.ok(response.body.includes('Billing disabled'));
+      });
+    });
+  });
+});
+
+describe('shuts down GCE instances', () => {
+  describe('functions_billing_limit', () => {
+    it('should attempt to shut down GCE instances when budget is exceeded', async () => {
+      // Mock GCE (because real GCE instances take too long to start/stop)
+      const listInstancesResponseMock = {
+        data: {
+          items: [{name: 'test-instance-1', status: 'RUNNING'}],
+        },
+      };
+
+      const computeMock = {
+        instances: {
+          list: sinon.stub().returns(listInstancesResponseMock),
+          stop: sinon.stub().resolves({data: {}}),
+        },
+      };
+
+      const googleapisMock = Object.assign({}, googleapis);
+      googleapisMock.google.compute = sinon.stub().returns(computeMock);
+
+      // Run test
       const jsonData = {costAmount: 500, budgetAmount: 400};
       const encodedData = Buffer.from(JSON.stringify(jsonData)).toString(
         'base64'
       );
       const pubsubMessage = {data: encodedData, attributes: {}};
 
-      const response = await requestRetry({
-        url: `${BASE_URL}/stopBilling`,
-        method: 'POST',
-        body: {data: pubsubMessage},
-        retryDelay: 200,
-        json: true,
-      });
+      const sample = proxyquire('../', {googleapis: googleapisMock}); // kokoro-allow-mock
 
-      assert.strictEqual(response.statusCode, 200);
-      assert.ok(response.body.includes('Billing disabled'));
-    });
-  });
-});
+      await sample.limitUse(pubsubMessage);
 
-describe('shuts down GCE instances', () => {
-  it('should attempt to shut down GCE instances when budget is exceeded', async () => {
-    // Mock GCE (because real GCE instances take too long to start/stop)
-    const listInstancesResponseMock = {
-      data: {
-        items: [{name: 'test-instance-1', status: 'RUNNING'}],
-      },
-    };
-
-    const computeMock = {
-      instances: {
-        list: sinon.stub().returns(listInstancesResponseMock),
-        stop: sinon.stub().resolves({data: {}}),
-      },
-    };
-
-    const googleapisMock = Object.assign({}, googleapis);
-    googleapisMock.google.compute = sinon.stub().returns(computeMock);
-
-    // Run test
-    const jsonData = {costAmount: 500, budgetAmount: 400};
-    const encodedData = Buffer.from(JSON.stringify(jsonData)).toString(
-      'base64'
-    );
-    const pubsubMessage = {data: encodedData, attributes: {}};
-
-    const sample = proxyquire('../', {googleapis: googleapisMock}); // kokoro-allow-mock
-
-    await sample.limitUse(pubsubMessage);
-
-    assert.strictEqual(computeMock.instances.list.calledOnce, true);
-    assert.ok(computeMock.instances.stop.calledOnce);
+      assert.strictEqual(computeMock.instances.list.calledOnce, true);
+      assert.ok(computeMock.instances.stop.calledOnce);
+    });
   });
 });
diff --git a/functions/billing/test/periodic.test.js b/functions/billing/test/periodic.test.js
index 2a9f0b2f2b..8b139103d5 100644
--- a/functions/billing/test/periodic.test.js
+++ b/functions/billing/test/periodic.test.js
@@ -54,30 +54,34 @@ before(async () => {
   }
 });
 
-it('should shut down GCE instances when budget is exceeded', async () => {
-  const ffProc = execPromise(
-    `functions-framework --target=limitUse --signature-type=event`,
-    {timeout: 1000, shell: true, cwd}
-  );
+describe('functions_billing_limit', () => {
+  it('should shut down GCE instances when budget is exceeded', async () => {
+    const ffProc = execPromise(
+      `functions-framework --target=limitUse --signature-type=event`,
+      {timeout: 1000, shell: true, cwd}
+    );
 
-  const jsonData = {costAmount: 500, budgetAmount: 400};
-  const encodedData = Buffer.from(JSON.stringify(jsonData)).toString('base64');
-  const pubsubMessage = {data: encodedData, attributes: {}};
+    const jsonData = {costAmount: 500, budgetAmount: 400};
+    const encodedData = Buffer.from(JSON.stringify(jsonData)).toString(
+      'base64'
+    );
+    const pubsubMessage = {data: encodedData, attributes: {}};
 
-  const response = await requestRetry({
-    url: `${BASE_URL}/`,
-    method: 'POST',
-    body: {data: pubsubMessage},
-    retryDelay: 200,
-    json: true,
-  });
+    const response = await requestRetry({
+      url: `${BASE_URL}/`,
+      method: 'POST',
+      body: {data: pubsubMessage},
+      retryDelay: 200,
+      json: true,
+    });
 
-  // Wait for the functions framework to stop
-  // Must be BEFORE assertions, in case they fail
-  await ffProc;
+    // Wait for the functions framework to stop
+    // Must be BEFORE assertions, in case they fail
+    await ffProc;
 
-  console.log(response.body);
+    console.log(response.body);
 
-  assert.strictEqual(response.statusCode, 200);
-  assert.ok(response.body.includes('instance(s) stopped successfully'));
+    assert.strictEqual(response.statusCode, 200);
+    assert.ok(response.body.includes('instance(s) stopped successfully'));
+  });
 });
diff --git a/functions/composer-storage-trigger/test/index.test.js b/functions/composer-storage-trigger/test/index.test.js
index caea21f9d8..dc229d97b6 100644
--- a/functions/composer-storage-trigger/test/index.test.js
+++ b/functions/composer-storage-trigger/test/index.test.js
@@ -30,62 +30,64 @@ const getSample = FetchStub => {
   };
 };
 
-it('Handles error in JSON body', async () => {
-  const event = {
-    data: {
-      file: 'some-file',
-    },
-  };
-  const expectedMsg = 'Something bad happened.';
-  const bodyJson = {error: expectedMsg};
-  const body = {
-    json: sinon.stub().returns(bodyJson),
-  };
-  const sample = getSample(sinon.stub().resolves(body));
+describe('composer_trigger', () => {
+  it('Handles error in JSON body', async () => {
+    const event = {
+      data: {
+        file: 'some-file',
+      },
+    };
+    const expectedMsg = 'Something bad happened.';
+    const bodyJson = {error: expectedMsg};
+    const body = {
+      json: sinon.stub().returns(bodyJson),
+    };
+    const sample = getSample(sinon.stub().resolves(body));
 
-  try {
-    await sample.program.triggerDag(event);
-    assert.fail('No error thrown');
-  } catch (err) {
-    assert.deepStrictEqual(err, new Error('Something bad happened.'));
-  }
-});
+    try {
+      await sample.program.triggerDag(event);
+      assert.fail('No error thrown');
+    } catch (err) {
+      assert.deepStrictEqual(err, new Error('Something bad happened.'));
+    }
+  });
 
-it('Handles error in IAP response.', async () => {
-  const event = {
-    data: {
-      file: 'some-file',
-    },
-  };
-  const expectedMsg = 'Default IAP Error Message.';
+  it('Handles error in IAP response.', async () => {
+    const event = {
+      data: {
+        file: 'some-file',
+      },
+    };
+    const expectedMsg = 'Default IAP Error Message.';
 
-  const serviceAccountAccessTokenRes = {
-    json: sinon.stub().resolves({access_token: 'default-access-token'}),
-  };
-  const signJsonClaimRes = {
-    json: sinon.stub().resolves({signature: 'default-jwt-signature'}),
-  };
-  const getTokenRes = {
-    json: sinon.stub().resolves({id_token: 'default-id-token'}),
-  };
-  const makeIapPostRequestRes = {
-    ok: false,
-    text: sinon.stub().resolves(expectedMsg),
-  };
-  const FetchStub = sinon
-    .stub()
-    .onCall(0)
-    .resolves(serviceAccountAccessTokenRes)
-    .onCall(1)
-    .resolves(signJsonClaimRes)
-    .onCall(2)
-    .resolves(getTokenRes)
-    .onCall(3)
-    .resolves(makeIapPostRequestRes);
-  const sample = getSample(FetchStub);
-  try {
-    await sample.program.triggerDag(event);
-  } catch (err) {
-    assert.deepStrictEqual(err, new Error(expectedMsg));
-  }
+    const serviceAccountAccessTokenRes = {
+      json: sinon.stub().resolves({access_token: 'default-access-token'}),
+    };
+    const signJsonClaimRes = {
+      json: sinon.stub().resolves({signature: 'default-jwt-signature'}),
+    };
+    const getTokenRes = {
+      json: sinon.stub().resolves({id_token: 'default-id-token'}),
+    };
+    const makeIapPostRequestRes = {
+      ok: false,
+      text: sinon.stub().resolves(expectedMsg),
+    };
+    const FetchStub = sinon
+      .stub()
+      .onCall(0)
+      .resolves(serviceAccountAccessTokenRes)
+      .onCall(1)
+      .resolves(signJsonClaimRes)
+      .onCall(2)
+      .resolves(getTokenRes)
+      .onCall(3)
+      .resolves(makeIapPostRequestRes);
+    const sample = getSample(FetchStub);
+    try {
+      await sample.program.triggerDag(event);
+    } catch (err) {
+      assert.deepStrictEqual(err, new Error(expectedMsg));
+    }
+  });
 });
diff --git a/functions/concepts/test/index.test.js b/functions/concepts/test/index.test.js
index 13b709463a..8e573c2eb1 100644
--- a/functions/concepts/test/index.test.js
+++ b/functions/concepts/test/index.test.js
@@ -24,12 +24,14 @@ const sample = require('../');
 beforeEach(tools.stubConsole);
 afterEach(tools.restoreConsole);
 
-it('should demonstrate error type behavior', () => {
-  const objError = new Error('Error object!');
+describe('functions_concepts_error_object', () => {
+  it('should demonstrate error type behavior', () => {
+    const objError = new Error('Error object!');
 
-  const req = {body: {throwAsString: true}};
-  const res = {end: sinon.stub()};
+    const req = {body: {throwAsString: true}};
+    const res = {end: sinon.stub()};
 
-  sample.errorTypes(req, res);
-  assert.deepStrictEqual(console.error.getCall(0).args, [objError]);
+    sample.errorTypes(req, res);
+    assert.deepStrictEqual(console.error.getCall(0).args, [objError]);
+  });
 });
diff --git a/functions/env_vars/test/index.test.js b/functions/env_vars/test/index.test.js
index 5e95102f52..4ff71e8c21 100644
--- a/functions/env_vars/test/index.test.js
+++ b/functions/env_vars/test/index.test.js
@@ -31,11 +31,13 @@ const getMocks = () => {
   };
 };
 
-it('should read env vars', () => {
-  const mocks = getMocks();
-  process.env['FOO'] = 'bar';
+describe('functions_env_vars', () => {
+  it('should read env vars', () => {
+    const mocks = getMocks();
+    process.env['FOO'] = 'bar';
 
-  functions.envVar(mocks.req, mocks.res);
+    functions.envVar(mocks.req, mocks.res);
 
-  assert.strictEqual(mocks.res.send.calledWith('bar'), true);
+    assert.strictEqual(mocks.res.send.calledWith('bar'), true);
+  });
 });
diff --git a/functions/firebase/test/index.test.js b/functions/firebase/test/index.test.js
index fa3b84b524..9d377eeea1 100644
--- a/functions/firebase/test/index.test.js
+++ b/functions/firebase/test/index.test.js
@@ -39,148 +39,158 @@ const getSample = () => {
 beforeEach(tools.stubConsole);
 afterEach(tools.restoreConsole);
 
-it('should listen to RTDB', () => {
-  const sample = getSample();
-
-  const delta = {
-    foo: 'bar',
-  };
-  const event = {
-    resource: 'resource',
-    auth: {
-      admin: true,
-    },
-    delta: delta,
-    params: {
-      baz: 'quux',
-    },
-  };
-
-  sample.program.helloRTDB(event);
-
-  assert.strictEqual(console.log.calledWith('  baz: quux'), true);
-  assert.strictEqual(
-    console.log.calledWith('Function triggered by change to: resource'),
-    true
-  );
-  assert.strictEqual(console.log.calledWith('Admin?: true'), true);
-  assert.strictEqual(
-    console.log.calledWith(JSON.stringify(delta, null, 2)),
-    true
-  );
+describe('functions_firebase_rtdb', () => {
+  it('should listen to RTDB', () => {
+    const sample = getSample();
+
+    const delta = {
+      foo: 'bar',
+    };
+    const event = {
+      resource: 'resource',
+      auth: {
+        admin: true,
+      },
+      delta: delta,
+      params: {
+        baz: 'quux',
+      },
+    };
+
+    sample.program.helloRTDB(event);
+
+    assert.strictEqual(console.log.calledWith('  baz: quux'), true);
+    assert.strictEqual(
+      console.log.calledWith('Function triggered by change to: resource'),
+      true
+    );
+    assert.strictEqual(console.log.calledWith('Admin?: true'), true);
+    assert.strictEqual(
+      console.log.calledWith(JSON.stringify(delta, null, 2)),
+      true
+    );
+  });
 });
 
-it('should listen to Firestore', () => {
-  const sample = getSample();
-
-  const oldValue = {
-    foo: 'bar',
-  };
-  const value = {
-    bar: 'baz',
-  };
-  const event = {
-    resource: 'resource',
-    eventType: 'type',
-    data: {
-      oldValue: oldValue,
-      value: value,
-    },
-  };
-
-  sample.program.helloFirestore(event);
-
-  assert.strictEqual(
-    console.log.calledWith('Function triggered by event on: resource'),
-    true
-  );
-  assert.strictEqual(console.log.calledWith('Event type: type'), true);
-  assert.strictEqual(
-    console.log.calledWith(JSON.stringify(oldValue, null, 2)),
-    true
-  );
-  assert.strictEqual(
-    console.log.calledWith(JSON.stringify(value, null, 2)),
-    true
-  );
+describe('functions_firebase_firestore', () => {
+  it('should listen to Firestore', () => {
+    const sample = getSample();
+
+    const oldValue = {
+      foo: 'bar',
+    };
+    const value = {
+      bar: 'baz',
+    };
+    const event = {
+      resource: 'resource',
+      eventType: 'type',
+      data: {
+        oldValue: oldValue,
+        value: value,
+      },
+    };
+
+    sample.program.helloFirestore(event);
+
+    assert.strictEqual(
+      console.log.calledWith('Function triggered by event on: resource'),
+      true
+    );
+    assert.strictEqual(console.log.calledWith('Event type: type'), true);
+    assert.strictEqual(
+      console.log.calledWith(JSON.stringify(oldValue, null, 2)),
+      true
+    );
+    assert.strictEqual(
+      console.log.calledWith(JSON.stringify(value, null, 2)),
+      true
+    );
+  });
 });
 
-it('should listen to Auth events', () => {
-  const sample = getSample();
-  const date = Date.now();
-  const event = {
-    resource: 'resource',
-    data: {
-      uid: 'me',
-      email: 'me@example.com',
-      metadata: {
-        createdAt: date,
+describe('functions_firebase_auth', () => {
+  it('should listen to Auth events', () => {
+    const sample = getSample();
+    const date = Date.now();
+    const event = {
+      resource: 'resource',
+      data: {
+        uid: 'me',
+        email: 'me@example.com',
+        metadata: {
+          createdAt: date,
+        },
       },
-    },
-  };
+    };
 
-  sample.program.helloAuth(event);
+    sample.program.helloAuth(event);
 
-  assert.strictEqual(
-    console.log.calledWith('Function triggered by change to user: me'),
-    true
-  );
-  assert.strictEqual(console.log.calledWith(`Created at: ${date}`), true);
-  assert.strictEqual(console.log.calledWith('Email: me@example.com'), true);
+    assert.strictEqual(
+      console.log.calledWith('Function triggered by change to user: me'),
+      true
+    );
+    assert.strictEqual(console.log.calledWith(`Created at: ${date}`), true);
+    assert.strictEqual(console.log.calledWith('Email: me@example.com'), true);
+  });
 });
 
-it('should listen to Analytics events', () => {
-  const date = new Date();
-  const event = {
-    data: {
-      eventDim: [
-        {
-          name: 'my-event',
-          timestampMicros: `${date.valueOf()}000`,
-        },
-      ],
-      userDim: {
-        deviceInfo: {
-          deviceModel: 'Pixel',
-        },
-        geoInfo: {
-          city: 'London',
-          country: 'UK',
+describe('functions_firebase_analytics', () => {
+  it('should listen to Analytics events', () => {
+    const date = new Date();
+    const event = {
+      data: {
+        eventDim: [
+          {
+            name: 'my-event',
+            timestampMicros: `${date.valueOf()}000`,
+          },
+        ],
+        userDim: {
+          deviceInfo: {
+            deviceModel: 'Pixel',
+          },
+          geoInfo: {
+            city: 'London',
+            country: 'UK',
+          },
         },
       },
-    },
-    resource: 'my-resource',
-  };
-
-  const sample = getSample();
-  sample.program.helloAnalytics(event);
-  assert.strictEqual(
-    console.log.args[0][0],
-    'Function triggered by the following event: my-resource'
-  );
-  assert.strictEqual(console.log.args[1][0], 'Name: my-event');
-  assert.strictEqual(console.log.args[2][0], `Timestamp: ${date}`);
-  assert.strictEqual(console.log.args[3][0], 'Device Model: Pixel');
-  assert.strictEqual(console.log.args[4][0], 'Location: London, UK');
+      resource: 'my-resource',
+    };
+
+    const sample = getSample();
+    sample.program.helloAnalytics(event);
+    assert.strictEqual(
+      console.log.args[0][0],
+      'Function triggered by the following event: my-resource'
+    );
+    assert.strictEqual(console.log.args[1][0], 'Name: my-event');
+    assert.strictEqual(console.log.args[2][0], `Timestamp: ${date}`);
+    assert.strictEqual(console.log.args[3][0], 'Device Model: Pixel');
+    assert.strictEqual(console.log.args[4][0], 'Location: London, UK');
+  });
 });
 
-it('should listen to Remote Config events', () => {
-  const sample = getSample();
+describe('functions_firebase_remote_config', () => {
+  it('should listen to Remote Config events', () => {
+    const sample = getSample();
 
-  const event = {
-    data: {
-      updateOrigin: 'CONSOLE',
-      updateType: 'INCREMENTAL_UPDATE',
-      versionNumber: '1',
-    },
-  };
+    const event = {
+      data: {
+        updateOrigin: 'CONSOLE',
+        updateType: 'INCREMENTAL_UPDATE',
+        versionNumber: '1',
+      },
+    };
 
-  sample.program.helloRemoteConfig(event);
+    sample.program.helloRemoteConfig(event);
 
-  assert.strictEqual(
-    console.log.calledWith('Update type: INCREMENTAL_UPDATE'),
-    true
-  );
-  assert.strictEqual(console.log.calledWith('Origin: CONSOLE'), true);
-  assert.strictEqual(console.log.calledWith('Version: 1'), true);
+    assert.strictEqual(
+      console.log.calledWith('Update type: INCREMENTAL_UPDATE'),
+      true
+    );
+    assert.strictEqual(console.log.calledWith('Origin: CONSOLE'), true);
+    assert.strictEqual(console.log.calledWith('Version: 1'), true);
+  });
 });
diff --git a/functions/helloworld/test/index.test.js b/functions/helloworld/test/index.test.js
index 3388a2119f..8de212c7d8 100644
--- a/functions/helloworld/test/index.test.js
+++ b/functions/helloworld/test/index.test.js
@@ -69,7 +69,7 @@ const httpInvocation = (fnUrl, port, body) => {
 describe('index.test.js', () => {
   before(tools.checkCredentials);
 
-  describe('helloGET', () => {
+  describe('functions_helloworld_get helloGET', () => {
     const PORT = 8081;
     let ffProc;
 
@@ -89,7 +89,7 @@ describe('index.test.js', () => {
     });
   });
 
-  describe('helloHttp', () => {
+  describe('functions_helloworld_http helloHttp', () => {
     const PORT = 8082;
     let ffProc;
 
@@ -132,7 +132,7 @@ describe('index.test.js', () => {
     });
   });
 
-  describe('helloBackground', () => {
+  describe('functions_helloworld_background helloBackground', () => {
     const PORT = 8083;
     let ffProc;
 
@@ -161,15 +161,15 @@ describe('index.test.js', () => {
     });
   });
 
-  describe('helloPubSub', () => {
+  describe('functions_helloworld_pubsub helloPubSub', () => {
     /* See sample.integration.pubsub.test.js */
   });
 
-  describe('helloGCS', () => {
+  describe('functions_helloworld_storage helloGCS', () => {
     /* See sample.integration.storage.test.js */
   });
 
-  describe('helloGCSGeneric', () => {
+  describe('functions_helloworld_storage_generic helloGCSGeneric', () => {
     it('helloGCSGeneric: should print event details', async () => {
       const PORT = 8084;
       const ffProc = startFF('helloGCSGeneric', 'event', PORT);
@@ -202,30 +202,32 @@ describe('index.test.js', () => {
     });
   });
 
-  describe('Error handling (unit tests)', () => {
-    // Silence dummy console calls in the samples
-    before(tools.stubConsole);
-    after(tools.restoreConsole);
+  describe('functions_helloworld_error', () => {
+    describe('Error handling (unit tests)', () => {
+      // Silence dummy console calls in the samples
+      before(tools.stubConsole);
+      after(tools.restoreConsole);
 
-    it('helloError: should throw an error', () => {
-      assert.throws(program.helloError, 'I failed you');
-    });
+      it('helloError: should throw an error', () => {
+        assert.throws(program.helloError, 'I failed you');
+      });
 
-    it('helloError2: should throw a value', () => {
-      assert.throws(program.helloError2, '1');
-    });
+      it('helloError2: should throw a value', () => {
+        assert.throws(program.helloError2, '1');
+      });
 
-    it('helloError3: callback should return an errback value', () => {
-      const cb = sinon.stub();
+      it('helloError3: callback should return an errback value', () => {
+        const cb = sinon.stub();
 
-      program.helloError3(null, null, cb);
+        program.helloError3(null, null, cb);
 
-      assert.ok(cb.calledOnce);
-      assert.ok(cb.calledWith('I failed you'));
+        assert.ok(cb.calledOnce);
+        assert.ok(cb.calledWith('I failed you'));
+      });
     });
   });
 
-  describe('helloTemplate', () => {
+  describe('functions_helloworld_template helloTemplate', () => {
     const PORT = 8085;
     let ffProc;
 
diff --git a/functions/helloworld/test/sample.integration.http.test.js b/functions/helloworld/test/sample.integration.http.test.js
index e46e313d82..3354d4a0b7 100644
--- a/functions/helloworld/test/sample.integration.http.test.js
+++ b/functions/helloworld/test/sample.integration.http.test.js
@@ -26,7 +26,7 @@ const cwd = path.join(__dirname, '..');
 
 // [END functions_http_integration_test]
 
-describe('HTTP integration test', () => {
+describe('functions_helloworld_http HTTP integration test', () => {
   // [START functions_http_integration_test]
   let ffProc;
 
diff --git a/functions/helloworld/test/sample.integration.pubsub.test.js b/functions/helloworld/test/sample.integration.pubsub.test.js
index 06e2ab5f7d..1c056f60b6 100644
--- a/functions/helloworld/test/sample.integration.pubsub.test.js
+++ b/functions/helloworld/test/sample.integration.pubsub.test.js
@@ -24,7 +24,7 @@ const cwd = path.join(__dirname, '..');
 
 // [END functions_pubsub_integration_test]
 
-describe('Pub/Sub integration test', () => {
+describe('functions_helloworld_pubsub integration test', () => {
   // [START functions_pubsub_integration_test]
   it('helloPubSub: should print a name', async () => {
     const name = uuid.v4();
diff --git a/functions/helloworld/test/sample.integration.storage.test.js b/functions/helloworld/test/sample.integration.storage.test.js
index ea9c5f671e..b381178cf2 100644
--- a/functions/helloworld/test/sample.integration.storage.test.js
+++ b/functions/helloworld/test/sample.integration.storage.test.js
@@ -24,7 +24,7 @@ const cwd = path.join(__dirname, '..');
 
 // [END functions_storage_integration_test]
 
-describe('GCS integration test', () => {
+describe('functions_helloworld_storage 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
diff --git a/functions/helloworld/test/sample.unit.http.test.js b/functions/helloworld/test/sample.unit.http.test.js
index 1c423bfd8c..3abdc75584 100644
--- a/functions/helloworld/test/sample.unit.http.test.js
+++ b/functions/helloworld/test/sample.unit.http.test.js
@@ -13,45 +13,47 @@
  * limitations under the License.
  */
 
-// [START functions_http_unit_test]
-const assert = require('assert');
-const sinon = require('sinon');
-const uuid = require('uuid');
-
-const {helloHttp} = require('..');
-
-it('helloHttp: should print a name', () => {
-  // Mock ExpressJS 'req' and 'res' parameters
-  const name = uuid.v4();
-  const req = {
-    query: {},
-    body: {
-      name: name,
-    },
-  };
-  const res = {send: sinon.stub()};
-
-  // Call tested function
-  helloHttp(req, res);
-
-  // Verify behavior of tested function
-  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()};
-
-  // Call tested function
-  helloHttp(req, res);
-
-  // Verify behavior of tested function
-  assert.ok(res.send.calledOnce);
-  assert.deepStrictEqual(res.send.firstCall.args, ['Hello World!']);
+describe('functions_helloworld_http', () => {
+  // [START functions_http_unit_test]
+  const assert = require('assert');
+  const sinon = require('sinon');
+  const uuid = require('uuid');
+
+  const {helloHttp} = require('..');
+
+  it('helloHttp: should print a name', () => {
+    // Mock ExpressJS 'req' and 'res' parameters
+    const name = uuid.v4();
+    const req = {
+      query: {},
+      body: {
+        name: name,
+      },
+    };
+    const res = {send: sinon.stub()};
+
+    // Call tested function
+    helloHttp(req, res);
+
+    // Verify behavior of tested function
+    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()};
+
+    // Call tested function
+    helloHttp(req, res);
+
+    // Verify behavior of tested function
+    assert.ok(res.send.calledOnce);
+    assert.deepStrictEqual(res.send.firstCall.args, ['Hello World!']);
+  });
 });
diff --git a/functions/helloworld/test/sample.unit.pubsub.test.js b/functions/helloworld/test/sample.unit.pubsub.test.js
index 6b38d6245c..7264ab8f9e 100644
--- a/functions/helloworld/test/sample.unit.pubsub.test.js
+++ b/functions/helloworld/test/sample.unit.pubsub.test.js
@@ -13,34 +13,36 @@
  * limitations under the License.
  */
 
-// [START functions_pubsub_unit_test]
-const assert = require('assert');
-const uuid = require('uuid');
-const utils = require('@google-cloud/nodejs-repo-tools');
+describe('functions_helloworld_pubsub', () => {
+  // [START functions_pubsub_unit_test]
+  const assert = require('assert');
+  const uuid = require('uuid');
+  const utils = require('@google-cloud/nodejs-repo-tools');
 
-const {helloPubSub} = require('..');
+  const {helloPubSub} = require('..');
 
-beforeEach(utils.stubConsole);
-afterEach(utils.restoreConsole);
+  beforeEach(utils.stubConsole);
+  afterEach(utils.restoreConsole);
 
-it('helloPubSub: should print a name', () => {
-  // Create mock Pub/Sub event
-  const name = uuid.v4();
-  const event = {
-    data: Buffer.from(name).toString('base64'),
-  };
+  it('helloPubSub: should print a name', () => {
+    // Create mock Pub/Sub event
+    const name = uuid.v4();
+    const event = {
+      data: Buffer.from(name).toString('base64'),
+    };
 
-  // Call tested function and verify its behavior
-  helloPubSub(event);
-  assert.ok(console.log.calledWith(`Hello, ${name}!`));
-});
-// [END functions_pubsub_unit_test]
+    // Call tested function and verify its behavior
+    helloPubSub(event);
+    assert.ok(console.log.calledWith(`Hello, ${name}!`));
+  });
+  // [END functions_pubsub_unit_test]
 
-it('helloPubSub: should print hello world', () => {
-  // Create mock Pub/Sub event
-  const event = {};
+  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!'));
+    // Call tested function and verify its behavior
+    helloPubSub(event);
+    assert.ok(console.log.calledWith('Hello, World!'));
+  });
 });
diff --git a/functions/helloworld/test/sample.unit.storage.test.js b/functions/helloworld/test/sample.unit.storage.test.js
index c48871076b..fd7c78ec5e 100644
--- a/functions/helloworld/test/sample.unit.storage.test.js
+++ b/functions/helloworld/test/sample.unit.storage.test.js
@@ -13,55 +13,57 @@
  * limitations under the License.
  */
 
-// [START functions_storage_unit_test]
-const assert = require('assert');
-const uuid = require('uuid');
-const utils = require('@google-cloud/nodejs-repo-tools');
+describe('functions_helloworld_storage', () => {
+  // [START functions_storage_unit_test]
+  const assert = require('assert');
+  const uuid = require('uuid');
+  const utils = require('@google-cloud/nodejs-repo-tools');
 
-const {helloGCS} = require('..');
+  const {helloGCS} = require('..');
 
-beforeEach(utils.stubConsole);
-afterEach(utils.restoreConsole);
+  beforeEach(utils.stubConsole);
+  afterEach(utils.restoreConsole);
 
-it('helloGCS: should print uploaded message', () => {
-  // Initialize mocks
-  const filename = uuid.v4();
-  const event = {
-    name: filename,
-    resourceState: 'exists',
-    metageneration: '1',
-  };
+  it('helloGCS: should print uploaded message', () => {
+    // Initialize mocks
+    const filename = uuid.v4();
+    const event = {
+      name: filename,
+      resourceState: 'exists',
+      metageneration: '1',
+    };
 
-  // Call tested function and verify its behavior
-  helloGCS(event);
-  assert.ok(console.log.calledWith(`File ${filename} uploaded.`));
-});
-// [END functions_storage_unit_test]
+    // Call tested function and verify its behavior
+    helloGCS(event);
+    assert.ok(console.log.calledWith(`File ${filename} uploaded.`));
+  });
+  // [END functions_storage_unit_test]
 
-it('helloGCS: should print metadata updated message', () => {
-  // Initialize mocks
-  const filename = uuid.v4();
-  const event = {
-    name: filename,
-    resourceState: 'exists',
-    metageneration: '2',
-  };
+  it('helloGCS: should print metadata updated message', () => {
+    // Initialize mocks
+    const filename = uuid.v4();
+    const event = {
+      name: filename,
+      resourceState: 'exists',
+      metageneration: '2',
+    };
 
-  // Call tested function and verify its behavior
-  helloGCS(event);
-  assert.ok(console.log.calledWith(`File ${filename} metadata updated.`));
-});
+    // Call tested function and verify its behavior
+    helloGCS(event);
+    assert.ok(console.log.calledWith(`File ${filename} metadata updated.`));
+  });
 
-it('helloGCS: should print deleted message', () => {
-  // Initialize mocks
-  const filename = uuid.v4();
-  const event = {
-    name: filename,
-    resourceState: 'not_exists',
-    metageneration: '3',
-  };
+  it('helloGCS: should print deleted message', () => {
+    // Initialize mocks
+    const filename = uuid.v4();
+    const event = {
+      name: filename,
+      resourceState: 'not_exists',
+      metageneration: '3',
+    };
 
-  // Call tested function and verify its behavior
-  helloGCS(event);
-  assert.ok(console.log.calledWith(`File ${filename} deleted.`));
+    // Call tested function and verify its behavior
+    helloGCS(event);
+    assert.ok(console.log.calledWith(`File ${filename} deleted.`));
+  });
 });
diff --git a/functions/http/test/index.test.js b/functions/http/test/index.test.js
index e1cc240a81..33908e00e2 100644
--- a/functions/http/test/index.test.js
+++ b/functions/http/test/index.test.js
@@ -70,180 +70,191 @@ const getMocks = () => {
 beforeEach(tools.stubConsole);
 afterEach(tools.restoreConsole);
 
-it('http:helloHttp: should handle GET', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  mocks.req.method = 'GET';
-  httpSample.sample.helloHttp(mocks.req, mocks.res);
-
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello World!');
-});
+describe('functions_http_method', () => {
+  it('http:helloHttp: should handle GET', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    mocks.req.method = 'GET';
+    httpSample.sample.helloHttp(mocks.req, mocks.res);
+
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello World!');
+  });
 
-it('http:helloHttp: should handle PUT', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  mocks.req.method = 'PUT';
-  httpSample.sample.helloHttp(mocks.req, mocks.res);
+  it('http:helloHttp: should handle PUT', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    mocks.req.method = 'PUT';
+    httpSample.sample.helloHttp(mocks.req, mocks.res);
 
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 403);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.strictEqual(mocks.res.send.firstCall.args[0], 'Forbidden!');
-});
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 403);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(mocks.res.send.firstCall.args[0], 'Forbidden!');
+  });
 
-it('http:helloHttp: should handle other methods', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  mocks.req.method = 'POST';
-  httpSample.sample.helloHttp(mocks.req, mocks.res);
-
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 405);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.deepStrictEqual(mocks.res.send.firstCall.args[0], {
-    error: 'Something blew up!',
+  it('http:helloHttp: should handle other methods', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    mocks.req.method = 'POST';
+    httpSample.sample.helloHttp(mocks.req, mocks.res);
+
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 405);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.deepStrictEqual(mocks.res.send.firstCall.args[0], {
+      error: 'Something blew up!',
+    });
   });
 });
 
-it('http:helloContent: should handle application/json', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  mocks.req.headers['content-type'] = 'application/json';
-  mocks.req.body = {name: 'John'};
-  httpSample.sample.helloContent(mocks.req, mocks.res);
-
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello John!');
-});
+describe('functions_http_content', () => {
+  it('http:helloContent: should handle application/json', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    mocks.req.headers['content-type'] = 'application/json';
+    mocks.req.body = {name: 'John'};
+    httpSample.sample.helloContent(mocks.req, mocks.res);
+
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello John!');
+  });
 
-it('http:helloContent: should handle application/octet-stream', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  mocks.req.headers['content-type'] = 'application/octet-stream';
-  mocks.req.body = Buffer.from('John');
-  httpSample.sample.helloContent(mocks.req, mocks.res);
-
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello John!');
-});
+  it('http:helloContent: should handle application/octet-stream', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    mocks.req.headers['content-type'] = 'application/octet-stream';
+    mocks.req.body = Buffer.from('John');
+    httpSample.sample.helloContent(mocks.req, mocks.res);
+
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello John!');
+  });
 
-it('http:helloContent: should handle text/plain', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  mocks.req.headers['content-type'] = 'text/plain';
-  mocks.req.body = 'John';
-  httpSample.sample.helloContent(mocks.req, mocks.res);
-
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello John!');
-});
+  it('http:helloContent: should handle text/plain', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    mocks.req.headers['content-type'] = 'text/plain';
+    mocks.req.body = 'John';
+    httpSample.sample.helloContent(mocks.req, mocks.res);
+
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello John!');
+  });
 
-it('http:helloContent: should handle application/x-www-form-urlencoded', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  mocks.req.headers['content-type'] = 'application/x-www-form-urlencoded';
-  mocks.req.body = {name: 'John'};
-  httpSample.sample.helloContent(mocks.req, mocks.res);
-
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello John!');
-});
+  it('http:helloContent: should handle application/x-www-form-urlencoded', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    mocks.req.headers['content-type'] = 'application/x-www-form-urlencoded';
+    mocks.req.body = {name: 'John'};
+    httpSample.sample.helloContent(mocks.req, mocks.res);
+
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello John!');
+  });
 
-it('http:helloContent: should handle other', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  httpSample.sample.helloContent(mocks.req, mocks.res);
+  it('http:helloContent: should handle other', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    httpSample.sample.helloContent(mocks.req, mocks.res);
 
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello World!');
-});
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(mocks.res.send.firstCall.args[0], 'Hello World!');
+  });
 
-it('http:helloContent: should escape XSS', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
-  mocks.req.headers['content-type'] = 'text/plain';
-  mocks.req.body = {name: '<script>alert(1)</script>'};
-  httpSample.sample.helloContent(mocks.req, mocks.res);
-
-  assert.strictEqual(mocks.res.status.calledOnce, true);
-  assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-  assert.strictEqual(
-    mocks.res.send.firstCall.args[0].includes('<script>'),
-    false
-  );
+  it('http:helloContent: should escape XSS', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
+    mocks.req.headers['content-type'] = 'text/plain';
+    mocks.req.body = {name: '<script>alert(1)</script>'};
+    httpSample.sample.helloContent(mocks.req, mocks.res);
+
+    assert.strictEqual(mocks.res.status.calledOnce, true);
+    assert.strictEqual(mocks.res.status.firstCall.args[0], 200);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(
+      mocks.res.send.firstCall.args[0].includes('<script>'),
+      false
+    );
+  });
 });
 
-it('http:cors: should respond to preflight request (no auth)', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
+describe('functions_http_cors', () => {
+  it('http:cors: should respond to preflight request (no auth)', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
 
-  httpSample.sample.corsEnabledFunction(mocks.corsPreflightReq, mocks.res);
+    httpSample.sample.corsEnabledFunction(mocks.corsPreflightReq, mocks.res);
 
-  assert.strictEqual(mocks.res.status.calledOnceWith(204), true);
-  assert.strictEqual(mocks.res.send.called, true);
-});
+    assert.strictEqual(mocks.res.status.calledOnceWith(204), true);
+    assert.strictEqual(mocks.res.send.called, true);
+  });
 
-it('http:cors: should respond to main request (no auth)', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
+  it('http:cors: should respond to main request (no auth)', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
 
-  httpSample.sample.corsEnabledFunction(mocks.corsMainReq, mocks.res);
+    httpSample.sample.corsEnabledFunction(mocks.corsMainReq, mocks.res);
 
-  assert.strictEqual(mocks.res.send.calledOnceWith('Hello World!'), true);
-});
+    assert.strictEqual(mocks.res.send.calledOnceWith('Hello World!'), true);
+  });
 
-it('http:cors: should respond to preflight request (auth)', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
+  it('http:cors: should respond to preflight request (auth)', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
 
-  httpSample.sample.corsEnabledFunctionAuth(mocks.corsPreflightReq, mocks.res);
+    httpSample.sample.corsEnabledFunctionAuth(
+      mocks.corsPreflightReq,
+      mocks.res
+    );
 
-  assert.strictEqual(mocks.res.status.calledOnceWith(204), true);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
-});
+    assert.strictEqual(mocks.res.status.calledOnceWith(204), true);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+  });
 
-it('http:cors: should respond to main request (auth)', () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
+  it('http:cors: should respond to main request (auth)', () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
 
-  httpSample.sample.corsEnabledFunctionAuth(mocks.corsMainReq, mocks.res);
+    httpSample.sample.corsEnabledFunctionAuth(mocks.corsMainReq, mocks.res);
 
-  assert.strictEqual(mocks.res.send.calledOnceWith('Hello World!'), true);
+    assert.strictEqual(mocks.res.send.calledOnceWith('Hello World!'), true);
+  });
 });
 
-it('http:getSignedUrl: should process example request', async () => {
-  const mocks = getMocks();
-  const httpSample = getSample();
+describe('functions_http_signed_url', () => {
+  it('http:getSignedUrl: should process example request', async () => {
+    const mocks = getMocks();
+    const httpSample = getSample();
 
-  const reqMock = {
-    method: 'POST',
-    body: {
-      bucket: 'nodejs-docs-samples',
-      filename: `gcf-gcs-url-${uuid.v4}`,
-      contentType: 'application/octet-stream',
-    },
-  };
+    const reqMock = {
+      method: 'POST',
+      body: {
+        bucket: 'nodejs-docs-samples',
+        filename: `gcf-gcs-url-${uuid.v4}`,
+        contentType: 'application/octet-stream',
+      },
+    };
 
-  httpSample.sample.getSignedUrl(reqMock, mocks.res);
+    httpSample.sample.getSignedUrl(reqMock, mocks.res);
 
-  // Instead of modifying the sample to return a promise,
-  // use a delay here and keep the sample idiomatic
-  await new Promise(resolve => setTimeout(resolve, 300));
+    // Instead of modifying the sample to return a promise,
+    // use a delay here and keep the sample idiomatic
+    await new Promise(resolve => setTimeout(resolve, 300));
 
-  assert.strictEqual(mocks.res.status.called, false);
-  assert.strictEqual(mocks.res.send.calledOnce, true);
+    assert.strictEqual(mocks.res.status.called, false);
+    assert.strictEqual(mocks.res.send.calledOnce, true);
+  });
 });
diff --git a/functions/imagemagick/test/index.test.js b/functions/imagemagick/test/index.test.js
index 3f67206515..1f06f8de2b 100644
--- a/functions/imagemagick/test/index.test.js
+++ b/functions/imagemagick/test/index.test.js
@@ -87,71 +87,75 @@ describe('functions/imagemagick tests', () => {
   beforeEach(tools.stubConsole);
   afterEach(tools.restoreConsole);
 
-  it('blurOffensiveImages detects safe images using Cloud Vision', async () => {
-    const PORT = 8080;
-    const ffProc = startFF(PORT);
-
-    await requestRetry({
-      url: `http://localhost:${PORT}/blurOffensiveImages`,
-      body: {
-        data: {
-          bucket: BUCKET_NAME,
-          name: testFiles.safe,
+  describe('functions_imagemagick_analyze', () => {
+    it('blurOffensiveImages detects safe images using Cloud Vision', async () => {
+      const PORT = 8080;
+      const ffProc = startFF(PORT);
+
+      await requestRetry({
+        url: `http://localhost:${PORT}/blurOffensiveImages`,
+        body: {
+          data: {
+            bucket: BUCKET_NAME,
+            name: testFiles.safe,
+          },
         },
-      },
-    });
-
-    const {stdout} = await stopFF(ffProc);
-    assert.ok(stdout.includes(`Detected ${testFiles.safe} as OK.`));
-  });
+      });
 
-  it('blurOffensiveImages successfully blurs offensive images', async () => {
-    const PORT = 8081;
-    const ffProc = startFF(PORT);
-
-    await requestRetry({
-      url: `http://localhost:${PORT}/blurOffensiveImages`,
-      body: {
-        data: {
-          bucket: BUCKET_NAME,
-          name: testFiles.offensive,
-        },
-      },
+      const {stdout} = await stopFF(ffProc);
+      assert.ok(stdout.includes(`Detected ${testFiles.safe} as OK.`));
     });
 
-    const {stdout} = await stopFF(ffProc);
-
-    assert.ok(stdout.includes(`Blurred image: ${testFiles.offensive}`));
-    assert.ok(
-      stdout.includes(
-        `Uploaded blurred image to: gs://${BLURRED_BUCKET_NAME}/${testFiles.offensive}`
-      )
-    );
+    describe('functions_imagemagick_blur', () => {
+      it('blurOffensiveImages successfully blurs offensive images', async () => {
+        const PORT = 8081;
+        const ffProc = startFF(PORT);
+
+        await requestRetry({
+          url: `http://localhost:${PORT}/blurOffensiveImages`,
+          body: {
+            data: {
+              bucket: BUCKET_NAME,
+              name: testFiles.offensive,
+            },
+          },
+        });
+
+        const {stdout} = await stopFF(ffProc);
+
+        assert.ok(stdout.includes(`Blurred image: ${testFiles.offensive}`));
+        assert.ok(
+          stdout.includes(
+            `Uploaded blurred image to: gs://${BLURRED_BUCKET_NAME}/${testFiles.offensive}`
+          )
+        );
 
-    const exists = await storage
-      .bucket(BLURRED_BUCKET_NAME)
-      .file(testFiles.offensive)
-      .exists();
-    assert.ok(exists, 'File uploaded');
-  });
+        const exists = await storage
+          .bucket(BLURRED_BUCKET_NAME)
+          .file(testFiles.offensive)
+          .exists();
+        assert.ok(exists, 'File uploaded');
+      });
+    });
 
-  it('blurOffensiveImages detects missing images as safe using Cloud Vision', async () => {
-    const PORT = 8082;
-    const ffProc = startFF(PORT);
-    const missingFileName = 'file-does-not-exist.jpg';
-
-    await requestRetry({
-      url: `http://localhost:${PORT}/blurOffensiveImages`,
-      body: {
-        data: {
-          bucket: BUCKET_NAME,
-          name: missingFileName,
+    it('blurOffensiveImages detects missing images as safe using Cloud Vision', async () => {
+      const PORT = 8082;
+      const ffProc = startFF(PORT);
+      const missingFileName = 'file-does-not-exist.jpg';
+
+      await requestRetry({
+        url: `http://localhost:${PORT}/blurOffensiveImages`,
+        body: {
+          data: {
+            bucket: BUCKET_NAME,
+            name: missingFileName,
+          },
         },
-      },
-    });
+      });
 
-    const {stdout} = await stopFF(ffProc);
-    assert.ok(stdout.includes(`Detected ${missingFileName} as OK.`));
+      const {stdout} = await stopFF(ffProc);
+      assert.ok(stdout.includes(`Detected ${missingFileName} as OK.`));
+    });
   });
 
   after(async () => {
diff --git a/functions/log/test/index.test.js b/functions/log/test/index.test.js
index 48f10b66d7..cc2d2eff07 100644
--- a/functions/log/test/index.test.js
+++ b/functions/log/test/index.test.js
@@ -55,77 +55,91 @@ const getSample = () => {
 beforeEach(tools.stubConsole);
 afterEach(tools.restoreConsole);
 
-it('should write to log', () => {
-  const expectedMsg = 'I am a log entry!';
-  const res = {end: sinon.stub()};
+describe('functions_log_helloworld', () => {
+  it('should write to log', () => {
+    const expectedMsg = 'I am a log entry!';
+    const res = {end: sinon.stub()};
 
-  getSample().program.helloWorld({}, res);
+    getSample().program.helloWorld({}, res);
 
-  assert.strictEqual(console.log.callCount, 1);
-  assert.deepStrictEqual(console.log.firstCall.args, [expectedMsg]);
-  assert.strictEqual(res.end.callCount, 1);
-  assert.deepStrictEqual(res.end.firstCall.args, []);
+    assert.strictEqual(console.log.callCount, 1);
+    assert.deepStrictEqual(console.log.firstCall.args, [expectedMsg]);
+    assert.strictEqual(res.end.callCount, 1);
+    assert.deepStrictEqual(res.end.firstCall.args, []);
+  });
 });
 
-it('getLogEntries: should retrieve logs', async () => {
-  const sample = getSample();
+describe('functions_log_retrieve', () => {
+  it('getLogEntries: should retrieve logs', async () => {
+    const sample = getSample();
 
-  const entries = await sample.program.getLogEntries();
-  assert.strictEqual(console.log.calledWith('Entries:'), true);
-  assert.strictEqual(entries === sample.mocks.results[0], true);
+    const entries = await sample.program.getLogEntries();
+    assert.strictEqual(console.log.calledWith('Entries:'), true);
+    assert.strictEqual(entries === sample.mocks.results[0], true);
+  });
 });
 
-it('getMetrics: should retrieve metrics', () => {
-  const sample = getSample();
-  const callback = sinon.stub();
+describe('functions_log_get_metrics', () => {
+  it('getMetrics: should retrieve metrics', () => {
+    const sample = getSample();
+    const callback = sinon.stub();
 
-  sample.program.getMetrics(callback);
+    sample.program.getMetrics(callback);
 
-  assert.strictEqual(callback.callCount, 1);
+    assert.strictEqual(callback.callCount, 1);
+  });
 });
 
-it('processLogEntry: should process log entry', () => {
-  const sample = getSample();
-  const json = JSON.stringify({
-    protoPayload: {
-      methodName: 'method',
-      resourceName: 'resource',
-      authenticationInfo: {
-        principalEmail: 'me@example.com',
+describe('functions_log_stackdriver', () => {
+  it('processLogEntry: should process log entry', () => {
+    const sample = getSample();
+    const json = JSON.stringify({
+      protoPayload: {
+        methodName: 'method',
+        resourceName: 'resource',
+        authenticationInfo: {
+          principalEmail: 'me@example.com',
+        },
       },
-    },
-  });
+    });
 
-  const data = {
-    data: Buffer.from(json, 'ascii'),
-  };
+    const data = {
+      data: Buffer.from(json, 'ascii'),
+    };
 
-  sample.program.processLogEntry(data);
+    sample.program.processLogEntry(data);
 
-  assert.strictEqual(console.log.calledWith('Method: method'), true);
-  assert.strictEqual(console.log.calledWith('Resource: resource'), true);
-  assert.strictEqual(console.log.calledWith('Initiator: me@example.com'), true);
-});
+    assert.strictEqual(console.log.calledWith('Method: method'), true);
+    assert.strictEqual(console.log.calledWith('Resource: resource'), true);
+    assert.strictEqual(
+      console.log.calledWith('Initiator: me@example.com'),
+      true
+    );
+  });
 
-it('processLogEntry: should work in Node 8', () => {
-  const sample = getSample();
-  const json = JSON.stringify({
-    protoPayload: {
-      methodName: 'method',
-      resourceName: 'resource',
-      authenticationInfo: {
-        principalEmail: 'me@example.com',
+  it('processLogEntry: should work in Node 8', () => {
+    const sample = getSample();
+    const json = JSON.stringify({
+      protoPayload: {
+        methodName: 'method',
+        resourceName: 'resource',
+        authenticationInfo: {
+          principalEmail: 'me@example.com',
+        },
       },
-    },
-  });
+    });
 
-  const data = {
-    data: Buffer.from(json, 'ascii'),
-  };
+    const data = {
+      data: Buffer.from(json, 'ascii'),
+    };
 
-  sample.program.processLogEntry(data);
+    sample.program.processLogEntry(data);
 
-  assert.strictEqual(console.log.calledWith('Method: method'), true);
-  assert.strictEqual(console.log.calledWith('Resource: resource'), true);
-  assert.strictEqual(console.log.calledWith('Initiator: me@example.com'), true);
+    assert.strictEqual(console.log.calledWith('Method: method'), true);
+    assert.strictEqual(console.log.calledWith('Resource: resource'), true);
+    assert.strictEqual(
+      console.log.calledWith('Initiator: me@example.com'),
+      true
+    );
+  });
 });
diff --git a/functions/memorystore/redis/test/index.test.js b/functions/memorystore/redis/test/index.test.js
index bcc3385434..d0d5fe4bb8 100644
--- a/functions/memorystore/redis/test/index.test.js
+++ b/functions/memorystore/redis/test/index.test.js
@@ -30,19 +30,21 @@ const getMocks = () => {
   };
 };
 
-describe('visitCount', () => {
-  it('should successfully increment the Redis counter', async () => {
-    const program = require('../');
-    const mocks = getMocks();
+describe('functions_memorystore_redis', () => {
+  describe('visitCount', () => {
+    it('should successfully increment the Redis counter', async () => {
+      const program = require('../');
+      const mocks = getMocks();
 
-    await program.visitCount(mocks.req, mocks.res);
+      await program.visitCount(mocks.req, mocks.res);
 
-    assert(!mocks.res.status.called);
-    assert(!mocks.res.send.called);
-    assert(mocks.res.writeHead.calledWith(200));
-    assert(mocks.res.end.calledOnce);
+      assert(!mocks.res.status.called);
+      assert(!mocks.res.send.called);
+      assert(mocks.res.writeHead.calledWith(200));
+      assert(mocks.res.end.calledOnce);
 
-    const [response] = mocks.res.end.firstCall.args;
-    assert(response.startsWith('Visit count:'));
+      const [response] = mocks.res.end.firstCall.args;
+      assert(response.startsWith('Visit count:'));
+    });
   });
 });
diff --git a/functions/node8/test/index.test.js b/functions/node8/test/index.test.js
index 1925de3650..12be84b25e 100644
--- a/functions/node8/test/index.test.js
+++ b/functions/node8/test/index.test.js
@@ -99,211 +99,246 @@ it('should escape XSS', () => {
   assert.strictEqual(resMock.send.calledWith(xssQuery), false);
 });
 
-it('should monitor Firebase RTDB', () => {
-  const sample = getSample();
-
-  const dataId = uuid.v4();
-  const resourceId = uuid.v4();
-
-  const data = {
-    admin: true,
-    delta: {
-      id: dataId,
-    },
-    params: {
-      baz: 'quux',
-    },
-  };
-  const context = {
-    resource: resourceId,
-  };
+describe('functions_firebase_rtdb_node8', () => {
+  it('should monitor Firebase RTDB', () => {
+    const sample = getSample();
 
-  sample.program.helloRTDB(data, context);
+    const dataId = uuid.v4();
+    const resourceId = uuid.v4();
 
-  assert.deepStrictEqual(console.log.getCall(1).args, ['  baz: quux']);
-  assert.strictEqual(console.log.getCall(2).args[0].includes(resourceId), true);
-  assert.deepStrictEqual(console.log.getCall(3).args, ['Admin?: true']);
-  assert.strictEqual(console.log.getCall(5).args[0].includes(dataId), true);
+    const data = {
+      admin: true,
+      delta: {
+        id: dataId,
+      },
+      params: {
+        baz: 'quux',
+      },
+    };
+    const context = {
+      resource: resourceId,
+    };
+
+    sample.program.helloRTDB(data, context);
+
+    assert.deepStrictEqual(console.log.getCall(1).args, ['  baz: quux']);
+    assert.strictEqual(
+      console.log.getCall(2).args[0].includes(resourceId),
+      true
+    );
+    assert.deepStrictEqual(console.log.getCall(3).args, ['Admin?: true']);
+    assert.strictEqual(console.log.getCall(5).args[0].includes(dataId), true);
+  });
 });
 
-it('should monitor Firestore', () => {
-  const sample = getSample();
-
-  const resourceId = uuid.v4();
-
-  const context = {
-    resource: resourceId,
-  };
-  const data = {
-    oldValue: {uuid: uuid.v4()},
-    value: {uuid: uuid.v4()},
-  };
-
-  sample.program.helloFirestore(data, context);
-
-  assert.strictEqual(console.log.firstCall.args[0].includes(resourceId), true);
-  assert.strictEqual(
-    console.log.calledWith(JSON.stringify(data.oldValue, null, 2)),
-    true
-  );
-  assert.strictEqual(
-    console.log.calledWith(JSON.stringify(data.value, null, 2)),
-    true
-  );
+describe('functions_firebase_firestore_node8', () => {
+  it('should monitor Firestore', () => {
+    const sample = getSample();
+
+    const resourceId = uuid.v4();
+
+    const context = {
+      resource: resourceId,
+    };
+    const data = {
+      oldValue: {uuid: uuid.v4()},
+      value: {uuid: uuid.v4()},
+    };
+
+    sample.program.helloFirestore(data, context);
+
+    assert.strictEqual(
+      console.log.firstCall.args[0].includes(resourceId),
+      true
+    );
+    assert.strictEqual(
+      console.log.calledWith(JSON.stringify(data.oldValue, null, 2)),
+      true
+    );
+    assert.strictEqual(
+      console.log.calledWith(JSON.stringify(data.value, null, 2)),
+      true
+    );
+  });
 });
 
-it('should monitor Auth', () => {
-  const sample = getSample();
+describe('functions_firebase_auth_node8', () => {
+  it('should monitor Auth', () => {
+    const sample = getSample();
 
-  const userId = uuid.v4();
-  const dateString = new Date().toISOString();
-  const emailString = `${uuid.v4()}@${uuid.v4()}.com`;
+    const userId = uuid.v4();
+    const dateString = new Date().toISOString();
+    const emailString = `${uuid.v4()}@${uuid.v4()}.com`;
 
-  const data = {
-    uid: userId,
-    metadata: {
-      createdAt: dateString,
-    },
-    email: emailString,
-  };
-
-  sample.program.helloAuth(data, null);
-
-  assert.strictEqual(console.log.firstCall.args[0].includes(userId), true);
-  assert.strictEqual(console.log.secondCall.args[0].includes(dateString), true);
-  assert.strictEqual(console.log.thirdCall.args[0].includes(emailString), true);
+    const data = {
+      uid: userId,
+      metadata: {
+        createdAt: dateString,
+      },
+      email: emailString,
+    };
+
+    sample.program.helloAuth(data, null);
+
+    assert.strictEqual(console.log.firstCall.args[0].includes(userId), true);
+    assert.strictEqual(
+      console.log.secondCall.args[0].includes(dateString),
+      true
+    );
+    assert.strictEqual(
+      console.log.thirdCall.args[0].includes(emailString),
+      true
+    );
+  });
 });
 
-it('should monitor Analytics', () => {
-  const sample = getSample();
+describe('functions_firebase_analytics_node8', () => {
+  it('should monitor Analytics', () => {
+    const sample = getSample();
 
-  const date = new Date();
-  const data = {
-    eventDim: [
-      {
-        name: 'my-event',
-        timestampMicros: `${date.valueOf()}000`,
-      },
-    ],
-    userDim: {
-      deviceInfo: {
-        deviceModel: 'Pixel',
-      },
-      geoInfo: {
-        city: 'London',
-        country: 'UK',
+    const date = new Date();
+    const data = {
+      eventDim: [
+        {
+          name: 'my-event',
+          timestampMicros: `${date.valueOf()}000`,
+        },
+      ],
+      userDim: {
+        deviceInfo: {
+          deviceModel: 'Pixel',
+        },
+        geoInfo: {
+          city: 'London',
+          country: 'UK',
+        },
       },
-    },
-  };
-
-  const context = {
-    resource: 'my-resource',
-  };
-
-  sample.program.helloAnalytics(data, context);
-
-  assert.strictEqual(
-    console.log.args[0][0],
-    'Function triggered by the following event: my-resource'
-  );
-  assert.strictEqual(console.log.args[1][0], 'Name: my-event');
-  assert.strictEqual(console.log.args[2][0], `Timestamp: ${date}`);
-  assert.strictEqual(console.log.args[3][0], 'Device Model: Pixel');
-  assert.strictEqual(console.log.args[4][0], 'Location: London, UK');
+    };
+
+    const context = {
+      resource: 'my-resource',
+    };
+
+    sample.program.helloAnalytics(data, context);
+
+    assert.strictEqual(
+      console.log.args[0][0],
+      'Function triggered by the following event: my-resource'
+    );
+    assert.strictEqual(console.log.args[1][0], 'Name: my-event');
+    assert.strictEqual(console.log.args[2][0], `Timestamp: ${date}`);
+    assert.strictEqual(console.log.args[3][0], 'Device Model: Pixel');
+    assert.strictEqual(console.log.args[4][0], 'Location: London, UK');
+  });
 });
 
-it('should make a promise request', async () => {
-  const sample = getSample();
-  const data = {
-    endpoint: 'foo.com',
-  };
-
-  const result = await sample.program.helloPromise(data);
-  assert.deepStrictEqual(sample.mocks.nodeFetch.firstCall.args, ['foo.com']);
-  assert.strictEqual(result, 'test');
+describe('functions_background_promise_node8', () => {
+  it('should make a promise request', async () => {
+    const sample = getSample();
+    const data = {
+      endpoint: 'foo.com',
+    };
+
+    const result = await sample.program.helloPromise(data);
+    assert.deepStrictEqual(sample.mocks.nodeFetch.firstCall.args, ['foo.com']);
+    assert.strictEqual(result, 'test');
+  });
 });
 
-it('should return synchronously', () => {
-  assert.strictEqual(
-    getSample().program.helloSynchronous({
-      something: true,
-    }),
-    'Something is true!'
-  );
+describe('functions_background_synchronous_node8', () => {
+  it('should return synchronously', () => {
+    assert.strictEqual(
+      getSample().program.helloSynchronous({
+        something: true,
+      }),
+      'Something is true!'
+    );
+  });
 });
 
-it('should throw an error', () => {
-  assert.throws(
-    () => {
-      getSample().program.helloSynchronous({
-        something: false,
-      });
-    },
-    Error,
-    'Something was not true!'
-  );
+describe('functions_background_synchronous_node8', () => {
+  it('should throw an error', () => {
+    assert.throws(
+      () => {
+        getSample().program.helloSynchronous({
+          something: false,
+        });
+      },
+      Error,
+      'Something was not true!'
+    );
+  });
 });
 
-it('should update data in response to Firestore events', () => {
-  const sample = getSample();
+describe('functions_firebase_reactive_node8', () => {
+  it('should update data in response to Firestore events', () => {
+    const sample = getSample();
 
-  const date = Date.now();
-  const data = {
-    email: 'me@example.com',
-    metadata: {
-      createdAt: date,
-    },
-    value: {
-      fields: {
-        original: {
-          stringValue: 'foobar',
+    const date = Date.now();
+    const data = {
+      email: 'me@example.com',
+      metadata: {
+        createdAt: date,
+      },
+      value: {
+        fields: {
+          original: {
+            stringValue: 'foobar',
+          },
         },
       },
-    },
-  };
-
-  const context = {
-    resource: '/documents/some/path',
-  };
-
-  sample.program.makeUpperCase(data, context);
-
-  assert.strictEqual(sample.mocks.firestore.doc.calledWith('some/path'), true);
-  assert.strictEqual(
-    console.log.calledWith('Replacing value: foobar --> FOOBAR'),
-    true
-  );
-  assert.strictEqual(
-    sample.mocks.firestore.set.calledWith({original: 'FOOBAR'}),
-    true
-  );
+    };
+
+    const context = {
+      resource: '/documents/some/path',
+    };
+
+    sample.program.makeUpperCase(data, context);
+
+    assert.strictEqual(
+      sample.mocks.firestore.doc.calledWith('some/path'),
+      true
+    );
+    assert.strictEqual(
+      console.log.calledWith('Replacing value: foobar --> FOOBAR'),
+      true
+    );
+    assert.strictEqual(
+      sample.mocks.firestore.set.calledWith({original: 'FOOBAR'}),
+      true
+    );
+  });
 });
 
-it('should listen to Firebase Remote Config events', () => {
-  const sample = getSample();
-
-  const data = {
-    updateOrigin: 'CONSOLE',
-    updateType: 'INCREMENTAL_UPDATE',
-    versionNumber: '1',
-  };
-
-  sample.program.helloRemoteConfig(data);
-
-  assert.strictEqual(
-    console.log.calledWith('Update type: INCREMENTAL_UPDATE'),
-    true
-  );
-  assert.strictEqual(console.log.calledWith('Origin: CONSOLE'), true);
-  assert.strictEqual(console.log.calledWith('Version: 1'), true);
+describe('functions_firebase_remote_config_node8', () => {
+  it('should listen to Firebase Remote Config events', () => {
+    const sample = getSample();
+
+    const data = {
+      updateOrigin: 'CONSOLE',
+      updateType: 'INCREMENTAL_UPDATE',
+      versionNumber: '1',
+    };
+
+    sample.program.helloRemoteConfig(data);
+
+    assert.strictEqual(
+      console.log.calledWith('Update type: INCREMENTAL_UPDATE'),
+      true
+    );
+    assert.strictEqual(console.log.calledWith('Origin: CONSOLE'), true);
+    assert.strictEqual(console.log.calledWith('Version: 1'), true);
+  });
 });
 
-it('should make async HTTP request', () => {
-  const sample = getSample();
+describe('functions_background_async', () => {
+  it('should make async HTTP request', () => {
+    const sample = getSample();
 
-  sample.program.helloAsync();
-  assert.strictEqual(
-    sample.mocks.nodeFetch.calledWith('https://www.example.com'),
-    true
-  );
+    sample.program.helloAsync();
+    assert.strictEqual(
+      sample.mocks.nodeFetch.calledWith('https://www.example.com'),
+      true
+    );
+  });
 });
diff --git a/functions/node8/test/sample.unit.pubsub.test.js b/functions/node8/test/sample.unit.pubsub.test.js
index 293bc61956..fd85b76f3d 100644
--- a/functions/node8/test/sample.unit.pubsub.test.js
+++ b/functions/node8/test/sample.unit.pubsub.test.js
@@ -23,24 +23,26 @@ const {helloPubSub} = require('..');
 beforeEach(utils.stubConsole);
 afterEach(utils.restoreConsole);
 
-it('helloPubSub: should print a name', async () => {
-  // Initialize mocks
-  const name = uuid.v4();
-  const event = {
-    data: Buffer.from(name).toString('base64'),
-  };
+describe('functions_helloworld_pubsub_node8', () => {
+  it('helloPubSub: should print a name', async () => {
+    // Initialize mocks
+    const name = uuid.v4();
+    const event = {
+      data: Buffer.from(name).toString('base64'),
+    };
 
-  // Call tested function and verify its behavior
-  await helloPubSub(event);
-  assert.strictEqual(console.log.calledWith(`Hello, ${name}!`), true);
-});
+    // Call tested function and verify its behavior
+    await helloPubSub(event);
+    assert.strictEqual(console.log.calledWith(`Hello, ${name}!`), true);
+  });
 
-it('helloPubSub: should print hello world', async () => {
-  // Initialize mocks
-  const event = {};
+  it('helloPubSub: should print hello world', async () => {
+    // Initialize mocks
+    const event = {};
 
-  // Call tested function and verify its behavior
-  await helloPubSub(event);
-  assert.strictEqual(console.log.calledWith('Hello, World!'), true);
+    // Call tested function and verify its behavior
+    await helloPubSub(event);
+    assert.strictEqual(console.log.calledWith('Hello, World!'), true);
+  });
 });
 // [END functions_pubsub_unit_test]
diff --git a/functions/node8/test/sample.unit.storage.test.js b/functions/node8/test/sample.unit.storage.test.js
index 8656a36f25..2a97c65a17 100644
--- a/functions/node8/test/sample.unit.storage.test.js
+++ b/functions/node8/test/sample.unit.storage.test.js
@@ -23,51 +23,56 @@ const {helloGCS} = require('..');
 beforeEach(utils.stubConsole);
 afterEach(utils.restoreConsole);
 
-it('helloGCS: should print uploaded message', async () => {
-  // Initialize mocks
-  const filename = uuid.v4();
-  const event = {
-    name: filename,
-    resourceState: 'exists',
-    metageneration: '1',
-  };
+describe('functions_helloworld_storage_node8', () => {
+  it('helloGCS: should print uploaded message', async () => {
+    // Initialize mocks
+    const filename = uuid.v4();
+    const event = {
+      name: filename,
+      resourceState: 'exists',
+      metageneration: '1',
+    };
 
-  // Call tested function and verify its behavior
-  await helloGCS(event);
-  assert.strictEqual(
-    console.log.calledWith(`File ${filename} uploaded.`),
-    true
-  );
-});
+    // Call tested function and verify its behavior
+    await helloGCS(event);
+    assert.strictEqual(
+      console.log.calledWith(`File ${filename} uploaded.`),
+      true
+    );
+  });
 
-it('helloGCS: should print metadata updated message', async () => {
-  // Initialize mocks
-  const filename = uuid.v4();
-  const event = {
-    name: filename,
-    resourceState: 'exists',
-    metageneration: '2',
-  };
+  it('helloGCS: should print metadata updated message', async () => {
+    // Initialize mocks
+    const filename = uuid.v4();
+    const event = {
+      name: filename,
+      resourceState: 'exists',
+      metageneration: '2',
+    };
 
-  // Call tested function and verify its behavior
-  await helloGCS(event);
-  assert.strictEqual(
-    console.log.calledWith(`File ${filename} metadata updated.`),
-    true
-  );
-});
+    // Call tested function and verify its behavior
+    await helloGCS(event);
+    assert.strictEqual(
+      console.log.calledWith(`File ${filename} metadata updated.`),
+      true
+    );
+  });
 
-it('helloGCS: should print deleted message', async () => {
-  // Initialize mocks
-  const filename = uuid.v4();
-  const event = {
-    name: filename,
-    resourceState: 'not_exists',
-    metageneration: '3',
-  };
+  it('helloGCS: should print deleted message', async () => {
+    // Initialize mocks
+    const filename = uuid.v4();
+    const event = {
+      name: filename,
+      resourceState: 'not_exists',
+      metageneration: '3',
+    };
 
-  // Call tested function and verify its behavior
-  await helloGCS(event);
-  assert.strictEqual(console.log.calledWith(`File ${filename} deleted.`), true);
+    // Call tested function and verify its behavior
+    await helloGCS(event);
+    assert.strictEqual(
+      console.log.calledWith(`File ${filename} deleted.`),
+      true
+    );
+  });
 });
 // [END functions_storage_unit_test]
diff --git a/functions/ocr/app/test/index.test.js b/functions/ocr/app/test/index.test.js
index 9f8e0af25e..c2ab9b5caa 100644
--- a/functions/ocr/app/test/index.test.js
+++ b/functions/ocr/app/test/index.test.js
@@ -40,101 +40,117 @@ before(tools.stubConsole);
 after(tools.restoreConsole);
 
 describe('processImage', () => {
-  it('processImage validates parameters', async () => {
-    try {
-      await program.processImage({data: {}});
-      assert.fail('no error thrown');
-    } catch (err) {
-      assert.strictEqual(err.message, errorMsg('Bucket'));
-    }
+  describe('functions_ocr_process', () => {
+    it('processImage validates parameters', async () => {
+      try {
+        await program.processImage({data: {}});
+        assert.fail('no error thrown');
+      } catch (err) {
+        assert.strictEqual(err.message, errorMsg('Bucket'));
+      }
+    });
   });
 
-  it('processImage detects text', async () => {
-    const data = {
-      bucket: bucketName,
-      name: filename,
-    };
-
-    await program.processImage(data);
-    assert.ok(console.log.calledWith(`Detected language "en" for ${filename}`));
-    assert.ok(
-      console.log.calledWith(`Extracted text from image:`, `${text}\n`)
-    );
-    assert.ok(console.log.calledWith(`Detected language "en" for ${filename}`));
-    assert.ok(console.log.calledWith(`File ${filename} processed.`));
+  describe('functions_ocr_process functions_ocr_detect functions_ocr_publish', () => {
+    it('processImage detects text', async () => {
+      const data = {
+        bucket: bucketName,
+        name: filename,
+      };
+
+      await program.processImage(data);
+      assert.ok(
+        console.log.calledWith(`Detected language "en" for ${filename}`)
+      );
+      assert.ok(
+        console.log.calledWith(`Extracted text from image:`, `${text}\n`)
+      );
+      assert.ok(
+        console.log.calledWith(`Detected language "en" for ${filename}`)
+      );
+      assert.ok(console.log.calledWith(`File ${filename} processed.`));
+    });
   });
 });
 
 describe('translateText', () => {
-  it('translateText validates parameters', async () => {
-    const event = {
-      data: Buffer.from(JSON.stringify({})).toString('base64'),
-    };
-    try {
-      await program.translateText(event);
-      assert.fail('no error thrown');
-    } catch (err) {
-      assert.deepStrictEqual(err.message, errorMsg('Text'));
-    }
+  describe('functions_ocr_translate', () => {
+    it('translateText validates parameters', async () => {
+      const event = {
+        data: Buffer.from(JSON.stringify({})).toString('base64'),
+      };
+      try {
+        await program.translateText(event);
+        assert.fail('no error thrown');
+      } catch (err) {
+        assert.deepStrictEqual(err.message, errorMsg('Text'));
+      }
+    });
   });
 
-  it('translateText translates and publishes text', async () => {
-    const data = {
-      data: Buffer.from(
-        JSON.stringify({
-          text,
-          filename,
-          lang,
-        })
-      ).toString('base64'),
-    };
-
-    await program.translateText(data);
-    assert.ok(console.log.calledWith(`Translating text into ${lang}`));
-    assert.ok(console.log.calledWith(`Text translated to ${lang}`));
+  describe('functions_ocr_translate functions_ocr_publish', () => {
+    it('translateText translates and publishes text', async () => {
+      const data = {
+        data: Buffer.from(
+          JSON.stringify({
+            text,
+            filename,
+            lang,
+          })
+        ).toString('base64'),
+      };
+
+      await program.translateText(data);
+      assert.ok(console.log.calledWith(`Translating text into ${lang}`));
+      assert.ok(console.log.calledWith(`Text translated to ${lang}`));
+    });
   });
 });
 
 describe('saveResult', () => {
-  it('saveResult validates parameters', async () => {
-    const event = {
-      data: Buffer.from(JSON.stringify({text, filename})).toString('base64'),
-    };
-
-    try {
-      await program.saveResult(event);
-      assert.fail('no error thrown');
-    } catch (err) {
-      assert.deepStrictEqual(err.message, errorMsg('Language', 'lang'));
-    }
+  describe('functions_ocr_save', () => {
+    it('saveResult validates parameters', async () => {
+      const event = {
+        data: Buffer.from(JSON.stringify({text, filename})).toString('base64'),
+      };
+
+      try {
+        await program.saveResult(event);
+        assert.fail('no error thrown');
+      } catch (err) {
+        assert.deepStrictEqual(err.message, errorMsg('Language', 'lang'));
+      }
+    });
   });
 
-  it('saveResult translates and publishes text', async () => {
-    const data = {
-      data: Buffer.from(JSON.stringify({text, filename, lang})).toString(
-        'base64'
-      ),
-    };
-
-    const newFilename = `${filename}_to_${lang}.txt`;
-
-    await program.saveResult(data);
-    assert.ok(
-      console.log.calledWith(`Received request to save file ${filename}`)
-    );
-    assert.ok(
-      console.log.calledWith(
-        `Saving result to ${newFilename} in bucket ${RESULT_BUCKET}`
-      )
-    );
-    assert.ok(console.log.calledWith('File saved.'));
-
-    // Check file was actually saved
-    assert.ok(
-      storage
-        .bucket(RESULT_BUCKET)
-        .file(newFilename)
-        .exists()
-    );
+  describe('functions_ocr_save functions_ocr_rename', () => {
+    it('saveResult translates and publishes text', async () => {
+      const data = {
+        data: Buffer.from(JSON.stringify({text, filename, lang})).toString(
+          'base64'
+        ),
+      };
+
+      const newFilename = `${filename}_to_${lang}.txt`;
+
+      await program.saveResult(data);
+      assert.ok(
+        console.log.calledWith(`Received request to save file ${filename}`)
+      );
+      assert.ok(
+        console.log.calledWith(
+          `Saving result to ${newFilename} in bucket ${RESULT_BUCKET}`
+        )
+      );
+      assert.ok(console.log.calledWith('File saved.'));
+
+      // Check file was actually saved
+      assert.ok(
+        storage
+          .bucket(RESULT_BUCKET)
+          .file(newFilename)
+          .exists()
+      );
+    });
   });
 });
diff --git a/functions/pubsub/test/index.test.js b/functions/pubsub/test/index.test.js
index a1390f30f6..3beb5817e0 100644
--- a/functions/pubsub/test/index.test.js
+++ b/functions/pubsub/test/index.test.js
@@ -48,46 +48,50 @@ describe('functions/pubsub', () => {
     await ffProc;
   });
 
-  it('publish fails without parameters', async () => {
-    const response = await requestRetry({
-      url: `${BASE_URL}/`,
-      method: 'POST',
-      body: {},
-      retryDelay: 200,
-      json: true,
+  describe('functions_pubsub_publish', () => {
+    it('publish fails without parameters', async () => {
+      const response = await requestRetry({
+        url: `${BASE_URL}/`,
+        method: 'POST',
+        body: {},
+        retryDelay: 200,
+        json: true,
+      });
+
+      assert.strictEqual(response.statusCode, 500);
+      assert.strictEqual(
+        response.body,
+        'Missing parameter(s); include "topic" and "subscription" properties in your request.'
+      );
     });
 
-    assert.strictEqual(response.statusCode, 500);
-    assert.strictEqual(
-      response.body,
-      'Missing parameter(s); include "topic" and "subscription" properties in your request.'
-    );
-  });
-
-  it('publishes a message', async () => {
-    const response = await requestRetry({
-      url: `${BASE_URL}/`,
-      method: 'POST',
-      body: {
-        topic: TOPIC,
-        message: 'Pub/Sub from Cloud Functions',
-      },
-      retryDelay: 200,
-      json: true,
+    it('publishes a message', async () => {
+      const response = await requestRetry({
+        url: `${BASE_URL}/`,
+        method: 'POST',
+        body: {
+          topic: TOPIC,
+          message: 'Pub/Sub from Cloud Functions',
+        },
+        retryDelay: 200,
+        json: true,
+      });
+
+      assert.strictEqual(response.statusCode, 200);
+      assert.strictEqual(response.body, 'Message published.');
     });
-
-    assert.strictEqual(response.statusCode, 200);
-    assert.strictEqual(response.body, 'Message published.');
   });
 
-  it('prints out a message', () => {
-    const jsonObject = JSON.stringify({data: MESSAGE});
-    const jsonBuffer = Buffer.from(jsonObject).toString('base64');
-    const pubsubMessage = {data: jsonBuffer, attributes: {}};
+  describe('functions_pubsub_subscribe', () => {
+    it('prints out a message', () => {
+      const jsonObject = JSON.stringify({data: MESSAGE});
+      const jsonBuffer = Buffer.from(jsonObject).toString('base64');
+      const pubsubMessage = {data: jsonBuffer, attributes: {}};
 
-    require('..').subscribe(pubsubMessage);
+      require('..').subscribe(pubsubMessage);
 
-    assert.strictEqual(console.log.callCount, 1);
-    assert.deepStrictEqual(console.log.firstCall.args, [jsonObject]);
+      assert.strictEqual(console.log.callCount, 1);
+      assert.deepStrictEqual(console.log.firstCall.args, [jsonObject]);
+    });
   });
 });
diff --git a/functions/scheduleinstance/test/index.test.js b/functions/scheduleinstance/test/index.test.js
index 4347bc373f..f713286185 100644
--- a/functions/scheduleinstance/test/index.test.js
+++ b/functions/scheduleinstance/test/index.test.js
@@ -53,123 +53,157 @@ beforeEach(tools.stubConsole);
 afterEach(tools.restoreConsole);
 
 /** Tests for startInstancePubSub */
-
-it('startInstancePubSub: should accept JSON-formatted event payload with label', async () => {
-  const mocks = getMocks();
-  const sample = getSample();
-  const pubsubData = {zone: 'test-zone', label: 'testkey=value'};
-  mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString('base64');
-  sample.program.startInstancePubSub(
-    mocks.event,
-    mocks.context,
-    mocks.callback
-  );
-
-  const data = await sample.mocks.requestPromise();
-  // The request was successfully sent.
-  assert.strictEqual(data, 'request sent');
-});
-
-it(`startInstancePubSub: should fail with missing 'zone' attribute`, () => {
-  const mocks = getMocks();
-  const sample = getSample();
-  const pubsubData = {label: 'testkey=value'};
-  mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString('base64');
-  sample.program.startInstancePubSub(
-    mocks.event,
-    mocks.context,
-    mocks.callback
-  );
-
-  assert.deepStrictEqual(
-    mocks.callback.firstCall.args[0],
-    new Error(`Attribute 'zone' missing from payload`)
-  );
-});
-
-it(`startInstancePubSub: should fail with missing 'label' attribute`, () => {
-  const mocks = getMocks();
-  const sample = getSample();
-  const pubsubData = {zone: 'test-zone'};
-  mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString('base64');
-  sample.program.startInstancePubSub(
-    mocks.event,
-    mocks.context,
-    mocks.callback
-  );
-
-  assert.deepStrictEqual(
-    mocks.callback.firstCall.args[0],
-    new Error(`Attribute 'label' missing from payload`)
-  );
-});
-
-it('startInstancePubSub: should fail with empty event payload', () => {
-  const mocks = getMocks();
-  const sample = getSample();
-  const pubsubData = {};
-  mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString('base64');
-  sample.program.startInstancePubSub(
-    mocks.event,
-    mocks.context,
-    mocks.callback
-  );
-
-  assert.deepStrictEqual(
-    mocks.callback.firstCall.args[0],
-    new Error(`Attribute 'zone' missing from payload`)
-  );
+describe('functions_start_instance_pubsub', () => {
+  it('startInstancePubSub: should accept JSON-formatted event payload with label', async () => {
+    const mocks = getMocks();
+    const sample = getSample();
+    const pubsubData = {zone: 'test-zone', label: 'testkey=value'};
+    mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString(
+      'base64'
+    );
+    sample.program.startInstancePubSub(
+      mocks.event,
+      mocks.context,
+      mocks.callback
+    );
+
+    const data = await sample.mocks.requestPromise();
+    // The request was successfully sent.
+    assert.strictEqual(data, 'request sent');
+  });
+
+  it(`startInstancePubSub: should fail with missing 'zone' attribute`, () => {
+    const mocks = getMocks();
+    const sample = getSample();
+    const pubsubData = {label: 'testkey=value'};
+    mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString(
+      'base64'
+    );
+    sample.program.startInstancePubSub(
+      mocks.event,
+      mocks.context,
+      mocks.callback
+    );
+
+    assert.deepStrictEqual(
+      mocks.callback.firstCall.args[0],
+      new Error(`Attribute 'zone' missing from payload`)
+    );
+  });
+
+  it(`startInstancePubSub: should fail with missing 'label' attribute`, () => {
+    const mocks = getMocks();
+    const sample = getSample();
+    const pubsubData = {zone: 'test-zone'};
+    mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString(
+      'base64'
+    );
+    sample.program.startInstancePubSub(
+      mocks.event,
+      mocks.context,
+      mocks.callback
+    );
+
+    assert.deepStrictEqual(
+      mocks.callback.firstCall.args[0],
+      new Error(`Attribute 'label' missing from payload`)
+    );
+  });
+
+  it('startInstancePubSub: should fail with empty event payload', () => {
+    const mocks = getMocks();
+    const sample = getSample();
+    const pubsubData = {};
+    mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString(
+      'base64'
+    );
+    sample.program.startInstancePubSub(
+      mocks.event,
+      mocks.context,
+      mocks.callback
+    );
+
+    assert.deepStrictEqual(
+      mocks.callback.firstCall.args[0],
+      new Error(`Attribute 'zone' missing from payload`)
+    );
+  });
 });
 
 /** Tests for stopInstancePubSub */
-
-it('startInstancePubSub: should accept JSON-formatted event payload with label', async () => {
-  const mocks = getMocks();
-  const sample = getSample();
-  const pubsubData = {zone: 'test-zone', label: 'testkey=value'};
-  mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString('base64');
-  sample.program.stopInstancePubSub(mocks.event, mocks.context, mocks.callback);
-
-  const data = await sample.mocks.requestPromise();
-  // The request was successfully sent.
-  assert.strictEqual(data, 'request sent');
-});
-
-it(`stopInstancePubSub: should fail with missing 'zone' attribute`, () => {
-  const mocks = getMocks();
-  const sample = getSample();
-  const pubsubData = {label: 'testkey=value'};
-  mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString('base64');
-  sample.program.stopInstancePubSub(mocks.event, mocks.context, mocks.callback);
-
-  assert.deepStrictEqual(
-    mocks.callback.firstCall.args[0],
-    new Error(`Attribute 'zone' missing from payload`)
-  );
-});
-
-it(`stopInstancePubSub: should fail with missing 'label' attribute`, () => {
-  const mocks = getMocks();
-  const sample = getSample();
-  const pubsubData = {zone: 'test-zone'};
-  mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString('base64');
-  sample.program.stopInstancePubSub(mocks.event, mocks.context, mocks.callback);
-
-  assert.deepStrictEqual(
-    mocks.callback.firstCall.args[0],
-    new Error(`Attribute 'label' missing from payload`)
-  );
-});
-
-it('stopInstancePubSub: should fail with empty event payload', () => {
-  const mocks = getMocks();
-  const sample = getSample();
-  const pubsubData = {};
-  mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString('base64');
-  sample.program.stopInstancePubSub(mocks.event, mocks.context, mocks.callback);
-
-  assert.deepStrictEqual(
-    mocks.callback.firstCall.args[0],
-    new Error(`Attribute 'zone' missing from payload`)
-  );
+describe('functions_stop_instance_pubsub', () => {
+  it('stopInstancePubSub: should accept JSON-formatted event payload with label', async () => {
+    const mocks = getMocks();
+    const sample = getSample();
+    const pubsubData = {zone: 'test-zone', label: 'testkey=value'};
+    mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString(
+      'base64'
+    );
+    sample.program.stopInstancePubSub(
+      mocks.event,
+      mocks.context,
+      mocks.callback
+    );
+
+    const data = await sample.mocks.requestPromise();
+    // The request was successfully sent.
+    assert.strictEqual(data, 'request sent');
+  });
+
+  it(`stopInstancePubSub: should fail with missing 'zone' attribute`, () => {
+    const mocks = getMocks();
+    const sample = getSample();
+    const pubsubData = {label: 'testkey=value'};
+    mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString(
+      'base64'
+    );
+    sample.program.stopInstancePubSub(
+      mocks.event,
+      mocks.context,
+      mocks.callback
+    );
+
+    assert.deepStrictEqual(
+      mocks.callback.firstCall.args[0],
+      new Error(`Attribute 'zone' missing from payload`)
+    );
+  });
+
+  it(`stopInstancePubSub: should fail with missing 'label' attribute`, () => {
+    const mocks = getMocks();
+    const sample = getSample();
+    const pubsubData = {zone: 'test-zone'};
+    mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString(
+      'base64'
+    );
+    sample.program.stopInstancePubSub(
+      mocks.event,
+      mocks.context,
+      mocks.callback
+    );
+
+    assert.deepStrictEqual(
+      mocks.callback.firstCall.args[0],
+      new Error(`Attribute 'label' missing from payload`)
+    );
+  });
+
+  it('stopInstancePubSub: should fail with empty event payload', () => {
+    const mocks = getMocks();
+    const sample = getSample();
+    const pubsubData = {};
+    mocks.event.data = Buffer.from(JSON.stringify(pubsubData)).toString(
+      'base64'
+    );
+    sample.program.stopInstancePubSub(
+      mocks.event,
+      mocks.context,
+      mocks.callback
+    );
+
+    assert.deepStrictEqual(
+      mocks.callback.firstCall.args[0],
+      new Error(`Attribute 'zone' missing from payload`)
+    );
+  });
 });
diff --git a/functions/sendgrid/test/index.test.js b/functions/sendgrid/test/index.test.js
index b7dcf28eac..1664914389 100644
--- a/functions/sendgrid/test/index.test.js
+++ b/functions/sendgrid/test/index.test.js
@@ -149,187 +149,189 @@ const getMocks = () => {
 beforeEach(tools.stubConsole);
 afterEach(tools.restoreConsole);
 
-it('Send fails if not a POST request', async () => {
-  const error = new Error('Only POST requests are accepted');
-  error.code = 405;
-  const sample = getSample();
-  const mocks = getMocks();
-
-  try {
-    await sample.program.sendgridEmail(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
-
-it('Send fails without an API key', async () => {
-  const error = new Error(
-    'SendGrid API key not provided. Make sure you have a "sg_key" property in your request querystring'
-  );
-  error.code = 401;
-  const mocks = getMocks();
-
-  mocks.req.method = method;
-
-  try {
-    await getSample().program.sendgridEmail(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
-
-it('Send fails without a "to"', async () => {
-  const error = new Error(
-    'To email address not provided. Make sure you have a "to" property in your request'
-  );
-  error.code = 400;
-  const mocks = getMocks();
-
-  mocks.req.method = method;
-  mocks.req.query.sg_key = key;
-
-  try {
-    await getSample().program.sendgridEmail(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
+describe('functions_sendgrid_email functions_get_payload functions_sendgrid_get_client', () => {
+  it('Send fails if not a POST request', async () => {
+    const error = new Error('Only POST requests are accepted');
+    error.code = 405;
+    const sample = getSample();
+    const mocks = getMocks();
+
+    try {
+      await sample.program.sendgridEmail(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-it('Send fails without a "from"', async () => {
-  const error = new Error(
-    'From email address not provided. Make sure you have a "from" property in your request'
-  );
-  error.code = 400;
-  const mocks = getMocks();
+  it('Send fails without an API key', async () => {
+    const error = new Error(
+      'SendGrid API key not provided. Make sure you have a "sg_key" property in your request querystring'
+    );
+    error.code = 401;
+    const mocks = getMocks();
+
+    mocks.req.method = method;
+
+    try {
+      await getSample().program.sendgridEmail(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-  mocks.req.method = method;
-  mocks.req.query.sg_key = key;
-  mocks.req.body.to = to;
+  it('Send fails without a "to"', async () => {
+    const error = new Error(
+      'To email address not provided. Make sure you have a "to" property in your request'
+    );
+    error.code = 400;
+    const mocks = getMocks();
+
+    mocks.req.method = method;
+    mocks.req.query.sg_key = key;
+
+    try {
+      await getSample().program.sendgridEmail(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-  try {
-    await getSample().program.sendgridEmail(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
+  it('Send fails without a "from"', async () => {
+    const error = new Error(
+      'From email address not provided. Make sure you have a "from" property in your request'
+    );
+    error.code = 400;
+    const mocks = getMocks();
+
+    mocks.req.method = method;
+    mocks.req.query.sg_key = key;
+    mocks.req.body.to = to;
+
+    try {
+      await getSample().program.sendgridEmail(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-it('Send fails without a "subject"', async () => {
-  const error = new Error(
-    'Email subject line not provided. Make sure you have a "subject" property in your request'
-  );
-  error.code = 400;
-  const mocks = getMocks();
+  it('Send fails without a "subject"', async () => {
+    const error = new Error(
+      'Email subject line not provided. Make sure you have a "subject" property in your request'
+    );
+    error.code = 400;
+    const mocks = getMocks();
+
+    mocks.req.method = method;
+    mocks.req.query.sg_key = key;
+    mocks.req.body.to = to;
+    mocks.req.body.from = from;
+
+    try {
+      await getSample().program.sendgridEmail(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-  mocks.req.method = method;
-  mocks.req.query.sg_key = key;
-  mocks.req.body.to = to;
-  mocks.req.body.from = from;
+  it('Send fails without a "body"', async () => {
+    const error = new Error(
+      'Email content not provided. Make sure you have a "body" property in your request'
+    );
+    error.code = 400;
+    const mocks = getMocks();
+
+    mocks.req.method = method;
+    mocks.req.query.sg_key = key;
+    mocks.req.body.to = to;
+    mocks.req.body.from = from;
+    mocks.req.body.subject = subject;
+
+    try {
+      await getSample().program.sendgridEmail(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-  try {
-    await getSample().program.sendgridEmail(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
+  it('Handles response error', async () => {
+    const mocks = getMocks();
+    const sample = getSample();
+
+    mocks.req.method = method;
+    mocks.req.query.sg_key = key;
+    mocks.req.body.to = to;
+    mocks.req.body.from = from;
+    mocks.req.body.subject = subject;
+    mocks.req.body.body = body;
+    sample.mocks.client.API.returns(
+      Promise.resolve({
+        statusCode: 500,
+        body: 'error',
+      })
+    );
+
+    try {
+      await sample.program.sendgridEmail(mocks.req, mocks.res);
+    } catch (err) {
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [500]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args[0].message, 'error');
+    }
+  });
 
-it('Send fails without a "body"', async () => {
-  const error = new Error(
-    'Email content not provided. Make sure you have a "body" property in your request'
-  );
-  error.code = 400;
-  const mocks = getMocks();
+  it('Sends the email and successfully responds', async () => {
+    const mocks = getMocks();
 
-  mocks.req.method = method;
-  mocks.req.query.sg_key = key;
-  mocks.req.body.to = to;
-  mocks.req.body.from = from;
-  mocks.req.body.subject = subject;
+    mocks.req.method = method;
+    mocks.req.query.sg_key = key;
+    mocks.req.body.to = to;
+    mocks.req.body.from = from;
+    mocks.req.body.subject = subject;
+    mocks.req.body.body = body;
 
-  try {
     await getSample().program.sendgridEmail(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
-
-it('Handles response error', async () => {
-  const mocks = getMocks();
-  const sample = getSample();
-
-  mocks.req.method = method;
-  mocks.req.query.sg_key = key;
-  mocks.req.body.to = to;
-  mocks.req.body.from = from;
-  mocks.req.body.subject = subject;
-  mocks.req.body.body = body;
-  sample.mocks.client.API.returns(
-    Promise.resolve({
-      statusCode: 500,
-      body: 'error',
-    })
-  );
-
-  try {
-    await sample.program.sendgridEmail(mocks.req, mocks.res);
-  } catch (err) {
     assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [500]);
+    assert.deepStrictEqual(mocks.res.status.firstCall.args, [200]);
     assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args[0].message, 'error');
-  }
-});
-
-it('Sends the email and successfully responds', async () => {
-  const mocks = getMocks();
-
-  mocks.req.method = method;
-  mocks.req.query.sg_key = key;
-  mocks.req.body.to = to;
-  mocks.req.body.from = from;
-  mocks.req.body.subject = subject;
-  mocks.req.body.body = body;
-
-  await getSample().program.sendgridEmail(mocks.req, mocks.res);
-  assert.strictEqual(mocks.res.status.callCount, 1);
-  assert.deepStrictEqual(mocks.res.status.firstCall.args, [200]);
-  assert.strictEqual(mocks.res.send.callCount, 1);
-  assert.deepStrictEqual(mocks.res.send.firstCall.args, ['success']);
+    assert.deepStrictEqual(mocks.res.send.firstCall.args, ['success']);
+  });
 });
 
 it('Handles empty response body', async () => {
@@ -357,173 +359,181 @@ it('Handles empty response body', async () => {
   assert.deepStrictEqual(mocks.res.end.firstCall.args, []);
 });
 
-it('Send fails if not a POST request', async () => {
-  const error = new Error('Only POST requests are accepted');
-  error.code = 405;
-  const sample = getSample();
-  const mocks = getMocks();
-
-  try {
-    await sample.program.sendgridWebhook(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
+describe('functions_sendgrid_webhook functions_sendgrid_verify_webhook', () => {
+  it('Send fails if not a POST request', async () => {
+    const error = new Error('Only POST requests are accepted');
+    error.code = 405;
+    const sample = getSample();
+    const mocks = getMocks();
+
+    try {
+      await sample.program.sendgridWebhook(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-it('Throws if no basic auth', async () => {
-  const error = new Error('Invalid credentials');
-  error.code = 401;
-  const sample = getSample();
-  const mocks = getMocks();
+  it('Throws if no basic auth', async () => {
+    const error = new Error('Invalid credentials');
+    error.code = 401;
+    const sample = getSample();
+    const mocks = getMocks();
+
+    mocks.req.method = method;
+    mocks.req.headers.authorization = '';
+
+    try {
+      await sample.program.sendgridWebhook(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-  mocks.req.method = method;
-  mocks.req.headers.authorization = '';
+  it('Throws if invalid username', async () => {
+    const error = new Error('Invalid credentials');
+    error.code = 401;
+    const sample = getSample();
+    const mocks = getMocks();
+
+    mocks.req.method = method;
+    mocks.req.headers.authorization = 'Basic d3Jvbmc6YmFy';
+
+    try {
+      await sample.program.sendgridWebhook(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-  try {
-    await sample.program.sendgridWebhook(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
+  it('Throws if invalid password', async () => {
+    const error = new Error('Invalid credentials');
+    error.code = 401;
+    const sample = getSample();
+    const mocks = getMocks();
+
+    mocks.req.method = method;
+    mocks.req.headers.authorization = 'Basic Zm9vOndyb25n';
+
+    try {
+      await sample.program.sendgridWebhook(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 
-it('Throws if invalid username', async () => {
-  const error = new Error('Invalid credentials');
-  error.code = 401;
-  const sample = getSample();
-  const mocks = getMocks();
+  it('Calls "end" if no events', async () => {
+    const sample = getSample();
+    const mocks = getMocks();
 
-  mocks.req.method = method;
-  mocks.req.headers.authorization = 'Basic d3Jvbmc6YmFy';
+    mocks.req.method = method;
+    mocks.req.headers.authorization = auth;
+    mocks.req.body = undefined;
 
-  try {
     await sample.program.sendgridWebhook(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
-
-it('Throws if invalid password', async () => {
-  const error = new Error('Invalid credentials');
-  error.code = 401;
-  const sample = getSample();
-  const mocks = getMocks();
-
-  mocks.req.method = method;
-  mocks.req.headers.authorization = 'Basic Zm9vOndyb25n';
-
-  try {
-    await sample.program.sendgridWebhook(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
-});
-
-it('Calls "end" if no events', async () => {
-  const sample = getSample();
-  const mocks = getMocks();
-
-  mocks.req.method = method;
-  mocks.req.headers.authorization = auth;
-  mocks.req.body = undefined;
-
-  await sample.program.sendgridWebhook(mocks.req, mocks.res);
-  assert.strictEqual(mocks.res.end.callCount, 1);
-  assert.deepStrictEqual(mocks.res.end.firstCall.args, []);
-});
-
-it('Saves files', async () => {
-  const sample = getSample();
-  const mocks = getMocks();
-
-  mocks.req.method = 'POST';
-  mocks.req.headers.authorization = auth;
-  mocks.req.body = events;
-  sample.mocks.uuid.v4 = sinon.stub().returns('1357');
-
-  await sample.program.sendgridWebhook(mocks.req, mocks.res);
-  const [filename] = sample.mocks.bucket.file.firstCall.args;
-  assert.strictEqual(mocks.res.status.callCount, 1);
-  assert.deepStrictEqual(mocks.res.status.firstCall.args, [200]);
-  assert.strictEqual(mocks.res.end.callCount, 1);
-  assert.deepStrictEqual(console.log.getCall(0).args, [
-    `Saving events to ${filename} in bucket ${sample.mocks.config.EVENT_BUCKET}`,
-  ]);
-  assert.deepStrictEqual(console.log.getCall(1).args, [
-    `JSON written to ${filename}`,
-  ]);
-});
+    assert.strictEqual(mocks.res.end.callCount, 1);
+    assert.deepStrictEqual(mocks.res.end.firstCall.args, []);
+  });
 
-it('sendgridLoad does nothing on delete', () => {
-  return getSample().program.sendgridLoad({
-    data: {
-      resourceState: 'not_exists',
-    },
+  describe('functions_sendgrid_fix_names functions_sendgrid_verify_webhook functions_sendgrid_webhook', () => {
+    it('Saves files', async () => {
+      const sample = getSample();
+      const mocks = getMocks();
+
+      mocks.req.method = 'POST';
+      mocks.req.headers.authorization = auth;
+      mocks.req.body = events;
+      sample.mocks.uuid.v4 = sinon.stub().returns('1357');
+
+      await sample.program.sendgridWebhook(mocks.req, mocks.res);
+      const [filename] = sample.mocks.bucket.file.firstCall.args;
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [200]);
+      assert.strictEqual(mocks.res.end.callCount, 1);
+      assert.deepStrictEqual(console.log.getCall(0).args, [
+        `Saving events to ${filename} in bucket ${sample.mocks.config.EVENT_BUCKET}`,
+      ]);
+      assert.deepStrictEqual(console.log.getCall(1).args, [
+        `JSON written to ${filename}`,
+      ]);
+    });
   });
 });
 
-it('sendgridLoad fails without a bucket', async () => {
-  const error = new Error(
-    'Bucket not provided. Make sure you have a "bucket" property in your request'
-  );
-  const event = {
-    data: {},
-  };
-
-  try {
-    await getSample().program.sendgridLoad(event);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-  }
-});
+describe('functions_sendgrid_load', () => {
+  it('sendgridLoad does nothing on delete', () => {
+    return getSample().program.sendgridLoad({
+      data: {
+        resourceState: 'not_exists',
+      },
+    });
+  });
 
-it('sendgridLoad fails without a name', async () => {
-  const error = new Error(
-    'Filename not provided. Make sure you have a "name" property in your request'
-  );
-  const event = {
-    data: {
-      bucket: 'event-bucket',
-    },
-  };
+  it('sendgridLoad fails without a bucket', async () => {
+    const error = new Error(
+      'Bucket not provided. Make sure you have a "bucket" property in your request'
+    );
+    const event = {
+      data: {},
+    };
+
+    try {
+      await getSample().program.sendgridLoad(event);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+    }
+  });
 
-  try {
-    await getSample().program.sendgridLoad(event);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-  }
+  it('sendgridLoad fails without a name', async () => {
+    const error = new Error(
+      'Filename not provided. Make sure you have a "name" property in your request'
+    );
+    const event = {
+      data: {
+        bucket: 'event-bucket',
+      },
+    };
+
+    try {
+      await getSample().program.sendgridLoad(event);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+    }
+  });
 });
 
-it('starts a load job', async () => {
-  const sample = getSample();
-  const name = '1234.json';
-  const event = {
-    data: {
-      bucket: 'event-bucket',
-      name: name,
-    },
-  };
-
-  await sample.program.sendgridLoad(event);
-  assert.deepStrictEqual(console.log.getCall(0).args, [
-    `Starting job for ${name}`,
-  ]);
-  assert.deepStrictEqual(console.log.getCall(1).args, [
-    `Job complete for ${name}`,
-  ]);
+describe('functions_sendgrid_get_table functions_sendgrid_load', () => {
+  it('starts a load job', async () => {
+    const sample = getSample();
+    const name = '1234.json';
+    const event = {
+      data: {
+        bucket: 'event-bucket',
+        name: name,
+      },
+    };
+
+    await sample.program.sendgridLoad(event);
+    assert.deepStrictEqual(console.log.getCall(0).args, [
+      `Starting job for ${name}`,
+    ]);
+    assert.deepStrictEqual(console.log.getCall(1).args, [
+      `Job complete for ${name}`,
+    ]);
+  });
 });
diff --git a/functions/slack/test/index.test.js b/functions/slack/test/index.test.js
index 0ba657902d..b33a334b9e 100644
--- a/functions/slack/test/index.test.js
+++ b/functions/slack/test/index.test.js
@@ -87,175 +87,183 @@ const getMocks = () => {
 beforeEach(tools.stubConsole);
 afterEach(tools.restoreConsole);
 
-it('Send fails if not a POST request', async () => {
-  const error = new Error('Only POST requests are accepted');
-  error.code = 405;
-  const mocks = getMocks();
-  const sample = getSample();
+describe('functions_slack_search', () => {
+  it('Send fails if not a POST request', async () => {
+    const error = new Error('Only POST requests are accepted');
+    error.code = 405;
+    const mocks = getMocks();
+    const sample = getSample();
 
-  try {
-    await sample.program.kgSearch(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
+    try {
+      await sample.program.kgSearch(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 });
 
-it('Throws if invalid slack token', async () => {
-  const error = new Error('Invalid credentials');
-  error.code = 401;
-  const mocks = getMocks();
-  const sample = getSample();
+describe('functions_slack_search functions_verify_webhook', () => {
+  it('Throws if invalid slack token', async () => {
+    const error = new Error('Invalid credentials');
+    error.code = 401;
+    const mocks = getMocks();
+    const sample = getSample();
 
-  mocks.req.method = method;
-  mocks.req.body.token = 'wrong';
+    mocks.req.method = method;
+    mocks.req.body.token = 'wrong';
 
-  try {
-    await sample.program.kgSearch(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
+    try {
+      await sample.program.kgSearch(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [error.code]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 });
 
-it('Handles search error', async () => {
-  const error = new Error('error');
-  const mocks = getMocks();
-  const sample = getSample();
+describe('functions_slack_request functions_slack_search functions_verify_webhook', () => {
+  it('Handles search error', async () => {
+    const error = new Error('error');
+    const mocks = getMocks();
+    const sample = getSample();
 
-  mocks.req.method = method;
-  mocks.req.body.token = SLACK_TOKEN;
-  mocks.req.body.text = query;
-  sample.mocks.kgsearch.entities.search.yields(error);
+    mocks.req.method = method;
+    mocks.req.body.token = SLACK_TOKEN;
+    mocks.req.body.text = query;
+    sample.mocks.kgsearch.entities.search.yields(error);
 
-  try {
-    await sample.program.kgSearch(mocks.req, mocks.res);
-  } catch (err) {
-    assert.deepStrictEqual(err, error);
-    assert.strictEqual(mocks.res.status.callCount, 1);
-    assert.deepStrictEqual(mocks.res.status.firstCall.args, [500]);
-    assert.strictEqual(mocks.res.send.callCount, 1);
-    assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
-    assert.strictEqual(console.error.callCount, 1);
-    assert.deepStrictEqual(console.error.firstCall.args, [error]);
-  }
+    try {
+      await sample.program.kgSearch(mocks.req, mocks.res);
+    } catch (err) {
+      assert.deepStrictEqual(err, error);
+      assert.strictEqual(mocks.res.status.callCount, 1);
+      assert.deepStrictEqual(mocks.res.status.firstCall.args, [500]);
+      assert.strictEqual(mocks.res.send.callCount, 1);
+      assert.deepStrictEqual(mocks.res.send.firstCall.args, [error]);
+      assert.strictEqual(console.error.callCount, 1);
+      assert.deepStrictEqual(console.error.firstCall.args, [error]);
+    }
+  });
 });
 
-it('Makes search request, receives empty results', async () => {
-  const mocks = getMocks();
-  const sample = getSample();
+describe('functions_slack_format functions_slack_request functions_slack_search functions_verify_webhook', () => {
+  it('Makes search request, receives empty results', async () => {
+    const mocks = getMocks();
+    const sample = getSample();
 
-  mocks.req.method = method;
-  mocks.req.body.token = SLACK_TOKEN;
-  mocks.req.body.text = query;
-  sample.mocks.kgsearch.entities.search.yields(null, {
-    data: {itemListElement: []},
-  });
+    mocks.req.method = method;
+    mocks.req.body.token = SLACK_TOKEN;
+    mocks.req.body.text = query;
+    sample.mocks.kgsearch.entities.search.yields(null, {
+      data: {itemListElement: []},
+    });
 
-  await sample.program.kgSearch(mocks.req, mocks.res);
-  assert.strictEqual(mocks.res.json.callCount, 1);
-  assert.deepStrictEqual(mocks.res.json.firstCall.args, [
-    {
-      text: `Query: ${query}`,
-      response_type: 'in_channel',
-      attachments: [
-        {
-          text: 'No results match your query...',
-        },
-      ],
-    },
-  ]);
-});
+    await sample.program.kgSearch(mocks.req, mocks.res);
+    assert.strictEqual(mocks.res.json.callCount, 1);
+    assert.deepStrictEqual(mocks.res.json.firstCall.args, [
+      {
+        text: `Query: ${query}`,
+        response_type: 'in_channel',
+        attachments: [
+          {
+            text: 'No results match your query...',
+          },
+        ],
+      },
+    ]);
+  });
 
-it('Makes search request, receives non-empty results', async () => {
-  const mocks = getMocks();
-  const sample = getSample();
+  it('Makes search request, receives non-empty results', async () => {
+    const mocks = getMocks();
+    const sample = getSample();
 
-  mocks.req.method = method;
-  mocks.req.body.token = SLACK_TOKEN;
-  mocks.req.body.text = query;
-  sample.mocks.kgsearch.entities.search.yields(null, {
-    data: {
-      itemListElement: [
-        {
-          result: {
-            name: 'Giraffe',
-            description: 'Animal',
-            detailedDescription: {
-              url: 'http://domain.com/giraffe',
-              articleBody: 'giraffe is a tall animal',
-            },
-            image: {
-              contentUrl: 'http://domain.com/image.jpg',
+    mocks.req.method = method;
+    mocks.req.body.token = SLACK_TOKEN;
+    mocks.req.body.text = query;
+    sample.mocks.kgsearch.entities.search.yields(null, {
+      data: {
+        itemListElement: [
+          {
+            result: {
+              name: 'Giraffe',
+              description: 'Animal',
+              detailedDescription: {
+                url: 'http://domain.com/giraffe',
+                articleBody: 'giraffe is a tall animal',
+              },
+              image: {
+                contentUrl: 'http://domain.com/image.jpg',
+              },
             },
           },
-        },
-      ],
-    },
+        ],
+      },
+    });
+
+    await sample.program.kgSearch(mocks.req, mocks.res);
+    assert.strictEqual(mocks.res.json.callCount, 1);
+    assert.deepStrictEqual(mocks.res.json.firstCall.args, [
+      {
+        text: `Query: ${query}`,
+        response_type: 'in_channel',
+        attachments: [
+          {
+            color: '#3367d6',
+            title: 'Giraffe: Animal',
+            title_link: 'http://domain.com/giraffe',
+            text: 'giraffe is a tall animal',
+            image_url: 'http://domain.com/image.jpg',
+          },
+        ],
+      },
+    ]);
   });
 
-  await sample.program.kgSearch(mocks.req, mocks.res);
-  assert.strictEqual(mocks.res.json.callCount, 1);
-  assert.deepStrictEqual(mocks.res.json.firstCall.args, [
-    {
-      text: `Query: ${query}`,
-      response_type: 'in_channel',
-      attachments: [
-        {
-          color: '#3367d6',
-          title: 'Giraffe: Animal',
-          title_link: 'http://domain.com/giraffe',
-          text: 'giraffe is a tall animal',
-          image_url: 'http://domain.com/image.jpg',
-        },
-      ],
-    },
-  ]);
-});
+  it('Makes search request, receives non-empty results but partial data', async () => {
+    const mocks = getMocks();
+    const sample = getSample();
 
-it('Makes search request, receives non-empty results but partial data', async () => {
-  const mocks = getMocks();
-  const sample = getSample();
+    mocks.req.method = method;
+    mocks.req.body.token = SLACK_TOKEN;
+    mocks.req.body.text = query;
+    sample.mocks.kgsearch.entities.search.yields(null, {
+      data: {
+        itemListElement: [
+          {
+            result: {
+              name: 'Giraffe',
+              detailedDescription: {},
+              image: {},
+            },
+          },
+        ],
+      },
+    });
 
-  mocks.req.method = method;
-  mocks.req.body.token = SLACK_TOKEN;
-  mocks.req.body.text = query;
-  sample.mocks.kgsearch.entities.search.yields(null, {
-    data: {
-      itemListElement: [
-        {
-          result: {
-            name: 'Giraffe',
-            detailedDescription: {},
-            image: {},
+    await sample.program.kgSearch(mocks.req, mocks.res);
+    assert.strictEqual(mocks.res.json.callCount, 1);
+    assert.deepStrictEqual(mocks.res.json.firstCall.args, [
+      {
+        text: `Query: ${query}`,
+        response_type: 'in_channel',
+        attachments: [
+          {
+            color: '#3367d6',
+            title: 'Giraffe',
           },
-        },
-      ],
-    },
+        ],
+      },
+    ]);
   });
-
-  await sample.program.kgSearch(mocks.req, mocks.res);
-  assert.strictEqual(mocks.res.json.callCount, 1);
-  assert.deepStrictEqual(mocks.res.json.firstCall.args, [
-    {
-      text: `Query: ${query}`,
-      response_type: 'in_channel',
-      attachments: [
-        {
-          color: '#3367d6',
-          title: 'Giraffe',
-        },
-      ],
-    },
-  ]);
 });
diff --git a/functions/spanner/test/index.test.js b/functions/spanner/test/index.test.js
index b8ea5df4ec..592be499df 100644
--- a/functions/spanner/test/index.test.js
+++ b/functions/spanner/test/index.test.js
@@ -71,20 +71,22 @@ const getSample = () => {
   };
 };
 
-it('get: Gets albums', async () => {
-  const sample = getSample();
-  const {mocks} = sample;
+describe('spanner_functions_quickstart', () => {
+  it('get: Gets albums', async () => {
+    const sample = getSample();
+    const {mocks} = sample;
 
-  await sample.program.get(mocks.req, mocks.res);
-  assert.strictEqual(mocks.spanner.instance.called, true);
-  assert.strictEqual(mocks.instance.database.called, true);
-  assert.strictEqual(mocks.database.run.calledWith(query), true);
-  assert.strictEqual(mocks.results[0].toJSON.called, true);
-  assert.strictEqual(
-    mocks.res.write.calledWith(
-      'SingerId: 1, AlbumId: 2, AlbumTitle: Total Junk\n'
-    ),
-    true
-  );
-  assert.strictEqual(mocks.res.end.called, true);
+    await sample.program.get(mocks.req, mocks.res);
+    assert.strictEqual(mocks.spanner.instance.called, true);
+    assert.strictEqual(mocks.instance.database.called, true);
+    assert.strictEqual(mocks.database.run.calledWith(query), true);
+    assert.strictEqual(mocks.results[0].toJSON.called, true);
+    assert.strictEqual(
+      mocks.res.write.calledWith(
+        'SingerId: 1, AlbumId: 2, AlbumTitle: Total Junk\n'
+      ),
+      true
+    );
+    assert.strictEqual(mocks.res.end.called, true);
+  });
 });
diff --git a/functions/speech-to-speech/functions/test/index.test.js b/functions/speech-to-speech/functions/test/index.test.js
index 15a4b8577d..47e7f1f70d 100644
--- a/functions/speech-to-speech/functions/test/index.test.js
+++ b/functions/speech-to-speech/functions/test/index.test.js
@@ -59,153 +59,162 @@ describe('speechTranslate tests', () => {
     }
   });
 
-  describe('Validate encoding field', () => {
-    it('should fail if encoding field is missing.', async () => {
-      const response = await requestRetry({
-        body: {
-          // encoding: 'LINEAR16',
-          sampleRateHertz: 16000,
-          languageCode: 'en',
-          audioContent: 'base64-audio-content',
-        },
+  describe('validate_request', () => {
+    describe('Validate encoding field', () => {
+      it('should fail if encoding field is missing.', async () => {
+        const response = await requestRetry({
+          body: {
+            // encoding: 'LINEAR16',
+            sampleRateHertz: 16000,
+            languageCode: 'en',
+            audioContent: 'base64-audio-content',
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Invalid encoding.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Invalid encoding.');
-    });
-    it('should fail if encoding field is empty.', async () => {
-      const response = await requestRetry({
-        body: {
-          encoding: '',
-          sampleRateHertz: 16000,
-          languageCode: 'en',
-          audioContent: 'base64-audio-content',
-        },
+
+      it('should fail if encoding field is empty.', async () => {
+        const response = await requestRetry({
+          body: {
+            encoding: '',
+            sampleRateHertz: 16000,
+            languageCode: 'en',
+            audioContent: 'base64-audio-content',
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Invalid encoding.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Invalid encoding.');
     });
-  });
 
-  describe('Validate sampleRateHertz field', () => {
-    it('should fail if sampleRateHertz field is missing.', async () => {
-      const response = await requestRetry({
-        body: {
-          encoding: 'LINEAR16',
-          // sampleRateHertz: 16000,
-          languageCode: 'en',
-          audioContent: 'base64-audio-content',
-        },
+    describe('Validate sampleRateHertz field', () => {
+      it('should fail if sampleRateHertz field is missing.', async () => {
+        const response = await requestRetry({
+          body: {
+            encoding: 'LINEAR16',
+            // sampleRateHertz: 16000,
+            languageCode: 'en',
+            audioContent: 'base64-audio-content',
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Sample rate hertz must be numeric.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Sample rate hertz must be numeric.');
-    });
-    it('should fail if sampleRateHertz field is empty.', async () => {
-      const response = await requestRetry({
-        body: {
-          encoding: 'LINEAR16',
-          sampleRateHertz: '',
-          languageCode: 'en',
-          audioContent: 'base64-audio-content',
-        },
+
+      it('should fail if sampleRateHertz field is empty.', async () => {
+        const response = await requestRetry({
+          body: {
+            encoding: 'LINEAR16',
+            sampleRateHertz: '',
+            languageCode: 'en',
+            audioContent: 'base64-audio-content',
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Sample rate hertz must be numeric.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Sample rate hertz must be numeric.');
-    });
-    it('should fail if sampleRateHertz field is not numeric.', async () => {
-      const response = await requestRetry({
-        body: {
-          encoding: 'LINEAR16',
-          sampleRateHertz: 'NaN',
-          languageCode: 'en',
-          audioContent: 'base64-audio-content',
-        },
+
+      it('should fail if sampleRateHertz field is not numeric.', async () => {
+        const response = await requestRetry({
+          body: {
+            encoding: 'LINEAR16',
+            sampleRateHertz: 'NaN',
+            languageCode: 'en',
+            audioContent: 'base64-audio-content',
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Sample rate hertz must be numeric.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Sample rate hertz must be numeric.');
     });
-  });
 
-  describe('Validate languageCode field', () => {
-    it('should fail if languageCode field is missing.', async () => {
-      const response = await requestRetry({
-        body: {
-          encoding: 'LINEAR16',
-          sampleRateHertz: 16000,
-          // languageCode: 'en',
-          audioContent: 'base64-audio-content',
-        },
+    describe('Validate languageCode field', () => {
+      it('should fail if languageCode field is missing.', async () => {
+        const response = await requestRetry({
+          body: {
+            encoding: 'LINEAR16',
+            sampleRateHertz: 16000,
+            // languageCode: 'en',
+            audioContent: 'base64-audio-content',
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Invalid language code.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Invalid language code.');
-    });
-    it('should fail if languageCode field is empty.', async () => {
-      const response = await requestRetry({
-        body: {
-          encoding: 'LINEAR16',
-          sampleRateHertz: 16000,
-          languageCode: '',
-          audioContent: 'base64-audio-content',
-        },
+
+      it('should fail if languageCode field is empty.', async () => {
+        const response = await requestRetry({
+          body: {
+            encoding: 'LINEAR16',
+            sampleRateHertz: 16000,
+            languageCode: '',
+            audioContent: 'base64-audio-content',
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Invalid language code.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Invalid language code.');
     });
-  });
 
-  describe('Validate audioContent field', () => {
-    it('should fail if audioContent field is missing.', async () => {
-      const response = await requestRetry({
-        body: {
-          encoding: 'LINEAR16',
-          sampleRateHertz: 16000,
-          languageCode: 'en',
-          // audioContent: 'base64-audio-content'
-        },
+    describe('Validate audioContent field', () => {
+      it('should fail if audioContent field is missing.', async () => {
+        const response = await requestRetry({
+          body: {
+            encoding: 'LINEAR16',
+            sampleRateHertz: 16000,
+            languageCode: 'en',
+            // audioContent: 'base64-audio-content'
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Invalid audio content.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Invalid audio content.');
-    });
-    it('should fail if audioContent field is empty.', async () => {
-      const response = await requestRetry({
-        body: {
-          encoding: 'LINEAR16',
-          sampleRateHertz: 16000,
-          languageCode: 'en',
-          audioContent: '',
-        },
+
+      it('should fail if audioContent field is empty.', async () => {
+        const response = await requestRetry({
+          body: {
+            encoding: 'LINEAR16',
+            sampleRateHertz: 16000,
+            languageCode: 'en',
+            audioContent: '',
+          },
+        });
+        assert.strictEqual(response.statusCode, 400);
+        assert.strictEqual(response.body, 'Invalid audio content.');
       });
-      assert.strictEqual(response.statusCode, 400);
-      assert.strictEqual(response.body, 'Invalid audio content.');
     });
   });
 
   describe('GCS bucket tests', () => {
     const gcsFilename = `speech-to-speech-${uuid.v4()}`;
 
-    it('should transcribe speech, translate it, and synthesize it in another language', async () => {
-      const response = await requestRetry({
-        body: {
-          filename: gcsFilename,
-          encoding: 'LINEAR16',
-          sampleRateHertz: 24000,
-          languageCode: 'en',
-          audioContent: fs.readFileSync('test/speech-recording.b64', 'utf8'),
-        },
+    describe('call_speech_to_text call_text_to_speech call_text_translation chain_cloud_calls upload_to_cloud_storage validate_request', () => {
+      it('should transcribe speech, translate it, and synthesize it in another language', async () => {
+        const response = await requestRetry({
+          body: {
+            filename: gcsFilename,
+            encoding: 'LINEAR16',
+            sampleRateHertz: 24000,
+            languageCode: 'en',
+            audioContent: fs.readFileSync('test/speech-recording.b64', 'utf8'),
+          },
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+
+        // Test transcription
+        response.body.translations.forEach(translation => {
+          assert.ifError(translation.error);
+        });
+        assert.strictEqual(
+          response.body['transcription'],
+          'this is a test please translate this message'
+        );
+
+        // Test speech synthesis + result uploading
+        assert.ok(outputBucket.file(gcsFilename).exists());
       });
-
-      assert.strictEqual(response.statusCode, 200);
-
-      // Test transcription
-      response.body.translations.forEach(translation => {
-        assert.ifError(translation.error);
-      });
-      assert.strictEqual(
-        response.body['transcription'],
-        'this is a test please translate this message'
-      );
-
-      // Test speech synthesis + result uploading
-      assert.ok(outputBucket.file(gcsFilename).exists());
     });
 
     after(async () => {
diff --git a/functions/sql/test/index.test.js b/functions/sql/test/index.test.js
index 7b9d54e136..2f474b95d5 100644
--- a/functions/sql/test/index.test.js
+++ b/functions/sql/test/index.test.js
@@ -29,56 +29,60 @@ const getProgram = env => {
   });
 };
 
-it('should query MySQL', async () => {
-  const program = getProgram({
-    INSTANCE_CONNECTION_NAME: `${INSTANCE_PREFIX}-mysql`,
-    SQL_USER: process.env.MYSQL_USER,
-    SQL_PASSWORD: process.env.MYSQL_PASSWORD,
-    SQL_NAME: process.env.MYSQL_DATABASE,
+describe('functions_sql_mysql', () => {
+  it('should query MySQL', async () => {
+    const program = getProgram({
+      INSTANCE_CONNECTION_NAME: `${INSTANCE_PREFIX}-mysql`,
+      SQL_USER: process.env.MYSQL_USER,
+      SQL_PASSWORD: process.env.MYSQL_PASSWORD,
+      SQL_NAME: process.env.MYSQL_DATABASE,
+    });
+
+    const resMock = {
+      status: sinon.stub().returnsThis(),
+      send: sinon.stub(),
+    };
+
+    program.mysqlDemo(null, resMock);
+
+    // Give the query time to complete
+    await new Promise(resolve => {
+      setTimeout(resolve, 1500);
+    });
+
+    assert.strictEqual(resMock.status.called, false);
+    assert.ok(resMock.send.calledOnce);
+
+    const [response] = resMock.send.firstCall.args;
+    assert.ok(new RegExp(/\d{4}-\d{1,2}-\d{1,2}/).test(response.message));
   });
-
-  const resMock = {
-    status: sinon.stub().returnsThis(),
-    send: sinon.stub(),
-  };
-
-  program.mysqlDemo(null, resMock);
-
-  // Give the query time to complete
-  await new Promise(resolve => {
-    setTimeout(resolve, 1500);
-  });
-
-  assert.strictEqual(resMock.status.called, false);
-  assert.ok(resMock.send.calledOnce);
-
-  const [response] = resMock.send.firstCall.args;
-  assert.ok(new RegExp(/\d{4}-\d{1,2}-\d{1,2}/).test(response.message));
 });
 
-it('should query Postgres', async () => {
-  const program = getProgram({
-    INSTANCE_CONNECTION_NAME: `${INSTANCE_PREFIX}-pg`,
-    SQL_USER: process.env.POSTGRES_USER,
-    SQL_PASSWORD: process.env.POSTGRES_PASSWORD,
-    SQL_NAME: process.env.POSTGRES_DATABASE,
-  });
+describe('functions_sql_postgres', () => {
+  it('should query Postgres', async () => {
+    const program = getProgram({
+      INSTANCE_CONNECTION_NAME: `${INSTANCE_PREFIX}-pg`,
+      SQL_USER: process.env.POSTGRES_USER,
+      SQL_PASSWORD: process.env.POSTGRES_PASSWORD,
+      SQL_NAME: process.env.POSTGRES_DATABASE,
+    });
 
-  const resMock = {
-    status: sinon.stub().returnsThis(),
-    send: sinon.stub(),
-  };
+    const resMock = {
+      status: sinon.stub().returnsThis(),
+      send: sinon.stub(),
+    };
 
-  program.postgresDemo(null, resMock);
+    program.postgresDemo(null, resMock);
 
-  // Give the query time to complete
-  await new Promise(resolve => {
-    setTimeout(resolve, 1500);
-  });
+    // Give the query time to complete
+    await new Promise(resolve => {
+      setTimeout(resolve, 1500);
+    });
 
-  assert.strictEqual(resMock.status.called, false);
-  assert.ok(resMock.send.calledOnce);
+    assert.strictEqual(resMock.status.called, false);
+    assert.ok(resMock.send.calledOnce);
 
-  const [response] = resMock.send.firstCall.args;
-  assert.ok(new RegExp(/\d{4}-\d{1,2}-\d{1,2}/).test(response.message));
+    const [response] = resMock.send.firstCall.args;
+    assert.ok(new RegExp(/\d{4}-\d{1,2}-\d{1,2}/).test(response.message));
+  });
 });
diff --git a/functions/tips/test/index.test.js b/functions/tips/test/index.test.js
index 26ecc6e3f8..d12fd7e55d 100644
--- a/functions/tips/test/index.test.js
+++ b/functions/tips/test/index.test.js
@@ -23,64 +23,68 @@ const sample = require(`../`);
 beforeEach(tools.stubConsole);
 afterEach(tools.restoreConsole);
 
-it('should demonstrate retry behavior for a promise', async () => {
-  // Retry by throwing an error
-  assert.throws(() => {
-    sample.retryPromise({
-      data: {
-        retry: true,
-      },
-    });
-  }, 'Retrying...');
+describe('functions_tips_retry', () => {
+  it('should demonstrate retry behavior for a promise', async () => {
+    // Retry by throwing an error
+    assert.throws(() => {
+      sample.retryPromise({
+        data: {
+          retry: true,
+        },
+      });
+    }, 'Retrying...');
 
-  // Terminate by returning a rejected promise
-  try {
-    await sample.retryPromise({data: {}});
-  } catch (err) {
-    assert.strictEqual(err.message, 'Not retrying...');
-    return Promise.resolve();
-  }
-});
+    // Terminate by returning a rejected promise
+    try {
+      await sample.retryPromise({data: {}});
+    } catch (err) {
+      assert.strictEqual(err.message, 'Not retrying...');
+      return Promise.resolve();
+    }
+  });
 
-it('should demonstrate retry behavior for a callback', done => {
-  const cb = sinon.stub();
-  const err = new Error('Error!');
+  it('should demonstrate retry behavior for a callback', done => {
+    const cb = sinon.stub();
+    const err = new Error('Error!');
 
-  // Retry by passing an error to the callback
-  sample.retryCallback(
-    {
-      data: {
-        retry: true,
+    // Retry by passing an error to the callback
+    sample.retryCallback(
+      {
+        data: {
+          retry: true,
+        },
       },
-    },
-    cb
-  );
-  assert.deepStrictEqual(cb.firstCall.args, [err]);
+      cb
+    );
+    assert.deepStrictEqual(cb.firstCall.args, [err]);
 
-  // Terminate by passing nothing to the callback
-  sample.retryCallback({data: {}}, cb);
-  assert.deepStrictEqual(cb.secondCall.args, []);
-  done();
+    // Terminate by passing nothing to the callback
+    sample.retryCallback({data: {}}, cb);
+    assert.deepStrictEqual(cb.secondCall.args, []);
+    done();
+  });
 });
 
-it('should call a GCP API', async () => {
-  const reqMock = {
-    body: {
-      topic: process.env.FUNCTIONS_TOPIC,
-    },
-  };
+describe('functions_tips_gcp_apis', () => {
+  it('should call a GCP API', async () => {
+    const reqMock = {
+      body: {
+        topic: process.env.FUNCTIONS_TOPIC,
+      },
+    };
 
-  const resMock = {
-    send: sinon.stub().returnsThis(),
-    status: sinon.stub().returnsThis(),
-  };
+    const resMock = {
+      send: sinon.stub().returnsThis(),
+      status: sinon.stub().returnsThis(),
+    };
 
-  sample.gcpApiCall(reqMock, resMock);
+    sample.gcpApiCall(reqMock, resMock);
 
-  // Instead of modifying the sample to return a promise,
-  // use a delay here and keep the sample idiomatic
-  await new Promise(resolve => setTimeout(resolve, 1000));
+    // Instead of modifying the sample to return a promise,
+    // use a delay here and keep the sample idiomatic
+    await new Promise(resolve => setTimeout(resolve, 1000));
 
-  assert.ok(resMock.status.calledOnce);
-  assert.ok(resMock.status.calledWith(200));
+    assert.ok(resMock.status.calledOnce);
+    assert.ok(resMock.status.calledWith(200));
+  });
 });
diff --git a/functions/tokenservice/functions/test/index.test.js b/functions/tokenservice/functions/test/index.test.js
index 1bd2adf90b..24da30cba7 100644
--- a/functions/tokenservice/functions/test/index.test.js
+++ b/functions/tokenservice/functions/test/index.test.js
@@ -68,7 +68,7 @@ describe('getOAuthToken tests', () => {
     await handleLinuxFailures(ffProc);
   });
 
-  describe('Firebase OAuth Token', () => {
+  describe('function_get_token Firebase OAuth Token', () => {
     // no argument 400 error
     it('should give 400 if no Context is provided', async () => {
       const response = await requestRetry({