Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use ensure method in storybook-root

Best JavaScript code snippet using storybook-root

test_async_transactions.js

Source:test_async_transactions.js

1/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */2/* vim:set ts=2 sw=2 sts=2 et: */3/* This Source Code Form is subject to the terms of the Mozilla Public4 * License, v. 2.0. If a copy of the MPL was not distributed with this5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */6const bmsvc    = PlacesUtils.bookmarks;7const tagssvc  = PlacesUtils.tagging;8const annosvc  = PlacesUtils.annotations;9const PT       = PlacesTransactions;10const rootGuid = PlacesUtils.bookmarks.rootGuid;11const menuGuid = PlacesUtils.bookmarks.menuGuid;12Components.utils.importGlobalProperties(["URL"]);13// Create and add bookmarks observer.14var observer = {15  __proto__: NavBookmarkObserver.prototype,16  tagRelatedGuids: new Set(),17  reset() {18    this.itemsAdded = new Map();19    this.itemsRemoved = new Map();20    this.itemsChanged = new Map();21    this.itemsMoved = new Map();22    this.beginUpdateBatch = false;23    this.endUpdateBatch = false;24  },25  onBeginUpdateBatch() {26    this.beginUpdateBatch = true;27  },28  onEndUpdateBatch() {29    this.endUpdateBatch = true;30  },31  onItemAdded(aItemId, aParentId, aIndex, aItemType, aURI, aTitle, aDateAdded,32           aGuid, aParentGuid) {33    // Ignore tag items.34    if (aParentId == PlacesUtils.tagsFolderId ||35        (aParentId != PlacesUtils.placesRootId &&36         bmsvc.getFolderIdForItem(aParentId) == PlacesUtils.tagsFolderId)) {37      this.tagRelatedGuids.add(aGuid);38      return;39    }40    this.itemsAdded.set(aGuid, { itemId:         aItemId,41                                 parentGuid:     aParentGuid,42                                 index:          aIndex,43                                 itemType:       aItemType,44                                 title:          aTitle,45                                 url:            aURI });46  },47  onItemRemoved(aItemId, aParentId, aIndex, aItemType, aURI, aGuid, aParentGuid) {48    if (this.tagRelatedGuids.has(aGuid))49      return;50    this.itemsRemoved.set(aGuid, { parentGuid: aParentGuid,51                                   index:      aIndex,52                                   itemType:   aItemType });53  },54  onItemChanged(aItemId, aProperty, aIsAnnoProperty, aNewValue, aLastModified,55           aItemType, aParentId, aGuid, aParentGuid) {56    if (this.tagRelatedGuids.has(aGuid))57      return;58    let changesForGuid = this.itemsChanged.get(aGuid);59    if (changesForGuid === undefined) {60      changesForGuid = new Map();61      this.itemsChanged.set(aGuid, changesForGuid);62    }63    let newValue = aNewValue;64    if (aIsAnnoProperty) {65      if (annosvc.itemHasAnnotation(aItemId, aProperty))66        newValue = annosvc.getItemAnnotation(aItemId, aProperty);67      else68        newValue = null;69    }70    let change = { isAnnoProperty: aIsAnnoProperty,71                   newValue,72                   lastModified: aLastModified,73                   itemType: aItemType };74    changesForGuid.set(aProperty, change);75  },76  onItemVisited: () => {},77  onItemMoved(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex, aItemType,78           aGuid, aOldParentGuid, aNewParentGuid) {79    this.itemsMoved.set(aGuid, { oldParentGuid: aOldParentGuid,80                                 oldIndex:      aOldIndex,81                                 newParentGuid: aNewParentGuid,82                                 newIndex:      aNewIndex,83                                 itemType:      aItemType });84  }85};86observer.reset();87// index at which items should begin88var bmStartIndex = 0;89function run_test() {90  bmsvc.addObserver(observer);91  do_register_cleanup(function() {92    bmsvc.removeObserver(observer);93  });94  run_next_test();95}96function sanityCheckTransactionHistory() {97  do_check_true(PT.undoPosition <= PT.length);98  let check_entry_throws = f => {99    try {100      f();101      do_throw("PT.entry should throw for invalid input");102    } catch (ex) {}103  };104  check_entry_throws( () => PT.entry(-1) );105  check_entry_throws( () => PT.entry({}) );106  check_entry_throws( () => PT.entry(PT.length) );107  if (PT.undoPosition < PT.length)108    do_check_eq(PT.topUndoEntry, PT.entry(PT.undoPosition));109  else110    do_check_null(PT.topUndoEntry);111  if (PT.undoPosition > 0)112    do_check_eq(PT.topRedoEntry, PT.entry(PT.undoPosition - 1));113  else114    do_check_null(PT.topRedoEntry);115}116function getTransactionsHistoryState() {117  let history = [];118  for (let i = 0; i < PT.length; i++) {119    history.push(PT.entry(i));120  }121  return [history, PT.undoPosition];122}123function ensureUndoState(aExpectedEntries = [], aExpectedUndoPosition = 0) {124  // ensureUndoState is called in various places during this test, so it's125  // a good places to sanity-check the transaction-history APIs in all126  // cases.127  sanityCheckTransactionHistory();128  let [actualEntries, actualUndoPosition] = getTransactionsHistoryState();129  do_check_eq(actualEntries.length, aExpectedEntries.length);130  do_check_eq(actualUndoPosition, aExpectedUndoPosition);131  function checkEqualEntries(aExpectedEntry, aActualEntry) {132    do_check_eq(aExpectedEntry.length, aActualEntry.length);133    aExpectedEntry.forEach( (t, i) => do_check_eq(t, aActualEntry[i]) );134  }135  aExpectedEntries.forEach( (e, i) => checkEqualEntries(e, actualEntries[i]) );136}137function ensureItemsAdded(...items) {138  let expectedResultsCount = items.length;139  for (let item of items) {140    if ("children" in item) {141      expectedResultsCount += item.children.length;142    }143    Assert.ok(observer.itemsAdded.has(item.guid),144      `Should have the expected guid ${item.guid}`);145    let info = observer.itemsAdded.get(item.guid);146    Assert.equal(info.parentGuid, item.parentGuid,147      "Should have notified the correct parentGuid");148    for (let propName of ["title", "index", "itemType"]) {149      if (propName in item)150        Assert.equal(info[propName], item[propName]);151    }152    if ("url" in item)153      Assert.ok(info.url.equals(item.url));154  }155  Assert.equal(observer.itemsAdded.size, expectedResultsCount,156    "Should have added the correct number of items");157}158function ensureItemsRemoved(...items) {159  let expectedResultsCount = items.length;160  for (let item of items) {161    // We accept both guids and full info object here.162    if (typeof(item) == "string") {163      Assert.ok(observer.itemsRemoved.has(item),164        `Should have removed the expected guid ${item}`);165    } else {166      if ("children" in item) {167        expectedResultsCount += item.children.length;168      }169      Assert.ok(observer.itemsRemoved.has(item.guid),170        `Should have removed expected guid ${item.guid}`);171      let info = observer.itemsRemoved.get(item.guid);172      Assert.equal(info.parentGuid, item.parentGuid,173        "Should have notified the correct parentGuid");174      if ("index" in item)175        Assert.equal(info.index, item.index);176    }177  }178  Assert.equal(observer.itemsRemoved.size, expectedResultsCount,179    "Should have removed the correct number of items");180}181function ensureItemsChanged(...items) {182  for (let item of items) {183    do_check_true(observer.itemsChanged.has(item.guid));184    let changes = observer.itemsChanged.get(item.guid);185    do_check_true(changes.has(item.property));186    let info = changes.get(item.property);187    if (!("isAnnoProperty" in item)) {188      do_check_false(info.isAnnoProperty);189    } else {190      do_check_eq(info.isAnnoProperty, Boolean(item.isAnnoProperty));191    }192    do_check_eq(info.newValue, item.newValue);193    if ("url" in item)194      do_check_true(item.url.equals(info.url));195  }196}197function ensureAnnotationsSet(aGuid, aAnnos) {198  do_check_true(observer.itemsChanged.has(aGuid));199  let changes = observer.itemsChanged.get(aGuid);200  for (let anno of aAnnos) {201    do_check_true(changes.has(anno.name));202    let changeInfo = changes.get(anno.name);203    do_check_true(changeInfo.isAnnoProperty);204    do_check_eq(changeInfo.newValue, anno.value);205  }206}207function ensureItemsMoved(...items) {208  do_check_true(observer.itemsMoved.size, items.length);209  for (let item of items) {210    do_check_true(observer.itemsMoved.has(item.guid));211    let info = observer.itemsMoved.get(item.guid);212    do_check_eq(info.oldParentGuid, item.oldParentGuid);213    do_check_eq(info.oldIndex, item.oldIndex);214    do_check_eq(info.newParentGuid, item.newParentGuid);215    do_check_eq(info.newIndex, item.newIndex);216  }217}218function ensureTimestampsUpdated(aGuid, aCheckDateAdded = false) {219  do_check_true(observer.itemsChanged.has(aGuid));220  let changes = observer.itemsChanged.get(aGuid);221  if (aCheckDateAdded)222    do_check_true(changes.has("dateAdded"))223  do_check_true(changes.has("lastModified"));224}225function ensureTagsForURI(aURI, aTags) {226  let tagsSet = tagssvc.getTagsForURI(aURI);227  do_check_eq(tagsSet.length, aTags.length);228  do_check_true(aTags.every( t => tagsSet.includes(t)));229}230function createTestFolderInfo(title = "Test Folder", parentGuid = menuGuid,231                              children = undefined) {232  let info = { parentGuid, title };233  if (children) {234    info.children = children;235  }236  return info;237}238function isLivemarkTree(aTree) {239  return !!aTree.annos &&240         aTree.annos.some( a => a.name == PlacesUtils.LMANNO_FEEDURI );241}242async function ensureLivemarkCreatedByAddLivemark(aLivemarkGuid) {243  // This throws otherwise.244  await PlacesUtils.livemarks.getLivemark({ guid: aLivemarkGuid });245}246function removeAllDatesInTree(tree) {247  if ("lastModified" in tree) {248    delete tree.lastModified;249  }250  if ("dateAdded" in tree) {251    delete tree.dateAdded;252  }253  if (!tree.children) {254    return;255  }256  for (let child of tree.children) {257    removeAllDatesInTree(child);258  }259}260// Checks if two bookmark trees (as returned by promiseBookmarksTree) are the261// same.262// false value for aCheckParentAndPosition is ignored if aIsRestoredItem is set.263async function ensureEqualBookmarksTrees(aOriginal,264                                         aNew,265                                         aIsRestoredItem = true,266                                         aCheckParentAndPosition = false,267                                         aIgnoreAllDates = false) {268  // Note "id" is not-enumerable, and is therefore skipped by Object.keys (both269  // ours and the one at deepEqual). This is fine for us because ids are not270  // restored by Redo.271  if (aIsRestoredItem) {272    if (aIgnoreAllDates) {273      removeAllDatesInTree(aOriginal);274      removeAllDatesInTree(aNew);275    } else if (!aOriginal.lastModified) {276      // Ignore lastModified for newly created items, for performance reasons.277      aNew.lastModified = aOriginal.lastModified;278    }279    Assert.deepEqual(aOriginal, aNew);280    if (isLivemarkTree(aNew))281      await ensureLivemarkCreatedByAddLivemark(aNew.guid);282    return;283  }284  for (let property of Object.keys(aOriginal)) {285    if (property == "children") {286      Assert.equal(aOriginal.children.length, aNew.children.length);287      for (let i = 0; i < aOriginal.children.length; i++) {288        await ensureEqualBookmarksTrees(aOriginal.children[i],289                                        aNew.children[i],290                                        false,291                                        true);292      }293    } else if (property == "guid") {294      // guid shouldn't be copied if the item was not restored.295      Assert.notEqual(aOriginal.guid, aNew.guid);296    } else if (property == "dateAdded") {297      // dateAdded shouldn't be copied if the item was not restored.298      Assert.ok(is_time_ordered(aOriginal.dateAdded, aNew.dateAdded));299    } else if (property == "lastModified") {300      // same same, except for the never-changed case301      if (!aOriginal.lastModified)302        Assert.ok(!aNew.lastModified);303      else304        Assert.ok(is_time_ordered(aOriginal.lastModified, aNew.lastModified));305    } else if (aCheckParentAndPosition ||306             (property != "parentGuid" && property != "index")) {307      Assert.deepEqual(aOriginal[property], aNew[property]);308    }309  }310  if (isLivemarkTree(aNew))311    await ensureLivemarkCreatedByAddLivemark(aNew.guid);312}313async function ensureBookmarksTreeRestoredCorrectly(...aOriginalBookmarksTrees) {314  for (let originalTree of aOriginalBookmarksTrees) {315    let restoredTree =316      await PlacesUtils.promiseBookmarksTree(originalTree.guid);317    await ensureEqualBookmarksTrees(originalTree, restoredTree);318  }319}320async function ensureBookmarksTreeRestoredCorrectlyExceptDates(...aOriginalBookmarksTrees) {321  for (let originalTree of aOriginalBookmarksTrees) {322    let restoredTree =323      await PlacesUtils.promiseBookmarksTree(originalTree.guid);324    await ensureEqualBookmarksTrees(originalTree, restoredTree, true, false, true);325  }326}327async function ensureNonExistent(...aGuids) {328  for (let guid of aGuids) {329    Assert.strictEqual((await PlacesUtils.promiseBookmarksTree(guid)), null);330  }331}332add_task(async function test_recycled_transactions() {333  async function ensureTransactThrowsFor(aTransaction) {334    let [txns, undoPosition] = getTransactionsHistoryState();335    try {336      await aTransaction.transact();337      do_throw("Shouldn't be able to use the same transaction twice");338    } catch (ex) { }339    ensureUndoState(txns, undoPosition);340  }341  let txn_a = PT.NewFolder(createTestFolderInfo());342  await txn_a.transact();343  ensureUndoState([[txn_a]], 0);344  await ensureTransactThrowsFor(txn_a);345  await PT.undo();346  ensureUndoState([[txn_a]], 1);347  ensureTransactThrowsFor(txn_a);348  await PT.clearTransactionsHistory();349  ensureUndoState();350  ensureTransactThrowsFor(txn_a);351  let txn_b = PT.NewFolder(createTestFolderInfo());352  await PT.batch(async function() {353    try {354      await txn_a.transact();355      do_throw("Shouldn't be able to use the same transaction twice");356    } catch (ex) { }357    ensureUndoState();358    await txn_b.transact();359  });360  ensureUndoState([[txn_b]], 0);361  await PT.undo();362  ensureUndoState([[txn_b]], 1);363  ensureTransactThrowsFor(txn_a);364  ensureTransactThrowsFor(txn_b);365  await PT.clearTransactionsHistory();366  ensureUndoState();367  observer.reset();368});369add_task(async function test_new_folder_with_annotation() {370  const ANNO = { name: "TestAnno", value: "TestValue" };371  let folder_info = createTestFolderInfo();372  folder_info.index = bmStartIndex;373  folder_info.annotations = [ANNO];374  ensureUndoState();375  let txn = PT.NewFolder(folder_info);376  folder_info.guid = await txn.transact();377  let originalInfo = await PlacesUtils.promiseBookmarksTree(folder_info.guid);378  let ensureDo = async function(aRedo = false) {379    ensureUndoState([[txn]], 0);380    await ensureItemsAdded(folder_info);381    ensureAnnotationsSet(folder_info.guid, [ANNO]);382    if (aRedo) {383      // Ignore lastModified in the comparison, for performance reasons.384      originalInfo.lastModified = null;385      await ensureBookmarksTreeRestoredCorrectlyExceptDates(originalInfo);386    }387    observer.reset();388  };389  let ensureUndo = () => {390    ensureUndoState([[txn]], 1);391    ensureItemsRemoved({ guid:       folder_info.guid,392                         parentGuid: folder_info.parentGuid,393                         index:      bmStartIndex });394    observer.reset();395  };396  await ensureDo();397  await PT.undo();398  await ensureUndo();399  await PT.redo();400  await ensureDo(true);401  await PT.undo();402  ensureUndo();403  await PT.clearTransactionsHistory();404  ensureUndoState();405});406add_task(async function test_new_folder_with_children() {407  let folder_info = createTestFolderInfo("Test folder", PlacesUtils.bookmarks.menuGuid, [{408    url: "http://test_create_item.com",409    title: "Test creating an item"410  }]);411  ensureUndoState();412  let txn = PT.NewFolder(folder_info);413  folder_info.guid = await txn.transact();414  let originalInfo = await PlacesUtils.promiseBookmarksTree(folder_info.guid);415  let ensureDo = async function(aRedo = false) {416    ensureUndoState([[txn]], 0);417    ensureItemsAdded(folder_info);418    if (aRedo) {419      // Ignore lastModified in the comparison, for performance reasons.420      originalInfo.lastModified = null;421      await ensureBookmarksTreeRestoredCorrectlyExceptDates(originalInfo);422    }423    observer.reset();424  };425  let ensureUndo = () => {426    ensureUndoState([[txn]], 1);427    ensureItemsRemoved({428      guid: folder_info.guid,429      parentGuid: folder_info.parentGuid,430      index: bmStartIndex,431      children: [{432        title: "Test creating an item",433        url: "http://test_create_item.com",434      }]435    });436    observer.reset();437  };438  await ensureDo();439  await PT.undo();440  await ensureUndo();441  await PT.redo();442  await ensureDo(true);443  await PT.undo();444  ensureUndo();445  await PT.clearTransactionsHistory();446  ensureUndoState();447});448add_task(async function test_new_bookmark() {449  let bm_info = { parentGuid: rootGuid,450                  url:        NetUtil.newURI("http://test_create_item.com"),451                  index:      bmStartIndex,452                  title:      "Test creating an item" };453  ensureUndoState();454  let txn = PT.NewBookmark(bm_info);455  bm_info.guid = await txn.transact();456  let originalInfo = await PlacesUtils.promiseBookmarksTree(bm_info.guid);457  let ensureDo = async function(aRedo = false) {458    ensureUndoState([[txn]], 0);459    await ensureItemsAdded(bm_info);460    if (aRedo)461      await ensureBookmarksTreeRestoredCorrectly(originalInfo);462    observer.reset();463  };464  let ensureUndo = () => {465    ensureUndoState([[txn]], 1);466    ensureItemsRemoved({ guid:       bm_info.guid,467                         parentGuid: bm_info.parentGuid,468                         index:      bmStartIndex });469    observer.reset();470  };471  await ensureDo();472  await PT.undo();473  ensureUndo();474  await PT.redo(true);475  await ensureDo();476  await PT.undo();477  ensureUndo();478  await PT.clearTransactionsHistory();479  ensureUndoState();480});481add_task(async function test_merge_create_folder_and_item() {482  let folder_info = createTestFolderInfo();483  let bm_info = { url: NetUtil.newURI("http://test_create_item_to_folder.com"),484                  title: "Test Bookmark",485                  index: bmStartIndex };486  let [folderTxnResult, bkmTxnResult] = await PT.batch(async function() {487    let folderTxn = PT.NewFolder(folder_info);488    folder_info.guid = bm_info.parentGuid = await folderTxn.transact();489    let bkmTxn = PT.NewBookmark(bm_info);490    bm_info.guid = await bkmTxn.transact();491    return [folderTxn, bkmTxn];492  });493  let ensureDo = async function() {494    ensureUndoState([[bkmTxnResult, folderTxnResult]], 0);495    await ensureItemsAdded(folder_info, bm_info);496    observer.reset();497  };498  let ensureUndo = () => {499    ensureUndoState([[bkmTxnResult, folderTxnResult]], 1);500    ensureItemsRemoved(folder_info, bm_info);501    observer.reset();502  };503  await ensureDo();504  await PT.undo();505  ensureUndo();506  await PT.redo();507  await ensureDo();508  await PT.undo();509  ensureUndo();510  await PT.clearTransactionsHistory();511  ensureUndoState();512});513add_task(async function test_move_items_to_folder() {514  let folder_a_info = createTestFolderInfo("Folder A");515  let bkm_a_info = { url: new URL("http://test_move_items.com"),516                     title: "Bookmark A" };517  let bkm_b_info = { url: NetUtil.newURI("http://test_move_items.com"),518                     title: "Bookmark B" };519  // Test moving items within the same folder.520  let [folder_a_txn_result, bkm_a_txn_result, bkm_b_txn_result] = await PT.batch(async function() {521    let folder_a_txn = PT.NewFolder(folder_a_info);522    folder_a_info.guid = bkm_a_info.parentGuid = bkm_b_info.parentGuid =523      await folder_a_txn.transact();524    let bkm_a_txn = PT.NewBookmark(bkm_a_info);525    bkm_a_info.guid = await bkm_a_txn.transact();526    let bkm_b_txn = PT.NewBookmark(bkm_b_info);527    bkm_b_info.guid = await bkm_b_txn.transact();528    return [folder_a_txn, bkm_a_txn, bkm_b_txn];529  });530  ensureUndoState([[bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result]], 0);531  let moveTxn = PT.Move({ guid:          bkm_a_info.guid,532                          newParentGuid: folder_a_info.guid });533  await moveTxn.transact();534  let ensureDo = () => {535    ensureUndoState([[moveTxn], [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result]], 0);536    ensureItemsMoved({ guid:          bkm_a_info.guid,537                       oldParentGuid: folder_a_info.guid,538                       newParentGuid: folder_a_info.guid,539                       oldIndex:      0,540                       newIndex:      1 });541    observer.reset();542  };543  let ensureUndo = () => {544    ensureUndoState([[moveTxn], [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result]], 1);545    ensureItemsMoved({ guid:          bkm_a_info.guid,546                       oldParentGuid: folder_a_info.guid,547                       newParentGuid: folder_a_info.guid,548                       oldIndex:      1,549                       newIndex:      0 });550    observer.reset();551  };552  ensureDo();553  await PT.undo();554  ensureUndo();555  await PT.redo();556  ensureDo();557  await PT.undo();558  ensureUndo();559  await PT.clearTransactionsHistory(false, true);560  ensureUndoState([[bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result]], 0);561  // Test moving items between folders.562  let folder_b_info = createTestFolderInfo("Folder B");563  let folder_b_txn = PT.NewFolder(folder_b_info);564  folder_b_info.guid = await folder_b_txn.transact();565  ensureUndoState([ [folder_b_txn],566                    [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result] ], 0);567  moveTxn = PT.Move({ guid:          bkm_a_info.guid,568                      newParentGuid: folder_b_info.guid,569                      newIndex:      bmsvc.DEFAULT_INDEX });570  await moveTxn.transact();571  ensureDo = () => {572    ensureUndoState([ [moveTxn],573                      [folder_b_txn],574                      [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result] ], 0);575    ensureItemsMoved({ guid:          bkm_a_info.guid,576                       oldParentGuid: folder_a_info.guid,577                       newParentGuid: folder_b_info.guid,578                       oldIndex:      0,579                       newIndex:      0 });580    observer.reset();581  };582  ensureUndo = () => {583    ensureUndoState([ [moveTxn],584                      [folder_b_txn],585                      [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result] ], 1);586    ensureItemsMoved({ guid:          bkm_a_info.guid,587                       oldParentGuid: folder_b_info.guid,588                       newParentGuid: folder_a_info.guid,589                       oldIndex:      0,590                       newIndex:      0 });591    observer.reset();592  };593  ensureDo();594  await PT.undo();595  ensureUndo();596  await PT.redo();597  ensureDo();598  await PT.undo();599  ensureUndo();600  // Clean up601  await PT.undo();  // folder_b_txn602  await PT.undo();  // folder_a_txn + the bookmarks;603  do_check_eq(observer.itemsRemoved.size, 4);604  ensureUndoState([ [moveTxn],605                    [folder_b_txn],606                    [bkm_b_txn_result, bkm_a_txn_result, folder_a_txn_result] ], 3);607  await PT.clearTransactionsHistory();608  ensureUndoState();609});610add_task(async function test_remove_folder() {611  let folder_level_1_info = createTestFolderInfo("Folder Level 1");612  let folder_level_2_info = { title: "Folder Level 2" };613  let [folder_level_1_txn_result,614       folder_level_2_txn_result] = await PT.batch(async function() {615    let folder_level_1_txn  = PT.NewFolder(folder_level_1_info);616    folder_level_1_info.guid = await folder_level_1_txn.transact();617    folder_level_2_info.parentGuid = folder_level_1_info.guid;618    let folder_level_2_txn = PT.NewFolder(folder_level_2_info);619    folder_level_2_info.guid = await folder_level_2_txn.transact();620    return [folder_level_1_txn, folder_level_2_txn];621  });622  let original_folder_level_1_tree =623    await PlacesUtils.promiseBookmarksTree(folder_level_1_info.guid);624  let original_folder_level_2_tree =625    Object.assign({ parentGuid: original_folder_level_1_tree.guid },626                  original_folder_level_1_tree.children[0]);627  ensureUndoState([[folder_level_2_txn_result, folder_level_1_txn_result]]);628  await ensureItemsAdded(folder_level_1_info, folder_level_2_info);629  observer.reset();630  let remove_folder_2_txn = PT.Remove(folder_level_2_info);631  await remove_folder_2_txn.transact();632  ensureUndoState([ [remove_folder_2_txn],633                    [folder_level_2_txn_result, folder_level_1_txn_result] ]);634  await ensureItemsRemoved(folder_level_2_info);635  // Undo Remove "Folder Level 2"636  await PT.undo();637  ensureUndoState([ [remove_folder_2_txn],638                    [folder_level_2_txn_result, folder_level_1_txn_result] ], 1);639  await ensureItemsAdded(folder_level_2_info);640  await ensureBookmarksTreeRestoredCorrectly(original_folder_level_2_tree);641  observer.reset();642  // Redo Remove "Folder Level 2"643  await PT.redo();644  ensureUndoState([ [remove_folder_2_txn],645                    [folder_level_2_txn_result, folder_level_1_txn_result] ]);646  await ensureItemsRemoved(folder_level_2_info);647  observer.reset();648  // Undo it again649  await PT.undo();650  ensureUndoState([ [remove_folder_2_txn],651                    [folder_level_2_txn_result, folder_level_1_txn_result] ], 1);652  await ensureItemsAdded(folder_level_2_info);653  await ensureBookmarksTreeRestoredCorrectly(original_folder_level_2_tree);654  observer.reset();655  // Undo the creation of both folders656  await PT.undo();657  ensureUndoState([ [remove_folder_2_txn],658                    [folder_level_2_txn_result, folder_level_1_txn_result] ], 2);659  await ensureItemsRemoved(folder_level_2_info, folder_level_1_info);660  observer.reset();661  // Redo the creation of both folders662  await PT.redo();663  ensureUndoState([ [remove_folder_2_txn],664                    [folder_level_2_txn_result, folder_level_1_txn_result] ], 1);665  await ensureItemsAdded(folder_level_1_info, folder_level_2_info);666  await ensureBookmarksTreeRestoredCorrectlyExceptDates(original_folder_level_1_tree);667  observer.reset();668  // Redo Remove "Folder Level 2"669  await PT.redo();670  ensureUndoState([ [remove_folder_2_txn],671                    [folder_level_2_txn_result, folder_level_1_txn_result] ]);672  await ensureItemsRemoved(folder_level_2_info);673  observer.reset();674  // Undo everything one last time675  await PT.undo();676  ensureUndoState([ [remove_folder_2_txn],677                    [folder_level_2_txn_result, folder_level_1_txn_result] ], 1);678  await ensureItemsAdded(folder_level_2_info);679  observer.reset();680  await PT.undo();681  ensureUndoState([ [remove_folder_2_txn],682                    [folder_level_2_txn_result, folder_level_1_txn_result] ], 2);683  await ensureItemsRemoved(folder_level_2_info, folder_level_2_info);684  observer.reset();685  await PT.clearTransactionsHistory();686  ensureUndoState();687});688add_task(async function test_add_and_remove_bookmarks_with_additional_info() {689  const testURI = NetUtil.newURI("http://add.remove.tag");690  const TAG_1 = "TestTag1";691  const TAG_2 = "TestTag2";692  const ANNO = { name: "TestAnno", value: "TestAnnoValue" };693  let folder_info = createTestFolderInfo();694  folder_info.guid = await PT.NewFolder(folder_info).transact();695  let ensureTags = ensureTagsForURI.bind(null, testURI);696  // Check that the NewBookmark transaction preserves tags.697  observer.reset();698  let b1_info = { parentGuid: folder_info.guid, url: testURI, tags: [TAG_1] };699  b1_info.guid = await PT.NewBookmark(b1_info).transact();700  let b1_originalInfo = await PlacesUtils.promiseBookmarksTree(b1_info.guid);701  ensureTags([TAG_1]);702  await PT.undo();703  ensureTags([]);704  observer.reset();705  await PT.redo();706  await ensureBookmarksTreeRestoredCorrectly(b1_originalInfo);707  ensureTags([TAG_1]);708  // Check if the Remove transaction removes and restores tags of children709  // correctly.710  await PT.Remove(folder_info.guid).transact();711  ensureTags([]);712  observer.reset();713  await PT.undo();714  await ensureBookmarksTreeRestoredCorrectly(b1_originalInfo);715  ensureTags([TAG_1]);716  await PT.redo();717  ensureTags([]);718  observer.reset();719  await PT.undo();720  await ensureBookmarksTreeRestoredCorrectly(b1_originalInfo);721  ensureTags([TAG_1]);722  // * Check that no-op tagging (the uri is already tagged with TAG_1) is723  //   also a no-op on undo.724  observer.reset();725  let b2_info = { parentGuid:  folder_info.guid,726                  url:         testURI,727                  tags:        [TAG_1, TAG_2],728                  annotations: [ANNO] };729  b2_info.guid = await PT.NewBookmark(b2_info).transact();730  let b2_post_creation_changes = [731   { guid: b2_info.guid,732     isAnnoProperty: true,733     property: ANNO.name,734     newValue: ANNO.value } ];735  ensureItemsChanged(...b2_post_creation_changes);736  ensureTags([TAG_1, TAG_2]);737  observer.reset();738  await PT.undo();739  await ensureItemsRemoved(b2_info);740  ensureTags([TAG_1]);741  // Check if Remove correctly restores tags and annotations.742  observer.reset();743  await PT.redo();744  ensureItemsChanged({ guid: b2_info.guid,745                       isAnnoProperty: true,746                       property: ANNO.name,747                       newValue: ANNO.value });748  ensureTags([TAG_1, TAG_2]);749  // Test Remove for multiple items.750  observer.reset();751  await PT.Remove(b1_info.guid).transact();752  await PT.Remove(b2_info.guid).transact();753  await PT.Remove(folder_info.guid).transact();754  await ensureItemsRemoved(b1_info, b2_info, folder_info);755  ensureTags([]);756  observer.reset();757  await PT.undo();758  await ensureItemsAdded(folder_info);759  ensureTags([]);760  observer.reset();761  await PT.undo();762  ensureItemsChanged(...b2_post_creation_changes);763  ensureTags([TAG_1, TAG_2]);764  observer.reset();765  await PT.undo();766  await ensureItemsAdded(b1_info);767  ensureTags([TAG_1, TAG_2]);768  // The redo calls below cleanup everything we did.769  observer.reset();770  await PT.redo();771  await ensureItemsRemoved(b1_info);772  ensureTags([TAG_1, TAG_2]);773  observer.reset();774  await PT.redo();775  await ensureItemsRemoved(b2_info);776  ensureTags([]);777  observer.reset();778  await PT.redo();779  await ensureItemsRemoved(folder_info);780  ensureTags([]);781  await PT.clearTransactionsHistory();782  ensureUndoState();783});784add_task(async function test_creating_and_removing_a_separator() {785  let folder_info = createTestFolderInfo();786  let separator_info = {};787  let undoEntries = [];788  observer.reset();789  let create_txns = await PT.batch(async function() {790    let folder_txn = PT.NewFolder(folder_info);791    folder_info.guid = separator_info.parentGuid = await folder_txn.transact();792    let separator_txn = PT.NewSeparator(separator_info);793    separator_info.guid = await separator_txn.transact();794    return [separator_txn, folder_txn];795  });796  undoEntries.unshift(create_txns);797  ensureUndoState(undoEntries, 0);798  ensureItemsAdded(folder_info, separator_info);799  observer.reset();800  await PT.undo();801  ensureUndoState(undoEntries, 1);802  ensureItemsRemoved(folder_info, separator_info);803  observer.reset();804  await PT.redo();805  ensureUndoState(undoEntries, 0);806  ensureItemsAdded(folder_info, separator_info);807  observer.reset();808  let remove_sep_txn = PT.Remove(separator_info);809  await remove_sep_txn.transact();810  undoEntries.unshift([remove_sep_txn]);811  ensureUndoState(undoEntries, 0);812  ensureItemsRemoved(separator_info);813  observer.reset();814  await PT.undo();815  ensureUndoState(undoEntries, 1);816  ensureItemsAdded(separator_info);817  observer.reset();818  await PT.undo();819  ensureUndoState(undoEntries, 2);820  ensureItemsRemoved(folder_info, separator_info);821  observer.reset();822  await PT.redo();823  ensureUndoState(undoEntries, 1);824  ensureItemsAdded(folder_info, separator_info);825  // Clear redo entries and check that |redo| does nothing826  observer.reset();827  await PT.clearTransactionsHistory(false, true);828  undoEntries.shift();829  ensureUndoState(undoEntries, 0);830  await PT.redo();831  ensureItemsAdded();832  ensureItemsRemoved();833  // Cleanup834  observer.reset();835  await PT.undo();836  ensureUndoState(undoEntries, 1);837  ensureItemsRemoved(folder_info, separator_info);838  await PT.clearTransactionsHistory();839  ensureUndoState();840});841add_task(async function test_add_and_remove_livemark() {842  let createLivemarkTxn = PT.NewLivemark(843    { feedUrl: NetUtil.newURI("http://test.remove.livemark"),844      parentGuid: rootGuid,845      title: "Test Remove Livemark" });846  let guid = await createLivemarkTxn.transact();847  let originalInfo = await PlacesUtils.promiseBookmarksTree(guid);848  Assert.ok(originalInfo);849  await ensureLivemarkCreatedByAddLivemark(guid);850  let removeTxn = PT.Remove(guid);851  await removeTxn.transact();852  await ensureNonExistent(guid);853  async function undo() {854    ensureUndoState([[removeTxn], [createLivemarkTxn]], 0);855    await PT.undo();856    ensureUndoState([[removeTxn], [createLivemarkTxn]], 1);857    await ensureBookmarksTreeRestoredCorrectly(originalInfo);858    await PT.undo();859    ensureUndoState([[removeTxn], [createLivemarkTxn]], 2);860    await ensureNonExistent(guid);861  }862  async function redo() {863    ensureUndoState([[removeTxn], [createLivemarkTxn]], 2);864    await PT.redo();865    ensureUndoState([[removeTxn], [createLivemarkTxn]], 1);866    await ensureBookmarksTreeRestoredCorrectly(originalInfo);867    await PT.redo();868    ensureUndoState([[removeTxn], [createLivemarkTxn]], 0);869    await ensureNonExistent(guid);870  }871  await undo();872  await redo();873  await undo();874  await redo();875  // Cleanup876  await undo();877  observer.reset();878  await PT.clearTransactionsHistory();879});880add_task(async function test_edit_title() {881  let bm_info = { parentGuid: rootGuid,882                  url:        NetUtil.newURI("http://test_create_item.com"),883                  title:      "Original Title" };884  function ensureTitleChange(aCurrentTitle) {885    ensureItemsChanged({ guid: bm_info.guid,886                         property: "title",887                         newValue: aCurrentTitle});888  }889  bm_info.guid = await PT.NewBookmark(bm_info).transact();890  observer.reset();891  await PT.EditTitle({ guid: bm_info.guid, title: "New Title" }).transact();892  ensureTitleChange("New Title");893  observer.reset();894  await PT.undo();895  ensureTitleChange("Original Title");896  observer.reset();897  await PT.redo();898  ensureTitleChange("New Title");899  // Cleanup900  observer.reset();901  await PT.undo();902  ensureTitleChange("Original Title");903  await PT.undo();904  ensureItemsRemoved(bm_info);905  await PT.clearTransactionsHistory();906  ensureUndoState();907});908add_task(async function test_edit_url() {909  let oldURI = NetUtil.newURI("http://old.test_editing_item_uri.com/");910  let newURI = NetUtil.newURI("http://new.test_editing_item_uri.com/");911  let bm_info = { parentGuid: rootGuid, url: oldURI, tags: ["TestTag"] };912  function ensureURIAndTags(aPreChangeURI, aPostChangeURI, aOLdURITagsPreserved) {913    ensureItemsChanged({ guid: bm_info.guid,914                         property: "uri",915                         newValue: aPostChangeURI.spec });916    ensureTagsForURI(aPostChangeURI, bm_info.tags);917    ensureTagsForURI(aPreChangeURI, aOLdURITagsPreserved ? bm_info.tags : []);918  }919  bm_info.guid = await PT.NewBookmark(bm_info).transact();920  ensureTagsForURI(oldURI, bm_info.tags);921  // When there's a single bookmark for the same url, tags should be moved.922  observer.reset();923  await PT.EditUrl({ guid: bm_info.guid, url: newURI }).transact();924  ensureURIAndTags(oldURI, newURI, false);925  observer.reset();926  await PT.undo();927  ensureURIAndTags(newURI, oldURI, false);928  observer.reset();929  await PT.redo();930  ensureURIAndTags(oldURI, newURI, false);931  observer.reset();932  await PT.undo();933  ensureURIAndTags(newURI, oldURI, false);934  // When there're multiple bookmarks for the same url, tags should be copied.935  let bm2_info = Object.create(bm_info);936  bm2_info.guid = await PT.NewBookmark(bm2_info).transact();937  let bm3_info = Object.create(bm_info);938  bm3_info.url = newURI;939  bm3_info.guid = await PT.NewBookmark(bm3_info).transact();940  observer.reset();941  await PT.EditUrl({ guid: bm_info.guid, url: newURI }).transact();942  ensureURIAndTags(oldURI, newURI, true);943  observer.reset();944  await PT.undo();945  ensureURIAndTags(newURI, oldURI, true);946  observer.reset();947  await PT.redo();948  ensureURIAndTags(oldURI, newURI, true);949  // Cleanup950  observer.reset();951  await PT.undo();952  ensureURIAndTags(newURI, oldURI, true);953  await PT.undo();954  await PT.undo();955  await PT.undo();956  ensureItemsRemoved(bm3_info, bm2_info, bm_info);957  await PT.clearTransactionsHistory();958  ensureUndoState();959});960add_task(async function test_edit_keyword() {961  let bm_info = { parentGuid: rootGuid,962                  url: NetUtil.newURI("http://test.edit.keyword") };963  const KEYWORD = "test_keyword";964  bm_info.guid = await PT.NewBookmark(bm_info).transact();965  function ensureKeywordChange(aCurrentKeyword = "") {966    ensureItemsChanged({ guid: bm_info.guid,967                         property: "keyword",968                         newValue: aCurrentKeyword });969  }970  bm_info.guid = await PT.NewBookmark(bm_info).transact();971  observer.reset();972  await PT.EditKeyword({ guid: bm_info.guid, keyword: KEYWORD, postData: "postData" }).transact();973  ensureKeywordChange(KEYWORD);974  let entry = await PlacesUtils.keywords.fetch(KEYWORD);975  Assert.equal(entry.url.href, bm_info.url.spec);976  Assert.equal(entry.postData, "postData");977  observer.reset();978  await PT.undo();979  ensureKeywordChange();980  entry = await PlacesUtils.keywords.fetch(KEYWORD);981  Assert.equal(entry, null);982  observer.reset();983  await PT.redo();984  ensureKeywordChange(KEYWORD);985  entry = await PlacesUtils.keywords.fetch(KEYWORD);986  Assert.equal(entry.url.href, bm_info.url.spec);987  Assert.equal(entry.postData, "postData");988  // Cleanup989  observer.reset();990  await PT.undo();991  ensureKeywordChange();992  await PT.undo();993  ensureItemsRemoved(bm_info);994  await PT.clearTransactionsHistory();995  ensureUndoState();996});997add_task(async function test_edit_specific_keyword() {998  let bm_info = { parentGuid: rootGuid,999                  url: NetUtil.newURI("http://test.edit.keyword") };1000  bm_info.guid = await PT.NewBookmark(bm_info).transact();1001  function ensureKeywordChange(aCurrentKeyword = "", aPreviousKeyword = "") {1002    ensureItemsChanged({ guid: bm_info.guid,1003                         property: "keyword",1004                         newValue: aCurrentKeyword1005                       });1006  }1007  await PlacesUtils.keywords.insert({ keyword: "kw1", url: bm_info.url.spec, postData: "postData1" });1008  await PlacesUtils.keywords.insert({ keyword: "kw2", url: bm_info.url.spec, postData: "postData2" });1009  bm_info.guid = await PT.NewBookmark(bm_info).transact();1010  observer.reset();1011  await PT.EditKeyword({ guid: bm_info.guid, keyword: "keyword", oldKeyword: "kw2" }).transact();1012  ensureKeywordChange("keyword", "kw2");1013  let entry = await PlacesUtils.keywords.fetch("kw1");1014  Assert.equal(entry.url.href, bm_info.url.spec);1015  Assert.equal(entry.postData, "postData1");1016  entry = await PlacesUtils.keywords.fetch("keyword");1017  Assert.equal(entry.url.href, bm_info.url.spec);1018  Assert.equal(entry.postData, "postData2");1019  entry = await PlacesUtils.keywords.fetch("kw2");1020  Assert.equal(entry, null);1021  observer.reset();1022  await PT.undo();1023  ensureKeywordChange("kw2", "keyword");1024  entry = await PlacesUtils.keywords.fetch("kw1");1025  Assert.equal(entry.url.href, bm_info.url.spec);1026  Assert.equal(entry.postData, "postData1");1027  entry = await PlacesUtils.keywords.fetch("kw2");1028  Assert.equal(entry.url.href, bm_info.url.spec);1029  Assert.equal(entry.postData, "postData2");1030  entry = await PlacesUtils.keywords.fetch("keyword");1031  Assert.equal(entry, null);1032  observer.reset();1033  await PT.redo();1034  ensureKeywordChange("keyword", "kw2");1035  entry = await PlacesUtils.keywords.fetch("kw1");1036  Assert.equal(entry.url.href, bm_info.url.spec);1037  Assert.equal(entry.postData, "postData1");1038  entry = await PlacesUtils.keywords.fetch("keyword");1039  Assert.equal(entry.url.href, bm_info.url.spec);1040  Assert.equal(entry.postData, "postData2");1041  entry = await PlacesUtils.keywords.fetch("kw2");1042  Assert.equal(entry, null);1043  // Cleanup1044  observer.reset();1045  await PT.undo();1046  ensureKeywordChange("kw2");1047  await PT.undo();1048  ensureItemsRemoved(bm_info);1049  await PT.clearTransactionsHistory();1050  ensureUndoState();1051});1052add_task(async function test_tag_uri() {1053  // This also tests passing uri specs.1054  let bm_info_a = { url: "http://bookmarked.uri",1055                    parentGuid: rootGuid };1056  let bm_info_b = { url: NetUtil.newURI("http://bookmarked2.uri"),1057                    parentGuid: rootGuid };1058  let unbookmarked_uri = NetUtil.newURI("http://un.bookmarked.uri");1059  await PT.batch(async function() {1060    bm_info_a.guid = await PT.NewBookmark(bm_info_a).transact();1061    bm_info_b.guid = await PT.NewBookmark(bm_info_b).transact();1062  });1063  async function doTest(aInfo) {1064    let urls = "url" in aInfo ? [aInfo.url] : aInfo.urls;1065    let tags = "tag" in aInfo ? [aInfo.tag] : aInfo.tags;1066    let ensureURI = url => typeof(url) == "string" ? NetUtil.newURI(url) : url;1067    urls = urls.map(ensureURI);1068    let tagWillAlsoBookmark = new Set();1069    for (let url of urls) {1070      if (!(await bmsvc.fetch({ url }))) {1071        tagWillAlsoBookmark.add(url);1072      }1073    }1074    async function ensureTagsSet() {1075      for (let url of urls) {1076        ensureTagsForURI(url, tags);1077        Assert.ok(await bmsvc.fetch({ url }));1078      }1079    }1080    async function ensureTagsUnset() {1081      for (let url of urls) {1082        ensureTagsForURI(url, []);1083        if (tagWillAlsoBookmark.has(url))1084          Assert.ok(!(await bmsvc.fetch({ url })));1085        else1086          Assert.ok(await bmsvc.fetch({ url }));1087      }1088    }1089    await PT.Tag(aInfo).transact();1090    await ensureTagsSet();1091    await PT.undo();1092    await ensureTagsUnset();1093    await PT.redo();1094    await ensureTagsSet();1095    await PT.undo();1096    await ensureTagsUnset();1097  }1098  await doTest({ url: bm_info_a.url, tags: ["MyTag"] });1099  await doTest({ urls: [bm_info_a.url], tag: "MyTag" });1100  await doTest({ urls: [bm_info_a.url, bm_info_b.url], tags: ["A, B"] });1101  await doTest({ urls: [bm_info_a.url, unbookmarked_uri], tag: "C" });1102  // Cleanup1103  observer.reset();1104  await PT.undo();1105  ensureItemsRemoved(bm_info_a, bm_info_b);1106  await PT.clearTransactionsHistory();1107  ensureUndoState();1108});1109add_task(async function test_untag_uri() {1110  let bm_info_a = { url: NetUtil.newURI("http://bookmarked.uri"),1111                    parentGuid: rootGuid,1112                    tags: ["A", "B"] };1113  let bm_info_b = { url: NetUtil.newURI("http://bookmarked2.uri"),1114                    parentGuid: rootGuid,1115                    tag: "B" };1116  await PT.batch(async function() {1117    bm_info_a.guid = await PT.NewBookmark(bm_info_a).transact();1118    ensureTagsForURI(bm_info_a.url, bm_info_a.tags);1119    bm_info_b.guid = await PT.NewBookmark(bm_info_b).transact();1120    ensureTagsForURI(bm_info_b.url, [bm_info_b.tag]);1121  });1122  async function doTest(aInfo) {1123    let urls, tagsRemoved;1124    if (aInfo instanceof Ci.nsIURI) {1125      urls = [aInfo];1126      tagsRemoved = [];1127    } else if (Array.isArray(aInfo)) {1128      urls = aInfo;1129      tagsRemoved = [];1130    } else {1131      urls = "url" in aInfo ? [aInfo.url] : aInfo.urls;1132      tagsRemoved = "tag" in aInfo ? [aInfo.tag] : aInfo.tags;1133    }1134    let preRemovalTags = new Map();1135    for (let url of urls) {1136      preRemovalTags.set(url, tagssvc.getTagsForURI(url));1137    }1138    function ensureTagsSet() {1139      for (let url of urls) {1140        ensureTagsForURI(url, preRemovalTags.get(url));1141      }1142    }1143    function ensureTagsUnset() {1144      for (let url of urls) {1145        let expectedTags = tagsRemoved.length == 0 ?1146           [] : preRemovalTags.get(url).filter(tag => !tagsRemoved.includes(tag));1147        ensureTagsForURI(url, expectedTags);1148      }1149    }1150    await PT.Untag(aInfo).transact();1151    await ensureTagsUnset();1152    await PT.undo();1153    await ensureTagsSet();1154    await PT.redo();1155    await ensureTagsUnset();1156    await PT.undo();1157    await ensureTagsSet();1158  }1159  await doTest(bm_info_a);1160  await doTest(bm_info_b);1161  await doTest(bm_info_a.url);1162  await doTest(bm_info_b.url);1163  await doTest([bm_info_a.url, bm_info_b.url]);1164  await doTest({ urls: [bm_info_a.url, bm_info_b.url], tags: ["A", "B"] });1165  await doTest({ urls: [bm_info_a.url, bm_info_b.url], tag: "B" });1166  await doTest({ urls: [bm_info_a.url, bm_info_b.url], tag: "C" });1167  await doTest({ urls: [bm_info_a.url, bm_info_b.url], tags: ["C"] });1168  // Cleanup1169  observer.reset();1170  await PT.undo();1171  ensureItemsRemoved(bm_info_a, bm_info_b);1172  await PT.clearTransactionsHistory();1173  ensureUndoState();1174});1175add_task(async function test_annotate() {1176  let bm_info = { url: NetUtil.newURI("http://test.item.annotation"),1177                  parentGuid: rootGuid };1178  let anno_info = { name: "TestAnno", value: "TestValue" };1179  function ensureAnnoState(aSet) {1180    ensureAnnotationsSet(bm_info.guid,1181                         [{ name: anno_info.name,1182                            value: aSet ? anno_info.value : null }]);1183  }1184  bm_info.guid = await PT.NewBookmark(bm_info).transact();1185  observer.reset();1186  await PT.Annotate({ guid: bm_info.guid, annotation: anno_info }).transact();1187  ensureAnnoState(true);1188  observer.reset();1189  await PT.undo();1190  ensureAnnoState(false);1191  observer.reset();1192  await PT.redo();1193  ensureAnnoState(true);1194  // Test removing the annotation by not passing the |value| property.1195  observer.reset();1196  await PT.Annotate({ guid: bm_info.guid,1197                      annotation: { name: anno_info.name }}).transact();1198  ensureAnnoState(false);1199  observer.reset();1200  await PT.undo();1201  ensureAnnoState(true);1202  observer.reset();1203  await PT.redo();1204  ensureAnnoState(false);1205  // Cleanup1206  await PT.undo();1207  observer.reset();1208});1209add_task(async function test_annotate_multiple() {1210  let guid = await PT.NewFolder(createTestFolderInfo()).transact();1211  let itemId = await PlacesUtils.promiseItemId(guid);1212  function AnnoObj(aName, aValue) {1213    this.name = aName;1214    this.value = aValue;1215    this.flags = 0;1216    this.expires = Ci.nsIAnnotationService.EXPIRE_NEVER;1217  }1218  function annos(a = null, b = null) {1219    return [new AnnoObj("A", a), new AnnoObj("B", b)];1220  }1221  function verifyAnnoValues(a = null, b = null) {1222    let currentAnnos = PlacesUtils.getAnnotationsForItem(itemId);1223    let expectedAnnos = [];1224    if (a !== null)1225      expectedAnnos.push(new AnnoObj("A", a));1226    if (b !== null)1227      expectedAnnos.push(new AnnoObj("B", b));1228    Assert.deepEqual(currentAnnos, expectedAnnos);1229  }1230  await PT.Annotate({ guid, annotations: annos(1, 2) }).transact();1231  verifyAnnoValues(1, 2);1232  await PT.undo();1233  verifyAnnoValues();1234  await PT.redo();1235  verifyAnnoValues(1, 2);1236  await PT.Annotate({ guid,1237                      annotation: { name: "A" } }).transact();1238  verifyAnnoValues(null, 2);1239  await PT.Annotate({ guid,1240                      annotation: { name: "B", value: 0 } }).transact();1241  verifyAnnoValues(null, 0);1242  await PT.undo();1243  verifyAnnoValues(null, 2);1244  await PT.redo();1245  verifyAnnoValues(null, 0);1246  await PT.undo();1247  verifyAnnoValues(null, 2);1248  await PT.undo();1249  verifyAnnoValues(1, 2);1250  await PT.undo();1251  verifyAnnoValues();1252  // Cleanup1253  await PT.undo();1254  observer.reset();1255});1256add_task(async function test_sort_folder_by_name() {1257  let folder_info = createTestFolderInfo();1258  let url = NetUtil.newURI("http://sort.by.name/");1259  let preSep =  ["3", "2", "1"].map(i => ({ title: i, url }));1260  let sep = {};1261  let postSep = ["c", "b", "a"].map(l => ({ title: l, url }));1262  let originalOrder = [...preSep, sep, ...postSep];1263  let sortedOrder = [...preSep.slice(0).reverse(),1264                     sep,1265                     ...postSep.slice(0).reverse()];1266  await PT.batch(async function() {1267    folder_info.guid = await PT.NewFolder(folder_info).transact();1268    for (let info of originalOrder) {1269      info.parentGuid = folder_info.guid;1270      info.guid = await (info == sep ?1271                    PT.NewSeparator(info).transact() :1272                    PT.NewBookmark(info).transact());1273    }1274  });1275  let folderId = await PlacesUtils.promiseItemId(folder_info.guid);1276  let folderContainer = PlacesUtils.getFolderContents(folderId).root;1277  function ensureOrder(aOrder) {1278    for (let i = 0; i < folderContainer.childCount; i++) {1279      do_check_eq(folderContainer.getChild(i).bookmarkGuid, aOrder[i].guid);1280    }1281  }1282  ensureOrder(originalOrder);1283  await PT.SortByName(folder_info.guid).transact();1284  ensureOrder(sortedOrder);1285  await PT.undo();1286  ensureOrder(originalOrder);1287  await PT.redo();1288  ensureOrder(sortedOrder);1289  // Cleanup1290  observer.reset();1291  await PT.undo();1292  ensureOrder(originalOrder);1293  await PT.undo();1294  ensureItemsRemoved(...originalOrder, folder_info);1295});1296add_task(async function test_livemark_txns() {1297  let livemark_info =1298    { feedUrl: NetUtil.newURI("http://test.feed.uri"),1299      parentGuid: rootGuid,1300      title: "Test Livemark" };1301  function ensureLivemarkAdded() {1302    ensureItemsAdded({ guid:       livemark_info.guid,1303                       title:      livemark_info.title,1304                       parentGuid: livemark_info.parentGuid,1305                       itemType:   bmsvc.TYPE_FOLDER });1306    let annos = [{ name:  PlacesUtils.LMANNO_FEEDURI,1307                   value: livemark_info.feedUrl.spec }];1308    if ("siteUrl" in livemark_info) {1309      annos.push({ name: PlacesUtils.LMANNO_SITEURI,1310                   value: livemark_info.siteUrl.spec });1311    }1312    ensureAnnotationsSet(livemark_info.guid, annos);1313  }1314  function ensureLivemarkRemoved() {1315    ensureItemsRemoved({ guid:       livemark_info.guid,1316                         parentGuid: livemark_info.parentGuid });1317  }1318  async function _testDoUndoRedoUndo() {1319    observer.reset();1320    livemark_info.guid = await PT.NewLivemark(livemark_info).transact();1321    ensureLivemarkAdded();1322    observer.reset();1323    await PT.undo();1324    ensureLivemarkRemoved();1325    observer.reset();1326    await PT.redo();1327    ensureLivemarkAdded();1328    await PT.undo();1329    ensureLivemarkRemoved();1330  }1331  await _testDoUndoRedoUndo()1332  livemark_info.siteUrl = NetUtil.newURI("http://feed.site.uri");1333  await _testDoUndoRedoUndo();1334  // Cleanup1335  observer.reset();1336  await PT.clearTransactionsHistory();1337});1338add_task(async function test_copy() {1339  async function duplicate_and_test(aOriginalGuid) {1340    let txn = PT.Copy({ guid: aOriginalGuid, newParentGuid: rootGuid });1341    let duplicateGuid = await txn.transact();1342    let originalInfo = await PlacesUtils.promiseBookmarksTree(aOriginalGuid);1343    let duplicateInfo = await PlacesUtils.promiseBookmarksTree(duplicateGuid);1344    await ensureEqualBookmarksTrees(originalInfo, duplicateInfo, false);1345    async function redo() {1346      await PT.redo();1347      await ensureBookmarksTreeRestoredCorrectlyExceptDates(originalInfo);1348      await PT.redo();1349      await ensureBookmarksTreeRestoredCorrectlyExceptDates(duplicateInfo);1350    }1351    async function undo() {1352      await PT.undo();1353      // also undo the original item addition.1354      await PT.undo();1355      await ensureNonExistent(aOriginalGuid, duplicateGuid);1356    }1357    await undo();1358    await redo();1359    await undo();1360    await redo();1361    // Cleanup. This also remove the original item.1362    await PT.undo();1363    observer.reset();1364    await PT.clearTransactionsHistory();1365  }1366  // Test duplicating leafs (bookmark, separator, empty folder)1367  PT.NewBookmark({ url: new URL("http://test.item.duplicate"),1368                   parentGuid: rootGuid,1369                   annos: [{ name: "Anno", value: "AnnoValue"}] });1370  let sepTxn = PT.NewSeparator({ parentGuid: rootGuid, index: 1 });1371  let livemarkTxn = PT.NewLivemark(1372    { feedUrl: new URL("http://test.feed.uri"),1373      parentGuid: rootGuid,1374      title: "Test Livemark", index: 1 });1375  let emptyFolderTxn = PT.NewFolder(createTestFolderInfo());1376  for (let txn of [livemarkTxn, sepTxn, emptyFolderTxn]) {1377    let guid = await txn.transact();1378    await duplicate_and_test(guid);1379  }1380  // Test duplicating a folder having some contents.1381  let filledFolderGuid = await PT.batch(async function() {1382    let folderGuid = await PT.NewFolder(createTestFolderInfo()).transact();1383    let nestedFolderGuid =1384      await PT.NewFolder({ parentGuid: folderGuid,1385                           title: "Nested Folder" }).transact();1386    // Insert a bookmark under the nested folder.1387    await PT.NewBookmark({ url: new URL("http://nested.nested.bookmark"),1388                           parentGuid: nestedFolderGuid }).transact();1389    // Insert a separator below the nested folder1390    await PT.NewSeparator({ parentGuid: folderGuid }).transact();1391    // And another bookmark.1392    await PT.NewBookmark({ url: new URL("http://nested.bookmark"),1393                           parentGuid: folderGuid }).transact();1394    return folderGuid;1395  });1396  await duplicate_and_test(filledFolderGuid);1397  // Cleanup1398  await PT.clearTransactionsHistory();1399});1400add_task(async function test_array_input_for_batch() {1401  let folderTxn = PT.NewFolder(createTestFolderInfo());1402  let folderGuid = await folderTxn.transact();1403  let sep1_txn = PT.NewSeparator({ parentGuid: folderGuid });1404  let sep2_txn = PT.NewSeparator({ parentGuid: folderGuid });1405  await PT.batch([sep1_txn, sep2_txn]);1406  ensureUndoState([[sep2_txn, sep1_txn], [folderTxn]], 0);1407  let ensureChildCount = async function(count) {1408    let tree = await PlacesUtils.promiseBookmarksTree(folderGuid);1409    if (count == 0)1410      Assert.ok(!("children" in tree));1411    else1412      Assert.equal(tree.children.length, count);1413  };1414  await ensureChildCount(2);1415  await PT.undo();1416  await ensureChildCount(0);1417  await PT.redo()1418  await ensureChildCount(2);1419  await PT.undo();1420  await ensureChildCount(0);1421  await PT.undo();1422  Assert.equal((await PlacesUtils.promiseBookmarksTree(folderGuid)), null);1423  // Cleanup1424  await PT.clearTransactionsHistory();1425});1426add_task(async function test_copy_excluding_annotations() {1427  let folderInfo = createTestFolderInfo();1428  let anno = n => { return { name: n, value: 1 } };1429  folderInfo.annotations = [anno("a"), anno("b"), anno("c")];1430  let folderGuid = await PT.NewFolder(folderInfo).transact();1431  let ensureAnnosSet = async function(guid, ...expectedAnnoNames) {1432    let tree = await PlacesUtils.promiseBookmarksTree(guid);1433    let annoNames = "annos" in tree ?1434                      tree.annos.map(a => a.name).sort() : [];1435    Assert.deepEqual(annoNames, expectedAnnoNames);1436  };1437  await ensureAnnosSet(folderGuid, "a", "b", "c");1438  let excluding_a_dupeGuid =1439    await PT.Copy({ guid: folderGuid,1440                    newParentGuid: rootGuid,1441                    excludingAnnotation: "a" }).transact();1442  await ensureAnnosSet(excluding_a_dupeGuid, "b", "c");1443  let excluding_ac_dupeGuid =1444    await PT.Copy({ guid: folderGuid,1445                    newParentGuid: rootGuid,1446                    excludingAnnotations: ["a", "c"] }).transact();1447  await ensureAnnosSet(excluding_ac_dupeGuid, "b");1448  // Cleanup1449  await PT.undo();1450  await PT.undo();1451  await PT.undo();1452  await PT.clearTransactionsHistory();1453});1454add_task(async function test_invalid_uri_spec_throws() {1455  Assert.throws(() =>1456    PT.NewBookmark({ parentGuid: rootGuid,1457                     url:        "invalid uri spec",1458                     title:      "test bookmark" }));1459  Assert.throws(() =>1460    PT.Tag({ tag: "TheTag",1461             urls: ["invalid uri spec"] }));1462  Assert.throws(() =>1463    PT.Tag({ tag: "TheTag",1464             urls: ["about:blank", "invalid uri spec"] }));1465});1466add_task(async function test_annotate_multiple_items() {1467  let parentGuid = menuGuid;1468  let guids = [1469    await PT.NewBookmark({ url: "about:blank", parentGuid }).transact(),1470    await PT.NewFolder({ title: "Test Folder", parentGuid }).transact()];1471  let annotation = { name: "TestAnno", value: "TestValue" };1472  await PT.Annotate({ guids, annotation }).transact();1473  async function ensureAnnoSet() {1474    for (let guid of guids) {1475      let itemId = await PlacesUtils.promiseItemId(guid);1476      Assert.equal(annosvc.getItemAnnotation(itemId, annotation.name),1477                   annotation.value);1478    }1479  }1480  async function ensureAnnoUnset() {1481    for (let guid of guids) {1482      let itemId = await PlacesUtils.promiseItemId(guid);1483      Assert.ok(!annosvc.itemHasAnnotation(itemId, annotation.name));1484    }1485  }1486  await ensureAnnoSet();1487  await PT.undo();1488  await ensureAnnoUnset();1489  await PT.redo();1490  await ensureAnnoSet();1491  await PT.undo();1492  await ensureAnnoUnset();1493  // Cleanup1494  await PT.undo();1495  await PT.undo();1496  await ensureNonExistent(...guids);1497  await PT.clearTransactionsHistory();1498  observer.reset();1499});1500add_task(async function test_remove_multiple() {1501  let guids = [];1502  await PT.batch(async function() {1503    let folderGuid = await PT.NewFolder({ title: "Test Folder",1504                                          parentGuid: menuGuid }).transact();1505    let nestedFolderGuid =1506      await PT.NewFolder({ title: "Nested Test Folder",1507                           parentGuid: folderGuid }).transact();1508    await PT.NewSeparator(nestedFolderGuid).transact();1509    guids.push(folderGuid);1510    let bmGuid =1511      await PT.NewBookmark({ url: new URL("http://test.bookmark.removed"),1512                             parentGuid: menuGuid }).transact();1513    guids.push(bmGuid);1514  });1515  let originalInfos = [];1516  for (let guid of guids) {1517    originalInfos.push(await PlacesUtils.promiseBookmarksTree(guid));1518  }1519  await PT.Remove(guids).transact();1520  await ensureNonExistent(...guids);1521  await PT.undo();1522  await ensureBookmarksTreeRestoredCorrectly(...originalInfos);1523  await PT.redo();1524  await ensureNonExistent(...guids);1525  await PT.undo();1526  await ensureBookmarksTreeRestoredCorrectly(...originalInfos);1527  // Undo the New* transactions batch.1528  await PT.undo();1529  await ensureNonExistent(...guids);1530  // Redo it.1531  await PT.redo();1532  await ensureBookmarksTreeRestoredCorrectlyExceptDates(...originalInfos);1533  // Redo remove.1534  await PT.redo();1535  await ensureNonExistent(...guids);1536  // Cleanup1537  await PT.clearTransactionsHistory();1538  observer.reset();...

