gapic_bigtable_instance_admin_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 bigtableinstanceadminModule from '../src';

import {PassThrough} from 'stream';

import {protobuf, LROperation, operationsProtos} 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 stubLongRunningCall<ResponseType>(
  response?: ResponseType,
  callError?: Error,
  lroError?: Error
) {
  const innerStub = lroError
    ? sinon.stub().rejects(lroError)
    : sinon.stub().resolves([response]);
  const mockOperation = {
    promise: innerStub,
  };
  return callError
    ? sinon.stub().rejects(callError)
    : sinon.stub().resolves([mockOperation]);
}

function stubLongRunningCallWithCallback<ResponseType>(
  response?: ResponseType,
  callError?: Error,
  lroError?: Error
) {
  const innerStub = lroError
    ? sinon.stub().rejects(lroError)
    : sinon.stub().resolves([response]);
  const mockOperation = {
    promise: innerStub,
  };
  return callError
    ? sinon.stub().callsArgWith(2, callError)
    : sinon.stub().callsArgWith(2, null, mockOperation);
}

function stubPageStreamingCall<ResponseType>(
  responses?: ResponseType[],
  error?: Error
) {
  const pagingStub = sinon.stub();
  if (responses) {
    for (let i = 0; i < responses.length; ++i) {
      pagingStub.onCall(i).callsArgWith(2, null, responses[i]);
    }
  }
  const transformStub = error
    ? sinon.stub().callsArgWith(2, error)
    : pagingStub;
  const mockStream = new PassThrough({
    objectMode: true,
    transform: transformStub,
  });
  // trigger as many responses as needed
  if (responses) {
    for (let i = 0; i < responses.length; ++i) {
      setImmediate(() => {
        mockStream.write({});
      });
    }
    setImmediate(() => {
      mockStream.end();
    });
  } else {
    setImmediate(() => {
      mockStream.write({});
    });
    setImmediate(() => {
      mockStream.end();
    });
  }
  return sinon.stub().returns(mockStream);
}

