feat: Add Storage#getServiceAccount(). (#331)

Author: stephenplusplus

handwritten/storage/src/index.js

@@ -442,6 +442,82 @@ class Storage extends common.Service {
       }
     );
   }
+
+  /**
+   * @typedef {array} GetServiceAccountResponse
+   * @property {object} 0 The service account resource.
+   * @property {object} 1 The full
+   * [API response](https://cloud.google.com/storage/docs/json_api/v1/projects/serviceAccount#resource).
+   */
+  /**
+   * @callback GetServiceAccountCallback
+   * @param {?Error} err Request error, if any.
+   * @param {object} serviceAccount The serviceAccount resource.
+   * @param {string} serviceAccount.emailAddress The service account email
+   *     address.
+   * @param {object} apiResponse The full
+   * [API response](https://cloud.google.com/storage/docs/json_api/v1/projects/serviceAccount#resource).
+   */
+  /**
+   * Get the email address of this project's Google Cloud Storage service
+   * account.
+   *
+   * @see [Projects.serviceAccount: get API Documentation]{@link https://cloud.google.com/storage/docs/json_api/v1/projects/serviceAccount/get}
+   * @see [Projects.serviceAccount Resource]{@link https://cloud.google.com/storage/docs/json_api/v1/projects/serviceAccount#resource}
+   *
+   * @param {object} [options] Configuration object.
+   * @param {string} [options.userProject] User project to be billed for this
+   *     request.
+   * @param {GetServiceAccountCallback} [callback] Callback function.
+   * @returns {Promise<GetServiceAccountResponse>}
+   *
+   * @example
+   * const storage = require('@google-cloud/storage')();
+   *
+   * storage.getServiceAccount(function(err, serviceAccount, apiResponse) {
+   *   if (!err) {
+   *     const serviceAccountEmail = serviceAccount.emailAddress;
+   *   }
+   * });
+   *
+   * //-
+   * // If the callback is omitted, we'll return a Promise.
+   * //-
+   * storage.getServiceAccount().then(function(data) {
+   *   const serviceAccountEmail = data[0].emailAddress;
+   *   const apiResponse = data[1];
+   * });
+   */
+  getServiceAccount(options, callback) {
+    if (!callback) {
+      callback = options;
+      options = {};
+    }
+
+    this.request(
+      {
+        uri: `/projects/${this.projectId}/serviceAccount`,
+        qs: options,
+      },
+      (err, resp) => {
+        if (err) {
+          callback(err, null, resp);
+          return;
+        }
+
+        const camelCaseResponse = {};
+
+        for (let prop in resp) {
+          let camelCaseProp = prop.replace(/_(\w)/g, (_, match) =>
+            match.toUpperCase()
+          );
+          camelCaseResponse[camelCaseProp] = resp[prop];
+        }
+
+        callback(null, camelCaseResponse, resp);
+      }
+    );
+  }
 }
 
 // Allow creating a `Storage` instance without using the `new` keyword. (#173)

handwritten/storage/system-test/storage.js

@@ -1846,22 +1846,16 @@ describe('storage', function() {
                 return;
               }
 
-              storage.request(
-                {
-                  uri:
-                    'https://www.googleapis.com/storage/v1/projects/{{projectId}}/serviceAccount',
-                },
-                function(err, resp) {
-                  if (err) {
-                    next(err);
-                    return;
-                  }
+              storage.getServiceAccount(function(err, serviceAccount) {
+                if (err) {
+                  next(err);
+                  return;
+                }
 
-                  SERVICE_ACCOUNT_EMAIL = resp.email_address;
+                SERVICE_ACCOUNT_EMAIL = serviceAccount.emailAddress;
 
-                  next();
-                }
-              );
+                next();
+              });
             },
 
             function grantPermissionToServiceAccount(next) {

handwritten/storage/test/index.js

@@ -434,4 +434,86 @@ describe('Storage', function() {
       });
     });
   });
+
+  describe('getServiceAccount', function() {
+    it('should make the correct request', function(done) {
+      storage.request = function(reqOpts) {
+        assert.strictEqual(
+          reqOpts.uri,
+          `/projects/${storage.projectId}/serviceAccount`
+        );
+        assert.deepStrictEqual(reqOpts.qs, {});
+        done();
+      };
+
+      storage.getServiceAccount(assert.ifError);
+    });
+
+    it('should allow user options', function(done) {
+      const options = {};
+
+      storage.request = function(reqOpts) {
+        assert.strictEqual(reqOpts.qs, options);
+        done();
+      };
+
+      storage.getServiceAccount(options, assert.ifError);
+    });
+
+    describe('error', function() {
+      const ERROR = new Error('Error.');
+      const API_RESPONSE = {};
+
+      beforeEach(function() {
+        storage.request = function(reqOpts, callback) {
+          callback(ERROR, API_RESPONSE);
+        };
+      });
+
+      it('should return the error and apiResponse', function(done) {
+        storage.getServiceAccount(function(err, serviceAccount, apiResponse) {
+          assert.strictEqual(err, ERROR);
+          assert.strictEqual(serviceAccount, null);
+          assert.strictEqual(apiResponse, API_RESPONSE);
+          done();
+        });
+      });
+    });
+
+    describe('success', function() {
+      const API_RESPONSE = {};
+
+      beforeEach(function() {
+        storage.request = function(reqOpts, callback) {
+          callback(null, API_RESPONSE);
+        };
+      });
+
+      it('should convert snake_case response to camelCase', function(done) {
+        const apiResponse = {
+          snake_case: true,
+        };
+
+        storage.request = function(reqOpts, callback) {
+          callback(null, apiResponse);
+        };
+
+        storage.getServiceAccount(function(err, serviceAccount) {
+          assert.ifError(err);
+          assert.strictEqual(serviceAccount.snakeCase, apiResponse.snake_case);
+          assert.strictEqual(serviceAccount.snake_case, undefined);
+          done();
+        });
+      });
+
+      it('should return the serviceAccount and apiResponse', function(done) {
+        storage.getServiceAccount(function(err, serviceAccount, apiResponse) {
+          assert.ifError(err);
+          assert.deepStrictEqual(serviceAccount, {});
+          assert.strictEqual(apiResponse, API_RESPONSE);
+          done();
+        });
+      });
+    });
+  });
 });