Adding support for pre-sent messages

components/copresence/rpc/rpc_handler_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/copresence/rpc/rpc_handler.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 18 matching lines @@
 using testing::ElementsAre;
 using testing::Property;
 using testing::SizeIs;
 
 namespace copresence {
 
 namespace {
 
 const char kChromeVersion[] = "Chrome Version String";
 
-void CreateSubscribedMessage(const std::vector<std::string>& subscription_ids,
-                             const std::string& message_string,
-                             SubscribedMessage* message_proto) {
-  message_proto->mutable_published_message()->set_payload(message_string);
-  for (const std::string& subscription_id : subscription_ids) {
-    message_proto->add_subscription_id(subscription_id);
-  }
-}
+void IgnoreMessages(
+    const RepeatedPtrField<SubscribedMessage>& /* messages */) {}
 
 }  // namespace
 
 class RpcHandlerTest : public testing::Test, public CopresenceDelegate {
  public:
   RpcHandlerTest()
       : whispernet_client_(new StubWhispernetClient),
         // TODO(ckehoe): Use a FakeCopresenceState here
         // and test that it gets called correctly.
         state_(new CopresenceStateImpl),
         rpc_handler_(this,
                      state_.get(),
                      &directive_handler_,
                      nullptr,
+                     base::Bind(&IgnoreMessages),
                      base::Bind(&RpcHandlerTest::CaptureHttpPost,
                                 base::Unretained(this))),
         status_(SUCCESS) {}
 
   // CopresenceDelegate implementation
 
   void HandleMessages(const std::string& /* app_id */,
                       const std::string& subscription_id,
                       const std::vector<Message>& messages) override {
-    // app_id is unused for now, pending a server fix.
-    for (const Message& message : messages) {
-      messages_by_subscription_[subscription_id].push_back(message.payload());
-    }
+    NOTREACHED();
   }
 
-  void HandleStatusUpdate(CopresenceStatus /* status */) override {}
+  void HandleStatusUpdate(CopresenceStatus /* status */) override {
+    NOTREACHED();
+  }
 
   net::URLRequestContextGetter* GetRequestContext() const override {
     return nullptr;
   }
 
   const std::string GetPlatformVersionString() const override {
     return kChromeVersion;
   }
 
   const std::string GetAPIKey(const std::string& app_id) const override {
@@ skipping 73 matching lines @@
   scoped_ptr<WhispernetClient> whispernet_client_;
   FakeDirectiveHandler directive_handler_;
   scoped_ptr<CopresenceStateImpl> state_;
   RpcHandler rpc_handler_;
 
   CopresenceStatus status_;
   std::string rpc_name_;
   std::string api_key_;
   std::string auth_token_;
   ScopedVector<MessageLite> request_protos_;
-  std::map<std::string, std::vector<std::string>> messages_by_subscription_;
 
  private:
   void CaptureHttpPost(
       net::URLRequestContextGetter* url_context_getter,
       const std::string& rpc_name,
       const std::string& api_key,
       const std::string& auth_token,
       scoped_ptr<MessageLite> request_proto,
       const RpcHandler::PostCleanupCallback& response_callback) {
     rpc_name_ = rpc_name;
@@ skipping 132 matching lines @@
       Property(&TokenObservation::token_id, "current inaudible")));
 }
 
 TEST_F(RpcHandlerTest, ReportResponseHandler) {
   // Fail on HTTP status != 200.
   scoped_ptr<ReportResponse> response(new ReportResponse);
   status_ = SUCCESS;
   SendReportResponse(net::HTTP_BAD_REQUEST, response.Pass());
   EXPECT_EQ(FAIL, status_);
 
-  // Construct test subscriptions.
-  std::vector<std::string> subscription_1(1, "Subscription 1");
-  std::vector<std::string> subscription_2(1, "Subscription 2");
-  std::vector<std::string> both_subscriptions;
-  both_subscriptions.push_back("Subscription 1");
-  both_subscriptions.push_back("Subscription 2");
-
   // Construct a test ReportResponse.
   response.reset(new ReportResponse);
   response->mutable_header()->mutable_status()->set_code(OK);
   UpdateSignalsResponse* update_response =
       response->mutable_update_signals_response();
   update_response->set_status(util::error::OK);
   Token* invalid_token = update_response->add_token();
   invalid_token->set_id("bad token");
   invalid_token->set_status(INVALID);
-  CreateSubscribedMessage(
-      subscription_1, "Message A", update_response->add_message());
-  CreateSubscribedMessage(
-      subscription_2, "Message B", update_response->add_message());
-  CreateSubscribedMessage(
-      both_subscriptions, "Message C", update_response->add_message());
   update_response->add_directive()->set_subscription_id("Subscription 1");
   update_response->add_directive()->set_subscription_id("Subscription 2");
 
-  // Process it.
-  messages_by_subscription_.clear();
+  // Check processing.
   status_ = FAIL;
   SendReportResponse(net::HTTP_OK, response.Pass());
-
-  // Check processing.
   EXPECT_EQ(SUCCESS, status_);
   EXPECT_TRUE(TokenIsInvalid("bad token"));
-  EXPECT_THAT(messages_by_subscription_["Subscription 1"],
-              ElementsAre("Message A", "Message C"));
-  EXPECT_THAT(messages_by_subscription_["Subscription 2"],
-              ElementsAre("Message B", "Message C"));
   EXPECT_THAT(directive_handler_.added_directives(),
               ElementsAre("Subscription 1", "Subscription 2"));
 }
 
 }  // namespace copresence