mirror of
https://github.com/zotero/zotero.git
synced 2026-08-28 05:25:31 +00:00
9c03a93e00
Closes #5974. Additional fixes for broken item tree behaviour when multiple items are selected, and changing focus with ctrl/cmd-arrow keys. Aligned Collection Tree/Virtualized Tree collapse/expand behaviour when multiple containers are selected, one of them is focused, and arrow key left-right is pressed, to the behaviour in Item Tree - now all of them are collapsed/expanded. --------- Co-authored-by: Dan Stillman <dstillman@zotero.org>
3686 lines
136 KiB
JavaScript
3686 lines
136 KiB
JavaScript
// Integration tests for CollectionViewItemTree via ZoteroPane.itemsView.
|
||
// Inherited ItemTree/ItemTreeRowProvider behavior is also tested through
|
||
// the CVIT instance.
|
||
"use strict";
|
||
|
||
describe("CollectionViewItemTree", function () {
|
||
var win, zp, cv, itemsView;
|
||
var existingItemID;
|
||
var existingItemID2;
|
||
|
||
// Load Zotero pane and select library
|
||
before(async function () {
|
||
win = await loadZoteroPane();
|
||
zp = win.ZoteroPane;
|
||
cv = zp.collectionsView;
|
||
|
||
var item1 = await createDataObject('item', { setTitle: true });
|
||
existingItemID = item1.id;
|
||
var item2 = await createDataObject('item');
|
||
existingItemID2 = item2.id;
|
||
});
|
||
beforeEach(async function () {
|
||
await selectLibrary(win);
|
||
itemsView = zp.itemsView;
|
||
itemsView._columnsId = null;
|
||
});
|
||
after(function () {
|
||
win.close();
|
||
});
|
||
|
||
it("shouldn't show items in trash in library root", async function () {
|
||
var item = await createDataObject('item', { title: "foo" });
|
||
var itemID = item.id;
|
||
item.deleted = true;
|
||
await item.saveTx();
|
||
assert.isFalse(itemsView.getRowIndexByID(itemID));
|
||
});
|
||
|
||
it("shouldn't show items in subcollections in trash when recursiveCollections=true", async function () {
|
||
Zotero.Prefs.set('recursiveCollections', true);
|
||
var c1 = await createDataObject('collection');
|
||
var c2 = await createDataObject('collection', { parentID: c1.id });
|
||
var c3 = await createDataObject('collection', { parentID: c1.id, deleted: true });
|
||
var item1 = await createDataObject('item', { collections: [c2.id] });
|
||
var item2 = await createDataObject('item', { collections: [c3.id] });
|
||
|
||
await select(win, c1);
|
||
// item2 is in a deleted collection and shouldn't be shown
|
||
assert.sameMembers(zp.itemsView._rows.map(x => x.id), [item1.id]);
|
||
|
||
Zotero.Prefs.clear('recursiveCollections');
|
||
});
|
||
|
||
describe("when performing a quick search", function () {
|
||
let quicksearch;
|
||
|
||
before(() => {
|
||
quicksearch = win.document.getElementById('zotero-tb-search-textbox');
|
||
});
|
||
after(async () => {
|
||
quicksearch.value = "";
|
||
quicksearch.doCommand();
|
||
await itemsView._refreshPromise;
|
||
Zotero.Prefs.set("hideContextAnnotationRows", false);
|
||
});
|
||
|
||
describe("when issuing a Select All command", function () {
|
||
let parentItem, match;
|
||
let selectAllEvent = { key: 'a' };
|
||
|
||
before(async function () {
|
||
parentItem = await createDataObject('item');
|
||
match = await importFileAttachment('test.png', { title: 'find-me', parentItemID: parentItem.id });
|
||
await importFileAttachment('test.png', { title: 'not-a-result', parentItemID: parentItem.id });
|
||
if (Zotero.isMac) {
|
||
selectAllEvent.metaKey = true;
|
||
}
|
||
else {
|
||
selectAllEvent.ctrlKey = true;
|
||
}
|
||
});
|
||
|
||
after(async function () {
|
||
await parentItem.erase();
|
||
});
|
||
|
||
it("should not select non-matching children", async function () {
|
||
quicksearch.value = match.getField('title');
|
||
quicksearch.doCommand();
|
||
await itemsView._refreshPromise;
|
||
itemsView.tree._onKeyDown(selectAllEvent);
|
||
|
||
var selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], match.id);
|
||
});
|
||
|
||
it("should expand collapsed parents with matching children", async function () {
|
||
itemsView.collapseAllRows();
|
||
var selected = itemsView.getSelectedItems(true);
|
||
// After collapse the parent item is selected
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], parentItem.id);
|
||
|
||
itemsView.tree._onKeyDown(selectAllEvent);
|
||
selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], match.id);
|
||
});
|
||
});
|
||
|
||
describe("when dragging attachments", function () {
|
||
let parentItem, childItem;
|
||
before(async () => {
|
||
parentItem = await createDataObject('item', { title: "match-parent" });
|
||
childItem = await importFileAttachment('test.png', { title: 'match-child', parentItemID: parentItem.id });
|
||
});
|
||
|
||
it("should display a child attachment when it is dragged into top level if it matches the search", async function () {
|
||
childItem.parentID = parentItem.id;
|
||
await childItem.save();
|
||
|
||
quicksearch.value = "match";
|
||
quicksearch.doCommand();
|
||
|
||
await itemsView._refreshPromise;
|
||
assert.lengthOf(itemsView._rows, 2);
|
||
assert.equal(itemsView.getRow(0).id, parentItem.id);
|
||
assert.equal(itemsView.getRow(1).id, childItem.id);
|
||
assert.equal(itemsView.getRow(1).level, 1);
|
||
|
||
// The drop effectively does this
|
||
childItem.parentID = false;
|
||
await childItem.save();
|
||
await itemsView._refreshPromise;
|
||
|
||
assert.lengthOf(itemsView._rows, 2);
|
||
assert.equal(itemsView.getRow(0).id, childItem.id);
|
||
assert.equal(itemsView.getRow(0).level, 0);
|
||
assert.equal(itemsView.getRow(1).id, parentItem.id);
|
||
});
|
||
|
||
it("should display a child attachment when it is dragged onto a parent item if it matches the search", async function () {
|
||
childItem.parentID = false;
|
||
await childItem.save();
|
||
|
||
quicksearch.value = "match";
|
||
quicksearch.doCommand();
|
||
|
||
await itemsView._refreshPromise;
|
||
assert.lengthOf(itemsView._rows, 2);
|
||
assert.equal(itemsView.getRow(0).id, childItem.id);
|
||
assert.equal(itemsView.getRow(0).level, 0);
|
||
assert.equal(itemsView.getRow(1).id, parentItem.id);
|
||
|
||
// The drop effectively does this
|
||
childItem.parentID = parentItem.id;
|
||
await childItem.save();
|
||
await itemsView._refreshPromise;
|
||
|
||
assert.lengthOf(itemsView._rows, 2);
|
||
assert.equal(itemsView.getRow(0).id, parentItem.id);
|
||
assert.equal(itemsView.getRow(1).id, childItem.id);
|
||
assert.equal(itemsView.getRow(1).level, 1);
|
||
});
|
||
});
|
||
|
||
it("should re-run the search when the quick-search mode changes", async function () {
|
||
// Term appears only in a field excluded by "Title, Creator, Year" mode
|
||
let item = createUnsavedDataObject('item', { itemType: 'journalArticle', title: 'Untitled' });
|
||
item.setField('abstractNote', 'zqsmodeterm');
|
||
await item.saveTx();
|
||
|
||
Zotero.Prefs.set('search.quicksearch-mode', 'titleCreatorYear');
|
||
quicksearch.value = 'zqsmodeterm';
|
||
await zp.search();
|
||
assert.isFalse(itemsView.getRowIndexByID(item.id));
|
||
|
||
// Changing only the mode, with the same search text, should re-run the search
|
||
Zotero.Prefs.set('search.quicksearch-mode', 'fields');
|
||
await zp.search();
|
||
assert.isNumber(itemsView.getRowIndexByID(item.id));
|
||
|
||
Zotero.Prefs.clear('search.quicksearch-mode');
|
||
await item.eraseTx();
|
||
});
|
||
|
||
it("should not clear quick search after deleting item from collection", async function () {
|
||
let col = await createDataObject('collection');
|
||
let item = await createDataObject('item', { title: "test", collections: [col.id] });
|
||
await zp.collectionsView.selectCollection(col.id);
|
||
|
||
quicksearch.value = "test";
|
||
quicksearch.doCommand();
|
||
await itemsView._refreshPromise;
|
||
|
||
await zp.itemsView.selectItems([item.id]);
|
||
item.removeFromCollection(col.id);
|
||
await item.saveTx();
|
||
|
||
await itemsView._refreshPromise;
|
||
assert.equal(quicksearch.value, "test");
|
||
});
|
||
|
||
it("should expand parent item and attachment for an annotation match", async function () {
|
||
Zotero.Prefs.set("hideContextAnnotationRows", false);
|
||
|
||
let item = await createDataObject('item', { title: "Collapsed Parent" });
|
||
let attachment = await importFileAttachment('test.pdf', { title: 'PDF', parentItemID: item.id });
|
||
let annotation = await createAnnotation('highlight', attachment, { comment: "uniqueAnnotationTerm" });
|
||
|
||
itemsView.collapseAllRows();
|
||
|
||
await zp.itemsView.setFilter('search', "uniqueAnnotationTerm");
|
||
|
||
let itemRow = itemsView.getRowIndexByID(item.id);
|
||
assert.isNumber(itemRow);
|
||
assert.isTrue(itemsView.isContainerOpen(itemRow));
|
||
|
||
let attachmentRow = itemsView.getRowIndexByID(attachment.id);
|
||
assert.isNumber(attachmentRow);
|
||
assert.isTrue(itemsView.isContainerOpen(attachmentRow));
|
||
|
||
assert.isNumber(itemsView.getRowIndexByID(annotation.id));
|
||
});
|
||
|
||
it("should keep attachment rows collapsed unless search matches annotation text when hideContextAnnotationRows=true", async function () {
|
||
Zotero.Prefs.set("hideContextAnnotationRows", true);
|
||
|
||
let item = await createDataObject('item', { title: "Item" });
|
||
// Ensure that non-file attachments that cannot have annotations do not cause any issues
|
||
await Zotero.Attachments.linkFromURL({
|
||
url: 'https://example.com',
|
||
title: 'Example',
|
||
parentItemID: item.id
|
||
});
|
||
|
||
let attachmentOne = await importFileAttachment('test.pdf', { title: 'PDF', parentItemID: item.id });
|
||
let highlightOne = await createAnnotation('highlight', attachmentOne, { comment: "Highlight te" });
|
||
let underlineOne = await createAnnotation('underline', attachmentOne, { comment: "Underline testing" });
|
||
|
||
let attachmentTwo = await importFileAttachment('test.pdf', { title: 'PDF test', parentItemID: item.id });
|
||
let highlightTwo = await createAnnotation('highlight', attachmentTwo, { comment: "Highlight te" });
|
||
|
||
// Search matching attachment title only should keep attachment rows collapsed
|
||
await zp.itemsView.setFilter('search', "PDF test");
|
||
|
||
let attachmentTwoRow = itemsView.getRowIndexByID(attachmentTwo.id);
|
||
assert.isNumber(attachmentTwoRow);
|
||
assert.isFalse(itemsView.isContainerOpen(attachmentTwoRow));
|
||
assert.isFalse(itemsView.getRowIndexByID(highlightTwo.id));
|
||
|
||
// Search matching annotation text should reveal matching annotation rows
|
||
await zp.itemsView.setFilter('search', "testing");
|
||
|
||
let attachmentOneRow = itemsView.getRowIndexByID(attachmentOne.id);
|
||
assert.isNumber(attachmentOneRow);
|
||
assert.isTrue(itemsView.isContainerOpen(attachmentOneRow));
|
||
assert.isNumber(itemsView.getRowIndexByID(underlineOne.id));
|
||
assert.isFalse(itemsView.getRowIndexByID(highlightOne.id));
|
||
assert.isFalse(itemsView.getRowIndexByID(highlightTwo.id));
|
||
});
|
||
|
||
it("should keep attachments expandable and show all annotations for non-annotation searches when hideContextAnnotationRows=true", async function () {
|
||
Zotero.Prefs.set("hideContextAnnotationRows", true);
|
||
|
||
let item = await createDataObject('item', { title: "uniqueParentTitle" });
|
||
let attachment = await importFileAttachment('test.pdf', { title: 'PDF', parentItemID: item.id });
|
||
let highlight = await createAnnotation('highlight', attachment, { comment: "comment one" });
|
||
let underline = await createAnnotation('underline', attachment, { comment: "comment two" });
|
||
|
||
// Search matches the parent item's title, not any annotation
|
||
await zp.itemsView.setFilter('search', "uniqueParentTitle");
|
||
|
||
// Expand the matched parent to reveal its attachment
|
||
let itemRow = itemsView.getRowIndexByID(item.id);
|
||
assert.isNumber(itemRow);
|
||
if (!itemsView.isContainerOpen(itemRow)) {
|
||
await itemsView.toggleOpenState(itemRow);
|
||
}
|
||
|
||
// The attachment should still be expandable even though no annotation matched
|
||
let attachmentRow = itemsView.getRowIndexByID(attachment.id);
|
||
assert.isNumber(attachmentRow);
|
||
assert.isFalse(itemsView.isContainerEmpty(attachmentRow));
|
||
|
||
// Expanding it should reveal all of its annotations rather than hiding them
|
||
if (!itemsView.isContainerOpen(attachmentRow)) {
|
||
await itemsView.toggleOpenState(attachmentRow);
|
||
}
|
||
assert.isNumber(itemsView.getRowIndexByID(highlight.id));
|
||
assert.isNumber(itemsView.getRowIndexByID(underline.id));
|
||
});
|
||
});
|
||
|
||
describe("#selectItem()", function () {
|
||
/**
|
||
* Don't hang if the pane's item-select handler is never triggered due to the item already
|
||
* being selected
|
||
*/
|
||
it("should return if item is already selected", async function () {
|
||
var numSelected = await itemsView.selectItem(existingItemID);
|
||
assert.equal(numSelected, 1);
|
||
var selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], existingItemID);
|
||
numSelected = await itemsView.selectItem(existingItemID);
|
||
assert.equal(numSelected, 1);
|
||
selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], existingItemID);
|
||
});
|
||
|
||
it("should clear tag selector when trying to select a missing item", async function () {
|
||
let itemOne = await createDataObject('item', { tags: [{ tag: 'item_tag_one' }] });
|
||
let itemTwo = await createDataObject('item');
|
||
|
||
// select a tag
|
||
await zp.tagSelector.handleTagSelected("item_tag_one");
|
||
await zp.itemsView._refreshPromise;
|
||
|
||
// ensure only the item with the tag is visible
|
||
assert.equal(zp.itemsView._rows.length, 1);
|
||
assert.equal(zp.itemsView._rows[0].id, itemOne.id);
|
||
|
||
// try to select the item without the tag
|
||
await zp.itemsView.selectItem(itemTwo.id);
|
||
|
||
// tag selector should be cleared and itemTwo - selected
|
||
assert.equal(zp.getCollectionTreeRows()[0].tags.size, 0);
|
||
assert.equal(zp.tagSelector.selectedTags.size, 0);
|
||
assert.equal(zp.itemsView.getSelectedItems()[0].id, itemTwo.id);
|
||
});
|
||
});
|
||
|
||
describe("#selectItems()", function () {
|
||
/**
|
||
* Don't hang if the pane's item-select handler is never triggered due to the items already
|
||
* being selected
|
||
*/
|
||
it("should return if all items are already selected", async function () {
|
||
var itemIDs = [existingItemID, existingItemID2];
|
||
var numSelected = await itemsView.selectItems(itemIDs);
|
||
assert.equal(numSelected, 2);
|
||
var selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 2);
|
||
assert.sameMembers(selected, itemIDs);
|
||
numSelected = await itemsView.selectItems(itemIDs);
|
||
assert.equal(numSelected, 2);
|
||
selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 2);
|
||
assert.sameMembers(selected, itemIDs);
|
||
});
|
||
|
||
|
||
it("should expand parent items to select children", async function () {
|
||
var item1 = await createDataObject('item');
|
||
var item2 = await createDataObject('item');
|
||
var item3 = await createDataObject('item');
|
||
var note1 = await createDataObject('item', { itemType: 'note', parentID: item1.id });
|
||
var note2 = await createDataObject('item', { itemType: 'note', parentID: item2.id });
|
||
var note3 = await createDataObject('item', { itemType: 'note', parentID: item3.id });
|
||
|
||
// one of the items has an attachment with annotations
|
||
var attachment = await importFileAttachment('test.pdf', { title: 'PDF', parentItemID: item1.id });
|
||
var highlight = await createAnnotation('highlight', attachment);
|
||
var underline = await createAnnotation('underline', attachment);
|
||
|
||
var toSelect = [note1.id, note2.id, note3.id, highlight.id, underline.id];
|
||
itemsView.collapseAllRows();
|
||
|
||
var numSelected = await itemsView.selectItems(toSelect);
|
||
assert.equal(numSelected, 5);
|
||
var selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 5);
|
||
assert.sameMembers(selected, toSelect);
|
||
|
||
// Again with the ids given in reverse order
|
||
itemsView.collapseAllRows();
|
||
toSelect = toSelect.reverse();
|
||
numSelected = await itemsView.selectItems(toSelect);
|
||
assert.equal(numSelected, 5);
|
||
selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 5);
|
||
assert.sameMembers(selected, toSelect);
|
||
});
|
||
});
|
||
|
||
describe("Expand/Collapse all rows", function () {
|
||
let collection, item1, item2, emptyItem, attachment1, attachment2;
|
||
|
||
before(async () => {
|
||
collection = await createDataObject('collection');
|
||
// Top-level items, attachment child per each, one annotation per attachment
|
||
item1 = await createDataObject('item', { title: 'Item 1', collections: [collection.id] });
|
||
item2 = await createDataObject('item', { title: 'Item 2', collections: [collection.id] });
|
||
attachment1 = await importFileAttachment('test.pdf', { title: 'Attachment 1', parentItemID: item1.id });
|
||
attachment2 = await importFileAttachment('test.pdf', { title: 'Attachment 2', parentItemID: item2.id });
|
||
await createAnnotation('highlight', attachment1);
|
||
await createAnnotation('highlight', attachment2);
|
||
// An empty top-level item (no children) to test that it doesn't block level progression
|
||
emptyItem = await createDataObject('item', { title: 'Empty Item', collections: [collection.id] });
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
await waitForItemsLoad(win);
|
||
});
|
||
|
||
beforeEach(async () => {
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
await waitForItemsLoad(win);
|
||
});
|
||
|
||
it("should expand all top-level rows when all rows are collapsed", async function () {
|
||
itemsView.collapseAllRows(true);
|
||
|
||
itemsView.expandAllRows();
|
||
|
||
// Top-level items should be expanded
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
|
||
// Attachments should be collapsed
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment1.id)));
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment2.id)));
|
||
});
|
||
|
||
it("should expand only collapsed top-level rows when some are already expanded", async function () {
|
||
itemsView.collapseAllRows(true);
|
||
|
||
let item1Index = itemsView.getRowIndexByID(item1.id);
|
||
await itemsView.toggleOpenState(item1Index);
|
||
|
||
itemsView.expandAllRows();
|
||
|
||
// Top-level items should be expanded
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
|
||
// Attachments should be collapsed
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment1.id)));
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment2.id)));
|
||
});
|
||
|
||
it("should expand attachment rows when all regular items are expanded", async function () {
|
||
itemsView.collapseAllRows(true);
|
||
|
||
let item1Index = itemsView.getRowIndexByID(item1.id);
|
||
let item2Index = itemsView.getRowIndexByID(item2.id);
|
||
await itemsView.toggleOpenState(item1Index);
|
||
await itemsView.toggleOpenState(item2Index);
|
||
|
||
itemsView.expandAllRows();
|
||
|
||
// All rows should be expanded
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment2.id)));
|
||
});
|
||
|
||
it("should expand all rows when some attachments are expanded", async function () {
|
||
itemsView.collapseAllRows(true);
|
||
|
||
// Expand item1 and its attachment
|
||
await itemsView.toggleOpenState(itemsView.getRowIndexByID(item1.id));
|
||
await itemsView.toggleOpenState(itemsView.getRowIndexByID(attachment1.id));
|
||
|
||
// item2 should still be collapsed at this point
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
|
||
itemsView.expandAllRows();
|
||
|
||
// All rows should be expanded
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment2.id)));
|
||
});
|
||
|
||
it("should collapse rows up one level", async function () {
|
||
itemsView.expandAllRows(true);
|
||
|
||
// All rows should be expanded
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment2.id)));
|
||
|
||
itemsView.collapseAllRows();
|
||
|
||
// All top-level items should be expanded
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item1.id)));
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
|
||
// But attachments should be collapsed
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment1.id)));
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(attachment2.id)));
|
||
});
|
||
});
|
||
|
||
describe("#getCellText()", function () {
|
||
it("should return new value after edit", async function () {
|
||
var str = Zotero.Utilities.randomString();
|
||
var item = await createDataObject('item', { title: str });
|
||
var row = itemsView.getRowIndexByID(item.id);
|
||
assert.equal(itemsView.getCellText(row, 'title'), str);
|
||
await modifyDataObject(item);
|
||
assert.notEqual(itemsView.getCellText(row, 'title'), str);
|
||
})
|
||
})
|
||
|
||
describe("#_saveOpenState() / #_restoreOpenState()", function () {
|
||
it("should restore open containers and keep closed containers closed", async function () {
|
||
let item1 = await createDataObject('item', { title: 'Item 1' });
|
||
let att1 = await importFileAttachment('test.pdf', { parentItemID: item1.id });
|
||
let ann1 = await createAnnotation('highlight', att1);
|
||
|
||
let item2 = await createDataObject('item', { title: 'Item 2' });
|
||
await importFileAttachment('test.png', { parentItemID: item2.id });
|
||
|
||
let item3 = await createDataObject('item', { title: 'Item 3' });
|
||
let att3 = await importFileAttachment('test.png', { parentItemID: item3.id });
|
||
|
||
await waitForItemsLoad(win);
|
||
|
||
let rowProvider = itemsView.rowProvider;
|
||
// Deep nesting for item1: open item1 -> attachment -> annotation path
|
||
assert.isTrue(rowProvider._expandToItem(ann1.id));
|
||
// Open item3 only
|
||
assert.isTrue(rowProvider._expandToItem(att3.id));
|
||
|
||
let item1Row = itemsView.getRowIndexByID(item1.id);
|
||
let att1Row = itemsView.getRowIndexByID(att1.id);
|
||
let item2Row = itemsView.getRowIndexByID(item2.id);
|
||
let item3Row = itemsView.getRowIndexByID(item3.id);
|
||
assert.isTrue(itemsView.isContainerOpen(item1Row));
|
||
assert.isTrue(itemsView.isContainerOpen(att1Row));
|
||
assert.isFalse(itemsView.isContainerOpen(item2Row));
|
||
assert.isTrue(itemsView.isContainerOpen(item3Row));
|
||
|
||
let openItemIDs = rowProvider._saveOpenState();
|
||
|
||
// _saveOpenState closes top-level open containers
|
||
item1Row = itemsView.getRowIndexByID(item1.id);
|
||
item2Row = itemsView.getRowIndexByID(item2.id);
|
||
item3Row = itemsView.getRowIndexByID(item3.id);
|
||
assert.isFalse(itemsView.isContainerOpen(item1Row));
|
||
assert.isFalse(itemsView.isContainerOpen(item2Row));
|
||
assert.isFalse(itemsView.isContainerOpen(item3Row));
|
||
assert.isFalse(itemsView.getRowIndexByID(att1.id));
|
||
|
||
rowProvider._restoreOpenState(openItemIDs);
|
||
|
||
item1Row = itemsView.getRowIndexByID(item1.id);
|
||
att1Row = itemsView.getRowIndexByID(att1.id);
|
||
item2Row = itemsView.getRowIndexByID(item2.id);
|
||
item3Row = itemsView.getRowIndexByID(item3.id);
|
||
assert.isTrue(itemsView.isContainerOpen(item1Row));
|
||
assert.isTrue(itemsView.isContainerOpen(att1Row));
|
||
assert.isFalse(itemsView.isContainerOpen(item2Row));
|
||
assert.isTrue(itemsView.isContainerOpen(item3Row));
|
||
});
|
||
});
|
||
|
||
describe("#toggleOpenState()", function () {
|
||
it("should preserve selection and detached focus when toggling another container", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
|
||
var parentItem = await createDataObject('item', { collections: [collection.id] });
|
||
var attachment = await importFileAttachment('test.png', { parentItemID: parentItem.id });
|
||
var item1 = await createDataObject('item', { collections: [collection.id] });
|
||
var item2 = await createDataObject('item', { collections: [collection.id] });
|
||
await waitForItemsLoad(win);
|
||
|
||
var parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
if (itemsView.isContainerOpen(parentRow)) {
|
||
await itemsView.toggleOpenState(parentRow);
|
||
await itemsView.waitForLoad();
|
||
}
|
||
await itemsView.selectItem(item1.id);
|
||
itemsView.selection.toggleSelect(itemsView.getRowIndexByID(item2.id));
|
||
itemsView.selection.focused = parentRow;
|
||
itemsView.selection.pivot = parentRow;
|
||
|
||
itemsView.tree._onKeyDown({
|
||
key: Zotero.arrowNextKey,
|
||
preventDefault: () => {},
|
||
stopPropagation: () => {}
|
||
});
|
||
await itemsView.waitForLoad();
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(parentItem.id)));
|
||
assert.sameMembers(itemsView.getSelectedItems(true), [item1.id, item2.id]);
|
||
assert.equal(itemsView.selection.focused, itemsView.getRowIndexByID(parentItem.id));
|
||
|
||
itemsView.tree._onKeyDown({
|
||
key: Zotero.arrowPreviousKey,
|
||
preventDefault: () => {},
|
||
stopPropagation: () => {}
|
||
});
|
||
await itemsView.waitForLoad();
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(parentItem.id)));
|
||
assert.sameMembers(itemsView.getSelectedItems(true), [item1.id, item2.id]);
|
||
assert.equal(itemsView.selection.focused, itemsView.getRowIndexByID(parentItem.id));
|
||
})
|
||
|
||
it("should select the parent when collapsing a selected child", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
|
||
var parentItem = await createDataObject('item', { collections: [collection.id] });
|
||
var attachment = await importFileAttachment('test.png', { parentItemID: parentItem.id });
|
||
await waitForItemsLoad(win);
|
||
|
||
var parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
if (!itemsView.isContainerOpen(parentRow)) {
|
||
await itemsView.toggleOpenState(parentRow);
|
||
await itemsView.waitForLoad();
|
||
}
|
||
await itemsView.selectItem(attachment.id);
|
||
parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
itemsView.selection.focused = parentRow;
|
||
itemsView.selection.pivot = parentRow;
|
||
// The selection changes to the parent, so a select event has to fire
|
||
var selectPromise = itemsView.waitForSelect();
|
||
await itemsView.toggleOpenState(parentRow);
|
||
await itemsView.waitForLoad();
|
||
await selectPromise;
|
||
assert.sameMembers(itemsView.getSelectedItems(true), [parentItem.id]);
|
||
assert.equal(itemsView.selection.focused, itemsView.getRowIndexByID(parentItem.id));
|
||
})
|
||
|
||
it("should keep detached focus when collapsing a selected child alongside another selected item", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
|
||
var parentItem = await createDataObject('item', { collections: [collection.id] });
|
||
var attachment = await importFileAttachment('test.png', { parentItemID: parentItem.id });
|
||
var item1 = await createDataObject('item', { collections: [collection.id] });
|
||
await waitForItemsLoad(win);
|
||
|
||
var parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
if (!itemsView.isContainerOpen(parentRow)) {
|
||
await itemsView.toggleOpenState(parentRow);
|
||
await itemsView.waitForLoad();
|
||
}
|
||
await itemsView.selectItem(item1.id);
|
||
itemsView.selection.toggleSelect(itemsView.getRowIndexByID(attachment.id));
|
||
parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
itemsView.selection.focused = parentRow;
|
||
itemsView.selection.pivot = parentRow;
|
||
|
||
var selectPromise = itemsView.waitForSelect();
|
||
await itemsView.toggleOpenState(parentRow);
|
||
await itemsView.waitForLoad();
|
||
await selectPromise;
|
||
assert.sameMembers(itemsView.getSelectedItems(true), [item1.id, parentItem.id]);
|
||
assert.equal(itemsView.selection.focused, itemsView.getRowIndexByID(parentItem.id));
|
||
})
|
||
|
||
it("should adjust focus with an empty selection when toggling a container above it", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
|
||
var ran = Zotero.Utilities.randomString();
|
||
var parentItem = await createDataObject('item', { title: ran + " AAA", collections: [collection.id] });
|
||
var attachment = await importFileAttachment('test.png', { parentItemID: parentItem.id });
|
||
var item1 = await createDataObject('item', { title: ran + " ZZZ", collections: [collection.id] });
|
||
await waitForItemsLoad(win);
|
||
|
||
var parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
if (!itemsView.isContainerOpen(parentRow)) {
|
||
await itemsView.toggleOpenState(parentRow);
|
||
await itemsView.waitForLoad();
|
||
}
|
||
var item1Row = itemsView.getRowIndexByID(item1.id);
|
||
assert.isAbove(item1Row, itemsView.getRowIndexByID(attachment.id));
|
||
// Empty the selection, leaving focus on the item
|
||
await itemsView.selectItem(item1.id);
|
||
itemsView.selection.toggleSelect(item1Row);
|
||
assert.equal(itemsView.selection.count, 0);
|
||
|
||
await itemsView.toggleOpenState(itemsView.getRowIndexByID(parentItem.id));
|
||
await itemsView.waitForLoad();
|
||
assert.equal(itemsView.selection.count, 0);
|
||
assert.equal(itemsView.selection.focused, itemsView.getRowIndexByID(item1.id));
|
||
|
||
await itemsView.toggleOpenState(itemsView.getRowIndexByID(parentItem.id));
|
||
await itemsView.waitForLoad();
|
||
assert.equal(itemsView.selection.count, 0);
|
||
assert.equal(itemsView.selection.focused, itemsView.getRowIndexByID(item1.id));
|
||
})
|
||
|
||
it("shouldn't scroll back to selected row when opening another container", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
|
||
var treebox = itemsView._treebox;
|
||
var numVisibleRows = treebox.getLastVisibleRow() - treebox.getFirstVisibleRow();
|
||
|
||
function getTitle(i, max) {
|
||
return new String(new Array(max + 1).join(0) + i).slice(-1 * max);
|
||
}
|
||
|
||
var num = numVisibleRows * 2 + 10;
|
||
var parentItem = await createDataObject('item', {
|
||
title: getTitle(0, num + 1),
|
||
collections: [collection.id]
|
||
});
|
||
await importFileAttachment('test.png', { parentItemID: parentItem.id });
|
||
|
||
var itemIDs = [];
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
for (let i = 1; i <= num; i++) {
|
||
let item = createUnsavedDataObject('item', {
|
||
title: getTitle(i, num + 1),
|
||
collections: [collection.id]
|
||
});
|
||
await item.save();
|
||
itemIDs.push(item.id);
|
||
}
|
||
});
|
||
await waitForItemsLoad(win);
|
||
|
||
var parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
var selectedItemID;
|
||
var maxDistance = -1;
|
||
for (let id of itemIDs) {
|
||
let row = itemsView.getRowIndexByID(id);
|
||
let distance = Math.abs(row - parentRow);
|
||
if (distance > maxDistance) {
|
||
maxDistance = distance;
|
||
selectedItemID = id;
|
||
}
|
||
}
|
||
assert.isAbove(maxDistance, numVisibleRows);
|
||
|
||
await itemsView.selectItem(selectedItemID);
|
||
assert.sameMembers(itemsView.getSelectedItems(true), [selectedItemID]);
|
||
|
||
treebox.scrollToRow(parentRow);
|
||
var firstVisibleBefore = treebox.getFirstVisibleRow();
|
||
assert.isFalse(itemsView.tree.rowIsVisible(itemsView.getRowIndexByID(selectedItemID)));
|
||
assert.isFalse(itemsView.isContainerOpen(parentRow));
|
||
|
||
await itemsView.toggleOpenState(parentRow);
|
||
await itemsView.waitForLoad();
|
||
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(parentItem.id)));
|
||
assert.sameMembers(itemsView.getSelectedItems(true), [selectedItemID]);
|
||
assert.equal(treebox.getFirstVisibleRow(), firstVisibleBefore);
|
||
assert.isFalse(itemsView.tree.rowIsVisible(itemsView.getRowIndexByID(selectedItemID)));
|
||
});
|
||
});
|
||
|
||
describe("#sort()", function () {
|
||
it("should ignore invalid secondary-sort field", async function () {
|
||
await createDataObject('item', { title: 'A' });
|
||
await createDataObject('item', { title: 'A' });
|
||
|
||
// Set invalid field as secondary sort for title
|
||
Zotero.Prefs.set('secondarySort.title', 'invalidField');
|
||
|
||
// Sort by title
|
||
var colIndex = itemsView.tree._getColumns().findIndex(column => column.dataKey == 'title');
|
||
await itemsView.tree._columns.toggleSort(colIndex);
|
||
|
||
var e = await getPromiseError(zp.itemsView.sort());
|
||
assert.isFalse(e);
|
||
assert.isUndefined(Zotero.Prefs.get('secondarySort.title'));
|
||
});
|
||
|
||
it("should ignore invalid fallback-sort field", async function () {
|
||
Zotero.Prefs.clear('fallbackSort');
|
||
var originalFallback = Zotero.Prefs.get('fallbackSort');
|
||
Zotero.Prefs.set('fallbackSort', 'invalidField,' + originalFallback);
|
||
|
||
// Sort by title
|
||
var colIndex = itemsView.tree._getColumns().findIndex(column => column.dataKey == 'title');
|
||
await itemsView.tree._columns.toggleSort(colIndex);
|
||
|
||
var e = await getPromiseError(zp.itemsView.sort());
|
||
assert.isFalse(e);
|
||
assert.equal(Zotero.Prefs.get('fallbackSort'), originalFallback);
|
||
});
|
||
|
||
it("should preserve open container state when sorting", async function () {
|
||
let parentItem = await createDataObject('item', { title: 'Parent' });
|
||
let attachment = await importFileAttachment('test.pdf', { parentItemID: parentItem.id });
|
||
await createAnnotation('highlight', attachment);
|
||
|
||
await waitForItemsLoad(win);
|
||
itemsView.expandAllRows(true);
|
||
await waitForItemsLoad(win);
|
||
|
||
let parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
let attachmentRow = itemsView.getRowIndexByID(attachment.id);
|
||
assert.isTrue(itemsView.isContainerOpen(parentRow));
|
||
assert.isTrue(itemsView.isContainerOpen(attachmentRow));
|
||
|
||
await itemsView.sort();
|
||
|
||
parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
attachmentRow = itemsView.getRowIndexByID(attachment.id);
|
||
assert.isTrue(itemsView.isContainerOpen(parentRow));
|
||
assert.isTrue(itemsView.isContainerOpen(attachmentRow));
|
||
});
|
||
|
||
it("should await sort context readiness before sorting", async function () {
|
||
let deferred = Zotero.Promise.defer();
|
||
let ensureStub = sinon.stub(itemsView, '_ensureSortContextReady').returns(deferred.promise);
|
||
let sortStub = sinon.stub(itemsView.rowProvider, 'sort');
|
||
|
||
try {
|
||
let sortPromise = itemsView.sort();
|
||
await Zotero.Promise.delay(20);
|
||
assert.equal(sortStub.callCount, 0);
|
||
deferred.resolve();
|
||
await sortPromise;
|
||
assert.equal(sortStub.callCount, 1);
|
||
}
|
||
finally {
|
||
sortStub.restore();
|
||
ensureStub.restore();
|
||
}
|
||
});
|
||
});
|
||
|
||
describe("#notify()", function () {
|
||
beforeEach(function () {
|
||
sinon.spy(win.ZoteroPane, "itemSelected");
|
||
})
|
||
|
||
afterEach(function () {
|
||
win.ZoteroPane.itemSelected.restore();
|
||
})
|
||
|
||
it("should select a new item", async function () {
|
||
let selectPromise = itemsView.waitForSelect();
|
||
itemsView.selection.clearSelection();
|
||
assert.lengthOf(itemsView.getSelectedItems(), 0);
|
||
|
||
await selectPromise;
|
||
assert.equal(win.ZoteroPane.itemSelected.callCount, 1);
|
||
|
||
// Create item
|
||
var item = new Zotero.Item('book');
|
||
var id = await item.saveTx();
|
||
|
||
// New item should be selected
|
||
var selected = itemsView.getSelectedItems();
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0].id, id);
|
||
|
||
// Item should have been selected once
|
||
assert.equal(win.ZoteroPane.itemSelected.callCount, 2);
|
||
assert.ok(await win.ZoteroPane.itemSelected.returnValues[1]);
|
||
});
|
||
|
||
it("shouldn't select a new item if skipNotifier is passed", async function () {
|
||
// Select existing item
|
||
await itemsView.selectItem(existingItemID);
|
||
var selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], existingItemID);
|
||
|
||
// Reset call count on spy
|
||
win.ZoteroPane.itemSelected.resetHistory();
|
||
|
||
// Create item with skipNotifier flag
|
||
var item = new Zotero.Item('book');
|
||
var id = await item.saveTx({
|
||
skipNotifier: true
|
||
});
|
||
|
||
// No select events should have occurred
|
||
assert.equal(win.ZoteroPane.itemSelected.callCount, 0);
|
||
|
||
// Existing item should still be selected
|
||
selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], existingItemID);
|
||
});
|
||
|
||
it("shouldn't select a new item if skipSelect is passed", async function () {
|
||
// Select existing item
|
||
await itemsView.selectItem(existingItemID);
|
||
var selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], existingItemID);
|
||
|
||
// Reset call count on spy
|
||
win.ZoteroPane.itemSelected.resetHistory();
|
||
|
||
// Create item with skipSelect flag
|
||
var item = new Zotero.Item('book');
|
||
var id = await item.saveTx({
|
||
skipSelect: true
|
||
});
|
||
|
||
// itemSelected should have been called once (from 'selectEventsSuppressed = false'
|
||
// in notify()) as a no-op
|
||
assert.equal(win.ZoteroPane.itemSelected.callCount, 1);
|
||
assert.isFalse(await win.ZoteroPane.itemSelected.returnValues[0]);
|
||
|
||
// Existing item should still be selected
|
||
selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], existingItemID);
|
||
});
|
||
|
||
it("should clear search and select new item if non-matching quick search is active", async function () {
|
||
await createDataObject('item');
|
||
|
||
var quicksearch = win.document.getElementById('zotero-tb-search');
|
||
quicksearch.searchTextbox.value = Zotero.randomString();
|
||
quicksearch.doCommand();
|
||
await itemsView._refreshPromise;
|
||
|
||
assert.equal(itemsView.rowCount, 0);
|
||
|
||
// Create item
|
||
var item = await createDataObject('item');
|
||
|
||
assert.isAbove(itemsView.rowCount, 0);
|
||
assert.equal(quicksearch.value, '');
|
||
|
||
// New item should be selected
|
||
var selected = itemsView.getSelectedItems();
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0].id, item.id);
|
||
});
|
||
|
||
it("shouldn't clear quicksearch if skipSelect is passed", async function () {
|
||
var searchString = Zotero.Items.get(existingItemID).getField('title');
|
||
|
||
await createDataObject('item');
|
||
|
||
var quicksearch = win.document.getElementById('zotero-tb-search-textbox');
|
||
quicksearch.value = searchString;
|
||
quicksearch.doCommand();
|
||
await itemsView._refreshPromise;
|
||
|
||
assert.equal(itemsView.rowCount, 1);
|
||
|
||
// Create item with skipSelect flag
|
||
var item = new Zotero.Item('book');
|
||
var ran = Zotero.Utilities.randomString();
|
||
item.setField('title', ran);
|
||
var id = await item.saveTx({
|
||
skipSelect: true
|
||
});
|
||
|
||
assert.equal(itemsView.rowCount, 1);
|
||
assert.equal(quicksearch.value, searchString);
|
||
|
||
// Clear search
|
||
quicksearch.value = "";
|
||
quicksearch.doCommand();
|
||
await itemsView._refreshPromise;
|
||
});
|
||
|
||
it("shouldn't change selection outside of trash if new trashed item is created with skipSelect", async function () {
|
||
await selectLibrary(win);
|
||
await waitForItemsLoad(win);
|
||
|
||
itemsView.selection.clearSelection();
|
||
|
||
var item = createUnsavedDataObject('item');
|
||
item.deleted = true;
|
||
var id = await item.saveTx({
|
||
skipSelect: true
|
||
});
|
||
|
||
// Nothing should be selected
|
||
var selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 0);
|
||
})
|
||
|
||
it("shouldn't select a modified item", async function () {
|
||
// Create item
|
||
var item = new Zotero.Item('book');
|
||
var id = await item.saveTx();
|
||
|
||
itemsView.selection.clearSelection();
|
||
assert.lengthOf(itemsView.getSelectedItems(), 0);
|
||
// Reset call count on spy
|
||
win.ZoteroPane.itemSelected.resetHistory();
|
||
|
||
// Modify item
|
||
item.setField('title', 'no select on modify');
|
||
await item.saveTx();
|
||
|
||
// itemSelected should not have been called
|
||
assert.equal(win.ZoteroPane.itemSelected.callCount, 0);
|
||
|
||
// Modified item should not be selected
|
||
assert.lengthOf(itemsView.getSelectedItems(), 0);
|
||
});
|
||
|
||
it("should maintain selection on a selected modified item", async function () {
|
||
// Create item
|
||
var item = new Zotero.Item('book');
|
||
var id = await item.saveTx();
|
||
|
||
await itemsView.selectItem(id);
|
||
var selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], id);
|
||
|
||
// Reset call count on spy
|
||
win.ZoteroPane.itemSelected.resetHistory();
|
||
|
||
// Modify item
|
||
item.setField('title', 'maintain selection on modify');
|
||
await item.saveTx();
|
||
|
||
// itemSelected should have been called once from restoreSelection
|
||
// due to potential resort on modification
|
||
assert.equal(win.ZoteroPane.itemSelected.callCount, 1);
|
||
assert.isFalse(await win.ZoteroPane.itemSelected.returnValues[0]);
|
||
|
||
// Modified item should still be selected
|
||
selected = itemsView.getSelectedItems(true);
|
||
assert.lengthOf(selected, 1);
|
||
assert.equal(selected[0], id);
|
||
});
|
||
|
||
it("should reselect the same row when an item is removed", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await selectCollection(win, collection);
|
||
itemsView = zp.itemsView;
|
||
|
||
var items = [];
|
||
var num = 6;
|
||
for (let i = 0; i < num; i++) {
|
||
let item = createUnsavedDataObject('item', { title: "" + i });
|
||
item.addToCollection(collection.id);
|
||
await item.saveTx();
|
||
items.push(item);
|
||
}
|
||
assert.equal(itemsView.rowCount, num);
|
||
|
||
// Select the third item in the list
|
||
itemsView.selection.select(2);
|
||
|
||
// Remove item
|
||
var treeRow = itemsView.getRow(2);
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
await collection.removeItems([treeRow.ref.id]);
|
||
}.bind(this));
|
||
|
||
// Selection should stay on third row
|
||
assert.equal(itemsView.selection.focused, 2);
|
||
|
||
// Delete item
|
||
var treeRow = itemsView.getRow(2);
|
||
await treeRow.ref.eraseTx();
|
||
|
||
// Selection should stay on third row
|
||
assert.equal(itemsView.selection.focused, 2);
|
||
|
||
await Zotero.Items.erase(items.map(item => item.id));
|
||
});
|
||
|
||
it("shouldn't select sibling on attachment erase if attachment wasn't selected", async function () {
|
||
var item = await createDataObject('item');
|
||
var att1 = await importFileAttachment('test.png', { title: 'A', parentItemID: item.id });
|
||
var att2 = await importFileAttachment('test.png', { title: 'B', parentItemID: item.id });
|
||
await zp.itemsView.selectItem(att2.id); // expand
|
||
await zp.itemsView.selectItem(item.id);
|
||
await att1.eraseTx();
|
||
assert.sameMembers(zp.itemsView.getSelectedItems(true), [item.id]);
|
||
});
|
||
|
||
it("should keep first visible item in view when other items are added with skipSelect and nothing in view is selected", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await waitForItemsLoad(win);
|
||
itemsView = zp.itemsView;
|
||
|
||
var treebox = itemsView._treebox;
|
||
var numVisibleRows = treebox.getLastVisibleRow() - treebox.getFirstVisibleRow();
|
||
|
||
// Get a numeric string left-padded with zeroes
|
||
function getTitle(i, max) {
|
||
return new String(new Array(max + 1).join(0) + i).slice(-1 * max);
|
||
}
|
||
|
||
var num = numVisibleRows + 10;
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
for (let i = 0; i < num; i++) {
|
||
let title = getTitle(i, num);
|
||
let item = createUnsavedDataObject('item', { title });
|
||
item.addToCollection(collection.id);
|
||
await item.save();
|
||
}
|
||
}.bind(this));
|
||
|
||
// Scroll halfway
|
||
treebox.scrollToRow(Math.round(num / 2) - Math.round(numVisibleRows / 2));
|
||
|
||
var firstVisibleItemID = itemsView.getRow(treebox.getFirstVisibleRow()).ref.id;
|
||
|
||
// Add one item at the beginning
|
||
var item = createUnsavedDataObject(
|
||
'item', { title: getTitle(0, num), collections: [collection.id] }
|
||
);
|
||
await item.saveTx({
|
||
skipSelect: true
|
||
});
|
||
// Then add a few more in a transaction
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
for (let i = 0; i < 3; i++) {
|
||
var item = createUnsavedDataObject(
|
||
'item', { title: getTitle(0, num), collections: [collection.id] }
|
||
);
|
||
await item.save({
|
||
skipSelect: true
|
||
});
|
||
}
|
||
}.bind(this));
|
||
|
||
// Make sure the same item is still in the first visible row
|
||
assert.equal(itemsView.getRow(treebox.getFirstVisibleRow()).ref.id, firstVisibleItemID);
|
||
});
|
||
|
||
it("should keep first visible selected item in position when other items are added with skipSelect", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
|
||
var treebox = itemsView._treebox;
|
||
var numVisibleRows = treebox.getLastVisibleRow() - treebox.getFirstVisibleRow();
|
||
|
||
// Get a numeric string left-padded with zeroes
|
||
function getTitle(i, max) {
|
||
return new String(new Array(max + 1).join(0) + i).slice(-1 * max);
|
||
}
|
||
|
||
var num = numVisibleRows + 10;
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
for (let i = 0; i < num; i++) {
|
||
let title = getTitle(i, num);
|
||
let item = createUnsavedDataObject('item', { title });
|
||
item.addToCollection(collection.id);
|
||
await item.save();
|
||
}
|
||
});
|
||
|
||
// Scroll halfway
|
||
treebox.scrollToRow(Math.round(num / 2) - Math.round(numVisibleRows / 2));
|
||
|
||
// Select an item
|
||
itemsView.selection.select(Math.round(num / 2));
|
||
var selectedItem = itemsView.getSelectedItems()[0];
|
||
var offset = itemsView.getRowIndexByID(selectedItem.treeViewID) - treebox.getFirstVisibleRow();
|
||
|
||
// Add one item at the beginning
|
||
var item = createUnsavedDataObject(
|
||
'item', { title: getTitle(0, num), collections: [collection.id] }
|
||
);
|
||
await item.saveTx({
|
||
skipSelect: true
|
||
});
|
||
// Then add a few more in a transaction
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
for (let i = 0; i < 3; i++) {
|
||
var item = createUnsavedDataObject(
|
||
'item', { title: getTitle(0, num), collections: [collection.id] }
|
||
);
|
||
await item.save({
|
||
skipSelect: true
|
||
});
|
||
}
|
||
});
|
||
|
||
// Make sure the selected item is still at the same position
|
||
assert.equal(itemsView.getSelectedItems()[0], selectedItem);
|
||
var newOffset = itemsView.getRowIndexByID(selectedItem.treeViewID) - treebox.getFirstVisibleRow();
|
||
assert.equal(newOffset, offset);
|
||
});
|
||
|
||
it("shouldn't scroll items list if at top when other items are added with skipSelect", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await select(win, collection);
|
||
itemsView = zp.itemsView;
|
||
|
||
var treebox = itemsView._treebox;
|
||
var numVisibleRows = treebox.getLastVisibleRow() - treebox.getFirstVisibleRow();
|
||
|
||
// Get a numeric string left-padded with zeroes
|
||
function getTitle(i, max) {
|
||
return new String(new Array(max + 1).join(0) + i).slice(-1 * max);
|
||
}
|
||
|
||
var num = numVisibleRows + 10;
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
// Start at "*1" so we can add items before
|
||
for (let i = 1; i < num; i++) {
|
||
let title = getTitle(i, num);
|
||
let item = createUnsavedDataObject('item', { title });
|
||
item.addToCollection(collection.id);
|
||
await item.save();
|
||
}
|
||
}.bind(this));
|
||
|
||
// Scroll to top
|
||
treebox.scrollToRow(0);
|
||
|
||
// Add one item at the beginning
|
||
var item = createUnsavedDataObject(
|
||
'item', { title: getTitle(0, num), collections: [collection.id] }
|
||
);
|
||
await item.saveTx({
|
||
skipSelect: true
|
||
});
|
||
// Then add a few more in a transaction
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
for (let i = 0; i < 3; i++) {
|
||
var item = createUnsavedDataObject(
|
||
'item', { title: getTitle(0, num), collections: [collection.id] }
|
||
);
|
||
await item.save({
|
||
skipSelect: true
|
||
});
|
||
}
|
||
}.bind(this));
|
||
|
||
// Make sure the first row is still at the top
|
||
assert.equal(treebox.getFirstVisibleRow(), 0);
|
||
});
|
||
|
||
it("should update search results when items are added", async function () {
|
||
var search = await createDataObject('search');
|
||
await select(win, search);
|
||
assert.equal(zp.itemsView.rowCount, 0);
|
||
|
||
var title = search.getConditions()[0].value;
|
||
|
||
// Add an item matching search
|
||
var item = await createDataObject('item', { title });
|
||
|
||
await waitForItemsLoad(win);
|
||
assert.equal(zp.itemsView.rowCount, 1);
|
||
assert.equal(zp.itemsView.getRowIndexByID(item.id), 0);
|
||
});
|
||
|
||
it("should re-sort search results when an item is modified", async function () {
|
||
var search = await createDataObject('search');
|
||
await select(win, search);
|
||
itemsView = zp.itemsView;
|
||
var title = search.getConditions()[0].value;
|
||
|
||
var item1 = await createDataObject('item', { title: title + " 1" });
|
||
var item2 = await createDataObject('item', { title: title + " 3" });
|
||
var item3 = await createDataObject('item', { title: title + " 5" });
|
||
var item4 = await createDataObject('item', { title: title + " 7" });
|
||
|
||
// Sort by title
|
||
var colIndex = itemsView.tree._getColumns().findIndex(column => column.dataKey == 'firstCreator');
|
||
await itemsView.tree._columns.toggleSort(colIndex);
|
||
await waitForItemsLoad(win);
|
||
colIndex = itemsView.tree._getColumns().findIndex(column => column.dataKey == 'title');
|
||
await itemsView.tree._columns.toggleSort(colIndex);
|
||
await waitForItemsLoad(win);
|
||
|
||
// Check initial sort order
|
||
assert.equal(itemsView.getRow(0).ref.getField('title'), title + " 1");
|
||
assert.equal(itemsView.getRow(3).ref.getField('title'), title + " 7");
|
||
|
||
// Set first row to title that should be sorted in the middle
|
||
itemsView.getRow(3).ref.setField('title', title + " 4");
|
||
await itemsView.getRow(3).ref.saveTx();
|
||
|
||
assert.equal(itemsView.getRow(0).ref.getField('title'), title + " 1");
|
||
assert.equal(itemsView.getRow(1).ref.getField('title'), title + " 3");
|
||
assert.equal(itemsView.getRow(2).ref.getField('title'), title + " 4");
|
||
assert.equal(itemsView.getRow(3).ref.getField('title'), title + " 5");
|
||
});
|
||
|
||
it("should update search results when search conditions are changed", async function () {
|
||
var search = createUnsavedDataObject('search');
|
||
var title1 = Zotero.Utilities.randomString();
|
||
var title2 = Zotero.Utilities.randomString();
|
||
search.fromJSON({
|
||
name: "Test",
|
||
conditions: [
|
||
{
|
||
condition: "title",
|
||
operator: "is",
|
||
value: title1
|
||
}
|
||
]
|
||
});
|
||
await search.saveTx();
|
||
|
||
await select(win, search);
|
||
|
||
// Add an item that doesn't match search
|
||
var item = await createDataObject('item', { title: title2 });
|
||
await waitForItemsLoad(win);
|
||
assert.equal(zp.itemsView.rowCount, 0);
|
||
|
||
// Modify conditions to match item
|
||
search.removeCondition(0);
|
||
search.addCondition("title", "is", title2);
|
||
await search.saveTx();
|
||
|
||
await waitForItemsLoad(win);
|
||
|
||
assert.equal(zp.itemsView.rowCount, 1);
|
||
});
|
||
|
||
it("should remove items from Unfiled Items when added to a collection", async function () {
|
||
var userLibraryID = Zotero.Libraries.userLibraryID;
|
||
var collection = await createDataObject('collection');
|
||
var item = await createDataObject('item', { title: "Unfiled Item" });
|
||
var attachment = await importFileAttachment('test.png', { parentItemID: item.id });
|
||
await zp.setVirtual(userLibraryID, 'unfiled', true, true);
|
||
assert.equal(zp.getCollectionTreeRows()[0].id, 'U' + userLibraryID);
|
||
await waitForItemsLoad(win);
|
||
let rowIndex = zp.itemsView.getRowIndexByID(item.id);
|
||
assert.isNumber(rowIndex);
|
||
await zp.itemsView.toggleOpenState(rowIndex);
|
||
let attachmentRowIndex = zp.itemsView.getRowIndexByID(attachment.id);
|
||
assert.isNumber(attachmentRowIndex);
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
await collection.addItem(item.id);
|
||
});
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(item.id));
|
||
// Ensure there is no leftover attachment row
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(attachment.id));
|
||
});
|
||
|
||
it("should not clear quicksearch when embedded attachment is added to a note", async function () {
|
||
// Create item with a child note
|
||
let item = await createDataObject('item', { title: "item" });
|
||
let note = await createDataObject('item', { itemType: 'note', parentItemID: item.id });
|
||
|
||
// Run quicksearch
|
||
let quickSearch = win.document.getElementById('zotero-tb-search-textbox');
|
||
quickSearch.value = "item";
|
||
await zp.search();
|
||
|
||
// Select the child note
|
||
await zp.itemsView.selectItem(note.id);
|
||
|
||
// Paste an image into the note
|
||
let notifySpy = sinon.spy(zp.itemsView, 'notify');
|
||
await createEmbeddedImage(note);
|
||
|
||
// Notify should be called twice: 'modify' for note and 'add' for attachment
|
||
assert.equal(zp.itemsView.notify.callCount, 2);
|
||
await notifySpy.returnValues[0];
|
||
notifySpy.restore();
|
||
|
||
// Ensure that the note is still selected and quick search is still active
|
||
assert.equal(zp.itemsView.getSelectedItems(true)[0], note.id);
|
||
assert.equal(quickSearch.value, "item");
|
||
});
|
||
|
||
it("should add an item to a collection when a saved search is also selected", async function () {
|
||
Zotero.Prefs.set('recursiveCollections', true);
|
||
let logError = sinon.spy(Zotero, 'logError');
|
||
try {
|
||
let collection = await createDataObject('collection');
|
||
let subcollection = await createDataObject('collection', { parentID: collection.id });
|
||
let search = await createDataObject('search');
|
||
|
||
await cv.selectByID("C" + collection.id);
|
||
await waitForItemsLoad(win);
|
||
cv.selection.toggleSelect(cv.getRowIndexByID("S" + search.id));
|
||
await zp.onCollectionSelected();
|
||
await zp.itemsView.waitForLoad();
|
||
|
||
// With recursiveCollections, an item added to a subcollection shows in
|
||
// the parent collection's view
|
||
let item = await createDataObject('item', { collections: [subcollection.id] });
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
||
assert.deepEqual(logError.getCalls().map(call => String(call.args[0])), []);
|
||
}
|
||
finally {
|
||
logError.restore();
|
||
Zotero.Prefs.clear('recursiveCollections');
|
||
await selectLibrary(win);
|
||
}
|
||
});
|
||
|
||
describe("Change parent item", function () {
|
||
let item1, item2, attachment1, highlight1;
|
||
|
||
beforeEach(async function () {
|
||
// Two top-level items
|
||
item1 = await createDataObject('item', { title: "Parent Item 1" });
|
||
item2 = await createDataObject('item', { title: "Parent Item 2" });
|
||
|
||
// A child attachment with an annotation for the first item
|
||
attachment1 = await importFileAttachment('test.pdf', { title: 'Attachment 1', parentItemID: item1.id });
|
||
highlight1 = await createAnnotation('highlight', attachment1);
|
||
|
||
// Make sure tree is expanded to show all items
|
||
zp.itemsView.expandAllRows(true);
|
||
});
|
||
|
||
it("should remove old attachment and annotation rows on attachment parent change", async function () {
|
||
// Change attachment parent
|
||
attachment1.parentID = item2.id;
|
||
await attachment1.saveTx();
|
||
|
||
let secondItemRowIndex = itemsView.getRowIndexByID(item2.id);
|
||
let attachmentRowIndex = itemsView.getRowIndexByID(attachment1.id);
|
||
let annotationRowIndex = itemsView.getRowIndexByID(highlight1.id);
|
||
|
||
// Verify that the attachment has been moved into the item
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.equal(attachmentRowIndex, secondItemRowIndex + 1);
|
||
assert.equal(itemsView.getRow(attachmentRowIndex).level, 1);
|
||
// Verify there is no leftover annotation row
|
||
assert.isFalse(annotationRowIndex);
|
||
});
|
||
|
||
it("should remove old attachment and annotation rows after a child attachment is moved to top level", async function () {
|
||
// Make attachment top level
|
||
attachment1.parentID = null;
|
||
await attachment1.saveTx();
|
||
|
||
let attachmentRowIndex = itemsView.getRowIndexByID(attachment1.id);
|
||
let annotationRowIndex = itemsView.getRowIndexByID(highlight1.id);
|
||
|
||
// Verify that the attachment has been moved to top level
|
||
assert.equal(itemsView.getRow(attachmentRowIndex).level, 0);
|
||
// Verify there is no leftover annotation row
|
||
assert.isFalse(annotationRowIndex);
|
||
});
|
||
|
||
it("should remove old attachment and annotation rows after a top-level attachment is made a child", async function () {
|
||
// Make a top-level attachment
|
||
let topLevelAttachment = await importFileAttachment('test.pdf', { title: 'Top Level Attachment', parentItemID: null });
|
||
let highlightOfTopLevel = await createAnnotation('highlight', topLevelAttachment);
|
||
|
||
// Move top-level attachment into item
|
||
topLevelAttachment.parentID = item2.id;
|
||
await topLevelAttachment.saveTx();
|
||
|
||
let secondItemRowIndex = itemsView.getRowIndexByID(item2.id);
|
||
let attachmentRowIndex = itemsView.getRowIndexByID(topLevelAttachment.id);
|
||
let annotationRowIndex = itemsView.getRowIndexByID(highlightOfTopLevel.id);
|
||
|
||
// Verify that the attachment has been moved into the item
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.equal(attachmentRowIndex, secondItemRowIndex + 1);
|
||
assert.equal(itemsView.getRow(attachmentRowIndex).level, 1);
|
||
// Verify there is no leftover annotation row
|
||
assert.isFalse(annotationRowIndex);
|
||
});
|
||
|
||
it("should handle child note being moved to top level", async function () {
|
||
let note1 = await createDataObject('item', { itemType: 'note', parentID: item1.id });
|
||
let itemRowIndex = itemsView.getRowIndexByID(item1.id);
|
||
let noteRowIndex = itemsView.getRowIndexByID(note1.id);
|
||
assert.equal(noteRowIndex, itemRowIndex + 1);
|
||
|
||
// Make the note top level
|
||
note1.parentID = null;
|
||
await note1.saveTx();
|
||
|
||
noteRowIndex = itemsView.getRowIndexByID(note1.id);
|
||
// Verify that the note has been moved to top level
|
||
assert.equal(itemsView.getRow(noteRowIndex).level, 0);
|
||
});
|
||
|
||
it("should handle top-level note being made a child note", async function () {
|
||
// Make a top-level note
|
||
let note = await createDataObject('item', { itemType: 'note', parentID: null });
|
||
|
||
// Move top-level note into item
|
||
note.parentID = item2.id;
|
||
await note.saveTx();
|
||
|
||
let secondItemRowIndex = itemsView.getRowIndexByID(item2.id);
|
||
let noteRowIndex = itemsView.getRowIndexByID(note.id);
|
||
|
||
// Verify that the note row has been moved into the item
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.equal(noteRowIndex, secondItemRowIndex + 1);
|
||
});
|
||
|
||
it("should handle child note being moved between items", async function () {
|
||
let note1 = await createDataObject('item', { itemType: 'note', parentID: item1.id });
|
||
let itemRowIndex = itemsView.getRowIndexByID(item1.id);
|
||
let noteRowIndex = itemsView.getRowIndexByID(note1.id);
|
||
assert.equal(noteRowIndex, itemRowIndex + 1);
|
||
|
||
// Move to another parent
|
||
note1.parentID = item2.id;
|
||
await note1.saveTx();
|
||
|
||
let secondItemRowIndex = itemsView.getRowIndexByID(item2.id);
|
||
noteRowIndex = itemsView.getRowIndexByID(note1.id);
|
||
// Verify that the note row has been moved into the item
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.equal(noteRowIndex, secondItemRowIndex + 1);
|
||
});
|
||
|
||
it("should not expand an empty parent item when attachment is added", async function () {
|
||
let item2RowIndex = itemsView.getRowIndexByID(item2.id);
|
||
assert.isFalse(itemsView.isContainerOpen(item2RowIndex));
|
||
|
||
// Add attachment to item2
|
||
await importFileAttachment('test.png', { parentItemID: item2.id });
|
||
|
||
// Verify item2 is still collapsed
|
||
item2RowIndex = itemsView.getRowIndexByID(item2.id);
|
||
assert.isFalse(itemsView.isContainerOpen(item2RowIndex));
|
||
});
|
||
});
|
||
|
||
describe("Recently Read", function () {
|
||
before(async function () {
|
||
await resetData();
|
||
});
|
||
afterEach(function () {
|
||
Zotero.Items._lastReadCutoffs.clear();
|
||
});
|
||
|
||
it("should re-sort by Last Read when child attachmentLastRead is updated in the user library", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let item1 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment1 = await importPDFAttachment(item1);
|
||
let item2 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment2 = await importPDFAttachment(item2);
|
||
assert.notOk(item1.getItemLastRead());
|
||
assert.notOk(item2.getItemLastRead());
|
||
|
||
// attachment2 is more recently opened
|
||
attachment1.attachmentLastRead = Math.round(Date.now() / 1000) - 5;
|
||
attachment2.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await attachment1.saveTx();
|
||
await attachment2.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
assert.equal(zp.getCollectionTreeRows()[0].id, 'Y' + userLibraryID);
|
||
await waitForItemsLoad(win);
|
||
assert.isAbove(zp.itemsView.getRowIndexByID(item1.id), zp.itemsView.getRowIndexByID(item2.id));
|
||
|
||
// Now make attachment2 much less recently opened
|
||
attachment2.attachmentLastRead = Math.round(Date.now() / 1000) - 60;
|
||
await attachment2.saveTx();
|
||
|
||
assert.isBelow(zp.itemsView.getRowIndexByID(item1.id), zp.itemsView.getRowIndexByID(item2.id));
|
||
|
||
await item1.eraseTx();
|
||
await item2.eraseTx();
|
||
});
|
||
|
||
it("should re-sort by Last Read when child attachmentLastRead is updated in a group library", async function () {
|
||
let groupLibraryID = (await createGroup()).libraryID;
|
||
let item1 = await createDataObject('item', { libraryID: groupLibraryID });
|
||
let attachment1 = await importPDFAttachment(item1);
|
||
let item2 = await createDataObject('item', { libraryID: groupLibraryID });
|
||
let attachment2 = await importPDFAttachment(item2);
|
||
assert.notOk(item1.getItemLastRead());
|
||
assert.notOk(item2.getItemLastRead());
|
||
|
||
// attachment2 is more recently opened
|
||
attachment1.attachmentLastRead = Math.round(Date.now() / 1000) - 5;
|
||
attachment2.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await attachment1.saveTx();
|
||
await attachment2.saveTx();
|
||
|
||
await zp.setVirtual(groupLibraryID, 'recentlyRead', true, true);
|
||
assert.equal(zp.getCollectionTreeRows()[0].id, 'Y' + groupLibraryID);
|
||
await waitForItemsLoad(win);
|
||
assert.isAbove(zp.itemsView.getRowIndexByID(item1.id), zp.itemsView.getRowIndexByID(item2.id));
|
||
|
||
// Now make attachment2 much less recently opened
|
||
attachment2.attachmentLastRead = Math.round(Date.now() / 1000) - 60;
|
||
await attachment2.saveTx();
|
||
|
||
assert.isBelow(zp.itemsView.getRowIndexByID(item1.id), zp.itemsView.getRowIndexByID(item2.id));
|
||
|
||
await item1.eraseTx();
|
||
await item2.eraseTx();
|
||
});
|
||
|
||
it("should show read child attachments as matched, not context, rows", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let item = await createDataObject('item', { libraryID: userLibraryID });
|
||
let readAttachment = await importPDFAttachment(item);
|
||
let unreadAttachment = await importPDFAttachment(item);
|
||
readAttachment.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await readAttachment.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
|
||
let itemsView = zp.itemsView;
|
||
let parentRow = itemsView.getRowIndexByID(item.id);
|
||
assert.isNumber(parentRow);
|
||
|
||
// Expand the parent to reveal its children
|
||
await itemsView.toggleOpenState(parentRow);
|
||
|
||
let readRow = itemsView.getRowIndexByID(readAttachment.id);
|
||
let unreadRow = itemsView.getRowIndexByID(unreadAttachment.id);
|
||
assert.isNumber(readRow);
|
||
assert.isNumber(unreadRow);
|
||
|
||
// The read attachment is matched, shown in black
|
||
assert.isNotOk(itemsView._getRowData(readRow).contextRow);
|
||
// The parent is also matched
|
||
assert.isNotOk(itemsView._getRowData(parentRow).contextRow);
|
||
// The unread sibling is still a grayed-out context row
|
||
assert.isTrue(itemsView._getRowData(unreadRow).contextRow);
|
||
|
||
await item.eraseTx();
|
||
});
|
||
|
||
it("should not auto-expand parents of read attachments", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let now = Math.round(Date.now() / 1000);
|
||
|
||
let item1 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment1 = await importPDFAttachment(item1);
|
||
attachment1.attachmentLastRead = now;
|
||
await attachment1.saveTx();
|
||
|
||
let item2 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment2 = await importPDFAttachment(item2);
|
||
attachment2.attachmentLastRead = now - 5;
|
||
await attachment2.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
|
||
let itemsView = zp.itemsView;
|
||
let item1Row = itemsView.getRowIndexByID(item1.id);
|
||
let item2Row = itemsView.getRowIndexByID(item2.id);
|
||
assert.isNumber(item1Row);
|
||
assert.isNumber(item2Row);
|
||
|
||
// Parents should remain collapsed - marking read children as matched
|
||
// must not trigger auto-expansion
|
||
assert.isFalse(itemsView.isContainerOpen(item1Row));
|
||
assert.isFalse(itemsView.isContainerOpen(item2Row));
|
||
// Child attachments are therefore not shown until the parent is expanded
|
||
assert.isFalse(itemsView.getRowIndexByID(attachment1.id));
|
||
assert.isFalse(itemsView.getRowIndexByID(attachment2.id));
|
||
|
||
await item1.eraseTx();
|
||
await item2.eraseTx();
|
||
});
|
||
|
||
it("should show empty Recently Read when no items have been read", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let item = await createDataObject('item', { libraryID: userLibraryID });
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
|
||
assert.equal(zp.itemsView.rowCount, 0);
|
||
|
||
await item.eraseTx();
|
||
});
|
||
|
||
it("should show items read more than 14 days ago if within 14 days of the most recently read item", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let threeMonthsAgo = Math.round(Date.now() / 1000) - (90 * 24 * 60 * 60);
|
||
|
||
let item1 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment1 = await importPDFAttachment(item1);
|
||
attachment1.attachmentLastRead = threeMonthsAgo;
|
||
await attachment1.saveTx();
|
||
|
||
let item2 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment2 = await importPDFAttachment(item2);
|
||
attachment2.attachmentLastRead = threeMonthsAgo - (5 * 24 * 60 * 60);
|
||
await attachment2.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
|
||
// Both should appear -- within 14 days of each other
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item1.id));
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item2.id));
|
||
|
||
await item1.eraseTx();
|
||
await item2.eraseTx();
|
||
});
|
||
|
||
it("should not show items read more than 14 days before the most recently read item", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let threeMonthsAgo = Math.round(Date.now() / 1000) - (90 * 24 * 60 * 60);
|
||
|
||
let item1 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment1 = await importPDFAttachment(item1);
|
||
attachment1.attachmentLastRead = threeMonthsAgo;
|
||
await attachment1.saveTx();
|
||
|
||
let item2 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment2 = await importPDFAttachment(item2);
|
||
attachment2.attachmentLastRead = threeMonthsAgo - (20 * 24 * 60 * 60);
|
||
await attachment2.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
|
||
// item1 should appear, item2 should not -- read 20 days before most recent
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item1.id));
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(item2.id));
|
||
|
||
await item1.eraseTx();
|
||
await item2.eraseTx();
|
||
});
|
||
|
||
it("should not remove old items when a new item is read", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let threeMonthsAgo = Math.round(Date.now() / 1000) - (90 * 24 * 60 * 60);
|
||
|
||
let item1 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment1 = await importPDFAttachment(item1);
|
||
attachment1.attachmentLastRead = threeMonthsAgo;
|
||
await attachment1.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item1.id));
|
||
|
||
// Read something new, so it shifts the window far away from item1
|
||
let item2 = await createDataObject('item', { libraryID: userLibraryID });
|
||
let attachment2 = await importPDFAttachment(item2);
|
||
attachment2.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await attachment2.saveTx();
|
||
await waitForItemsLoad(win);
|
||
|
||
// item1 should still be visible
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item1.id));
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item2.id));
|
||
|
||
await item1.eraseTx();
|
||
await item2.eraseTx();
|
||
});
|
||
|
||
describe("With Quick Search", function () {
|
||
let quicksearch;
|
||
|
||
before(() => {
|
||
quicksearch = win.document.getElementById('zotero-tb-search-textbox');
|
||
});
|
||
afterEach(async () => {
|
||
quicksearch.value = "";
|
||
quicksearch.doCommand();
|
||
await zp.itemsView._refreshPromise;
|
||
});
|
||
|
||
it("should find parent item by title", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let item = await createDataObject('item', { title: 'Unique Parent Title ZZZ' });
|
||
let attachment = await importPDFAttachment(item);
|
||
attachment.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await attachment.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
||
|
||
quicksearch.value = "Unique Parent Title ZZZ";
|
||
quicksearch.doCommand();
|
||
await zp.itemsView._refreshPromise;
|
||
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
||
});
|
||
|
||
it("should not show non-matching parent item", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let matchItem = await createDataObject('item', { title: 'Matching Item AAA' });
|
||
let matchAttachment = await importPDFAttachment(matchItem);
|
||
matchAttachment.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await matchAttachment.saveTx();
|
||
|
||
let otherItem = await createDataObject('item', { title: 'Other Item BBB' });
|
||
let otherAttachment = await importPDFAttachment(otherItem);
|
||
otherAttachment.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await otherAttachment.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(matchItem.id));
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(otherItem.id));
|
||
|
||
quicksearch.value = "Matching Item AAA";
|
||
quicksearch.doCommand();
|
||
await zp.itemsView._refreshPromise;
|
||
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(matchItem.id));
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(otherItem.id));
|
||
});
|
||
|
||
it("should show read attachments as matches in every selected library", async function () {
|
||
let group = await createGroup();
|
||
let title = 'Cross Library Read QQQ';
|
||
let userItem = await createDataObject('item', { title });
|
||
let userAttachment = await importPDFAttachment(userItem);
|
||
let groupItem = await createDataObject(
|
||
'item', { libraryID: group.libraryID, title }
|
||
);
|
||
let groupAttachment = await importPDFAttachment(groupItem);
|
||
for (let attachment of [userAttachment, groupAttachment]) {
|
||
attachment.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await attachment.saveTx();
|
||
}
|
||
|
||
await zp.setVirtual(Zotero.Libraries.userLibraryID, 'recentlyRead', true, true);
|
||
await zp.setVirtual(group.libraryID, 'recentlyRead', true, true);
|
||
await cv.expandLibrary(group.libraryID);
|
||
await cv.selectByID("Y" + Zotero.Libraries.userLibraryID);
|
||
await waitForItemsLoad(win);
|
||
cv.selection.toggleSelect(cv.getRowIndexByID("Y" + group.libraryID));
|
||
await zp.onCollectionSelected();
|
||
await zp.itemsView.waitForLoad();
|
||
|
||
quicksearch.value = title;
|
||
quicksearch.doCommand();
|
||
await zp.itemsView._refreshPromise;
|
||
|
||
// The attachments are what was actually read, so they display as
|
||
// results rather than grayed-out context rows
|
||
let view = zp.itemsView;
|
||
for (let attachment of [userAttachment, groupAttachment]) {
|
||
await view.expandToItem(attachment.id);
|
||
let row = view.getRowIndexByID(attachment.id);
|
||
assert.isNumber(row, `Attachment ${attachment.id} should be shown`);
|
||
assert.isFalse(
|
||
view.tree._jsWindow.getElementByIndex(row).classList.contains('context-row'),
|
||
`Attachment in library ${attachment.libraryID} should be a match`
|
||
);
|
||
}
|
||
|
||
await selectLibrary(win);
|
||
await group.eraseTx();
|
||
});
|
||
});
|
||
|
||
describe("After Remove from Recently Read", function () {
|
||
it("should remove a parent item when the parent is selected", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let item = await createDataObject('item');
|
||
let attachment = await importPDFAttachment(item);
|
||
|
||
attachment.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await attachment.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
||
|
||
await zp.itemsView.selectItem(item.id);
|
||
await zp.itemsView.deleteSelection();
|
||
|
||
assert.isNull(attachment.attachmentLastRead);
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(item.id));
|
||
});
|
||
|
||
it("should clear only the selected child attachment's lastRead", async function () {
|
||
let userLibraryID = Zotero.Libraries.userLibraryID;
|
||
let item = await createDataObject('item');
|
||
let attachment1 = await importPDFAttachment(item);
|
||
let attachment2 = await importPDFAttachment(item);
|
||
|
||
let lastRead = Math.round(Date.now() / 1000);
|
||
attachment1.attachmentLastRead = lastRead;
|
||
attachment2.attachmentLastRead = lastRead;
|
||
await attachment1.saveTx();
|
||
await attachment2.saveTx();
|
||
|
||
await zp.setVirtual(userLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
|
||
// Expand the parent and select the first child attachment
|
||
let parentRow = zp.itemsView.getRowIndexByID(item.id);
|
||
if (!zp.itemsView.isContainerOpen(parentRow)) {
|
||
await zp.itemsView.toggleOpenState(parentRow);
|
||
}
|
||
await zp.itemsView.selectItem(attachment1.id);
|
||
|
||
await zp.itemsView.deleteSelection();
|
||
|
||
assert.isNull(attachment1.attachmentLastRead);
|
||
assert.equal(attachment2.attachmentLastRead, lastRead);
|
||
});
|
||
|
||
it("should remove an item from a read-only group library", async function () {
|
||
let group = await createGroup();
|
||
let groupLibraryID = group.libraryID;
|
||
let item = await createDataObject('item', { libraryID: groupLibraryID });
|
||
let attachment = await importPDFAttachment(item);
|
||
|
||
attachment.attachmentLastRead = Math.round(Date.now() / 1000);
|
||
await attachment.saveTx();
|
||
|
||
// Make the group read-only after creating test data
|
||
group.editable = false;
|
||
await group.saveTx();
|
||
|
||
await zp.setVirtual(groupLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
||
|
||
await zp.itemsView.selectItem(item.id);
|
||
await zp.itemsView.deleteSelection();
|
||
|
||
assert.isNull(attachment.attachmentLastRead);
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(item.id));
|
||
});
|
||
|
||
it("should remove a group item when its lastRead synced setting is cleared", async function () {
|
||
let group = await createGroup();
|
||
let groupLibraryID = group.libraryID;
|
||
let item = await createDataObject('item', { libraryID: groupLibraryID });
|
||
let attachment = await importPDFAttachment(item);
|
||
let key = attachment._getLastReadSettingKey();
|
||
|
||
await Zotero.SyncedSettings.set(Zotero.Libraries.userLibraryID, key, Math.round(Date.now() / 1000));
|
||
|
||
await zp.setVirtual(groupLibraryID, 'recentlyRead', true, true);
|
||
await waitForItemsLoad(win);
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
||
|
||
// Simulate clearing via sync (as if another device removed it)
|
||
await Zotero.SyncedSettings.clear(Zotero.Libraries.userLibraryID, key, { skipDeleteLog: true });
|
||
|
||
// Wait for the notify to propagate and the view to refresh
|
||
await zp.itemsView._refreshPromise;
|
||
|
||
assert.isNull(attachment.attachmentLastRead);
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(item.id));
|
||
});
|
||
});
|
||
});
|
||
|
||
describe("Trash", function () {
|
||
it("should remove untrashed parent item when last trashed child is deleted", async function () {
|
||
var item = await createDataObject('item');
|
||
var note = await createDataObject(
|
||
'item', { itemType: 'note', parentID: item.id, deleted: true }
|
||
);
|
||
await selectTrash(win);
|
||
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
||
var promise = waitForDialog();
|
||
await zp.emptyTrash();
|
||
await promise;
|
||
// Small delay for modal to close and notifications to go through
|
||
// otherwise, next publications tab does not get opened
|
||
await Zotero.Promise.delay(100);
|
||
assert.equal(zp.itemsView.rowCount, 0);
|
||
});
|
||
|
||
it("should show only top-most trashed collection", async function () {
|
||
var c1 = await createDataObject('collection', { deleted: true });
|
||
var c2 = await createDataObject('collection', { parentID: c1.id });
|
||
var c3 = await createDataObject('collection', { parentID: c2.id });
|
||
|
||
// Go to trash
|
||
await selectTrash(win);
|
||
|
||
// Make sure only top-level collection shows
|
||
assert.isNumber(itemsView.getRowIndexByID(c1.treeViewID));
|
||
assert.isFalse(itemsView.getRowIndexByID(c2.treeViewID));
|
||
assert.isFalse(itemsView.getRowIndexByID(c3.treeViewID));
|
||
});
|
||
|
||
it("should assign collection/search row types in trash", async function () {
|
||
let collection = await createDataObject('collection', { deleted: true });
|
||
let search = await createDataObject('search', { deleted: true });
|
||
|
||
await selectTrash(win);
|
||
|
||
let collectionRowIndex = itemsView.getRowIndexByID(collection.treeViewID);
|
||
let searchRowIndex = itemsView.getRowIndexByID(search.treeViewID);
|
||
assert.isNumber(collectionRowIndex);
|
||
assert.isNumber(searchRowIndex);
|
||
assert.equal(itemsView.getRow(collectionRowIndex).type, 'collection');
|
||
assert.equal(itemsView.getRow(searchRowIndex).type, 'search');
|
||
});
|
||
|
||
it("shouldn't show trashed collections or searches when an advanced search is active", async function () {
|
||
let item = await createDataObject('item', { title: "advancedTrashMatch", deleted: true });
|
||
let collection = await createDataObject('collection', { name: "advancedTrashMatch", deleted: true });
|
||
let search = await createDataObject('search', { name: "advancedTrashMatch", deleted: true });
|
||
|
||
await selectTrash(win);
|
||
|
||
let s = new Zotero.Search();
|
||
s.libraryID = item.libraryID;
|
||
s.addCondition('title', 'is', "advancedTrashMatch");
|
||
await itemsView.setFilter('advanced-search', s);
|
||
|
||
// The matching item is shown, but the collection and search, which can't
|
||
// match item-level conditions, are excluded
|
||
assert.isNumber(itemsView.getRowIndexByID(item.treeViewID));
|
||
assert.isFalse(itemsView.getRowIndexByID(collection.treeViewID));
|
||
assert.isFalse(itemsView.getRowIndexByID(search.treeViewID));
|
||
|
||
await itemsView.setFilter('advanced-search', null);
|
||
});
|
||
|
||
it("should filter trashed collections and searches by name during a quick search", async function () {
|
||
let match = await createDataObject('collection', { name: "quickTrashFindme", deleted: true });
|
||
let other = await createDataObject('collection', { name: "quickTrashOther", deleted: true });
|
||
let matchSearch = await createDataObject('search', { name: "quickTrashFindme", deleted: true });
|
||
let otherSearch = await createDataObject('search', { name: "quickTrashOther", deleted: true });
|
||
|
||
await selectTrash(win);
|
||
await itemsView.setFilter('search', "quickTrashFindme");
|
||
|
||
assert.isNumber(itemsView.getRowIndexByID(match.treeViewID));
|
||
assert.isNumber(itemsView.getRowIndexByID(matchSearch.treeViewID));
|
||
assert.isFalse(itemsView.getRowIndexByID(other.treeViewID));
|
||
assert.isFalse(itemsView.getRowIndexByID(otherSearch.treeViewID));
|
||
|
||
await itemsView.setFilter('search', "");
|
||
});
|
||
|
||
it("should sort by hasAttachment in trash without crashing", async function () {
|
||
await createDataObject('collection', { deleted: true });
|
||
await createDataObject('search', { deleted: true });
|
||
await createDataObject('item', { deleted: true });
|
||
await selectTrash(win);
|
||
|
||
let columnIndex = itemsView._getColumns().findIndex(column => column.dataKey == 'hasAttachment');
|
||
assert.isAtLeast(columnIndex, 0);
|
||
|
||
await itemsView._handleColumnSort(columnIndex, 1);
|
||
assert.isAbove(itemsView.rowCount, 0);
|
||
});
|
||
|
||
it("should restore all subcollections when parent is restored", async function () {
|
||
var c1 = await createDataObject('collection', { deleted: true });
|
||
var c2 = await createDataObject('collection', { parentID: c1.id });
|
||
var c3 = await createDataObject('collection', { parentID: c2.id });
|
||
|
||
// Go to trash
|
||
await selectTrash(win);
|
||
|
||
// Restore
|
||
await itemsView.selectItem(c1.treeViewID);
|
||
await zp.restoreSelectedItems();
|
||
|
||
// Make sure it's gone from trash
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(c1.treeViewID));
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(c2.treeViewID));
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(c3.treeViewID));
|
||
|
||
// Make sure it shows up back in collectionTree
|
||
assert.isNumber(zp.collectionsView.getRowIndexByID(c1.treeViewID));
|
||
})
|
||
|
||
for (let objectType of ['collection', 'search']) {
|
||
it(`should remove ${objectType} from trash on delete`, async function (){
|
||
var o1 = await createDataObject(objectType, { deleted: true });
|
||
var o2 = await createDataObject(objectType, { deleted: true });
|
||
var o3 = await createDataObject(objectType, { deleted: true });
|
||
|
||
// Go to trash
|
||
await selectTrash(win);
|
||
|
||
// Permanently delete
|
||
await itemsView.selectItems([o1.treeViewID, o2.treeViewID, o3.treeViewID]);
|
||
await itemsView.deleteSelection();
|
||
|
||
// Make sure it's gone from trash
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(o1.treeViewID));
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(o2.treeViewID));
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(o3.treeViewID));
|
||
})
|
||
}
|
||
});
|
||
|
||
describe("My Publications", function () {
|
||
before(async function () {
|
||
var libraryID = Zotero.Libraries.userLibraryID;
|
||
|
||
var s = new Zotero.Search;
|
||
s.libraryID = libraryID;
|
||
s.addCondition('publications', 'true');
|
||
var ids = await s.search();
|
||
|
||
await Zotero.Items.erase(ids);
|
||
|
||
await zp.collectionsView.selectByID("P" + libraryID);
|
||
await waitForItemsLoad(win);
|
||
|
||
// Make sure we're showing the intro text
|
||
var messageElem = win.document.querySelector('.items-tree-message');
|
||
assert.notEqual(messageElem.style.display, 'none');
|
||
});
|
||
|
||
it("should replace My Publications intro text with items list on item add", async function () {
|
||
var item = await createDataObject('item');
|
||
|
||
await zp.collectionsView.selectByID("P" + item.libraryID);
|
||
await waitForItemsLoad(win);
|
||
|
||
item.inPublications = true;
|
||
await item.saveTx();
|
||
|
||
var messageElem = win.document.querySelector('.items-tree-message');
|
||
assert.equal(messageElem.style.display, 'none');
|
||
|
||
assert.isNumber(itemsView.getRowIndexByID(item.id));
|
||
});
|
||
|
||
it("should add new item to My Publications items list", async function () {
|
||
var item1 = createUnsavedDataObject('item');
|
||
item1.inPublications = true;
|
||
await item1.saveTx();
|
||
|
||
await zp.collectionsView.selectByID("P" + item1.libraryID);
|
||
await waitForItemsLoad(win);
|
||
|
||
var messageElem = win.document.querySelector('.items-tree-message');
|
||
assert.equal(messageElem.style.display, 'none');
|
||
|
||
var item2 = createUnsavedDataObject('item');
|
||
item2.inPublications = true;
|
||
await item2.saveTx();
|
||
|
||
assert.isNumber(itemsView.getRowIndexByID(item2.id));
|
||
});
|
||
|
||
it("should add modified item to My Publications items list", async function () {
|
||
var item1 = createUnsavedDataObject('item');
|
||
item1.inPublications = true;
|
||
await item1.saveTx();
|
||
var item2 = await createDataObject('item');
|
||
|
||
await zp.collectionsView.selectByID("P" + item1.libraryID);
|
||
await waitForItemsLoad(win);
|
||
|
||
var messageElem = win.document.querySelector('.items-tree-message');
|
||
assert.equal(messageElem.style.display, 'none');
|
||
|
||
assert.isFalse(itemsView.getRowIndexByID(item2.id));
|
||
|
||
item2.inPublications = true;
|
||
await item2.saveTx();
|
||
|
||
assert.isNumber(itemsView.getRowIndexByID(item2.id));
|
||
});
|
||
|
||
it("should show Show/Hide button for imported file attachment", async function () {
|
||
var item = await createDataObject('item', { inPublications: true });
|
||
var attachment = await importFileAttachment('test.png', { parentItemID: item.id });
|
||
|
||
await zp.collectionsView.selectByID("P" + item.libraryID);
|
||
await waitForItemsLoad(win);
|
||
|
||
await itemsView.selectItem(attachment.id);
|
||
await Zotero.Promise.delay();
|
||
|
||
var box = zp.itemPane.getCurrentPane().querySelector('.item-pane-my-publications-button');
|
||
assert.isFalse(box.hidden);
|
||
});
|
||
|
||
it("shouldn't show Show/Hide button for linked file attachment", async function () {
|
||
var item = await createDataObject('item', { inPublications: true });
|
||
var attachment = await Zotero.Attachments.linkFromFile({
|
||
file: OS.Path.join(getTestDataDirectory().path, 'test.png'),
|
||
parentItemID: item.id
|
||
});
|
||
|
||
await zp.collectionsView.selectByID("P" + item.libraryID);
|
||
await waitForItemsLoad(win);
|
||
|
||
await itemsView.selectItem(attachment.id);
|
||
|
||
var box = zp.itemPane.getCurrentPane().querySelector('.item-pane-my-publications-button');
|
||
// box is not created if it shouldn't show
|
||
assert.isNull(box);
|
||
});
|
||
});
|
||
})
|
||
|
||
|
||
describe("#onDrop()", function () {
|
||
function drop(index, orient, dataTransfer) {
|
||
Zotero.DragDrop.currentOrientation = orient;
|
||
var event = { dataTransfer };
|
||
// On macOS, ItemTree checks modifier keys, not just the dropEffect
|
||
if (Zotero.isMac
|
||
&& dataTransfer.types.includes('application/x-moz-file')) {
|
||
switch (dataTransfer.dropEffect) {
|
||
case 'link':
|
||
event.metaKey = true;
|
||
event.altKey = true;
|
||
break;
|
||
|
||
case 'move':
|
||
event.metaKey = true;
|
||
event.altKey = false;
|
||
break;
|
||
|
||
default:
|
||
event.metaKey = false;
|
||
event.altKey = false;
|
||
}
|
||
}
|
||
return itemsView.onDrop(event, index);
|
||
}
|
||
|
||
beforeEach(() => {
|
||
// Don't run recognize on every file
|
||
Zotero.Prefs.set('autoRecognizeFiles', false);
|
||
Zotero.Prefs.clear('autoRenameFiles');
|
||
Zotero.Prefs.clear('autoRenameFiles.linked');
|
||
});
|
||
|
||
after(function* () {
|
||
Zotero.Prefs.clear('autoRecognizeFiles');
|
||
Zotero.Prefs.clear('autoRenameFiles');
|
||
Zotero.Prefs.clear('autoRenameFiles.linked');
|
||
});
|
||
|
||
it("should move a child item from one item to another", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await waitForItemsLoad(win);
|
||
var item1 = await createDataObject('item', { title: "A", collections: [collection.id] });
|
||
var item2 = await createDataObject('item', { title: "B", collections: [collection.id] });
|
||
var item3 = await createDataObject('item', { itemType: 'note', parentID: item1.id });
|
||
|
||
await itemsView.selectItem(item3.id);
|
||
|
||
var promise = itemsView.waitForSelect();
|
||
|
||
drop(itemsView.getRowIndexByID(item2.id), 0, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['zotero/item'],
|
||
getData: function (type) {
|
||
if (type == 'zotero/item') {
|
||
return item3.id + "";
|
||
}
|
||
},
|
||
mozItemCount: 1
|
||
});
|
||
|
||
await promise;
|
||
|
||
// Old parent should be empty
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(item1.id)));
|
||
assert.isTrue(itemsView.isContainerEmpty(itemsView.getRowIndexByID(item1.id)));
|
||
|
||
// New parent should be open
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.isFalse(itemsView.isContainerEmpty(itemsView.getRowIndexByID(item2.id)));
|
||
});
|
||
|
||
it("should move a child item from last item in list to another", async function () {
|
||
var collection = await createDataObject('collection');
|
||
await waitForItemsLoad(win);
|
||
var item1 = await createDataObject('item', { title: "A", collections: [collection.id] });
|
||
var item2 = await createDataObject('item', { title: "B", collections: [collection.id] });
|
||
var item3 = await createDataObject('item', { itemType: 'note', parentID: item2.id });
|
||
|
||
await itemsView.selectItem(item3.id);
|
||
|
||
var promise = itemsView.waitForSelect();
|
||
|
||
drop(itemsView.getRowIndexByID(item1.id), 0, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['zotero/item'],
|
||
getData: function (type) {
|
||
if (type == 'zotero/item') {
|
||
return item3.id + "";
|
||
}
|
||
},
|
||
mozItemCount: 1
|
||
});
|
||
|
||
await promise;
|
||
|
||
// Old parent should be empty
|
||
assert.isFalse(itemsView.isContainerOpen(itemsView.getRowIndexByID(item2.id)));
|
||
assert.isTrue(itemsView.isContainerEmpty(itemsView.getRowIndexByID(item2.id)));
|
||
|
||
// New parent should be open
|
||
assert.isTrue(itemsView.isContainerOpen(itemsView.getRowIndexByID(item1.id)));
|
||
assert.isFalse(itemsView.isContainerEmpty(itemsView.getRowIndexByID(item1.id)));
|
||
});
|
||
|
||
it("should create a stored top-level attachment when a file is dragged", async function () {
|
||
var file = getTestDataDirectory();
|
||
file.append('test.png');
|
||
|
||
var promise = itemsView.waitForSelect();
|
||
|
||
drop(0, -1, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
await promise;
|
||
var items = itemsView.getSelectedItems();
|
||
var path = await items[0].getFilePathAsync();
|
||
assert.equal(
|
||
((await Zotero.File.getBinaryContentsAsync(path))),
|
||
((await Zotero.File.getBinaryContentsAsync(file)))
|
||
);
|
||
});
|
||
|
||
it("should add a dragged file to all selected collections", async function () {
|
||
var collection1 = await createDataObject('collection');
|
||
var collection2 = await createDataObject('collection');
|
||
|
||
// Select both collections
|
||
await cv.selectByID("C" + collection1.id);
|
||
await waitForItemsLoad(win);
|
||
cv.selection.toggleSelect(cv.getRowIndexByID("C" + collection2.id));
|
||
await zp.onCollectionSelected();
|
||
await zp.itemsView.waitForLoad();
|
||
itemsView = zp.itemsView;
|
||
|
||
var file = getTestDataDirectory();
|
||
file.append('test.png');
|
||
|
||
var idsPromise = waitForItemEvent('add');
|
||
|
||
drop(0, -1, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
var ids = await idsPromise;
|
||
var item = Zotero.Items.get(ids[0]);
|
||
assert.isTrue(item.inCollection(collection1.id));
|
||
assert.isTrue(item.inCollection(collection2.id));
|
||
});
|
||
|
||
it("should allow a file drop onto a specific item but not blank space for a cross-library selection", async function () {
|
||
var group = await createGroup();
|
||
var c1 = await createDataObject('collection');
|
||
var c2 = await createDataObject('collection', { libraryID: group.libraryID });
|
||
var userItem = await createDataObject('item', { collections: [c1.id] });
|
||
var groupItem = await createDataObject('item', { libraryID: group.libraryID, collections: [c2.id] });
|
||
|
||
await cv.expandLibrary(group.libraryID);
|
||
await cv.selectByID("C" + c1.id);
|
||
await waitForItemsLoad(win);
|
||
cv.selection.toggleSelect(cv.getRowIndexByID("C" + c2.id));
|
||
await zp.onCollectionSelected();
|
||
await zp.itemsView.waitForLoad();
|
||
itemsView = zp.itemsView;
|
||
|
||
var file = getTestDataDirectory();
|
||
file.append('test.png');
|
||
var fileDataTransfer = {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
};
|
||
|
||
// Directly onto a specific item (which identifies the target library): allowed
|
||
assert.isTrue(itemsView.canDropCheck(itemsView.getRowIndexByID(userItem.id), 0, fileDataTransfer));
|
||
// Into blank space (ambiguous across libraries): rejected
|
||
assert.isFalse(itemsView.canDropCheck(-1, -1, fileDataTransfer));
|
||
|
||
// Dropping onto the group item attaches the file in the group library
|
||
var idsPromise = waitForItemEvent('add');
|
||
await drop(itemsView.getRowIndexByID(groupItem.id), 0, fileDataTransfer);
|
||
var ids = await idsPromise;
|
||
var attachment = Zotero.Items.get(ids[0]);
|
||
assert.equal(attachment.libraryID, group.libraryID);
|
||
assert.equal(attachment.parentItemID, groupItem.id);
|
||
|
||
await selectLibrary(win);
|
||
await group.eraseTx();
|
||
});
|
||
|
||
it("should allow a blank-space file drop for a mixed collection and saved-search selection regardless of order", async function () {
|
||
var collection = await createDataObject('collection');
|
||
var search = await createDataObject('search');
|
||
|
||
var file = getTestDataDirectory();
|
||
file.append('test.png');
|
||
var fileDataTransfer = {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
};
|
||
|
||
// Select the saved search first (so it's focused), then add the collection
|
||
await cv.selectByID("S" + search.id);
|
||
await waitForItemsLoad(win);
|
||
cv.selection.toggleSelect(cv.getRowIndexByID("C" + collection.id));
|
||
await zp.onCollectionSelected();
|
||
await zp.itemsView.waitForLoad();
|
||
itemsView = zp.itemsView;
|
||
|
||
// Allowed even though the focused row is a search, since a selected
|
||
// collection can receive the file
|
||
assert.isTrue(itemsView.canDropCheck(-1, -1, fileDataTransfer));
|
||
|
||
await selectLibrary(win);
|
||
});
|
||
|
||
it("should create a stored top-level attachment when a file URI is dragged", async function () {
|
||
var promise = itemsView.waitForSelect();
|
||
var pdfFile = getTestDataDirectory();
|
||
pdfFile.append('test.pdf');
|
||
var pdfURL = Services.io.newFileURI(pdfFile).spec;
|
||
|
||
await drop(0, -1, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['text/x-moz-url'],
|
||
getData: function (type) {
|
||
if (type == 'text/x-moz-url') {
|
||
return pdfURL;
|
||
}
|
||
},
|
||
mozItemCount: 1,
|
||
});
|
||
|
||
await promise;
|
||
var item = itemsView.getSelectedItems()[0];
|
||
assert.equal(item.getField('url'), '');
|
||
assert.equal(
|
||
(await Zotero.File.getBinaryContentsAsync(await item.getFilePathAsync())),
|
||
(await Zotero.File.getBinaryContentsAsync(pdfFile))
|
||
);
|
||
});
|
||
|
||
it("should create a stored child attachment when a file URI is dragged", async function () {
|
||
var view = zp.itemsView;
|
||
var parentItem = await createDataObject('item');
|
||
var parentRow = view.getRowIndexByID(parentItem.id);
|
||
|
||
var promise = waitForItemEvent('add');
|
||
var pdfFile = getTestDataDirectory();
|
||
pdfFile.append('test.pdf');
|
||
var pdfURL = Services.io.newFileURI(pdfFile).spec;
|
||
|
||
await drop(parentRow, 0, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['text/x-moz-url'],
|
||
getData: function (type) {
|
||
if (type == 'text/x-moz-url') {
|
||
return pdfURL;
|
||
}
|
||
},
|
||
mozItemCount: 1,
|
||
});
|
||
|
||
var itemIDs = await promise;
|
||
var item = Zotero.Items.get(itemIDs[0]);
|
||
assert.equal(item.parentItemID, parentItem.id);
|
||
assert.equal(item.getField('url'), '');
|
||
assert.equal(
|
||
(await Zotero.File.getBinaryContentsAsync(await item.getFilePathAsync())),
|
||
(await Zotero.File.getBinaryContentsAsync(pdfFile))
|
||
);
|
||
});
|
||
|
||
it("should automatically retrieve metadata for top-level PDF if pref is enabled", async function () {
|
||
Zotero.Prefs.set('autoRecognizeFiles', true);
|
||
|
||
var view = zp.itemsView;
|
||
|
||
var promise = waitForItemEvent('add');
|
||
|
||
// Fake recognizer response
|
||
Zotero.HTTP.mock = sinon.FakeXMLHttpRequest;
|
||
var server = sinon.fakeServer.create();
|
||
server.autoRespond = true;
|
||
setHTTPResponse(
|
||
server,
|
||
ZOTERO_CONFIG.SERVICES_URL,
|
||
{
|
||
method: 'POST',
|
||
url: 'recognizer/recognize',
|
||
status: 200,
|
||
headers: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
json: {
|
||
title: 'Test',
|
||
authors: []
|
||
}
|
||
}
|
||
);
|
||
|
||
var file = getTestDataDirectory();
|
||
file.append('test.pdf');
|
||
|
||
drop(0, -1, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
// Wait for attachment item
|
||
var attachmentIDs = await promise;
|
||
// Wait for attachment item to be moved under new item
|
||
await waitForItemEvent('add');
|
||
await waitForItemEvent('modify');
|
||
await waitForItemEvent('modify');
|
||
|
||
assert.isFalse(Zotero.Items.get(attachmentIDs[0]).isTopLevelItem());
|
||
|
||
Zotero.HTTP.mock = null;
|
||
});
|
||
|
||
it("should automatically retrieve metadata for multiple top-level PDFs if pref is enabled", async function () {
|
||
Zotero.Prefs.set('autoRecognizeFiles', true);
|
||
|
||
var view = zp.itemsView;
|
||
|
||
var promise = waitForItemEvent('add');
|
||
var recognizerPromise = waitForRecognizer();
|
||
|
||
// Fake recognizer response
|
||
Zotero.HTTP.mock = sinon.FakeXMLHttpRequest;
|
||
var server = sinon.fakeServer.create();
|
||
server.autoRespond = true;
|
||
setHTTPResponse(
|
||
server,
|
||
ZOTERO_CONFIG.SERVICES_URL,
|
||
{
|
||
method: 'POST',
|
||
url: 'recognizer/recognize',
|
||
status: 200,
|
||
headers: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
json: {
|
||
title: 'Test',
|
||
authors: []
|
||
}
|
||
}
|
||
);
|
||
|
||
var file = getTestDataDirectory();
|
||
file.append('test.pdf');
|
||
|
||
drop(0, -1, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozGetDataAt: function (type) {
|
||
if (type == 'application/x-moz-file') {
|
||
return file;
|
||
}
|
||
},
|
||
mozItemCount: 2,
|
||
})
|
||
|
||
var [item1, item2] = Zotero.Items.get(await promise);
|
||
|
||
var progressWindow = await recognizerPromise;
|
||
progressWindow.close();
|
||
Zotero.ProgressQueues.get('recognize').cancel();
|
||
assert.isFalse(item1.isTopLevelItem());
|
||
assert.isFalse(item2.isTopLevelItem());
|
||
|
||
Zotero.HTTP.mock = null;
|
||
});
|
||
|
||
it("should rename a stored child attachment using parent metadata if no existing file attachments and pref enabled", async function () {
|
||
var view = zp.itemsView;
|
||
var parentTitle = Zotero.Utilities.randomString();
|
||
var parentItem = await createDataObject('item', { title: parentTitle });
|
||
await Zotero.Attachments.linkFromURL({
|
||
url: 'https://example.com',
|
||
title: 'Example',
|
||
parentItemID: parentItem.id
|
||
});
|
||
var parentRow = view.getRowIndexByID(parentItem.id);
|
||
|
||
var file = getTestDataDirectory();
|
||
file.append('empty.pdf');
|
||
|
||
var promise = waitForItemEvent('add');
|
||
|
||
drop(parentRow, 0, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
var itemIDs = await promise;
|
||
var item = Zotero.Items.get(itemIDs[0]);
|
||
assert.equal(item.parentItemID, parentItem.id);
|
||
var path = await item.getFilePathAsync();
|
||
assert.equal(OS.Path.basename(path), parentTitle + '.pdf');
|
||
});
|
||
|
||
it("should rename a linked child attachment using parent metadata if no existing file attachments and pref enabled", async function () {
|
||
Zotero.Prefs.set('autoRenameFiles.linked', true);
|
||
|
||
var view = zp.itemsView;
|
||
var parentTitle = Zotero.Utilities.randomString();
|
||
var parentItem = await createDataObject('item', { title: parentTitle });
|
||
await Zotero.Attachments.linkFromURL({
|
||
url: 'https://example.com',
|
||
title: 'Example',
|
||
parentItemID: parentItem.id
|
||
});
|
||
var parentRow = view.getRowIndexByID(parentItem.id);
|
||
|
||
var file = OS.Path.join(await getTempDirectory(), 'empty.pdf');
|
||
await OS.File.copy(
|
||
OS.Path.join(getTestDataDirectory().path, 'empty.pdf'),
|
||
file
|
||
);
|
||
file = Zotero.File.pathToFile(file);
|
||
|
||
var promise = waitForItemEvent('add');
|
||
|
||
drop(parentRow, 0, {
|
||
dropEffect: 'link',
|
||
effectAllowed: 'link',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
var itemIDs = await promise;
|
||
var item = Zotero.Items.get(itemIDs[0]);
|
||
assert.equal(item.parentItemID, parentItem.id);
|
||
var path = await item.getFilePathAsync();
|
||
assert.equal(OS.Path.basename(path), parentTitle + '.pdf');
|
||
});
|
||
|
||
it("shouldn't rename a linked child attachment using parent metadata if pref disabled", async function () {
|
||
Zotero.Prefs.set('autoRenameFiles.linked', false);
|
||
|
||
var view = zp.itemsView;
|
||
var parentTitle = Zotero.Utilities.randomString();
|
||
var parentItem = await createDataObject('item', { title: parentTitle });
|
||
await Zotero.Attachments.linkFromURL({
|
||
url: 'https://example.com',
|
||
title: 'Example',
|
||
parentItemID: parentItem.id
|
||
});
|
||
var parentRow = view.getRowIndexByID(parentItem.id);
|
||
|
||
var file = OS.Path.join(await getTempDirectory(), 'empty.pdf');
|
||
await OS.File.copy(
|
||
OS.Path.join(getTestDataDirectory().path, 'empty.pdf'),
|
||
file
|
||
);
|
||
file = Zotero.File.pathToFile(file);
|
||
|
||
var promise = waitForItemEvent('add');
|
||
|
||
drop(parentRow, 0, {
|
||
dropEffect: 'link',
|
||
effectAllowed: 'link',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
var itemIDs = await promise;
|
||
var item = Zotero.Items.get(itemIDs[0]);
|
||
assert.equal(item.parentItemID, parentItem.id);
|
||
var path = await item.getFilePathAsync();
|
||
assert.equal(OS.Path.basename(path), 'empty.pdf');
|
||
});
|
||
|
||
it("shouldn't rename a stored child attachment using parent metadata if pref disabled", async function () {
|
||
Zotero.Prefs.set('autoRenameFiles', false);
|
||
|
||
var view = zp.itemsView;
|
||
var parentTitle = Zotero.Utilities.randomString();
|
||
var parentItem = await createDataObject('item', { title: parentTitle });
|
||
var parentRow = view.getRowIndexByID(parentItem.id);
|
||
|
||
var originalFileName = 'empty.pdf';
|
||
var file = getTestDataDirectory();
|
||
file.append(originalFileName);
|
||
|
||
var promise = waitForItemEvent('add');
|
||
|
||
drop(parentRow, 0, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
var itemIDs = await promise;
|
||
var item = Zotero.Items.get(itemIDs[0]);
|
||
assert.equal(item.parentItemID, parentItem.id);
|
||
var path = await item.getFilePathAsync();
|
||
// Should match original filename, not parent title
|
||
assert.equal(OS.Path.basename(path), originalFileName);
|
||
});
|
||
|
||
it("shouldn't rename a stored child attachment using parent metadata if existing file attachments", async function () {
|
||
var view = zp.itemsView;
|
||
var parentTitle = Zotero.Utilities.randomString();
|
||
var parentItem = await createDataObject('item', { title: parentTitle });
|
||
await Zotero.Attachments.linkFromFile({
|
||
file: OS.Path.join(getTestDataDirectory().path, 'test.png'),
|
||
parentItemID: parentItem.id
|
||
});
|
||
var parentRow = view.getRowIndexByID(parentItem.id);
|
||
|
||
var originalFileName = 'empty.pdf';
|
||
var file = getTestDataDirectory();
|
||
file.append(originalFileName);
|
||
|
||
var promise = waitForItemEvent('add');
|
||
|
||
drop(parentRow, 0, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
var itemIDs = await promise;
|
||
var item = Zotero.Items.get(itemIDs[0]);
|
||
assert.equal(item.parentItemID, parentItem.id);
|
||
var path = await item.getFilePathAsync();
|
||
assert.equal(OS.Path.basename(path), originalFileName);
|
||
});
|
||
|
||
it("shouldn't rename a stored child attachment using parent metadata if drag includes multiple files", async function () {
|
||
var view = zp.itemsView;
|
||
var parentTitle = Zotero.Utilities.randomString();
|
||
var parentItem = await createDataObject('item', { title: parentTitle });
|
||
var parentRow = view.getRowIndexByID(parentItem.id);
|
||
|
||
var originalFileName = 'empty.pdf';
|
||
var originalFilenameWithoutExtension = 'empty';
|
||
var file = getTestDataDirectory();
|
||
file.append(originalFileName);
|
||
|
||
var promise = waitForItemEvent('add');
|
||
|
||
drop(parentRow, 0, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 2,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i <= 1) {
|
||
return file;
|
||
}
|
||
}
|
||
})
|
||
|
||
var itemIDs = await promise;
|
||
var item = Zotero.Items.get(itemIDs[0]);
|
||
assert.equal(item.parentItemID, parentItem.id);
|
||
var path = await item.getFilePathAsync();
|
||
assert.equal(OS.Path.basename(path), originalFileName);
|
||
|
||
for (let item of Zotero.Items.get(itemIDs)) {
|
||
assert.equal(item.getField('title'), originalFilenameWithoutExtension);
|
||
}
|
||
});
|
||
|
||
it("should set an automatic title on the first file attachment of each supported type", async function () {
|
||
let view = zp.itemsView;
|
||
let parentItem = await createDataObject('item');
|
||
let parentRow = view.getRowIndexByID(parentItem.id);
|
||
|
||
// Add a link attachment, which won't affect renaming
|
||
await Zotero.Attachments.linkFromURL({
|
||
url: 'https://example.com/',
|
||
parentItemID: parentItem.id,
|
||
});
|
||
|
||
let file = getTestDataDirectory();
|
||
file.append('test.pdf');
|
||
|
||
let dataTransfer = {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
};
|
||
|
||
let promise = waitForItemEvent('add');
|
||
drop(parentRow, 0, dataTransfer);
|
||
|
||
// Add a PDF attachment, which will get a default title
|
||
let pdfAttachment1 = Zotero.Items.get((await promise)[0]);
|
||
assert.equal(pdfAttachment1.parentItemID, parentItem.id);
|
||
assert.equal(pdfAttachment1.getField('title'), Zotero.getString('file-type-pdf'));
|
||
|
||
promise = waitForItemEvent('add');
|
||
drop(parentRow, 0, dataTransfer);
|
||
|
||
// Add a second, which will get a title based on its filename
|
||
let pdfAttachment2 = Zotero.Items.get((await promise)[0]);
|
||
assert.equal(pdfAttachment2.parentItemID, parentItem.id);
|
||
assert.equal(pdfAttachment2.getField('title'), 'test');
|
||
});
|
||
|
||
it("should select attachment after a file is dragged onto a top-level item", async function () {
|
||
let item = await createDataObject('item', { title: "Top-level Item" });
|
||
// a file is dropped onto an existing item
|
||
let itemIndex = zp.itemsView.getRowIndexByID(item.id);
|
||
let file = getTestDataDirectory();
|
||
file.append('test.pdf');
|
||
|
||
drop(itemIndex, 0, {
|
||
dropEffect: 'copy',
|
||
effectAllowed: 'copy',
|
||
types: ['application/x-moz-file'],
|
||
mozItemCount: 1,
|
||
mozGetDataAt: function (type, i) {
|
||
if (type == 'application/x-moz-file' && i == 0) {
|
||
return file;
|
||
}
|
||
}
|
||
});
|
||
await waitForNotifierEvent('add', 'item');
|
||
// the top-level item should be expanded
|
||
assert.isTrue(zp.itemsView.isContainerOpen(itemIndex));
|
||
// the child attachment that was added should be selected
|
||
assert.equal(zp.itemsView.selection.focused, itemIndex + 1);
|
||
});
|
||
});
|
||
|
||
describe("#_expandToItem()", function () {
|
||
it("should expand all ancestors for a nested annotation", async function () {
|
||
let parentItem = await createDataObject('item', { title: 'Parent Item' });
|
||
let attachment = await importFileAttachment('test.pdf', { parentItemID: parentItem.id });
|
||
let annotation = await createAnnotation('highlight', attachment);
|
||
await waitForItemsLoad(win);
|
||
|
||
itemsView.collapseAllRows();
|
||
await waitForItemsLoad(win);
|
||
|
||
let collapsedParentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
assert.isNumber(collapsedParentRow);
|
||
assert.isFalse(itemsView.isContainerOpen(collapsedParentRow));
|
||
assert.isFalse(itemsView.getRowIndexByID(attachment.id));
|
||
assert.isFalse(itemsView.getRowIndexByID(annotation.id));
|
||
|
||
let expanded = itemsView.rowProvider._expandToItem(annotation.id);
|
||
assert.isTrue(expanded);
|
||
|
||
let parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
let attachmentRow = itemsView.getRowIndexByID(attachment.id);
|
||
assert.isTrue(itemsView.isContainerOpen(parentRow));
|
||
assert.isTrue(itemsView.isContainerOpen(attachmentRow));
|
||
assert.isNumber(itemsView.getRowIndexByID(annotation.id));
|
||
});
|
||
});
|
||
|
||
describe("#setCollectionTreeRows()", function () {
|
||
it("should no-op when setting the same rows", async function () {
|
||
let rowProvider = itemsView.rowProvider;
|
||
let currentRow = rowProvider.collectionTreeRows[0];
|
||
assert.ok(currentRow);
|
||
|
||
let refreshSpy = sinon.spy(rowProvider, 'refresh');
|
||
|
||
try {
|
||
await rowProvider.setCollectionTreeRows([currentRow]);
|
||
assert.equal(refreshSpy.callCount, 0);
|
||
}
|
||
finally {
|
||
refreshSpy.restore();
|
||
}
|
||
});
|
||
|
||
it("should treat collections, saved searches, and library roots as one kind of view", async function () {
|
||
let collection = await createDataObject('collection');
|
||
let search = await createDataObject('search');
|
||
|
||
await selectLibrary(win);
|
||
assert.equal(zp.itemsView.viewMode, 'default');
|
||
|
||
await cv.selectByID("C" + collection.id);
|
||
await waitForItemsLoad(win);
|
||
assert.equal(zp.itemsView.viewMode, 'default');
|
||
|
||
// A collection and a saved search together are still an ordinary view
|
||
cv.selection.toggleSelect(cv.getRowIndexByID("S" + search.id));
|
||
await zp.onCollectionSelected();
|
||
await zp.itemsView.waitForLoad();
|
||
assert.equal(zp.itemsView.viewMode, 'default');
|
||
|
||
await cv.selectByID("T" + Zotero.Libraries.userLibraryID);
|
||
await waitForItemsLoad(win);
|
||
assert.equal(zp.itemsView.viewMode, 'trash');
|
||
|
||
await selectLibrary(win);
|
||
});
|
||
|
||
it("should reject rows that don't form a single view", async function () {
|
||
let collection = await createDataObject('collection');
|
||
await cv.selectByID("C" + collection.id);
|
||
await waitForItemsLoad(win);
|
||
|
||
let collectionRow = cv.getRow(cv.getRowIndexByID("C" + collection.id));
|
||
let trashRow = cv.getRow(cv.getRowIndexByID("T" + Zotero.Libraries.userLibraryID));
|
||
|
||
let error = await getPromiseError(
|
||
zp.itemsView.rowProvider.setCollectionTreeRows([collectionRow, trashRow])
|
||
);
|
||
assert.match(error.message, /don't form a single view/);
|
||
|
||
await selectLibrary(win);
|
||
});
|
||
});
|
||
|
||
describe("Library grouping", function () {
|
||
// Fluent wraps interpolated values in bidi isolation marks; strip them for
|
||
// plain-text comparisons
|
||
function stripBidi(str) {
|
||
return str.replace(/[-]/g, '');
|
||
}
|
||
|
||
async function selectMultipleCollections(collections) {
|
||
await cv.selectByID("C" + collections[0].id);
|
||
await waitForItemsLoad(win);
|
||
for (let i = 1; i < collections.length; i++) {
|
||
cv.selection.toggleSelect(cv.getRowIndexByID("C" + collections[i].id));
|
||
}
|
||
await zp.onCollectionSelected();
|
||
await zp.itemsView.waitForLoad();
|
||
}
|
||
|
||
it("should group items by library with headers in collections-list order", async function () {
|
||
let group = await createGroup();
|
||
let collection1 = await createDataObject('collection');
|
||
let collection2 = await createDataObject('collection', { libraryID: group.libraryID });
|
||
// Reverse-alphabetical across the library boundary, so title sorting
|
||
// alone would put the group item first
|
||
let item1 = await createDataObject('item', { title: "ZZZ", collections: [collection1.id] });
|
||
let item2 = await createDataObject(
|
||
'item',
|
||
{ libraryID: group.libraryID, title: "AAA", collections: [collection2.id] }
|
||
);
|
||
|
||
await cv.expandLibrary(group.libraryID);
|
||
await selectMultipleCollections([collection1, collection2]);
|
||
|
||
let view = zp.itemsView;
|
||
let userHeaderRow = view.getRowIndexByID("L" + Zotero.Libraries.userLibraryID);
|
||
let groupHeaderRow = view.getRowIndexByID("L" + group.libraryID);
|
||
let item1Row = view.getRowIndexByID(item1.id);
|
||
let item2Row = view.getRowIndexByID(item2.id);
|
||
|
||
assert.isNumber(userHeaderRow, "User library header should be shown");
|
||
assert.isNumber(groupHeaderRow, "Group library header should be shown");
|
||
assert.isBelow(userHeaderRow, groupHeaderRow,
|
||
"User library group should come first");
|
||
assert.isAbove(item1Row, userHeaderRow);
|
||
assert.isBelow(item1Row, groupHeaderRow,
|
||
"User library item should be in the user library group despite sorting after the group item");
|
||
assert.isAbove(item2Row, groupHeaderRow);
|
||
|
||
// Header rows aren't selectable
|
||
assert.isFalse(view.isSelectable(userHeaderRow));
|
||
|
||
// Each cross-library header is the library name plus what's selected in it
|
||
assert.equal(stripBidi(view.getRow(groupHeaderRow).getDisplayTitle()),
|
||
Zotero.Libraries.getName(group.libraryID) + " (1 collection selected)");
|
||
|
||
// A blank spacer row sits above every header except the first, for whitespace
|
||
// separating the sections
|
||
assert.notEqual(view.getRow(userHeaderRow - 1)?.type, 'spacer',
|
||
"No spacer above the first header");
|
||
assert.equal(view.getRow(groupHeaderRow - 1).type, 'spacer',
|
||
"Spacer row above a later header");
|
||
assert.isFalse(view.isSelectable(groupHeaderRow - 1),
|
||
"Spacer rows aren't selectable");
|
||
|
||
await selectLibrary(win);
|
||
await group.eraseTx();
|
||
});
|
||
|
||
it("should pin the section header of the library scrolled to the top", async function () {
|
||
let group = await createGroup();
|
||
let collection1 = await createDataObject('collection');
|
||
let collection2 = await createDataObject('collection', { libraryID: group.libraryID });
|
||
await createDataObject('item', { collections: [collection1.id] });
|
||
// Enough group items below the group header that it can be scrolled to the top
|
||
await Zotero.DB.executeTransaction(async function () {
|
||
for (let i = 0; i < 60; i++) {
|
||
let item = createUnsavedDataObject(
|
||
'item', { libraryID: group.libraryID, collections: [collection2.id] }
|
||
);
|
||
await item.save();
|
||
}
|
||
});
|
||
|
||
await cv.expandLibrary(group.libraryID);
|
||
await selectMultipleCollections([collection1, collection2]);
|
||
|
||
let view = zp.itemsView;
|
||
let tree = view.tree;
|
||
let body = tree._jsWindow.targetElement;
|
||
let userHeaderRow = view.getRowIndexByID("L" + Zotero.Libraries.userLibraryID);
|
||
let groupHeaderRow = view.getRowIndexByID("L" + group.libraryID);
|
||
|
||
// At the very top, the real header is in place, so nothing is pinned -- a pinned
|
||
// copy would just double the header
|
||
body.scrollTop = 0;
|
||
tree._updateStickySectionHeader();
|
||
assert.equal(tree._stickyHeader.style.display, 'none');
|
||
|
||
// Scrolling the first (user library) header up under the top pins it
|
||
body.scrollTop = tree._jsWindow._getItemPosition(userHeaderRow) + 5;
|
||
tree._updateStickySectionHeader();
|
||
assert.include(tree._stickyHeader.textContent,
|
||
Zotero.Libraries.getName(Zotero.Libraries.userLibraryID));
|
||
|
||
// The pinned header lines up horizontally with the real header row
|
||
let realIcon = tree._jsWindow.getElementByIndex(userHeaderRow).querySelector('.icon-item-type');
|
||
let stickyIcon = tree._stickyHeaderContent.querySelector('.icon-item-type');
|
||
assert.equal(
|
||
stickyIcon.getBoundingClientRect().left,
|
||
realIcon.getBoundingClientRect().left,
|
||
"Pinned header icon should align with the real header icon"
|
||
);
|
||
|
||
// A focused header row renders with the focus class, but the pinned copy must
|
||
// not carry that focus ring
|
||
tree.selection.focused = userHeaderRow;
|
||
assert.isTrue(tree._renderItem(userHeaderRow).classList.contains('focused'),
|
||
"Setup: a focused header row renders with the focus class");
|
||
tree._stickyHeaderIndex = null;
|
||
tree._updateStickySectionHeader();
|
||
assert.isFalse(tree._stickyHeaderContent.querySelector('.row').classList.contains('focused'),
|
||
"Pinned header should not show a focus ring");
|
||
|
||
// Scrolling the group header up under the top pins the group library header instead
|
||
body.scrollTop = tree._jsWindow._getItemPosition(groupHeaderRow) + 5;
|
||
tree._updateStickySectionHeader();
|
||
assert.include(tree._stickyHeader.textContent, Zotero.Libraries.getName(group.libraryID));
|
||
|
||
await selectLibrary(win);
|
||
await group.eraseTx();
|
||
});
|
||
|
||
it("should restart row striping at each section header", async function () {
|
||
let group = await createGroup();
|
||
let collection1 = await createDataObject('collection');
|
||
let collection2 = await createDataObject('collection', { libraryID: group.libraryID });
|
||
// One user-library item so the group's first item falls on an even absolute index
|
||
await createDataObject('item', { collections: [collection1.id] });
|
||
await createDataObject('item', { libraryID: group.libraryID, collections: [collection2.id] });
|
||
|
||
await cv.expandLibrary(group.libraryID);
|
||
await selectMultipleCollections([collection1, collection2]);
|
||
|
||
let view = zp.itemsView;
|
||
let tree = view.tree;
|
||
let groupHeaderRow = view.getRowIndexByID("L" + group.libraryID);
|
||
let firstGroupItemRow = groupHeaderRow + 1;
|
||
// The header is the section's unstriped row, so the item right below it is
|
||
// striped (odd) -- even though its absolute index is even
|
||
assert.equal(firstGroupItemRow % 2, 0, "Setup: first group item at an even index");
|
||
let elem = tree._jsWindow.getElementByIndex(firstGroupItemRow);
|
||
assert.isTrue(elem.classList.contains('odd'), "First item below a header is striped");
|
||
assert.isFalse(elem.classList.contains('even'));
|
||
|
||
await selectLibrary(win);
|
||
await group.eraseTx();
|
||
});
|
||
|
||
it("should show one summary header but not group for a single-library multi-selection", async function () {
|
||
let collection1 = await createDataObject('collection');
|
||
let collection2 = await createDataObject('collection');
|
||
let item1 = await createDataObject('item', { collections: [collection1.id] });
|
||
let item2 = await createDataObject('item', { collections: [collection2.id] });
|
||
|
||
await selectMultipleCollections([collection1, collection2]);
|
||
|
||
let view = zp.itemsView;
|
||
// One library -> a single summary header, but not grouped into sections
|
||
assert.isFalse(view.rowProvider._groupedByLibrary);
|
||
let headerRow = view.getRowIndexByID("L" + Zotero.Libraries.userLibraryID);
|
||
assert.isNumber(headerRow, "A summary header should be shown");
|
||
assert.equal(stripBidi(view.getRow(headerRow).getDisplayTitle()), "2 collections selected");
|
||
assert.isNumber(view.getRowIndexByID(item1.id));
|
||
assert.isNumber(view.getRowIndexByID(item2.id));
|
||
|
||
await selectLibrary(win);
|
||
});
|
||
|
||
it("shouldn't include header and spacer rows in the view's items", async function () {
|
||
let group = await createGroup();
|
||
let collection1 = await createDataObject('collection');
|
||
let collection2 = await createDataObject('collection', { libraryID: group.libraryID });
|
||
let item1 = await createDataObject('item', { collections: [collection1.id] });
|
||
let item2 = await createDataObject(
|
||
'item', { libraryID: group.libraryID, collections: [collection2.id] }
|
||
);
|
||
|
||
await cv.expandLibrary(group.libraryID);
|
||
await selectMultipleCollections([collection1, collection2]);
|
||
|
||
let view = zp.itemsView;
|
||
// Two headers and a spacer sit among the rows
|
||
assert.equal(view.rowCount, 5);
|
||
|
||
let items = view.getSortedItems();
|
||
assert.sameMembers(items.map(o => o.id), [item1.id, item2.id]);
|
||
assert.isTrue(items.every(o => o instanceof Zotero.Item));
|
||
assert.sameMembers(view.getSortedItems(true), [item1.id, item2.id]);
|
||
assert.equal(view.objectRowCount, 2);
|
||
|
||
await selectLibrary(win);
|
||
await group.eraseTx();
|
||
});
|
||
|
||
it("should keep headers above their items after a column sort", async function () {
|
||
let group = await createGroup();
|
||
let collection1 = await createDataObject('collection');
|
||
let collection2 = await createDataObject('collection', { libraryID: group.libraryID });
|
||
await createDataObject('item', { title: "AAA", collections: [collection1.id] });
|
||
await createDataObject('item', { title: "ZZZ", collections: [collection1.id] });
|
||
await createDataObject(
|
||
'item', { libraryID: group.libraryID, title: "MMM", collections: [collection2.id] }
|
||
);
|
||
|
||
await cv.expandLibrary(group.libraryID);
|
||
await selectMultipleCollections([collection1, collection2]);
|
||
|
||
let view = zp.itemsView;
|
||
await view.sort();
|
||
|
||
let userHeaderRow = view.getRowIndexByID("L" + Zotero.Libraries.userLibraryID);
|
||
let groupHeaderRow = view.getRowIndexByID("L" + group.libraryID);
|
||
assert.equal(userHeaderRow, 0, "First header stays at the top");
|
||
assert.equal(view.getRow(groupHeaderRow - 1).type, 'spacer',
|
||
"Spacer stays directly above the later header");
|
||
// Every item still sits within its own library's section
|
||
for (let i = 0; i < view.rowCount; i++) {
|
||
let row = view.getRow(i);
|
||
if (!row.isObjectRow) continue;
|
||
if (row.ref.libraryID == group.libraryID) {
|
||
assert.isAbove(i, groupHeaderRow, `Group item at row ${i}`);
|
||
}
|
||
else {
|
||
assert.isBelow(i, groupHeaderRow - 1, `User library item at row ${i}`);
|
||
}
|
||
}
|
||
|
||
await selectLibrary(win);
|
||
await group.eraseTx();
|
||
});
|
||
|
||
it("shouldn't group feeds by library, even across feed libraries", async function () {
|
||
let feed1 = await createFeed();
|
||
let feed2 = await createFeed();
|
||
let feedItem1 = await createDataObject('feedItem', { libraryID: feed1.libraryID });
|
||
let feedItem2 = await createDataObject('feedItem', { libraryID: feed2.libraryID });
|
||
|
||
// Select both feeds (each is its own feed library)
|
||
await cv.selectByID(feed1.treeViewID);
|
||
await waitForItemsLoad(win);
|
||
cv.selection.toggleSelect(cv.getRowIndexByID(feed2.treeViewID));
|
||
await zp.onCollectionSelected();
|
||
await zp.itemsView.waitForLoad();
|
||
|
||
let view = zp.itemsView;
|
||
// The selection spans two feed libraries, but feeds are never grouped
|
||
assert.isFalse(view.rowProvider._groupedByLibrary);
|
||
assert.isFalse(view.getRowIndexByID("L" + feed1.libraryID),
|
||
"No library header should be shown for a feeds selection");
|
||
assert.isNumber(view.getRowIndexByID(feedItem1.id));
|
||
assert.isNumber(view.getRowIndexByID(feedItem2.id));
|
||
|
||
await selectLibrary(win);
|
||
await clearFeeds();
|
||
});
|
||
});
|
||
|
||
describe("#setFilter()", function () {
|
||
it("should refresh when search filter value changes", async function () {
|
||
let rowProvider = itemsView.rowProvider;
|
||
let refreshSpy = sinon.spy(rowProvider, 'refresh');
|
||
let setSearchStub = sinon.stub(rowProvider.collectionTreeRows[0], 'setSearch').returns(true);
|
||
|
||
try {
|
||
await rowProvider.setFilter('search', 'changed-search');
|
||
assert.isTrue(setSearchStub.calledOnceWithExactly('changed-search',
|
||
Zotero.Prefs.get('search.quicksearch-mode')));
|
||
assert.isTrue(refreshSpy.calledOnceWithExactly({ restoreSelection: true }));
|
||
}
|
||
finally {
|
||
setSearchStub.restore();
|
||
refreshSpy.restore();
|
||
}
|
||
});
|
||
|
||
it("should not refresh when filter value is unchanged", async function () {
|
||
let rowProvider = itemsView.rowProvider;
|
||
let refreshSpy = sinon.spy(rowProvider, 'refresh');
|
||
let setSearchStub = sinon.stub(rowProvider.collectionTreeRows[0], 'setSearch').returns(false);
|
||
|
||
try {
|
||
await rowProvider.setFilter('search', 'unchanged-search');
|
||
assert.equal(refreshSpy.callCount, 0);
|
||
}
|
||
finally {
|
||
setSearchStub.restore();
|
||
refreshSpy.restore();
|
||
}
|
||
});
|
||
});
|
||
|
||
describe("#_refresh()", function () {
|
||
it("should await sort context readiness before sorting", async function () {
|
||
let rowProvider = itemsView.rowProvider;
|
||
let deferred = Zotero.Promise.defer();
|
||
let ensureStub = sinon.stub(itemsView, '_ensureSortContextReady').returns(deferred.promise);
|
||
let sortSpy = sinon.spy(rowProvider, '_sort');
|
||
|
||
try {
|
||
let refreshPromise = rowProvider._refresh();
|
||
await Zotero.Promise.delay(20);
|
||
assert.equal(sortSpy.callCount, 0);
|
||
deferred.resolve();
|
||
await refreshPromise;
|
||
assert.isTrue(sortSpy.called);
|
||
}
|
||
finally {
|
||
sortSpy.restore();
|
||
ensureStub.restore();
|
||
}
|
||
});
|
||
});
|
||
|
||
describe("#handleRowModelUpdate()", function () {
|
||
it("should clear selection and return false when loading is true", async function () {
|
||
await itemsView.waitForLoad();
|
||
let item = await createDataObject('item');
|
||
await waitForItemsLoad(win);
|
||
|
||
let row = itemsView.getRowIndexByID(item.id);
|
||
assert.isNumber(row);
|
||
itemsView.selection.select(row);
|
||
assert.equal(itemsView.selection.count, 1);
|
||
|
||
let setMessageSpy = sinon.spy(itemsView, 'setItemsPaneMessage');
|
||
|
||
try {
|
||
let done = await itemsView.handleRowModelUpdate([], { loading: true });
|
||
assert.isFalse(done);
|
||
assert.equal(itemsView.selection.count, 0);
|
||
assert.equal(itemsView.selection.focused, 0);
|
||
assert.isTrue(setMessageSpy.calledOnce);
|
||
assert.equal(setMessageSpy.firstCall.args[0], Zotero.getString('pane.items.loading'));
|
||
}
|
||
finally {
|
||
setMessageSpy.restore();
|
||
await itemsView.clearItemsPaneMessage();
|
||
}
|
||
});
|
||
});
|
||
|
||
describe("#_restoreSelection()", function () {
|
||
it("should reselect collection in trash", async function () {
|
||
var userLibraryID = Zotero.Libraries.userLibraryID;
|
||
var collection = await createDataObject('collection', { deleted: true });
|
||
var item = await createDataObject('item', { deleted: true });
|
||
await cv.selectByID("T" + userLibraryID);
|
||
await waitForItemsLoad(win);
|
||
|
||
var collectionRow = zp.itemsView.getRowIndexByID(collection.treeViewID)
|
||
var itemRow = zp.itemsView.getRowIndexByID(item.id)
|
||
zp.itemsView.selection.toggleSelect(collectionRow);
|
||
zp.itemsView.selection.toggleSelect(itemRow);
|
||
|
||
var selection = zp.itemsView.getSelectedObjects();
|
||
assert.lengthOf(selection, 2);
|
||
zp.itemsView.selection.clearSelection();
|
||
assert.lengthOf(zp.itemsView.getSelectedObjects(), 0);
|
||
zp.itemsView._restoreSelection(selection);
|
||
assert.lengthOf(zp.itemsView.getSelectedObjects(), 2);
|
||
});
|
||
|
||
it("should not expand collapsed parents when expandCollapsedParents is false", async function () {
|
||
let parentItem = await createDataObject('item', { title: 'Parent Item' });
|
||
let childAttachment = await importFileAttachment('test.png', { parentItemID: parentItem.id });
|
||
await waitForItemsLoad(win);
|
||
|
||
await itemsView.selectItem(childAttachment.id);
|
||
let parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
assert.isTrue(itemsView.isContainerOpen(parentRow));
|
||
|
||
itemsView.rowProvider._closeContainer(parentRow);
|
||
parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
assert.isFalse(itemsView.isContainerOpen(parentRow));
|
||
|
||
itemsView.selection.clearSelection();
|
||
await itemsView._restoreSelection([childAttachment], false, false);
|
||
|
||
parentRow = itemsView.getRowIndexByID(parentItem.id);
|
||
assert.isFalse(itemsView.isContainerOpen(parentRow));
|
||
assert.isFalse(itemsView.getRowIndexByID(childAttachment.id));
|
||
assert.sameMembers(itemsView.getSelectedItems(true), [parentItem.id]);
|
||
});
|
||
});
|
||
|
||
describe("primary cell rendering", function () {
|
||
async function getPrimaryCellContent(asHTML = false) {
|
||
let cellText;
|
||
do {
|
||
await Zotero.Promise.delay(10);
|
||
cellText = win.document.querySelector('#zotero-items-tree .row.selected .cell.title .cell-text');
|
||
}
|
||
while (!cellText);
|
||
return asHTML ? cellText.innerHTML : cellText.innerText;
|
||
}
|
||
|
||
before(async function () {
|
||
await waitForItemsLoad(win);
|
||
});
|
||
|
||
it("should render citeproc.js HTML", async function () {
|
||
await createDataObject('item', {
|
||
title: 'Review of <i>Review of <i>B<sub>oo</sub>k</i> <another-tag/></i>'
|
||
});
|
||
assert.equal(await getPrimaryCellContent(true), 'Review of <i xmlns="http://www.w3.org/1999/xhtml">Review of <span style="font-style: normal;">B<sub>oo</sub>k</span> <another-tag/></i>');
|
||
});
|
||
|
||
describe("showAttachmentFilenames pref", function () {
|
||
beforeEach(function () {
|
||
Zotero.Prefs.set('showAttachmentFilenames', true);
|
||
});
|
||
|
||
after(function () {
|
||
Zotero.Prefs.clear('showAttachmentFilenames');
|
||
});
|
||
|
||
it("should display attachment filenames instead of titles", async function () {
|
||
await importPDFAttachment(null, { title: 'Title' });
|
||
assert.equal(await getPrimaryCellContent(), 'test.pdf');
|
||
});
|
||
|
||
it("should display full path when it can't be parsed", async function () {
|
||
if (Zotero.isWin) this.skip();
|
||
|
||
let file = getTestDataDirectory();
|
||
file.append('test.pdf');
|
||
let attachment = await Zotero.Attachments.linkFromFile({
|
||
file,
|
||
title: 'Title'
|
||
});
|
||
attachment.attachmentPath = 'C:\\a\\b\\c\\test.pdf';
|
||
await attachment.saveTx();
|
||
assert.equal(await getPrimaryCellContent(), attachment.attachmentPath);
|
||
});
|
||
});
|
||
});
|
||
|
||
describe("Annotations", function () {
|
||
let toplevelItem, attachment, highlight, underline, ink, image, note;
|
||
|
||
before(async () => {
|
||
var collection = await createDataObject('collection');
|
||
await select(win, collection);
|
||
});
|
||
|
||
beforeEach(async () => {
|
||
toplevelItem = await createDataObject('item', { title: "Item" });
|
||
attachment = await importFileAttachment('test.pdf', { title: 'PDF', parentItemID: toplevelItem.id });
|
||
highlight = await createAnnotation('highlight', attachment);
|
||
underline = await createAnnotation('underline', attachment);
|
||
ink = await createAnnotation('ink', attachment);
|
||
image = await createAnnotation('image', attachment);
|
||
note = await createAnnotation('image', attachment);
|
||
});
|
||
|
||
it("should display annotations as child rows of attachments", async () => {
|
||
zp.itemsView.expandAllRows(true);
|
||
|
||
var attachmentRowIndex = zp.itemsView.getRowIndexByID(attachment.id);
|
||
|
||
let offset = 0;
|
||
for (let annotation of attachment.getAnnotations()) {
|
||
let annotationRowIndex = zp.itemsView.getRowIndexByID(annotation.id);
|
||
offset += 1;
|
||
assert.equal(annotationRowIndex, attachmentRowIndex + offset);
|
||
assert.equal(zp.itemsView.getRow(annotationRowIndex).type, 'annotation');
|
||
}
|
||
});
|
||
|
||
it("should preserve order of annotation rows after sorting", async () => {
|
||
let itemAboveOne = await createDataObject('item', { title: "AAA" });
|
||
let itemAboveTwo = await createDataObject('item', { title: "BBB" });
|
||
let itemBelowOne = await createDataObject('item', { title: "ZZZ" });
|
||
|
||
// Ensure known starting state: primary sort by title ascending
|
||
var colIndex = itemsView.tree._getColumns().findIndex(column => column.dataKey == 'title');
|
||
for (let i = 0; i < 3; i++) {
|
||
let sortFields = itemsView.getSortFields();
|
||
if (sortFields[0] == 'title' && itemsView.getSortDirection(sortFields) == 1) {
|
||
break;
|
||
}
|
||
await zp.itemsView.tree._columns.toggleSort(colIndex);
|
||
}
|
||
assert.equal(itemsView.getSortField(), 'title');
|
||
assert.equal(itemsView.getSortDirection(itemsView.getSortFields()), 1);
|
||
|
||
// Expand annotations
|
||
var itemRowIndex = zp.itemsView.getRowIndexByID(toplevelItem.id);
|
||
await zp.itemsView.toggleOpenState(itemRowIndex);
|
||
|
||
var attachmentRowIndex = zp.itemsView.getRowIndexByID(attachment.id);
|
||
await zp.itemsView.toggleOpenState(attachmentRowIndex);
|
||
|
||
// Record sequence of items
|
||
let rowIDs = zp.itemsView._rows.map(row => row.id);
|
||
|
||
// Sort by title in reverse
|
||
await zp.itemsView.tree._columns.toggleSort(colIndex);
|
||
|
||
attachmentRowIndex = zp.itemsView.getRowIndexByID(attachment.id);
|
||
// Make sure annotations appear after the attachment
|
||
let offset = 0;
|
||
for (let annotation of attachment.getAnnotations()) {
|
||
let annotationRowIndex = zp.itemsView.getRowIndexByID(annotation.id);
|
||
offset += 1;
|
||
assert.equal(annotationRowIndex, attachmentRowIndex + offset);
|
||
}
|
||
|
||
// Sort back and make sure the order of rows is the same as in the beginning
|
||
await zp.itemsView.tree._columns.toggleSort(colIndex);
|
||
assert.deepEqual(rowIDs, zp.itemsView._rows.map(row => row.id));
|
||
});
|
||
|
||
it("should erase annotation on escape when row is selected", async () => {
|
||
zp.itemsView.expandAllRows(true);
|
||
|
||
// Select and delete ink annotation
|
||
let inkID = ink.id;
|
||
await zp.itemsView.selectItems([inkID]);
|
||
|
||
await zp.itemsView.deleteSelection();
|
||
|
||
// Make sure it is deleted and the row is gone
|
||
assert.isFalse(Zotero.Items.get(inkID));
|
||
assert.isFalse(zp.itemsView.getRowIndexByID(inkID));
|
||
});
|
||
|
||
it("should add note from selected annotation rows of the same parent item", async () => {
|
||
zp.itemsView.expandAllRows(true);
|
||
|
||
// make sure underline has some text, just like highlight
|
||
underline.annotationText = "underline";
|
||
await underline.saveTx();
|
||
await zp.itemsView.selectItems([highlight.id, underline.id]);
|
||
|
||
// Click button in the header of annotations pane
|
||
win.document.querySelector("annotation-items-pane .custom-head button").click();
|
||
await waitForItemEvent('add');
|
||
await waitForItemEvent('modify');
|
||
|
||
// Make sure note is created as a child of top level item
|
||
let note = Zotero.Items.get(toplevelItem.getNotes()[0]);
|
||
assert.exists(note);
|
||
let text = note.getNote();
|
||
// Only two paragraphs, one for each annotation, should be added
|
||
assert.equal(text.split("<p>").length - 1, 2);
|
||
});
|
||
|
||
it("should create note from selected annotation rows of different parent items", async () => {
|
||
let toplevelItemTwo = await createDataObject('item', { title: "Another entry" });
|
||
let attachmentTwo = await importFileAttachment('test.pdf', { title: 'PDF two', parentItemID: toplevelItemTwo.id });
|
||
let highlightTwo = await createAnnotation('highlight', attachmentTwo);
|
||
|
||
zp.itemsView.expandAllRows(true);
|
||
|
||
await zp.itemsView.selectItems([highlight.id, highlightTwo.id]);
|
||
|
||
// Click button in the header of annotations pane
|
||
win.document.querySelector("annotation-items-pane .custom-head button").click();
|
||
await waitForItemEvent('add');
|
||
await waitForItemEvent('modify');
|
||
|
||
let note = zp.getSelectedItems()[0];
|
||
assert.isTrue(note.isNote());
|
||
assert.isFalse(note.parentID);
|
||
|
||
let text = note.getNote();
|
||
// Only two paragraphs, one for each annotation, should be added
|
||
assert.equal(text.split("<p>").length - 1, 2);
|
||
// Headers of both top level items are present
|
||
assert.include(text, toplevelItem.getDisplayTitle());
|
||
assert.include(text, toplevelItemTwo.getDisplayTitle());
|
||
});
|
||
});
|
||
|
||
describe("Search error handling", function () {
|
||
var rowProvider;
|
||
|
||
// Stub getSearchObject on a collectionTreeRow so that the search's .search() throws,
|
||
// simulating a broken saved search (e.g., "too many SQL variables").
|
||
function stubBrokenSearch(ctr) {
|
||
return sinon.stub(ctr, 'getSearchObject').resolves({
|
||
search: () => { throw new Error('simulated search failure'); }
|
||
});
|
||
}
|
||
|
||
beforeEach(async function () {
|
||
var search = await createDataObject('search');
|
||
await select(win, search);
|
||
itemsView = zp.itemsView;
|
||
rowProvider = itemsView.rowProvider;
|
||
});
|
||
|
||
it("should show load error message on search failure", async function () {
|
||
var stub = stubBrokenSearch(rowProvider.collectionTreeRows[0]);
|
||
var setMessageSpy = sinon.spy(itemsView, 'setItemsPaneMessage');
|
||
try {
|
||
await rowProvider.refresh();
|
||
assert.isTrue(setMessageSpy.called);
|
||
assert.include(setMessageSpy.lastCall.args[0], Zotero.getString('pane.items.loadError'));
|
||
assert.equal(itemsView.rowCount, 0);
|
||
}
|
||
finally {
|
||
stub.restore();
|
||
setMessageSpy.restore();
|
||
}
|
||
});
|
||
|
||
it("should recover after switching to a working collection", async function () {
|
||
var stub = stubBrokenSearch(rowProvider.collectionTreeRows[0]);
|
||
await rowProvider.refresh();
|
||
stub.restore();
|
||
|
||
await selectLibrary(win);
|
||
itemsView = zp.itemsView;
|
||
assert.isAbove(itemsView.rowCount, 0);
|
||
assert.isFalse(!!itemsView._itemsPaneMessage);
|
||
});
|
||
|
||
it("should not re-throw SearchError from refresh()", async function () {
|
||
var stub = stubBrokenSearch(rowProvider.collectionTreeRows[0]);
|
||
try {
|
||
// refresh() should resolve, not reject
|
||
await rowProvider.refresh();
|
||
}
|
||
finally {
|
||
stub.restore();
|
||
}
|
||
});
|
||
});
|
||
|
||
describe("enabledIn columns", function () {
|
||
it("should preserve column position and visibility across view switches", async function () {
|
||
let group = await createGroup();
|
||
let groupLibraryID = group.libraryID;
|
||
|
||
// Switch to group library
|
||
await selectLibrary(win, groupLibraryID);
|
||
itemsView = zp.itemsView;
|
||
|
||
// Find addedBy column and enable it
|
||
let columns = itemsView._getColumns();
|
||
let addedByIndex = columns.findIndex(c => c.dataKey == 'addedBy');
|
||
assert.notEqual(addedByIndex, -1, 'addedBy column should exist in group view');
|
||
let addedByCol = columns[addedByIndex];
|
||
if (addedByCol.hidden) {
|
||
itemsView.tree._columns.toggleHidden(addedByIndex);
|
||
}
|
||
// Confirm it's visible
|
||
columns = itemsView._getColumns();
|
||
addedByCol = columns.find(c => c.dataKey == 'addedBy');
|
||
assert.isFalse(addedByCol.hidden, 'addedBy should be visible after toggle');
|
||
|
||
// Move addedBy to ordinal 2 (between other visible columns)
|
||
itemsView.tree._columns.setOrder(
|
||
columns.findIndex(c => c.dataKey == 'addedBy'), 2
|
||
);
|
||
|
||
// Record visible columns and addedBy position
|
||
columns = itemsView._getColumns();
|
||
let visibleBefore = columns.filter(c => !c.hidden).map(c => c.dataKey);
|
||
let addedByOrdinalBefore = columns.find(c => c.dataKey == 'addedBy').ordinal;
|
||
assert.include(visibleBefore, 'addedBy');
|
||
|
||
// Switch to user library — addedBy should not be there
|
||
await selectLibrary(win);
|
||
itemsView = zp.itemsView;
|
||
columns = itemsView._getColumns();
|
||
let addedByInUserLib = columns.find(c => c.dataKey == 'addedBy');
|
||
assert.isTrue(addedByInUserLib.disabled, 'addedBy should be disabled in user library');
|
||
|
||
// Verify addedBy is not in visible columns rendered by tree
|
||
let visibleInUserLib = itemsView.tree._getVisibleColumns().map(c => c.dataKey);
|
||
assert.notInclude(visibleInUserLib, 'addedBy');
|
||
|
||
// Switch back to group library
|
||
await selectLibrary(win, groupLibraryID);
|
||
itemsView = zp.itemsView;
|
||
|
||
// addedBy should still be visible and at the same ordinal
|
||
columns = itemsView._getColumns();
|
||
addedByCol = columns.find(c => c.dataKey == 'addedBy');
|
||
assert.isFalse(addedByCol.hidden, 'addedBy should be visible after switching back');
|
||
assert.isFalse(!!addedByCol.disabled, 'addedBy should not be disabled in group');
|
||
assert.equal(addedByCol.ordinal, addedByOrdinalBefore,
|
||
'addedBy ordinal should be preserved after switching views');
|
||
|
||
// Verify it's still in the same position among visible columns
|
||
let visibleAfter = columns.filter(c => !c.hidden).map(c => c.dataKey);
|
||
assert.deepEqual(visibleAfter, visibleBefore,
|
||
'visible column order should be preserved');
|
||
});
|
||
});
|
||
})
|