src/components/copresence/rpc/rpc_handler_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/copresence/rpc/rpc_handler.h"
   6
   7 #include <map>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/bind_helpers.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "components/copresence/handlers/directive_handler.h"
  15 #include "components/copresence/proto/data.pb.h"
  16 #include "components/copresence/proto/enums.pb.h"
  17 #include "components/copresence/proto/rpcs.pb.h"
  18 #include "net/http/http_status_code.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using google::protobuf::MessageLite;
  22 using google::protobuf::RepeatedPtrField;
  23
  24 namespace copresence {
  25
  26 namespace {
  27
  28 const char kChromeVersion[] = "Chrome Version String";
  29
  30 void CreateSubscribedMessage(const std::vector<std::string>& subscription_ids,
  31                              const std::string& message_string,
  32                              SubscribedMessage* message_proto) {
  33   message_proto->mutable_published_message()->set_payload(message_string);
  34   for (std::vector<std::string>::const_iterator subscription_id =
  35            subscription_ids.begin();
  36        subscription_id != subscription_ids.end();
  37        ++subscription_id) {
  38     message_proto->add_subscription_id(*subscription_id);
  39   }
  40 }
  41
  42 // TODO(ckehoe): Make DirectiveHandler an interface.
  43 class FakeDirectiveHandler : public DirectiveHandler {
  44  public:
  45   FakeDirectiveHandler() {}
  46   virtual ~FakeDirectiveHandler() {}
  47
  48   const std::vector<Directive>& added_directives() const {
  49     return added_directives_;
  50   }
  51
  52   virtual void Initialize(
  53       const AudioRecorder::DecodeSamplesCallback& decode_cb,
  54       const AudioDirectiveHandler::EncodeTokenCallback& encode_cb) OVERRIDE {}
  55
  56   virtual void AddDirective(const Directive& directive) OVERRIDE {
  57     added_directives_.push_back(directive);
  58   }
  59
  60   virtual void RemoveDirectives(const std::string& op_id) OVERRIDE {
  61     // TODO(ckehoe): Add a parallel implementation when prod has one.
  62   }
  63
  64  private:
  65   std::vector<Directive> added_directives_;
  66
  67   DISALLOW_COPY_AND_ASSIGN(FakeDirectiveHandler);
  68 };
  69
  70 }  // namespace
  71
  72 class RpcHandlerTest : public testing::Test, public CopresenceDelegate {
  73  public:
  74   RpcHandlerTest() : rpc_handler_(this), status_(SUCCESS), api_key_("API key") {
  75     rpc_handler_.server_post_callback_ =
  76         base::Bind(&RpcHandlerTest::CaptureHttpPost, base::Unretained(this));
  77     rpc_handler_.device_id_ = "Device ID";
  78   }
  79
  80   void CaptureHttpPost(
  81       net::URLRequestContextGetter* url_context_getter,
  82       const std::string& rpc_name,
  83       scoped_ptr<MessageLite> request_proto,
  84       const RpcHandler::PostCleanupCallback& response_callback) {
  85     rpc_name_ = rpc_name;
  86     request_proto_ = request_proto.Pass();
  87   }
  88
  89   void CaptureStatus(CopresenceStatus status) {
  90     status_ = status;
  91   }
  92
  93   inline const ReportRequest* GetReportSent() {
  94     return static_cast<ReportRequest*>(request_proto_.get());
  95   }
  96
  97   const TokenTechnology& GetTokenTechnologyFromReport() {
  98     return GetReportSent()->update_signals_request().state().capabilities()
  99         .token_technology(0);
 100   }
 101
 102   const RepeatedPtrField<PublishedMessage>& GetMessagesPublished() {
 103     return GetReportSent()->manage_messages_request().message_to_publish();
 104   }
 105
 106   const RepeatedPtrField<Subscription>& GetSubscriptionsSent() {
 107     return GetReportSent()->manage_subscriptions_request().subscription();
 108   }
 109
 110   void SetDeviceId(const std::string& device_id) {
 111     rpc_handler_.device_id_ = device_id;
 112   }
 113
 114   const std::string& GetDeviceId() {
 115     return rpc_handler_.device_id_;
 116   }
 117
 118   void AddInvalidToken(const std::string& token) {
 119     rpc_handler_.invalid_audio_token_cache_.Add(token, true);
 120   }
 121
 122   bool TokenIsInvalid(const std::string& token) {
 123     return rpc_handler_.invalid_audio_token_cache_.HasKey(token);
 124   }
 125
 126   FakeDirectiveHandler* InstallFakeDirectiveHandler() {
 127     FakeDirectiveHandler* handler = new FakeDirectiveHandler;
 128     rpc_handler_.directive_handler_.reset(handler);
 129     return handler;
 130   }
 131
 132   void InvokeReportResponseHandler(int status_code,
 133                                    const std::string& response) {
 134     rpc_handler_.ReportResponseHandler(
 135         base::Bind(&RpcHandlerTest::CaptureStatus, base::Unretained(this)),
 136         NULL,
 137         status_code,
 138         response);
 139   }
 140
 141   // CopresenceDelegate implementation
 142
 143   virtual void HandleMessages(
 144       const std::string& app_id,
 145       const std::string& subscription_id,
 146       const std::vector<Message>& messages) OVERRIDE {
 147     // app_id is unused for now, pending a server fix.
 148     messages_by_subscription_[subscription_id] = messages;
 149   }
 150
 151   virtual net::URLRequestContextGetter* GetRequestContext() const OVERRIDE {
 152     return NULL;
 153   }
 154
 155   virtual const std::string GetPlatformVersionString() const OVERRIDE {
 156     return kChromeVersion;
 157   }
 158
 159   virtual const std::string GetAPIKey() const OVERRIDE {
 160     return api_key_;
 161   }
 162
 163   virtual WhispernetClient* GetWhispernetClient() OVERRIDE {
 164     return NULL;
 165   }
 166
 167  protected:
 168   // For rpc_handler_.invalid_audio_token_cache_
 169   base::MessageLoop message_loop_;
 170
 171   RpcHandler rpc_handler_;
 172   CopresenceStatus status_;
 173   std::string api_key_;
 174
 175   std::string rpc_name_;
 176   scoped_ptr<MessageLite> request_proto_;
 177   std::map<std::string, std::vector<Message>> messages_by_subscription_;
 178 };
 179
 180 TEST_F(RpcHandlerTest, Initialize) {
 181   SetDeviceId("");
 182   rpc_handler_.Initialize(RpcHandler::SuccessCallback());
 183   RegisterDeviceRequest* registration =
 184       static_cast<RegisterDeviceRequest*>(request_proto_.get());
 185   Identity identity = registration->device_identifiers().registrant();
 186   EXPECT_EQ(CHROME, identity.type());
 187   EXPECT_FALSE(identity.chrome_id().empty());
 188 }
 189
 190 TEST_F(RpcHandlerTest, CreateRequestHeader) {
 191   SetDeviceId("CreateRequestHeader Device ID");
 192   rpc_handler_.SendReportRequest(make_scoped_ptr(new ReportRequest),
 193                                  "CreateRequestHeader App ID",
 194                                  StatusCallback());
 195   EXPECT_EQ(RpcHandler::kReportRequestRpcName, rpc_name_);
 196   ReportRequest* report = static_cast<ReportRequest*>(request_proto_.get());
 197   EXPECT_EQ(kChromeVersion,
 198             report->header().framework_version().version_name());
 199   EXPECT_EQ("CreateRequestHeader App ID",
 200             report->header().client_version().client());
 201   EXPECT_EQ("CreateRequestHeader Device ID",
 202             report->header().registered_device_id());
 203   EXPECT_EQ(CHROME_PLATFORM_TYPE,
 204             report->header().device_fingerprint().type());
 205 }
 206
 207 TEST_F(RpcHandlerTest, ReportTokens) {
 208   std::vector<AudioToken> test_tokens;
 209   test_tokens.push_back(AudioToken("token 1", false));
 210   test_tokens.push_back(AudioToken("token 2", true));
 211   test_tokens.push_back(AudioToken("token 3", false));
 212   AddInvalidToken("token 2");
 213
 214   rpc_handler_.ReportTokens(test_tokens);
 215   EXPECT_EQ(RpcHandler::kReportRequestRpcName, rpc_name_);
 216   ReportRequest* report = static_cast<ReportRequest*>(request_proto_.get());
 217   google::protobuf::RepeatedPtrField<TokenObservation> tokens_sent =
 218       report->update_signals_request().token_observation();
 219   ASSERT_EQ(2, tokens_sent.size());
 220   EXPECT_EQ("token 1", tokens_sent.Get(0).token_id());
 221   EXPECT_EQ("token 3", tokens_sent.Get(1).token_id());
 222 }
 223
 224 TEST_F(RpcHandlerTest, ReportResponseHandler) {
 225   // Fail on HTTP status != 200.
 226   ReportResponse empty_response;
 227   empty_response.mutable_header()->mutable_status()->set_code(OK);
 228   std::string serialized_empty_response;
 229   ASSERT_TRUE(empty_response.SerializeToString(&serialized_empty_response));
 230   status_ = SUCCESS;
 231   InvokeReportResponseHandler(net::HTTP_BAD_REQUEST, serialized_empty_response);
 232   EXPECT_EQ(FAIL, status_);
 233
 234   std::vector<std::string> subscription_1(1, "Subscription 1");
 235   std::vector<std::string> subscription_2(1, "Subscription 2");
 236   std::vector<std::string> both_subscriptions;
 237   both_subscriptions.push_back("Subscription 1");
 238   both_subscriptions.push_back("Subscription 2");
 239
 240   ReportResponse test_response;
 241   test_response.mutable_header()->mutable_status()->set_code(OK);
 242   UpdateSignalsResponse* update_response =
 243       test_response.mutable_update_signals_response();
 244   update_response->set_status(util::error::OK);
 245   Token* invalid_token = update_response->add_token();
 246   invalid_token->set_id("bad token");
 247   invalid_token->set_status(INVALID);
 248   CreateSubscribedMessage(
 249       subscription_1, "Message A", update_response->add_message());
 250   CreateSubscribedMessage(
 251       subscription_2, "Message B", update_response->add_message());
 252   CreateSubscribedMessage(
 253       both_subscriptions, "Message C", update_response->add_message());
 254   update_response->add_directive()->set_subscription_id("Subscription 1");
 255   update_response->add_directive()->set_subscription_id("Subscription 2");
 256
 257   messages_by_subscription_.clear();
 258   FakeDirectiveHandler* directive_handler = InstallFakeDirectiveHandler();
 259   std::string serialized_proto;
 260   ASSERT_TRUE(test_response.SerializeToString(&serialized_proto));
 261   status_ = FAIL;
 262   InvokeReportResponseHandler(net::HTTP_OK, serialized_proto);
 263
 264   EXPECT_EQ(SUCCESS, status_);
 265   EXPECT_TRUE(TokenIsInvalid("bad token"));
 266   ASSERT_EQ(2U, messages_by_subscription_.size());
 267   ASSERT_EQ(2U, messages_by_subscription_["Subscription 1"].size());
 268   ASSERT_EQ(2U, messages_by_subscription_["Subscription 2"].size());
 269   EXPECT_EQ("Message A",
 270             messages_by_subscription_["Subscription 1"][0].payload());
 271   EXPECT_EQ("Message B",
 272             messages_by_subscription_["Subscription 2"][0].payload());
 273   EXPECT_EQ("Message C",
 274             messages_by_subscription_["Subscription 1"][1].payload());
 275   EXPECT_EQ("Message C",
 276             messages_by_subscription_["Subscription 2"][1].payload());
 277
 278   ASSERT_EQ(2U, directive_handler->added_directives().size());
 279   EXPECT_EQ("Subscription 1",
 280             directive_handler->added_directives()[0].subscription_id());
 281   EXPECT_EQ("Subscription 2",
 282             directive_handler->added_directives()[1].subscription_id());
 283 }
 284
 285 }  // namespace copresence