function stubAsyncIterationCall<ResponseType>(
  responses?: ResponseType[],
  error?: Error
) {
  let counter = 0;
  const asyncIterable = {
    [Symbol.asyncIterator]() {
      return {
        async next() {
          if (error) {
            return Promise.reject(error);
          }
          if (counter >= responses!.length) {
            return Promise.resolve({done: true, value: undefined});
          }
          return Promise.resolve({done: false, value: responses![counter++]});
        },
      };
    },
  };
  return sinon.stub().returns(asyncIterable);
}

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

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

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

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

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

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

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

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

    it('has getProjectId method', async () => {
      const fakeProjectId = 'fake-project-id';
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          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 bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          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('getInstance', () => {
    it('invokes getInstance without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetInstanceRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Instance()
      );
      client.innerApiCalls.getInstance = stubSimpleCall(expectedResponse);
      const [response] = await client.getInstance(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.getInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getInstance without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetInstanceRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Instance()
      );
      client.innerApiCalls.getInstance =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.getInstance(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.IInstance | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.getInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getInstance with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetInstanceRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.getInstance = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.getInstance(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.getInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getInstance with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetInstanceRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.getInstance(request), expectedError);
    });
  });

  describe('listInstances', () => {
    it('invokes listInstances without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListInstancesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListInstancesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListInstancesResponse()
      );
      client.innerApiCalls.listInstances = stubSimpleCall(expectedResponse);
      const [response] = await client.listInstances(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.listInstances as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listInstances as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listInstances without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListInstancesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListInstancesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListInstancesResponse()
      );
      client.innerApiCalls.listInstances =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.listInstances(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.IListInstancesResponse | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.listInstances as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listInstances as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listInstances with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListInstancesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListInstancesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.listInstances = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.listInstances(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.listInstances as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listInstances as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listInstances with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListInstancesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListInstancesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.listInstances(request), expectedError);
    });
  });

  describe('updateInstance', () => {
    it('invokes updateInstance without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Instance()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.Instance',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Instance()
      );
      client.innerApiCalls.updateInstance = stubSimpleCall(expectedResponse);
      const [response] = await client.updateInstance(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.updateInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateInstance without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Instance()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.Instance',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Instance()
      );
      client.innerApiCalls.updateInstance =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.updateInstance(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.IInstance | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.updateInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateInstance with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Instance()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.Instance',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.updateInstance = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.updateInstance(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.updateInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateInstance with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Instance()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.Instance',
        ['name']
      );
      request.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.updateInstance(request), expectedError);
    });
  });

  describe('deleteInstance', () => {
    it('invokes deleteInstance without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteInstanceRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.protobuf.Empty()
      );
      client.innerApiCalls.deleteInstance = stubSimpleCall(expectedResponse);
      const [response] = await client.deleteInstance(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.deleteInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteInstance without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteInstanceRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.protobuf.Empty()
      );
      client.innerApiCalls.deleteInstance =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.deleteInstance(
          request,
          (
            err?: Error | null,
            result?: protos.google.protobuf.IEmpty | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.deleteInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteInstance with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteInstanceRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.deleteInstance = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.deleteInstance(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.deleteInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteInstance with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteInstanceRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.deleteInstance(request), expectedError);
    });
  });

  describe('getCluster', () => {
    it('invokes getCluster without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetClusterRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Cluster()
      );
      client.innerApiCalls.getCluster = stubSimpleCall(expectedResponse);
      const [response] = await client.getCluster(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.getCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getCluster without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetClusterRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Cluster()
      );
      client.innerApiCalls.getCluster =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.getCluster(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.ICluster | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.getCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getCluster with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetClusterRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.getCluster = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.getCluster(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.getCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getCluster with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetClusterRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.getCluster(request), expectedError);
    });
  });

  describe('listClusters', () => {
    it('invokes listClusters without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListClustersRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListClustersRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListClustersResponse()
      );
      client.innerApiCalls.listClusters = stubSimpleCall(expectedResponse);
      const [response] = await client.listClusters(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.listClusters as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listClusters as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listClusters without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListClustersRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListClustersRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListClustersResponse()
      );
      client.innerApiCalls.listClusters =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.listClusters(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.IListClustersResponse | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.listClusters as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listClusters as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listClusters with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListClustersRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListClustersRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.listClusters = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.listClusters(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.listClusters as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listClusters as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listClusters with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListClustersRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListClustersRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.listClusters(request), expectedError);
    });
  });

  describe('deleteCluster', () => {
    it('invokes deleteCluster without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteClusterRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.protobuf.Empty()
      );
      client.innerApiCalls.deleteCluster = stubSimpleCall(expectedResponse);
      const [response] = await client.deleteCluster(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.deleteCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteCluster without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteClusterRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.protobuf.Empty()
      );
      client.innerApiCalls.deleteCluster =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.deleteCluster(
          request,
          (
            err?: Error | null,
            result?: protos.google.protobuf.IEmpty | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.deleteCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteCluster with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteClusterRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.deleteCluster = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.deleteCluster(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.deleteCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteCluster with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteClusterRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.deleteCluster(request), expectedError);
    });
  });

  describe('createAppProfile', () => {
    it('invokes createAppProfile without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateAppProfileRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.AppProfile()
      );
      client.innerApiCalls.createAppProfile = stubSimpleCall(expectedResponse);
      const [response] = await client.createAppProfile(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.createAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createAppProfile without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateAppProfileRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.AppProfile()
      );
      client.innerApiCalls.createAppProfile =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.createAppProfile(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.IAppProfile | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.createAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createAppProfile with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateAppProfileRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.createAppProfile = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.createAppProfile(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.createAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createAppProfile with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateAppProfileRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.createAppProfile(request), expectedError);
    });
  });

  describe('getAppProfile', () => {
    it('invokes getAppProfile without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetAppProfileRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.AppProfile()
      );
      client.innerApiCalls.getAppProfile = stubSimpleCall(expectedResponse);
      const [response] = await client.getAppProfile(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.getAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getAppProfile without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetAppProfileRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.bigtable.admin.v2.AppProfile()
      );
      client.innerApiCalls.getAppProfile =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.getAppProfile(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.IAppProfile | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.getAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getAppProfile with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetAppProfileRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.getAppProfile = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.getAppProfile(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.getAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getAppProfile with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.GetAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.GetAppProfileRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.getAppProfile(request), expectedError);
    });
  });

  describe('deleteAppProfile', () => {
    it('invokes deleteAppProfile without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteAppProfileRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.protobuf.Empty()
      );
      client.innerApiCalls.deleteAppProfile = stubSimpleCall(expectedResponse);
      const [response] = await client.deleteAppProfile(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.deleteAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteAppProfile without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteAppProfileRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.protobuf.Empty()
      );
      client.innerApiCalls.deleteAppProfile =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.deleteAppProfile(
          request,
          (
            err?: Error | null,
            result?: protos.google.protobuf.IEmpty | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.deleteAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteAppProfile with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteAppProfileRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.deleteAppProfile = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.deleteAppProfile(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.deleteAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes deleteAppProfile with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.DeleteAppProfileRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.DeleteAppProfileRequest',
        ['name']
      );
      request.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.deleteAppProfile(request), expectedError);
    });
  });

  describe('getIamPolicy', () => {
    it('invokes getIamPolicy without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.GetIamPolicyRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.GetIamPolicyRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.iam.v1.Policy()
      );
      client.innerApiCalls.getIamPolicy = stubSimpleCall(expectedResponse);
      const [response] = await client.getIamPolicy(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.getIamPolicy as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getIamPolicy as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getIamPolicy without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.GetIamPolicyRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.GetIamPolicyRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.iam.v1.Policy()
      );
      client.innerApiCalls.getIamPolicy =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.getIamPolicy(
          request,
          (
            err?: Error | null,
            result?: protos.google.iam.v1.IPolicy | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.getIamPolicy as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getIamPolicy as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getIamPolicy with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.GetIamPolicyRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.GetIamPolicyRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.getIamPolicy = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.getIamPolicy(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.getIamPolicy as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.getIamPolicy as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes getIamPolicy with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.GetIamPolicyRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.GetIamPolicyRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.getIamPolicy(request), expectedError);
    });
  });

  describe('setIamPolicy', () => {
    it('invokes setIamPolicy without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.SetIamPolicyRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.SetIamPolicyRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.iam.v1.Policy()
      );
      client.innerApiCalls.setIamPolicy = stubSimpleCall(expectedResponse);
      const [response] = await client.setIamPolicy(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.setIamPolicy as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.setIamPolicy as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes setIamPolicy without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.SetIamPolicyRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.SetIamPolicyRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.iam.v1.Policy()
      );
      client.innerApiCalls.setIamPolicy =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.setIamPolicy(
          request,
          (
            err?: Error | null,
            result?: protos.google.iam.v1.IPolicy | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.setIamPolicy as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.setIamPolicy as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes setIamPolicy with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.SetIamPolicyRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.SetIamPolicyRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.setIamPolicy = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.setIamPolicy(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.setIamPolicy as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.setIamPolicy as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes setIamPolicy with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.SetIamPolicyRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.SetIamPolicyRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.setIamPolicy(request), expectedError);
    });
  });

  describe('testIamPermissions', () => {
    it('invokes testIamPermissions without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.TestIamPermissionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.TestIamPermissionsRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.iam.v1.TestIamPermissionsResponse()
      );
      client.innerApiCalls.testIamPermissions =
        stubSimpleCall(expectedResponse);
      const [response] = await client.testIamPermissions(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.testIamPermissions as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.testIamPermissions as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes testIamPermissions without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.TestIamPermissionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.TestIamPermissionsRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.iam.v1.TestIamPermissionsResponse()
      );
      client.innerApiCalls.testIamPermissions =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.testIamPermissions(
          request,
          (
            err?: Error | null,
            result?: protos.google.iam.v1.ITestIamPermissionsResponse | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.testIamPermissions as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.testIamPermissions as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes testIamPermissions with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.TestIamPermissionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.TestIamPermissionsRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedHeaderRequestParams = `resource=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.testIamPermissions = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.testIamPermissions(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.testIamPermissions as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.testIamPermissions as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes testIamPermissions with closed client', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.iam.v1.TestIamPermissionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.iam.v1.TestIamPermissionsRequest',
        ['resource']
      );
      request.resource = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.testIamPermissions(request), expectedError);
    });
  });

  describe('createInstance', () => {
    it('invokes createInstance without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateInstanceRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.createInstance =
        stubLongRunningCall(expectedResponse);
      const [operation] = await client.createInstance(request);
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.createInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createInstance without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateInstanceRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.createInstance =
        stubLongRunningCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.createInstance(
          request,
          (
            err?: Error | null,
            result?: LROperation<
              protos.google.bigtable.admin.v2.IInstance,
              protos.google.bigtable.admin.v2.ICreateInstanceMetadata
            > | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const operation = (await promise) as LROperation<
        protos.google.bigtable.admin.v2.IInstance,
        protos.google.bigtable.admin.v2.ICreateInstanceMetadata
      >;
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.createInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createInstance with call error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateInstanceRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.createInstance = stubLongRunningCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.createInstance(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.createInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createInstance with LRO error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateInstanceRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateInstanceRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.createInstance = stubLongRunningCall(
        undefined,
        undefined,
        expectedError
      );
      const [operation] = await client.createInstance(request);
      await assert.rejects(operation.promise(), expectedError);
      const actualRequest = (
        client.innerApiCalls.createInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkCreateInstanceProgress without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedResponse = generateSampleMessage(
        new operationsProtos.google.longrunning.Operation()
      );
      expectedResponse.name = 'test';
      expectedResponse.response = {type_url: 'url', value: Buffer.from('')};
      expectedResponse.metadata = {type_url: 'url', value: Buffer.from('')};

      client.operationsClient.getOperation = stubSimpleCall(expectedResponse);
      const decodedOperation = await client.checkCreateInstanceProgress(
        expectedResponse.name
      );
      assert.deepStrictEqual(decodedOperation.name, expectedResponse.name);
      assert(decodedOperation.metadata);
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });

    it('invokes checkCreateInstanceProgress with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedError = new Error('expected');

      client.operationsClient.getOperation = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.checkCreateInstanceProgress(''),
        expectedError
      );
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });
  });

  describe('partialUpdateInstance', () => {
    it('invokes partialUpdateInstance without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.PartialUpdateInstanceRequest()
      );
      request.instance ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.PartialUpdateInstanceRequest',
        ['instance', 'name']
      );
      request.instance.name = defaultValue1;
      const expectedHeaderRequestParams = `instance.name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.partialUpdateInstance =
        stubLongRunningCall(expectedResponse);
      const [operation] = await client.partialUpdateInstance(request);
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.partialUpdateInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.partialUpdateInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes partialUpdateInstance without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.PartialUpdateInstanceRequest()
      );
      request.instance ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.PartialUpdateInstanceRequest',
        ['instance', 'name']
      );
      request.instance.name = defaultValue1;
      const expectedHeaderRequestParams = `instance.name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.partialUpdateInstance =
        stubLongRunningCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.partialUpdateInstance(
          request,
          (
            err?: Error | null,
            result?: LROperation<
              protos.google.bigtable.admin.v2.IInstance,
              protos.google.bigtable.admin.v2.IUpdateInstanceMetadata
            > | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const operation = (await promise) as LROperation<
        protos.google.bigtable.admin.v2.IInstance,
        protos.google.bigtable.admin.v2.IUpdateInstanceMetadata
      >;
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.partialUpdateInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.partialUpdateInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes partialUpdateInstance with call error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.PartialUpdateInstanceRequest()
      );
      request.instance ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.PartialUpdateInstanceRequest',
        ['instance', 'name']
      );
      request.instance.name = defaultValue1;
      const expectedHeaderRequestParams = `instance.name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.partialUpdateInstance = stubLongRunningCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.partialUpdateInstance(request),
        expectedError
      );
      const actualRequest = (
        client.innerApiCalls.partialUpdateInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.partialUpdateInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes partialUpdateInstance with LRO error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.PartialUpdateInstanceRequest()
      );
      request.instance ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.PartialUpdateInstanceRequest',
        ['instance', 'name']
      );
      request.instance.name = defaultValue1;
      const expectedHeaderRequestParams = `instance.name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.partialUpdateInstance = stubLongRunningCall(
        undefined,
        undefined,
        expectedError
      );
      const [operation] = await client.partialUpdateInstance(request);
      await assert.rejects(operation.promise(), expectedError);
      const actualRequest = (
        client.innerApiCalls.partialUpdateInstance as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.partialUpdateInstance as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkPartialUpdateInstanceProgress without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedResponse = generateSampleMessage(
        new operationsProtos.google.longrunning.Operation()
      );
      expectedResponse.name = 'test';
      expectedResponse.response = {type_url: 'url', value: Buffer.from('')};
      expectedResponse.metadata = {type_url: 'url', value: Buffer.from('')};

      client.operationsClient.getOperation = stubSimpleCall(expectedResponse);
      const decodedOperation = await client.checkPartialUpdateInstanceProgress(
        expectedResponse.name
      );
      assert.deepStrictEqual(decodedOperation.name, expectedResponse.name);
      assert(decodedOperation.metadata);
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });

    it('invokes checkPartialUpdateInstanceProgress with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedError = new Error('expected');

      client.operationsClient.getOperation = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.checkPartialUpdateInstanceProgress(''),
        expectedError
      );
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });
  });

  describe('createCluster', () => {
    it('invokes createCluster without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateClusterRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.createCluster =
        stubLongRunningCall(expectedResponse);
      const [operation] = await client.createCluster(request);
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.createCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createCluster without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateClusterRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.createCluster =
        stubLongRunningCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.createCluster(
          request,
          (
            err?: Error | null,
            result?: LROperation<
              protos.google.bigtable.admin.v2.ICluster,
              protos.google.bigtable.admin.v2.ICreateClusterMetadata
            > | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const operation = (await promise) as LROperation<
        protos.google.bigtable.admin.v2.ICluster,
        protos.google.bigtable.admin.v2.ICreateClusterMetadata
      >;
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.createCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createCluster with call error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateClusterRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.createCluster = stubLongRunningCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.createCluster(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.createCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes createCluster with LRO error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.CreateClusterRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.CreateClusterRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.createCluster = stubLongRunningCall(
        undefined,
        undefined,
        expectedError
      );
      const [operation] = await client.createCluster(request);
      await assert.rejects(operation.promise(), expectedError);
      const actualRequest = (
        client.innerApiCalls.createCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.createCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkCreateClusterProgress without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedResponse = generateSampleMessage(
        new operationsProtos.google.longrunning.Operation()
      );
      expectedResponse.name = 'test';
      expectedResponse.response = {type_url: 'url', value: Buffer.from('')};
      expectedResponse.metadata = {type_url: 'url', value: Buffer.from('')};

      client.operationsClient.getOperation = stubSimpleCall(expectedResponse);
      const decodedOperation = await client.checkCreateClusterProgress(
        expectedResponse.name
      );
      assert.deepStrictEqual(decodedOperation.name, expectedResponse.name);
      assert(decodedOperation.metadata);
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });

    it('invokes checkCreateClusterProgress with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedError = new Error('expected');

      client.operationsClient.getOperation = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.checkCreateClusterProgress(''),
        expectedError
      );
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });
  });

  describe('updateCluster', () => {
    it('invokes updateCluster without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Cluster()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.Cluster',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.updateCluster =
        stubLongRunningCall(expectedResponse);
      const [operation] = await client.updateCluster(request);
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.updateCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateCluster without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Cluster()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.Cluster',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.updateCluster =
        stubLongRunningCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.updateCluster(
          request,
          (
            err?: Error | null,
            result?: LROperation<
              protos.google.bigtable.admin.v2.ICluster,
              protos.google.bigtable.admin.v2.IUpdateClusterMetadata
            > | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const operation = (await promise) as LROperation<
        protos.google.bigtable.admin.v2.ICluster,
        protos.google.bigtable.admin.v2.IUpdateClusterMetadata
      >;
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.updateCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateCluster with call error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Cluster()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.Cluster',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.updateCluster = stubLongRunningCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.updateCluster(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.updateCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateCluster with LRO error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.Cluster()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.Cluster',
        ['name']
      );
      request.name = defaultValue1;
      const expectedHeaderRequestParams = `name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.updateCluster = stubLongRunningCall(
        undefined,
        undefined,
        expectedError
      );
      const [operation] = await client.updateCluster(request);
      await assert.rejects(operation.promise(), expectedError);
      const actualRequest = (
        client.innerApiCalls.updateCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkUpdateClusterProgress without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedResponse = generateSampleMessage(
        new operationsProtos.google.longrunning.Operation()
      );
      expectedResponse.name = 'test';
      expectedResponse.response = {type_url: 'url', value: Buffer.from('')};
      expectedResponse.metadata = {type_url: 'url', value: Buffer.from('')};

      client.operationsClient.getOperation = stubSimpleCall(expectedResponse);
      const decodedOperation = await client.checkUpdateClusterProgress(
        expectedResponse.name
      );
      assert.deepStrictEqual(decodedOperation.name, expectedResponse.name);
      assert(decodedOperation.metadata);
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });

    it('invokes checkUpdateClusterProgress with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedError = new Error('expected');

      client.operationsClient.getOperation = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.checkUpdateClusterProgress(''),
        expectedError
      );
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });
  });

  describe('partialUpdateCluster', () => {
    it('invokes partialUpdateCluster without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.PartialUpdateClusterRequest()
      );
      request.cluster ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.PartialUpdateClusterRequest',
        ['cluster', 'name']
      );
      request.cluster.name = defaultValue1;
      const expectedHeaderRequestParams = `cluster.name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.partialUpdateCluster =
        stubLongRunningCall(expectedResponse);
      const [operation] = await client.partialUpdateCluster(request);
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.partialUpdateCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.partialUpdateCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes partialUpdateCluster without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.PartialUpdateClusterRequest()
      );
      request.cluster ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.PartialUpdateClusterRequest',
        ['cluster', 'name']
      );
      request.cluster.name = defaultValue1;
      const expectedHeaderRequestParams = `cluster.name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.partialUpdateCluster =
        stubLongRunningCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.partialUpdateCluster(
          request,
          (
            err?: Error | null,
            result?: LROperation<
              protos.google.bigtable.admin.v2.ICluster,
              protos.google.bigtable.admin.v2.IPartialUpdateClusterMetadata
            > | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const operation = (await promise) as LROperation<
        protos.google.bigtable.admin.v2.ICluster,
        protos.google.bigtable.admin.v2.IPartialUpdateClusterMetadata
      >;
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.partialUpdateCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.partialUpdateCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes partialUpdateCluster with call error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.PartialUpdateClusterRequest()
      );
      request.cluster ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.PartialUpdateClusterRequest',
        ['cluster', 'name']
      );
      request.cluster.name = defaultValue1;
      const expectedHeaderRequestParams = `cluster.name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.partialUpdateCluster = stubLongRunningCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.partialUpdateCluster(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.partialUpdateCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.partialUpdateCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes partialUpdateCluster with LRO error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.PartialUpdateClusterRequest()
      );
      request.cluster ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.PartialUpdateClusterRequest',
        ['cluster', 'name']
      );
      request.cluster.name = defaultValue1;
      const expectedHeaderRequestParams = `cluster.name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.partialUpdateCluster = stubLongRunningCall(
        undefined,
        undefined,
        expectedError
      );
      const [operation] = await client.partialUpdateCluster(request);
      await assert.rejects(operation.promise(), expectedError);
      const actualRequest = (
        client.innerApiCalls.partialUpdateCluster as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.partialUpdateCluster as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkPartialUpdateClusterProgress without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedResponse = generateSampleMessage(
        new operationsProtos.google.longrunning.Operation()
      );
      expectedResponse.name = 'test';
      expectedResponse.response = {type_url: 'url', value: Buffer.from('')};
      expectedResponse.metadata = {type_url: 'url', value: Buffer.from('')};

      client.operationsClient.getOperation = stubSimpleCall(expectedResponse);
      const decodedOperation = await client.checkPartialUpdateClusterProgress(
        expectedResponse.name
      );
      assert.deepStrictEqual(decodedOperation.name, expectedResponse.name);
      assert(decodedOperation.metadata);
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });

    it('invokes checkPartialUpdateClusterProgress with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedError = new Error('expected');

      client.operationsClient.getOperation = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.checkPartialUpdateClusterProgress(''),
        expectedError
      );
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });
  });

  describe('updateAppProfile', () => {
    it('invokes updateAppProfile without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.UpdateAppProfileRequest()
      );
      request.appProfile ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.UpdateAppProfileRequest',
        ['appProfile', 'name']
      );
      request.appProfile.name = defaultValue1;
      const expectedHeaderRequestParams = `app_profile.name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.updateAppProfile =
        stubLongRunningCall(expectedResponse);
      const [operation] = await client.updateAppProfile(request);
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.updateAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateAppProfile without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.UpdateAppProfileRequest()
      );
      request.appProfile ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.UpdateAppProfileRequest',
        ['appProfile', 'name']
      );
      request.appProfile.name = defaultValue1;
      const expectedHeaderRequestParams = `app_profile.name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.longrunning.Operation()
      );
      client.innerApiCalls.updateAppProfile =
        stubLongRunningCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.updateAppProfile(
          request,
          (
            err?: Error | null,
            result?: LROperation<
              protos.google.bigtable.admin.v2.IAppProfile,
              protos.google.bigtable.admin.v2.IUpdateAppProfileMetadata
            > | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const operation = (await promise) as LROperation<
        protos.google.bigtable.admin.v2.IAppProfile,
        protos.google.bigtable.admin.v2.IUpdateAppProfileMetadata
      >;
      const [response] = await operation.promise();
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.updateAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateAppProfile with call error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.UpdateAppProfileRequest()
      );
      request.appProfile ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.UpdateAppProfileRequest',
        ['appProfile', 'name']
      );
      request.appProfile.name = defaultValue1;
      const expectedHeaderRequestParams = `app_profile.name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.updateAppProfile = stubLongRunningCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.updateAppProfile(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.updateAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes updateAppProfile with LRO error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.UpdateAppProfileRequest()
      );
      request.appProfile ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.UpdateAppProfileRequest',
        ['appProfile', 'name']
      );
      request.appProfile.name = defaultValue1;
      const expectedHeaderRequestParams = `app_profile.name=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.updateAppProfile = stubLongRunningCall(
        undefined,
        undefined,
        expectedError
      );
      const [operation] = await client.updateAppProfile(request);
      await assert.rejects(operation.promise(), expectedError);
      const actualRequest = (
        client.innerApiCalls.updateAppProfile as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateAppProfile as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes checkUpdateAppProfileProgress without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedResponse = generateSampleMessage(
        new operationsProtos.google.longrunning.Operation()
      );
      expectedResponse.name = 'test';
      expectedResponse.response = {type_url: 'url', value: Buffer.from('')};
      expectedResponse.metadata = {type_url: 'url', value: Buffer.from('')};

      client.operationsClient.getOperation = stubSimpleCall(expectedResponse);
      const decodedOperation = await client.checkUpdateAppProfileProgress(
        expectedResponse.name
      );
      assert.deepStrictEqual(decodedOperation.name, expectedResponse.name);
      assert(decodedOperation.metadata);
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });

    it('invokes checkUpdateAppProfileProgress with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const expectedError = new Error('expected');

      client.operationsClient.getOperation = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.checkUpdateAppProfileProgress(''),
        expectedError
      );
      assert((client.operationsClient.getOperation as SinonStub).getCall(0));
    });
  });

  describe('listAppProfiles', () => {
    it('invokes listAppProfiles without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListAppProfilesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListAppProfilesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
      ];
      client.innerApiCalls.listAppProfiles = stubSimpleCall(expectedResponse);
      const [response] = await client.listAppProfiles(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.listAppProfiles as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listAppProfiles as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listAppProfiles without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListAppProfilesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListAppProfilesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
      ];
      client.innerApiCalls.listAppProfiles =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.listAppProfiles(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.IAppProfile[] | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.listAppProfiles as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listAppProfiles as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listAppProfiles with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListAppProfilesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListAppProfilesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.listAppProfiles = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.listAppProfiles(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.listAppProfiles as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listAppProfiles as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listAppProfilesStream without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListAppProfilesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListAppProfilesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
      ];
      client.descriptors.page.listAppProfiles.createStream =
        stubPageStreamingCall(expectedResponse);
      const stream = client.listAppProfilesStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: protos.google.bigtable.admin.v2.AppProfile[] = [];
        stream.on(
          'data',
          (response: protos.google.bigtable.admin.v2.AppProfile) => {
            responses.push(response);
          }
        );
        stream.on('end', () => {
          resolve(responses);
        });
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      const responses = await promise;
      assert.deepStrictEqual(responses, expectedResponse);
      assert(
        (client.descriptors.page.listAppProfiles.createStream as SinonStub)
          .getCall(0)
          .calledWith(client.innerApiCalls.listAppProfiles, request)
      );
      assert(
        (client.descriptors.page.listAppProfiles.createStream as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('invokes listAppProfilesStream with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListAppProfilesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListAppProfilesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listAppProfiles.createStream =
        stubPageStreamingCall(undefined, expectedError);
      const stream = client.listAppProfilesStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: protos.google.bigtable.admin.v2.AppProfile[] = [];
        stream.on(
          'data',
          (response: protos.google.bigtable.admin.v2.AppProfile) => {
            responses.push(response);
          }
        );
        stream.on('end', () => {
          resolve(responses);
        });
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      assert(
        (client.descriptors.page.listAppProfiles.createStream as SinonStub)
          .getCall(0)
          .calledWith(client.innerApiCalls.listAppProfiles, request)
      );
      assert(
        (client.descriptors.page.listAppProfiles.createStream as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listAppProfiles without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListAppProfilesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListAppProfilesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.AppProfile()),
      ];
      client.descriptors.page.listAppProfiles.asyncIterate =
        stubAsyncIterationCall(expectedResponse);
      const responses: protos.google.bigtable.admin.v2.IAppProfile[] = [];
      const iterable = client.listAppProfilesAsync(request);
      for await (const resource of iterable) {
        responses.push(resource!);
      }
      assert.deepStrictEqual(responses, expectedResponse);
      assert.deepStrictEqual(
        (
          client.descriptors.page.listAppProfiles.asyncIterate as SinonStub
        ).getCall(0).args[1],
        request
      );
      assert(
        (client.descriptors.page.listAppProfiles.asyncIterate as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listAppProfiles with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListAppProfilesRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListAppProfilesRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listAppProfiles.asyncIterate =
        stubAsyncIterationCall(undefined, expectedError);
      const iterable = client.listAppProfilesAsync(request);
      await assert.rejects(async () => {
        const responses: protos.google.bigtable.admin.v2.IAppProfile[] = [];
        for await (const resource of iterable) {
          responses.push(resource!);
        }
      });
      assert.deepStrictEqual(
        (
          client.descriptors.page.listAppProfiles.asyncIterate as SinonStub
        ).getCall(0).args[1],
        request
      );
      assert(
        (client.descriptors.page.listAppProfiles.asyncIterate as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });
  });

  describe('listHotTablets', () => {
    it('invokes listHotTablets without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListHotTabletsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListHotTabletsRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
      ];
      client.innerApiCalls.listHotTablets = stubSimpleCall(expectedResponse);
      const [response] = await client.listHotTablets(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.listHotTablets as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listHotTablets as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listHotTablets without error using callback', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListHotTabletsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListHotTabletsRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
      ];
      client.innerApiCalls.listHotTablets =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.listHotTablets(
          request,
          (
            err?: Error | null,
            result?: protos.google.bigtable.admin.v2.IHotTablet[] | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.listHotTablets as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listHotTablets as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listHotTablets with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListHotTabletsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListHotTabletsRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.innerApiCalls.listHotTablets = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.listHotTablets(request), expectedError);
      const actualRequest = (
        client.innerApiCalls.listHotTablets as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.listHotTablets as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

    it('invokes listHotTabletsStream without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListHotTabletsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListHotTabletsRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
      ];
      client.descriptors.page.listHotTablets.createStream =
        stubPageStreamingCall(expectedResponse);
      const stream = client.listHotTabletsStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: protos.google.bigtable.admin.v2.HotTablet[] = [];
        stream.on(
          'data',
          (response: protos.google.bigtable.admin.v2.HotTablet) => {
            responses.push(response);
          }
        );
        stream.on('end', () => {
          resolve(responses);
        });
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      const responses = await promise;
      assert.deepStrictEqual(responses, expectedResponse);
      assert(
        (client.descriptors.page.listHotTablets.createStream as SinonStub)
          .getCall(0)
          .calledWith(client.innerApiCalls.listHotTablets, request)
      );
      assert(
        (client.descriptors.page.listHotTablets.createStream as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('invokes listHotTabletsStream with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListHotTabletsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListHotTabletsRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listHotTablets.createStream =
        stubPageStreamingCall(undefined, expectedError);
      const stream = client.listHotTabletsStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: protos.google.bigtable.admin.v2.HotTablet[] = [];
        stream.on(
          'data',
          (response: protos.google.bigtable.admin.v2.HotTablet) => {
            responses.push(response);
          }
        );
        stream.on('end', () => {
          resolve(responses);
        });
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      assert(
        (client.descriptors.page.listHotTablets.createStream as SinonStub)
          .getCall(0)
          .calledWith(client.innerApiCalls.listHotTablets, request)
      );
      assert(
        (client.descriptors.page.listHotTablets.createStream as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listHotTablets without error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListHotTabletsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListHotTabletsRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
        generateSampleMessage(new protos.google.bigtable.admin.v2.HotTablet()),
      ];
      client.descriptors.page.listHotTablets.asyncIterate =
        stubAsyncIterationCall(expectedResponse);
      const responses: protos.google.bigtable.admin.v2.IHotTablet[] = [];
      const iterable = client.listHotTabletsAsync(request);
      for await (const resource of iterable) {
        responses.push(resource!);
      }
      assert.deepStrictEqual(responses, expectedResponse);
      assert.deepStrictEqual(
        (
          client.descriptors.page.listHotTablets.asyncIterate as SinonStub
        ).getCall(0).args[1],
        request
      );
      assert(
        (client.descriptors.page.listHotTablets.asyncIterate as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listHotTablets with error', async () => {
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.bigtable.admin.v2.ListHotTabletsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.bigtable.admin.v2.ListHotTabletsRequest',
        ['parent']
      );
      request.parent = defaultValue1;
      const expectedHeaderRequestParams = `parent=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listHotTablets.asyncIterate =
        stubAsyncIterationCall(undefined, expectedError);
      const iterable = client.listHotTabletsAsync(request);
      await assert.rejects(async () => {
        const responses: protos.google.bigtable.admin.v2.IHotTablet[] = [];
        for await (const resource of iterable) {
          responses.push(resource!);
        }
      });
      assert.deepStrictEqual(
        (
          client.descriptors.page.listHotTablets.asyncIterate as SinonStub
        ).getCall(0).args[1],
        request
      );
      assert(
        (client.descriptors.page.listHotTablets.asyncIterate as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });
  });

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

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

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

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

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

    describe('backup', () => {
      const fakePath = '/rendered/path/backup';
      const expectedParameters = {
        project: 'projectValue',
        instance: 'instanceValue',
        cluster: 'clusterValue',
        backup: 'backupValue',
      };
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      client.pathTemplates.backupPathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.backupPathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

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

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

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

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

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

    describe('cluster', () => {
      const fakePath = '/rendered/path/cluster';
      const expectedParameters = {
        project: 'projectValue',
        instance: 'instanceValue',
        cluster: 'clusterValue',
      };
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      client.pathTemplates.clusterPathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.clusterPathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

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

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

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

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

    describe('hotTablet', () => {
      const fakePath = '/rendered/path/hotTablet';
      const expectedParameters = {
        project: 'projectValue',
        instance: 'instanceValue',
        cluster: 'clusterValue',
        hot_tablet: 'hotTabletValue',
      };
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      client.pathTemplates.hotTabletPathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.hotTabletPathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

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

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

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

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

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

    describe('instance', () => {
      const fakePath = '/rendered/path/instance';
      const expectedParameters = {
        project: 'projectValue',
        instance: 'instanceValue',
      };
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          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('project', () => {
      const fakePath = '/rendered/path/project';
      const expectedParameters = {
        project: 'projectValue',
      };
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      client.pathTemplates.projectPathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.projectPathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

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

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

    describe('snapshot', () => {
      const fakePath = '/rendered/path/snapshot';
      const expectedParameters = {
        project: 'projectValue',
        instance: 'instanceValue',
        cluster: 'clusterValue',
        snapshot: 'snapshotValue',
      };
      const client =
        new bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          credentials: {client_email: 'bogus', private_key: 'bogus'},
          projectId: 'bogus',
        });
      client.initialize();
      client.pathTemplates.snapshotPathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.snapshotPathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

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

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

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

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

      it('matchSnapshotFromSnapshotName', () => {
        const result = client.matchSnapshotFromSnapshotName(fakePath);
        assert.strictEqual(result, 'snapshotValue');
        assert(
          (client.pathTemplates.snapshotPathTemplate.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 bigtableinstanceadminModule.v2.BigtableInstanceAdminClient({
          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)
        );
      });
    });
  });
});