feat: add gapic getAppProfilesStream method (#771)

Author: AVaksman

src/index.ts

@@ -750,7 +750,10 @@ export class Bigtable {
       });
     };
 
-    const gapicStreamingMethods = {listTablesStream: true};
+    const gapicStreamingMethods = {
+      listTablesStream: true,
+      listAppProfilesStream: true,
+    };
 
     if (isStreamMode) {
       stream = streamEvents(new PassThrough({objectMode: true}));

src/instance.ts

@@ -686,6 +686,65 @@ Please use the format 'my-instance' or '${bigtable.projectName}/instances/my-ins
     );
   }
 
+  /**
+   * Get {@link AppProfile} objects for all the App Profiles in your
+   * Cloud Bigtable instance as a readable object stream.
+   *
+   * @param {object} [gaxOptions] Request configuration options, outlined here:
+   *     https://googleapis.github.io/gax-nodejs/CallSettings.html.
+   *     {@link Instance#getAppProfiles} for a complete list of options.
+   * @returns {stream}
+   *
+   * @example
+   * const {Bigtable} = require('@google-cloud/bigtable');
+   * const bigtable = new Bigtable();
+   * const instance = bigtable.instance('my-instance');
+   *
+   * instance.getAppProfilesStream()
+   *   .on('error', console.error)
+   *   .on('data', function(appProfile) {
+   *     // appProfile is a AppProfile object.
+   *   })
+   *   .on('end', () => {
+   *     // All appProfiles retrieved.
+   *   });
+   *
+   * //-
+   * // If you anticipate many results, you can end a stream early to prevent
+   * // unnecessary processing and API requests.
+   * //-
+   * instance.getAppProfilesStream()
+   *   .on('data', function(appProfile) {
+   *     this.end();
+   *   });
+   */
+  getAppProfilesStream(gaxOptions?: CallOptions): NodeJS.ReadableStream {
+    const reqOpts = {
+      parent: this.name,
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    const transformToAppProfile = (
+      chunk: google.bigtable.admin.v2.IAppProfile,
+      enc: string,
+      callback: Function
+    ) => {
+      const appProfile = self.appProfile(chunk.name!.split('/').pop()!);
+      appProfile.metadata = chunk;
+      callback(null, appProfile);
+    };
+    return pumpify.obj([
+      this.bigtable.request({
+        client: 'BigtableInstanceAdminClient',
+        method: 'listAppProfilesStream',
+        reqOpts,
+        gaxOpts: gaxOptions,
+      }),
+      new Transform({objectMode: true, transform: transformToAppProfile}),
+    ]);
+  }
+
   getClusters(options?: CallOptions): Promise<GetClustersResponse>;
   getClusters(options: CallOptions, callback: GetClustersCallback): void;
   getClusters(callback: GetClustersCallback): void;

system-test/bigtable.ts

@@ -163,6 +163,20 @@ describe('Bigtable', () => {
       assert(appProfiles.length > 0);
     });
 
+    it('should retrieve a list of app profiles in stream mode', done => {
+      const appProfiles: AppProfile[] = [];
+      INSTANCE.getAppProfilesStream()
+        .on('error', done)
+        .on('data', appProfile => {
+          assert(appProfile instanceof AppProfile);
+          appProfiles.push(appProfile);
+        })
+        .on('end', () => {
+          assert(appProfiles.length > 0);
+          done();
+        });
+    });
+
     it('should check if an app profile exists', async () => {
       const [exists] = await APP_PROFILE.exists();
       assert.strictEqual(exists, true);

test/index.ts

@@ -635,6 +635,13 @@ describe('Bigtable', () => {
       gaxOpts: {},
     };
 
+    const gapicStreamingMethods = [
+      'listTablesStream',
+      'listInstancesStream',
+      'listAppProfilesStream',
+      'listClustersStream',
+    ];
+
     beforeEach(() => {
       bigtable.getProjectId_ = (callback: Function) => {
         callback(null, PROJECT_ID);
@@ -874,76 +881,80 @@ describe('Bigtable', () => {
       });
     });
 
-    describe('makeGapicStreamRequest', () => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      let GAX_STREAM: any;
-      const config = {
-        client: 'client',
-        method: 'listTablesStream',
-        reqOpts: {
-          a: 'b',
-          c: 'd',
-        },
-        gaxOpts: {},
-      };
-
-      beforeEach(() => {
-        GAX_STREAM = new PassThrough();
-        bigtable.api[config.client][config.method] = {
-          bind() {
-            return () => {
-              return GAX_STREAM;
+    gapicStreamingMethods.forEach(method => {
+      describe('makeGapicStreamRequest', () => {
+        describe(method, () => {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          let GAX_STREAM: any;
+          const config = {
+            client: 'client',
+            method: method,
+            reqOpts: {
+              a: 'b',
+              c: 'd',
+            },
+            gaxOpts: {},
+          };
+
+          beforeEach(() => {
+            GAX_STREAM = new PassThrough();
+            bigtable.api[config.client][config.method] = {
+              bind() {
+                return () => {
+                  return GAX_STREAM;
+                };
+              },
             };
-          },
-        };
-      });
+          });
 
-      it('should expose an abort function', done => {
-        GAX_STREAM.cancel = done;
+          it('should expose an abort function', done => {
+            GAX_STREAM.cancel = done;
 
-        const requestStream = bigtable.request(config);
-        requestStream.emit('reading');
-        requestStream.abort();
-      });
+            const requestStream = bigtable.request(config);
+            requestStream.emit('reading');
+            requestStream.abort();
+          });
 
-      it('should prepare the request once reading', done => {
-        bigtable.api[config.client][config.method] = {
-          bind(gaxClient: {}, reqOpts: {}, gaxOpts: {}) {
-            assert.strictEqual(gaxClient, bigtable.api[config.client]);
-            assert.deepStrictEqual(reqOpts, config.reqOpts);
-            assert.strictEqual(gaxOpts, config.gaxOpts);
-            setImmediate(done);
-            return () => {
-              return GAX_STREAM;
+          it('should prepare the request once reading', done => {
+            bigtable.api[config.client][config.method] = {
+              bind(gaxClient: {}, reqOpts: {}, gaxOpts: {}) {
+                assert.strictEqual(gaxClient, bigtable.api[config.client]);
+                assert.deepStrictEqual(reqOpts, config.reqOpts);
+                assert.strictEqual(gaxOpts, config.gaxOpts);
+                setImmediate(done);
+                return () => {
+                  return GAX_STREAM;
+                };
+              },
             };
-          },
-        };
 
-        const requestStream = bigtable.request(config);
-        requestStream.emit('reading');
-      });
+            const requestStream = bigtable.request(config);
+            requestStream.emit('reading');
+          });
 
-      it('should destroy the stream with prepare error', done => {
-        const error = new Error('Error.');
-        bigtable.getProjectId_ = (callback: Function) => {
-          callback(error);
-        };
-        const requestStream = bigtable.request(config);
-        requestStream.emit('reading');
-        requestStream.on('error', (err: Error) => {
-          assert.strictEqual(err, error);
-          done();
-        });
-      });
+          it('should destroy the stream with prepare error', done => {
+            const error = new Error('Error.');
+            bigtable.getProjectId_ = (callback: Function) => {
+              callback(error);
+            };
+            const requestStream = bigtable.request(config);
+            requestStream.emit('reading');
+            requestStream.on('error', (err: Error) => {
+              assert.strictEqual(err, error);
+              done();
+            });
+          });
 
-      it('should destroy the stream with GAX error', done => {
-        const error = new Error('Error.');
-        const requestStream = bigtable.request(config);
-        requestStream.emit('reading');
-        GAX_STREAM.emit('error', error);
-        requestStream.on('error', (err: Error) => {
-          assert.strictEqual(err, error);
-          done();
+          it('should destroy the stream with GAX error', done => {
+            const error = new Error('Error.');
+            const requestStream = bigtable.request(config);
+            requestStream.emit('reading');
+            GAX_STREAM.emit('error', error);
+            requestStream.on('error', (err: Error) => {
+              assert.strictEqual(err, error);
+              done();
+            });
+          });
         });
       });
     });

test/instance.ts

@@ -724,6 +724,104 @@ describe('Bigtable/Instance', () => {
     });
   });
 
+  describe('getApprofilesStream', () => {
+    let returnStream: PassThrough;
+    beforeEach(() => {
+      returnStream = new PassThrough({
+        objectMode: true,
+      });
+    });
+
+    it('should provide the proper request options', done => {
+      const stub = sandbox.stub(pumpify, 'obj');
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (instance.bigtable.request as Function) = (config: any) => {
+        assert.strictEqual(config.client, 'BigtableInstanceAdminClient');
+        assert.strictEqual(config.method, 'listAppProfilesStream');
+        assert.deepStrictEqual(config.reqOpts, {
+          parent: INSTANCE_NAME,
+        });
+        assert.deepStrictEqual(config.gaxOpts, undefined);
+        setImmediate(done);
+        return returnStream;
+      };
+      instance.getAppProfilesStream();
+      assert.strictEqual(stub.getCall(0).args[0][0], returnStream);
+    });
+
+    it('should accept gaxOptions', done => {
+      const gaxOptions = {timeout: 1000};
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (instance.bigtable.request as Function) = (config: any) => {
+        assert.strictEqual(config.gaxOpts, gaxOptions);
+        setImmediate(done);
+        return returnStream;
+      };
+      instance.getAppProfilesStream(gaxOptions);
+    });
+
+    it('should return error from gapic', done => {
+      const error = new Error('Error.');
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (instance.bigtable.request as Function) = () => {
+        return returnStream;
+      };
+      setImmediate(() => {
+        returnStream.destroy(error);
+      });
+
+      instance.getAppProfilesStream().on('error', err => {
+        assert.strictEqual(err, error);
+        done();
+      });
+    });
+
+    it('should return an array of AppProfile objects', done => {
+      const response = [
+        {
+          name:
+            '/projects/my-project/instances/my-instance/appProfiles/my-appProfile-a',
+        },
+        {
+          name:
+            '/projects/my-project/instances/my-instance/appProfiles/my-appProfile-a',
+        },
+      ];
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (instance.bigtable.request as Function) = () => {
+        return returnStream;
+      };
+      setImmediate(() => {
+        response.forEach(r => {
+          returnStream.push(r);
+        });
+        returnStream.push(null);
+      });
+
+      const appProfiles: AppProfile[] = [];
+      instance
+        .getAppProfilesStream()
+        .on('error', assert.ifError)
+        .on('data', appProfile => {
+          assert(appProfile instanceof FakeAppProfile);
+          appProfiles.push(appProfile);
+        })
+        .on('end', () => {
+          assert.strictEqual(
+            appProfiles[0].id,
+            response[0].name.split('/').pop()
+          );
+          assert.deepStrictEqual(appProfiles[0].metadata, response[0]);
+          assert.strictEqual(
+            appProfiles[1].id,
+            response[1].name.split('/').pop()
+          );
+          assert.deepStrictEqual(appProfiles[1].metadata, response[1]);
+          done();
+        });
+    });
+  });
+
   describe('getClusters', () => {
     it('should provide the proper request options', done => {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any