Tests for the Copresence API.

chrome/browser/extensions/api/copresence/copresence_apitest.cc

+// Copyright 2013 The Chromium Authors. All rights reserved.

[not at google - send to devlin, 2014/08/15 22:17:03]

2014.

And this file should probably be "unittest" not "apitest".

[Charlie, 2014/08/15 23:46:40]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/json/json_writer.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/api/copresence/copresence_api.h"
+#include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/extension_function_test_utils.h"
+#include "components/copresence/proto/data.pb.h"
+#include "components/copresence/proto/rpcs.pb.h"
+#include "components/copresence/public/copresence_manager.h"
+
+using base::ListValue;
+using copresence::BROADCAST_ONLY;
+using copresence::CopresenceManager;
+using copresence::CopresenceManagerDelegate;
+using copresence::FAIL;
+using copresence::PublishedMessage;
+using copresence::ReportRequest;
+using copresence::SCAN_ONLY;
+using copresence::Subscription;
+using google::protobuf::RepeatedPtrField;
+
+namespace test_utils = extension_function_test_utils;
+
+namespace extensions {
+
+using api::copresence::Message;
+using api::copresence::Operation;
+using api::copresence::PublishOperation;
+using api::copresence::Strategy;
+using api::copresence::SubscribeOperation;
+using api::copresence::UnpublishOperation;
+using api::copresence::UnsubscribeOperation;
+
+
+PublishOperation* CreatePublish(const std::string& id) {
+  PublishOperation* publish = new PublishOperation;
+
+  publish->id = id;
+  publish->time_to_live_millis.reset(new int(1000));
+  publish->message.type = "joke";
+  publish->message.payload = "Knock Knock";
+
+  return publish;
+}
+
+SubscribeOperation* CreateSubscribe(const std::string& id) {
+  SubscribeOperation* subscribe = new SubscribeOperation;
+
+  subscribe->id = id;
+  subscribe->time_to_live_millis.reset(new int(1000));
+  subscribe->filter.type = "joke";
+
+  return subscribe;
+}
+
+template <typename T>
+bool GetOnly(const RepeatedPtrField<T>& things, T* out) {
+  if (things.size() != 1)
+    return false;
+
+  *out = things.Get(0);
+  return true;
+}
+
+class MockCopresenceManager : public CopresenceManager {
+ public:
+  explicit MockCopresenceManager(CopresenceManagerDelegate* delegate)
+      : delegate_(delegate) {}
+  virtual ~MockCopresenceManager() {}
+
+  virtual void ExecuteReportRequest(
+      ReportRequest request,
+      const std::string& app_id,
+      const copresence::StatusCallback& status_callback) OVERRIDE {
+    request_ = request;
+    app_id_ = app_id;
+    status_callback.Run(copresence::SUCCESS);
+  }
+
+  CopresenceManagerDelegate* delegate_;
+
+  ReportRequest request_;
+  std::string app_id_;
+};
+
+class CopresenceApiTest : public ExtensionApiTest {

[not at google - send to devlin, 2014/08/15 22:17:03]

ApiTest is still a browser tests which requires spinning up a whole browser. You
shouldn't need any of this anymore since you're just exercising the Function
implementations directly.

Hopefully extension ExtensionApiUnittest should do it (see
chrome/browser/extensions/api/alarms/alarms_api_unittest.cc)

You'll lose SetUpOnMainThread, but hopefully that's for the better?

[Charlie, 2014/08/15 23:46:40]

Done. And they run much faster now! Thanks.

+ public:
+  CopresenceApiTest() {}
+  virtual ~CopresenceApiTest() {}
+
+  virtual void SetUpOnMainThread() OVERRIDE {
+    test_extension_ = test_utils::CreateEmptyExtension();
+
+    CopresenceService* service =
+        CopresenceService::GetFactoryInstance()->Get(profile());
+    copresence_manager_ = new MockCopresenceManager(service);
+    service->set_manager_for_testing(
+        make_scoped_ptr<CopresenceManager>(copresence_manager_));
+  }
+
+  // Takes ownership of the operation_list.
+  void ExecuteOperations(ListValue* operation_list, bool expect_error) {
+    ListValue args_list;
+    std::string json_args;
+    args_list.Append(operation_list);
+    base::JSONWriter::Write(&args_list, &json_args);
+
+    scoped_refptr<UIThreadExtensionFunction> function =
+        new CopresenceExecuteFunction;
+    function->set_extension(test_extension_.get());
+    function->set_browser_context(profile());
+    if (expect_error) {
+      test_utils::RunFunctionAndReturnError(
+          function.get(), json_args, browser());
+    } else {
+      test_utils::RunFunction(
+          function.get(), json_args, browser(), test_utils::NONE);
+    }
+  }
+
+  void ExecuteOperation(scoped_ptr<Operation> operation, bool expect_error) {
+    ListValue* operation_list = new ListValue;
+    operation_list->Append(operation->ToValue().release());
+    ExecuteOperations(operation_list, expect_error);
+  }
+
+  const ReportRequest& request_sent() const {
+    return copresence_manager_->request_;
+  }
+
+  const std::string& app_id_sent() const {
+    return copresence_manager_->app_id_;
+  }
+
+  void clear_app_id() {
+    copresence_manager_->app_id_ = "";
+  }
+
+  CopresenceManagerDelegate* delegate() {
+    return copresence_manager_->delegate_;
+  }
+
+ protected:
+  scoped_refptr<Extension> test_extension_;
+  MockCopresenceManager* copresence_manager_;
+};
+
+IN_PROC_BROWSER_TEST_F(CopresenceApiTest, Publish) {
+  scoped_ptr<PublishOperation> publish(CreatePublish("pub"));
+  publish->strategies.reset(new Strategy);
+  publish->strategies->only_broadcast.reset(new bool(true));  // Default
+
+  scoped_ptr<Operation> operation(new Operation);
+  operation->publish = publish.Pass();
+
+  clear_app_id();
+  ExecuteOperation(operation.Pass(), false);
+  EXPECT_EQ(test_extension_->id(), app_id_sent());
+
+  PublishedMessage message;
+  ASSERT_TRUE(GetOnly(
+      request_sent().manage_messages_request().message_to_publish(), &message));
+  EXPECT_EQ("pub", message.id());
+  EXPECT_EQ(1000, message.access_policy().ttl_millis());
+  EXPECT_EQ(copresence::NO_ACL_CHECK, message.access_policy().acl().acl_type());
+  EXPECT_EQ("joke", message.message().type().type());
+  EXPECT_EQ("Knock Knock!", message.message().payload());
+  EXPECT_EQ(BROADCAST_ONLY,
+            message.token_exchange_strategy().broadcast_scan_configuration());
+}
+
+IN_PROC_BROWSER_TEST_F(CopresenceApiTest, Subscribe) {
+  scoped_ptr<SubscribeOperation> subscribe(CreateSubscribe("sub"));
+  subscribe->strategies.reset(new Strategy);
+  subscribe->strategies->only_broadcast.reset(new bool(true));  // Not default
+
+  scoped_ptr<Operation> operation(new Operation);
+  operation->subscribe = subscribe.Pass();
+
+  clear_app_id();
+  ExecuteOperation(operation.Pass(), false);
+  EXPECT_EQ(test_extension_->id(), app_id_sent());
+
+  Subscription subscription;
+  ASSERT_TRUE(GetOnly(
+      request_sent().manage_subscriptions_request().subscription(),
+      &subscription));
+  EXPECT_EQ("sub", subscription.id());
+  EXPECT_EQ(1000, subscription.ttl_millis());
+  EXPECT_EQ("joke", subscription.message_type().type());
+  copresence::BroadcastScanConfiguration strategy =
+      subscription.token_exchange_strategy().broadcast_scan_configuration();
+  EXPECT_EQ(BROADCAST_ONLY, strategy);
+}
+
+IN_PROC_BROWSER_TEST_F(CopresenceApiTest, DefaultStrategies) {
+  scoped_ptr<Operation> publishOperation(new Operation);
+  publishOperation->publish.reset(CreatePublish("pub"));
+
+  scoped_ptr<Operation> subscribeOperation(new Operation);
+  subscribeOperation->subscribe.reset(CreateSubscribe("sub"));
+
+  ListValue* operation_list = new ListValue;
+  operation_list->Append(publishOperation->ToValue().release());
+  operation_list->Append(subscribeOperation->ToValue().release());
+  ExecuteOperations(operation_list, false);
+
+  EXPECT_EQ(BROADCAST_ONLY,
+            request_sent().manage_messages_request().message_to_publish(0)
+                .token_exchange_strategy().broadcast_scan_configuration());
+  EXPECT_EQ(SCAN_ONLY,
+            request_sent().manage_subscriptions_request().subscription(0)
+                .token_exchange_strategy().broadcast_scan_configuration());
+}
+
+IN_PROC_BROWSER_TEST_F(CopresenceApiTest, UnPubSub) {
+  // First we need to create a publish and a subscribe to cancel.
+  scoped_ptr<Operation> publishOperation(new Operation);
+  scoped_ptr<Operation> subscribeOperation(new Operation);
+  publishOperation->publish.reset(CreatePublish("pub"));
+  subscribeOperation->subscribe.reset(CreateSubscribe("sub"));
+  ListValue* operation_list = new ListValue;
+  operation_list->Append(publishOperation->ToValue().release());
+  operation_list->Append(subscribeOperation->ToValue().release());
+  ExecuteOperations(operation_list, false);
+
+  scoped_ptr<Operation> unpublishOperation(new Operation);
+  unpublishOperation->unpublish.reset(new UnpublishOperation);
+  unpublishOperation->unpublish->unpublish_id = "pub";
+
+  scoped_ptr<Operation> unsubscribeOperation(new Operation);
+  unsubscribeOperation->unsubscribe.reset(new UnsubscribeOperation);
+  unsubscribeOperation->unsubscribe->unsubscribe_id = "sub";
+
+  operation_list = new ListValue;
+  operation_list->Append(unpublishOperation->ToValue().release());
+  operation_list->Append(unsubscribeOperation->ToValue().release());
+  ExecuteOperations(operation_list, false);
+
+  std::string unpublish_id;
+  ASSERT_TRUE(GetOnly(
+      request_sent().manage_messages_request().id_to_unpublish(),
+      &unpublish_id));
+  EXPECT_EQ("pub", unpublish_id);
+
+  std::string unsubscribe_id;
+  ASSERT_TRUE(GetOnly(
+      request_sent().manage_subscriptions_request().id_to_unsubscribe(),
+      &unsubscribe_id));
+  EXPECT_EQ("sub", unsubscribe_id);
+}
+
+IN_PROC_BROWSER_TEST_F(CopresenceApiTest, BadId) {
+  scoped_ptr<Operation> unsubscribeOperation(new Operation);
+  unsubscribeOperation->unsubscribe.reset(new UnsubscribeOperation);
+  unsubscribeOperation->unsubscribe->unsubscribe_id = "invalid id";
+
+  ExecuteOperation(unsubscribeOperation.Pass(), true);
+}
+
+IN_PROC_BROWSER_TEST_F(CopresenceApiTest, MultipleOperations) {
+  scoped_ptr<Operation> multiOperation(new Operation);

[not at google - send to devlin, 2014/08/15 22:17:03]

multiOperation -> multi_operation.

There are other places in this file to make similar changes.

[Charlie, 2014/08/15 23:46:40]

Fixed the ones I could find, at least.

+  multiOperation->publish.reset(CreatePublish("pub"));
+  multiOperation->subscribe.reset(CreateSubscribe("sub"));
+
+  ExecuteOperation(multiOperation.Pass(), true);
+}
+
+}  // namespace extensions