chrome/browser/chromeos/extensions/default_app_order_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. 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 "chrome/browser/chromeos/extensions/default_app_order.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/files/file_path.h"
  11 #include "base/files/file_util.h"
  12 #include "base/files/scoped_temp_dir.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/path_service.h"
  15 #include "base/test/scoped_path_override.h"
  16 #include "chrome/common/extensions/extension_constants.h"
  17 #include "chromeos/chromeos_paths.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 namespace chromeos {
  21
  22 namespace {
  23
  24 const base::FilePath::CharType kTestFile[] =
  25     FILE_PATH_LITERAL("test_default_app_order.json");
  26 }
  27
  28 class DefaultAppOrderTest : public testing::Test {
  29  public:
  30   DefaultAppOrderTest() {}
  31   virtual ~DefaultAppOrderTest() {}
  32
  33   // testing::Test overrides:
  34   virtual void SetUp() override {
  35     default_app_order::Get(&built_in_default_);
  36   }
  37   virtual void TearDown() override {
  38   }
  39
  40   bool IsBuiltInDefault(const std::vector<std::string>& apps) {
  41     if (apps.size() != built_in_default_.size())
  42       return false;
  43
  44     for (size_t i = 0; i < built_in_default_.size(); ++i) {
  45       if (built_in_default_[i] != apps[i])
  46         return false;
  47     }
  48
  49     return true;
  50   }
  51
  52   void SetExternalFile(const base::FilePath& path) {
  53     path_override_.reset(new base::ScopedPathOverride(
  54         chromeos::FILE_DEFAULT_APP_ORDER, path));
  55   }
  56
  57   void CreateExternalOrderFile(const std::string& content) {
  58     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  59     base::FilePath external_file = temp_dir_.path().Append(kTestFile);
  60     base::WriteFile(external_file, content.c_str(), content.size());
  61     SetExternalFile(external_file);
  62   }
  63
  64  private:
  65   std::vector<std::string> built_in_default_;
  66
  67   base::ScopedTempDir temp_dir_;
  68   scoped_ptr<base::ScopedPathOverride> path_override_;
  69
  70   DISALLOW_COPY_AND_ASSIGN(DefaultAppOrderTest);
  71 };
  72
  73 // Tests that the built-in default order is returned when ExternalLoader is not
  74 // created.
  75 TEST_F(DefaultAppOrderTest, BuiltInDefault) {
  76   std::vector<std::string> apps;
  77   default_app_order::Get(&apps);
  78   EXPECT_TRUE(IsBuiltInDefault(apps));
  79 }
  80
  81 // Tests external order file overrides built-in default.
  82 TEST_F(DefaultAppOrderTest, ExternalOrder) {
  83   const char kExternalOrder[] = "[\"app1\",\"app2\",\"app3\","
  84       "{ \"oem_apps_folder\": true,\"localized_content\": {"
  85       "    \"default\": {\"name\": \"OEM name\"}}}]";
  86   CreateExternalOrderFile(std::string(kExternalOrder));
  87
  88   scoped_ptr<default_app_order::ExternalLoader> loader(
  89       new default_app_order::ExternalLoader(false));
  90
  91   std::vector<std::string> apps;
  92   default_app_order::Get(&apps);
  93   EXPECT_EQ(3u, apps.size());
  94   EXPECT_EQ(std::string("app1"), apps[0]);
  95   EXPECT_EQ(std::string("app2"), apps[1]);
  96   EXPECT_EQ(std::string("app3"), apps[2]);
  97   EXPECT_EQ(std::string("OEM name"), default_app_order::GetOemAppsFolderName());
  98 }
  99
 100 // Tests none-existent order file gives built-in default.
 101 TEST_F(DefaultAppOrderTest, NoExternalFile) {
 102   base::ScopedTempDir scoped_tmp_dir;
 103   ASSERT_TRUE(scoped_tmp_dir.CreateUniqueTempDir());
 104
 105   base::FilePath none_existent_file =
 106       scoped_tmp_dir.path().AppendASCII("none_existent_file");
 107   ASSERT_FALSE(base::PathExists(none_existent_file));
 108   SetExternalFile(none_existent_file);
 109
 110   scoped_ptr<default_app_order::ExternalLoader> loader(
 111       new default_app_order::ExternalLoader(false));
 112
 113   std::vector<std::string> apps;
 114   default_app_order::Get(&apps);
 115   EXPECT_TRUE(IsBuiltInDefault(apps));
 116 }
 117
 118 // Tests bad json file gives built-in default.
 119 TEST_F(DefaultAppOrderTest, BadExternalFile) {
 120   const char kExternalOrder[] = "This is not a valid json.";
 121   CreateExternalOrderFile(std::string(kExternalOrder));
 122
 123   scoped_ptr<default_app_order::ExternalLoader> loader(
 124       new default_app_order::ExternalLoader(false));
 125
 126   std::vector<std::string> apps;
 127   default_app_order::Get(&apps);
 128   EXPECT_TRUE(IsBuiltInDefault(apps));
 129 }
 130
 131 TEST_F(DefaultAppOrderTest, ImportDefault) {
 132   const char kExternalOrder[] =
 133       "[\"app1\","
 134       "{ \"import_default_order\": true }, \"app2\"]";
 135   CreateExternalOrderFile(std::string(kExternalOrder));
 136
 137   scoped_ptr<default_app_order::ExternalLoader> loader(
 138       new default_app_order::ExternalLoader(false));
 139
 140   std::vector<std::string> apps;
 141   default_app_order::Get(&apps);
 142   EXPECT_EQ(default_app_order::kDefaultAppOrderCount + 2, apps.size());
 143   EXPECT_EQ(std::string("app1"), apps[0]);
 144   EXPECT_EQ(extension_misc::kChromeAppId, apps[1]);
 145   EXPECT_EQ(std::string("app2"),
 146             apps[default_app_order::kDefaultAppOrderCount + 1]);
 147 }
 148
 149 }  // namespace chromeos