f8b41c971c
Automatic renaming is now done for dragging of an external file onto an
item (as added in 7cb95f41) as well as dragging as a linked file,
dragging a non-native (not text or HTML) URL, "Attach Link to File…",
"Attach Stored Copy of File…", and "Retrieve Metadata for PDF". It only
applies if a single file is being added and if the parent item has no
non-HTML attachments. By default, the renaming only applies to PDFs, but
this can be changed with the renameAttachmentFiles.automatic.fileTypes
hidden pref.
A new General pref, "Automatically rename attachment files using parent
metadata", controls whether the renaming happens.
Files saved via web translators are renamed regardless of this pref,
because they would often be gibberish otherwise.
Closes #113
1092 lines
34 KiB
JavaScript
1092 lines
34 KiB
JavaScript
"use strict";
|
|
|
|
describe("Zotero.ItemTreeView", function() {
|
|
var win, zp, cv, itemsView, existingItemID;
|
|
|
|
// Load Zotero pane and select library
|
|
before(function* () {
|
|
win = yield loadZoteroPane();
|
|
zp = win.ZoteroPane;
|
|
cv = zp.collectionsView;
|
|
|
|
var item = yield createDataObject('item', { setTitle: true });
|
|
existingItemID = item.id;
|
|
});
|
|
beforeEach(function* () {
|
|
yield selectLibrary(win);
|
|
itemsView = zp.itemsView;
|
|
})
|
|
after(function () {
|
|
win.close();
|
|
});
|
|
|
|
it("shouldn't show items in trash in library root", function* () {
|
|
var item = yield createDataObject('item', { title: "foo" });
|
|
var itemID = item.id;
|
|
item.deleted = true;
|
|
yield item.saveTx();
|
|
assert.isFalse(itemsView.getRowIndexByID(itemID));
|
|
})
|
|
|
|
describe("#selectItem()", function () {
|
|
/**
|
|
* Make sure that selectItem() doesn'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", function* () {
|
|
yield itemsView.selectItem(existingItemID);
|
|
var selected = itemsView.getSelectedItems(true);
|
|
assert.lengthOf(selected, 1);
|
|
assert.equal(selected[0], existingItemID);
|
|
yield itemsView.selectItem(existingItemID);
|
|
selected = itemsView.getSelectedItems(true);
|
|
assert.lengthOf(selected, 1);
|
|
assert.equal(selected[0], existingItemID);
|
|
});
|
|
})
|
|
|
|
describe("#getCellText()", function () {
|
|
it("should return new value after edit", function* () {
|
|
var str = Zotero.Utilities.randomString();
|
|
var item = yield createDataObject('item', { title: str });
|
|
var row = itemsView.getRowIndexByID(item.id);
|
|
assert.equal(itemsView.getCellText(row, { id: 'zotero-items-column-title' }), str);
|
|
yield modifyDataObject(item);
|
|
assert.notEqual(itemsView.getCellText(row, { id: 'zotero-items-column-title' }), str);
|
|
})
|
|
})
|
|
|
|
describe("#notify()", function () {
|
|
beforeEach(function () {
|
|
sinon.spy(win.ZoteroPane, "itemSelected");
|
|
})
|
|
|
|
afterEach(function () {
|
|
win.ZoteroPane.itemSelected.restore();
|
|
})
|
|
|
|
it("should select a new item", function* () {
|
|
itemsView.selection.clearSelection();
|
|
assert.lengthOf(itemsView.getSelectedItems(), 0);
|
|
|
|
assert.equal(win.ZoteroPane.itemSelected.callCount, 1);
|
|
|
|
// Create item
|
|
var item = new Zotero.Item('book');
|
|
var id = yield 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(win.ZoteroPane.itemSelected.returnValues[1].value());
|
|
});
|
|
|
|
it("shouldn't select a new item if skipNotifier is passed", function* () {
|
|
// Select existing item
|
|
yield 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.reset();
|
|
|
|
// Create item with skipNotifier flag
|
|
var item = new Zotero.Item('book');
|
|
var id = yield 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", function* () {
|
|
// Select existing item
|
|
yield 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.reset();
|
|
|
|
// Create item with skipSelect flag
|
|
var item = new Zotero.Item('book');
|
|
var id = yield 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(win.ZoteroPane.itemSelected.returnValues[0].value());
|
|
|
|
// 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.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", function* () {
|
|
var searchString = Zotero.Items.get(existingItemID).getField('title');
|
|
|
|
yield createDataObject('item');
|
|
|
|
var quicksearch = win.document.getElementById('zotero-tb-search');
|
|
quicksearch.value = searchString;
|
|
quicksearch.doCommand();
|
|
yield 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 = yield item.saveTx({
|
|
skipSelect: true
|
|
});
|
|
|
|
assert.equal(itemsView.rowCount, 1);
|
|
assert.equal(quicksearch.value, searchString);
|
|
|
|
// Clear search
|
|
quicksearch.value = "";
|
|
quicksearch.doCommand();
|
|
yield itemsView._refreshPromise;
|
|
});
|
|
|
|
it("shouldn't change selection outside of trash if new trashed item is created with skipSelect", function* () {
|
|
yield selectLibrary(win);
|
|
yield waitForItemsLoad(win);
|
|
|
|
itemsView.selection.clearSelection();
|
|
|
|
var item = createUnsavedDataObject('item');
|
|
item.deleted = true;
|
|
var id = yield item.saveTx({
|
|
skipSelect: true
|
|
});
|
|
|
|
// Nothing should be selected
|
|
var selected = itemsView.getSelectedItems(true);
|
|
assert.lengthOf(selected, 0);
|
|
})
|
|
|
|
it("shouldn't select a modified item", function* () {
|
|
// Create item
|
|
var item = new Zotero.Item('book');
|
|
var id = yield item.saveTx();
|
|
|
|
itemsView.selection.clearSelection();
|
|
assert.lengthOf(itemsView.getSelectedItems(), 0);
|
|
// Reset call count on spy
|
|
win.ZoteroPane.itemSelected.reset();
|
|
|
|
// Modify item
|
|
item.setField('title', 'no select on modify');
|
|
yield item.saveTx();
|
|
|
|
// itemSelected should have been called once (from 'selectEventsSuppressed = false'
|
|
// in notify()) as a no-op
|
|
assert.equal(win.ZoteroPane.itemSelected.callCount, 1);
|
|
assert.isFalse(win.ZoteroPane.itemSelected.returnValues[0].value());
|
|
|
|
// Modified item should not be selected
|
|
assert.lengthOf(itemsView.getSelectedItems(), 0);
|
|
});
|
|
|
|
it("should maintain selection on a selected modified item", function* () {
|
|
// Create item
|
|
var item = new Zotero.Item('book');
|
|
var id = yield item.saveTx();
|
|
|
|
yield 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.reset();
|
|
|
|
// Modify item
|
|
item.setField('title', 'maintain selection on modify');
|
|
yield item.saveTx();
|
|
|
|
// itemSelected should have been called once (from 'selectEventsSuppressed = false'
|
|
// in notify()) as a no-op
|
|
assert.equal(win.ZoteroPane.itemSelected.callCount, 1);
|
|
assert.isFalse(win.ZoteroPane.itemSelected.returnValues[0].value());
|
|
|
|
// 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", function* () {
|
|
var collection = yield createDataObject('collection');
|
|
yield waitForItemsLoad(win);
|
|
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);
|
|
yield 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);
|
|
yield Zotero.DB.executeTransaction(function* () {
|
|
yield collection.removeItems([treeRow.ref.id]);
|
|
}.bind(this));
|
|
|
|
// Selection should stay on third row
|
|
assert.equal(itemsView.selection.currentIndex, 2);
|
|
|
|
// Delete item
|
|
var treeRow = itemsView.getRow(2);
|
|
yield treeRow.ref.eraseTx();
|
|
|
|
// Selection should stay on third row
|
|
assert.equal(itemsView.selection.currentIndex, 2);
|
|
|
|
yield Zotero.Items.erase(items.map(item => item.id));
|
|
});
|
|
|
|
it("shouldn't select sibling on attachment erase if attachment wasn't selected", function* () {
|
|
var item = yield createDataObject('item');
|
|
var att1 = yield importFileAttachment('test.png', { title: 'A', parentItemID: item.id });
|
|
var att2 = yield importFileAttachment('test.png', { title: 'B', parentItemID: item.id });
|
|
yield zp.itemsView.selectItem(att2.id); // expand
|
|
yield zp.itemsView.selectItem(item.id);
|
|
yield 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", function* () {
|
|
var collection = yield createDataObject('collection');
|
|
yield waitForItemsLoad(win);
|
|
itemsView = zp.itemsView;
|
|
|
|
var treebox = itemsView._treebox;
|
|
var numVisibleRows = treebox.getPageLength();
|
|
|
|
// 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;
|
|
yield Zotero.DB.executeTransaction(function* () {
|
|
for (let i = 0; i < num; i++) {
|
|
let title = getTitle(i, num);
|
|
let item = createUnsavedDataObject('item', { title });
|
|
item.addToCollection(collection.id);
|
|
yield 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] }
|
|
);
|
|
yield item.saveTx({
|
|
skipSelect: true
|
|
});
|
|
// Then add a few more in a transaction
|
|
yield Zotero.DB.executeTransaction(function* () {
|
|
for (let i = 0; i < 3; i++) {
|
|
var item = createUnsavedDataObject(
|
|
'item', { title: getTitle(0, num), collections: [collection.id] }
|
|
);
|
|
yield 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", function* () {
|
|
var collection = yield createDataObject('collection');
|
|
yield waitForItemsLoad(win);
|
|
itemsView = zp.itemsView;
|
|
|
|
var treebox = itemsView._treebox;
|
|
var numVisibleRows = treebox.getPageLength();
|
|
|
|
// 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;
|
|
yield Zotero.DB.executeTransaction(function* () {
|
|
for (let i = 0; i < num; i++) {
|
|
let title = getTitle(i, num);
|
|
let item = createUnsavedDataObject('item', { title });
|
|
item.addToCollection(collection.id);
|
|
yield item.save();
|
|
}
|
|
}.bind(this));
|
|
|
|
// 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] }
|
|
);
|
|
yield item.saveTx({
|
|
skipSelect: true
|
|
});
|
|
// Then add a few more in a transaction
|
|
yield Zotero.DB.executeTransaction(function* () {
|
|
for (let i = 0; i < 3; i++) {
|
|
var item = createUnsavedDataObject(
|
|
'item', { title: getTitle(0, num), collections: [collection.id] }
|
|
);
|
|
yield item.save({
|
|
skipSelect: true
|
|
});
|
|
}
|
|
}.bind(this));
|
|
|
|
// 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", function* () {
|
|
var collection = yield createDataObject('collection');
|
|
yield waitForItemsLoad(win);
|
|
itemsView = zp.itemsView;
|
|
|
|
var treebox = itemsView._treebox;
|
|
var numVisibleRows = treebox.getPageLength();
|
|
|
|
// 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;
|
|
yield Zotero.DB.executeTransaction(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);
|
|
yield 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] }
|
|
);
|
|
yield item.saveTx({
|
|
skipSelect: true
|
|
});
|
|
// Then add a few more in a transaction
|
|
yield Zotero.DB.executeTransaction(function* () {
|
|
for (let i = 0; i < 3; i++) {
|
|
var item = createUnsavedDataObject(
|
|
'item', { title: getTitle(0, num), collections: [collection.id] }
|
|
);
|
|
yield 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", function* () {
|
|
var search = yield createDataObject('search');
|
|
var title = search.getConditions()[0].value;
|
|
|
|
yield waitForItemsLoad(win);
|
|
assert.equal(zp.itemsView.rowCount, 0);
|
|
|
|
// Add an item matching search
|
|
var item = yield createDataObject('item', { title });
|
|
|
|
yield 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", function* () {
|
|
var search = yield createDataObject('search');
|
|
itemsView = zp.itemsView;
|
|
var title = search.getConditions()[0].value;
|
|
|
|
var item1 = yield createDataObject('item', { title: title + " 1" });
|
|
var item2 = yield createDataObject('item', { title: title + " 3" });
|
|
var item3 = yield createDataObject('item', { title: title + " 5" });
|
|
var item4 = yield createDataObject('item', { title: title + " 7" });
|
|
|
|
var col = itemsView._treebox.columns.getNamedColumn('zotero-items-column-title');
|
|
col.element.click();
|
|
if (col.element.getAttribute('sortDirection') == 'ascending') {
|
|
col.element.click();
|
|
}
|
|
|
|
// Check initial sort order
|
|
assert.equal(itemsView.getRow(0).ref.getField('title'), title + " 7");
|
|
assert.equal(itemsView.getRow(3).ref.getField('title'), title + " 1");
|
|
|
|
// Set first row to title that should be sorted in the middle
|
|
itemsView.getRow(0).ref.setField('title', title + " 4");
|
|
yield itemsView.getRow(0).ref.saveTx();
|
|
|
|
assert.equal(itemsView.getRow(0).ref.getField('title'), title + " 5");
|
|
assert.equal(itemsView.getRow(1).ref.getField('title'), title + " 4");
|
|
assert.equal(itemsView.getRow(3).ref.getField('title'), title + " 1");
|
|
});
|
|
|
|
it("should update search results when search conditions are changed", 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
|
|
}
|
|
]
|
|
});
|
|
yield search.saveTx();
|
|
|
|
yield waitForItemsLoad(win);
|
|
|
|
// Add an item that doesn't match search
|
|
var item = yield createDataObject('item', { title: title2 });
|
|
yield waitForItemsLoad(win);
|
|
assert.equal(zp.itemsView.rowCount, 0);
|
|
|
|
// Modify conditions to match item
|
|
search.removeCondition(0);
|
|
search.addCondition("title", "is", title2);
|
|
yield search.saveTx();
|
|
|
|
yield waitForItemsLoad(win);
|
|
|
|
assert.equal(zp.itemsView.rowCount, 1);
|
|
});
|
|
|
|
it("should remove items from Unfiled Items when added to a collection", function* () {
|
|
var userLibraryID = Zotero.Libraries.userLibraryID;
|
|
var collection = yield createDataObject('collection');
|
|
var item = yield createDataObject('item', { title: "Unfiled Item" });
|
|
yield zp.setVirtual(userLibraryID, 'unfiled', true);
|
|
var selected = yield cv.selectByID("U" + userLibraryID);
|
|
assert.ok(selected);
|
|
yield waitForItemsLoad(win);
|
|
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
|
yield Zotero.DB.executeTransaction(function* () {
|
|
yield collection.addItem(item.id);
|
|
});
|
|
assert.isFalse(zp.itemsView.getRowIndexByID(item.id));
|
|
});
|
|
|
|
describe("Trash", function () {
|
|
it("should remove untrashed parent item when last trashed child is deleted", function* () {
|
|
var userLibraryID = Zotero.Libraries.userLibraryID;
|
|
var item = yield createDataObject('item');
|
|
var note = yield createDataObject(
|
|
'item', { itemType: 'note', parentID: item.id, deleted: true }
|
|
);
|
|
yield cv.selectByID("T" + userLibraryID);
|
|
yield waitForItemsLoad(win);
|
|
assert.isNumber(zp.itemsView.getRowIndexByID(item.id));
|
|
var promise = waitForDialog();
|
|
yield zp.emptyTrash();
|
|
yield promise;
|
|
assert.isFalse(zp.itemsView.getRowIndexByID(item.id));
|
|
});
|
|
});
|
|
|
|
describe("My Publications", function () {
|
|
before(function* () {
|
|
var libraryID = Zotero.Libraries.userLibraryID;
|
|
|
|
var s = new Zotero.Search;
|
|
s.libraryID = libraryID;
|
|
s.addCondition('publications', 'true');
|
|
var ids = yield s.search();
|
|
|
|
yield Zotero.Items.erase(ids);
|
|
|
|
yield zp.collectionsView.selectByID("P" + libraryID);
|
|
yield waitForItemsLoad(win);
|
|
|
|
// Make sure we're showing the intro text
|
|
var deck = win.document.getElementById('zotero-items-pane-content');
|
|
assert.equal(deck.selectedIndex, 1);
|
|
});
|
|
|
|
it("should replace My Publications intro text with items list on item add", function* () {
|
|
var item = yield createDataObject('item');
|
|
|
|
yield zp.collectionsView.selectByID("P" + item.libraryID);
|
|
yield waitForItemsLoad(win);
|
|
var iv = zp.itemsView;
|
|
|
|
item.inPublications = true;
|
|
yield item.saveTx();
|
|
|
|
var deck = win.document.getElementById('zotero-items-pane-content');
|
|
assert.equal(deck.selectedIndex, 0);
|
|
|
|
assert.isNumber(iv.getRowIndexByID(item.id));
|
|
});
|
|
|
|
it("should add new item to My Publications items list", function* () {
|
|
var item1 = createUnsavedDataObject('item');
|
|
item1.inPublications = true;
|
|
yield item1.saveTx();
|
|
|
|
yield zp.collectionsView.selectByID("P" + item1.libraryID);
|
|
yield waitForItemsLoad(win);
|
|
var iv = zp.itemsView;
|
|
|
|
var deck = win.document.getElementById('zotero-items-pane-content');
|
|
assert.equal(deck.selectedIndex, 0);
|
|
|
|
var item2 = createUnsavedDataObject('item');
|
|
item2.inPublications = true;
|
|
yield item2.saveTx();
|
|
|
|
assert.isNumber(iv.getRowIndexByID(item2.id));
|
|
});
|
|
|
|
it("should add modified item to My Publications items list", function* () {
|
|
var item1 = createUnsavedDataObject('item');
|
|
item1.inPublications = true;
|
|
yield item1.saveTx();
|
|
var item2 = yield createDataObject('item');
|
|
|
|
yield zp.collectionsView.selectByID("P" + item1.libraryID);
|
|
yield waitForItemsLoad(win);
|
|
var iv = zp.itemsView;
|
|
|
|
var deck = win.document.getElementById('zotero-items-pane-content');
|
|
assert.equal(deck.selectedIndex, 0);
|
|
|
|
assert.isFalse(iv.getRowIndexByID(item2.id));
|
|
|
|
item2.inPublications = true;
|
|
yield item2.saveTx();
|
|
|
|
assert.isNumber(iv.getRowIndexByID(item2.id));
|
|
});
|
|
|
|
it("should show Show/Hide button for imported file attachment", function* () {
|
|
var item = yield createDataObject('item', { inPublications: true });
|
|
var attachment = yield importFileAttachment('test.png', { parentItemID: item.id });
|
|
|
|
yield zp.collectionsView.selectByID("P" + item.libraryID);
|
|
yield waitForItemsLoad(win);
|
|
var iv = zp.itemsView;
|
|
|
|
yield iv.selectItem(attachment.id);
|
|
|
|
var box = win.document.getElementById('zotero-item-pane-top-buttons-my-publications');
|
|
assert.isFalse(box.hidden);
|
|
});
|
|
|
|
it("shouldn't show Show/Hide button for linked file attachment", function* () {
|
|
var item = yield createDataObject('item', { inPublications: true });
|
|
var attachment = yield Zotero.Attachments.linkFromFile({
|
|
file: OS.Path.join(getTestDataDirectory().path, 'test.png'),
|
|
parentItemID: item.id
|
|
});
|
|
|
|
yield zp.collectionsView.selectByID("P" + item.libraryID);
|
|
yield waitForItemsLoad(win);
|
|
var iv = zp.itemsView;
|
|
|
|
yield iv.selectItem(attachment.id);
|
|
|
|
var box = win.document.getElementById('zotero-item-pane-top-buttons-my-publications');
|
|
assert.isTrue(box.hidden);
|
|
});
|
|
});
|
|
})
|
|
|
|
|
|
describe("#drop()", function () {
|
|
var httpd;
|
|
var port = 16213;
|
|
var baseURL = `http://localhost:${port}/`;
|
|
var pdfFilename = "test.pdf";
|
|
var pdfURL = baseURL + pdfFilename;
|
|
var pdfPath;
|
|
|
|
// Serve a PDF to test URL dragging
|
|
before(function () {
|
|
Components.utils.import("resource://zotero-unit/httpd.js");
|
|
httpd = new HttpServer();
|
|
httpd.start(port);
|
|
var file = getTestDataDirectory();
|
|
file.append(pdfFilename);
|
|
pdfPath = file.path;
|
|
httpd.registerFile("/" + pdfFilename, file);
|
|
|
|
Zotero.Prefs.clear('renameAttachmentFiles.automatic');
|
|
});
|
|
|
|
afterEach(() => {
|
|
Zotero.Prefs.clear('renameAttachmentFiles.automatic');
|
|
});
|
|
|
|
after(function* () {
|
|
var defer = new Zotero.Promise.defer();
|
|
httpd.stop(() => defer.resolve());
|
|
yield defer.promise;
|
|
});
|
|
|
|
it("should move a child item from one item to another", function* () {
|
|
var collection = yield createDataObject('collection');
|
|
yield waitForItemsLoad(win);
|
|
var item1 = yield createDataObject('item', { title: "A", collections: [collection.id] });
|
|
var item2 = yield createDataObject('item', { title: "B", collections: [collection.id] });
|
|
var item3 = yield createDataObject('item', { itemType: 'note', parentID: item1.id });
|
|
|
|
let view = zp.itemsView;
|
|
yield view.selectItem(item3.id, true);
|
|
|
|
var promise = view.waitForSelect();
|
|
|
|
view.drop(view.getRowIndexByID(item2.id), 0, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == 'zotero/item';
|
|
}
|
|
},
|
|
getData: function (type) {
|
|
if (type == 'zotero/item') {
|
|
return item3.id + "";
|
|
}
|
|
},
|
|
mozItemCount: 1
|
|
})
|
|
|
|
yield promise;
|
|
|
|
// Old parent should be empty
|
|
assert.isFalse(view.isContainerOpen(view.getRowIndexByID(item1.id)));
|
|
assert.isTrue(view.isContainerEmpty(view.getRowIndexByID(item1.id)));
|
|
|
|
// New parent should be open
|
|
assert.isTrue(view.isContainerOpen(view.getRowIndexByID(item2.id)));
|
|
assert.isFalse(view.isContainerEmpty(view.getRowIndexByID(item2.id)));
|
|
});
|
|
|
|
it("should move a child item from last item in list to another", function* () {
|
|
var collection = yield createDataObject('collection');
|
|
yield waitForItemsLoad(win);
|
|
var item1 = yield createDataObject('item', { title: "A", collections: [collection.id] });
|
|
var item2 = yield createDataObject('item', { title: "B", collections: [collection.id] });
|
|
var item3 = yield createDataObject('item', { itemType: 'note', parentID: item2.id });
|
|
|
|
let view = zp.itemsView;
|
|
yield view.selectItem(item3.id, true);
|
|
|
|
var promise = view.waitForSelect();
|
|
|
|
view.drop(view.getRowIndexByID(item1.id), 0, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == 'zotero/item';
|
|
}
|
|
},
|
|
getData: function (type) {
|
|
if (type == 'zotero/item') {
|
|
return item3.id + "";
|
|
}
|
|
},
|
|
mozItemCount: 1
|
|
})
|
|
|
|
yield promise;
|
|
|
|
// Old parent should be empty
|
|
assert.isFalse(view.isContainerOpen(view.getRowIndexByID(item2.id)));
|
|
assert.isTrue(view.isContainerEmpty(view.getRowIndexByID(item2.id)));
|
|
|
|
// New parent should be open
|
|
assert.isTrue(view.isContainerOpen(view.getRowIndexByID(item1.id)));
|
|
assert.isFalse(view.isContainerEmpty(view.getRowIndexByID(item1.id)));
|
|
});
|
|
|
|
it("should create a stored top-level attachment when a file is dragged", function* () {
|
|
var file = getTestDataDirectory();
|
|
file.append('test.png');
|
|
|
|
var promise = itemsView.waitForSelect();
|
|
|
|
itemsView.drop(0, -1, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == 'application/x-moz-file';
|
|
}
|
|
},
|
|
mozItemCount: 1,
|
|
mozGetDataAt: function (type, i) {
|
|
if (type == 'application/x-moz-file' && i == 0) {
|
|
return file;
|
|
}
|
|
}
|
|
})
|
|
|
|
yield promise;
|
|
var items = itemsView.getSelectedItems();
|
|
var path = yield items[0].getFilePathAsync();
|
|
assert.equal(
|
|
(yield Zotero.File.getBinaryContentsAsync(path)),
|
|
(yield Zotero.File.getBinaryContentsAsync(file))
|
|
);
|
|
});
|
|
|
|
it("should create a stored top-level attachment when a URL is dragged", function* () {
|
|
var promise = itemsView.waitForSelect();
|
|
|
|
itemsView.drop(0, -1, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == 'text/x-moz-url';
|
|
}
|
|
},
|
|
getData: function (type) {
|
|
if (type == 'text/x-moz-url') {
|
|
return pdfURL;
|
|
}
|
|
},
|
|
mozItemCount: 1,
|
|
})
|
|
|
|
yield promise;
|
|
var item = itemsView.getSelectedItems()[0];
|
|
assert.equal(item.getField('url'), pdfURL);
|
|
assert.equal(
|
|
(yield Zotero.File.getBinaryContentsAsync(yield item.getFilePathAsync())),
|
|
(yield Zotero.File.getBinaryContentsAsync(pdfPath))
|
|
);
|
|
});
|
|
|
|
it("should create a stored child attachment when a URL is dragged", function* () {
|
|
var view = zp.itemsView;
|
|
var parentItem = yield createDataObject('item');
|
|
var parentRow = view.getRowIndexByID(parentItem.id);
|
|
|
|
var promise = waitForItemEvent('add');
|
|
|
|
itemsView.drop(parentRow, 0, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == 'text/x-moz-url';
|
|
}
|
|
},
|
|
getData: function (type) {
|
|
if (type == 'text/x-moz-url') {
|
|
return pdfURL;
|
|
}
|
|
},
|
|
mozItemCount: 1,
|
|
})
|
|
|
|
var itemIDs = yield promise;
|
|
var item = Zotero.Items.get(itemIDs[0]);
|
|
assert.equal(item.parentItemID, parentItem.id);
|
|
assert.equal(item.getField('url'), pdfURL);
|
|
assert.equal(
|
|
(yield Zotero.File.getBinaryContentsAsync(yield item.getFilePathAsync())),
|
|
(yield Zotero.File.getBinaryContentsAsync(pdfPath))
|
|
);
|
|
});
|
|
|
|
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');
|
|
|
|
itemsView.drop(parentRow, 0, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == '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 title = item.getField('title');
|
|
var path = await item.getFilePathAsync();
|
|
assert.equal(title, parentTitle + '.pdf');
|
|
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 () {
|
|
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');
|
|
|
|
itemsView.drop(parentRow, 0, {
|
|
dropEffect: 'link',
|
|
effectAllowed: 'link',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == '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 title = item.getField('title');
|
|
var path = await item.getFilePathAsync();
|
|
assert.equal(title, parentTitle + '.pdf');
|
|
assert.equal(OS.Path.basename(path), parentTitle + '.pdf');
|
|
});
|
|
|
|
it("shouldn't rename a stored child attachment using parent metadata if pref disabled", async function () {
|
|
Zotero.Prefs.set('renameAttachmentFiles.automatic', 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 originalFileName = 'empty.pdf';
|
|
var file = getTestDataDirectory();
|
|
file.append(originalFileName);
|
|
|
|
var promise = waitForItemEvent('add');
|
|
|
|
itemsView.drop(parentRow, 0, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == '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 title = item.getField('title');
|
|
var path = await item.getFilePathAsync();
|
|
// Should match original filename, not parent title
|
|
assert.equal(title, originalFileName);
|
|
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');
|
|
|
|
itemsView.drop(parentRow, 0, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == '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 title = item.getField('title');
|
|
var path = await item.getFilePathAsync();
|
|
assert.equal(title, originalFileName);
|
|
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 file = getTestDataDirectory();
|
|
file.append(originalFileName);
|
|
|
|
var promise = waitForItemEvent('add');
|
|
|
|
itemsView.drop(parentRow, 0, {
|
|
dropEffect: 'copy',
|
|
effectAllowed: 'copy',
|
|
types: {
|
|
contains: function (type) {
|
|
return type == '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 title = item.getField('title');
|
|
var path = await item.getFilePathAsync();
|
|
assert.equal(title, originalFileName);
|
|
assert.equal(OS.Path.basename(path), originalFileName);
|
|
});
|
|
});
|
|
})
|