@coveo/push-api-client 3.0.122 → 3.0.123

package/dist/help/fileConsumer.js

@@ -1,151 +1,151 @@
-"use strict";
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileConsumer = void 0;
-const parseFile_1 = require("../validation/parseFile");
-const path_1 = require("path");
-const generator_1 = require("./generator");
-const bueno_1 = require("@coveo/bueno");
-/**
- * Util class to help injesting documents through a list of files and uploading generated document batches.
- */
-class FileConsumer {
-    /**
-     * Creates an instance of FileConsumer.
-     * @param {(batch: BatchUpdateDocuments) => Promise<Response>} upload the upload operation to apply to every document batch
-     * @param {Required<ConcurrentProcessing>} processingConfig
-     */
-    constructor(upload, processingConfig) {
-        this.upload = upload;
-        this.processingConfig = processingConfig;
-        this.cbSuccess = () => { };
-        this.cbFail = () => { };
-    }
-    async consume(files, options) {
-        const fileNames = files.map((path) => (0, path_1.basename)(path));
-        const { chunksToUpload, close } = this.splitByChunkAndUpload(fileNames);
-        const docBuilderGenerator = function* (docBuilders) {
-            for (const upload of chunksToUpload(docBuilders)) {
-                yield upload();
-            }
-        };
-        // parallelize uploads across multiple files
-        const fileGenerator = function () {
-            return __asyncGenerator(this, arguments, function* () {
-                for (const filePath of files.values()) {
-                    const docBuilders = yield __await((0, parseFile_1.parseAndGetDocumentBuilderFromJSONDocument)(filePath, options));
-                    yield __await(yield* __asyncDelegator(__asyncValues(docBuilderGenerator(docBuilders))));
-                }
-            });
-        };
-        await (0, generator_1.consumeGenerator)(fileGenerator.bind(this), this.processingConfig.maxConcurrent);
-        await close();
-    }
-    onSuccess(callback) {
-        this.cbSuccess = callback;
-    }
-    onError(callback) {
-        this.cbFail = callback;
-    }
-    splitByChunkAndUpload(fileNames, accumulator = this.accumulator) {
-        const chunksToUpload = (documentBuilders) => {
-            const batchesToUpload = [];
-            for (const docBuilder of documentBuilders) {
-                const sizeOfDoc = Buffer.byteLength(JSON.stringify(docBuilder.marshal()));
-                if (accumulator.size + sizeOfDoc >= FileConsumer.maxContentLength) {
-                    const chunks = accumulator.chunks;
-                    if (chunks.length > 0) {
-                        batchesToUpload.push(() => this.uploadBatch(chunks, fileNames));
-                    }
-                    accumulator.chunks = [docBuilder];
-                    accumulator.size = sizeOfDoc;
-                }
-                else {
-                    accumulator.size += sizeOfDoc;
-                    accumulator.chunks.push(docBuilder);
-                }
-            }
-            return batchesToUpload;
-        };
-        const close = async () => {
-            await this.uploadBatch(accumulator.chunks, fileNames);
-        };
-        return { chunksToUpload, close };
-    }
-    set expectedDocumentCount(count) {
-        this._totalDocumentCount = count;
-        this._remainingDocumentCount = count;
-    }
-    getRemainingDocumentCount(batch) {
-        if (this._remainingDocumentCount === undefined) {
-            return;
-        }
-        return (this._remainingDocumentCount -= batch.length);
-    }
-    async uploadBatch(batch, fileNames) {
-        let res;
-        const progress = this.getProgress(batch);
-        try {
-            res = await this.upload({
-                addOrUpdate: batch,
-                delete: [],
-            });
-        }
-        catch (error) {
-            this.cbFail(error, {
-                files: fileNames,
-                batch,
-                progress,
-            });
-        }
-        this.cbSuccess({
-            files: fileNames,
-            batch,
-            res,
-            progress,
-        });
-    }
-    getProgress(batch) {
-        const remainingDocumentCount = this.getRemainingDocumentCount(batch);
-        if ((0, bueno_1.isUndefined)(remainingDocumentCount) ||
-            (0, bueno_1.isUndefined)(this._totalDocumentCount)) {
-            return;
-        }
-        return {
-            remainingDocumentCount,
-            totalDocumentCount: this._totalDocumentCount,
-        };
-    }
-    get accumulator() {
-        return {
-            size: 0,
-            chunks: [],
-        };
-    }
-}
-exports.FileConsumer = FileConsumer;
-FileConsumer.maxContentLength = 5 * 1024 * 1024;
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileConsumer = void 0;
+const parseFile_1 = require("../validation/parseFile");
+const path_1 = require("path");
+const generator_1 = require("./generator");
+const bueno_1 = require("@coveo/bueno");
+/**
+ * Util class to help injesting documents through a list of files and uploading generated document batches.
+ */
+class FileConsumer {
+    /**
+     * Creates an instance of FileConsumer.
+     * @param {(batch: BatchUpdateDocuments) => Promise<Response>} upload the upload operation to apply to every document batch
+     * @param {Required<ConcurrentProcessing>} processingConfig
+     */
+    constructor(upload, processingConfig) {
+        this.upload = upload;
+        this.processingConfig = processingConfig;
+        this.cbSuccess = () => { };
+        this.cbFail = () => { };
+    }
+    async consume(files, options) {
+        const fileNames = files.map((path) => (0, path_1.basename)(path));
+        const { chunksToUpload, close } = this.splitByChunkAndUpload(fileNames);
+        const docBuilderGenerator = function* (docBuilders) {
+            for (const upload of chunksToUpload(docBuilders)) {
+                yield upload();
+            }
+        };
+        // parallelize uploads across multiple files
+        const fileGenerator = function () {
+            return __asyncGenerator(this, arguments, function* () {
+                for (const filePath of files.values()) {
+                    const docBuilders = yield __await((0, parseFile_1.parseAndGetDocumentBuilderFromJSONDocument)(filePath, options));
+                    yield __await(yield* __asyncDelegator(__asyncValues(docBuilderGenerator(docBuilders))));
+                }
+            });
+        };
+        await (0, generator_1.consumeGenerator)(fileGenerator.bind(this), this.processingConfig.maxConcurrent);
+        await close();
+    }
+    onSuccess(callback) {
+        this.cbSuccess = callback;
+    }
+    onError(callback) {
+        this.cbFail = callback;
+    }
+    splitByChunkAndUpload(fileNames, accumulator = this.accumulator) {
+        const chunksToUpload = (documentBuilders) => {
+            const batchesToUpload = [];
+            for (const docBuilder of documentBuilders) {
+                const sizeOfDoc = Buffer.byteLength(JSON.stringify(docBuilder.marshal()));
+                if (accumulator.size + sizeOfDoc >= FileConsumer.maxContentLength) {
+                    const chunks = accumulator.chunks;
+                    if (chunks.length > 0) {
+                        batchesToUpload.push(() => this.uploadBatch(chunks, fileNames));
+                    }
+                    accumulator.chunks = [docBuilder];
+                    accumulator.size = sizeOfDoc;
+                }
+                else {
+                    accumulator.size += sizeOfDoc;
+                    accumulator.chunks.push(docBuilder);
+                }
+            }
+            return batchesToUpload;
+        };
+        const close = async () => {
+            await this.uploadBatch(accumulator.chunks, fileNames);
+        };
+        return { chunksToUpload, close };
+    }
+    set expectedDocumentCount(count) {
+        this._totalDocumentCount = count;
+        this._remainingDocumentCount = count;
+    }
+    getRemainingDocumentCount(batch) {
+        if (this._remainingDocumentCount === undefined) {
+            return;
+        }
+        return (this._remainingDocumentCount -= batch.length);
+    }
+    async uploadBatch(batch, fileNames) {
+        let res;
+        const progress = this.getProgress(batch);
+        try {
+            res = await this.upload({
+                addOrUpdate: batch,
+                delete: [],
+            });
+        }
+        catch (error) {
+            this.cbFail(error, {
+                files: fileNames,
+                batch,
+                progress,
+            });
+        }
+        this.cbSuccess({
+            files: fileNames,
+            batch,
+            res,
+            progress,
+        });
+    }
+    getProgress(batch) {
+        const remainingDocumentCount = this.getRemainingDocumentCount(batch);
+        if ((0, bueno_1.isUndefined)(remainingDocumentCount) ||
+            (0, bueno_1.isUndefined)(this._totalDocumentCount)) {
+            return;
+        }
+        return {
+            remainingDocumentCount,
+            totalDocumentCount: this._totalDocumentCount,
+        };
+    }
+    get accumulator() {
+        return {
+            size: 0,
+            chunks: [],
+        };
+    }
+}
+exports.FileConsumer = FileConsumer;
+FileConsumer.maxContentLength = 5 * 1024 * 1024;
 //# sourceMappingURL=fileConsumer.js.map

