Testing your Cloud Pub/Sub subscriber application with googlemock

This document describes how to test your own Cloud Pub/Sub application using the Cloud Pub/Sub C++ client library, Google Test and the and Google Test Mocking Framework.

Mocking a Successful Subscriber::Subscribe() call

First include the headers for the Cloud Pub/Sub Subscriber Client, the mocking class, and the Google Mock framework.

#include "google/cloud/pubsub/mocks/mock_publisher_connection.h"
#include "google/cloud/pubsub/publisher.h"
#include <gmock/gmock.h>

The example uses a number of aliases to save typing and improve readability:

using ::google::cloud::promise;
using ::google::cloud::pubsub_mocks::MockAckHandler;
using ::google::cloud::pubsub_mocks::MockSubscriberConnection;
using ::testing::Return;
using ::testing::UnorderedElementsAre;
namespace pubsub = ::google::cloud::pubsub;

Create a mocking object for google::cloud::pubsub::SubscriberConnection:

  auto mock = std::make_shared<MockSubscriberConnection>();

It is customary to first setup the expectations for your mock, and then write the rest of the code. In this case we need to create a mock pubsub::AckHandler and setup its expectation for each simulated message:

          auto mock_handler = std::make_unique<MockAckHandler>();
          EXPECT_CALL(*mock_handler, ack_id)
              .WillRepeatedly(Return("ack-id-" + std::to_string(i)));
          EXPECT_CALL(*mock_handler, ack).Times(1);

To simulate the background generation of messages we use a lambda:

  auto generator =
      [](promise<google::cloud::Status> promise,
         pubsub::SubscriberConnection::SubscribeParams const& params) {
        for (int i = 0; i != 3; ++i) {
          auto mock_handler = std::make_unique<MockAckHandler>();
          EXPECT_CALL(*mock_handler, ack_id)
              .WillRepeatedly(Return("ack-id-" + std::to_string(i)));
          EXPECT_CALL(*mock_handler, ack).Times(1);
 
          params.callback(pubsub::MessageBuilder{}
                              .SetData("message-" + std::to_string(i))
                              .Build(),
                          pubsub::AckHandler(std::move(mock_handler)));
        }
        // Close the stream with a successful error code
        promise.set_value({});
      };

This message generator is used in the SubscriberConnection expectations:

  EXPECT_CALL(*mock, Subscribe)
      .WillOnce([&](pubsub::SubscriberConnection::SubscribeParams params) {
        promise<google::cloud::Status> p;
        auto result = p.get_future();
        // start the generator in a separate thread.
        (void)std::async(std::launch::async, generator, std::move(p),
                         std::move(params));
        return result;
      });

With the expectations in place, create a google::cloud::pubsub::Subscriber object:

  pubsub::Subscriber subscriber(mock);

And then make calls on this client as usual:

  std::vector<pubsub::PubsubMessageDataType> payloads;
  auto handler = [&](pubsub::Message const& m, pubsub::AckHandler h) {
    payloads.push_back(m.data());
    std::move(h).ack();
  };
  auto session = subscriber.Subscribe(handler);

And then verify the results meet your expectations:

  EXPECT_TRUE(session.get().ok());
  EXPECT_THAT(payloads,
              UnorderedElementsAre("message-0", "message-1", "message-2"));

Full Listing

Finally we present the full code for this example:

 
#include "google/cloud/pubsub/mocks/mock_ack_handler.h"
#include "google/cloud/pubsub/mocks/mock_exactly_once_ack_handler.h"
#include "google/cloud/pubsub/mocks/mock_subscriber_connection.h"
#include "google/cloud/pubsub/subscriber.h"
#include <gmock/gmock.h>
#include <future>
 