indexdb.ts

Source:indexdb.ts

1import { Restaurants } from '../../../both/collections/restaurant/restaurant.collection';2import { UserDetails } from '../../../both/collections/auth/user-detail.collection';3import { Sections } from '../../../both/collections/menu/section.collection';4import { Categories } from '../../../both/collections/menu/category.collection';5import { Subcategories } from '../../../both/collections/menu/subcategory.collection';6import { Additions } from '../../../both/collections/menu/addition.collection';7import { Items } from '../../../both/collections/menu/item.collection';8import { GarnishFoodCol } from '../../../both/collections/menu/garnish-food.collection';9import { PaymentMethods } from '../../../both/collections/general/paymentMethod.collection';10import { PaymentsHistory } from '../../../both/collections/payment/payment-history.collection';11import { Accounts } from '../../../both/collections/restaurant/account.collection';12import { Orders } from '../../../both/collections/restaurant/order.collection';13import { Tables } from '../../../both/collections/restaurant/table.collection';14import { Payments } from '../../../both/collections/restaurant/payment.collection';15import { WaiterCallDetails } from '../../../both/collections/restaurant/waiter-call-detail.collection';16import { CcPaymentMethods } from '../../../both/collections/payment/cc-payment-methods.collection';17import { PaymentTransactions } from '../../../both/collections/payment/payment-transaction.collection';18import { Invoices } from '../../../both/collections/restaurant/invoice.collection';19import { Cities } from '../../../both/collections/general/city.collection';20import { Countries } from '../../../both/collections/general/country.collection';21import { Languages } from '../../../both/collections/general/language.collection';22export function createdbindexes(){23    // Restaurant Collection Indexes24    Restaurants.collection._ensureIndex( { creation_user: 1 } );25    Restaurants.collection._ensureIndex( { name: 1 } );    26    Restaurants.collection._ensureIndex( { isActive: 1 } );    27    // User Collections Indexes28    UserDetails.collection._ensureIndex( { user_id: 1 } );29    UserDetails.collection._ensureIndex( { restaurant_work: 1 } );30    UserDetails.collection._ensureIndex( { current_restaurant: 1, current_table: 1 } );    31    // Section Collection Indexes32    Sections.collection._ensureIndex( { creation_user: 1 } );33    Sections.collection._ensureIndex( { restaurants: 1 } );    34    // Category Collection Indexes35    Categories.collection._ensureIndex( { creation_user: 1 } );36    Categories.collection._ensureIndex( { section: 1 } );    37    // Subcategory Collection Indexes38    Subcategories.collection._ensureIndex( { creation_user: 1 } );39    Subcategories.collection._ensureIndex( { category: 1 } );40    // Addition Collection Indexes41    Additions.collection._ensureIndex( { creation_user: 1 } );42    Additions.collection._ensureIndex( { restaurants: 1 } );    43    // Item Collection Indexes44    Items.collection._ensureIndex( { additionsIsAccepted: 1 } );45    Items.collection._ensureIndex( { garnishFoodIsAcceped: 1 } );46    Items.collection._ensureIndex( { creation_user: 1 } );47    Items.collection._ensureIndex( { sectionId: 1 } );48    Items.collection._ensureIndex( { restaurants: 1 } );49    // GarnishFood Collection Indexes50    GarnishFoodCol.collection._ensureIndex( { creation_user: 1 } );51    GarnishFoodCol.collection._ensureIndex( { restaurants: 1 } );52    // PaymentMethod Collection Indexes53    PaymentMethods.collection._ensureIndex( { isActive: 1 } );   54    55    // PaymentsHistory Collection Indexes56    PaymentsHistory.collection._ensureIndex( { restaurantIds: 1 } );57    PaymentsHistory.collection._ensureIndex( { creation_user: 1 } );58    PaymentsHistory.collection._ensureIndex( { creation_date: 1 } );59    // Accounts Collection Indexes60    Accounts.collection._ensureIndex( { restaurantId: 1 } );61    Accounts.collection._ensureIndex( { status: 1 } );62    Accounts.collection._ensureIndex( { tableId: 1 } );63    // Tables Collection Indexes64    Tables.collection._ensureIndex( { QR_code: 1 } );65    Tables.collection._ensureIndex( { restaurantId: 1 } );    66    // Orders Collection Indexes67    Orders.collection._ensureIndex( { restaurantId: 1 } );68    Orders.collection._ensureIndex( { tableId: 1 } );69    Orders.collection._ensureIndex( { status: 1 } );70    Orders.collection._ensureIndex( { accountId: 1 } );71    // Payments Collection Indexes72    Payments.collection._ensureIndex( { creation_user: 1 } );73    Payments.collection._ensureIndex( { restaurantId: 1, tableId: 1, status: 1 } );74    75    // WaiterCallDetails Collection Indexes76    WaiterCallDetails.collection._ensureIndex( { status: 1 } );77    WaiterCallDetails.collection._ensureIndex( { user_id: 1 } );78    WaiterCallDetails.collection._ensureIndex( { restaurant_id: 1, table_id: 1, type: 1 } );    79    // CcPaymentMethods Collection Indexes80    CcPaymentMethods.collection._ensureIndex( { is_active: 1 } );81    // PaymentTransactions Collection Indexes82    PaymentTransactions.collection._ensureIndex( { creation_user: 1 } );83    // Invoices Collection Indexes84    Invoices.collection._ensureIndex( { customer_id: 1 } );85    // Cities Collection Indexes86    Cities.collection._ensureIndex( { country: 1 } );87    Cities.collection._ensureIndex( { is_active: 1 } );88    // Countries Collection Indexes89    Countries.collection._ensureIndex( { is_active: 1 } );90    // Languages Collection Indexes91    Languages.collection._ensureIndex( { is_active: 1 } );...

RequireEnsurePlugin.js

Source:RequireEnsurePlugin.js

1/*2	MIT License http://www.opensource.org/licenses/mit-license.php3	Author Tobias Koppers @sokra4*/5"use strict";6const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");7const RequireEnsureDependency = require("./RequireEnsureDependency");8const NullFactory = require("../NullFactory");9const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");10const ParserHelpers = require("../ParserHelpers");11class RequireEnsurePlugin {12	apply(compiler) {13		compiler.hooks.compilation.tap(14			"RequireEnsurePlugin",15			(compilation, { normalModuleFactory }) => {16				compilation.dependencyFactories.set(17					RequireEnsureItemDependency,18					normalModuleFactory19				);20				compilation.dependencyTemplates.set(21					RequireEnsureItemDependency,22					new RequireEnsureItemDependency.Template()23				);24				compilation.dependencyFactories.set(25					RequireEnsureDependency,26					new NullFactory()27				);28				compilation.dependencyTemplates.set(29					RequireEnsureDependency,30					new RequireEnsureDependency.Template()31				);32				const handler = (parser, parserOptions) => {33					if (34						typeof parserOptions.requireEnsure !== "undefined" &&35						!parserOptions.requireEnsure36					)37						return;38					new RequireEnsureDependenciesBlockParserPlugin().apply(parser);39					parser.hooks.evaluateTypeof40						.for("require.ensure")41						.tap(42							"RequireEnsurePlugin",43							ParserHelpers.evaluateToString("function")44						);45					parser.hooks.typeof46						.for("require.ensure")47						.tap(48							"RequireEnsurePlugin",49							ParserHelpers.toConstantDependency(50								parser,51								JSON.stringify("function")52							)53						);54				};55				normalModuleFactory.hooks.parser56					.for("javascript/auto")57					.tap("RequireEnsurePlugin", handler);58				normalModuleFactory.hooks.parser59					.for("javascript/dynamic")60					.tap("RequireEnsurePlugin", handler);61			}62		);63	}64}...

