src/xwalk/sysapps/common/common_api_browsertest.cc

   1 // Copyright (c) 2013 Intel Corporation. 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 "xwalk/sysapps/common/common_api_browsertest.h"
   6
   7 #include "base/path_service.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "content/public/test/browser_test.h"
  10 #include "content/public/test/browser_test_utils.h"
  11 #include "content/public/test/test_utils.h"
  12 #include "net/base/filename_util.h"
  13 #include "xwalk/extensions/browser/xwalk_extension_service.h"
  14 #include "xwalk/extensions/common/xwalk_extension.h"
  15 #include "xwalk/runtime/browser/runtime.h"
  16 #include "xwalk/sysapps/common/binding_object.h"
  17 #include "xwalk/test/base/in_process_browser_test.h"
  18 #include "xwalk/test/base/xwalk_test_utils.h"
  19
  20 using namespace xwalk::extensions;  // NOLINT
  21 using xwalk::sysapps::BindingObject;
  22
  23 SysAppsTestExtension::SysAppsTestExtension() {
  24   set_name("sysapps_common_test");
  25   set_javascript_api(
  26     "var v8tools = requireNative('v8tools');"
  27     ""
  28     "var internal = requireNative('internal');"
  29     "internal.setupInternalExtension(extension);"
  30     ""
  31     "var common = requireNative('sysapps_common');"
  32     "common.setupSysAppsCommon(internal, v8tools);"
  33     ""
  34     "var Promise = requireNative('sysapps_promise').Promise;"
  35     ""
  36     "var TestObject = function() {"
  37     "  common.BindingObject.call(this, common.getUniqueId());"
  38     "  common.EventTarget.call(this);"
  39     "  internal.postMessage('TestObjectConstructor', [this._id]);"
  40     "  this._addMethod('isTestEventActive', true);"
  41     "  this._addMethod('fireTestEvent', true);"
  42     "  this._addMethodWithPromise('makeFulfilledPromise', Promise);"
  43     "  this._addMethodWithPromise('makeRejectedPromise', Promise);"
  44     "  this._addEvent('test');"
  45     "  this._registerLifecycleTracker();"
  46     "};"
  47     ""
  48     "TestObject.prototype = new common.EventTargetPrototype();"
  49     ""
  50     "exports.v8tools = v8tools;"
  51     "exports.TestObject = TestObject;"
  52     "exports.hasObject = function(object_id, callback) {"
  53     "  internal.postMessage('hasObject', [object_id], callback);"
  54     "};");
  55 }
  56
  57 XWalkExtensionInstance* SysAppsTestExtension::CreateInstance() {
  58   return new SysAppsTestExtensionInstance();
  59 }
  60
  61 SysAppsTestExtensionInstance::SysAppsTestExtensionInstance()
  62   : handler_(this),
  63     store_(&handler_) {
  64   handler_.Register("TestObjectConstructor",
  65       base::Bind(&SysAppsTestExtensionInstance::OnSysAppsTestObjectContructor,
  66                  base::Unretained(this)));
  67   handler_.Register("hasObject",
  68       base::Bind(&SysAppsTestExtensionInstance::OnHasObject,
  69                  base::Unretained(this)));
  70 }
  71
  72 void SysAppsTestExtensionInstance::HandleMessage(scoped_ptr<base::Value> msg) {
  73   handler_.HandleMessage(msg.Pass());
  74 }
  75
  76 void SysAppsTestExtensionInstance::OnSysAppsTestObjectContructor(
  77     scoped_ptr<XWalkExtensionFunctionInfo> info) {
  78   std::string object_id;
  79   ASSERT_TRUE(info->arguments()->GetString(0, &object_id));
  80
  81   scoped_ptr<BindingObject> obj(new SysAppsTestObject);
  82   store_.AddBindingObject(object_id, obj.Pass());
  83 }
  84
  85 void SysAppsTestExtensionInstance::OnHasObject(
  86     scoped_ptr<XWalkExtensionFunctionInfo> info) {
  87   std::string object_id;
  88   ASSERT_TRUE(info->arguments()->GetString(0, &object_id));
  89
  90   scoped_ptr<base::ListValue> result(new base::ListValue());
  91   result->AppendBoolean(store_.HasObjectForTesting(object_id));
  92
  93   info->PostResult(result.Pass());
  94 }
  95
  96 SysAppsTestObject::SysAppsTestObject() : is_test_event_active_(false) {
  97   handler_.Register("isTestEventActive",
  98       base::Bind(&SysAppsTestObject::OnIsTestEventActive,
  99                  base::Unretained(this)));
 100   handler_.Register("fireTestEvent",
 101       base::Bind(&SysAppsTestObject::OnFireTestEvent,
 102                  base::Unretained(this)));
 103   handler_.Register("makeFulfilledPromise",
 104       base::Bind(&SysAppsTestObject::OnMakeFulfilledPromise,
 105                  base::Unretained(this)));
 106   handler_.Register("makeRejectedPromise",
 107       base::Bind(&SysAppsTestObject::OnMakeRejectedPromise,
 108                  base::Unretained(this)));
 109 }
 110
 111 void SysAppsTestObject::StartEvent(const std::string& type) {
 112   if (type == "test")
 113     is_test_event_active_ = true;
 114 }
 115
 116 void SysAppsTestObject::StopEvent(const std::string& type) {
 117   if (type == "test")
 118     is_test_event_active_ = false;
 119 }
 120
 121 void SysAppsTestObject::OnIsTestEventActive(
 122     scoped_ptr<XWalkExtensionFunctionInfo> info) {
 123   scoped_ptr<base::ListValue> result(new base::ListValue());
 124   result->AppendBoolean(is_test_event_active_);
 125
 126   info->PostResult(result.Pass());
 127 }
 128
 129 void SysAppsTestObject::OnFireTestEvent(
 130     scoped_ptr<XWalkExtensionFunctionInfo> info) {
 131   scoped_ptr<base::ListValue> data(new base::ListValue());
 132   data->AppendString("Lorem ipsum");
 133   DispatchEvent("test", data.Pass());
 134
 135   scoped_ptr<base::ListValue> result(new base::ListValue());
 136   info->PostResult(result.Pass());
 137 }
 138
 139 void SysAppsTestObject::OnMakeFulfilledPromise(
 140     scoped_ptr<XWalkExtensionFunctionInfo> info) {
 141   scoped_ptr<base::ListValue> result(new base::ListValue());
 142   result->AppendString("Lorem ipsum");  // Data.
 143   result->AppendString("");  // Error, empty == no error.
 144
 145   info->PostResult(result.Pass());
 146 }
 147
 148 void SysAppsTestObject::OnMakeRejectedPromise(
 149     scoped_ptr<XWalkExtensionFunctionInfo> info) {
 150   scoped_ptr<base::ListValue> result(new base::ListValue());
 151   result->AppendString("");  // Data.
 152   result->AppendString("Lorem ipsum");  // Error, !empty == error.
 153
 154   info->PostResult(result.Pass());
 155 }
 156
 157 class SysAppsCommonTest : public InProcessBrowserTest {
 158  public:
 159   virtual void SetUp() {
 160     XWalkExtensionService::SetCreateUIThreadExtensionsCallbackForTesting(
 161         base::Bind(&SysAppsCommonTest::CreateExtensions,
 162                    base::Unretained(this)));
 163     InProcessBrowserTest::SetUp();
 164   }
 165
 166   void CreateExtensions(XWalkExtensionVector* extensions) {
 167     extensions->push_back(new SysAppsTestExtension);
 168   }
 169 };
 170
 171 IN_PROC_BROWSER_TEST_F(SysAppsCommonTest, SysAppsCommon) {
 172   const base::string16 passString = base::ASCIIToUTF16("Pass");
 173   const base::string16 failString = base::ASCIIToUTF16("Fail");
 174
 175   content::RunAllPendingInMessageLoop();
 176   content::TitleWatcher title_watcher(runtime()->web_contents(), passString);
 177   title_watcher.AlsoWaitForTitle(failString);
 178
 179   base::FilePath test_file;
 180   PathService::Get(base::DIR_SOURCE_ROOT, &test_file);
 181   test_file = test_file
 182       .Append(FILE_PATH_LITERAL("xwalk"))
 183       .Append(FILE_PATH_LITERAL("sysapps"))
 184       .Append(FILE_PATH_LITERAL("common"))
 185       .Append(FILE_PATH_LITERAL("common_api_browsertest.html"));
 186
 187   xwalk_test_utils::NavigateToURL(runtime(), net::FilePathToFileURL(test_file));
 188   EXPECT_EQ(passString, title_watcher.WaitAndGetTitle());
 189 }