Adding support for authenticated copresence calls

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 "net/http/http_status_code.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using google::protobuf::MessageLite;
@@ skipping 39 matching lines @@
  private:
   std::vector<Directive> added_directives_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDirectiveHandler);
 };
 
 }  // namespace
 
 class RpcHandlerTest : public testing::Test, public CopresenceDelegate {
  public:
-  RpcHandlerTest() : rpc_handler_(this), status_(SUCCESS), api_key_("API key") {
+  RpcHandlerTest() : rpc_handler_(this), status_(SUCCESS) {
     rpc_handler_.server_post_callback_ =
         base::Bind(&RpcHandlerTest::CaptureHttpPost, base::Unretained(this));
-    rpc_handler_.device_id_ = "Device ID";
   }
 
-  void CaptureHttpPost(
-      net::URLRequestContextGetter* url_context_getter,
-      const std::string& rpc_name,
-      scoped_ptr<MessageLite> request_proto,
-      const RpcHandler::PostCleanupCallback& response_callback) {
-    rpc_name_ = rpc_name;
-    request_proto_ = request_proto.Pass();
+  // 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.
+    messages_by_subscription_[subscription_id] = messages;
   }
 
-  void CaptureStatus(CopresenceStatus status) {
-    status_ = status;
+  net::URLRequestContextGetter* GetRequestContext() const override {
+    return NULL;
   }
 
-  inline const ReportRequest* GetReportSent() {
-    return static_cast<ReportRequest*>(request_proto_.get());
+  const std::string GetPlatformVersionString() const override {
+    return kChromeVersion;
   }
 
-  const TokenTechnology& GetTokenTechnologyFromReport() {
-    return GetReportSent()->update_signals_request().state().capabilities()
-        .token_technology(0);
+  const std::string GetAPIKey(const std::string& app_id) const override {
+    return app_id + " API Key";
   }
 
-  const RepeatedPtrField<PublishedMessage>& GetMessagesPublished() {
-    return GetReportSent()->manage_messages_request().message_to_publish();
+  const std::string GetAuthToken() const override {
+    return auth_token_;
   }
 
-  const RepeatedPtrField<Subscription>& GetSubscriptionsSent() {
-    return GetReportSent()->manage_subscriptions_request().subscription();
-  }
+  WhispernetClient* GetWhispernetClient() override { return NULL; }
 
-  void SetDeviceId(const std::string& device_id) {
-    rpc_handler_.device_id_ = device_id;
-  }
-
-  const std::string& GetDeviceId() {
-    return rpc_handler_.device_id_;
-  }
-
-  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);
-  }
-
-  FakeDirectiveHandler* InstallFakeDirectiveHandler() {
-    FakeDirectiveHandler* handler = new FakeDirectiveHandler;
-    rpc_handler_.directive_handler_.reset(handler);
-    return handler;
-  }
-
+ protected:
   void InvokeReportResponseHandler(int status_code,
                                    const std::string& response) {
     rpc_handler_.ReportResponseHandler(
         base::Bind(&RpcHandlerTest::CaptureStatus, base::Unretained(this)),
         NULL,
         status_code,
         response);
   }
 
-  // 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.
-    messages_by_subscription_[subscription_id] = messages;
+  FakeDirectiveHandler* InstallFakeDirectiveHandler() {
+    FakeDirectiveHandler* handler = new FakeDirectiveHandler;
+    rpc_handler_.directive_handler_.reset(handler);
+    return handler;
   }
 
-  net::URLRequestContextGetter* GetRequestContext() const override {
-    return NULL;
+  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;
   }
 
-  const std::string GetPlatformVersionString() const override {
-    return kChromeVersion;
+  void AddInvalidToken(const std::string& token) {
+    rpc_handler_.invalid_audio_token_cache_.Add(token, true);
   }
 
-  const std::string GetAPIKey() const override { return api_key_; }
+  bool TokenIsInvalid(const std::string& token) {
+    return rpc_handler_.invalid_audio_token_cache_.HasKey(token);
+  }
 
-  WhispernetClient* GetWhispernetClient() override { return NULL; }
-
- protected:
   // For rpc_handler_.invalid_audio_token_cache_
   base::MessageLoop message_loop_;
 
   RpcHandler rpc_handler_;
   CopresenceStatus status_;
-  std::string api_key_;
 
   std::string rpc_name_;
-  scoped_ptr<MessageLite> request_proto_;
+  std::string api_key_;
+  std::string auth_token_;
+  ScopedVector<MessageLite> request_protos_;
   std::map<std::string, std::vector<Message>> 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;
+    api_key_ = api_key;
+    auth_token_ = auth_token;
+    request_protos_.push_back(request_proto.release());
+  }
+
+  void CaptureStatus(CopresenceStatus status) {
+    status_ = status;
+  }
 };
 
-TEST_F(RpcHandlerTest, Initialize) {
-  SetDeviceId("");
-  rpc_handler_.Initialize(RpcHandler::SuccessCallback());
-  RegisterDeviceRequest* registration =
-      static_cast<RegisterDeviceRequest*>(request_proto_.get());
+TEST_F(RpcHandlerTest, RegisterDevice) {
+  EXPECT_FALSE(rpc_handler_.IsRegisteredForToken(""));
+  rpc_handler_.RegisterForToken("", RpcHandler::SuccessCallback());
+  EXPECT_EQ(1u, request_protos_.size());
+  const RegisterDeviceRequest* registration =
+      static_cast<RegisterDeviceRequest*>(request_protos_[0]);
   Identity identity = registration->device_identifiers().registrant();
   EXPECT_EQ(CHROME, identity.type());
   EXPECT_FALSE(identity.chrome_id().empty());
+
+  EXPECT_FALSE(rpc_handler_.IsRegisteredForToken("abc"));
+  rpc_handler_.RegisterForToken("abc", RpcHandler::SuccessCallback());
+  EXPECT_EQ(2u, request_protos_.size());
+  registration = static_cast<RegisterDeviceRequest*>(request_protos_[1]);
+  EXPECT_FALSE(registration->has_device_identifiers());
 }
 
+// TODO(ckehoe): Add a test for RegisterResponseHandler.
+
 TEST_F(RpcHandlerTest, CreateRequestHeader) {
-  SetDeviceId("CreateRequestHeader Device ID");
+  SetDeviceIdAndAuthToken("CreateRequestHeader Device ID",
+                          "CreateRequestHeader Auth Token");
   rpc_handler_.SendReportRequest(make_scoped_ptr(new ReportRequest),
-                                 "CreateRequestHeader App ID",
+                                 "CreateRequestHeader App",
+                                 "CreateRequestHeader Auth Token",
                                  StatusCallback());
   EXPECT_EQ(RpcHandler::kReportRequestRpcName, rpc_name_);
-  ReportRequest* report = static_cast<ReportRequest*>(request_proto_.get());
+  EXPECT_EQ("CreateRequestHeader App API Key", api_key_);
+  EXPECT_EQ("CreateRequestHeader Auth Token", auth_token_);
+  const ReportRequest* report = static_cast<ReportRequest*>(request_protos_[0]);
   EXPECT_EQ(kChromeVersion,
             report->header().framework_version().version_name());
-  EXPECT_EQ("CreateRequestHeader App ID",
+  EXPECT_EQ("CreateRequestHeader App",
             report->header().client_version().client());
   EXPECT_EQ("CreateRequestHeader Device ID",
             report->header().registered_device_id());
   EXPECT_EQ(CHROME_PLATFORM_TYPE,
             report->header().device_fingerprint().type());
 }
 
 TEST_F(RpcHandlerTest, ReportTokens) {
   std::vector<AudioToken> test_tokens;
   test_tokens.push_back(AudioToken("token 1", false));
   test_tokens.push_back(AudioToken("token 2", true));
   test_tokens.push_back(AudioToken("token 3", false));
   AddInvalidToken("token 2");
 
+  SetDeviceIdAndAuthToken("ReportTokens Device 1", "");
+  SetDeviceIdAndAuthToken("ReportTokens Device 2", "ReportTokens Auth");
+
   rpc_handler_.ReportTokens(test_tokens);
   EXPECT_EQ(RpcHandler::kReportRequestRpcName, rpc_name_);
-  ReportRequest* report = static_cast<ReportRequest*>(request_proto_.get());
+  EXPECT_EQ(" API Key", api_key_);
+  EXPECT_EQ(2u, request_protos_.size());
+  const ReportRequest* report = static_cast<ReportRequest*>(request_protos_[0]);
   RepeatedPtrField<TokenObservation> tokens_sent =
       report->update_signals_request().token_observation();
   ASSERT_EQ(2, tokens_sent.size());
   EXPECT_EQ("token 1", tokens_sent.Get(0).token_id());
   EXPECT_EQ("token 3", tokens_sent.Get(1).token_id());
 }
 
 TEST_F(RpcHandlerTest, ReportResponseHandler) {
   // Fail on HTTP status != 200.
   ReportResponse empty_response;
@@ skipping 49 matching lines @@
             messages_by_subscription_["Subscription 2"][1].payload());
 
   ASSERT_EQ(2U, directive_handler->added_directives().size());
   EXPECT_EQ("Subscription 1",
             directive_handler->added_directives()[0].subscription_id());
   EXPECT_EQ("Subscription 2",
             directive_handler->added_directives()[1].subscription_id());
 }
 
 }  // namespace copresence