Using AI Code Generation

1import { ensure } from 'storybook-root';2import { storiesOf } from '@storybook/react';3import { action } from '@storybook/addon-actions';4import React from 'react';5import Button from './Button';6storiesOf('Button', module)7  .add('with text', () => (8    <Button onClick={action('clicked')}>Hello Button</Button>9  .add('with some emoji', () => (10    <Button onClick={action('clicked')}>11  ));12import { ensure } from 'storybook-root';13import { storiesOf } from '@storybook/react';14import { action } from '@storybook/addon-actions';15import React from 'react';16import Button from './Button';17storiesOf('Button', module)18  .add('with text', () => (19    <Button onClick={action('clicked')}>Hello Button</Button>20  .add('with some emoji', () => (21    <Button onClick={action('clicked')}>22  ));23import { ensure } from 'storybook-root';24import { storiesOf } from '@storybook/react';25import { action } from '@storybook/addon-actions';26import React from 'react';27import Button from './Button';28storiesOf('Button', module)29  .add('with text', () => (30    <Button onClick={action('clicked')}>Hello Button</Button>31  .add('with some emoji', () => (32    <Button onClick={action('clicked')}>33  ));34import { ensure } from 'storybook-root';35import { storiesOf } from '@storybook/react';36import { action } from '@storybook/addon-actions';37import React from 'react';38import Button from './Button';39storiesOf('Button', module)40  .add('with text', () => (41    <Button onClick={

Using AI Code Generation

1import { ensure } from 'storybook-root';2import { storiesOf } from '@storybook/react';3import { withInfo } from '@storybook/addon-info';4const stories = storiesOf('Button', module);5stories.addDecorator(withInfo);6ensure(stories, 'with text', () => <Button>Hello Button</Button>);7import { ensure } from 'storybook-root';8import { storiesOf } from '@storybook/react';9import { withInfo } from '@storybook/addon-info';10const stories = storiesOf('Button', module);11stories.addDecorator(withInfo);12ensure(stories, 'with text', () => <Button>Hello Button</Button>);13import { ensure } from 'storybook-root';14import { storiesOf } from '@storybook/react';15import { withInfo } from '@storybook/addon-info';16const stories = storiesOf('Button', module);17stories.addDecorator(withInfo);18ensure(stories, 'with text', () => <Button>Hello Button</Button>);19import { ensure } from 'storybook-root';20import { storiesOf } from '@storybook/react';21import { withInfo } from '@storybook/addon-info';22const stories = storiesOf('Button', module);23stories.addDecorator(withInfo);24ensure(stories, 'with text', () => <Button>Hello Button</Button>);25import { ensure } from 'storybook-root';26import { storiesOf } from '@storybook/react';27import { withInfo } from '@storybook/addon-info';28const stories = storiesOf('Button', module);29stories.addDecorator(withInfo);30ensure(stories, 'with text', () => <Button>Hello Button</Button>);31import { ensure } from 'storybook-root';32import { storiesOf } from '@storybook/react';33import { withInfo } from '@storybook/addon-info';34const stories = storiesOf('Button', module);35stories.addDecorator(withInfo);36ensure(stories, 'with text', () => <Button>Hello Button</Button>);37import { ensure } from 'storybook-root';38import { storiesOf } from '@storybook/react';39import { withInfo } from '@storybook/addon-info';40const stories = storiesOf('Button', module);

Using AI Code Generation

1import { ensure } from "storybook-root-saga";2import { takeEvery } from "redux-saga/effects";3function* testSaga() {4}5export default function* rootSaga() {6  yield ensure("TEST_SAGA", takeEvery, "TEST_SAGA", testSaga);7}8import { configure } from "@storybook/react";9import { setAddon, addDecorator } from "@storybook/react";10import { withInfo } from "@storybook/addon-info";11import JSXAddon from "storybook-addon-jsx";12import { withKnobs } from "@storybook/addon-knobs";13import { Provider } from "react-redux";14import { createStore, applyMiddleware } from "redux";15import createSagaMiddleware from "redux-saga";16import rootReducer from "../src/reducers";17import rootSaga from "../src/sagas";18const sagaMiddleware = createSagaMiddleware();19const store = createStore(rootReducer, applyMiddleware(sagaMiddleware));20sagaMiddleware.run(rootSaga);21addDecorator(22  withInfo({23  })24);25addDecorator(withKnobs);26setAddon(JSXAddon);27addDecorator(story => <Provider store={store}>{story()}</Provider>);28configure(() => require("../src/stories"), module);29const path = require("path");30module.exports = ({ config }) => {31  config.module.rules.push({32    include: path.resolve(__dirname, "../src"),33      {34        loader: require.resolve("babel-loader"),35        options: {36          presets: [["es2015", { modules: false }], "react"]37        }38      }39  });40  return config;41};42import { combineReducers } from "redux";43import { reducer as formReducer } from "redux-form";44const rootReducer = combineReducers({45});46export default rootReducer;47import { all } from "redux-saga/effects";48import testSaga from "./test";49export default function* rootSaga() {50  yield all([testSaga()]);51}

Using AI Code Generation

1import { ensure } from 'storybook-root';2import { storiesOf } from '@storybook/react';3import React from 'react';4storiesOf('Test', module)5  .add('Test', () => {6    ensure('Test', 'Test');7    return <div>Test</div>;8  });9import { ensure } from 'storybook-root';10import { storiesOf } from '@storybook/react';11import React from 'react';12storiesOf('Test', module)13  .add('Test', () => {14    ensure('Test', 'Test');15    return <div>Test</div>;16  });17import { ensure } from 'storybook-root';18import { storiesOf } from '@storybook/react';19import React from 'react';20storiesOf('Test', module)21  .add('Test', () => {22    ensure('Test', 'Test');23    return <div>Test</div>;24  });25import { ensure } from 'storybook-root';26import { storiesOf } from '@storybook/react';27import React from 'react';28storiesOf('Test', module)29  .add('Test', () => {30    ensure('Test', 'Test');31    return <div>Test</div>;32  });33import { ensure } from 'storybook-root';34import { storiesOf } from '@storybook/react';35import React from 'react';36storiesOf('Test', module)37  .add('Test', () => {38    ensure('Test', 'Test');39    return <div>Test</div>;40  });41import { ensure } from 'storybook-root';42import { storiesOf } from '@storybook/react';43import React from 'react';44storiesOf('Test', module)45  .add('Test', () => {46    ensure('Test', 'Test');47    return <div>Test</div>;48  });49import { ensure } from 'storybook-root';50import { storiesOf } from '@storybook/react';51import React from 'react';

Using AI Code Generation

1import { ensure } from 'storybook-root';2const test = () => {3  ensure('storybook-root');4  return 'storybook-root';5};6export default test;7import test from './test';8describe('test', () => {9  it('should return storybook-root', () => {10    expect(test()).toBe('storybook-root');11  });12});13import { configure } from '@storybook/react';14import { ensure } from 'storybook-root';15ensure('storybook-root');16import { addDecorator } from '@storybook/react';17import { ensure } from 'storybook-root';18ensure('storybook-root');19import { addons } from '@storybook/addons';20import { ensure } from 'storybook-root';21ensure('storybook-root');22import '@storybook/addon-actions/register';23import '@storybook/addon-links/register';24import { ensure } from 'storybook-root';25ensure('storybook-root');26const path = require('path');27const { ensure } = require('storybook-root');28ensure('storybook-root');29module.exports = ({ config }) => {30  config.module.rules.push({31    test: /\.(ts|tsx)$/,32    include: path.resolve(__dirname, '../'),33      {34        loader: require.resolve('awesome-typescript-loader'),35        options: {36        },37      },38      {39        loader: require.resolve('react-docgen-typescript-loader'),40      },41  });42  config.resolve.extensions.push('.ts', '.tsx');43  return config;44};45{46  "compilerOptions": {

Using AI Code Generation

1export default function* rootSaga() {2  yield ensure([3    authSaga(),4  ]);5}6export default function* authSaga() {7  yield takeLatest(AUTH_REQUEST, authRequest);8}9export const AUTH_REQUEST = 'AUTH_REQUEST';10export const AUTH_SUCCESS = 'AUTH_SUCCESS';11export const AUTH_FAILURE = 'AUTH_FAILURE';12export const authRequest = createAction(AUTH_REQUEST);13export const authSuccess = createAction(AUTH_SUCCESS);14export const authFailure = createAction(AUTH_FAILURE);15import { createReducer } from 'reduxsauce';16import { AUTH_REQUEST, AUTH_SUCCESS, AUTH_FAILURE } from './actions';17export const INITIAL_STATE = {18};19const authRequest = state => ({20});21const authSuccess = (state, { user }) => ({22});23const authFailure = (state, { error }) => ({24});25export default createReducer(INITIAL_STATE, {26});27import React, { Component } from 'react';28import { connect } from 'react-redux';29import { authRequest } from '../actions';30import { Button } from 'react-native';31class AuthContainer extends Component {32  render() {33    const { authRequest } = this.props;34    return (35        onPress={() => authRequest({ email: '

Using AI Code Generation

1import { ensure } from 'storybook-root';2ensure('test', {3});4import { assert } from 'storybook-root';5describe('test', () => {6  it('test', () => {7    assert('test', {8    });9  });10});11import { assert } from 'storybook-root';12describe('test', () => {13  it('test', () => {14    assert('test', {15    });16  });17});18import { assert } from 'storybook-root';19describe('test', () => {20  it('test', () => {21    assert('test', {22    });23  });24});25import { assert } from 'storybook-root';26describe('test', () => {27  it('test', () => {28    assert('test', {29    });30  });31});32import { assert } from 'storybook-root';33describe('test', () => {34  it('test', () => {35    assert('test', {36    });37  });38});39import { assert } from 'storybook-root';40describe('test', () => {41  it('test', () => {42    assert('test', {43    });44  });45});46import { assert } from 'storybook-root';47describe('test', () => {48  it('test', () => {49    assert('test', {50    });51  });52});53import { assert } from 'storybook-root';54describe('test', () => {55  it('test', () => {56    assert('test', {57    });58  });59});

Using AI Code Generation

1import {ensure} from '@storybook-root';2const {expect} = chai;3describe('test', () => {4    it('should work', () => {5        expect(ensure).to.be.a('function');6    });7});8import {ensure} from '@storybook-root';9const {expect} = chai;10describe('test', () => {11    it('should work', () => {12        expect(ensure).to.be.a('function');13    });14});15import {ensure} from '@storybook-root';16const {expect} = chai;17describe('test', () => {18    it('should work', () => {19        expect(ensure).to.be.a('function');20    });21});22import {ensure} from '@storybook-root';23const {expect} = chai;24describe('test', () => {25    it('should work', () => {26        expect(ensure).to.be.a('function');27    });28});29import {ensure} from '@storybook-root';30const {expect} = chai;31describe('test', () => {32    it('should work', () => {33        expect(ensure).to.be.a('function');34    });35});36import {ensure} from '@storybook-root';37const {expect} = chai;38describe('test', () => {39    it('should work', () => {40        expect(ensure).to.be.a('function');41    });42});43import {ensure} from '@storybook-root';44const {expect} = chai;45describe('test', () => {46    it('should work', () => {47        expect(ensure).to.be.a('function');48    });49});50import {ensure} from '@storybook-root';51const {expect} = chai;52describe('test', () => {53    it('should work', () => {54        expect(ensure).to.be.a('function');55    });56});

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.