akira
/
pdfjs-dist
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Generic build of PDF.js library.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8599 Commits
1 Branch
1804 Tags
126 MiB
 
 
Tree: e9a1a47d28
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e9a1a47d28'
${ noResults }
pdfjs-dist/test/unit/api_spec.js

690 lines
25 KiB
Raw Blame History

/* globals PDFJS, expect, it, describe, Promise, combineUrl, waitsFor,
InvalidPDFException, MissingPDFException, StreamType, FontType,
PDFDocumentProxy, PasswordException, PasswordResponses,
PDFPageProxy, createPromiseCapability, beforeEach, afterEach */
'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(error).toEqual('the promise should not have been rejected');
});
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);
loadingTask.destroy();
});
});
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._worker.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 loadingTask = PDFJS.getDocument(typedArrayPdf);
waitsForPromiseResolved(loadingTask.promise, function(data) {
expect(data instanceof PDFDocumentProxy).toEqual(true);
loadingTask.destroy();
});
});
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 loadingTask = PDFJS.getDocument(url);
waitsForPromiseRejected(loadingTask.promise, function (error) {
expect(error instanceof InvalidPDFException).toEqual(true);
loadingTask.destroy();
});
});
it('creates pdf doc from non-existent URL', function() {
var nonExistentUrl = combineUrl(window.location.href,
'../pdfs/non-existent.pdf');
var loadingTask = PDFJS.getDocument(nonExistentUrl);
waitsForPromiseRejected(loadingTask.promise, function(error) {
expect(error instanceof MissingPDFException).toEqual(true);
loadingTask.destroy();
});
});
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);
loadingTask.destroy();
});
});
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 passwordNeededLoadingTask = PDFJS.getDocument({
url: url, password: '',
});
waitsForPromiseRejected(passwordNeededLoadingTask.promise,
function (data) {
expect(data instanceof PasswordException).toEqual(true);
expect(data.code).toEqual(PasswordResponses.NEED_PASSWORD);
passwordNeededLoadingTask.destroy();
});
var passwordIncorrectLoadingTask = PDFJS.getDocument({
url: url, password: 'qwerty',
});
waitsForPromiseRejected(passwordIncorrectLoadingTask.promise,
function (data) {
expect(data instanceof PasswordException).toEqual(true);
expect(data.code).toEqual(PasswordResponses.INCORRECT_PASSWORD);
passwordIncorrectLoadingTask.destroy();
});
var passwordAcceptedLoadingTask = PDFJS.getDocument({
url: url, password: 'asdfasdf',
});
waitsForPromiseResolved(passwordAcceptedLoadingTask.promise,
function (data) {
expect(data instanceof PDFDocumentProxy).toEqual(true);
passwordAcceptedLoadingTask.destroy();
});
});
});
});
describe('PDFWorker', function() {
it('worker created or destroyed', function () {
var worker = new PDFJS.PDFWorker('test1');
waitsForPromiseResolved(worker.promise, function () {
expect(worker.name).toEqual('test1');
expect(!!worker.port).toEqual(true);
expect(worker.destroyed).toEqual(false);
expect(!!worker._webWorker).toEqual(true);
expect(worker.port === worker._webWorker).toEqual(true);
worker.destroy();
expect(!!worker.port).toEqual(false);
expect(worker.destroyed).toEqual(true);
});
});
it('worker created or destroyed by getDocument', function () {
var loadingTask = PDFJS.getDocument(basicApiUrl);
var worker;
waitsForPromiseResolved(loadingTask.promise, function () {
worker = loadingTask._worker;
expect(!!worker).toEqual(true);
});
var destroyPromise = loadingTask.promise.then(function () {
return loadingTask.destroy();
});
waitsForPromiseResolved(destroyPromise, function () {
var destroyedWorker = loadingTask._worker;
expect(!!destroyedWorker).toEqual(false);
expect(worker.destroyed).toEqual(true);
});
});
it('worker created and can be used in getDocument', function () {
var worker = new PDFJS.PDFWorker('test1');
var loadingTask = PDFJS.getDocument({url: basicApiUrl, worker: worker});
waitsForPromiseResolved(loadingTask.promise, function () {
var docWorker = loadingTask._worker;
expect(!!docWorker).toEqual(false);
// checking is the same port is used in the MessageHandler
var messageHandlerPort = loadingTask._transport.messageHandler.comObj;
expect(messageHandlerPort === worker.port).toEqual(true);
});
var destroyPromise = loadingTask.promise.then(function () {
return loadingTask.destroy();
});
waitsForPromiseResolved(destroyPromise, function () {
expect(worker.destroyed).toEqual(false);
worker.destroy();
});
});
it('creates more than one worker', function () {
var worker1 = new PDFJS.PDFWorker('test1');
var worker2 = new PDFJS.PDFWorker('test2');
var worker3 = new PDFJS.PDFWorker('test3');
var ready = Promise.all([worker1.promise, worker2.promise,
worker3.promise]);
waitsForPromiseResolved(ready, function () {
expect(worker1.port !== worker2.port &&
worker1.port !== worker3.port &&
worker2.port !== worker3.port).toEqual(true);
worker1.destroy();
worker2.destroy();
worker3.destroy();
});
});
});
describe('PDFDocument', function() {
var loadingTask;
var doc;
beforeEach(function() {
loadingTask = PDFJS.getDocument(basicApiUrl);
waitsForPromiseResolved(loadingTask.promise, function(data) {
doc = data;
});
});
afterEach(function() {
loadingTask.destroy();
});
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 non-existent page labels', function () {
var promise = doc.getPageLabels();
waitsForPromiseResolved(promise, function (data) {
expect(data).toEqual(null);
});
});
it('gets page labels', function () {
// PageLabels with Roman/Arabic numerals.
var url0 = combineUrl(window.location.href, '../pdfs/bug793632.pdf');
var loadingTask0 = PDFJS.getDocument(url0);
var promise0 = loadingTask0.promise.then(function (pdfDoc) {
return pdfDoc.getPageLabels();
});
// PageLabels with only a label prefix.
var url1 = combineUrl(window.location.href, '../pdfs/issue1453.pdf');
var loadingTask1 = PDFJS.getDocument(url1);
var promise1 = loadingTask1.promise.then(function (pdfDoc) {
return pdfDoc.getPageLabels();
});
// PageLabels identical to standard page numbering.
var url2 = combineUrl(window.location.href, '../pdfs/rotation.pdf');
var loadingTask2 = PDFJS.getDocument(url2);
var promise2 = loadingTask2.promise.then(function (pdfDoc) {
return pdfDoc.getPageLabels();
});
waitsForPromiseResolved(Promise.all([promise0, promise1, promise2]),
function (pageLabels) {
expect(pageLabels[0]).toEqual(['i', 'ii', 'iii', '1']);
expect(pageLabels[1]).toEqual(['Front Page1']);
expect(pageLabels[2]).toEqual(['1', '2']);
loadingTask0.destroy();
loadingTask1.destroy();
loadingTask2.destroy();
});
});
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 loadingTask = PDFJS.getDocument(pdfUrl);
var promise = loadingTask.promise.then(function(doc) {
return doc.getJavaScript();
});
waitsForPromiseResolved(promise, function (data) {
expect(data).toEqual(['print({});']);
expect(data[0]).toMatch(viewerPrintRegExp);
loadingTask.destroy();
});
});
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 loadingTask = PDFJS.getDocument(pdfUrl);
var promise = loadingTask.promise.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);
loadingTask.destroy();
});
});
it('gets outline', function() {
var promise = doc.getOutline();
waitsForPromiseResolved(promise, function(outline) {
// Two top level entries.
expect(outline instanceof Array).toEqual(true);
expect(outline.length).toEqual(2);
// Make sure some basic attributes are set.
var outlineItem = outline[1];
expect(outlineItem.title).toEqual('Chapter 1');
expect(outlineItem.dest instanceof Array).toEqual(true);
expect(outlineItem.url).toEqual(null);
expect(outlineItem.items.length).toEqual(1);
expect(outlineItem.items[0].title).toEqual('Paragraph 1.1');
});
});
it('gets outline containing a url', function() {
var pdfUrl = combineUrl(window.location.href, '../pdfs/issue3214.pdf');
var loadingTask = PDFJS.getDocument(pdfUrl);
loadingTask.promise.then(function (pdfDocument) {
pdfDocument.getOutline().then(function (outline) {
expect(outline instanceof Array).toEqual(true);
expect(outline.length).toEqual(5);
var outlineItem = outline[2];
expect(outlineItem.dest).toEqual(null);
expect(outlineItem.url).toEqual('http://google.com');
loadingTask.destroy(); // Cleanup the worker.
});
});
});
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);
loadingTask1.destroy();
loadingTask2.destroy();
});
});
});
describe('Page', function() {
var loadingTask;
var pdfDocument, page;
beforeEach(function() {
loadingTask = PDFJS.getDocument(basicApiUrl);
waitsForPromiseResolved(loadingTask.promise, function(doc) {
pdfDocument = doc;
waitsForPromiseResolved(pdfDocument.getPage(1), function(data) {
page = data;
});
});
});
afterEach(function() {
loadingTask.destroy();
});
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 defaultPromise = page.getTextContent();
var normalizeWhitespacePromise = page.getTextContent({
normalizeWhitespace: true });
var promises = [
defaultPromise,
normalizeWhitespacePromise
];
waitsForPromiseResolved(Promise.all(promises), function (data) {
expect(!!data[0].items).toEqual(true);
expect(data[0].items.length).toEqual(7);
expect(!!data[0].styles).toEqual(true);
// A simple check that ensures the two `textContent` object match.
expect(JSON.stringify(data[0])).toEqual(JSON.stringify(data[1]));
});
});
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 });
});
});
});
describe('Multiple PDFJS instances', function() {
// Regression test for https://github.com/mozilla/pdf.js/issues/6205
// A PDF using the Helvetica font.
var pdf1 = combineUrl(window.location.href, '../pdfs/tracemonkey.pdf');
// A PDF using the Times font.
var pdf2 = combineUrl(window.location.href, '../pdfs/TAMReview.pdf');
// A PDF using the Arial font.
var pdf3 = combineUrl(window.location.href, '../pdfs/issue6068.pdf');
var loadingTasks = [];
var pdfDocuments = [];
// Render the first page of the given PDF file.
// Fulfills the promise with the base64-encoded version of the PDF.
function renderPDF(filename) {
var loadingTask = PDFJS.getDocument(filename);
loadingTasks.push(loadingTask);
return loadingTask.promise
.then(function(pdf) {
pdfDocuments.push(pdf);
return pdf.getPage(1);
}).then(function(page) {
var c = document.createElement('canvas');
var v = page.getViewport(1.2);
c.width = v.width;
c.height = v.height;
return page.render({
canvasContext: c.getContext('2d'),
viewport: v,
}).then(function() {
return c.toDataURL();
});
});
}
afterEach(function() {
// Issue 6205 reported an issue with font rendering, so clear the loaded
// fonts so that we can see whether loading PDFs in parallel does not
// cause any issues with the rendered fonts.
var destroyPromises = pdfDocuments.map(function(pdfDocument) {
return pdfDocument.destroy();
});
waitsForPromiseResolved(Promise.all(destroyPromises), function() {});
// Destroy the workers.
destroyPromises = loadingTasks.map(function(loadingTask) {
return loadingTask.destroy();
});
waitsForPromiseResolved(Promise.all(destroyPromises), function() {});
});
it('should correctly render PDFs in parallel', function() {
var baseline1, baseline2, baseline3;
var promiseDone = renderPDF(pdf1).then(function(data1) {
baseline1 = data1;
return renderPDF(pdf2);
}).then(function(data2) {
baseline2 = data2;
return renderPDF(pdf3);
}).then(function(data3) {
baseline3 = data3;
return Promise.all([
renderPDF(pdf1),
renderPDF(pdf2),
renderPDF(pdf3),
]);
}).then(function(dataUrls) {
expect(dataUrls[0]).toEqual(baseline1);
expect(dataUrls[1]).toEqual(baseline2);
expect(dataUrls[2]).toEqual(baseline3);
return true;
});
waitsForPromiseResolved(promiseDone, function() {});
});
});
});