The Tor Browser: browser/components/places/tests/unit/test_PUIU

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* Any copyright is dedicated to the Public Domain.

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

     4 function waitForBookmarkNotification(aNotification, aCallback, aProperty)

5 {

     6   PlacesUtils.bookmarks.addObserver({

     7     validate: function (aMethodName, aData)

     8     {

     9       if (aMethodName == aNotification &&

    10           (!aProperty || aProperty == aData.property)) {

    11         PlacesUtils.bookmarks.removeObserver(this);

    12         aCallback(aData);

    13       }

    14     },

    16     // nsINavBookmarkObserver

    17     QueryInterface: XPCOMUtils.generateQI([Ci.nsINavBookmarkObserver]),

    18     onBeginUpdateBatch: function onBeginUpdateBatch()

    19       this.validate(arguments.callee.name, arguments),

    20     onEndUpdateBatch: function onEndUpdateBatch()

    21       this.validate(arguments.callee.name, arguments),

    22     onItemAdded: function onItemAdded(aItemId, aParentId, aIndex, aItemType,

    23                                       aURI, aTitle)

    24     {

    25       return this.validate(arguments.callee.name, { id: aItemId,

    26                                                     index: aIndex,

    27                                                     type: aItemType,

    28                                                     url: aURI ? aURI.spec : null,

    29                                                     title: aTitle });

    30     },

    31     onItemRemoved: function onItemRemoved()

    32       this.validate(arguments.callee.name, arguments),

    33     onItemChanged: function onItemChanged(aItemId, aProperty, aIsAnno,

    34                                           aNewValue, aLastModified, aItemType)

    35     {

    36       return this.validate(arguments.callee.name,

    37                            { id: aItemId,

    38                              get index() PlacesUtils.bookmarks.getItemIndex(this.id),

    39                              type: aItemType,

    40                              property: aProperty,

    41                              get url() aItemType == PlacesUtils.bookmarks.TYPE_BOOKMARK ?

    42                                                 PlacesUtils.bookmarks.getBookmarkURI(this.id).spec :

    43                                                 null,

    44                              get title() PlacesUtils.bookmarks.getItemTitle(this.id),

    45                            });

    46     },

    47     onItemVisited: function onItemVisited()

    48       this.validate(arguments.callee.name, arguments),

    49     onItemMoved: function onItemMoved(aItemId, aOldParentId, aOldIndex,

    50                                       aNewParentId, aNewIndex, aItemType)

    51     {

    52       this.validate(arguments.callee.name, { id: aItemId,

    53                                              index: aNewIndex,

    54                                              type: aItemType });

    55     }

    56   }, false);

    57 }

    59 function wrapNodeByIdAndParent(aItemId, aParentId)

    60 {

    61   let wrappedNode;

    62   let root = PlacesUtils.getFolderContents(aParentId, false, false).root;

    63   for (let i = 0; i < root.childCount; ++i) {

    64     let node = root.getChild(i);

    65     if (node.itemId == aItemId) {

    66       let type;

    67       if (PlacesUtils.nodeIsContainer(node)) {

    68         type = PlacesUtils.TYPE_X_MOZ_PLACE_CONTAINER;

    69       }

    70       else if (PlacesUtils.nodeIsURI(node)) {

    71         type = PlacesUtils.TYPE_X_MOZ_PLACE;

    72       }

    73       else if (PlacesUtils.nodeIsSeparator(node)) {

    74         type = PlacesUtils.TYPE_X_MOZ_PLACE_SEPARATOR;

    75       }

    76       else {

    77         do_throw("Unknown node type");

    78       }

    79       wrappedNode = PlacesUtils.wrapNode(node, type);

    80     }

    81   }

    82   root.containerOpen = false;

    83   return JSON.parse(wrappedNode);

    84 }

    86 add_test(function test_text_paste()

    87 {

    88   const TEST_URL = "http://places.moz.org/"

    89   const TEST_TITLE = "Places bookmark"

    91   waitForBookmarkNotification("onItemAdded", function(aData)

    92   {

    93     do_check_eq(aData.title, TEST_TITLE);

    94     do_check_eq(aData.url, TEST_URL);

    95     do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);

    96     do_check_eq(aData.index, 0);

    97     run_next_test();

    98   });

   100   let txn = PlacesUIUtils.makeTransaction(

   101     { title: TEST_TITLE, uri: TEST_URL },

   102     PlacesUtils.TYPE_X_MOZ_URL,

   103     PlacesUtils.unfiledBookmarksFolderId,

   104     PlacesUtils.bookmarks.DEFAULT_INDEX,

   105     true // Unused for text.

   106   );

   107   PlacesUtils.transactionManager.doTransaction(txn);

   108 });

   110 add_test(function test_container()

   111 {

   112   const TEST_TITLE = "Places folder"

   114   waitForBookmarkNotification("onItemChanged", function(aData)

   115   {

   116     do_check_eq(aData.title, TEST_TITLE);

   117     do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_FOLDER);

   118     do_check_eq(aData.index, 1);

   120     waitForBookmarkNotification("onItemAdded", function(aData)

   121     {

   122       do_check_eq(aData.title, TEST_TITLE);

   123       do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_FOLDER);

   124       do_check_eq(aData.index, 2);

   125       let id = aData.id;

   127       waitForBookmarkNotification("onItemMoved", function(aData)

   128       {

   129         do_check_eq(aData.id, id);

   130         do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_FOLDER);

   131         do_check_eq(aData.index, 1);

   133         run_next_test();

   134       });

   136       let txn = PlacesUIUtils.makeTransaction(

   137         wrapNodeByIdAndParent(aData.id, PlacesUtils.unfiledBookmarksFolderId),

   138         0, // Unused for real nodes.

   139         PlacesUtils.unfiledBookmarksFolderId,

   140         1, // Move to position 1.

   141         false

   142       );

   143       PlacesUtils.transactionManager.doTransaction(txn);

   144     });

   146     try {

   147     let txn = PlacesUIUtils.makeTransaction(

   148       wrapNodeByIdAndParent(aData.id, PlacesUtils.unfiledBookmarksFolderId),

   149       0, // Unused for real nodes.

   150       PlacesUtils.unfiledBookmarksFolderId,

   151       PlacesUtils.bookmarks.DEFAULT_INDEX,

   152       true

   153     );

   154     PlacesUtils.transactionManager.doTransaction(txn);

   155     } catch(ex) {

   156       do_throw(ex);

   157     }

   158   }, "random-anno");

   160   let id = PlacesUtils.bookmarks.createFolder(PlacesUtils.unfiledBookmarksFolderId,

   161                                               TEST_TITLE,

   162                                               PlacesUtils.bookmarks.DEFAULT_INDEX);

   163   PlacesUtils.annotations.setItemAnnotation(id, PlacesUIUtils.DESCRIPTION_ANNO,

   164                                             "description", 0,

   165                                             PlacesUtils.annotations.EXPIRE_NEVER);

   166   PlacesUtils.annotations.setItemAnnotation(id, "random-anno",

   167                                             "random-value", 0,

   168                                             PlacesUtils.annotations.EXPIRE_NEVER);

   169 });

   172 add_test(function test_separator()

   173 {

   174   waitForBookmarkNotification("onItemChanged", function(aData)

   175   {

   176     do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);

   177     do_check_eq(aData.index, 3);

   179     waitForBookmarkNotification("onItemAdded", function(aData)

   180     {

   181       do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);

   182       do_check_eq(aData.index, 4);

   183       let id = aData.id;

   185       waitForBookmarkNotification("onItemMoved", function(aData)

   186       {

   187         do_check_eq(aData.id, id);

   188         do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_SEPARATOR);

   189         do_check_eq(aData.index, 1);

   191         run_next_test();

   192       });

   194       let txn = PlacesUIUtils.makeTransaction(

   195         wrapNodeByIdAndParent(aData.id, PlacesUtils.unfiledBookmarksFolderId),

   196         0, // Unused for real nodes.

   197         PlacesUtils.unfiledBookmarksFolderId,

   198         1, // Move to position 1.

   199         false

   200       );

   201       PlacesUtils.transactionManager.doTransaction(txn);

   202     });

   204     try {

   205     let txn = PlacesUIUtils.makeTransaction(

   206       wrapNodeByIdAndParent(aData.id, PlacesUtils.unfiledBookmarksFolderId),

   207       0, // Unused for real nodes.

   208       PlacesUtils.unfiledBookmarksFolderId,

   209       PlacesUtils.bookmarks.DEFAULT_INDEX,

   210       true

   211     );

   212     PlacesUtils.transactionManager.doTransaction(txn);

   213     } catch(ex) {

   214       do_throw(ex);

   215     }

   216   }, "random-anno");

   218   let id = PlacesUtils.bookmarks.insertSeparator(PlacesUtils.unfiledBookmarksFolderId,

   219                                                  PlacesUtils.bookmarks.DEFAULT_INDEX);

   220   PlacesUtils.annotations.setItemAnnotation(id, "random-anno",

   221                                             "random-value", 0,

   222                                             PlacesUtils.annotations.EXPIRE_NEVER);

   223 });

   225 add_test(function test_bookmark()

   226 {

   227   const TEST_URL = "http://places.moz.org/"

   228   const TEST_TITLE = "Places bookmark"

   230   waitForBookmarkNotification("onItemChanged", function(aData)

   231   {

   232     do_check_eq(aData.title, TEST_TITLE);

   233     do_check_eq(aData.url, TEST_URL);

   234     do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);

   235     do_check_eq(aData.index, 5);

   237     waitForBookmarkNotification("onItemAdded", function(aData)

   238     {

   239       do_check_eq(aData.title, TEST_TITLE);

   240       do_check_eq(aData.url, TEST_URL);

   241       do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);

   242       do_check_eq(aData.index, 6);

   243       let id = aData.id;

   245       waitForBookmarkNotification("onItemMoved", function(aData)

   246       {

   247         do_check_eq(aData.id, id);

   248         do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);

   249         do_check_eq(aData.index, 1);

   251         run_next_test();

   252       });

   254       let txn = PlacesUIUtils.makeTransaction(

   255         wrapNodeByIdAndParent(aData.id, PlacesUtils.unfiledBookmarksFolderId),

   256         0, // Unused for real nodes.

   257         PlacesUtils.unfiledBookmarksFolderId,

   258         1, // Move to position 1.

   259         false

   260       );

   261       PlacesUtils.transactionManager.doTransaction(txn);

   262     });

   264     try {

   265     let txn = PlacesUIUtils.makeTransaction(

   266       wrapNodeByIdAndParent(aData.id, PlacesUtils.unfiledBookmarksFolderId),

   267       0, // Unused for real nodes.

   268       PlacesUtils.unfiledBookmarksFolderId,

   269       PlacesUtils.bookmarks.DEFAULT_INDEX,

   270       true

   271     );

   272     PlacesUtils.transactionManager.doTransaction(txn);

   273     } catch(ex) {

   274       do_throw(ex);

   275     }

   276   }, "random-anno");

   278   let id = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,

   279                                                 NetUtil.newURI(TEST_URL),

   280                                                 PlacesUtils.bookmarks.DEFAULT_INDEX,

   281                                                 TEST_TITLE);

   282   PlacesUtils.annotations.setItemAnnotation(id, PlacesUIUtils.DESCRIPTION_ANNO,

   283                                             "description", 0,

   284                                             PlacesUtils.annotations.EXPIRE_NEVER);

   285   PlacesUtils.annotations.setItemAnnotation(id, "random-anno",

   286                                             "random-value", 0,

   287                                             PlacesUtils.annotations.EXPIRE_NEVER);

   288 });

   290 add_test(function test_visit()

   291 {

   292   const TEST_URL = "http://places.moz.org/"

   293   const TEST_TITLE = "Places bookmark"

   295   waitForBookmarkNotification("onItemAdded", function(aData)

   296   {

   297     do_check_eq(aData.title, TEST_TITLE);

   298     do_check_eq(aData.url, TEST_URL);

   299     do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);

   300     do_check_eq(aData.index, 7);

   302     waitForBookmarkNotification("onItemAdded", function(aData)

   303     {

   304       do_check_eq(aData.title, TEST_TITLE);

   305       do_check_eq(aData.url, TEST_URL);

   306       do_check_eq(aData.type, PlacesUtils.bookmarks.TYPE_BOOKMARK);

   307       do_check_eq(aData.index, 8);

   308       run_next_test();

   309     });

   311     try {

   312     let node = wrapNodeByIdAndParent(aData.id, PlacesUtils.unfiledBookmarksFolderId);

   313     // Simulate a not-bookmarked node, will copy it to a new bookmark.

   314     node.id = -1;

   315     let txn = PlacesUIUtils.makeTransaction(

   316       node,

   317       0, // Unused for real nodes.

   318       PlacesUtils.unfiledBookmarksFolderId,

   319       PlacesUtils.bookmarks.DEFAULT_INDEX,

   320       true

   321     );

   322     PlacesUtils.transactionManager.doTransaction(txn);

   323     } catch(ex) {

   324       do_throw(ex);

   325     }

   326   });

   328   PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,

   329                                        NetUtil.newURI(TEST_URL),

   330                                        PlacesUtils.bookmarks.DEFAULT_INDEX,

   331                                        TEST_TITLE);

   332 });

   334 add_test(function check_annotations() {

   335   // As last step check how many items for each annotation exist.

   337   // Copies should retain the description annotation.

   338   let descriptions =

   339     PlacesUtils.annotations.getItemsWithAnnotation(PlacesUIUtils.DESCRIPTION_ANNO, {});

   340   do_check_eq(descriptions.length, 4);

   342   // Only the original bookmarks should have this annotation.

   343   let others = PlacesUtils.annotations.getItemsWithAnnotation("random-anno", {});

   344   do_check_eq(others.length, 3);

   345   run_next_test();

   346 });

   348 function run_test()

   349 {

   350   run_next_test();

   351 }

The Tor Browser / file revision

browser/components/places/tests/unit/test_PUIU_makeTransaction.js@6474c204b198

browser/components/places/tests/unit/test_PUIU_makeTransaction.js