gapic_bigtable_v2.ts

// Copyright 2023 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ** This file is automatically generated by gapic-generator-typescript. **
// ** https://github.com/googleapis/gapic-generator-typescript **
// ** All changes to this file may be overwritten. **

import * as protos from '../protos/protos';
import * as assert from 'assert';
import * as sinon from 'sinon';
import {SinonStub} from 'sinon';
import {describe, it} from 'mocha';
import * as bigtableModule from '../src';

import {PassThrough} from 'stream';

import {protobuf} from 'google-gax';

// Dynamically loaded proto JSON is needed to get the type information
// to fill in default values for request objects
const root = protobuf.Root.fromJSON(
  require('../protos/protos.json')
).resolveAll();

// eslint-disable-next-line @typescript-eslint/no-unused-vars
function getTypeDefaultValue(typeName: string, fields: string[]) {
  let type = root.lookupType(typeName) as protobuf.Type;
  for (const field of fields.slice(0, -1)) {
    type = type.fields[field]?.resolvedType as protobuf.Type;
  }
  return type.fields[fields[fields.length - 1]]?.defaultValue;
}

function generateSampleMessage<T extends object>(instance: T) {
  const filledObject = (
    instance.constructor as typeof protobuf.Message
  ).toObject(instance as protobuf.Message<T>, {defaults: true});
  return (instance.constructor as typeof protobuf.Message).fromObject(
    filledObject
  ) as T;
}

function stubSimpleCall<ResponseType>(response?: ResponseType, error?: Error) {
  return error
    ? sinon.stub().rejects(error)
    : sinon.stub().resolves([response]);
}

function stubSimpleCallWithCallback<ResponseType>(
  response?: ResponseType,
  error?: Error
) {
  return error
    ? sinon.stub().callsArgWith(2, error)
    : sinon.stub().callsArgWith(2, null, response);
}

function stubServerStreamingCall<ResponseType>(
  response?: ResponseType,
  error?: Error
) {
  const transformStub = error
    ? sinon.stub().callsArgWith(2, error)
    : sinon.stub().callsArgWith(2, null, response);
  const mockStream = new PassThrough({
    objectMode: true,
    transform: transformStub,
  });
  // write something to the stream to trigger transformStub and send the response back to the client
  setImmediate(() => {
    mockStream.write({});
  });
  setImmediate(() => {
    mockStream.end();
  });
  return sinon.stub().returns(mockStream);
}

