mol-pdf 1.0.0

package/lib/cafe-pdf/src/pdfjs-dist/lib/test/unit/murmurhash3_spec.js

@@ -0,0 +1,71 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _murmurhash = require("../../core/murmurhash3");
+
+describe('MurmurHash3_64', function () {
+  it('instantiates without seed', function () {
+    var hash = new _murmurhash.MurmurHash3_64();
+    expect(hash).toEqual(jasmine.any(_murmurhash.MurmurHash3_64));
+  });
+  it('instantiates with seed', function () {
+    var hash = new _murmurhash.MurmurHash3_64(1);
+    expect(hash).toEqual(jasmine.any(_murmurhash.MurmurHash3_64));
+  });
+  var hexDigestExpected = 'f61cfdbfdae0f65e';
+  var sourceText = 'test';
+  var sourceCharCodes = [116, 101, 115, 116];
+  it('correctly generates a hash from a string', function () {
+    var hash = new _murmurhash.MurmurHash3_64();
+    hash.update(sourceText);
+    expect(hash.hexdigest()).toEqual(hexDigestExpected);
+  });
+  it('correctly generates a hash from a Uint8Array', function () {
+    var hash = new _murmurhash.MurmurHash3_64();
+    hash.update(new Uint8Array(sourceCharCodes));
+    expect(hash.hexdigest()).toEqual(hexDigestExpected);
+  });
+  it('correctly generates a hash from a Uint32Array', function () {
+    var hash = new _murmurhash.MurmurHash3_64();
+    hash.update(new Uint32Array(new Uint8Array(sourceCharCodes).buffer));
+    expect(hash.hexdigest()).toEqual(hexDigestExpected);
+  });
+  it('changes the hash after update without seed', function () {
+    var hash = new _murmurhash.MurmurHash3_64();
+    var hexdigest1, hexdigest2;
+    hash.update(sourceText);
+    hexdigest1 = hash.hexdigest();
+    hash.update(sourceText);
+    hexdigest2 = hash.hexdigest();
+    expect(hexdigest1).not.toEqual(hexdigest2);
+  });
+  it('changes the hash after update with seed', function () {
+    var hash = new _murmurhash.MurmurHash3_64(1);
+    var hexdigest1, hexdigest2;
+    hash.update(sourceText);
+    hexdigest1 = hash.hexdigest();
+    hash.update(sourceText);
+    hexdigest2 = hash.hexdigest();
+    expect(hexdigest1).not.toEqual(hexdigest2);
+  });
+});

package/lib/cafe-pdf/src/pdfjs-dist/lib/test/unit/network_spec.js

@@ -0,0 +1,120 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _util = require("../../shared/util");
+
+var _network = require("../../display/network");
+
+describe('network', function () {
+  var pdf1 = new URL('../pdfs/tracemonkey.pdf', window.location).href;
+  var pdf1Length = 1016315;
+  it('read without stream and range', function (done) {
+    var stream = new _network.PDFNetworkStream({
+      url: pdf1,
+      rangeChunkSize: 65536,
+      disableStream: true,
+      disableRange: true
+    });
+    var fullReader = stream.getFullReader();
+    var isStreamingSupported, isRangeSupported;
+    var promise = fullReader.headersReady.then(function () {
+      isStreamingSupported = fullReader.isStreamingSupported;
+      isRangeSupported = fullReader.isRangeSupported;
+    });
+    var len = 0,
+        count = 0;
+
+    var read = function read() {
+      return fullReader.read().then(function (result) {
+        if (result.done) {
+          return undefined;
+        }
+
+        count++;
+        len += result.value.byteLength;
+        return read();
+      });
+    };
+
+    var readPromise = Promise.all([read(), promise]);
+    readPromise.then(function (page) {
+      expect(len).toEqual(pdf1Length);
+      expect(count).toEqual(1);
+      expect(isStreamingSupported).toEqual(false);
+      expect(isRangeSupported).toEqual(false);
+      done();
+    })["catch"](function (reason) {
+      done.fail(reason);
+    });
+  });
+  it('read custom ranges', function (done) {
+    var rangeSize = 32768;
+    var stream = new _network.PDFNetworkStream({
+      url: pdf1,
+      length: pdf1Length,
+      rangeChunkSize: rangeSize,
+      disableStream: true,
+      disableRange: false
+    });
+    var fullReader = stream.getFullReader();
+    var isStreamingSupported, isRangeSupported, fullReaderCancelled;
+    var promise = fullReader.headersReady.then(function () {
+      isStreamingSupported = fullReader.isStreamingSupported;
+      isRangeSupported = fullReader.isRangeSupported;
+      fullReader.cancel(new _util.AbortException('Don\'t need fullReader.'));
+      fullReaderCancelled = true;
+    });
+    var tailSize = pdf1Length % rangeSize || rangeSize;
+    var range1Reader = stream.getRangeReader(pdf1Length - tailSize - rangeSize, pdf1Length - tailSize);
+    var range2Reader = stream.getRangeReader(pdf1Length - tailSize, pdf1Length);
+    var result1 = {
+      value: 0
+    },
+        result2 = {
+      value: 0
+    };
+
+    var read = function read(reader, lenResult) {
+      return reader.read().then(function (result) {
+        if (result.done) {
+          return undefined;
+        }
+
+        lenResult.value += result.value.byteLength;
+        return read(reader, lenResult);
+      });
+    };
+
+    var readPromises = Promise.all([read(range1Reader, result1), read(range2Reader, result2), promise]);
+    readPromises.then(function () {
+      expect(result1.value).toEqual(rangeSize);
+      expect(result2.value).toEqual(tailSize);
+      expect(isStreamingSupported).toEqual(false);
+      expect(isRangeSupported).toEqual(true);
+      expect(fullReaderCancelled).toEqual(true);
+      done();
+    })["catch"](function (reason) {
+      done.fail(reason);
+    });
+  });
+});

