Tests for the Copresence API.

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

Index: chrome/browser/extensions/api/copresence/copresence_apitest.cc
diff --git a/chrome/browser/extensions/api/copresence/copresence_apitest.cc b/chrome/browser/extensions/api/copresence/copresence_apitest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2b7f73cabe3b01e0acfd21e45342d1bfe4135701
--- /dev/null
+++ b/chrome/browser/extensions/api/copresence/copresence_apitest.cc
@@ -0,0 +1,291 @@
+// Copyright 2013 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 "base/json/json_writer.h"
+#include "base/path_service.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 "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/chrome_content_client.h"
+#include "chrome/common/extensions/chrome_extensions_client.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "components/copresence/proto/data.pb.h"
+#include "components/copresence/proto/rpcs.pb.h"
+#include "components/copresence/public/copresence_manager.h"
+#include "content/common/url_schemes.h"
+#include "content/public/common/content_client.h"
+#include "ui/base/resource/resource_bundle.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;
+
+const char kExtensionId[] = "my extension";
+
+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 {
+ public:
+  CopresenceApiTest() {
+    TestingBrowserProcess::CreateInstance();
+    CHECK(temp_dir_.CreateUniqueTempDir());
+    TestingBrowserProcess::GetGlobal()->SetProfileManager(
+        new ProfileManager(temp_dir_.path()));
+
+    ExtensionsClient::Set(ChromeExtensionsClient::GetInstance());
+    content::SetContentClient(&content_client_);
+    content::RegisterContentSchemes(false);
+
+    base::FilePath extensions_shell_and_test_pak_path;
+    CHECK(PathService::Get(base::DIR_MODULE,
+                           &extensions_shell_and_test_pak_path));
+    ui::ResourceBundle::InitSharedInstanceWithPakPath(
+        extensions_shell_and_test_pak_path.AppendASCII(
+            "extensions_shell_and_test.pak"));
+
+    test_extension_ = test_utils::CreateEmptyExtension(kExtensionId);
+
+    CopresenceService* service =
+        CopresenceService::GetFactoryInstance()->Get(profile());

[xiyuan, 2014/08/15 20:48:35]

You cannot do this in test's ctor. It is way too early. If you need profile, you
need to hook up with other test setup functions, e.g. SetUpOnMainThread.

https://code.google.com/p/chromium/codesearch#chromium/src/content/public/tes...

[Charlie, 2014/08/15 21:25:38]

Thanks Xiyuan! That was why I had a lot of extra init code.

+    copresence_manager_ = new MockCopresenceManager(service);
+    service->set_manager_for_testing(
+        make_scoped_ptr<CopresenceManager>(copresence_manager_));
+  }
+
+  virtual ~CopresenceApiTest() {}
+
+  // Takes ownership of the operation_list.
+  void ExecuteOperations(ListValue* operation_list, bool expect_error) const {
+    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)
+      const {
+    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_;
+
+ private:
+  ChromeContentClient content_client_;
+  base::ScopedTempDir temp_dir_;
+};
+
+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(kExtensionId, 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(kExtensionId, 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;
+  publishOperation->publish.reset(CreatePublish("pub2"));
+
+  scoped_ptr<Operation> subscribeOperation;
+  subscribeOperation->subscribe.reset(CreateSubscribe("sub2"));
+
+  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) {
+  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";
+
+  ListValue* 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> unpublishOperation(new Operation);
+  unpublishOperation->unpublish.reset(new UnpublishOperation);
+  unpublishOperation->unpublish->unpublish_id = "invalid id";
+
+  ExecuteOperation(unpublishOperation.Pass(), true);
+}
+
+IN_PROC_BROWSER_TEST_F(CopresenceApiTest, MultipleOperations) {
+  scoped_ptr<Operation> multiOperation;
+  multiOperation->publish.reset(CreatePublish("pub3"));
+  multiOperation->subscribe.reset(CreateSubscribe("sub3"));
+
+  ExecuteOperation(multiOperation.Pass(), true);
+}
+
+}  // namespace extensions