describe('v2.BigtableClient', () => {
  describe('Common methods', () => {
    it('has servicePath', () => {
      const servicePath = bigtableModule.v2.BigtableClient.servicePath;
      assert(servicePath);
    });

    it('has apiEndpoint', () => {
      const apiEndpoint = bigtableModule.v2.BigtableClient.apiEndpoint;
      assert(apiEndpoint);
    });

    it('has port', () => {
      const port = bigtableModule.v2.BigtableClient.port;
      assert(port);
      assert(typeof port === 'number');
    });

    it('should create a client with no option', () => {
      const client = new bigtableModule.v2.BigtableClient();
      assert(client);
    });

    it('should create a client with gRPC fallback', () => {
      const client = new bigtableModule.v2.BigtableClient({
        fallback: true,
      });
      assert(client);
    });

    it('has initialize method and supports deferred initialization', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      assert.strictEqual(client.bigtableStub, undefined);
      await client.initialize();
      assert(client.bigtableStub);
    });

    it('has close method for the initialized client', done => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      assert(client.bigtableStub);
      client.close().then(() => {
        done();
      });
    });

    it('has close method for the non-initialized client', done => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      assert.strictEqual(client.bigtableStub, undefined);
      client.close().then(() => {
        done();
      });
    });

    it('has getProjectId method', async () => {
      const fakeProjectId = 'fake-project-id';
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.auth.getProjectId = sinon.stub().resolves(fakeProjectId);
      const result = await client.getProjectId();
      assert.strictEqual(result, fakeProjectId);
      assert((client.auth.getProjectId as SinonStub).calledWithExactly());
    });

    it('has getProjectId method with callback', async () => {
      const fakeProjectId = 'fake-project-id';
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.auth.getProjectId = sinon
        .stub()
        .callsArgWith(0, null, fakeProjectId);
      const promise = new Promise((resolve, reject) => {
        client.getProjectId((err?: Error | null, projectId?: string | null) => {
          if (err) {
            reject(err);
          } else {
            resolve(projectId);
          }
        });
      });
      const result = await promise;
      assert.strictEqual(result, fakeProjectId);
    });
  });

  describe('mutateRow', () => {
    it('invokes mutateRow without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowResponse()
      );
      client.innerApiCalls.mutateRow = stubSimpleCall(expectedResponse);
      const [response] = await client.mutateRow(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.mutateRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.mutateRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes mutateRow without error using callback', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowResponse()
      );
      client.innerApiCalls.mutateRow =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.mutateRow(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.v2.IMutateRowResponse | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.mutateRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.mutateRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes mutateRow with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedError = new Error('expected');
      client.innerApiCalls.mutateRow = stubSimpleCall(undefined, expectedError);
      await assert.rejects(client.mutateRow(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.mutateRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.mutateRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes mutateRow with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.mutateRow(request), expectedError);
    });
  });

  describe('checkAndMutateRow', () => {
    it('invokes checkAndMutateRow without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.CheckAndMutateRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.CheckAndMutateRowResponse()
      );
      client.innerApiCalls.checkAndMutateRow = stubSimpleCall(expectedResponse);
      const [response] = await client.checkAndMutateRow(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.checkAndMutateRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.checkAndMutateRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkAndMutateRow without error using callback', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.CheckAndMutateRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.CheckAndMutateRowResponse()
      );
      client.innerApiCalls.checkAndMutateRow =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.checkAndMutateRow(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.v2.ICheckAndMutateRowResponse | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.checkAndMutateRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.checkAndMutateRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkAndMutateRow with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.CheckAndMutateRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedError = new Error('expected');
      client.innerApiCalls.checkAndMutateRow = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.checkAndMutateRow(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.checkAndMutateRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.checkAndMutateRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkAndMutateRow with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.CheckAndMutateRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.checkAndMutateRow(request), expectedError);
    });
  });

  describe('pingAndWarm', () => {
    it('invokes pingAndWarm without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.PingAndWarmRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.PingAndWarmResponse()
      );
      client.innerApiCalls.pingAndWarm = stubSimpleCall(expectedResponse);
      const [response] = await client.pingAndWarm(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.pingAndWarm as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.pingAndWarm as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes pingAndWarm without error using callback', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.PingAndWarmRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.PingAndWarmResponse()
      );
      client.innerApiCalls.pingAndWarm =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.pingAndWarm(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.v2.IPingAndWarmResponse | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.pingAndWarm as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.pingAndWarm as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes pingAndWarm with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.PingAndWarmRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedError = new Error('expected');
      client.innerApiCalls.pingAndWarm = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.pingAndWarm(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.pingAndWarm as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.pingAndWarm as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes pingAndWarm with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.PingAndWarmRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.pingAndWarm(request), expectedError);
    });
  });

  describe('readModifyWriteRow', () => {
    it('invokes readModifyWriteRow without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadModifyWriteRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.ReadModifyWriteRowResponse()
      );
      client.innerApiCalls.readModifyWriteRow =
        stubSimpleCall(expectedResponse);
      const [response] = await client.readModifyWriteRow(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.readModifyWriteRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.readModifyWriteRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes readModifyWriteRow without error using callback', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadModifyWriteRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.ReadModifyWriteRowResponse()
      );
      client.innerApiCalls.readModifyWriteRow =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.readModifyWriteRow(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.v2.IReadModifyWriteRowResponse | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.readModifyWriteRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.readModifyWriteRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes readModifyWriteRow with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadModifyWriteRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedError = new Error('expected');
      client.innerApiCalls.readModifyWriteRow = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.readModifyWriteRow(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.readModifyWriteRow as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.readModifyWriteRow as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes readModifyWriteRow with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadModifyWriteRowRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.readModifyWriteRow(request), expectedError);
    });
  });

  describe('readRows', () => {
    it('invokes readRows without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadRowsRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.ReadRowsResponse()
      );
      client.innerApiCalls.readRows = stubServerStreamingCall(expectedResponse);
      const stream = client.readRows(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.ReadRowsResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.readRows as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.readRows as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes readRows with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadRowsRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedError = new Error('expected');
      client.innerApiCalls.readRows = stubServerStreamingCall(
        undefined,
        expectedError
      );
      const stream = client.readRows(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.ReadRowsResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      const actualRequest = (
        client.innerApiCalls.readRows as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.readRows as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes readRows with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadRowsRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedError = new Error('The client has already been closed.');
      client.close();
      const stream = client.readRows(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.ReadRowsResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
    });
  });

  describe('sampleRowKeys', () => {
    it('invokes sampleRowKeys without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.SampleRowKeysRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.SampleRowKeysResponse()
      );
      client.innerApiCalls.sampleRowKeys =
        stubServerStreamingCall(expectedResponse);
      const stream = client.sampleRowKeys(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.SampleRowKeysResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.sampleRowKeys as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.sampleRowKeys as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes sampleRowKeys with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.SampleRowKeysRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedError = new Error('expected');
      client.innerApiCalls.sampleRowKeys = stubServerStreamingCall(
        undefined,
        expectedError
      );
      const stream = client.sampleRowKeys(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.SampleRowKeysResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      const actualRequest = (
        client.innerApiCalls.sampleRowKeys as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.sampleRowKeys as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes sampleRowKeys with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.SampleRowKeysRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedError = new Error('The client has already been closed.');
      client.close();
      const stream = client.sampleRowKeys(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.SampleRowKeysResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
    });
  });

  describe('mutateRows', () => {
    it('invokes mutateRows without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowsRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowsResponse()
      );
      client.innerApiCalls.mutateRows =
        stubServerStreamingCall(expectedResponse);
      const stream = client.mutateRows(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.MutateRowsResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.mutateRows as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.mutateRows as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes mutateRows with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowsRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedHeaderRequestParams = 'app_profile_id=value';
      const expectedError = new Error('expected');
      client.innerApiCalls.mutateRows = stubServerStreamingCall(
        undefined,
        expectedError
      );
      const stream = client.mutateRows(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.MutateRowsResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      const actualRequest = (
        client.innerApiCalls.mutateRows as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.mutateRows as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes mutateRows with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.MutateRowsRequest()
      );
      // path template is empty
      request.appProfileId = 'value';
      const expectedError = new Error('The client has already been closed.');
      client.close();
      const stream = client.mutateRows(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.MutateRowsResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
    });
  });

  describe('generateInitialChangeStreamPartitions', () => {
    it('invokes generateInitialChangeStreamPartitions without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.GenerateInitialChangeStreamPartitionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.v2.GenerateInitialChangeStreamPartitionsRequest',
        ['tableName']
      );
      request.tableName = defaultValue1;
      const expectedHeaderRequestParams = `table_name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.GenerateInitialChangeStreamPartitionsResponse()
      );
      client.innerApiCalls.generateInitialChangeStreamPartitions =
        stubServerStreamingCall(expectedResponse);
      const stream = client.generateInitialChangeStreamPartitions(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (
            response: protos.google.bigtable.v2.GenerateInitialChangeStreamPartitionsResponse
          ) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.generateInitialChangeStreamPartitions as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.generateInitialChangeStreamPartitions as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes generateInitialChangeStreamPartitions with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.GenerateInitialChangeStreamPartitionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.v2.GenerateInitialChangeStreamPartitionsRequest',
        ['tableName']
      );
      request.tableName = defaultValue1;
      const expectedHeaderRequestParams = `table_name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.generateInitialChangeStreamPartitions =
        stubServerStreamingCall(undefined, expectedError);
      const stream = client.generateInitialChangeStreamPartitions(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (
            response: protos.google.bigtable.v2.GenerateInitialChangeStreamPartitionsResponse
          ) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      const actualRequest = (
        client.innerApiCalls.generateInitialChangeStreamPartitions as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.generateInitialChangeStreamPartitions as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes generateInitialChangeStreamPartitions with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.GenerateInitialChangeStreamPartitionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.v2.GenerateInitialChangeStreamPartitionsRequest',
        ['tableName']
      );
      request.tableName = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      const stream = client.generateInitialChangeStreamPartitions(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (
            response: protos.google.bigtable.v2.GenerateInitialChangeStreamPartitionsResponse
          ) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
    });
  });

  describe('readChangeStream', () => {
    it('invokes readChangeStream without error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadChangeStreamRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.v2.ReadChangeStreamRequest',
        ['tableName']
      );
      request.tableName = defaultValue1;
      const expectedHeaderRequestParams = `table_name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.v2.ReadChangeStreamResponse()
      );
      client.innerApiCalls.readChangeStream =
        stubServerStreamingCall(expectedResponse);
      const stream = client.readChangeStream(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.ReadChangeStreamResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.readChangeStream as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.readChangeStream as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes readChangeStream with error', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadChangeStreamRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.v2.ReadChangeStreamRequest',
        ['tableName']
      );
      request.tableName = defaultValue1;
      const expectedHeaderRequestParams = `table_name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.readChangeStream = stubServerStreamingCall(
        undefined,
        expectedError
      );
      const stream = client.readChangeStream(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.ReadChangeStreamResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      const actualRequest = (
        client.innerApiCalls.readChangeStream as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.readChangeStream as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes readChangeStream with closed client', async () => {
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.v2.ReadChangeStreamRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.v2.ReadChangeStreamRequest',
        ['tableName']
      );
      request.tableName = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      const stream = client.readChangeStream(request);
      const promise = new Promise((resolve, reject) => {
        stream.on(
          'data',
          (response: protos.google.bigtable.v2.ReadChangeStreamResponse) => {
            resolve(response);
          }
        );
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
    });
  });

  describe('Path templates', () => {
    describe('instance', () => {
      const fakePath = '/rendered/path/instance';
      const expectedParameters = {
        project: 'projectValue',
        instance: 'instanceValue',
      };
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      client.pathTemplates.instancePathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.instancePathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

      it('instancePath', () => {
        const result = client.instancePath('projectValue', 'instanceValue');
        assert.strictEqual(result, fakePath);
        assert(
          (client.pathTemplates.instancePathTemplate.render as SinonStub)
            .getCall(-1)
            .calledWith(expectedParameters)
        );
      });

      it('matchProjectFromInstanceName', () => {
        const result = client.matchProjectFromInstanceName(fakePath);
        assert.strictEqual(result, 'projectValue');
        assert(
          (client.pathTemplates.instancePathTemplate.match as SinonStub)
            .getCall(-1)
            .calledWith(fakePath)
        );
      });

      it('matchInstanceFromInstanceName', () => {
        const result = client.matchInstanceFromInstanceName(fakePath);
        assert.strictEqual(result, 'instanceValue');
        assert(
          (client.pathTemplates.instancePathTemplate.match as SinonStub)
            .getCall(-1)
            .calledWith(fakePath)
        );
      });
    });

    describe('table', () => {
      const fakePath = '/rendered/path/table';
      const expectedParameters = {
        project: 'projectValue',
        instance: 'instanceValue',
        table: 'tableValue',
      };
      const client = new bigtableModule.v2.BigtableClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      client.pathTemplates.tablePathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.tablePathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

      it('tablePath', () => {
        const result = client.tablePath(
          'projectValue',
          'instanceValue',
          'tableValue'
        );
        assert.strictEqual(result, fakePath);
        assert(
          (client.pathTemplates.tablePathTemplate.render as SinonStub)
            .getCall(-1)
            .calledWith(expectedParameters)
        );
      });

      it('matchProjectFromTableName', () => {
        const result = client.matchProjectFromTableName(fakePath);
        assert.strictEqual(result, 'projectValue');
        assert(
          (client.pathTemplates.tablePathTemplate.match as SinonStub)
            .getCall(-1)
            .calledWith(fakePath)
        );
      });

      it('matchInstanceFromTableName', () => {
        const result = client.matchInstanceFromTableName(fakePath);
        assert.strictEqual(result, 'instanceValue');
        assert(
          (client.pathTemplates.tablePathTemplate.match as SinonStub)
            .getCall(-1)
            .calledWith(fakePath)
        );
      });

      it('matchTableFromTableName', () => {
        const result = client.matchTableFromTableName(fakePath);
        assert.strictEqual(result, 'tableValue');
        assert(
          (client.pathTemplates.tablePathTemplate.match as SinonStub)
            .getCall(-1)
            .calledWith(fakePath)
        );
      });
    });
  });
});