The Tor Browser: toolkit/components/places/tests/bookmarks/test

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* vim:set ts=2 sw=2 sts=2 et: */

     3 /* This Source Code Form is subject to the terms of the Mozilla Public

     4  * License, v. 2.0. If a copy of the MPL was not distributed with this

     5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     7 let bs = PlacesUtils.bookmarks;

     8 let hs = PlacesUtils.history;

     9 let anno = PlacesUtils.annotations;

    12 let bookmarksObserver = {

    13   onBeginUpdateBatch: function() {

    14     this._beginUpdateBatch = true;

    15   },

    16   onEndUpdateBatch: function() {

    17     this._endUpdateBatch = true;

    18   },

    19   onItemAdded: function(id, folder, index, itemType, uri, title, dateAdded,

    20                         guid) {

    21     this._itemAddedId = id;

    22     this._itemAddedParent = folder;

    23     this._itemAddedIndex = index;

    24     this._itemAddedURI = uri;

    25     this._itemAddedTitle = title;

    27     // Ensure that we've created a guid for this item.

    28     let stmt = DBConn().createStatement(

    29       "SELECT guid "

    30     + "FROM moz_bookmarks "

    31     + "WHERE id = :item_id "

    32     );

    33     stmt.params.item_id = id;

    34     do_check_true(stmt.executeStep());

    35     do_check_false(stmt.getIsNull(0));

    36     do_check_valid_places_guid(stmt.row.guid);

    37     do_check_eq(stmt.row.guid, guid);

    38     stmt.finalize();

    39   },

    40   onItemRemoved: function(id, folder, index, itemType) {

    41     this._itemRemovedId = id;

    42     this._itemRemovedFolder = folder;

    43     this._itemRemovedIndex = index;

    44   },

    45   onItemChanged: function(id, property, isAnnotationProperty, value,

    46                           lastModified, itemType) {

    47     this._itemChangedId = id;

    48     this._itemChangedProperty = property;

    49     this._itemChanged_isAnnotationProperty = isAnnotationProperty;

    50     this._itemChangedValue = value;

    51   },

    52   onItemVisited: function(id, visitID, time) {

    53     this._itemVisitedId = id;

    54     this._itemVisitedVistId = visitID;

    55     this._itemVisitedTime = time;

    56   },

    57   onItemMoved: function(id, oldParent, oldIndex, newParent, newIndex,

    58                         itemType) {

    59     this._itemMovedId = id

    60     this._itemMovedOldParent = oldParent;

    61     this._itemMovedOldIndex = oldIndex;

    62     this._itemMovedNewParent = newParent;

    63     this._itemMovedNewIndex = newIndex;

    64   },

    65   QueryInterface: XPCOMUtils.generateQI([

    66     Ci.nsINavBookmarkObserver,

    67   ])

    68 };

    71 // Get bookmarks menu folder id.

    72 let root = bs.bookmarksMenuFolder;

    73 // Index at which items should begin.

    74 let bmStartIndex = 0;

    77 function run_test() {

    78   run_next_test();

    79 }

    81 add_task(function test_bookmarks() {

    82   bs.addObserver(bookmarksObserver, false);

    84   // test special folders

    85   do_check_true(bs.placesRoot > 0);

    86   do_check_true(bs.bookmarksMenuFolder > 0);

    87   do_check_true(bs.tagsFolder > 0);

    88   do_check_true(bs.toolbarFolder > 0);

    89   do_check_true(bs.unfiledBookmarksFolder > 0);

    91   // test getFolderIdForItem() with bogus item id will throw

    92   try {

    93     let id = bs.getFolderIdForItem(0);

    94     do_throw("getFolderIdForItem accepted bad input");

    95   } catch(ex) {}

    97   // test getFolderIdForItem() with bogus item id will throw

    98   try {

    99     let id = bs.getFolderIdForItem(-1);

   100     do_throw("getFolderIdForItem accepted bad input");

   101   } catch(ex) {}

   103   // test root parentage

   104   do_check_eq(bs.getFolderIdForItem(bs.bookmarksMenuFolder), bs.placesRoot);

   105   do_check_eq(bs.getFolderIdForItem(bs.tagsFolder), bs.placesRoot);

   106   do_check_eq(bs.getFolderIdForItem(bs.toolbarFolder), bs.placesRoot);

   107   do_check_eq(bs.getFolderIdForItem(bs.unfiledBookmarksFolder), bs.placesRoot);

   109   // create a folder to hold all the tests

   110   // this makes the tests more tolerant of changes to default_places.html

   111   let testRoot = bs.createFolder(root, "places bookmarks xpcshell tests",

   112                                  bs.DEFAULT_INDEX);

   113   do_check_eq(bookmarksObserver._itemAddedId, testRoot);

   114   do_check_eq(bookmarksObserver._itemAddedParent, root);

   115   do_check_eq(bookmarksObserver._itemAddedIndex, bmStartIndex);

   116   do_check_eq(bookmarksObserver._itemAddedURI, null);

   117   let testStartIndex = 0;

   119   // test getItemIndex for folders

   120   do_check_eq(bs.getItemIndex(testRoot), bmStartIndex);

   122   // test getItemType for folders

   123   do_check_eq(bs.getItemType(testRoot), bs.TYPE_FOLDER);

   125   // insert a bookmark.

   126   // the time before we insert, in microseconds

   127   let beforeInsert = Date.now() * 1000;

   128   do_check_true(beforeInsert > 0);

   130   let newId = bs.insertBookmark(testRoot, uri("http://google.com/"),

   131                                 bs.DEFAULT_INDEX, "");

   132   do_check_eq(bookmarksObserver._itemAddedId, newId);

   133   do_check_eq(bookmarksObserver._itemAddedParent, testRoot);

   134   do_check_eq(bookmarksObserver._itemAddedIndex, testStartIndex);

   135   do_check_true(bookmarksObserver._itemAddedURI.equals(uri("http://google.com/")));

   136   do_check_eq(bs.getBookmarkURI(newId).spec, "http://google.com/");

   138   let dateAdded = bs.getItemDateAdded(newId);

   139   // dateAdded can equal beforeInsert

   140   do_check_true(is_time_ordered(beforeInsert, dateAdded));

   142   // after just inserting, modified should not be set

   143   let lastModified = bs.getItemLastModified(newId);

   144   do_check_eq(lastModified, dateAdded);

   146   // The time before we set the title, in microseconds.

   147   let beforeSetTitle = Date.now() * 1000;

   148   do_check_true(beforeSetTitle >= beforeInsert);

   150   // Workaround possible VM timers issues moving lastModified and dateAdded

   151   // to the past.

   152   bs.setItemLastModified(newId, --lastModified);

   153   bs.setItemDateAdded(newId, --dateAdded);

   155   // set bookmark title

   156   bs.setItemTitle(newId, "Google");

   157   do_check_eq(bookmarksObserver._itemChangedId, newId);

   158   do_check_eq(bookmarksObserver._itemChangedProperty, "title");

   159   do_check_eq(bookmarksObserver._itemChangedValue, "Google");

   161   // check that dateAdded hasn't changed

   162   let dateAdded2 = bs.getItemDateAdded(newId);

   163   do_check_eq(dateAdded2, dateAdded);

   165   // check lastModified after we set the title

   166   let lastModified2 = bs.getItemLastModified(newId);

   167   LOG("test setItemTitle");

   168   LOG("dateAdded = " + dateAdded);

   169   LOG("beforeSetTitle = " + beforeSetTitle);

   170   LOG("lastModified = " + lastModified);

   171   LOG("lastModified2 = " + lastModified2);

   172   do_check_true(is_time_ordered(lastModified, lastModified2));

   173   do_check_true(is_time_ordered(dateAdded, lastModified2));

   175   // get item title

   176   let title = bs.getItemTitle(newId);

   177   do_check_eq(title, "Google");

   179   // test getItemType for bookmarks

   180   do_check_eq(bs.getItemType(newId), bs.TYPE_BOOKMARK);

   182   // get item title bad input

   183   try {

   184     let title = bs.getItemTitle(-3);

   185     do_throw("getItemTitle accepted bad input");

   186   } catch(ex) {}

   188   // get the folder that the bookmark is in

   189   let folderId = bs.getFolderIdForItem(newId);

   190   do_check_eq(folderId, testRoot);

   192   // test getItemIndex for bookmarks

   193   do_check_eq(bs.getItemIndex(newId), testStartIndex);

   195   // create a folder at a specific index

   196   let workFolder = bs.createFolder(testRoot, "Work", 0);

   197   do_check_eq(bookmarksObserver._itemAddedId, workFolder);

   198   do_check_eq(bookmarksObserver._itemAddedParent, testRoot);

   199   do_check_eq(bookmarksObserver._itemAddedIndex, 0);

   200   do_check_eq(bookmarksObserver._itemAddedURI, null);

   202   do_check_eq(bs.getItemTitle(workFolder), "Work");

   203   bs.setItemTitle(workFolder, "Work #");

   204   do_check_eq(bs.getItemTitle(workFolder), "Work #");

   206   // add item into subfolder, specifying index

   207   let newId2 = bs.insertBookmark(workFolder,

   208                                  uri("http://developer.mozilla.org/"),

   209                                  0, "");

   210   do_check_eq(bookmarksObserver._itemAddedId, newId2);

   211   do_check_eq(bookmarksObserver._itemAddedParent, workFolder);

   212   do_check_eq(bookmarksObserver._itemAddedIndex, 0);

   214   // change item

   215   bs.setItemTitle(newId2, "DevMo");

   216   do_check_eq(bookmarksObserver._itemChangedProperty, "title");

   218   // insert item into subfolder

   219   let newId3 = bs.insertBookmark(workFolder,

   220                                  uri("http://msdn.microsoft.com/"),

   221                                  bs.DEFAULT_INDEX, "");

   222   do_check_eq(bookmarksObserver._itemAddedId, newId3);

   223   do_check_eq(bookmarksObserver._itemAddedParent, workFolder);

   224   do_check_eq(bookmarksObserver._itemAddedIndex, 1);

   226   // change item

   227   bs.setItemTitle(newId3, "MSDN");

   228   do_check_eq(bookmarksObserver._itemChangedProperty, "title");

   230   // remove item

   231   bs.removeItem(newId2);

   232   do_check_eq(bookmarksObserver._itemRemovedId, newId2);

   233   do_check_eq(bookmarksObserver._itemRemovedFolder, workFolder);

   234   do_check_eq(bookmarksObserver._itemRemovedIndex, 0);

   236   // insert item into subfolder

   237   let newId4 = bs.insertBookmark(workFolder,

   238                                  uri("http://developer.mozilla.org/"),

   239                                  bs.DEFAULT_INDEX, "");

   240   do_check_eq(bookmarksObserver._itemAddedId, newId4);

   241   do_check_eq(bookmarksObserver._itemAddedParent, workFolder);

   242   do_check_eq(bookmarksObserver._itemAddedIndex, 1);

   244   // create folder

   245   let homeFolder = bs.createFolder(testRoot, "Home", bs.DEFAULT_INDEX);

   246   do_check_eq(bookmarksObserver._itemAddedId, homeFolder);

   247   do_check_eq(bookmarksObserver._itemAddedParent, testRoot);

   248   do_check_eq(bookmarksObserver._itemAddedIndex, 2);

   250   // insert item

   251   let newId5 = bs.insertBookmark(homeFolder, uri("http://espn.com/"),

   252                                  bs.DEFAULT_INDEX, "");

   253   do_check_eq(bookmarksObserver._itemAddedId, newId5);

   254   do_check_eq(bookmarksObserver._itemAddedParent, homeFolder);

   255   do_check_eq(bookmarksObserver._itemAddedIndex, 0);

   257   // change item

   258   bs.setItemTitle(newId5, "ESPN");

   259   do_check_eq(bookmarksObserver._itemChangedId, newId5);

   260   do_check_eq(bookmarksObserver._itemChangedProperty, "title");

   262   // insert query item

   263   let uri6 = uri("place:domain=google.com&type="+

   264                  Ci.nsINavHistoryQueryOptions.RESULTS_AS_SITE_QUERY);

   265   let newId6 = bs.insertBookmark(testRoot, uri6, bs.DEFAULT_INDEX, "");

   266   do_check_eq(bookmarksObserver._itemAddedParent, testRoot);

   267   do_check_eq(bookmarksObserver._itemAddedIndex, 3);

   269   // change item

   270   bs.setItemTitle(newId6, "Google Sites");

   271   do_check_eq(bookmarksObserver._itemChangedProperty, "title");

   273   // test getIdForItemAt

   274   do_check_eq(bs.getIdForItemAt(testRoot, 0), workFolder);

   275   // wrong parent, should return -1

   276   do_check_eq(bs.getIdForItemAt(1337, 0), -1);

   277   // wrong index, should return -1

   278   do_check_eq(bs.getIdForItemAt(testRoot, 1337), -1);

   279   // wrong parent and index, should return -1

   280   do_check_eq(bs.getIdForItemAt(1337, 1337), -1);

   282   // move folder, appending, to different folder

   283   let oldParentCC = getChildCount(testRoot);

   284   bs.moveItem(workFolder, homeFolder, bs.DEFAULT_INDEX);

   285   do_check_eq(bookmarksObserver._itemMovedId, workFolder);

   286   do_check_eq(bookmarksObserver._itemMovedOldParent, testRoot);

   287   do_check_eq(bookmarksObserver._itemMovedOldIndex, 0);

   288   do_check_eq(bookmarksObserver._itemMovedNewParent, homeFolder);

   289   do_check_eq(bookmarksObserver._itemMovedNewIndex, 1);

   291   // test that the new index is properly stored

   292   do_check_eq(bs.getItemIndex(workFolder), 1);

   293   do_check_eq(bs.getFolderIdForItem(workFolder), homeFolder);

   295   // try to get index of the item from within the old parent folder

   296   // check that it has been really removed from there

   297   do_check_neq(bs.getIdForItemAt(testRoot, 0), workFolder);

   298   // check the last item from within the old parent folder

   299   do_check_neq(bs.getIdForItemAt(testRoot, -1), workFolder);

   300   // check the index of the item within the new parent folder

   301   do_check_eq(bs.getIdForItemAt(homeFolder, 1), workFolder);

   302   // try to get index of the last item within the new parent folder

   303   do_check_eq(bs.getIdForItemAt(homeFolder, -1), workFolder);

   304   // XXX expose FolderCount, and check that the old parent has one less child?

   305   do_check_eq(getChildCount(testRoot), oldParentCC-1);

   307   // move item, appending, to different folder

   308   bs.moveItem(newId5, testRoot, bs.DEFAULT_INDEX);

   309   do_check_eq(bookmarksObserver._itemMovedId, newId5);

   310   do_check_eq(bookmarksObserver._itemMovedOldParent, homeFolder);

   311   do_check_eq(bookmarksObserver._itemMovedOldIndex, 0);

   312   do_check_eq(bookmarksObserver._itemMovedNewParent, testRoot);

   313   do_check_eq(bookmarksObserver._itemMovedNewIndex, 3);

   315   // test get folder's index

   316   let tmpFolder = bs.createFolder(testRoot, "tmp", 2);

   317   do_check_eq(bs.getItemIndex(tmpFolder), 2);

   319   // test setKeywordForBookmark

   320   let kwTestItemId = bs.insertBookmark(testRoot, uri("http://keywordtest.com"),

   321                                        bs.DEFAULT_INDEX, "");

   322   try {

   323     let dateAdded = bs.getItemDateAdded(kwTestItemId);

   324     // after just inserting, modified should not be set

   325     let lastModified = bs.getItemLastModified(kwTestItemId);

   326     do_check_eq(lastModified, dateAdded);

   328     // Workaround possible VM timers issues moving lastModified and dateAdded

   329     // to the past.

   330     bs.setItemLastModified(kwTestItemId, --lastModified);

   331     bs.setItemDateAdded(kwTestItemId, --dateAdded);

   333     bs.setKeywordForBookmark(kwTestItemId, "bar");

   335     let lastModified2 = bs.getItemLastModified(kwTestItemId);

   336     LOG("test setKeywordForBookmark");

   337     LOG("dateAdded = " + dateAdded);

   338     LOG("lastModified = " + lastModified);

   339     LOG("lastModified2 = " + lastModified2);

   340     do_check_true(is_time_ordered(lastModified, lastModified2));

   341     do_check_true(is_time_ordered(dateAdded, lastModified2));

   342   } catch(ex) {

   343     do_throw("setKeywordForBookmark: " + ex);

   344   }

   346   let lastModified3 = bs.getItemLastModified(kwTestItemId);

   347   // test getKeywordForBookmark

   348   let k = bs.getKeywordForBookmark(kwTestItemId);

   349   do_check_eq("bar", k);

   351   // test getKeywordForURI

   352   let k = bs.getKeywordForURI(uri("http://keywordtest.com/"));

   353   do_check_eq("bar", k);

   355   // test getURIForKeyword

   356   let u = bs.getURIForKeyword("bar");

   357   do_check_eq("http://keywordtest.com/", u.spec);

   359   // test removeFolderChildren

   360   // 1) add/remove each child type (bookmark, separator, folder)

   361   let tmpFolder = bs.createFolder(testRoot, "removeFolderChildren",

   362                                   bs.DEFAULT_INDEX);

   363   bs.insertBookmark(tmpFolder, uri("http://foo9.com/"), bs.DEFAULT_INDEX, "");

   364   bs.createFolder(tmpFolder, "subfolder", bs.DEFAULT_INDEX);

   365   bs.insertSeparator(tmpFolder, bs.DEFAULT_INDEX);

   366   // 2) confirm that folder has 3 children

   367   let options = hs.getNewQueryOptions();

   368   let query = hs.getNewQuery();

   369   query.setFolders([tmpFolder], 1);

   370   try {

   371     let result = hs.executeQuery(query, options);

   372     let rootNode = result.root;

   373     rootNode.containerOpen = true;

   374     do_check_eq(rootNode.childCount, 3);

   375     rootNode.containerOpen = false;

   376   } catch(ex) {

   377     do_throw("test removeFolderChildren() - querying for children failed: " + ex);

   378   }

   379   // 3) remove all children

   380   bs.removeFolderChildren(tmpFolder);

   381   // 4) confirm that folder has 0 children

   382   try {

   383     result = hs.executeQuery(query, options);

   384     let rootNode = result.root;

   385     rootNode.containerOpen = true;

   386     do_check_eq(rootNode.childCount, 0);

   387     rootNode.containerOpen = false;

   388   } catch(ex) {

   389     do_throw("removeFolderChildren(): " + ex);

   390   }

   392   // XXX - test folderReadOnly

   394   // test bookmark id in query output

   395   try {

   396     let options = hs.getNewQueryOptions();

   397     let query = hs.getNewQuery();

   398     query.setFolders([testRoot], 1);

   399     let result = hs.executeQuery(query, options);

   400     let rootNode = result.root;

   401     rootNode.containerOpen = true;

   402     let cc = rootNode.childCount;

   403     LOG("bookmark itemId test: CC = " + cc);

   404     do_check_true(cc > 0);

   405     for (let i=0; i < cc; ++i) {

   406       let node = rootNode.getChild(i);

   407       if (node.type == node.RESULT_TYPE_FOLDER ||

   408           node.type == node.RESULT_TYPE_URI ||

   409           node.type == node.RESULT_TYPE_SEPARATOR ||

   410           node.type == node.RESULT_TYPE_QUERY) {

   411         do_check_true(node.itemId > 0);

   412       }

   413       else {

   414         do_check_eq(node.itemId, -1);

   415       }

   416     }

   417     rootNode.containerOpen = false;

   418   }

   419   catch(ex) {

   420     do_throw("bookmarks query: " + ex);

   421   }

   423   // test that multiple bookmarks with same URI show up right in bookmark

   424   // folder queries, todo: also to do for complex folder queries

   425   try {

   426     // test uri

   427     let mURI = uri("http://multiple.uris.in.query");

   429     let testFolder = bs.createFolder(testRoot, "test Folder", bs.DEFAULT_INDEX);

   430     // add 2 bookmarks

   431     bs.insertBookmark(testFolder, mURI, bs.DEFAULT_INDEX, "title 1");

   432     bs.insertBookmark(testFolder, mURI, bs.DEFAULT_INDEX, "title 2");

   434     // query

   435     let options = hs.getNewQueryOptions();

   436     let query = hs.getNewQuery();

   437     query.setFolders([testFolder], 1);

   438     let result = hs.executeQuery(query, options);

   439     let rootNode = result.root;

   440     rootNode.containerOpen = true;

   441     let cc = rootNode.childCount;

   442     do_check_eq(cc, 2);

   443     do_check_eq(rootNode.getChild(0).title, "title 1");

   444     do_check_eq(rootNode.getChild(1).title, "title 2");

   445     rootNode.containerOpen = false;

   446   }

   447   catch(ex) {

   448     do_throw("bookmarks query: " + ex);

   449   }

   451   // test change bookmark uri

   452   let newId10 = bs.insertBookmark(testRoot, uri("http://foo10.com/"),

   453                                   bs.DEFAULT_INDEX, "");

   454   let dateAdded = bs.getItemDateAdded(newId10);

   455   // after just inserting, modified should not be set

   456   let lastModified = bs.getItemLastModified(newId10);

   457   do_check_eq(lastModified, dateAdded);

   459   // Workaround possible VM timers issues moving lastModified and dateAdded

   460   // to the past.

   461   bs.setItemLastModified(newId10, --lastModified);

   462   bs.setItemDateAdded(newId10, --dateAdded);

   464   bs.changeBookmarkURI(newId10, uri("http://foo11.com/"));

   466   // check that lastModified is set after we change the bookmark uri

   467   let lastModified2 = bs.getItemLastModified(newId10);

   468   LOG("test changeBookmarkURI");

   469   LOG("dateAdded = " + dateAdded);

   470   LOG("lastModified = " + lastModified);

   471   LOG("lastModified2 = " + lastModified2);

   472   do_check_true(is_time_ordered(lastModified, lastModified2));

   473   do_check_true(is_time_ordered(dateAdded, lastModified2));

   475   do_check_eq(bookmarksObserver._itemChangedId, newId10);

   476   do_check_eq(bookmarksObserver._itemChangedProperty, "uri");

   477   do_check_eq(bookmarksObserver._itemChangedValue, "http://foo11.com/");

   479   // test getBookmarkURI

   480   let newId11 = bs.insertBookmark(testRoot, uri("http://foo11.com/"),

   481                                   bs.DEFAULT_INDEX, "");

   482   let bmURI = bs.getBookmarkURI(newId11);

   483   do_check_eq("http://foo11.com/", bmURI.spec);

   485   // test getBookmarkURI with non-bookmark items

   486   try {

   487     bs.getBookmarkURI(testRoot);

   488     do_throw("getBookmarkURI() should throw for non-bookmark items!");

   489   } catch(ex) {}

   491   // test getItemIndex

   492   let newId12 = bs.insertBookmark(testRoot, uri("http://foo11.com/"), 1, "");

   493   let bmIndex = bs.getItemIndex(newId12);

   494   do_check_eq(1, bmIndex);

   496   // insert a bookmark with title ZZZXXXYYY and then search for it.

   497   // this test confirms that we can find bookmarks that we haven't visited

   498   // (which are "hidden") and that we can find by title.

   499   // see bug #369887 for more details

   500   let newId13 = bs.insertBookmark(testRoot, uri("http://foobarcheese.com/"),

   501                                   bs.DEFAULT_INDEX, "");

   502   do_check_eq(bookmarksObserver._itemAddedId, newId13);

   503   do_check_eq(bookmarksObserver._itemAddedParent, testRoot);

   504   do_check_eq(bookmarksObserver._itemAddedIndex, 11);

   506   // set bookmark title

   507   bs.setItemTitle(newId13, "ZZZXXXYYY");

   508   do_check_eq(bookmarksObserver._itemChangedId, newId13);

   509   do_check_eq(bookmarksObserver._itemChangedProperty, "title");

   510   do_check_eq(bookmarksObserver._itemChangedValue, "ZZZXXXYYY");

   512   // check if setting an item annotation triggers onItemChanged

   513   bookmarksObserver._itemChangedId = -1;

   514   anno.setItemAnnotation(newId3, "test-annotation", "foo", 0, 0);

   515   do_check_eq(bookmarksObserver._itemChangedId, newId3);

   516   do_check_eq(bookmarksObserver._itemChangedProperty, "test-annotation");

   517   do_check_true(bookmarksObserver._itemChanged_isAnnotationProperty);

   518   do_check_eq(bookmarksObserver._itemChangedValue, "");

   520   // test search on bookmark title ZZZXXXYYY

   521   try {

   522     let options = hs.getNewQueryOptions();

   523     options.excludeQueries = 1;

   524     options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;

   525     let query = hs.getNewQuery();

   526     query.searchTerms = "ZZZXXXYYY";

   527     let result = hs.executeQuery(query, options);

   528     let rootNode = result.root;

   529     rootNode.containerOpen = true;

   530     let cc = rootNode.childCount;

   531     do_check_eq(cc, 1);

   532     let node = rootNode.getChild(0);

   533     do_check_eq(node.title, "ZZZXXXYYY");

   534     do_check_true(node.itemId > 0);

   535     rootNode.containerOpen = false;

   536   }

   537   catch(ex) {

   538     do_throw("bookmarks query: " + ex);

   539   }

   541   // test dateAdded and lastModified properties

   542   // for a search query

   543   try {

   544     let options = hs.getNewQueryOptions();

   545     options.excludeQueries = 1;

   546     options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS;

   547     let query = hs.getNewQuery();

   548     query.searchTerms = "ZZZXXXYYY";

   549     let result = hs.executeQuery(query, options);

   550     let rootNode = result.root;

   551     rootNode.containerOpen = true;

   552     let cc = rootNode.childCount;

   553     do_check_eq(cc, 1);

   554     let node = rootNode.getChild(0);

   556     do_check_eq(typeof node.dateAdded, "number");

   557     do_check_true(node.dateAdded > 0);

   559     do_check_eq(typeof node.lastModified, "number");

   560     do_check_true(node.lastModified > 0);

   562     rootNode.containerOpen = false;

   563   }

   564   catch(ex) {

   565     do_throw("bookmarks query: " + ex);

   566   }

   568   // test dateAdded and lastModified properties

   569   // for a folder query

   570   try {

   571     let options = hs.getNewQueryOptions();

   572     let query = hs.getNewQuery();

   573     query.setFolders([testRoot], 1);

   574     let result = hs.executeQuery(query, options);

   575     let rootNode = result.root;

   576     rootNode.containerOpen = true;

   577     let cc = rootNode.childCount;

   578     do_check_true(cc > 0);

   579     for (let i = 0; i < cc; i++) {

   580       let node = rootNode.getChild(i);

   582       if (node.type == node.RESULT_TYPE_URI) {

   583         do_check_eq(typeof node.dateAdded, "number");

   584         do_check_true(node.dateAdded > 0);

   586         do_check_eq(typeof node.lastModified, "number");

   587         do_check_true(node.lastModified > 0);

   588         break;

   589       }

   590     }

   591     rootNode.containerOpen = false;

   592   }

   593   catch(ex) {

   594     do_throw("bookmarks query: " + ex);

   595   }

   597   // check setItemLastModified() and setItemDateAdded()

   598   let newId14 = bs.insertBookmark(testRoot, uri("http://bar.tld/"),

   599                                   bs.DEFAULT_INDEX, "");

   600   let dateAdded = bs.getItemDateAdded(newId14);

   601   let lastModified = bs.getItemLastModified(newId14);

   602   do_check_eq(lastModified, dateAdded);

   603   bs.setItemLastModified(newId14, 1234);

   604   let fakeLastModified = bs.getItemLastModified(newId14);

   605   do_check_eq(fakeLastModified, 1234);

   606   bs.setItemDateAdded(newId14, 4321);

   607   let fakeDateAdded = bs.getItemDateAdded(newId14);

   608   do_check_eq(fakeDateAdded, 4321);

   610   // ensure that removing an item removes its annotations

   611   do_check_true(anno.itemHasAnnotation(newId3, "test-annotation"));

   612   bs.removeItem(newId3);

   613   do_check_false(anno.itemHasAnnotation(newId3, "test-annotation"));

   615   // bug 378820

   616   let uri1 = uri("http://foo.tld/a");

   617   bs.insertBookmark(testRoot, uri1, bs.DEFAULT_INDEX, "");

   618   yield promiseAddVisits(uri1);

   620   // bug 646993 - test bookmark titles longer than the maximum allowed length

   621   let title15 = Array(TITLE_LENGTH_MAX + 5).join("X");

   622   let title15expected = title15.substring(0, TITLE_LENGTH_MAX);

   623   let newId15 = bs.insertBookmark(testRoot, uri("http://evil.com/"),

   624                                   bs.DEFAULT_INDEX, title15);

   626   do_check_eq(bs.getItemTitle(newId15).length,

   627               title15expected.length);

   628   do_check_eq(bookmarksObserver._itemAddedTitle, title15expected);

   629   // test title length after updates

   630   bs.setItemTitle(newId15, title15 + " updated");

   631   do_check_eq(bs.getItemTitle(newId15).length,

   632               title15expected.length);

   633   do_check_eq(bookmarksObserver._itemChangedId, newId15);

   634   do_check_eq(bookmarksObserver._itemChangedProperty, "title");

   635   do_check_eq(bookmarksObserver._itemChangedValue, title15expected);

   637   testSimpleFolderResult();

   638 });

   640 function testSimpleFolderResult() {

   641   // the time before we create a folder, in microseconds

   642   // Workaround possible VM timers issues subtracting 1us.

   643   let beforeCreate = Date.now() * 1000 - 1;

   644   do_check_true(beforeCreate > 0);

   646   // create a folder

   647   let parent = bs.createFolder(root, "test", bs.DEFAULT_INDEX);

   649   let dateCreated = bs.getItemDateAdded(parent);

   650   LOG("check that the folder was created with a valid dateAdded");

   651   LOG("beforeCreate = " + beforeCreate);

   652   LOG("dateCreated = " + dateCreated);

   653   do_check_true(is_time_ordered(beforeCreate, dateCreated));

   655   // the time before we insert, in microseconds

   656   // Workaround possible VM timers issues subtracting 1ms.

   657   let beforeInsert = Date.now() * 1000 - 1;

   658   do_check_true(beforeInsert > 0);

   660   // insert a separator

   661   let sep = bs.insertSeparator(parent, bs.DEFAULT_INDEX);

   663   let dateAdded = bs.getItemDateAdded(sep);

   664   LOG("check that the separator was created with a valid dateAdded");

   665   LOG("beforeInsert = " + beforeInsert);

   666   LOG("dateAdded = " + dateAdded);

   667   do_check_true(is_time_ordered(beforeInsert, dateAdded));

   669   // re-set item title separately so can test nodes' last modified

   670   let item = bs.insertBookmark(parent, uri("about:blank"),

   671                                bs.DEFAULT_INDEX, "");

   672   bs.setItemTitle(item, "test bookmark");

   674   // see above

   675   let folder = bs.createFolder(parent, "test folder", bs.DEFAULT_INDEX);

   676   bs.setItemTitle(folder, "test folder");

   678   let longName = Array(TITLE_LENGTH_MAX + 5).join("A");

   679   let folderLongName = bs.createFolder(parent, longName, bs.DEFAULT_INDEX);

   680   do_check_eq(bookmarksObserver._itemAddedTitle, longName.substring(0, TITLE_LENGTH_MAX));

   682   let options = hs.getNewQueryOptions();

   683   let query = hs.getNewQuery();

   684   query.setFolders([parent], 1);

   685   let result = hs.executeQuery(query, options);

   686   let rootNode = result.root;

   687   rootNode.containerOpen = true;

   688   do_check_eq(rootNode.childCount, 4);

   690   let node = rootNode.getChild(0);

   691   do_check_true(node.dateAdded > 0);

   692   do_check_eq(node.lastModified, node.dateAdded);

   693   do_check_eq(node.itemId, sep);

   694   do_check_eq(node.title, "");

   695   node = rootNode.getChild(1);

   696   do_check_eq(node.itemId, item);

   697   do_check_true(node.dateAdded > 0);

   698   do_check_true(node.lastModified > 0);

   699   do_check_eq(node.title, "test bookmark");

   700   node = rootNode.getChild(2);

   701   do_check_eq(node.itemId, folder);

   702   do_check_eq(node.title, "test folder");

   703   do_check_true(node.dateAdded > 0);

   704   do_check_true(node.lastModified > 0);

   705   node = rootNode.getChild(3);

   706   do_check_eq(node.itemId, folderLongName);

   707   do_check_eq(node.title, longName.substring(0, TITLE_LENGTH_MAX));

   708   do_check_true(node.dateAdded > 0);

   709   do_check_true(node.lastModified > 0);

   711   // update with another long title

   712   bs.setItemTitle(folderLongName, longName + " updated");

   713   do_check_eq(bookmarksObserver._itemChangedId, folderLongName);

   714   do_check_eq(bookmarksObserver._itemChangedProperty, "title");

   715   do_check_eq(bookmarksObserver._itemChangedValue, longName.substring(0, TITLE_LENGTH_MAX));

   717   node = rootNode.getChild(3);

   718   do_check_eq(node.title, longName.substring(0, TITLE_LENGTH_MAX));

   720   rootNode.containerOpen = false;

   721 }

   723 function getChildCount(aFolderId) {

   724   let cc = -1;

   725   try {

   726     let options = hs.getNewQueryOptions();

   727     let query = hs.getNewQuery();

   728     query.setFolders([aFolderId], 1);

   729     let result = hs.executeQuery(query, options);

   730     let rootNode = result.root;

   731     rootNode.containerOpen = true;

   732     cc = rootNode.childCount;

   733     rootNode.containerOpen = false;

   734   } catch(ex) {

   735     do_throw("getChildCount failed: " + ex);

   736   }

   737   return cc;

   738 }

The Tor Browser / file revision

toolkit/components/places/tests/bookmarks/test_bookmarks.js@129ffea94266

toolkit/components/places/tests/bookmarks/test_bookmarks.js