namespace {
 
using ::google::cloud::promise;
using ::google::cloud::pubsub_mocks::MockAckHandler;
using ::google::cloud::pubsub_mocks::MockSubscriberConnection;
using ::testing::Return;
using ::testing::UnorderedElementsAre;
namespace pubsub = ::google::cloud::pubsub;
 
TEST(MockSubscribeExample, Subscribe) {
  auto mock = std::make_shared<MockSubscriberConnection>();
 
  // Generate 3 messages in a separate thread and then close the
  // subscription with success.
  auto generator =
      [](promise<google::cloud::Status> promise,
         pubsub::SubscriberConnection::SubscribeParams const& params) {
        for (int i = 0; i != 3; ++i) {
          auto mock_handler = std::make_unique<MockAckHandler>();
          EXPECT_CALL(*mock_handler, ack_id)
              .WillRepeatedly(Return("ack-id-" + std::to_string(i)));
          EXPECT_CALL(*mock_handler, ack).Times(1);
 
          params.callback(pubsub::MessageBuilder{}
                              .SetData("message-" + std::to_string(i))
                              .Build(),
                          pubsub::AckHandler(std::move(mock_handler)));
        }
        // Close the stream with a successful error code
        promise.set_value({});
      };
 
  EXPECT_CALL(*mock, Subscribe)
      .WillOnce([&](pubsub::SubscriberConnection::SubscribeParams params) {
        promise<google::cloud::Status> p;
        auto result = p.get_future();
        // start the generator in a separate thread.
        (void)std::async(std::launch::async, generator, std::move(p),
                         std::move(params));
        return result;
      });
 
  pubsub::Subscriber subscriber(mock);
 
  std::vector<pubsub::PubsubMessageDataType> payloads;
  auto handler = [&](pubsub::Message const& m, pubsub::AckHandler h) {
    payloads.push_back(m.data());
    std::move(h).ack();
  };
  auto session = subscriber.Subscribe(handler);
 
  EXPECT_TRUE(session.get().ok());
  EXPECT_THAT(payloads,
              UnorderedElementsAre("message-0", "message-1", "message-2"));
}
 
}  // namespace
 

Mocking with Exactly-Once Delivery

To mock exactly once delivery is very similar:

using ::google::cloud::Status;
using ::google::cloud::pubsub_mocks::MockExactlyOnceAckHandler;
using ::testing::ByMove;
 
TEST(MockSubscribeExample, ExactlyOnceSubscribe) {
  auto mock = std::make_shared<MockSubscriberConnection>();
 
  // Generate 3 messages in a separate thread and then close the
  // subscription with success.
  auto generator =
      [](promise<google::cloud::Status> promise,
         pubsub::SubscriberConnection::ExactlyOnceSubscribeParams const&
             params) {
        for (int i = 0; i != 3; ++i) {
          auto mock_handler = std::make_unique<MockExactlyOnceAckHandler>();
          EXPECT_CALL(*mock_handler, ack_id)
              .WillRepeatedly(Return("ack-id-" + std::to_string(i)));
          EXPECT_CALL(*mock_handler, ack)
              .WillOnce(Return(ByMove(make_ready_future(Status{}))));
 
          // Simulate callbacks
          params.callback(
              pubsub::MessageBuilder{}
                  .SetData("message-" + std::to_string(i))
                  .Build(),
              pubsub::ExactlyOnceAckHandler(std::move(mock_handler)));
        }
        // Close the stream with a successful error code
        promise.set_value({});
      };
 
  EXPECT_CALL(*mock, ExactlyOnceSubscribe)
      .WillOnce(
          [&](pubsub::SubscriberConnection::ExactlyOnceSubscribeParams params) {
            promise<google::cloud::Status> p;
            auto result = p.get_future();
            // start the generator in a separate thread.
            (void)std::async(std::launch::async, generator, std::move(p),
                             std::move(params));
            return result;
          });
 
  pubsub::Subscriber subscriber(mock);
 
  std::vector<pubsub::PubsubMessageDataType> payloads;
  auto callback = [&](pubsub::Message const& m,
                      pubsub::ExactlyOnceAckHandler h) {
    payloads.push_back(m.data());
    std::move(h).ack();
  };
  auto session = subscriber.Subscribe(callback);
 
  EXPECT_TRUE(session.get().ok());
  EXPECT_THAT(payloads,
              UnorderedElementsAre("message-0", "message-1", "message-2"));
}