package/dist/help/fileConsumer.spec.js

@@ -1,154 +1,154 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-jest.mock('../validation/parseFile');
-const __1 = require("..");
-const fileConsumer_1 = require("./fileConsumer");
-const parseFile_1 = require("../validation/parseFile");
-const mockedParse = jest.mocked(parseFile_1.parseAndGetDocumentBuilderFromJSONDocument);
-// generating 5 documents of 2 mb each
-mockedParse.mockResolvedValue(generateDocBuilderBatch(5, 2));
-function generateDocBuilderBatch(documentCount, documentSize) {
-    let counter = 1;
-    const randomCharacter = '#';
-    const bytes = documentSize * 1024 * 1024;
-    const data = Buffer.alloc(bytes, randomCharacter).toString();
-    const docBuilderFactory = () => new __1.DocumentBuilder(`https://url.com/${counter++}`, 'title').withData(data);
-    return [...Array(documentCount)].map(docBuilderFactory);
-}
-describe('FileConsumer', () => {
-    let fileConsumer;
-    const fakeUpload = jest.fn();
-    const singleEntry = ['foo.json'];
-    const entries = ['bar.json', 'baz.json'];
-    describe('when upload is successful', () => {
-        beforeEach(() => {
-            fileConsumer = new fileConsumer_1.FileConsumer(fakeUpload, { maxConcurrent: 10 });
-            fakeUpload.mockResolvedValue({
-                status: 202,
-                statusText: 'All good',
-            });
-        });
-        afterEach(() => {
-            fakeUpload.mockReset();
-        });
-        it('should call the success callback', async () => {
-            const mockedHandleSuccess = jest.fn();
-            fileConsumer.onSuccess(mockedHandleSuccess);
-            await fileConsumer.consume(entries);
-            expect(mockedHandleSuccess).toHaveBeenCalled();
-        });
-        it('should not call the error callback', async () => {
-            const mockedHandleError = jest.fn();
-            fileConsumer.onError(mockedHandleError);
-            await fileConsumer.consume(entries);
-            expect(mockedHandleError).not.toHaveBeenCalled();
-        });
-        it('should only push JSON files', async () => {
-            const expectedSequence = [
-                'https://url.com/1',
-                'https://url.com/2',
-                'https://url.com/3',
-                'https://url.com/4',
-                'https://url.com/5',
-            ].values();
-            const handleBatchUpload = (data) => {
-                for (const element of data.batch) {
-                    const documentBuilder = element;
-                    const { documentId } = documentBuilder.marshal();
-                    expect(documentId).toEqual(expectedSequence.next().value);
-                }
-            };
-            fileConsumer.onSuccess(handleBatchUpload);
-            await fileConsumer.consume(singleEntry);
-        });
-        describe.each([
-            {
-                // 1 file with 5 documents of 2MB each => 10MB to upload => 3 batches: [4MB] [4MB] [2MB]
-                title: 'when consume a single file',
-                sequence: [2, 2, 1],
-                entries: ['foo.json'],
-            },
-            {
-                // 2 files with 5 documents each weighing 2MB => 20MB to upload => 5 batches: [4MB] [4MB] [4MB] [4MB] [4MB]
-                title: 'when consume 2 files',
-                sequence: [2, 2, 2, 2, 2],
-                entries: ['foo.json', 'bar.json'],
-            },
-        ])('$title', ({ sequence, entries }) => {
-            it(`should create ${sequence.length} batches`, async () => {
-                const batchOrder = sequence.values();
-                const handleBatchUpload = (data) => expect(data.batch.length).toEqual(batchOrder.next().value);
-                fileConsumer.onSuccess(handleBatchUpload);
-                await fileConsumer.consume(entries);
-            });
-            it(`should call callback ${sequence.length} times`, async () => {
-                const mockedHandleSuccess = jest.fn();
-                fileConsumer.onSuccess(mockedHandleSuccess);
-                await fileConsumer.consume(entries);
-                expect(mockedHandleSuccess).toHaveBeenCalledTimes(sequence.length);
-            });
-        });
-        describe('when the upload progress is returned', () => {
-            const mockedHandleSuccess = jest.fn();
-            const documentCount = 5;
-            beforeEach(async () => {
-                fileConsumer.expectedDocumentCount = documentCount;
-                fileConsumer.onSuccess(mockedHandleSuccess);
-                await fileConsumer.consume(singleEntry);
-            });
-            it('should call callback on every batch upload', async () => {
-                expect(mockedHandleSuccess).toHaveBeenCalledTimes(3);
-            });
-            it('should return remaining and total documents at each call', async () => {
-                expect(mockedHandleSuccess).toHaveBeenNthCalledWith(1, expect.objectContaining({
-                    progress: { remainingDocumentCount: 3, totalDocumentCount: 5 },
-                }));
-                expect(mockedHandleSuccess).toHaveBeenNthCalledWith(2, expect.objectContaining({
-                    progress: { remainingDocumentCount: 1, totalDocumentCount: 5 },
-                }));
-                expect(mockedHandleSuccess).toHaveBeenNthCalledWith(3, expect.objectContaining({
-                    progress: { remainingDocumentCount: 0, totalDocumentCount: 5 },
-                }));
-            });
-        });
-    });
-    describe('when upload is in error', () => {
-        let fileConsumer;
-        beforeEach(() => {
-            fileConsumer = new fileConsumer_1.FileConsumer(fakeUpload, { maxConcurrent: 10 });
-            fakeUpload.mockRejectedValueOnce({
-                status: 412,
-                statusText: 'BAD_REQUEST',
-            });
-        });
-        it('should return the number of remaining documents', async () => {
-            const mockedHandleError = jest.fn();
-            const documentCount = 5;
-            fileConsumer.expectedDocumentCount = documentCount;
-            fileConsumer.onError(mockedHandleError);
-            await fileConsumer.consume(singleEntry);
-            expect(mockedHandleError).toHaveBeenCalledTimes(1);
-            expect(mockedHandleError).toHaveBeenCalledWith({
-                status: 412,
-                statusText: 'BAD_REQUEST',
-            }, expect.objectContaining({
-                progress: { remainingDocumentCount: 3, totalDocumentCount: 5 },
-            }) // 2 out of 5 document processed... 3 remaiming
-            );
-        });
-        it('should call the error callback', async () => {
-            const mockedHandleError = jest.fn();
-            fileConsumer.onError(mockedHandleError);
-            await fileConsumer.consume(entries);
-            expect(mockedHandleError).toHaveBeenCalled();
-        });
-        it('should call the error callback', async () => {
-            const handleBatchError = (err) => {
-                expect(err).toEqual({ status: 412, statusText: 'BAD_REQUEST' });
-            };
-            fileConsumer.onError(handleBatchError);
-            await fileConsumer.consume(entries);
-        });
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('../validation/parseFile');
+const __1 = require("..");
+const fileConsumer_1 = require("./fileConsumer");
+const parseFile_1 = require("../validation/parseFile");
+const mockedParse = jest.mocked(parseFile_1.parseAndGetDocumentBuilderFromJSONDocument);
+// generating 5 documents of 2 mb each
+mockedParse.mockResolvedValue(generateDocBuilderBatch(5, 2));
+function generateDocBuilderBatch(documentCount, documentSize) {
+    let counter = 1;
+    const randomCharacter = '#';
+    const bytes = documentSize * 1024 * 1024;
+    const data = Buffer.alloc(bytes, randomCharacter).toString();
+    const docBuilderFactory = () => new __1.DocumentBuilder(`https://url.com/${counter++}`, 'title').withData(data);
+    return [...Array(documentCount)].map(docBuilderFactory);
+}
+describe('FileConsumer', () => {
+    let fileConsumer;
+    const fakeUpload = jest.fn();
+    const singleEntry = ['foo.json'];
+    const entries = ['bar.json', 'baz.json'];
+    describe('when upload is successful', () => {
+        beforeEach(() => {
+            fileConsumer = new fileConsumer_1.FileConsumer(fakeUpload, { maxConcurrent: 10 });
+            fakeUpload.mockResolvedValue({
+                status: 202,
+                statusText: 'All good',
+            });
+        });
+        afterEach(() => {
+            fakeUpload.mockReset();
+        });
+        it('should call the success callback', async () => {
+            const mockedHandleSuccess = jest.fn();
+            fileConsumer.onSuccess(mockedHandleSuccess);
+            await fileConsumer.consume(entries);
+            expect(mockedHandleSuccess).toHaveBeenCalled();
+        });
+        it('should not call the error callback', async () => {
+            const mockedHandleError = jest.fn();
+            fileConsumer.onError(mockedHandleError);
+            await fileConsumer.consume(entries);
+            expect(mockedHandleError).not.toHaveBeenCalled();
+        });
+        it('should only push JSON files', async () => {
+            const expectedSequence = [
+                'https://url.com/1',
+                'https://url.com/2',
+                'https://url.com/3',
+                'https://url.com/4',
+                'https://url.com/5',
+            ].values();
+            const handleBatchUpload = (data) => {
+                for (const element of data.batch) {
+                    const documentBuilder = element;
+                    const { documentId } = documentBuilder.marshal();
+                    expect(documentId).toEqual(expectedSequence.next().value);
+                }
+            };
+            fileConsumer.onSuccess(handleBatchUpload);
+            await fileConsumer.consume(singleEntry);
+        });
+        describe.each([
+            {
+                // 1 file with 5 documents of 2MB each => 10MB to upload => 3 batches: [4MB] [4MB] [2MB]
+                title: 'when consume a single file',
+                sequence: [2, 2, 1],
+                entries: ['foo.json'],
+            },
+            {
+                // 2 files with 5 documents each weighing 2MB => 20MB to upload => 5 batches: [4MB] [4MB] [4MB] [4MB] [4MB]
+                title: 'when consume 2 files',
+                sequence: [2, 2, 2, 2, 2],
+                entries: ['foo.json', 'bar.json'],
+            },
+        ])('$title', ({ sequence, entries }) => {
+            it(`should create ${sequence.length} batches`, async () => {
+                const batchOrder = sequence.values();
+                const handleBatchUpload = (data) => expect(data.batch.length).toEqual(batchOrder.next().value);
+                fileConsumer.onSuccess(handleBatchUpload);
+                await fileConsumer.consume(entries);
+            });
+            it(`should call callback ${sequence.length} times`, async () => {
+                const mockedHandleSuccess = jest.fn();
+                fileConsumer.onSuccess(mockedHandleSuccess);
+                await fileConsumer.consume(entries);
+                expect(mockedHandleSuccess).toHaveBeenCalledTimes(sequence.length);
+            });
+        });
+        describe('when the upload progress is returned', () => {
+            const mockedHandleSuccess = jest.fn();
+            const documentCount = 5;
+            beforeEach(async () => {
+                fileConsumer.expectedDocumentCount = documentCount;
+                fileConsumer.onSuccess(mockedHandleSuccess);
+                await fileConsumer.consume(singleEntry);
+            });
+            it('should call callback on every batch upload', async () => {
+                expect(mockedHandleSuccess).toHaveBeenCalledTimes(3);
+            });
+            it('should return remaining and total documents at each call', async () => {
+                expect(mockedHandleSuccess).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                    progress: { remainingDocumentCount: 3, totalDocumentCount: 5 },
+                }));
+                expect(mockedHandleSuccess).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                    progress: { remainingDocumentCount: 1, totalDocumentCount: 5 },
+                }));
+                expect(mockedHandleSuccess).toHaveBeenNthCalledWith(3, expect.objectContaining({
+                    progress: { remainingDocumentCount: 0, totalDocumentCount: 5 },
+                }));
+            });
+        });
+    });
+    describe('when upload is in error', () => {
+        let fileConsumer;
+        beforeEach(() => {
+            fileConsumer = new fileConsumer_1.FileConsumer(fakeUpload, { maxConcurrent: 10 });
+            fakeUpload.mockRejectedValueOnce({
+                status: 412,
+                statusText: 'BAD_REQUEST',
+            });
+        });
+        it('should return the number of remaining documents', async () => {
+            const mockedHandleError = jest.fn();
+            const documentCount = 5;
+            fileConsumer.expectedDocumentCount = documentCount;
+            fileConsumer.onError(mockedHandleError);
+            await fileConsumer.consume(singleEntry);
+            expect(mockedHandleError).toHaveBeenCalledTimes(1);
+            expect(mockedHandleError).toHaveBeenCalledWith({
+                status: 412,
+                statusText: 'BAD_REQUEST',
+            }, expect.objectContaining({
+                progress: { remainingDocumentCount: 3, totalDocumentCount: 5 },
+            }) // 2 out of 5 document processed... 3 remaiming
+            );
+        });
+        it('should call the error callback', async () => {
+            const mockedHandleError = jest.fn();
+            fileConsumer.onError(mockedHandleError);
+            await fileConsumer.consume(entries);
+            expect(mockedHandleError).toHaveBeenCalled();
+        });
+        it('should call the error callback', async () => {
+            const handleBatchError = (err) => {
+                expect(err).toEqual({ status: 412, statusText: 'BAD_REQUEST' });
+            };
+            fileConsumer.onError(handleBatchError);
+            await fileConsumer.consume(entries);
+        });
+    });
+});
 //# sourceMappingURL=fileConsumer.spec.js.map