gapic_publisher_v1.ts

// Copyright 2024 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 publisherModule from '../src';

import {PassThrough} from 'stream';

import {protobuf, IamProtos} 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 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('v1.PublisherClient', () => {
  describe('Common methods', () => {
    it('has servicePath', () => {
      const servicePath = publisherModule.v1.PublisherClient.servicePath;
      assert(servicePath);
    });

    it('has apiEndpoint', () => {
      const apiEndpoint = publisherModule.v1.PublisherClient.apiEndpoint;
      assert(apiEndpoint);
    });

    it('has port', () => {
      const port = publisherModule.v1.PublisherClient.port;
      assert(port);
      assert(typeof port === 'number');
    });

    it('should create a client with no option', () => {
      const client = new publisherModule.v1.PublisherClient();
      assert(client);
    });

    it('should create a client with gRPC fallback', () => {
      const client = new publisherModule.v1.PublisherClient({
        fallback: true,
      });
      assert(client);
    });

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

    it('has close method for the initialized client', done => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      assert(client.publisherStub);
      client.close().then(() => {
        done();
      });
    });

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

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

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

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

    it('invokes createTopic with closed client', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.Topic()
      );
      const defaultValue1 = getTypeDefaultValue('.google.pubsub.v1.Topic', [
        'name',
      ]);
      request.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.createTopic(request), expectedError);
    });
  });

  describe('updateTopic', () => {
    it('invokes updateTopic without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.UpdateTopicRequest()
      );
      request.topic ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.UpdateTopicRequest',
        ['topic', 'name']
      );
      request.topic.name = defaultValue1;
      const expectedHeaderRequestParams = `topic.name=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.pubsub.v1.Topic()
      );
      client.innerApiCalls.updateTopic = stubSimpleCall(expectedResponse);
      const [response] = await client.updateTopic(request);
      assert.deepStrictEqual(response, expectedResponse);
      const actualRequest = (
        client.innerApiCalls.updateTopic as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.updateTopic as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

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

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

    it('invokes updateTopic with closed client', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.UpdateTopicRequest()
      );
      request.topic ??= {};
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.UpdateTopicRequest',
        ['topic', 'name']
      );
      request.topic.name = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.updateTopic(request), expectedError);
    });
  });

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

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

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

    it('invokes publish with closed client', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.PublishRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.PublishRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.publish(request), expectedError);
    });
  });

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

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

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

    it('invokes getTopic with closed client', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.GetTopicRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.GetTopicRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.getTopic(request), expectedError);
    });
  });

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

    it('invokes deleteTopic without error using callback', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.DeleteTopicRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.DeleteTopicRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedResponse = generateSampleMessage(
        new protos.google.protobuf.Empty()
      );
      client.innerApiCalls.deleteTopic =
        stubSimpleCallWithCallback(expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.deleteTopic(
          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.deleteTopic as SinonStub
      ).getCall(0).args[0];
      assert.deepStrictEqual(actualRequest, request);
      const actualHeaderRequestParams = (
        client.innerApiCalls.deleteTopic as SinonStub
      ).getCall(0).args[1].otherArgs.headers['x-goog-request-params'];
      assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams));
    });

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

    it('invokes deleteTopic with closed client', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.DeleteTopicRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.DeleteTopicRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.deleteTopic(request), expectedError);
    });
  });

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

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

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

    it('invokes detachSubscription with closed client', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.DetachSubscriptionRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.DetachSubscriptionRequest',
        ['subscription']
      );
      request.subscription = defaultValue1;
      const expectedError = new Error('The client has already been closed.');
      client.close();
      await assert.rejects(client.detachSubscription(request), expectedError);
    });
  });

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

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

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

    it('invokes listTopicsStream without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicsRequest',
        ['project']
      );
      request.project = defaultValue1;
      const expectedHeaderRequestParams = `project=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.pubsub.v1.Topic()),
        generateSampleMessage(new protos.google.pubsub.v1.Topic()),
        generateSampleMessage(new protos.google.pubsub.v1.Topic()),
      ];
      client.descriptors.page.listTopics.createStream =
        stubPageStreamingCall(expectedResponse);
      const stream = client.listTopicsStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: protos.google.pubsub.v1.Topic[] = [];
        stream.on('data', (response: protos.google.pubsub.v1.Topic) => {
          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.listTopics.createStream as SinonStub)
          .getCall(0)
          .calledWith(client.innerApiCalls.listTopics, request)
      );
      assert(
        (client.descriptors.page.listTopics.createStream as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('invokes listTopicsStream with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicsRequest',
        ['project']
      );
      request.project = defaultValue1;
      const expectedHeaderRequestParams = `project=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listTopics.createStream = stubPageStreamingCall(
        undefined,
        expectedError
      );
      const stream = client.listTopicsStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: protos.google.pubsub.v1.Topic[] = [];
        stream.on('data', (response: protos.google.pubsub.v1.Topic) => {
          responses.push(response);
        });
        stream.on('end', () => {
          resolve(responses);
        });
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      assert(
        (client.descriptors.page.listTopics.createStream as SinonStub)
          .getCall(0)
          .calledWith(client.innerApiCalls.listTopics, request)
      );
      assert(
        (client.descriptors.page.listTopics.createStream as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listTopics without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicsRequest',
        ['project']
      );
      request.project = defaultValue1;
      const expectedHeaderRequestParams = `project=${defaultValue1}`;
      const expectedResponse = [
        generateSampleMessage(new protos.google.pubsub.v1.Topic()),
        generateSampleMessage(new protos.google.pubsub.v1.Topic()),
        generateSampleMessage(new protos.google.pubsub.v1.Topic()),
      ];
      client.descriptors.page.listTopics.asyncIterate =
        stubAsyncIterationCall(expectedResponse);
      const responses: protos.google.pubsub.v1.ITopic[] = [];
      const iterable = client.listTopicsAsync(request);
      for await (const resource of iterable) {
        responses.push(resource!);
      }
      assert.deepStrictEqual(responses, expectedResponse);
      assert.deepStrictEqual(
        (client.descriptors.page.listTopics.asyncIterate as SinonStub).getCall(
          0
        ).args[1],
        request
      );
      assert(
        (client.descriptors.page.listTopics.asyncIterate as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listTopics with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicsRequest',
        ['project']
      );
      request.project = defaultValue1;
      const expectedHeaderRequestParams = `project=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listTopics.asyncIterate = stubAsyncIterationCall(
        undefined,
        expectedError
      );
      const iterable = client.listTopicsAsync(request);
      await assert.rejects(async () => {
        const responses: protos.google.pubsub.v1.ITopic[] = [];
        for await (const resource of iterable) {
          responses.push(resource!);
        }
      });
      assert.deepStrictEqual(
        (client.descriptors.page.listTopics.asyncIterate as SinonStub).getCall(
          0
        ).args[1],
        request
      );
      assert(
        (client.descriptors.page.listTopics.asyncIterate as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });
  });

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

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

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

    it('invokes listTopicSubscriptionsStream without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicSubscriptionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicSubscriptionsRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedResponse = [new String(), new String(), new String()];
      client.descriptors.page.listTopicSubscriptions.createStream =
        stubPageStreamingCall(expectedResponse);
      const stream = client.listTopicSubscriptionsStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: string[] = [];
        stream.on('data', (response: string) => {
          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.listTopicSubscriptions
            .createStream as SinonStub
        )
          .getCall(0)
          .calledWith(client.innerApiCalls.listTopicSubscriptions, request)
      );
      assert(
        (
          client.descriptors.page.listTopicSubscriptions
            .createStream as SinonStub
        )
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('invokes listTopicSubscriptionsStream with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicSubscriptionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicSubscriptionsRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listTopicSubscriptions.createStream =
        stubPageStreamingCall(undefined, expectedError);
      const stream = client.listTopicSubscriptionsStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: string[] = [];
        stream.on('data', (response: string) => {
          responses.push(response);
        });
        stream.on('end', () => {
          resolve(responses);
        });
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      assert(
        (
          client.descriptors.page.listTopicSubscriptions
            .createStream as SinonStub
        )
          .getCall(0)
          .calledWith(client.innerApiCalls.listTopicSubscriptions, request)
      );
      assert(
        (
          client.descriptors.page.listTopicSubscriptions
            .createStream as SinonStub
        )
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listTopicSubscriptions without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicSubscriptionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicSubscriptionsRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedResponse = [new String(), new String(), new String()];
      client.descriptors.page.listTopicSubscriptions.asyncIterate =
        stubAsyncIterationCall(expectedResponse);
      const responses: string[] = [];
      const iterable = client.listTopicSubscriptionsAsync(request);
      for await (const resource of iterable) {
        responses.push(resource!);
      }
      assert.deepStrictEqual(responses, expectedResponse);
      assert.deepStrictEqual(
        (
          client.descriptors.page.listTopicSubscriptions
            .asyncIterate as SinonStub
        ).getCall(0).args[1],
        request
      );
      assert(
        (
          client.descriptors.page.listTopicSubscriptions
            .asyncIterate as SinonStub
        )
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listTopicSubscriptions with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicSubscriptionsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicSubscriptionsRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listTopicSubscriptions.asyncIterate =
        stubAsyncIterationCall(undefined, expectedError);
      const iterable = client.listTopicSubscriptionsAsync(request);
      await assert.rejects(async () => {
        const responses: string[] = [];
        for await (const resource of iterable) {
          responses.push(resource!);
        }
      });
      assert.deepStrictEqual(
        (
          client.descriptors.page.listTopicSubscriptions
            .asyncIterate as SinonStub
        ).getCall(0).args[1],
        request
      );
      assert(
        (
          client.descriptors.page.listTopicSubscriptions
            .asyncIterate as SinonStub
        )
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });
  });

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

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

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

    it('invokes listTopicSnapshotsStream without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicSnapshotsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicSnapshotsRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedResponse = [new String(), new String(), new String()];
      client.descriptors.page.listTopicSnapshots.createStream =
        stubPageStreamingCall(expectedResponse);
      const stream = client.listTopicSnapshotsStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: string[] = [];
        stream.on('data', (response: string) => {
          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.listTopicSnapshots.createStream as SinonStub)
          .getCall(0)
          .calledWith(client.innerApiCalls.listTopicSnapshots, request)
      );
      assert(
        (client.descriptors.page.listTopicSnapshots.createStream as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('invokes listTopicSnapshotsStream with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicSnapshotsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicSnapshotsRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listTopicSnapshots.createStream =
        stubPageStreamingCall(undefined, expectedError);
      const stream = client.listTopicSnapshotsStream(request);
      const promise = new Promise((resolve, reject) => {
        const responses: string[] = [];
        stream.on('data', (response: string) => {
          responses.push(response);
        });
        stream.on('end', () => {
          resolve(responses);
        });
        stream.on('error', (err: Error) => {
          reject(err);
        });
      });
      await assert.rejects(promise, expectedError);
      assert(
        (client.descriptors.page.listTopicSnapshots.createStream as SinonStub)
          .getCall(0)
          .calledWith(client.innerApiCalls.listTopicSnapshots, request)
      );
      assert(
        (client.descriptors.page.listTopicSnapshots.createStream as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listTopicSnapshots without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicSnapshotsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicSnapshotsRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedResponse = [new String(), new String(), new String()];
      client.descriptors.page.listTopicSnapshots.asyncIterate =
        stubAsyncIterationCall(expectedResponse);
      const responses: string[] = [];
      const iterable = client.listTopicSnapshotsAsync(request);
      for await (const resource of iterable) {
        responses.push(resource!);
      }
      assert.deepStrictEqual(responses, expectedResponse);
      assert.deepStrictEqual(
        (
          client.descriptors.page.listTopicSnapshots.asyncIterate as SinonStub
        ).getCall(0).args[1],
        request
      );
      assert(
        (client.descriptors.page.listTopicSnapshots.asyncIterate as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });

    it('uses async iteration with listTopicSnapshots with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new protos.google.pubsub.v1.ListTopicSnapshotsRequest()
      );
      const defaultValue1 = getTypeDefaultValue(
        '.google.pubsub.v1.ListTopicSnapshotsRequest',
        ['topic']
      );
      request.topic = defaultValue1;
      const expectedHeaderRequestParams = `topic=${defaultValue1}`;
      const expectedError = new Error('expected');
      client.descriptors.page.listTopicSnapshots.asyncIterate =
        stubAsyncIterationCall(undefined, expectedError);
      const iterable = client.listTopicSnapshotsAsync(request);
      await assert.rejects(async () => {
        const responses: string[] = [];
        for await (const resource of iterable) {
          responses.push(resource!);
        }
      });
      assert.deepStrictEqual(
        (
          client.descriptors.page.listTopicSnapshots.asyncIterate as SinonStub
        ).getCall(0).args[1],
        request
      );
      assert(
        (client.descriptors.page.listTopicSnapshots.asyncIterate as SinonStub)
          .getCall(0)
          .args[2].otherArgs.headers['x-goog-request-params'].includes(
            expectedHeaderRequestParams
          )
      );
    });
  });
  describe('getIamPolicy', () => {
    it('invokes getIamPolicy without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.GetIamPolicyRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new IamProtos.google.iam.v1.Policy()
      );
      client.iamClient.getIamPolicy = stubSimpleCall(expectedResponse);
      const response = await client.getIamPolicy(request, expectedOptions);
      assert.deepStrictEqual(response, [expectedResponse]);
      assert(
        (client.iamClient.getIamPolicy as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
    it('invokes getIamPolicy without error using callback', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.GetIamPolicyRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new IamProtos.google.iam.v1.Policy()
      );
      client.iamClient.getIamPolicy = sinon
        .stub()
        .callsArgWith(2, null, expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.getIamPolicy(
          request,
          expectedOptions,
          (
            err?: Error | null,
            result?: IamProtos.google.iam.v1.Policy | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      assert((client.iamClient.getIamPolicy as SinonStub).getCall(0));
    });
    it('invokes getIamPolicy with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.GetIamPolicyRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.iamClient.getIamPolicy = stubSimpleCall(undefined, expectedError);
      await assert.rejects(
        client.getIamPolicy(request, expectedOptions),
        expectedError
      );
      assert(
        (client.iamClient.getIamPolicy as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
  });
  describe('setIamPolicy', () => {
    it('invokes setIamPolicy without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.SetIamPolicyRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new IamProtos.google.iam.v1.Policy()
      );
      client.iamClient.setIamPolicy = stubSimpleCall(expectedResponse);
      const response = await client.setIamPolicy(request, expectedOptions);
      assert.deepStrictEqual(response, [expectedResponse]);
      assert(
        (client.iamClient.setIamPolicy as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
    it('invokes setIamPolicy without error using callback', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.SetIamPolicyRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new IamProtos.google.iam.v1.Policy()
      );
      client.iamClient.setIamPolicy = sinon
        .stub()
        .callsArgWith(2, null, expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.setIamPolicy(
          request,
          expectedOptions,
          (
            err?: Error | null,
            result?: IamProtos.google.iam.v1.Policy | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      assert((client.iamClient.setIamPolicy as SinonStub).getCall(0));
    });
    it('invokes setIamPolicy with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.SetIamPolicyRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.iamClient.setIamPolicy = stubSimpleCall(undefined, expectedError);
      await assert.rejects(
        client.setIamPolicy(request, expectedOptions),
        expectedError
      );
      assert(
        (client.iamClient.setIamPolicy as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
  });
  describe('testIamPermissions', () => {
    it('invokes testIamPermissions without error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.TestIamPermissionsRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new IamProtos.google.iam.v1.TestIamPermissionsResponse()
      );
      client.iamClient.testIamPermissions = stubSimpleCall(expectedResponse);
      const response = await client.testIamPermissions(
        request,
        expectedOptions
      );
      assert.deepStrictEqual(response, [expectedResponse]);
      assert(
        (client.iamClient.testIamPermissions as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
    it('invokes testIamPermissions without error using callback', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.TestIamPermissionsRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new IamProtos.google.iam.v1.TestIamPermissionsResponse()
      );
      client.iamClient.testIamPermissions = sinon
        .stub()
        .callsArgWith(2, null, expectedResponse);
      const promise = new Promise((resolve, reject) => {
        client.testIamPermissions(
          request,
          expectedOptions,
          (
            err?: Error | null,
            result?: IamProtos.google.iam.v1.TestIamPermissionsResponse | null
          ) => {
            if (err) {
              reject(err);
            } else {
              resolve(result);
            }
          }
        );
      });
      const response = await promise;
      assert.deepStrictEqual(response, expectedResponse);
      assert((client.iamClient.testIamPermissions as SinonStub).getCall(0));
    });
    it('invokes testIamPermissions with error', async () => {
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      const request = generateSampleMessage(
        new IamProtos.google.iam.v1.TestIamPermissionsRequest()
      );
      request.resource = '';
      const expectedHeaderRequestParams = 'resource=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.iamClient.testIamPermissions = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.testIamPermissions(request, expectedOptions),
        expectedError
      );
      assert(
        (client.iamClient.testIamPermissions as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
  });

  describe('Path templates', () => {
    describe('project', () => {
      const fakePath = '/rendered/path/project';
      const expectedParameters = {
        project: 'projectValue',
      };
      const client = new publisherModule.v1.PublisherClient({
        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('projectTopic', () => {
      const fakePath = '/rendered/path/projectTopic';
      const expectedParameters = {
        project: 'projectValue',
        topic: 'topicValue',
      };
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      client.pathTemplates.projectTopicPathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.projectTopicPathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

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

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

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

    describe('schema', () => {
      const fakePath = '/rendered/path/schema';
      const expectedParameters = {
        project: 'projectValue',
        schema: 'schemaValue',
      };
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      client.pathTemplates.schemaPathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.schemaPathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

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

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

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

    describe('snapshot', () => {
      const fakePath = '/rendered/path/snapshot';
      const expectedParameters = {
        project: 'projectValue',
        snapshot: 'snapshotValue',
      };
      const client = new publisherModule.v1.PublisherClient({
        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', '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('matchSnapshotFromSnapshotName', () => {
        const result = client.matchSnapshotFromSnapshotName(fakePath);
        assert.strictEqual(result, 'snapshotValue');
        assert(
          (client.pathTemplates.snapshotPathTemplate.match as SinonStub)
            .getCall(-1)
            .calledWith(fakePath)
        );
      });
    });

    describe('subscription', () => {
      const fakePath = '/rendered/path/subscription';
      const expectedParameters = {
        project: 'projectValue',
        subscription: 'subscriptionValue',
      };
      const client = new publisherModule.v1.PublisherClient({
        credentials: {client_email: 'bogus', private_key: 'bogus'},
        projectId: 'bogus',
      });
      client.initialize();
      client.pathTemplates.subscriptionPathTemplate.render = sinon
        .stub()
        .returns(fakePath);
      client.pathTemplates.subscriptionPathTemplate.match = sinon
        .stub()
        .returns(expectedParameters);

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

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

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