MD Bookmarks: Allow 'complex' actions to access the page state directly

chrome/test/data/webui/md_bookmarks/reducers_test.js

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+/**
+ * Helper method for creating a 'remove-bookmark' action.
+ * @param {string} id
+ * @param {string} parentId
+ * @param {number} index
+ * @param {!Array<string>} descendants
+ * @return {!Action}
+ */
+function remove(id, parentId, index, descendants) {
+  descendants.push(id);
+  return bookmarks.actions.removeBookmarkSubtree(
+      id, parentId, index, new Set(descendants));
+}
+
 suite('selection state', function() {
   var state;
   var action;
 
-  function select(items, anchor, add) {
-    return {
-      name: 'select-items',
-      add: add,
-      anchor: anchor,
-      items: items,
-    };
-  }
-
   setup(function() {
     state = {
       anchor: null,
       items: {},
     };
   });
 
   test('can select an item', function() {
-    action = select(['1'], '1', false);
+    action = bookmarks.actions.selectItemSet(['1'], '1', false);
     state = bookmarks.SelectionState.updateSelection(state, action);
 
     assertDeepEquals(['1'], normalizeSet(state.items));
     assertEquals('1', state.anchor);
 
     // Replace current selection.
-    action = select(['2'], '2', false);
+    action = bookmarks.actions.selectItemSet(['2'], '2', false);
     state = bookmarks.SelectionState.updateSelection(state, action);
     assertDeepEquals(['2'], normalizeSet(state.items));
     assertEquals('2', state.anchor);
 
     // Add to current selection.
-    action = select(['3'], '3', true);
+    action = bookmarks.actions.selectItemSet(['3'], '3', true);
     state = bookmarks.SelectionState.updateSelection(state, action);
     assertDeepEquals(['2', '3'], normalizeSet(state.items));
     assertEquals('3', state.anchor);
   });
 
   test('can select multiple items', function() {
-    action = select(['1', '2', '3'], '3', false);
+    action = bookmarks.actions.selectItemSet(['1', '2', '3'], '3', false);
     state = bookmarks.SelectionState.updateSelection(state, action);
     assertDeepEquals(['1', '2', '3'], normalizeSet(state.items));
 
-    action = select(['3', '4'], '4', true);
+    action = bookmarks.actions.selectItemSet(['3', '4'], '4', true);
     state = bookmarks.SelectionState.updateSelection(state, action);
     assertDeepEquals(['1', '2', '3', '4'], normalizeSet(state.items));
   });
 
   test('is cleared when selected folder changes', function() {
-    action = select(['1', '2', '3'], '3', false);
+    action = bookmarks.actions.selectItemSet(['1', '2', '3'], '3', false);
     state = bookmarks.SelectionState.updateSelection(state, action);
 
     action = bookmarks.actions.selectFolder('2');
     state = bookmarks.SelectionState.updateSelection(state, action);
     assertDeepEquals({}, state.items);
   });
 
   test('is cleared when search finished', function() {
-    action = select(['1', '2', '3'], '3', false);
+    action = bookmarks.actions.selectItemSet(['1', '2', '3'], '3', false);
     state = bookmarks.SelectionState.updateSelection(state, action);
 
     action = bookmarks.actions.setSearchResults(['2']);
     state = bookmarks.SelectionState.updateSelection(state, action);
     assertDeepEquals({}, state.items);
   });
 
   test('is cleared when search cleared', function() {
-    action = select(['1', '2', '3'], '3', false);
+    action = bookmarks.actions.selectItemSet(['1', '2', '3'], '3', false);
     state = bookmarks.SelectionState.updateSelection(state, action);
 
     action = bookmarks.actions.clearSearch();
     state = bookmarks.SelectionState.updateSelection(state, action);
     assertDeepEquals({}, state.items);
   });
 
   test('deselect items', function() {
-    action = select(['1', '2', '3'], '3', false);
+    action = bookmarks.actions.selectItemSet(['1', '2', '3'], '3', false);
     state = bookmarks.SelectionState.updateSelection(state, action);
 
     action = bookmarks.actions.deselectItems();
     state = bookmarks.SelectionState.updateSelection(state, action);
     assertDeepEquals({}, state.items);
   });
 
   test('deselects items when they are deleted', function() {
     var nodeList = testTree(createFolder('0', [
       createFolder(
           '1',
           [
             createItem('2'),
             createItem('3'),
             createItem('4'),
           ]),
       createItem('5'),
     ]));
 
-    action = select(['2', '4', '5'], '4', false);
+    action = bookmarks.actions.selectItemSet(['2', '4', '5'], '4', false);
     state = bookmarks.SelectionState.updateSelection(state, action);
 
-    action = bookmarks.actions.removeBookmark('1', '0', 0, nodeList);
+    action = remove('1', '0', 0, ['2', '3', '4']);
     state = bookmarks.SelectionState.updateSelection(state, action);
 
     assertDeepEquals(['5'], normalizeSet(state.items));
     assertEquals(null, state.anchor);
   });
 });
 
 suite('closed folder state', function() {
   var nodes;
   var state;
@@ skipping 88 matching lines @@
         state, action, nodes);
     assertEquals('1', state);
   });
 
   test('selects ancestor when selected folder is deleted', function() {
     action = bookmarks.actions.selectFolder('3');
     state = bookmarks.SelectedFolderState.updateSelectedFolder(
         state, action, nodes);
 
     // Delete the selected folder:
-    action = bookmarks.actions.removeBookmark('3', '2', 0, nodes);
+    action = remove('3', '2', 0, []);
     state = bookmarks.SelectedFolderState.updateSelectedFolder(
         state, action, nodes);
 
     assertEquals('2', state);
 
     action = bookmarks.actions.selectFolder('4');
     state = bookmarks.SelectedFolderState.updateSelectedFolder(
         state, action, nodes);
 
     // Delete an ancestor of the selected folder:
-    action = bookmarks.actions.removeBookmark('2', '1', 0, nodes);
+    action = remove('2', '1', 0, ['3']);
     state = bookmarks.SelectedFolderState.updateSelectedFolder(
         state, action, nodes);
 
     assertEquals('1', state);
   });
 });
 
 suite('node state', function() {
   var state;
   var action;
@@ skipping 61 matching lines @@
 
     action = bookmarks.actions.createBookmark(item.id, item);
     state = bookmarks.NodeState.updateNodes(state, action);
 
     assertEquals('6', state['7'].parentId);
     assertEquals(undefined, state['7'].children);
     assertDeepEquals(['7'], state['6'].children);
   });
 
   test('updates when a node is deleted', function() {
-    action = bookmarks.actions.removeBookmark('3', '1', 1, state);
+    action = remove('3', '1', 1, []);
     state = bookmarks.NodeState.updateNodes(state, action);
 
     assertDeepEquals(['2', '4'], state['1'].children);
 
     assertDeepEquals(['2', '4'], state['1'].children);
     assertEquals(undefined, state['3']);
   });
 
   test('removes all children of deleted nodes', function() {
-    action = bookmarks.actions.removeBookmark('1', '0', 0, state);
+    action = remove('1', '0', 0, ['2', '3', '4']);
     state = bookmarks.NodeState.updateNodes(state, action);
 
     assertDeepEquals(['0', '5'], Object.keys(state).sort());
   });
 
   test('updates when a node is moved', function() {
     // Move within the same folder backwards.
     action = bookmarks.actions.moveBookmark('3', '1', 0, '1', 1);
     state = bookmarks.NodeState.updateNodes(state, action);
 
@@ skipping 76 matching lines @@
 
   test('removes deleted nodes', function() {
     var action;
 
     action = bookmarks.actions.setSearchTerm('test');
     state = bookmarks.reduceAction(state, action);
 
     action = bookmarks.actions.setSearchResults(['1', '3', '2']);
     state = bookmarks.reduceAction(state, action);
 
-    action = bookmarks.actions.removeBookmark('2', '1', 0, state.nodes);
+    action = remove('2', '1', 0, ['3']);
     state = bookmarks.reduceAction(state, action);
 
     // 2 and 3 should be removed, since 2 was deleted and 3 was a descendant of
     // 2.
     assertDeepEquals(['1'], state.search.results);
   });
 });