gapic_publisher_v1.ts

// Copyright 2020 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';

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', () => {
  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', () => {
    const client = new publisherModule.v1.PublisherClient({
      credentials: {client_email: 'bogus', private_key: 'bogus'},
      projectId: 'bogus',
    });
    client.close();
  });

  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()
      );
      request.name = '';
      const expectedHeaderRequestParams = 'name=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new protos.google.pubsub.v1.Topic()
      );
      client.innerApiCalls.createTopic = stubSimpleCall(expectedResponse);
      const [response] = await client.createTopic(request);
      assert.deepStrictEqual(response, expectedResponse);
      assert(
        (client.innerApiCalls.createTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.name = '';
      const expectedHeaderRequestParams = 'name=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.createTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions /*, callback defined above */)
      );
    });

    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()
      );
      request.name = '';
      const expectedHeaderRequestParams = 'name=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.innerApiCalls.createTopic = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.createTopic(request), expectedError);
      assert(
        (client.innerApiCalls.createTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
  });

  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 = {};
      request.topic.name = '';
      const expectedHeaderRequestParams = 'topic.name=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new protos.google.pubsub.v1.Topic()
      );
      client.innerApiCalls.updateTopic = stubSimpleCall(expectedResponse);
      const [response] = await client.updateTopic(request);
      assert.deepStrictEqual(response, expectedResponse);
      assert(
        (client.innerApiCalls.updateTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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 = {};
      request.topic.name = '';
      const expectedHeaderRequestParams = 'topic.name=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.updateTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions /*, callback defined above */)
      );
    });

    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 = {};
      request.topic.name = '';
      const expectedHeaderRequestParams = 'topic.name=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.innerApiCalls.updateTopic = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.updateTopic(request), expectedError);
      assert(
        (client.innerApiCalls.updateTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
  });

  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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new protos.google.pubsub.v1.PublishResponse()
      );
      client.innerApiCalls.publish = stubSimpleCall(expectedResponse);
      const [response] = await client.publish(request);
      assert.deepStrictEqual(response, expectedResponse);
      assert(
        (client.innerApiCalls.publish as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.publish as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions /*, callback defined above */)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.innerApiCalls.publish = stubSimpleCall(undefined, expectedError);
      await assert.rejects(client.publish(request), expectedError);
      assert(
        (client.innerApiCalls.publish as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
  });

  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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new protos.google.pubsub.v1.Topic()
      );
      client.innerApiCalls.getTopic = stubSimpleCall(expectedResponse);
      const [response] = await client.getTopic(request);
      assert.deepStrictEqual(response, expectedResponse);
      assert(
        (client.innerApiCalls.getTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.getTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions /*, callback defined above */)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.innerApiCalls.getTopic = stubSimpleCall(undefined, expectedError);
      await assert.rejects(client.getTopic(request), expectedError);
      assert(
        (client.innerApiCalls.getTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
  });

  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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = generateSampleMessage(
        new protos.google.protobuf.Empty()
      );
      client.innerApiCalls.deleteTopic = stubSimpleCall(expectedResponse);
      const [response] = await client.deleteTopic(request);
      assert.deepStrictEqual(response, expectedResponse);
      assert(
        (client.innerApiCalls.deleteTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.deleteTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions /*, callback defined above */)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.innerApiCalls.deleteTopic = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.deleteTopic(request), expectedError);
      assert(
        (client.innerApiCalls.deleteTopic as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });
  });

  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()
      );
      request.project = '';
      const expectedHeaderRequestParams = 'project=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.listTopics as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.project = '';
      const expectedHeaderRequestParams = 'project=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.listTopics as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions /*, callback defined above */)
      );
    });

    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()
      );
      request.project = '';
      const expectedHeaderRequestParams = 'project=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.innerApiCalls.listTopics = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.listTopics(request), expectedError);
      assert(
        (client.innerApiCalls.listTopics as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.project = '';
      const expectedHeaderRequestParams = 'project=';
      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.strictEqual(
        (client.descriptors.page.listTopics.createStream as SinonStub).getCall(
          0
        ).args[2].otherArgs.headers['x-goog-request-params'],
        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()
      );
      request.project = '';
      const expectedHeaderRequestParams = 'project=';
      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.strictEqual(
        (client.descriptors.page.listTopics.createStream as SinonStub).getCall(
          0
        ).args[2].otherArgs.headers['x-goog-request-params'],
        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()
      );
      request.project = '';
      const expectedHeaderRequestParams = 'project=';
      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.strictEqual(
        (client.descriptors.page.listTopics.asyncIterate as SinonStub).getCall(
          0
        ).args[2].otherArgs.headers['x-goog-request-params'],
        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()
      );
      request.project = '';
      const expectedHeaderRequestParams = 'project=';
      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.strictEqual(
        (client.descriptors.page.listTopics.asyncIterate as SinonStub).getCall(
          0
        ).args[2].otherArgs.headers['x-goog-request-params'],
        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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = [new String(), new String(), new String()];
      client.innerApiCalls.listTopicSubscriptions = stubSimpleCall(
        expectedResponse
      );
      const [response] = await client.listTopicSubscriptions(request);
      assert.deepStrictEqual(response, expectedResponse);
      assert(
        (client.innerApiCalls.listTopicSubscriptions as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.listTopicSubscriptions as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions /*, callback defined above */)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.innerApiCalls.listTopicSubscriptions = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(
        client.listTopicSubscriptions(request),
        expectedError
      );
      assert(
        (client.innerApiCalls.listTopicSubscriptions as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      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.strictEqual(
        (client.descriptors.page.listTopicSubscriptions
          .createStream as SinonStub).getCall(0).args[2].otherArgs.headers[
          'x-goog-request-params'
        ],
        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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      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.strictEqual(
        (client.descriptors.page.listTopicSubscriptions
          .createStream as SinonStub).getCall(0).args[2].otherArgs.headers[
          'x-goog-request-params'
        ],
        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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      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.strictEqual(
        (client.descriptors.page.listTopicSubscriptions
          .asyncIterate as SinonStub).getCall(0).args[2].otherArgs.headers[
          'x-goog-request-params'
        ],
        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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      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.strictEqual(
        (client.descriptors.page.listTopicSubscriptions
          .asyncIterate as SinonStub).getCall(0).args[2].otherArgs.headers[
          'x-goog-request-params'
        ],
        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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedResponse = [new String(), new String(), new String()];
      client.innerApiCalls.listTopicSnapshots = stubSimpleCall(
        expectedResponse
      );
      const [response] = await client.listTopicSnapshots(request);
      assert.deepStrictEqual(response, expectedResponse);
      assert(
        (client.innerApiCalls.listTopicSnapshots as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      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);
      assert(
        (client.innerApiCalls.listTopicSnapshots as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions /*, callback defined above */)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      const expectedOptions = {
        otherArgs: {
          headers: {
            'x-goog-request-params': expectedHeaderRequestParams,
          },
        },
      };
      const expectedError = new Error('expected');
      client.innerApiCalls.listTopicSnapshots = stubSimpleCall(
        undefined,
        expectedError
      );
      await assert.rejects(client.listTopicSnapshots(request), expectedError);
      assert(
        (client.innerApiCalls.listTopicSnapshots as SinonStub)
          .getCall(0)
          .calledWith(request, expectedOptions, undefined)
      );
    });

    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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      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.strictEqual(
        (client.descriptors.page.listTopicSnapshots
          .createStream as SinonStub).getCall(0).args[2].otherArgs.headers[
          'x-goog-request-params'
        ],
        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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      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.strictEqual(
        (client.descriptors.page.listTopicSnapshots
          .createStream as SinonStub).getCall(0).args[2].otherArgs.headers[
          'x-goog-request-params'
        ],
        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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      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.strictEqual(
        (client.descriptors.page.listTopicSnapshots
          .asyncIterate as SinonStub).getCall(0).args[2].otherArgs.headers[
          'x-goog-request-params'
        ],
        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()
      );
      request.topic = '';
      const expectedHeaderRequestParams = 'topic=';
      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.strictEqual(
        (client.descriptors.page.listTopicSnapshots
          .asyncIterate as SinonStub).getCall(0).args[2].otherArgs.headers[
          'x-goog-request-params'
        ],
        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('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)
        );
      });
    });
  });
});