b05652ca97
Currently `getAnnotations` will *only* fetch annotations that are either `viewable` or `printable`. This is "hidden" inside the `core.js` file, meaning that API consumers might be confused as to why they are not recieving *all* the annotations present for a page. I thus think that the API should, by default, return *all* available annotations unless specifically told otherwise. In e.g. the default viewer, we obviously only want to display annotations that are `viewable`, hence this patch adds an `intent` parameter to `getAnnotations` that makes it possible to decide if only `viewable` or `printable` annotations should be fetched.
451 lines
17 KiB
JavaScript
451 lines
17 KiB
JavaScript
/* globals PDFJS, expect, it, describe, Promise, combineUrl, waitsFor,
|
|
InvalidPDFException, MissingPDFException, StreamType, FontType,
|
|
PDFDocumentProxy, PasswordException, PasswordResponses,
|
|
PDFPageProxy, createPromiseCapability */
|
|
|
|
'use strict';
|
|
|
|
describe('api', function() {
|
|
var basicApiUrl = combineUrl(window.location.href, '../pdfs/basicapi.pdf');
|
|
var basicApiFileLength = 105779; // bytes
|
|
function waitsForPromiseResolved(promise, successCallback) {
|
|
var resolved = false;
|
|
promise.then(function(val) {
|
|
resolved = true;
|
|
successCallback(val);
|
|
},
|
|
function(error) {
|
|
// Shouldn't get here.
|
|
expect(false).toEqual(true);
|
|
});
|
|
waitsFor(function() {
|
|
return resolved;
|
|
}, 20000);
|
|
}
|
|
function waitsForPromiseRejected(promise, failureCallback) {
|
|
var rejected = false;
|
|
promise.then(function(val) {
|
|
// Shouldn't get here.
|
|
expect(false).toEqual(true);
|
|
},
|
|
function(error) {
|
|
rejected = true;
|
|
failureCallback(error);
|
|
});
|
|
waitsFor(function() {
|
|
return rejected;
|
|
}, 20000);
|
|
}
|
|
|
|
describe('PDFJS', function() {
|
|
describe('getDocument', function() {
|
|
it('creates pdf doc from URL', function() {
|
|
var loadingTask = PDFJS.getDocument(basicApiUrl);
|
|
|
|
var isProgressReportedResolved = false;
|
|
var progressReportedCapability = createPromiseCapability();
|
|
|
|
// Attach the callback that is used to report loading progress;
|
|
// similarly to how viewer.js works.
|
|
loadingTask.onProgress = function (progressData) {
|
|
if (!isProgressReportedResolved) {
|
|
isProgressReportedResolved = true;
|
|
progressReportedCapability.resolve(progressData);
|
|
}
|
|
};
|
|
|
|
var promises = [
|
|
progressReportedCapability.promise,
|
|
loadingTask.promise
|
|
];
|
|
waitsForPromiseResolved(Promise.all(promises), function (data) {
|
|
expect((data[0].loaded / data[0].total) > 0).toEqual(true);
|
|
expect(data[1] instanceof PDFDocumentProxy).toEqual(true);
|
|
expect(loadingTask).toEqual(data[1].loadingTask);
|
|
});
|
|
});
|
|
it('creates pdf doc from URL and aborts before worker initialized',
|
|
function() {
|
|
var loadingTask = PDFJS.getDocument(basicApiUrl);
|
|
loadingTask.destroy();
|
|
waitsForPromiseRejected(loadingTask.promise, function(reason) {
|
|
expect(true).toEqual(true);
|
|
});
|
|
});
|
|
it('creates pdf doc from URL and aborts loading after worker initialized',
|
|
function() {
|
|
var loadingTask = PDFJS.getDocument(basicApiUrl);
|
|
// This can be somewhat random -- we cannot guarantee perfect
|
|
// 'Terminate' message to the worker before/after setting up pdfManager.
|
|
var destroyed = loadingTask._transport.workerInitializedCapability.
|
|
promise.then(function () {
|
|
return loadingTask.destroy();
|
|
});
|
|
waitsForPromiseResolved(destroyed, function (data) {
|
|
expect(true).toEqual(true);
|
|
});
|
|
});
|
|
it('creates pdf doc from typed array', function() {
|
|
var nonBinaryRequest = PDFJS.disableWorker;
|
|
var request = new XMLHttpRequest();
|
|
request.open('GET', basicApiUrl, false);
|
|
if (!nonBinaryRequest) {
|
|
try {
|
|
request.responseType = 'arraybuffer';
|
|
nonBinaryRequest = request.responseType !== 'arraybuffer';
|
|
} catch (e) {
|
|
nonBinaryRequest = true;
|
|
}
|
|
}
|
|
if (nonBinaryRequest && request.overrideMimeType) {
|
|
request.overrideMimeType('text/plain; charset=x-user-defined');
|
|
}
|
|
request.send(null);
|
|
|
|
var typedArrayPdf;
|
|
if (nonBinaryRequest) {
|
|
var data = Array.prototype.map.call(request.responseText,
|
|
function (ch) {
|
|
return ch.charCodeAt(0) & 0xFF;
|
|
});
|
|
typedArrayPdf = new Uint8Array(data);
|
|
} else {
|
|
typedArrayPdf = new Uint8Array(request.response);
|
|
}
|
|
// Sanity check to make sure that we fetched the entire PDF file.
|
|
expect(typedArrayPdf.length).toEqual(basicApiFileLength);
|
|
|
|
var promise = PDFJS.getDocument(typedArrayPdf);
|
|
waitsForPromiseResolved(promise, function(data) {
|
|
expect(data instanceof PDFDocumentProxy).toEqual(true);
|
|
});
|
|
});
|
|
it('creates pdf doc from invalid PDF file', function() {
|
|
// A severely corrupt PDF file (even Adobe Reader fails to open it).
|
|
var url = combineUrl(window.location.href, '../pdfs/bug1020226.pdf');
|
|
|
|
var promise = PDFJS.getDocument(url);
|
|
waitsForPromiseRejected(promise, function (error) {
|
|
expect(error instanceof InvalidPDFException).toEqual(true);
|
|
});
|
|
});
|
|
it('creates pdf doc from non-existent URL', function() {
|
|
var nonExistentUrl = combineUrl(window.location.href,
|
|
'../pdfs/non-existent.pdf');
|
|
var promise = PDFJS.getDocument(nonExistentUrl);
|
|
waitsForPromiseRejected(promise, function(error) {
|
|
expect(error instanceof MissingPDFException).toEqual(true);
|
|
});
|
|
});
|
|
it('creates pdf doc from PDF file protected with user and owner password',
|
|
function () {
|
|
var url = combineUrl(window.location.href, '../pdfs/pr6531_1.pdf');
|
|
var loadingTask = PDFJS.getDocument(url);
|
|
|
|
var isPasswordNeededResolved = false;
|
|
var passwordNeededCapability = createPromiseCapability();
|
|
var isPasswordIncorrectResolved = false;
|
|
var passwordIncorrectCapability = createPromiseCapability();
|
|
|
|
// Attach the callback that is used to request a password;
|
|
// similarly to how viewer.js handles passwords.
|
|
loadingTask.onPassword = function (updatePassword, reason) {
|
|
if (reason === PasswordResponses.NEED_PASSWORD &&
|
|
!isPasswordNeededResolved) {
|
|
isPasswordNeededResolved = true;
|
|
passwordNeededCapability.resolve();
|
|
|
|
updatePassword('qwerty'); // Provide an incorrect password.
|
|
return;
|
|
}
|
|
if (reason === PasswordResponses.INCORRECT_PASSWORD &&
|
|
!isPasswordIncorrectResolved) {
|
|
isPasswordIncorrectResolved = true;
|
|
passwordIncorrectCapability.resolve();
|
|
|
|
updatePassword('asdfasdf'); // Provide the correct password.
|
|
return;
|
|
}
|
|
// Shouldn't get here.
|
|
expect(false).toEqual(true);
|
|
};
|
|
|
|
var promises = [
|
|
passwordNeededCapability.promise,
|
|
passwordIncorrectCapability.promise,
|
|
loadingTask.promise
|
|
];
|
|
waitsForPromiseResolved(Promise.all(promises), function (data) {
|
|
expect(data[2] instanceof PDFDocumentProxy).toEqual(true);
|
|
});
|
|
});
|
|
it('creates pdf doc from PDF file protected with only a user password',
|
|
function () {
|
|
var url = combineUrl(window.location.href, '../pdfs/pr6531_2.pdf');
|
|
|
|
var passwordNeededPromise = PDFJS.getDocument({
|
|
url: url, password: '',
|
|
});
|
|
waitsForPromiseRejected(passwordNeededPromise, function (data) {
|
|
expect(data instanceof PasswordException).toEqual(true);
|
|
expect(data.code).toEqual(PasswordResponses.NEED_PASSWORD);
|
|
});
|
|
|
|
var passwordIncorrectPromise = PDFJS.getDocument({
|
|
url: url, password: 'qwerty',
|
|
});
|
|
waitsForPromiseRejected(passwordIncorrectPromise, function (data) {
|
|
expect(data instanceof PasswordException).toEqual(true);
|
|
expect(data.code).toEqual(PasswordResponses.INCORRECT_PASSWORD);
|
|
});
|
|
|
|
var passwordAcceptedPromise = PDFJS.getDocument({
|
|
url: url, password: 'asdfasdf',
|
|
});
|
|
waitsForPromiseResolved(passwordAcceptedPromise, function (data) {
|
|
expect(data instanceof PDFDocumentProxy).toEqual(true);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
describe('PDFDocument', function() {
|
|
var promise = PDFJS.getDocument(basicApiUrl);
|
|
var doc;
|
|
waitsForPromiseResolved(promise, function(data) {
|
|
doc = data;
|
|
});
|
|
it('gets number of pages', function() {
|
|
expect(doc.numPages).toEqual(3);
|
|
});
|
|
it('gets fingerprint', function() {
|
|
var fingerprint = doc.fingerprint;
|
|
expect(typeof fingerprint).toEqual('string');
|
|
expect(fingerprint.length > 0).toEqual(true);
|
|
});
|
|
it('gets page', function() {
|
|
var promise = doc.getPage(1);
|
|
waitsForPromiseResolved(promise, function(data) {
|
|
expect(data instanceof PDFPageProxy).toEqual(true);
|
|
expect(data.pageIndex).toEqual(0);
|
|
});
|
|
});
|
|
it('gets non-existent page', function() {
|
|
var promise = doc.getPage(100);
|
|
waitsForPromiseRejected(promise, function(data) {
|
|
expect(data instanceof Error).toEqual(true);
|
|
});
|
|
});
|
|
it('gets page index', function() {
|
|
// reference to second page
|
|
var ref = {num: 17, gen: 0};
|
|
var promise = doc.getPageIndex(ref);
|
|
waitsForPromiseResolved(promise, function(pageIndex) {
|
|
expect(pageIndex).toEqual(1);
|
|
});
|
|
});
|
|
it('gets destinations', function() {
|
|
var promise = doc.getDestinations();
|
|
waitsForPromiseResolved(promise, function(data) {
|
|
expect(data).toEqual({ chapter1: [{ gen: 0, num: 17 }, { name: 'XYZ' },
|
|
0, 841.89, null] });
|
|
});
|
|
});
|
|
it('gets a destination', function() {
|
|
var promise = doc.getDestination('chapter1');
|
|
waitsForPromiseResolved(promise, function(data) {
|
|
expect(data).toEqual([{ gen: 0, num: 17 }, { name: 'XYZ' },
|
|
0, 841.89, null]);
|
|
});
|
|
});
|
|
it('gets a non-existent destination', function() {
|
|
var promise = doc.getDestination('non-existent-named-destination');
|
|
waitsForPromiseResolved(promise, function(data) {
|
|
expect(data).toEqual(null);
|
|
});
|
|
});
|
|
it('gets attachments', function() {
|
|
var promise = doc.getAttachments();
|
|
waitsForPromiseResolved(promise, function (data) {
|
|
expect(data).toEqual(null);
|
|
});
|
|
});
|
|
it('gets javascript', function() {
|
|
var promise = doc.getJavaScript();
|
|
waitsForPromiseResolved(promise, function (data) {
|
|
expect(data).toEqual([]);
|
|
});
|
|
});
|
|
// Keep this in sync with the pattern in viewer.js. The pattern is used to
|
|
// detect whether or not to automatically start printing.
|
|
var viewerPrintRegExp = /\bprint\s*\(/;
|
|
it('gets javascript with printing instructions (Print action)', function() {
|
|
// PDF document with "Print" Named action in OpenAction
|
|
var pdfUrl = combineUrl(window.location.href, '../pdfs/bug1001080.pdf');
|
|
var promise = PDFJS.getDocument(pdfUrl).then(function(doc) {
|
|
return doc.getJavaScript();
|
|
});
|
|
waitsForPromiseResolved(promise, function (data) {
|
|
expect(data).toEqual(['print({});']);
|
|
expect(data[0]).toMatch(viewerPrintRegExp);
|
|
});
|
|
});
|
|
it('gets javascript with printing instructions (JS action)', function() {
|
|
// PDF document with "JavaScript" action in OpenAction
|
|
var pdfUrl = combineUrl(window.location.href, '../pdfs/issue6106.pdf');
|
|
var promise = PDFJS.getDocument(pdfUrl).then(function(doc) {
|
|
return doc.getJavaScript();
|
|
});
|
|
waitsForPromiseResolved(promise, function (data) {
|
|
expect(data).toEqual(
|
|
['this.print({bUI:true,bSilent:false,bShrinkToFit:true});']);
|
|
expect(data[0]).toMatch(viewerPrintRegExp);
|
|
});
|
|
});
|
|
it('gets outline', function() {
|
|
var promise = doc.getOutline();
|
|
waitsForPromiseResolved(promise, function(outline) {
|
|
// Two top level entries.
|
|
expect(outline.length).toEqual(2);
|
|
// Make sure some basic attributes are set.
|
|
expect(outline[1].title).toEqual('Chapter 1');
|
|
expect(outline[1].items.length).toEqual(1);
|
|
expect(outline[1].items[0].title).toEqual('Paragraph 1.1');
|
|
});
|
|
});
|
|
it('gets metadata', function() {
|
|
var promise = doc.getMetadata();
|
|
waitsForPromiseResolved(promise, function(metadata) {
|
|
expect(metadata.info['Title']).toEqual('Basic API Test');
|
|
expect(metadata.info['PDFFormatVersion']).toEqual('1.7');
|
|
expect(metadata.metadata.get('dc:title')).toEqual('Basic API Test');
|
|
});
|
|
});
|
|
it('gets data', function() {
|
|
var promise = doc.getData();
|
|
waitsForPromiseResolved(promise, function (data) {
|
|
expect(data instanceof Uint8Array).toEqual(true);
|
|
expect(data.length).toEqual(basicApiFileLength);
|
|
});
|
|
});
|
|
it('gets download info', function() {
|
|
var promise = doc.getDownloadInfo();
|
|
waitsForPromiseResolved(promise, function (data) {
|
|
expect(data).toEqual({ length: basicApiFileLength });
|
|
});
|
|
});
|
|
it('gets stats', function() {
|
|
var promise = doc.getStats();
|
|
waitsForPromiseResolved(promise, function (stats) {
|
|
expect(stats).toEqual({ streamTypes: [], fontTypes: [] });
|
|
});
|
|
});
|
|
|
|
it('checks that fingerprints are unique', function() {
|
|
var url1 = combineUrl(window.location.href, '../pdfs/issue4436r.pdf');
|
|
var loadingTask1 = PDFJS.getDocument(url1);
|
|
|
|
var url2 = combineUrl(window.location.href, '../pdfs/issue4575.pdf');
|
|
var loadingTask2 = PDFJS.getDocument(url2);
|
|
|
|
var promises = [loadingTask1.promise,
|
|
loadingTask2.promise];
|
|
waitsForPromiseResolved(Promise.all(promises), function (data) {
|
|
var fingerprint1 = data[0].fingerprint;
|
|
expect(typeof fingerprint1).toEqual('string');
|
|
expect(fingerprint1.length > 0).toEqual(true);
|
|
|
|
var fingerprint2 = data[1].fingerprint;
|
|
expect(typeof fingerprint2).toEqual('string');
|
|
expect(fingerprint2.length > 0).toEqual(true);
|
|
|
|
expect(fingerprint1).not.toEqual(fingerprint2);
|
|
});
|
|
});
|
|
});
|
|
describe('Page', function() {
|
|
var resolvePromise;
|
|
var promise = new Promise(function (resolve) {
|
|
resolvePromise = resolve;
|
|
});
|
|
var pdfDocument;
|
|
PDFJS.getDocument(basicApiUrl).then(function(doc) {
|
|
doc.getPage(1).then(function(data) {
|
|
resolvePromise(data);
|
|
});
|
|
pdfDocument = doc;
|
|
});
|
|
var page;
|
|
waitsForPromiseResolved(promise, function(data) {
|
|
page = data;
|
|
});
|
|
it('gets page number', function () {
|
|
expect(page.pageNumber).toEqual(1);
|
|
});
|
|
it('gets rotate', function () {
|
|
expect(page.rotate).toEqual(0);
|
|
});
|
|
it('gets ref', function () {
|
|
expect(page.ref).toEqual({ num: 15, gen: 0 });
|
|
});
|
|
it('gets view', function () {
|
|
expect(page.view).toEqual([0, 0, 595.28, 841.89]);
|
|
});
|
|
it('gets viewport', function () {
|
|
var viewport = page.getViewport(1.5, 90);
|
|
expect(viewport.viewBox).toEqual(page.view);
|
|
expect(viewport.scale).toEqual(1.5);
|
|
expect(viewport.rotation).toEqual(90);
|
|
expect(viewport.transform).toEqual([0, 1.5, 1.5, 0, 0, 0]);
|
|
expect(viewport.width).toEqual(1262.835);
|
|
expect(viewport.height).toEqual(892.92);
|
|
});
|
|
it('gets annotations', function () {
|
|
var defaultPromise = page.getAnnotations();
|
|
waitsForPromiseResolved(defaultPromise, function (data) {
|
|
expect(data.length).toEqual(4);
|
|
});
|
|
|
|
var displayPromise = page.getAnnotations({ intent: 'display' });
|
|
waitsForPromiseResolved(displayPromise, function (data) {
|
|
expect(data.length).toEqual(4);
|
|
});
|
|
|
|
var printPromise = page.getAnnotations({ intent: 'print' });
|
|
waitsForPromiseResolved(printPromise, function (data) {
|
|
expect(data.length).toEqual(4);
|
|
});
|
|
});
|
|
it('gets text content', function () {
|
|
var promise = page.getTextContent();
|
|
waitsForPromiseResolved(promise, function (data) {
|
|
expect(!!data.items).toEqual(true);
|
|
expect(data.items.length).toEqual(7);
|
|
expect(!!data.styles).toEqual(true);
|
|
});
|
|
});
|
|
it('gets operator list', function() {
|
|
var promise = page.getOperatorList();
|
|
waitsForPromiseResolved(promise, function (oplist) {
|
|
expect(!!oplist.fnArray).toEqual(true);
|
|
expect(!!oplist.argsArray).toEqual(true);
|
|
expect(oplist.lastChunk).toEqual(true);
|
|
});
|
|
});
|
|
it('gets stats after parsing page', function () {
|
|
var promise = page.getOperatorList().then(function () {
|
|
return pdfDocument.getStats();
|
|
});
|
|
var expectedStreamTypes = [];
|
|
expectedStreamTypes[StreamType.FLATE] = true;
|
|
var expectedFontTypes = [];
|
|
expectedFontTypes[FontType.TYPE1] = true;
|
|
expectedFontTypes[FontType.CIDFONTTYPE2] = true;
|
|
|
|
waitsForPromiseResolved(promise, function (stats) {
|
|
expect(stats).toEqual({ streamTypes: expectedStreamTypes,
|
|
fontTypes: expectedFontTypes });
|
|
});
|
|
});
|
|
});
|
|
});
|