Home | History | Annotate | Download | only in settings 
      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 <map>
      6 #include <string>
      7 
      8 #include "base/bind.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/memory/weak_ptr.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/stl_util.h"
     13 #include "base/values.h"
     14 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
     15 #include "chrome/browser/chromeos/settings/cros_settings.h"
     16 #include "chrome/browser/chromeos/settings/device_settings_service.h"
     17 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
     18 #include "chrome/test/base/scoped_testing_local_state.h"
     19 #include "chrome/test/base/testing_browser_process.h"
     20 #include "chromeos/settings/cros_settings_names.h"
     21 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
     22 #include "content/public/test/test_browser_thread.h"
     23 #include "policy/proto/device_management_backend.pb.h"
     24 #include "testing/gtest/include/gtest/gtest.h"
     25 
     26 namespace em = enterprise_management;
     27 
     28 namespace chromeos {
     29 
     30 class CrosSettingsTest : public testing::Test {
     31  protected:
     32   CrosSettingsTest()
     33       : ui_thread_(content::BrowserThread::UI, &message_loop_),
     34         local_state_(TestingBrowserProcess::GetGlobal()),
     35         settings_(DeviceSettingsService::Get()),
     36         weak_factory_(this) {}
     37 
     38   virtual ~CrosSettingsTest() {}
     39 
     40   virtual void TearDown() OVERRIDE {
     41     ASSERT_TRUE(expected_props_.empty());
     42     STLDeleteValues(&expected_props_);
     43     expected_props_.clear();
     44   }
     45 
     46   void FetchPref(const std::string& pref) {
     47     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     48     if (expected_props_.find(pref) == expected_props_.end())
     49       return;
     50 
     51     if (CrosSettingsProvider::TRUSTED ==
     52             settings_.PrepareTrustedValues(
     53                 base::Bind(&CrosSettingsTest::FetchPref,
     54                            weak_factory_.GetWeakPtr(), pref))) {
     55       scoped_ptr<base::Value> expected_value(
     56           expected_props_.find(pref)->second);
     57       const base::Value* pref_value = settings_.GetPref(pref);
     58       if (expected_value.get()) {
     59         ASSERT_TRUE(pref_value);
     60         ASSERT_TRUE(expected_value->Equals(pref_value));
     61       } else {
     62         ASSERT_FALSE(pref_value);
     63       }
     64       expected_props_.erase(pref);
     65     }
     66   }
     67 
     68   void SetPref(const std::string& pref_name, const base::Value* value) {
     69     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     70     settings_.Set(pref_name, *value);
     71   }
     72 
     73   void AddExpectation(const std::string& pref_name, base::Value* value) {
     74     base::Value*& entry = expected_props_[pref_name];
     75     delete entry;
     76     entry = value;
     77   }
     78 
     79   void PrepareEmptyPolicy(em::PolicyData* policy) {
     80     // Prepare some policy blob.
     81     em::PolicyFetchResponse response;
     82     em::ChromeDeviceSettingsProto pol;
     83     policy->set_policy_type(policy::dm_protocol::kChromeDevicePolicyType);
     84     policy->set_username("me@owner");
     85     policy->set_policy_value(pol.SerializeAsString());
     86     // Wipe the signed settings store.
     87     response.set_policy_data(policy->SerializeAsString());
     88     response.set_policy_data_signature("false");
     89   }
     90 
     91   static bool IsWhitelisted(CrosSettings* cs, const std::string& username) {
     92     return cs->FindEmailInList(kAccountsPrefUsers, username, NULL);
     93   }
     94 
     95   base::MessageLoopForUI message_loop_;
     96   content::TestBrowserThread ui_thread_;
     97 
     98   ScopedTestingLocalState local_state_;
     99   ScopedDeviceSettingsTestHelper device_settings_test_helper_;
    100   CrosSettings settings_;
    101 
    102   base::WeakPtrFactory<CrosSettingsTest> weak_factory_;
    103 
    104   std::map<std::string, base::Value*> expected_props_;
    105 };
    106 
    107 TEST_F(CrosSettingsTest, SetPref) {
    108   // Change to something that is not the default.
    109   AddExpectation(kAccountsPrefAllowGuest, new base::FundamentalValue(false));
    110   SetPref(kAccountsPrefAllowGuest, expected_props_[kAccountsPrefAllowGuest]);
    111   FetchPref(kAccountsPrefAllowGuest);
    112   ASSERT_TRUE(expected_props_.empty());
    113 }
    114 
    115 TEST_F(CrosSettingsTest, GetPref) {
    116   // We didn't change the default so look for it.
    117   AddExpectation(kAccountsPrefAllowGuest, new base::FundamentalValue(true));
    118   FetchPref(kAccountsPrefAllowGuest);
    119 }
    120 
    121 TEST_F(CrosSettingsTest, SetWhitelist) {
    122   // Setting the whitelist should also switch the value of
    123   // kAccountsPrefAllowNewUser to false.
    124   base::ListValue whitelist;
    125   whitelist.Append(new base::StringValue("me@owner"));
    126   AddExpectation(kAccountsPrefAllowNewUser, new base::FundamentalValue(false));
    127   AddExpectation(kAccountsPrefUsers, whitelist.DeepCopy());
    128   SetPref(kAccountsPrefUsers, &whitelist);
    129   FetchPref(kAccountsPrefAllowNewUser);
    130   FetchPref(kAccountsPrefUsers);
    131 }
    132 
    133 TEST_F(CrosSettingsTest, SetWhitelistWithListOps) {
    134   base::ListValue* whitelist = new base::ListValue();
    135   base::StringValue hacky_user("h@xxor");
    136   whitelist->Append(hacky_user.DeepCopy());
    137   AddExpectation(kAccountsPrefAllowNewUser, new base::FundamentalValue(false));
    138   AddExpectation(kAccountsPrefUsers, whitelist);
    139   // Add some user to the whitelist.
    140   settings_.AppendToList(kAccountsPrefUsers, &hacky_user);
    141   FetchPref(kAccountsPrefAllowNewUser);
    142   FetchPref(kAccountsPrefUsers);
    143 }
    144 
    145 TEST_F(CrosSettingsTest, SetWhitelistWithListOps2) {
    146   base::ListValue whitelist;
    147   base::StringValue hacky_user("h@xxor");
    148   base::StringValue lamy_user("l@mer");
    149   whitelist.Append(hacky_user.DeepCopy());
    150   base::ListValue* expected_list = whitelist.DeepCopy();
    151   whitelist.Append(lamy_user.DeepCopy());
    152   AddExpectation(kAccountsPrefAllowNewUser, new base::FundamentalValue(false));
    153   AddExpectation(kAccountsPrefUsers, whitelist.DeepCopy());
    154   SetPref(kAccountsPrefUsers, &whitelist);
    155   FetchPref(kAccountsPrefAllowNewUser);
    156   FetchPref(kAccountsPrefUsers);
    157   ASSERT_TRUE(expected_props_.empty());
    158   // Now try to remove one element from that list.
    159   AddExpectation(kAccountsPrefUsers, expected_list);
    160   settings_.RemoveFromList(kAccountsPrefUsers, &lamy_user);
    161   FetchPref(kAccountsPrefAllowNewUser);
    162   FetchPref(kAccountsPrefUsers);
    163 }
    164 
    165 TEST_F(CrosSettingsTest, SetEmptyWhitelist) {
    166   // Setting the whitelist empty should switch the value of
    167   // kAccountsPrefAllowNewUser to true.
    168   base::ListValue whitelist;
    169   AddExpectation(kAccountsPrefAllowNewUser, new base::FundamentalValue(true));
    170   SetPref(kAccountsPrefUsers, &whitelist);
    171   FetchPref(kAccountsPrefAllowNewUser);
    172   FetchPref(kAccountsPrefUsers);
    173 }
    174 
    175 TEST_F(CrosSettingsTest, SetEmptyWhitelistAndNoNewUsers) {
    176   // Setting the whitelist empty and disallowing new users should result in no
    177   // new users allowed.
    178   base::ListValue whitelist;
    179   base::FundamentalValue disallow_new(false);
    180   AddExpectation(kAccountsPrefUsers, whitelist.DeepCopy());
    181   AddExpectation(kAccountsPrefAllowNewUser, new base::FundamentalValue(false));
    182   SetPref(kAccountsPrefUsers, &whitelist);
    183   SetPref(kAccountsPrefAllowNewUser, &disallow_new);
    184   FetchPref(kAccountsPrefAllowNewUser);
    185   FetchPref(kAccountsPrefUsers);
    186 }
    187 
    188 TEST_F(CrosSettingsTest, SetWhitelistAndNoNewUsers) {
    189   // Setting the whitelist should allow us to set kAccountsPrefAllowNewUser to
    190   // false (which is the implicit value too).
    191   base::ListValue whitelist;
    192   whitelist.Append(new base::StringValue("me@owner"));
    193   AddExpectation(kAccountsPrefUsers, whitelist.DeepCopy());
    194   AddExpectation(kAccountsPrefAllowNewUser, new base::FundamentalValue(false));
    195   SetPref(kAccountsPrefUsers, &whitelist);
    196   SetPref(kAccountsPrefAllowNewUser,
    197           expected_props_[kAccountsPrefAllowNewUser]);
    198   FetchPref(kAccountsPrefAllowNewUser);
    199   FetchPref(kAccountsPrefUsers);
    200 }
    201 
    202 TEST_F(CrosSettingsTest, SetAllowNewUsers) {
    203   // Setting kAccountsPrefAllowNewUser to true with no whitelist should be ok.
    204   AddExpectation(kAccountsPrefAllowNewUser, new base::FundamentalValue(true));
    205   SetPref(kAccountsPrefAllowNewUser,
    206           expected_props_[kAccountsPrefAllowNewUser]);
    207   FetchPref(kAccountsPrefAllowNewUser);
    208 }
    209 
    210 TEST_F(CrosSettingsTest, SetEphemeralUsersEnabled) {
    211   base::FundamentalValue ephemeral_users_enabled(true);
    212   AddExpectation(kAccountsPrefEphemeralUsersEnabled,
    213                  new base::FundamentalValue(true));
    214   SetPref(kAccountsPrefEphemeralUsersEnabled, &ephemeral_users_enabled);
    215   FetchPref(kAccountsPrefEphemeralUsersEnabled);
    216 }
    217 
    218 TEST_F(CrosSettingsTest, FindEmailInList) {
    219   base::ListValue list;
    220   list.Append(new base::StringValue("user (at) example.com"));
    221   list.Append(new base::StringValue("nodomain"));
    222   list.Append(new base::StringValue("with.dots (at) gmail.com"));
    223   list.Append(new base::StringValue("Upper (at) example.com"));
    224 
    225   CrosSettings* cs = &settings_;
    226   cs->Set(kAccountsPrefUsers, list);
    227 
    228   EXPECT_TRUE(IsWhitelisted(cs, "user (at) example.com"));
    229   EXPECT_FALSE(IsWhitelisted(cs, "us.er (at) example.com"));
    230   EXPECT_TRUE(IsWhitelisted(cs, "USER (at) example.com"));
    231   EXPECT_FALSE(IsWhitelisted(cs, "user"));
    232 
    233   EXPECT_TRUE(IsWhitelisted(cs, "nodomain"));
    234   EXPECT_TRUE(IsWhitelisted(cs, "nodomain (at) gmail.com"));
    235   EXPECT_TRUE(IsWhitelisted(cs, "no.domain (at) gmail.com"));
    236   EXPECT_TRUE(IsWhitelisted(cs, "NO.DOMAIN"));
    237 
    238   EXPECT_TRUE(IsWhitelisted(cs, "with.dots (at) gmail.com"));
    239   EXPECT_TRUE(IsWhitelisted(cs, "withdots (at) gmail.com"));
    240   EXPECT_TRUE(IsWhitelisted(cs, "WITH.DOTS (at) gmail.com"));
    241   EXPECT_TRUE(IsWhitelisted(cs, "WITHDOTS"));
    242 
    243   EXPECT_TRUE(IsWhitelisted(cs, "Upper (at) example.com"));
    244   EXPECT_FALSE(IsWhitelisted(cs, "U.pper (at) example.com"));
    245   EXPECT_FALSE(IsWhitelisted(cs, "Upper"));
    246   EXPECT_TRUE(IsWhitelisted(cs, "upper (at) example.com"));
    247 }
    248 
    249 TEST_F(CrosSettingsTest, FindEmailInListWildcard) {
    250   base::ListValue list;
    251   list.Append(new base::StringValue("user (at) example.com"));
    252   list.Append(new base::StringValue("*@example.com"));
    253 
    254   CrosSettings* cs = &settings_;
    255   cs->Set(kAccountsPrefUsers, list);
    256 
    257   bool wildcard_match = false;
    258   EXPECT_TRUE(cs->FindEmailInList(
    259       kAccountsPrefUsers, "test (at) example.com", &wildcard_match));
    260   EXPECT_TRUE(wildcard_match);
    261   EXPECT_TRUE(cs->FindEmailInList(
    262       kAccountsPrefUsers, "user (at) example.com", &wildcard_match));
    263   EXPECT_FALSE(wildcard_match);
    264   EXPECT_TRUE(cs->FindEmailInList(
    265       kAccountsPrefUsers, "*@example.com", &wildcard_match));
    266   EXPECT_TRUE(wildcard_match);
    267 }
    268 
    269 }  // namespace chromeos
    270