src/chrome/browser/extensions/api/copresence/copresence_api_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 "base/json/json_writer.h"
   6 #include "base/values.h"
   7 #include "chrome/browser/extensions/api/copresence/copresence_api.h"
   8 #include "chrome/browser/extensions/extension_api_unittest.h"
   9 #include "chrome/browser/extensions/extension_function_test_utils.h"
  10 #include "components/copresence/proto/data.pb.h"
  11 #include "components/copresence/proto/rpcs.pb.h"
  12 #include "components/copresence/public/copresence_manager.h"
  13
  14 using base::ListValue;
  15 using copresence::AUDIO_CONFIGURATION_AUDIBLE;
  16 using copresence::AUDIO_CONFIGURATION_UNKNOWN;
  17 using copresence::BROADCAST_ONLY;
  18 using copresence::CopresenceDelegate;
  19 using copresence::CopresenceManager;
  20 using copresence::FAIL;
  21 using copresence::PublishedMessage;
  22 using copresence::ReportRequest;
  23 using copresence::SCAN_ONLY;
  24 using copresence::Subscription;
  25 using google::protobuf::RepeatedPtrField;
  26
  27 namespace test_utils = extension_function_test_utils;
  28
  29 namespace extensions {
  30
  31 using api::copresence::Message;
  32 using api::copresence::Operation;
  33 using api::copresence::PublishOperation;
  34 using api::copresence::Strategy;
  35 using api::copresence::SubscribeOperation;
  36 using api::copresence::UnpublishOperation;
  37 using api::copresence::UnsubscribeOperation;
  38
  39
  40 PublishOperation* CreatePublish(const std::string& id) {
  41   PublishOperation* publish = new PublishOperation;
  42
  43   publish->id = id;
  44   publish->time_to_live_millis.reset(new int(1000));
  45   publish->message.type = "joke";
  46   publish->message.payload = "Knock Knock!";
  47
  48   return publish;
  49 }
  50
  51 SubscribeOperation* CreateSubscribe(const std::string& id) {
  52   SubscribeOperation* subscribe = new SubscribeOperation;
  53
  54   subscribe->id = id;
  55   subscribe->time_to_live_millis.reset(new int(1000));
  56   subscribe->filter.type = "joke";
  57
  58   return subscribe;
  59 }
  60
  61 template <typename T>
  62 bool GetOnly(const RepeatedPtrField<T>& things, T* out) {
  63   if (things.size() != 1)
  64     return false;
  65
  66   *out = things.Get(0);
  67   return true;
  68 }
  69
  70 class MockCopresenceManager : public CopresenceManager {
  71  public:
  72   explicit MockCopresenceManager(CopresenceDelegate* delegate)
  73       : delegate_(delegate) {}
  74   ~MockCopresenceManager() override {}
  75
  76   void ExecuteReportRequest(
  77       const ReportRequest& request,
  78       const std::string& app_id,
  79       const std::string& /* auth_token */,
  80       const copresence::StatusCallback& status_callback) override {
  81     request_ = request;
  82     app_id_ = app_id;
  83     status_callback.Run(copresence::SUCCESS);
  84   }
  85
  86   CopresenceDelegate* delegate_;
  87
  88   ReportRequest request_;
  89   std::string app_id_;
  90 };
  91
  92 class CopresenceApiUnittest : public ExtensionApiUnittest {
  93  public:
  94   CopresenceApiUnittest() {}
  95   ~CopresenceApiUnittest() override {}
  96
  97   void SetUp() override {
  98     ExtensionApiUnittest::SetUp();
  99
 100     CopresenceService* service =
 101         CopresenceService::GetFactoryInstance()->Get(profile());
 102     copresence_manager_ = new MockCopresenceManager(service);
 103     service->set_manager_for_testing(
 104         make_scoped_ptr<CopresenceManager>(copresence_manager_));
 105   }
 106
 107   // Takes ownership of the operation_list.
 108   bool ExecuteOperations(ListValue* operation_list) {
 109     scoped_ptr<ListValue> args_list(new ListValue);
 110     args_list->Append(operation_list);
 111
 112     scoped_refptr<UIThreadExtensionFunction> function =
 113         new CopresenceExecuteFunction;
 114     function->set_extension(extension());
 115     function->set_browser_context(profile());
 116     function->set_has_callback(true);
 117     test_utils::RunFunction(
 118         function.get(), args_list.Pass(), browser(), test_utils::NONE);
 119     return function->GetResultList();
 120   }
 121
 122   bool ExecuteOperation(scoped_ptr<Operation> operation) {
 123     ListValue* operation_list = new ListValue;
 124     operation_list->Append(operation->ToValue().release());
 125     return ExecuteOperations(operation_list);
 126   }
 127
 128   const ReportRequest& request_sent() const {
 129     return copresence_manager_->request_;
 130   }
 131
 132   const std::string& app_id_sent() const {
 133     return copresence_manager_->app_id_;
 134   }
 135
 136   void clear_app_id() {
 137     copresence_manager_->app_id_ = "";
 138   }
 139
 140   CopresenceDelegate* delegate() {
 141     return copresence_manager_->delegate_;
 142   }
 143
 144  protected:
 145   MockCopresenceManager* copresence_manager_;
 146 };
 147
 148 TEST_F(CopresenceApiUnittest, Publish) {
 149   scoped_ptr<PublishOperation> publish(CreatePublish("pub"));
 150   publish->strategies.reset(new Strategy);
 151   publish->strategies->only_broadcast.reset(new bool(true));  // Default
 152
 153   scoped_ptr<Operation> operation(new Operation);
 154   operation->publish = publish.Pass();
 155
 156   clear_app_id();
 157   EXPECT_TRUE(ExecuteOperation(operation.Pass()));
 158   EXPECT_EQ(extension()->id(), app_id_sent());
 159
 160   PublishedMessage message;
 161   ASSERT_TRUE(GetOnly(
 162       request_sent().manage_messages_request().message_to_publish(), &message));
 163   EXPECT_EQ("pub", message.id());
 164   EXPECT_EQ(1000, message.access_policy().ttl_millis());
 165   EXPECT_EQ(copresence::NO_ACL_CHECK, message.access_policy().acl().acl_type());
 166   EXPECT_EQ("joke", message.message().type().type());
 167   EXPECT_EQ("Knock Knock!", message.message().payload());
 168   EXPECT_EQ(BROADCAST_ONLY,
 169             message.token_exchange_strategy().broadcast_scan_configuration());
 170   EXPECT_EQ(AUDIO_CONFIGURATION_UNKNOWN,
 171             message.token_exchange_strategy().audio_configuration());
 172 }
 173
 174 TEST_F(CopresenceApiUnittest, Subscribe) {
 175   scoped_ptr<SubscribeOperation> subscribe(CreateSubscribe("sub"));
 176   subscribe->strategies.reset(new Strategy);
 177   subscribe->strategies->only_broadcast.reset(new bool(true));  // Not default
 178   subscribe->strategies->audible.reset(new bool(true));  // Not default
 179
 180   scoped_ptr<Operation> operation(new Operation);
 181   operation->subscribe = subscribe.Pass();
 182
 183   clear_app_id();
 184   EXPECT_TRUE(ExecuteOperation(operation.Pass()));
 185   EXPECT_EQ(extension()->id(), app_id_sent());
 186
 187   Subscription subscription;
 188   ASSERT_TRUE(GetOnly(
 189       request_sent().manage_subscriptions_request().subscription(),
 190       &subscription));
 191   EXPECT_EQ("sub", subscription.id());
 192   EXPECT_EQ(1000, subscription.ttl_millis());
 193   EXPECT_EQ("joke", subscription.message_type().type());
 194   copresence::BroadcastScanConfiguration broadcast_scan =
 195       subscription.token_exchange_strategy().broadcast_scan_configuration();
 196   EXPECT_EQ(BROADCAST_ONLY, broadcast_scan);
 197   EXPECT_EQ(AUDIO_CONFIGURATION_AUDIBLE,
 198             subscription.token_exchange_strategy().audio_configuration());
 199 }
 200
 201 TEST_F(CopresenceApiUnittest, DefaultStrategies) {
 202   scoped_ptr<Operation> publish_operation(new Operation);
 203   publish_operation->publish.reset(CreatePublish("pub"));
 204
 205   scoped_ptr<Operation> subscribe_operation(new Operation);
 206   subscribe_operation->subscribe.reset(CreateSubscribe("sub"));
 207
 208   ListValue* operation_list = new ListValue;
 209   operation_list->Append(publish_operation->ToValue().release());
 210   operation_list->Append(subscribe_operation->ToValue().release());
 211   EXPECT_TRUE(ExecuteOperations(operation_list));
 212
 213   EXPECT_EQ(BROADCAST_ONLY,
 214             request_sent().manage_messages_request().message_to_publish(0)
 215                 .token_exchange_strategy().broadcast_scan_configuration());
 216   EXPECT_EQ(SCAN_ONLY,
 217             request_sent().manage_subscriptions_request().subscription(0)
 218                 .token_exchange_strategy().broadcast_scan_configuration());
 219 }
 220
 221 TEST_F(CopresenceApiUnittest, LowPowerStrategy) {
 222   scoped_ptr<Operation> subscribe_operation(new Operation);
 223   subscribe_operation->subscribe.reset(CreateSubscribe("sub"));
 224   subscribe_operation->subscribe->strategies.reset(new Strategy);
 225   subscribe_operation->subscribe->strategies->low_power.reset(new bool(true));
 226
 227   ListValue* operation_list = new ListValue;
 228   operation_list->Append(subscribe_operation->ToValue().release());
 229   EXPECT_TRUE(ExecuteOperations(operation_list));
 230
 231   EXPECT_EQ(copresence::BROADCAST_SCAN_CONFIGURATION_UNKNOWN,
 232             request_sent().manage_subscriptions_request().subscription(0)
 233                 .token_exchange_strategy().broadcast_scan_configuration());
 234 }
 235
 236 TEST_F(CopresenceApiUnittest, UnPubSub) {
 237   // First we need to create a publish and a subscribe to cancel.
 238   scoped_ptr<Operation> publish_operation(new Operation);
 239   scoped_ptr<Operation> subscribe_operation(new Operation);
 240   publish_operation->publish.reset(CreatePublish("pub"));
 241   subscribe_operation->subscribe.reset(CreateSubscribe("sub"));
 242   ListValue* operation_list = new ListValue;
 243   operation_list->Append(publish_operation->ToValue().release());
 244   operation_list->Append(subscribe_operation->ToValue().release());
 245   EXPECT_TRUE(ExecuteOperations(operation_list));
 246
 247   scoped_ptr<Operation> unpublish_operation(new Operation);
 248   unpublish_operation->unpublish.reset(new UnpublishOperation);
 249   unpublish_operation->unpublish->unpublish_id = "pub";
 250
 251   scoped_ptr<Operation> unsubscribe_operation(new Operation);
 252   unsubscribe_operation->unsubscribe.reset(new UnsubscribeOperation);
 253   unsubscribe_operation->unsubscribe->unsubscribe_id = "sub";
 254
 255   operation_list = new ListValue;
 256   operation_list->Append(unpublish_operation->ToValue().release());
 257   operation_list->Append(unsubscribe_operation->ToValue().release());
 258   EXPECT_TRUE(ExecuteOperations(operation_list));
 259
 260   std::string unpublish_id;
 261   ASSERT_TRUE(GetOnly(
 262       request_sent().manage_messages_request().id_to_unpublish(),
 263       &unpublish_id));
 264   EXPECT_EQ("pub", unpublish_id);
 265
 266   std::string unsubscribe_id;
 267   ASSERT_TRUE(GetOnly(
 268       request_sent().manage_subscriptions_request().id_to_unsubscribe(),
 269       &unsubscribe_id));
 270   EXPECT_EQ("sub", unsubscribe_id);
 271 }
 272
 273 TEST_F(CopresenceApiUnittest, BadId) {
 274   scoped_ptr<Operation> unsubscribe_operation(new Operation);
 275   unsubscribe_operation->unsubscribe.reset(new UnsubscribeOperation);
 276   unsubscribe_operation->unsubscribe->unsubscribe_id = "invalid id";
 277
 278   EXPECT_FALSE(ExecuteOperation(unsubscribe_operation.Pass()));
 279 }
 280
 281 TEST_F(CopresenceApiUnittest, MultipleOperations) {
 282   scoped_ptr<Operation> multi_operation(new Operation);
 283   multi_operation->publish.reset(CreatePublish("pub"));
 284   multi_operation->subscribe.reset(CreateSubscribe("sub"));
 285
 286   EXPECT_FALSE(ExecuteOperation(multi_operation.Pass()));
 287 }
 288
 289 }  // namespace extensions
 290
 291 // TODO(ckehoe): add tests for auth tokens and api key functionality