package/lib/cafe-pdf/src/pdfjs-dist/lib/test/unit/network_utils_spec.js

@@ -0,0 +1,349 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _network_utils = require("../../display/network_utils");
+
+var _util = require("../../shared/util");
+
+describe('network_utils', function () {
+  describe('validateRangeRequestCapabilities', function () {
+    it('rejects range chunk sizes that are not larger than zero', function () {
+      expect(function () {
+        (0, _network_utils.validateRangeRequestCapabilities)({
+          rangeChunkSize: 0
+        });
+      }).toThrow(new Error('Range chunk size must be larger than zero'));
+    });
+    it('rejects disabled or non-HTTP range requests', function () {
+      expect((0, _network_utils.validateRangeRequestCapabilities)({
+        disableRange: true,
+        isHttp: true,
+        getResponseHeader: function getResponseHeader(headerName) {
+          if (headerName === 'Content-Length') {
+            return 8;
+          }
+
+          throw new Error("Unexpected headerName: ".concat(headerName));
+        },
+        rangeChunkSize: 64
+      })).toEqual({
+        allowRangeRequests: false,
+        suggestedLength: 8
+      });
+      expect((0, _network_utils.validateRangeRequestCapabilities)({
+        disableRange: false,
+        isHttp: false,
+        getResponseHeader: function getResponseHeader(headerName) {
+          if (headerName === 'Content-Length') {
+            return 8;
+          }
+
+          throw new Error("Unexpected headerName: ".concat(headerName));
+        },
+        rangeChunkSize: 64
+      })).toEqual({
+        allowRangeRequests: false,
+        suggestedLength: 8
+      });
+    });
+    it('rejects invalid Accept-Ranges header values', function () {
+      expect((0, _network_utils.validateRangeRequestCapabilities)({
+        disableRange: false,
+        isHttp: true,
+        getResponseHeader: function getResponseHeader(headerName) {
+          if (headerName === 'Accept-Ranges') {
+            return 'none';
+          } else if (headerName === 'Content-Length') {
+            return 8;
+          }
+
+          throw new Error("Unexpected headerName: ".concat(headerName));
+        },
+        rangeChunkSize: 64
+      })).toEqual({
+        allowRangeRequests: false,
+        suggestedLength: 8
+      });
+    });
+    it('rejects invalid Content-Encoding header values', function () {
+      expect((0, _network_utils.validateRangeRequestCapabilities)({
+        disableRange: false,
+        isHttp: true,
+        getResponseHeader: function getResponseHeader(headerName) {
+          if (headerName === 'Accept-Ranges') {
+            return 'bytes';
+          } else if (headerName === 'Content-Encoding') {
+            return 'gzip';
+          } else if (headerName === 'Content-Length') {
+            return 8;
+          }
+
+          throw new Error("Unexpected headerName: ".concat(headerName));
+        },
+        rangeChunkSize: 64
+      })).toEqual({
+        allowRangeRequests: false,
+        suggestedLength: 8
+      });
+    });
+    it('rejects invalid Content-Length header values', function () {
+      expect((0, _network_utils.validateRangeRequestCapabilities)({
+        disableRange: false,
+        isHttp: true,
+        getResponseHeader: function getResponseHeader(headerName) {
+          if (headerName === 'Accept-Ranges') {
+            return 'bytes';
+          } else if (headerName === 'Content-Encoding') {
+            return null;
+          } else if (headerName === 'Content-Length') {
+            return 'eight';
+          }
+
+          throw new Error("Unexpected headerName: ".concat(headerName));
+        },
+        rangeChunkSize: 64
+      })).toEqual({
+        allowRangeRequests: false,
+        suggestedLength: undefined
+      });
+    });
+    it('rejects file sizes that are too small for range requests', function () {
+      expect((0, _network_utils.validateRangeRequestCapabilities)({
+        disableRange: false,
+        isHttp: true,
+        getResponseHeader: function getResponseHeader(headerName) {
+          if (headerName === 'Accept-Ranges') {
+            return 'bytes';
+          } else if (headerName === 'Content-Encoding') {
+            return null;
+          } else if (headerName === 'Content-Length') {
+            return 8;
+          }
+
+          throw new Error("Unexpected headerName: ".concat(headerName));
+        },
+        rangeChunkSize: 64
+      })).toEqual({
+        allowRangeRequests: false,
+        suggestedLength: 8
+      });
+    });
+    it('accepts file sizes large enough for range requests', function () {
+      expect((0, _network_utils.validateRangeRequestCapabilities)({
+        disableRange: false,
+        isHttp: true,
+        getResponseHeader: function getResponseHeader(headerName) {
+          if (headerName === 'Accept-Ranges') {
+            return 'bytes';
+          } else if (headerName === 'Content-Encoding') {
+            return null;
+          } else if (headerName === 'Content-Length') {
+            return 8192;
+          }
+
+          throw new Error("Unexpected headerName: ".concat(headerName));
+        },
+        rangeChunkSize: 64
+      })).toEqual({
+        allowRangeRequests: true,
+        suggestedLength: 8192
+      });
+    });
+  });
+  describe('extractFilenameFromHeader', function () {
+    it('returns null when content disposition header is blank', function () {
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return null;
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toBeNull();
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return undefined;
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toBeNull();
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return '';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toBeNull();
+    });
+    it('gets the filename from the response header', function () {
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'inline';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toBeNull();
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toBeNull();
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename="filename.pdf"';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename="filename.pdf and spaces.pdf"';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf and spaces.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename="tl;dr.pdf"';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('tl;dr.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename=filename.pdf';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename=filename.pdf someotherparam';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename="%e4%b8%ad%e6%96%87.pdf"';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('中文.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename="100%.pdf"';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('100%.pdf');
+    });
+    it('gets the filename from the response header (RFC 6266)', function () {
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename*=filename.pdf';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename*=\'\'filename.pdf';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename*=utf-8\'\'filename.pdf';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename=no.pdf; filename*=utf-8\'\'filename.pdf';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename*=utf-8\'\'filename.pdf; filename=no.pdf';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+    });
+    it('gets the filename from the response header (RFC 2231)', function () {
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename*0=filename; filename*1=.pdf';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('filename.pdf');
+    });
+    it('only extracts filename with pdf extension', function () {
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'attachment; filename="filename.png"';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toBeNull();
+    });
+    it('extension validation is case insensitive', function () {
+      expect((0, _network_utils.extractFilenameFromHeader)(function (headerName) {
+        if (headerName === 'Content-Disposition') {
+          return 'form-data; name="fieldName"; filename="file.PdF"';
+        }
+
+        throw new Error("Unexpected headerName: ".concat(headerName));
+      })).toEqual('file.PdF');
+    });
+  });
+  describe('createResponseStatusError', function () {
+    it('handles missing PDF file responses', function () {
+      expect((0, _network_utils.createResponseStatusError)(404, 'https://foo.com/bar.pdf')).toEqual(new _util.MissingPDFException('Missing PDF "https://foo.com/bar.pdf".'));
+      expect((0, _network_utils.createResponseStatusError)(0, 'file://foo.pdf')).toEqual(new _util.MissingPDFException('Missing PDF "file://foo.pdf".'));
+    });
+    it('handles unexpected responses', function () {
+      expect((0, _network_utils.createResponseStatusError)(302, 'https://foo.com/bar.pdf')).toEqual(new _util.UnexpectedResponseException('Unexpected server response (302) while retrieving PDF ' + '"https://foo.com/bar.pdf".'));
+      expect((0, _network_utils.createResponseStatusError)(0, 'https://foo.com/bar.pdf')).toEqual(new _util.UnexpectedResponseException('Unexpected server response (0) while retrieving PDF ' + '"https://foo.com/bar.pdf".'));
+    });
+  });
+  describe('validateResponseStatus', function () {
+    it('accepts valid response statuses', function () {
+      expect((0, _network_utils.validateResponseStatus)(200)).toEqual(true);
+      expect((0, _network_utils.validateResponseStatus)(206)).toEqual(true);
+    });
+    it('rejects invalid response statuses', function () {
+      expect((0, _network_utils.validateResponseStatus)(302)).toEqual(false);
+      expect((0, _network_utils.validateResponseStatus)(404)).toEqual(false);
+      expect((0, _network_utils.validateResponseStatus)(null)).toEqual(false);
+      expect((0, _network_utils.validateResponseStatus)(undefined)).toEqual(false);
+    });
+  });
+});