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")); }