The Tor Browser: toolkit/components/contentprefs/tests/unit/test

     1 /*

     2  * Any copyright is dedicated to the Public Domain.

     3  * http://creativecommons.org/publicdomain/zero/1.0/

     4  */

     6 let cps = new ContentPrefInstance(null);

     8 function run_test() {

     9   testCacheWorks("test1.example.com", "test-pref1");

    10   testHasCachedPrefFunction("test2.example.com", "test-pref2");

    11   testSetCaches("test3.example.com", "test-pref3");

    12   testGetCaches("test4.example.com", "test-pref4");

    13   testRemovePrefs("test5.example.com", "test-pref5");

    14   testTypeConversions("test6.example.com", "test-pref6");

    15   testNonExistingPrefCachesAsUndefined("test7.example.com", "test-pref7");

    16   testCacheEviction("test8.example.com", "test-pref8");

    17 }

    19 function testCacheWorks(uri, prefName) {

    20   const CACHED_VALUE = 3;

    21   const NEW_VALUE = 5;

    23   cps.setPref(uri, prefName, CACHED_VALUE);

    24   do_check_eq(cps.getPref(uri, prefName), CACHED_VALUE);

    26   // Now change the value directly through the DB and check

    27   // that the cached value is different

    29   let groupId = selectValue("SELECT id FROM groups WHERE name = :param1", "id", uri);

    30   let settingId = selectValue("SELECT id FROM settings WHERE name = :param1", "id", prefName);

    31   let prefId = selectValue("SELECT id FROM prefs WHERE groupID = :param1 AND settingID = :param2",

    32                            "id", groupId, settingId);

    34   let stmt = cps.DBConnection.createStatement("UPDATE prefs SET value = :value WHERE id = :id");

    35   stmt.params.value = NEW_VALUE;

    36   stmt.params.id = prefId;

    37   stmt.execute();

    39   let dbValue = selectValue("SELECT value FROM prefs WHERE id = :param1", "value", prefId);

    40   let cacheValue = cps.getPref(uri, prefName);

    42   do_check_eq(dbValue, NEW_VALUE);

    43   do_check_eq(cacheValue, CACHED_VALUE);

    44   do_check_neq(cacheValue, dbValue);

    46   do_test_pending();

    47   cps.getPref(uri, prefName, function (value) {

    48     do_check_eq(dbValue, NEW_VALUE);

    49     do_check_eq(value, CACHED_VALUE);

    50     do_check_neq(value, dbValue);

    51     do_test_finished();

    52   });

    53 }

    55 function testHasCachedPrefFunction(uri, prefName) {

    56   const STARTING_VALUE = 3;

    57   const NEW_VALUE = 5;

    59   do_check_false(isCached(uri, prefName));

    61   cps.setPref(uri, prefName, STARTING_VALUE);

    63   let groupId = selectValue("SELECT id FROM groups WHERE name = :param1", "id", uri);

    64   let settingId = selectValue("SELECT id FROM settings WHERE name = :param1", "id", prefName);

    65   let prefId = selectValue("SELECT id FROM prefs WHERE groupID = :param1 AND settingID = :param2",

    66                        "id", groupId, settingId);

    68   do_check_neq(prefId, undefined);

    70   let originalValue = selectValue("SELECT value FROM prefs WHERE id = :param1", "value", prefId);

    71   do_check_eq(originalValue, STARTING_VALUE);

    73   let stmt = cps.DBConnection.createStatement("UPDATE prefs SET value = :value WHERE id = :id");

    74   stmt.params.value = NEW_VALUE;

    75   stmt.params.id = prefId;

    76   stmt.execute();

    78   let newValue = selectValue("SELECT value FROM prefs WHERE id = :param1", "value", prefId);

    79   do_check_eq(newValue, NEW_VALUE);

    81   let cachedValue = cps.getPref(uri, prefName);

    82   do_check_eq(cachedValue, STARTING_VALUE);

    83   do_check_true(isCached(uri, prefName));

    84 }

    86 function testSetCaches(uri, prefName) {

    87   cps.setPref(uri, prefName, 0);

    88   do_check_true(isCached(uri, prefName));

    89 }

    91 function testRemovePrefs(uri, prefName) {

    93   /* removePref */

    94   cps.setPref("www1." + uri, prefName, 1);

    96   do_check_eq(cps.getPref("www1." + uri, prefName), 1);

    98   cps.removePref("www1." + uri, prefName);

   100   do_check_false(isCached("www1." + uri, prefName));

   101   do_check_false(cps.hasPref("www1." + uri, prefName));

   102   do_check_neq(cps.getPref("www1." + uri, prefName), 1);

   104   /* removeGroupedPrefs */

   105   cps.setPref("www2." + uri, prefName, 2);

   106   cps.setPref("www3." + uri, prefName, 3);

   108   do_check_eq(cps.getPref("www2." + uri, prefName), 2);

   109   do_check_eq(cps.getPref("www3." + uri, prefName), 3);

   111   cps.removeGroupedPrefs();

   113   do_check_false(isCached("www2." + uri, prefName));

   114   do_check_false(isCached("www3." + uri, prefName));

   115   do_check_false(cps.hasPref("www2." + uri, prefName));

   116   do_check_false(cps.hasPref("www3." + uri, prefName));

   117   do_check_neq(cps.getPref("www2." + uri, prefName), 2);

   118   do_check_neq(cps.getPref("www3." + uri, prefName), 3);

   120   /* removePrefsByName */

   121   cps.setPref("www4." + uri, prefName, 4);

   122   cps.setPref("www5." + uri, prefName, 5);

   124   do_check_eq(cps.getPref("www4." + uri, prefName), 4);

   125   do_check_eq(cps.getPref("www5." + uri, prefName), 5);

   127   cps.removePrefsByName(prefName);

   129   do_check_false(isCached("www4." + uri, prefName));

   130   do_check_false(isCached("www5." + uri, prefName));

   131   do_check_false(cps.hasPref("www4." + uri, prefName));

   132   do_check_false(cps.hasPref("www5." + uri, prefName));

   133   do_check_neq(cps.getPref("www4." + uri, prefName), 4);

   134   do_check_neq(cps.getPref("www5." + uri, prefName), 5);

   135 }

   137 function testGetCaches(uri, prefName) {

   138   const VALUE = 4;

   140   let insertGroup = cps.DBConnection.createStatement("INSERT INTO groups (name) VALUES (:name)");

   141   insertGroup.params.name = uri;

   142   insertGroup.execute();

   143   let groupId = cps.DBConnection.lastInsertRowID;

   145   let insertSetting = cps.DBConnection.createStatement("INSERT INTO settings (name) VALUES (:name)");

   146   insertSetting.params.name = prefName;

   147   insertSetting.execute();

   148   let settingId = cps.DBConnection.lastInsertRowID;

   150   let insertPref = cps.DBConnection.createStatement("INSERT INTO prefs (groupID, settingID, value) " +

   151                                                     "VALUES (:groupId, :settingId, :value)");

   152   insertPref.params.groupId = groupId;

   153   insertPref.params.settingId = settingId;

   154   insertPref.params.value = VALUE;

   155   insertPref.execute();

   156   let prefId = cps.DBConnection.lastInsertRowID;

   158   let dbValue = selectValue("SELECT value FROM prefs WHERE id = :param1", "value", prefId);

   160   // First access from service should hit the DB

   161   let svcValue = cps.getPref(uri, prefName);

   163   // Second time should get the value from cache

   164   let cacheValue = cps.getPref(uri, prefName);

   166   do_check_eq(VALUE, dbValue);

   167   do_check_eq(VALUE, svcValue);

   168   do_check_eq(VALUE, cacheValue);

   170   do_check_true(isCached(uri, prefName));

   171 }

   173 function testTypeConversions(uri, prefName) {

   174   let value;

   176   cps.setPref(uri, prefName, true);

   177   value = cps.getPref(uri, prefName);

   178   do_check_true(value === 1);

   180   cps.setPref(uri, prefName, false);

   181   value = cps.getPref(uri, prefName);

   182   do_check_true(value === 0);

   184   cps.setPref(uri, prefName, null);

   185   value = cps.getPref(uri, prefName);

   186   do_check_true(value === null);

   188   cps.setPref(uri, prefName, undefined);

   189   value = cps.getPref(uri, prefName);

   190   do_check_true(value === null);

   191 }

   193 function testNonExistingPrefCachesAsUndefined(uri, prefName) {

   195   do_check_false(isCached(uri, prefName));

   197   // Cache the pref

   198   let value = cps.getPref(uri, prefName);

   199   do_check_true(value === undefined);

   201   do_check_true(isCached(uri, prefName));

   203   // Cached pref

   204   value = cps.getPref(uri, prefName);

   205   do_check_true(value === undefined);

   206 }

   208 function testCacheEviction(uri, prefName) {

   210   cps.setPref(uri, prefName, 5);

   211   do_check_eq(cps.getPref(uri, prefName), 5);

   212   do_check_true(isCached(uri, prefName));

   214   // try to evict value from cache by adding various other entries

   215   const ENTRIES_TO_ADD = 200;

   216   for (let i = 0; i < ENTRIES_TO_ADD; i++) {

   217     let uriToAdd = "www" + i + uri;

   218     cps.setPref(uriToAdd, prefName, 0);

   219   }

   221   do_check_false(isCached(uri, prefName));

   223 }

   225 function selectValue(stmt, columnName, param1, param2) {

   226   let stmt = cps.DBConnection.createStatement(stmt);

   227   if (param1)

   228     stmt.params.param1 = param1;

   230   if (param2)

   231     stmt.params.param2 = param2;

   233   stmt.executeStep();

   234   let val = stmt.row[columnName];

   235   stmt.reset();

   236   stmt.finalize();

   237   return val;

   238 }

   240 function isCached(uri, prefName) {

   241   return cps.hasCachedPref(uri, prefName);

   242 }

The Tor Browser / file revision

toolkit/components/contentprefs/tests/unit/test_contentPrefsCache.js@925c144e1f1f

toolkit/components/contentprefs/tests/unit/test_contentPrefsCache.js