RpcHandlerTest cleanup

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "components/copresence/handlers/directive_handler.h"
 #include "components/copresence/mediums/audio/audio_manager.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/proto/enums.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
+#include "components/copresence/test/stub_whispernet_client.h"
 #include "net/http/http_status_code.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using google::protobuf::MessageLite;
 using google::protobuf::RepeatedPtrField;
 
+using testing::ElementsAre;
 using testing::Property;
 using testing::SizeIs;
-using testing::ElementsAre;
 
 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);
   }
 }
 
 // TODO(ckehoe): Make DirectiveHandler an interface.
-class FakeDirectiveHandler : public DirectiveHandler {
+class FakeDirectiveHandler final : public DirectiveHandler {
  public:
   FakeDirectiveHandler() {}
-  ~FakeDirectiveHandler() override {}
 
-  const std::vector<Directive>& added_directives() const {
+  const std::vector<std::string>& added_directives() const {
     return added_directives_;
   }
 
-  void Start(WhispernetClient* whispernet_client) override {
+  void Start(WhispernetClient* /* whispernet_client */) override {
     NOTREACHED();
   }
 
   void AddDirective(const Directive& directive) override {
-    added_directives_.push_back(directive);
+    added_directives_.push_back(directive.subscription_id());
   }
 
   void RemoveDirectives(const std::string& op_id) override {
     NOTREACHED();
   }
 
   const std::string GetCurrentAudioToken(AudioType type) const override {
     return type == AUDIBLE ? "current audible" : "current inaudible";
   }
 
  private:
-  std::vector<Directive> added_directives_;
+  std::vector<std::string> added_directives_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDirectiveHandler);
 };
 
 }  // namespace
 
 class RpcHandlerTest : public testing::Test, public CopresenceDelegate {
  public:
-  RpcHandlerTest() : rpc_handler_(this, &directive_handler_), status_(SUCCESS) {
-    rpc_handler_.server_post_callback_ =
-        base::Bind(&RpcHandlerTest::CaptureHttpPost, base::Unretained(this));
-  }
+  RpcHandlerTest()
+    : whispernet_client_(new StubWhispernetClient),
+      rpc_handler_(this,
+                   &directive_handler_,
+                   base::Bind(&RpcHandlerTest::CaptureHttpPost,
+                              base::Unretained(this))),
+      status_(SUCCESS) {}
 
   // CopresenceDelegate implementation
 
-  void HandleMessages(const std::string& app_id,
+  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.
-    messages_by_subscription_[subscription_id] = messages;
+    for (const Message& message : messages) {
+      messages_by_subscription_[subscription_id].push_back(message.payload());
+    }
   }
 
   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 {
     return app_id + " API Key";
   }
 
   const std::string GetAuthToken() const override {
     return auth_token_;
   }
 
-  WhispernetClient* GetWhispernetClient() override { return nullptr; }
+  WhispernetClient* GetWhispernetClient() override {
+    return whispernet_client_.get();
+  }
 
  protected:
   void InvokeReportResponseHandler(int status_code,
                                    const std::string& response) {
     rpc_handler_.ReportResponseHandler(
         base::Bind(&RpcHandlerTest::CaptureStatus, base::Unretained(this)),
         nullptr,
         status_code,
         response);
   }
 
   void SetDeviceIdAndAuthToken(const std::string& device_id,
                                const std::string& auth_token) {
     rpc_handler_.device_id_by_auth_token_[auth_token] = device_id;
     auth_token_ = auth_token;
   }
 
   void AddInvalidToken(const std::string& token) {
     rpc_handler_.invalid_audio_token_cache_.Add(token, true);
   }
 
   bool TokenIsInvalid(const std::string& token) {
     return rpc_handler_.invalid_audio_token_cache_.HasKey(token);
   }
 
   // For rpc_handler_.invalid_audio_token_cache_
   base::MessageLoop message_loop_;
 
+  scoped_ptr<WhispernetClient> whispernet_client_;
   FakeDirectiveHandler directive_handler_;
   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<Message>> messages_by_subscription_;
+  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 106 matching lines @@
 
   messages_by_subscription_.clear();
   std::string serialized_proto;
   ASSERT_TRUE(test_response.SerializeToString(&serialized_proto));
   status_ = FAIL;
   InvokeReportResponseHandler(net::HTTP_OK, serialized_proto);
 
   EXPECT_EQ(SUCCESS, status_);
   EXPECT_TRUE(TokenIsInvalid("bad token"));
 
-  EXPECT_THAT(messages_by_subscription_["Subscription 1"], ElementsAre(
-      Property(&Message::payload, "Message A"),
-      Property(&Message::payload, "Message C")));
+  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(messages_by_subscription_["Subscription 2"], ElementsAre(
-      Property(&Message::payload, "Message B"),
-      Property(&Message::payload, "Message C")));
-
-  EXPECT_THAT(directive_handler_.added_directives(), ElementsAre(
-      Property(&Directive::subscription_id, "Subscription 1"),
-      Property(&Directive::subscription_id, "Subscription 2")));
+  EXPECT_THAT(directive_handler_.added_directives(),
+              ElementsAre("Subscription 1", "Subscription 2"));
 }
 
 }  // namespace copresence