Sakurai/pdf.js
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #13246 from timvandermeij/unit-test-async-await-pt2

Browse Source 
Convert done callbacks to async/await in more unit test files
This commit is contained in:
Tim van der Meij 2021-04-16 20:24:53 +02:00 committed by GitHub
commit cba6a3f375
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 306 additions and 444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
test/unit/annotation_storage_spec.js
View File

@ -17,7 +17,7 @@ import { AnnotationStorage } from "../../src/display/annotation_storage.js";
describe("AnnotationStorage", function () { describe("AnnotationStorage", function () {
describe("GetOrDefaultValue", function () { describe("GetOrDefaultValue", function () {
it("should get and set a new value in the annotation storage", function (done) { it("should get and set a new value in the annotation storage", function () {
const annotationStorage = new AnnotationStorage(); const annotationStorage = new AnnotationStorage();
let value = annotationStorage.getValue("123A", { let value = annotationStorage.getValue("123A", {
value: "hello world", value: "hello world",
@ -34,20 +34,18 @@ describe("AnnotationStorage", function () {
value: "an other string", value: "an other string",
}).value; }).value;
expect(value).toEqual("hello world"); expect(value).toEqual("hello world");
done();
}); });
}); });
describe("SetValue", function () { describe("SetValue", function () {
it("should set a new value in the annotation storage", function (done) { it("should set a new value in the annotation storage", function () {
const annotationStorage = new AnnotationStorage(); const annotationStorage = new AnnotationStorage();
annotationStorage.setValue("123A", { value: "an other string" }); annotationStorage.setValue("123A", { value: "an other string" });
const value = annotationStorage.getAll()["123A"].value; const value = annotationStorage.getAll()["123A"].value;
expect(value).toEqual("an other string"); expect(value).toEqual("an other string");
done();
}); });
it("should call onSetModified() if value is changed", function (done) { it("should call onSetModified() if value is changed", function () {
const annotationStorage = new AnnotationStorage(); const annotationStorage = new AnnotationStorage();
let called = false; let called = false;
const callback = function () { const callback = function () {
@ -66,12 +64,11 @@ describe("AnnotationStorage", function () {
called = false; called = false;
annotationStorage.setValue("asdf", { value: "modified" }); annotationStorage.setValue("asdf", { value: "modified" });
expect(called).toBe(false); expect(called).toBe(false);
done();
}); });
}); });
describe("ResetModified", function () { describe("ResetModified", function () {
it("should call onResetModified() if set", function (done) { it("should call onResetModified() if set", function () {
const annotationStorage = new AnnotationStorage(); const annotationStorage = new AnnotationStorage();
let called = false; let called = false;
const callback = function () { const callback = function () {
@ -92,7 +89,6 @@ describe("AnnotationStorage", function () {
annotationStorage.setValue("asdf", { value: "modified" }); annotationStorage.setValue("asdf", { value: "modified" });
annotationStorage.resetModified(); annotationStorage.resetModified();
expect(called).toBe(true); expect(called).toBe(true);
done();
}); });
}); });
}); });

349
test/unit/cmap_spec.js
View File

@ -40,305 +40,218 @@ describe("cmap", function () {
fetchBuiltInCMap = null; fetchBuiltInCMap = null;
}); });
it("parses beginbfchar", function (done) { it("parses beginbfchar", async function () {
// prettier-ignore // prettier-ignore
const str = "2 beginbfchar\n" + const str = "2 beginbfchar\n" +
"<03> <00>\n" + "<03> <00>\n" +
"<04> <01>\n" + "<04> <01>\n" +
"endbfchar\n"; "endbfchar\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise expect(cmap.lookup(0x03)).toEqual(String.fromCharCode(0x00));
.then(function (cmap) { expect(cmap.lookup(0x04)).toEqual(String.fromCharCode(0x01));
expect(cmap.lookup(0x03)).toEqual(String.fromCharCode(0x00)); expect(cmap.lookup(0x05)).toBeUndefined();
expect(cmap.lookup(0x04)).toEqual(String.fromCharCode(0x01));
expect(cmap.lookup(0x05)).toBeUndefined();
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("parses beginbfrange with range", function (done) {
it("parses beginbfrange with range", async function () {
// prettier-ignore // prettier-ignore
const str = "1 beginbfrange\n" + const str = "1 beginbfrange\n" +
"<06> <0B> 0\n" + "<06> <0B> 0\n" +
"endbfrange\n"; "endbfrange\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise expect(cmap.lookup(0x05)).toBeUndefined();
.then(function (cmap) { expect(cmap.lookup(0x06)).toEqual(String.fromCharCode(0x00));
expect(cmap.lookup(0x05)).toBeUndefined(); expect(cmap.lookup(0x0b)).toEqual(String.fromCharCode(0x05));
expect(cmap.lookup(0x06)).toEqual(String.fromCharCode(0x00)); expect(cmap.lookup(0x0c)).toBeUndefined();
expect(cmap.lookup(0x0b)).toEqual(String.fromCharCode(0x05));
expect(cmap.lookup(0x0c)).toBeUndefined();
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("parses beginbfrange with array", function (done) {
it("parses beginbfrange with array", async function () {
// prettier-ignore // prettier-ignore
const str = "1 beginbfrange\n" + const str = "1 beginbfrange\n" +
"<0D> <12> [ 0 1 2 3 4 5 ]\n" + "<0D> <12> [ 0 1 2 3 4 5 ]\n" +
"endbfrange\n"; "endbfrange\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise expect(cmap.lookup(0x0c)).toBeUndefined();
.then(function (cmap) { expect(cmap.lookup(0x0d)).toEqual(0x00);
expect(cmap.lookup(0x0c)).toBeUndefined(); expect(cmap.lookup(0x12)).toEqual(0x05);
expect(cmap.lookup(0x0d)).toEqual(0x00); expect(cmap.lookup(0x13)).toBeUndefined();
expect(cmap.lookup(0x12)).toEqual(0x05);
expect(cmap.lookup(0x13)).toBeUndefined();
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("parses begincidchar", function (done) {
it("parses begincidchar", async function () {
// prettier-ignore // prettier-ignore
const str = "1 begincidchar\n" + const str = "1 begincidchar\n" +
"<14> 0\n" + "<14> 0\n" +
"endcidchar\n"; "endcidchar\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise expect(cmap.lookup(0x14)).toEqual(0x00);
.then(function (cmap) { expect(cmap.lookup(0x15)).toBeUndefined();
expect(cmap.lookup(0x14)).toEqual(0x00);
expect(cmap.lookup(0x15)).toBeUndefined();
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("parses begincidrange", function (done) {
it("parses begincidrange", async function () {
// prettier-ignore // prettier-ignore
const str = "1 begincidrange\n" + const str = "1 begincidrange\n" +
"<0016> <001B> 0\n" + "<0016> <001B> 0\n" +
"endcidrange\n"; "endcidrange\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise expect(cmap.lookup(0x15)).toBeUndefined();
.then(function (cmap) { expect(cmap.lookup(0x16)).toEqual(0x00);
expect(cmap.lookup(0x15)).toBeUndefined(); expect(cmap.lookup(0x1b)).toEqual(0x05);
expect(cmap.lookup(0x16)).toEqual(0x00); expect(cmap.lookup(0x1c)).toBeUndefined();
expect(cmap.lookup(0x1b)).toEqual(0x05);
expect(cmap.lookup(0x1c)).toBeUndefined();
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("decodes codespace ranges", function (done) {
it("decodes codespace ranges", async function () {
// prettier-ignore // prettier-ignore
const str = "1 begincodespacerange\n" + const str = "1 begincodespacerange\n" +
"<01> <02>\n" + "<01> <02>\n" +
"<00000003> <00000004>\n" + "<00000003> <00000004>\n" +
"endcodespacerange\n"; "endcodespacerange\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise const c = {};
.then(function (cmap) { cmap.readCharCode(String.fromCharCode(1), 0, c);
const c = {}; expect(c.charcode).toEqual(1);
cmap.readCharCode(String.fromCharCode(1), 0, c); expect(c.length).toEqual(1);
expect(c.charcode).toEqual(1); cmap.readCharCode(String.fromCharCode(0, 0, 0, 3), 0, c);
expect(c.length).toEqual(1); expect(c.charcode).toEqual(3);
cmap.readCharCode(String.fromCharCode(0, 0, 0, 3), 0, c); expect(c.length).toEqual(4);
expect(c.charcode).toEqual(3);
expect(c.length).toEqual(4);
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("decodes 4 byte codespace ranges", function (done) {
it("decodes 4 byte codespace ranges", async function () {
// prettier-ignore // prettier-ignore
const str = "1 begincodespacerange\n" + const str = "1 begincodespacerange\n" +
"<8EA1A1A1> <8EA1FEFE>\n" + "<8EA1A1A1> <8EA1FEFE>\n" +
"endcodespacerange\n"; "endcodespacerange\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise const c = {};
.then(function (cmap) { cmap.readCharCode(String.fromCharCode(0x8e, 0xa1, 0xa1, 0xa1), 0, c);
const c = {}; expect(c.charcode).toEqual(0x8ea1a1a1);
cmap.readCharCode(String.fromCharCode(0x8e, 0xa1, 0xa1, 0xa1), 0, c); expect(c.length).toEqual(4);
expect(c.charcode).toEqual(0x8ea1a1a1);
expect(c.length).toEqual(4);
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("read usecmap", function (done) {
it("read usecmap", async function () {
const str = "/Adobe-Japan1-1 usecmap\n"; const str = "/Adobe-Japan1-1 usecmap\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ const cmap = await CMapFactory.create({
encoding: stream, encoding: stream,
fetchBuiltInCMap, fetchBuiltInCMap,
useCMap: null, useCMap: null,
}); });
cmapPromise expect(cmap instanceof CMap).toEqual(true);
.then(function (cmap) { expect(cmap.useCMap).not.toBeNull();
expect(cmap instanceof CMap).toEqual(true); expect(cmap.builtInCMap).toBeFalsy();
expect(cmap.useCMap).not.toBeNull(); expect(cmap.length).toEqual(0x20a7);
expect(cmap.builtInCMap).toBeFalsy(); expect(cmap.isIdentityCMap).toEqual(false);
expect(cmap.length).toEqual(0x20a7);
expect(cmap.isIdentityCMap).toEqual(false);
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("parses cmapname", function (done) {
it("parses cmapname", async function () {
const str = "/CMapName /Identity-H def\n"; const str = "/CMapName /Identity-H def\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise expect(cmap.name).toEqual("Identity-H");
.then(function (cmap) {
expect(cmap.name).toEqual("Identity-H");
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("parses wmode", function (done) {
it("parses wmode", async function () {
const str = "/WMode 1 def\n"; const str = "/WMode 1 def\n";
const stream = new StringStream(str); const stream = new StringStream(str);
const cmapPromise = CMapFactory.create({ encoding: stream }); const cmap = await CMapFactory.create({ encoding: stream });
cmapPromise expect(cmap.vertical).toEqual(true);
.then(function (cmap) {
expect(cmap.vertical).toEqual(true);
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("loads built in cmap", function (done) {
const cmapPromise = CMapFactory.create({ it("loads built in cmap", async function () {
const cmap = await CMapFactory.create({
encoding: Name.get("Adobe-Japan1-1"), encoding: Name.get("Adobe-Japan1-1"),
fetchBuiltInCMap, fetchBuiltInCMap,
useCMap: null, useCMap: null,
}); });
cmapPromise expect(cmap instanceof CMap).toEqual(true);
.then(function (cmap) { expect(cmap.useCMap).toBeNull();
expect(cmap instanceof CMap).toEqual(true); expect(cmap.builtInCMap).toBeTruthy();
expect(cmap.useCMap).toBeNull(); expect(cmap.length).toEqual(0x20a7);
expect(cmap.builtInCMap).toBeTruthy(); expect(cmap.isIdentityCMap).toEqual(false);
expect(cmap.length).toEqual(0x20a7);
expect(cmap.isIdentityCMap).toEqual(false);
done();
})
.catch(function (reason) {
done.fail(reason);
});
}); });
it("loads built in identity cmap", function (done) {
const cmapPromise = CMapFactory.create({ it("loads built in identity cmap", async function () {
const cmap = await CMapFactory.create({
encoding: Name.get("Identity-H"), encoding: Name.get("Identity-H"),
fetchBuiltInCMap, fetchBuiltInCMap,
useCMap: null, useCMap: null,
}); });
cmapPromise expect(cmap instanceof IdentityCMap).toEqual(true);
.then(function (cmap) { expect(cmap.vertical).toEqual(false);
expect(cmap instanceof IdentityCMap).toEqual(true); expect(cmap.length).toEqual(0x10000);
expect(cmap.vertical).toEqual(false); expect(function () {
expect(cmap.length).toEqual(0x10000); return cmap.isIdentityCMap;
expect(function () { }).toThrow(new Error("should not access .isIdentityCMap"));
return cmap.isIdentityCMap; });
}).toThrow(new Error("should not access .isIdentityCMap"));
done(); it("attempts to load a non-existent built-in CMap", async function () {
}) try {
.catch(function (reason) { await CMapFactory.create({
done.fail(reason); encoding: Name.get("null"),
fetchBuiltInCMap,
useCMap: null,
}); });
// Shouldn't get here.
expect(false).toEqual(true);
} catch (reason) {
expect(reason instanceof Error).toEqual(true);
expect(reason.message).toEqual("Unknown CMap name: null");
}
}); });
it("attempts to load a non-existent built-in CMap", function (done) { it("attempts to load a built-in CMap without the necessary API parameters", async function () {
const cmapPromise = CMapFactory.create({
encoding: Name.get("null"),
fetchBuiltInCMap,
useCMap: null,
});
cmapPromise.then(
function () {
done.fail("No CMap should be loaded");
},
function (reason) {
expect(reason instanceof Error).toEqual(true);
expect(reason.message).toEqual("Unknown CMap name: null");
done();
}
);
});
it("attempts to load a built-in CMap without the necessary API parameters", function (done) {
function tmpFetchBuiltInCMap(name) { function tmpFetchBuiltInCMap(name) {
const CMapReaderFactory = new DefaultCMapReaderFactory({}); const CMapReaderFactory = new DefaultCMapReaderFactory({});
return CMapReaderFactory.fetch({ name });
return CMapReaderFactory.fetch({
name,
});
} }
const cmapPromise = CMapFactory.create({ try {
encoding: Name.get("Adobe-Japan1-1"), await CMapFactory.create({
fetchBuiltInCMap: tmpFetchBuiltInCMap, encoding: Name.get("Adobe-Japan1-1"),
useCMap: null, fetchBuiltInCMap: tmpFetchBuiltInCMap,
}); useCMap: null,
cmapPromise.then( });
function () {
done.fail("No CMap should be loaded"); // Shouldn't get here.
}, expect(false).toEqual(true);
function (reason) { } catch (reason) {
expect(reason instanceof Error).toEqual(true); expect(reason instanceof Error).toEqual(true);
expect(reason.message).toEqual( expect(reason.message).toEqual(
'The CMap "baseUrl" parameter must be specified, ensure that ' + 'The CMap "baseUrl" parameter must be specified, ensure that ' +
'the "cMapUrl" and "cMapPacked" API parameters are provided.' 'the "cMapUrl" and "cMapPacked" API parameters are provided.'
); );
done(); }
}
);
}); });
it("attempts to load a built-in CMap with inconsistent API parameters", function (done) { it("attempts to load a built-in CMap with inconsistent API parameters", async function () {
function tmpFetchBuiltInCMap(name) { function tmpFetchBuiltInCMap(name) {
const CMapReaderFactory = new DefaultCMapReaderFactory({ const CMapReaderFactory = new DefaultCMapReaderFactory({
baseUrl: CMAP_PARAMS.cMapUrl, baseUrl: CMAP_PARAMS.cMapUrl,
isCompressed: false, isCompressed: false,
}); });
return CMapReaderFactory.fetch({ name });
return CMapReaderFactory.fetch({
name,
});
} }
const cmapPromise = CMapFactory.create({ try {
encoding: Name.get("Adobe-Japan1-1"), await CMapFactory.create({
fetchBuiltInCMap: tmpFetchBuiltInCMap, encoding: Name.get("Adobe-Japan1-1"),
useCMap: null, fetchBuiltInCMap: tmpFetchBuiltInCMap,
}); useCMap: null,
cmapPromise.then( });
function () {
done.fail("No CMap should be loaded"); // Shouldn't get here.
}, expect(false).toEqual(true);
function (reason) { } catch (reason) {
expect(reason instanceof Error).toEqual(true); expect(reason instanceof Error).toEqual(true);
const message = reason.message; const message = reason.message;
expect(message.startsWith("Unable to load CMap at: ")).toEqual(true); expect(message.startsWith("Unable to load CMap at: ")).toEqual(true);
expect(message.endsWith("/external/bcmaps/Adobe-Japan1-1")).toEqual( expect(message.endsWith("/external/bcmaps/Adobe-Japan1-1")).toEqual(true);
true }
);
done();
}
);
}); });
}); });

85
test/unit/crypto_spec.js
View File

@ -588,43 +588,40 @@ describe("CipherTransformFactory", function () {
return dict; return dict;
} }
function ensurePasswordCorrect(done, dict, fileId, password) { function ensurePasswordCorrect(dict, fileId, password) {
try { try {
const factory = new CipherTransformFactory(dict, fileId, password); const factory = new CipherTransformFactory(dict, fileId, password);
expect("createCipherTransform" in factory).toEqual(true); expect("createCipherTransform" in factory).toEqual(true);
} catch (ex) { } catch (ex) {
done.fail("Password should be accepted: " + ex); // Shouldn't get here.
return; expect(false).toEqual(true);
} }
done();
} }
function ensurePasswordNeeded(done, dict, fileId, password) { function ensurePasswordNeeded(dict, fileId, password) {
try { try {
// eslint-disable-next-line no-new // eslint-disable-next-line no-new
new CipherTransformFactory(dict, fileId, password); new CipherTransformFactory(dict, fileId, password);
// Shouldn't get here.
expect(false).toEqual(true);
} catch (ex) { } catch (ex) {
expect(ex instanceof PasswordException).toEqual(true); expect(ex instanceof PasswordException).toEqual(true);
expect(ex.code).toEqual(PasswordResponses.NEED_PASSWORD); expect(ex.code).toEqual(PasswordResponses.NEED_PASSWORD);
done();
return;
} }
done.fail("Password should be rejected.");
} }
function ensurePasswordIncorrect(done, dict, fileId, password) { function ensurePasswordIncorrect(dict, fileId, password) {
try { try {
// eslint-disable-next-line no-new // eslint-disable-next-line no-new
new CipherTransformFactory(dict, fileId, password); new CipherTransformFactory(dict, fileId, password);
// Shouldn't get here.
expect(false).toEqual(true);
} catch (ex) { } catch (ex) {
expect(ex instanceof PasswordException).toEqual(true); expect(ex instanceof PasswordException).toEqual(true);
expect(ex.code).toEqual(PasswordResponses.INCORRECT_PASSWORD); expect(ex.code).toEqual(PasswordResponses.INCORRECT_PASSWORD);
done();
return;
} }
done.fail("Password should be rejected.");
} }
function ensureEncryptDecryptIsIdentity(dict, fileId, password, string) { function ensureEncryptDecryptIsIdentity(dict, fileId, password, string) {
@ -784,55 +781,55 @@ describe("CipherTransformFactory", function () {
describe("#ctor", function () { describe("#ctor", function () {
describe("AES256 Revision 5", function () { describe("AES256 Revision 5", function () {
it("should accept user password", function (done) { it("should accept user password", function () {
ensurePasswordCorrect(done, aes256Dict, fileId1, "user"); ensurePasswordCorrect(aes256Dict, fileId1, "user");
}); });
it("should accept owner password", function (done) { it("should accept owner password", function () {
ensurePasswordCorrect(done, aes256Dict, fileId1, "owner"); ensurePasswordCorrect(aes256Dict, fileId1, "owner");
}); });
it("should not accept blank password", function (done) { it("should not accept blank password", function () {
ensurePasswordNeeded(done, aes256Dict, fileId1); ensurePasswordNeeded(aes256Dict, fileId1);
}); });
it("should not accept wrong password", function (done) { it("should not accept wrong password", function () {
ensurePasswordIncorrect(done, aes256Dict, fileId1, "wrong"); ensurePasswordIncorrect(aes256Dict, fileId1, "wrong");
}); });
it("should accept blank password", function (done) { it("should accept blank password", function () {
ensurePasswordCorrect(done, aes256BlankDict, fileId1); ensurePasswordCorrect(aes256BlankDict, fileId1);
}); });
}); });
describe("AES256 Revision 6", function () { describe("AES256 Revision 6", function () {
it("should accept user password", function (done) { it("should accept user password", function () {
ensurePasswordCorrect(done, aes256IsoDict, fileId1, "user"); ensurePasswordCorrect(aes256IsoDict, fileId1, "user");
}); });
it("should accept owner password", function (done) { it("should accept owner password", function () {
ensurePasswordCorrect(done, aes256IsoDict, fileId1, "owner"); ensurePasswordCorrect(aes256IsoDict, fileId1, "owner");
}); });
it("should not accept blank password", function (done) { it("should not accept blank password", function () {
ensurePasswordNeeded(done, aes256IsoDict, fileId1); ensurePasswordNeeded(aes256IsoDict, fileId1);
}); });
it("should not accept wrong password", function (done) { it("should not accept wrong password", function () {
ensurePasswordIncorrect(done, aes256IsoDict, fileId1, "wrong"); ensurePasswordIncorrect(aes256IsoDict, fileId1, "wrong");
}); });
it("should accept blank password", function (done) { it("should accept blank password", function () {
ensurePasswordCorrect(done, aes256IsoBlankDict, fileId1); ensurePasswordCorrect(aes256IsoBlankDict, fileId1);
}); });
}); });
it("should accept user password", function (done) { it("should accept user password", function () {
ensurePasswordCorrect(done, dict1, fileId1, "123456"); ensurePasswordCorrect(dict1, fileId1, "123456");
}); });
it("should accept owner password", function (done) { it("should accept owner password", function () {
ensurePasswordCorrect(done, dict1, fileId1, "654321"); ensurePasswordCorrect(dict1, fileId1, "654321");
}); });
it("should not accept blank password", function (done) { it("should not accept blank password", function () {
ensurePasswordNeeded(done, dict1, fileId1); ensurePasswordNeeded(dict1, fileId1);
}); });
it("should not accept wrong password", function (done) { it("should not accept wrong password", function () {
ensurePasswordIncorrect(done, dict1, fileId1, "wrong"); ensurePasswordIncorrect(dict1, fileId1, "wrong");
}); });
it("should accept blank password", function (done) { it("should accept blank password", function () {
ensurePasswordCorrect(done, dict2, fileId2); ensurePasswordCorrect(dict2, fileId2);
}); });
}); });

66
test/unit/display_svg_spec.js
View File

@ -59,17 +59,15 @@ function withZlib(isZlibRequired, callback) {
describe("SVGGraphics", function () { describe("SVGGraphics", function () {
let loadingTask; let loadingTask;
let page; let page;
beforeAll(function (done) {
beforeAll(async function () {
loadingTask = getDocument(buildGetDocumentParams("xobject-image.pdf")); loadingTask = getDocument(buildGetDocumentParams("xobject-image.pdf"));
loadingTask.promise.then(function (doc) { const doc = await loadingTask.promise;
doc.getPage(1).then(function (firstPage) { page = await doc.getPage(1);
page = firstPage;
done();
});
});
}); });
afterAll(function (done) {
loadingTask.destroy().then(done); afterAll(async function () {
await loadingTask.destroy();
}); });
describe("paintImageXObject", function () { describe("paintImageXObject", function () {
@ -129,39 +127,33 @@ describe("SVGGraphics", function () {
} }
}); });
it("should produce a reasonably small svg:image", function (done) { it("should produce a reasonably small svg:image", async function () {
if (!isNodeJS) { if (!isNodeJS) {
pending("zlib.deflateSync is not supported in non-Node environments."); pending("zlib.deflateSync is not supported in non-Node environments.");
} }
withZlib(true, getSVGImage) const svgImg = await withZlib(true, getSVGImage);
.then(function (svgImg) { expect(svgImg.nodeName).toBe("svg:image");
expect(svgImg.nodeName).toBe("svg:image"); expect(svgImg.getAttributeNS(null, "width")).toBe("200px");
expect(svgImg.getAttributeNS(null, "width")).toBe("200px"); expect(svgImg.getAttributeNS(null, "height")).toBe("100px");
expect(svgImg.getAttributeNS(null, "height")).toBe("100px"); const imgUrl = svgImg.getAttributeNS(XLINK_NS, "href");
const imgUrl = svgImg.getAttributeNS(XLINK_NS, "href"); // forceDataSchema = true, so the generated URL should be a data:-URL.
// forceDataSchema = true, so the generated URL should be a data:-URL. expect(imgUrl).toMatch(/^data:image\/png;base64,/);
expect(imgUrl).toMatch(/^data:image\/png;base64,/); // Test whether the generated image has a reasonable file size.
// Test whether the generated image has a reasonable file size. // I obtained a data URL of size 366 with Node 8.1.3 and zlib 1.2.11.
// I obtained a data URL of size 366 with Node 8.1.3 and zlib 1.2.11. // Without zlib (uncompressed), the size of the data URL was excessive
// Without zlib (uncompressed), the size of the data URL was excessive // (80246).
// (80246). expect(imgUrl.length).toBeLessThan(367);
expect(imgUrl.length).toBeLessThan(367);
})
.then(done, done.fail);
}); });
it("should be able to produce a svg:image without zlib", function (done) { it("should be able to produce a svg:image without zlib", async function () {
withZlib(false, getSVGImage) const svgImg = await withZlib(false, getSVGImage);
.then(function (svgImg) { expect(svgImg.nodeName).toBe("svg:image");
expect(svgImg.nodeName).toBe("svg:image"); expect(svgImg.getAttributeNS(null, "width")).toBe("200px");
expect(svgImg.getAttributeNS(null, "width")).toBe("200px"); expect(svgImg.getAttributeNS(null, "height")).toBe("100px");
expect(svgImg.getAttributeNS(null, "height")).toBe("100px"); const imgUrl = svgImg.getAttributeNS(XLINK_NS, "href");
const imgUrl = svgImg.getAttributeNS(XLINK_NS, "href"); expect(imgUrl).toMatch(/^data:image\/png;base64,/);
expect(imgUrl).toMatch(/^data:image\/png;base64,/); // The size of our naively generated PNG file is excessive :(
// The size of our naively generated PNG file is excessive :( expect(imgUrl.length).toBe(80246);
expect(imgUrl.length).toBe(80246);
})
.then(done, done.fail);
}); });
}); });
}); });

238
test/unit/message_handler_spec.js
View File

@ -39,7 +39,7 @@ describe("message_handler", function () {
expect(typeof readable.getReader).toEqual("function"); expect(typeof readable.getReader).toEqual("function");
}); });
it("should read using a reader", function (done) { it("should read using a reader", async function () {
let log = ""; let log = "";
const port = new LoopbackPort(); const port = new LoopbackPort();
const messageHandler1 = new MessageHandler("main", "worker", port); const messageHandler1 = new MessageHandler("main", "worker", port);
@ -71,29 +71,23 @@ describe("message_handler", function () {
}, },
} }
); );
const reader = readable.getReader(); const reader = readable.getReader();
sleep(10) await sleep(10);
.then(() => { expect(log).toEqual("");
expect(log).toEqual("");
return reader.read(); let result = await reader.read();
}) expect(log).toEqual("p");
.then(result => { expect(result.value).toEqual("hi");
expect(log).toEqual("p"); expect(result.done).toEqual(false);
expect(result.value).toEqual("hi");
expect(result.done).toEqual(false); await sleep(10);
return sleep(10); result = await reader.read();
}) expect(result.value).toEqual(undefined);
.then(() => { expect(result.done).toEqual(true);
return reader.read();
})
.then(result => {
expect(result.value).toEqual(undefined);
expect(result.done).toEqual(true);
done();
});
}); });
it("should not read any data when cancelled", function (done) { it("should not read any data when cancelled", async function () {
let log = ""; let log = "";
const port = new LoopbackPort(); const port = new LoopbackPort();
const messageHandler2 = new MessageHandler("worker", "main", port); const messageHandler2 = new MessageHandler("worker", "main", port);
@ -139,27 +133,21 @@ describe("message_handler", function () {
); );
const reader = readable.getReader(); const reader = readable.getReader();
sleep(10) await sleep(10);
.then(() => { expect(log).toEqual("01");
expect(log).toEqual("01");
return reader.read(); const result = await reader.read();
}) expect(result.value).toEqual([1, 2, 3, 4]);
.then(result => { expect(result.done).toEqual(false);
expect(result.value).toEqual([1, 2, 3, 4]);
expect(result.done).toEqual(false); await sleep(10);
return sleep(10); expect(log).toEqual("01p2");
})
.then(() => { await reader.cancel(new AbortException("reader cancelled."));
expect(log).toEqual("01p2"); expect(log).toEqual("01p2c4");
return reader.cancel(new AbortException("reader cancelled."));
})
.then(() => {
expect(log).toEqual("01p2c4");
done();
});
}); });
it("should not read when errored", function (done) { it("should not read when errored", async function () {
let log = ""; let log = "";
const port = new LoopbackPort(); const port = new LoopbackPort();
const messageHandler2 = new MessageHandler("worker", "main", port); const messageHandler2 = new MessageHandler("worker", "main", port);
@ -195,26 +183,26 @@ describe("message_handler", function () {
); );
const reader = readable.getReader(); const reader = readable.getReader();
await sleep(10);
expect(log).toEqual("01");
sleep(10) const result = await reader.read();
.then(() => { expect(result.value).toEqual([1, 2, 3, 4]);
expect(log).toEqual("01"); expect(result.done).toEqual(false);
return reader.read();
}) try {
.then(result => { await reader.read();
expect(result.value).toEqual([1, 2, 3, 4]);
expect(result.done).toEqual(false); // Shouldn't get here.
return reader.read(); expect(false).toEqual(true);
}) } catch (reason) {
.catch(reason => { expect(log).toEqual("01pe");
expect(log).toEqual("01pe"); expect(reason instanceof UnknownErrorException).toEqual(true);
expect(reason instanceof UnknownErrorException).toEqual(true); expect(reason.message).toEqual("should not read when errored");
expect(reason.message).toEqual("should not read when errored"); }
done();
});
}); });
it("should read data with blocking promise", function (done) { it("should read data with blocking promise", async function () {
let log = ""; let log = "";
const port = new LoopbackPort(); const port = new LoopbackPort();
const messageHandler2 = new MessageHandler("worker", "main", port); const messageHandler2 = new MessageHandler("worker", "main", port);
@ -257,40 +245,32 @@ describe("message_handler", function () {
const reader = readable.getReader(); const reader = readable.getReader();
// Sleep for 10ms, so that read() is not unblocking the ready promise. // Sleep for 10ms, so that read() is not unblocking the ready promise.
// Chain all read() to stream in sequence. // Chain all read() to stream in sequence.
sleep(10) await sleep(10);
.then(() => { expect(log).toEqual("01");
expect(log).toEqual("01");
return reader.read(); let result = await reader.read();
}) expect(result.value).toEqual([1, 2, 3, 4]);
.then(result => { expect(result.done).toEqual(false);
expect(result.value).toEqual([1, 2, 3, 4]);
expect(result.done).toEqual(false); await sleep(10);
return sleep(10); expect(log).toEqual("01p2");
})
.then(() => { result = await reader.read();
expect(log).toEqual("01p2"); expect(result.value).toEqual([5, 6, 7, 8]);
return reader.read(); expect(result.done).toEqual(false);
})
.then(result => { await sleep(10);
expect(result.value).toEqual([5, 6, 7, 8]); expect(log).toEqual("01p2p");
expect(result.done).toEqual(false);
return sleep(10); result = await reader.read();
}) expect(result.value).toEqual(undefined);
.then(() => { expect(result.done).toEqual(true);
expect(log).toEqual("01p2p");
return reader.read();
})
.then(result => {
expect(result.value).toEqual(undefined);
expect(result.done).toEqual(true);
done();
});
}); });
it( it(
"should read data with blocking promise and buffer whole data" + "should read data with blocking promise and buffer whole data" +
" into stream", " into stream",
function (done) { async function () {
let log = ""; let log = "";
const port = new LoopbackPort(); const port = new LoopbackPort();
const messageHandler2 = new MessageHandler("worker", "main", port); const messageHandler2 = new MessageHandler("worker", "main", port);
@ -332,39 +312,30 @@ describe("message_handler", function () {
); );
const reader = readable.getReader(); const reader = readable.getReader();
await sleep(10);
expect(log).toEqual("012");
sleep(10) let result = await reader.read();
.then(() => { expect(result.value).toEqual([1, 2, 3, 4]);
expect(log).toEqual("012"); expect(result.done).toEqual(false);
return reader.read();
}) await sleep(10);
.then(result => { expect(log).toEqual("012p");
expect(result.value).toEqual([1, 2, 3, 4]);
expect(result.done).toEqual(false); result = await reader.read();
return sleep(10); expect(result.value).toEqual([5, 6, 7, 8]);
}) expect(result.done).toEqual(false);
.then(() => {
expect(log).toEqual("012p"); await sleep(10);
return reader.read(); expect(log).toEqual("012p");
})
.then(result => { result = await reader.read();
expect(result.value).toEqual([5, 6, 7, 8]); expect(result.value).toEqual(undefined);
expect(result.done).toEqual(false); expect(result.done).toEqual(true);
return sleep(10);
})
.then(() => {
expect(log).toEqual("012p");
return reader.read();
})
.then(result => {
expect(result.value).toEqual(undefined);
expect(result.done).toEqual(true);
done();
});
} }
); );
it("should ignore any pull after close is called", function (done) { it("should ignore any pull after close is called", async function () {
let log = ""; let log = "";
const port = new LoopbackPort(); const port = new LoopbackPort();
const capability = createPromiseCapability(); const capability = createPromiseCapability();
@ -399,29 +370,22 @@ describe("message_handler", function () {
); );
const reader = readable.getReader(); const reader = readable.getReader();
await sleep(10);
expect(log).toEqual("01");
sleep(10) capability.resolve();
.then(() => { await capability.promise;
expect(log).toEqual("01");
capability.resolve(); let result = await reader.read();
return capability.promise.then(() => { expect(result.value).toEqual([1, 2, 3, 4]);
return reader.read(); expect(result.done).toEqual(false);
});
}) await sleep(10);
.then(result => { expect(log).toEqual("01");
expect(result.value).toEqual([1, 2, 3, 4]);
expect(result.done).toEqual(false); result = await reader.read();
return sleep(10); expect(result.value).toEqual(undefined);
}) expect(result.done).toEqual(true);
.then(() => {
expect(log).toEqual("01");
return reader.read();
})
.then(result => {
expect(result.value).toEqual(undefined);
expect(result.done).toEqual(true);
done();
});
}); });
}); });
}); });