src/xwalk/application/common/application_storage_impl_unittest.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/application/common/application_storage_impl.h"
   6
   7 #include "base/file_util.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/json/json_file_value_serializer.h"
  10 #include "base/logging.h"
  11 #include "base/path_service.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "xwalk/application/common/application_storage.h"
  14 #include "xwalk/application/common/application_manifest_constants.h"
  15
  16 namespace xwalk {
  17
  18 namespace keys = application_manifest_keys;
  19
  20 namespace application {
  21
  22 class ApplicationStorageImplTest : public testing::Test {
  23  public:
  24   void TestInit() {
  25     base::FilePath tmp;
  26     ASSERT_TRUE(PathService::Get(base::DIR_TEMP, &tmp));
  27     ASSERT_TRUE(temp_dir_.CreateUniqueTempDirUnderPath(tmp));
  28     app_storage_impl_.reset(new ApplicationStorageImpl(temp_dir_.path()));
  29     ASSERT_TRUE(app_storage_impl_->Init());
  30   }
  31
  32  protected:
  33   base::ScopedTempDir temp_dir_;
  34   scoped_ptr<ApplicationStorageImpl> app_storage_impl_;
  35 };
  36
  37 TEST_F(ApplicationStorageImplTest, CreateDBFile) {
  38   TestInit();
  39   EXPECT_TRUE(base::PathExists(
  40       temp_dir_.path().Append(ApplicationStorageImpl::kDBFileName)));
  41 }
  42
  43 TEST_F(ApplicationStorageImplTest, DBInsert) {
  44   TestInit();
  45   base::DictionaryValue manifest;
  46   manifest.SetString(keys::kNameKey, "no name");
  47   manifest.SetString(keys::kXWalkVersionKey, "0");
  48   manifest.SetString("a", "b");
  49   std::string error;
  50   scoped_refptr<ApplicationData> application = ApplicationData::Create(
  51       base::FilePath(),
  52       Manifest::INVALID_TYPE,
  53       manifest,
  54       "",
  55       &error);
  56   ASSERT_TRUE(error.empty());
  57   ASSERT_TRUE(application);
  58   EXPECT_TRUE(app_storage_impl_->AddApplication(application.get(),
  59                                                 base::Time::FromDoubleT(0)));
  60   ApplicationData::ApplicationDataMap applications;
  61   ASSERT_TRUE(app_storage_impl_->GetInstalledApplications(applications));
  62   EXPECT_EQ(applications.size(), 1);
  63   EXPECT_TRUE(applications[application->ID()]);
  64 }
  65
  66 TEST_F(ApplicationStorageImplTest, DBDelete) {
  67   TestInit();
  68   base::DictionaryValue manifest;
  69   manifest.SetString(keys::kNameKey, "no name");
  70   manifest.SetString(keys::kXWalkVersionKey, "0");
  71   manifest.SetString("a", "b");
  72   std::string error;
  73   scoped_refptr<ApplicationData> application =
  74       ApplicationData::Create(base::FilePath(),
  75                               Manifest::INTERNAL,
  76                               manifest,
  77                               "",
  78                               &error);
  79   ASSERT_TRUE(error.empty());
  80   EXPECT_TRUE(application);
  81   EXPECT_TRUE(app_storage_impl_->AddApplication(application.get(),
  82                                                 base::Time::FromDoubleT(0)));
  83
  84   EXPECT_TRUE(app_storage_impl_->RemoveApplication(application->ID()));
  85   ApplicationData::ApplicationDataMap applications;
  86   ASSERT_TRUE(app_storage_impl_->GetInstalledApplications(applications));
  87   EXPECT_EQ(applications.size(), 0);
  88 }
  89
  90 TEST_F(ApplicationStorageImplTest, DBUpgradeToV1) {
  91   base::FilePath tmp;
  92   ASSERT_TRUE(PathService::Get(base::DIR_TEMP, &tmp));
  93   ASSERT_TRUE(temp_dir_.CreateUniqueTempDirUnderPath(tmp));
  94
  95   scoped_ptr<base::DictionaryValue> db_value(new base::DictionaryValue);
  96   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
  97   value->SetString("path", "");
  98   base::DictionaryValue* manifest = new base::DictionaryValue;
  99   manifest->SetString("a", "b");
 100   manifest->SetString(keys::kNameKey, "no name");
 101   manifest->SetString(keys::kXWalkVersionKey, "0");
 102   value->Set("manifest", manifest);
 103   value->SetDouble("install_time", 0);
 104   db_value->Set("test_id", value.release());
 105
 106   base::FilePath v0_db_file(
 107       temp_dir_.path().AppendASCII("applications_db"));
 108   JSONFileValueSerializer serializer(v0_db_file);
 109   ASSERT_TRUE(serializer.Serialize(*db_value.get()));
 110   ASSERT_TRUE(base::PathExists(v0_db_file));
 111
 112   app_storage_impl_.reset(new ApplicationStorageImpl(temp_dir_.path()));
 113   ASSERT_TRUE(app_storage_impl_->Init());
 114   ApplicationData::ApplicationDataMap applications;
 115   ASSERT_TRUE(app_storage_impl_->GetInstalledApplications(applications));
 116   ASSERT_FALSE(base::PathExists(v0_db_file));
 117   EXPECT_EQ(applications.size(), 1);
 118   EXPECT_TRUE(applications["test_id"]);
 119 }
 120
 121 TEST_F(ApplicationStorageImplTest, DBUpdate) {
 122   TestInit();
 123   base::DictionaryValue manifest;
 124   manifest.SetString(keys::kNameKey, "no name");
 125   manifest.SetString(keys::kXWalkVersionKey, "0");
 126   manifest.SetString("a", "b");
 127   std::string error;
 128   scoped_refptr<ApplicationData> application =
 129       ApplicationData::Create(base::FilePath(),
 130                               Manifest::INTERNAL,
 131                               manifest,
 132                               "",
 133                               &error);
 134   ASSERT_TRUE(error.empty());
 135   ASSERT_TRUE(application);
 136   EXPECT_TRUE(app_storage_impl_->AddApplication(application.get(),
 137                                                 base::Time::FromDoubleT(0)));
 138
 139   manifest.SetString("a", "c");
 140   scoped_refptr<ApplicationData> new_application =
 141       ApplicationData::Create(base::FilePath(),
 142                               Manifest::INTERNAL,
 143                               manifest,
 144                               "",
 145                               &error);
 146   ASSERT_TRUE(error.empty());
 147   ASSERT_TRUE(new_application);
 148   EXPECT_TRUE(app_storage_impl_->UpdateApplication(new_application.get(),
 149                                                    base::Time::FromDoubleT(0)));
 150   ApplicationData::ApplicationDataMap applications;
 151   ASSERT_TRUE(app_storage_impl_->GetInstalledApplications(applications));
 152   EXPECT_EQ(applications.size(), 1);
 153   scoped_refptr<ApplicationData> saved_application =
 154       applications[new_application->ID()];
 155   EXPECT_TRUE(saved_application);
 156
 157   EXPECT_TRUE(saved_application->GetManifest()->value()->Equals(
 158       new_application->GetManifest()->value()));
 159 }
 160
 161 TEST_F(ApplicationStorageImplTest, SetPermission) {
 162   TestInit();
 163   base::DictionaryValue manifest;
 164   manifest.SetString(keys::kNameKey, "no name");
 165   manifest.SetString(keys::kXWalkVersionKey, "0");
 166   manifest.SetString("a", "b");
 167   std::string error;
 168   scoped_refptr<ApplicationData> application =
 169       ApplicationData::Create(base::FilePath(),
 170                               Manifest::INTERNAL,
 171                               manifest,
 172                               "",
 173                               &error);
 174   ASSERT_TRUE(error.empty());
 175   ASSERT_TRUE(application);
 176   EXPECT_TRUE(application->SetPermission("permission", ALLOW));
 177   EXPECT_TRUE(app_storage_impl_->AddApplication(application.get(),
 178                                                 base::Time::FromDoubleT(0)));
 179
 180   ApplicationData::ApplicationDataMap applications;
 181   ASSERT_TRUE(app_storage_impl_->GetInstalledApplications(applications));
 182   EXPECT_EQ(applications.size(), 1);
 183   EXPECT_TRUE(applications[application->ID()]);
 184   EXPECT_TRUE(
 185       applications[application->ID()]->GetPermission("permission") == ALLOW);
 186 }
 187
 188 }  // namespace application
 189 }  // namespace xwalk