src/xwalk/application/browser/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/browser/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/browser/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(applications));
  30   }
  31
  32  protected:
  33   base::ScopedTempDir temp_dir_;
  34   scoped_ptr<ApplicationStorageImpl> app_storage_impl_;
  35   ApplicationData::ApplicationDataMap applications;
  36 };
  37
  38 TEST_F(ApplicationStorageImplTest, CreateDBFile) {
  39   TestInit();
  40   EXPECT_TRUE(base::PathExists(
  41       temp_dir_.path().Append(ApplicationStorageImpl::kDBFileName)));
  42 }
  43
  44 TEST_F(ApplicationStorageImplTest, DBInsert) {
  45   TestInit();
  46   base::DictionaryValue manifest;
  47   manifest.SetString(keys::kNameKey, "no name");
  48   manifest.SetString(keys::kVersionKey, "0");
  49   manifest.SetString("a", "b");
  50   std::string error;
  51   scoped_refptr<ApplicationData> application = ApplicationData::Create(
  52       base::FilePath(),
  53       Manifest::INVALID_TYPE,
  54       manifest,
  55       "",
  56       &error);
  57   ASSERT_TRUE(error.empty());
  58   ASSERT_TRUE(application);
  59   std::set<std::string> events;
  60   events.insert("test_events");
  61   application->SetEvents(events);
  62   EXPECT_TRUE(app_storage_impl_->AddApplication(application.get(),
  63                                                 base::Time::FromDoubleT(0)));
  64   ApplicationData::ApplicationDataMap applications;
  65   ASSERT_TRUE(app_storage_impl_->GetInstalledApplications(applications));
  66   EXPECT_EQ(applications.size(), 1);
  67   EXPECT_TRUE(applications[application->ID()]);
  68   EXPECT_EQ(applications[application->ID()]
  69             ->GetEvents().count("test_events"), 1);
  70 }
  71
  72 TEST_F(ApplicationStorageImplTest, DBDelete) {
  73   TestInit();
  74   base::DictionaryValue manifest;
  75   manifest.SetString(keys::kNameKey, "no name");
  76   manifest.SetString(keys::kVersionKey, "0");
  77   manifest.SetString("a", "b");
  78   std::string error;
  79   scoped_refptr<ApplicationData> application =
  80       ApplicationData::Create(base::FilePath(),
  81                               Manifest::INTERNAL,
  82                               manifest,
  83                               "",
  84                               &error);
  85   ASSERT_TRUE(error.empty());
  86   EXPECT_TRUE(application);
  87   EXPECT_TRUE(app_storage_impl_->AddApplication(application.get(),
  88                                                 base::Time::FromDoubleT(0)));
  89
  90   EXPECT_TRUE(app_storage_impl_->RemoveApplication(application->ID()));
  91   ApplicationData::ApplicationDataMap applications;
  92   ASSERT_TRUE(app_storage_impl_->GetInstalledApplications(applications));
  93   EXPECT_EQ(applications.size(), 0);
  94 }
  95
  96 TEST_F(ApplicationStorageImplTest, DBUpgradeToV1) {
  97   base::FilePath tmp;
  98   ASSERT_TRUE(PathService::Get(base::DIR_TEMP, &tmp));
  99   ASSERT_TRUE(temp_dir_.CreateUniqueTempDirUnderPath(tmp));
 100
 101   scoped_ptr<base::DictionaryValue> db_value(new base::DictionaryValue);
 102   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
 103   value->SetString("path", "");
 104   base::DictionaryValue* manifest = new base::DictionaryValue;
 105   manifest->SetString("a", "b");
 106   manifest->SetString(keys::kNameKey, "no name");
 107   manifest->SetString(keys::kVersionKey, "0");
 108   value->Set("manifest", manifest);
 109   value->SetDouble("install_time", 0);
 110   db_value->Set("test_id", value.release());
 111
 112   base::FilePath v0_db_file(
 113       temp_dir_.path().AppendASCII("applications_db"));
 114   JSONFileValueSerializer serializer(v0_db_file);
 115   ASSERT_TRUE(serializer.Serialize(*db_value.get()));
 116   ASSERT_TRUE(base::PathExists(v0_db_file));
 117
 118   app_storage_impl_.reset(new ApplicationStorageImpl(temp_dir_.path()));
 119   ApplicationData::ApplicationDataMap applications;
 120   ASSERT_TRUE(app_storage_impl_->Init(applications));
 121   ASSERT_FALSE(base::PathExists(v0_db_file));
 122   EXPECT_EQ(applications.size(), 1);
 123   EXPECT_TRUE(applications["test_id"]);
 124 }
 125
 126 TEST_F(ApplicationStorageImplTest, DBUpdate) {
 127   TestInit();
 128   base::DictionaryValue manifest;
 129   manifest.SetString(keys::kNameKey, "no name");
 130   manifest.SetString(keys::kVersionKey, "0");
 131   manifest.SetString("a", "b");
 132   std::string error;
 133   scoped_refptr<ApplicationData> application =
 134       ApplicationData::Create(base::FilePath(),
 135                               Manifest::INTERNAL,
 136                               manifest,
 137                               "",
 138                               &error);
 139   ASSERT_TRUE(error.empty());
 140   ASSERT_TRUE(application);
 141   EXPECT_TRUE(app_storage_impl_->AddApplication(application.get(),
 142                                                 base::Time::FromDoubleT(0)));
 143
 144   manifest.SetString("a", "c");
 145   scoped_refptr<ApplicationData> new_application =
 146       ApplicationData::Create(base::FilePath(),
 147                               Manifest::INTERNAL,
 148                               manifest,
 149                               "",
 150                               &error);
 151   ASSERT_TRUE(error.empty());
 152   ASSERT_TRUE(new_application);
 153   EXPECT_TRUE(app_storage_impl_->UpdateApplication(new_application.get(),
 154                                                    base::Time::FromDoubleT(0)));
 155   ApplicationData::ApplicationDataMap applications;
 156   ASSERT_TRUE(app_storage_impl_->GetInstalledApplications(applications));
 157   EXPECT_EQ(applications.size(), 1);
 158   scoped_refptr<ApplicationData> saved_application =
 159       applications[new_application->ID()];
 160   EXPECT_TRUE(saved_application);
 161
 162   EXPECT_TRUE(saved_application->GetManifest()->value()->Equals(
 163       new_application->GetManifest()->value()));
 164 }
 165
 166 }  // namespace application
 167 }  // namespace xwalk