piper-utils 1.1.70 → 1.1.71

package/src/eventManager/handleFile.test.js

@@ -1,460 +1,463 @@
-import Promise from 'bluebird';
-import { containsError, handleFile } from './handleFile.js';
-import S3Util from '../s3/S3Utils/S3Utils.js';
-
-describe('handleFile', () => {
-    it('should ignore NoSuchKey errors (SDK v2 style with code property)', async () => {
-        spyOn(S3Util, 'getObject').and.rejectWith({
-            NoSuchKey: 'The specified key does not exists',
-            message: 'The specified key does not exist.',
-            code: 'NoSuchKey',
-            region: null,
-            time: '2018-08-31T17:37:58.599Z',
-            requestId: '22DC04A07A54BD91',
-            extendedRequestId:
-                'csziWftoyoFinWJDya8eF1TGyNoT/lf+zLkdFQsHD2N0w7XDku0JgKO9qms9Ok+52tMuK+ENx1U=',
-            cfId: undefined,
-            statusCode: 404,
-            retryable: false,
-            retryDelay: 71.30459621135599
-        });
-        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
-        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({}));
-        const response = await handleFile();
-
-        expect(deleteSpy).not.toHaveBeenCalled();
-        expect(putSpy).not.toHaveBeenCalled();
-        expect(response).toBe(undefined);
-    });
-
-    it('should ignore NoSuchKey errors (SDK v3 style with name property)', async () => {
-        // AWS SDK v3 uses 'name' property for error identification
-        spyOn(S3Util, 'getObject').and.rejectWith({
-            name: 'NoSuchKey',
-            message: 'The specified key does not exist.',
-            $metadata: {
-                httpStatusCode: 404,
-                requestId: '22DC04A07A54BD91'
-            }
-        });
-        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
-        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({}));
-        const response = await handleFile('some/path', 'someBucket', creator.createFunc);
-
-        expect(deleteSpy).not.toHaveBeenCalled();
-        expect(putSpy).not.toHaveBeenCalled();
-        expect(response).toBe(undefined);
-    });
-
-    it('should rethrow non-NoSuchKey S3 errors', async () => {
-        const s3Error = {
-            name: 'AccessDenied',
-            message: 'Access Denied',
-            $metadata: {
-                httpStatusCode: 403
-            }
-        };
-        spyOn(S3Util, 'getObject').and.rejectWith(s3Error);
-        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
-        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
-
-        try {
-            await handleFile('some/path', 'someBucket', () => Promise.resolve());
-            fail('Expected error to be thrown');
-        } catch (err) {
-            expect(err).toEqual(s3Error);
-            expect(deleteSpy).not.toHaveBeenCalled();
-            expect(putSpy).not.toHaveBeenCalled();
-        }
-    });
-
-    it('handle file receives proper params', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-        spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({ foo: 'bar' }));
-
-        return handleFile('somePath', 'someBucket', creator.createFunc).then((response) => {
-            expect(response).toEqual({ foo: 'bar' });
-            expect(putObjectSpy).not.toHaveBeenCalled();
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
-            expect(creator.createFunc).toHaveBeenCalled();
-        });
-    });
-
-    it('handle file errors correctly', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-
-        return handleFile('somePath', 'someBucket', creator.createFunc).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'failed-once/somePath',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-
-    it('handle file errors correctly with delayUntil', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-
-        return handleFile('delayUntil/202001011234/somePath', 'someBucket', creator.createFunc).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'failed-once/somePath',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'delayUntil/202001011234/somePath' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'delayUntil/202001011234/somePath' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-
-    it('handle file errors correctly for failed-once', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-
-        return handleFile('failed-once/somePath', 'someBucket', creator.createFunc).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'failed-twice/somePath',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'failed-once/somePath' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'failed-once/somePath' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-
-    it('handle file errors correctly for failed-twice', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-
-        return handleFile('failed-twice/somePath', 'someBucket', creator.createFunc).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'error/somePath',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'failed-twice/somePath' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'failed-twice/somePath' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-
-    it('handle file errors correctly for shouldSkipFailedFolders', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-
-        return handleFile('somePath', 'someBucket', creator.createFunc, { shouldSkipFailedFolders: true }).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'error/somePath',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-
-    it('handle file userImportTypes & shouldSkipFailedFolders', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(
-            spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' }));
-
-        const userImportTypes = {
-            kovo: 'kovo',
-            zoobooks: 'zoobooks'
-        };
-
-        return handleFile('kovo/file.json', 'someBucket', creator.createFunc, { shouldSkipFailedFolders: true, userImportTypes }).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'kovo/error/file.json',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/file.json' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/file.json' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-    it('userImportTypes & handle file errors correctly for failed-once', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-        const userImportTypes = {
-            kovo: 'kovo',
-            zoobooks: 'zoobooks'
-        };
-        return handleFile('kovo/failed-once/file.json', 'someBucket', creator.createFunc, { userImportTypes }).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'kovo/failed-twice/file.json',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/failed-once/file.json' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/failed-once/file.json' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-    it('userImportTypes & handle file errors correctly for failed-twice', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-        const userImportTypes = {
-            kovo: 'kovo',
-            zoobooks: 'zoobooks'
-        };
-        return handleFile('kovo/failed-twice/file.json', 'someBucket', creator.createFunc, { userImportTypes }).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'kovo/error/file.json',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/failed-twice/file.json' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/failed-twice/file.json' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-    it('userImportTypes & handle file errors correctly', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-        const userImportTypes = {
-            kovo: 'kovo',
-            zoobooks: 'zoobooks'
-        };
-
-        return handleFile('kovo/file.json', 'someBucket', creator.createFunc, { userImportTypes }).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch((err) => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'kovo/failed-once/file.json',
-                Body: '{ "test": "val" }'
-            });
-
-            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/file.json' });
-            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/file.json' });
-            expect(creator.createFunc).toHaveBeenCalled();
-            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
-        });
-    });
-    it('userImportTypes & handle file with bad userImportTypes', () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-        const userImportTypes = {
-            duck: 'duck'
-        };
-
-        return handleFile('kovo/file.json', 'someBucket', creator.createFunc, { userImportTypes }).then(() => {
-            throw new Error('This function should have rejected');
-        }).catch(() => {
-            expect(putObjectSpy).toHaveBeenCalledWith({
-                Bucket: 'someBucket',
-                Key: 'pathAndEventMisMatchError/kovo/file.json',
-                Body: '{ "test": "val" }'
-            });
-        });
-    });
-    it('should throw if nesting error folders', async () => {
-        const creator = {
-            createFunc: () => {
-                return Promise.resolve();
-            }
-        };
-
-        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
-        spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
-        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
-
-        try {
-            await handleFile('error/error/file.json', 'someBucket', creator.createFunc);
-        } catch (e) {
-            expect(e).toBeDefined();
-            expect(putObjectSpy).not.toHaveBeenCalled();
-        }
-
-    });
-    it('containsError: should throw if nesting error folders', async () => {
-        const r = containsError('error/error', 'error');
-        expect(r).toBe(true);
-
-    });
-    it('containsError: should throw if nesting error folders', async () => {
-        const r = containsError('error/false', 'error');
-        expect(r).toBe(false);
-    });
-    it('should skip blank-string bodies', async () => {
-        const creator = { createFunc: () => Promise.resolve() };
-
-        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('   '));
-        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
-        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
-        const txSpy  = spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({}));
-
-        const res = await handleFile('somePath', 'someBucket', creator.createFunc);
-
-        expect(res).toBeUndefined();
-        expect(deleteSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
-        expect(putSpy).not.toHaveBeenCalled();
-        expect(txSpy).not.toHaveBeenCalled();
-    });
-
-    it('should skip bodies that parse to an empty object', async () => {
-        const creator = { createFunc: () => Promise.resolve() };
-
-        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{}'));
-        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
-        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
-        const txSpy  = spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({}));
-
-        const res = await handleFile('somePath', 'someBucket', creator.createFunc);
-
-        expect(res).toBeUndefined();
-        expect(deleteSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
-        expect(putSpy).not.toHaveBeenCalled();
-        expect(txSpy).not.toHaveBeenCalled();
-    });
-});
+import Promise from 'bluebird';
+import { isNestedFailurePath, handleFile } from './handleFile.js';
+import S3Util from '../s3/S3Utils/S3Utils.js';
+
+describe('handleFile', () => {
+    it('should ignore NoSuchKey errors (SDK v2 style with code property)', async () => {
+        spyOn(S3Util, 'getObject').and.rejectWith({
+            NoSuchKey: 'The specified key does not exists',
+            message: 'The specified key does not exist.',
+            code: 'NoSuchKey',
+            region: null,
+            time: '2018-08-31T17:37:58.599Z',
+            requestId: '22DC04A07A54BD91',
+            extendedRequestId:
+                'csziWftoyoFinWJDya8eF1TGyNoT/lf+zLkdFQsHD2N0w7XDku0JgKO9qms9Ok+52tMuK+ENx1U=',
+            cfId: undefined,
+            statusCode: 404,
+            retryable: false,
+            retryDelay: 71.30459621135599
+        });
+        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
+        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({}));
+        const response = await handleFile();
+
+        expect(deleteSpy).not.toHaveBeenCalled();
+        expect(putSpy).not.toHaveBeenCalled();
+        expect(response).toBe(undefined);
+    });
+
+    it('should ignore NoSuchKey errors (SDK v3 style with name property)', async () => {
+        // AWS SDK v3 uses 'name' property for error identification
+        spyOn(S3Util, 'getObject').and.rejectWith({
+            name: 'NoSuchKey',
+            message: 'The specified key does not exist.',
+            $metadata: {
+                httpStatusCode: 404,
+                requestId: '22DC04A07A54BD91'
+            }
+        });
+        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
+        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({}));
+        const response = await handleFile('some/path', 'someBucket', creator.createFunc);
+
+        expect(deleteSpy).not.toHaveBeenCalled();
+        expect(putSpy).not.toHaveBeenCalled();
+        expect(response).toBe(undefined);
+    });
+
+    it('should rethrow non-NoSuchKey S3 errors', async () => {
+        const s3Error = {
+            name: 'AccessDenied',
+            message: 'Access Denied',
+            $metadata: {
+                httpStatusCode: 403
+            }
+        };
+        spyOn(S3Util, 'getObject').and.rejectWith(s3Error);
+        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
+        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
+
+        try {
+            await handleFile('some/path', 'someBucket', () => Promise.resolve());
+            fail('Expected error to be thrown');
+        } catch (err) {
+            expect(err).toEqual(s3Error);
+            expect(deleteSpy).not.toHaveBeenCalled();
+            expect(putSpy).not.toHaveBeenCalled();
+        }
+    });
+
+    it('handle file receives proper params', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+        spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({ foo: 'bar' }));
+
+        return handleFile('somePath', 'someBucket', creator.createFunc).then((response) => {
+            expect(response).toEqual({ foo: 'bar' });
+            expect(putObjectSpy).not.toHaveBeenCalled();
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
+            expect(creator.createFunc).toHaveBeenCalled();
+        });
+    });
+
+    it('handle file errors correctly', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+
+        return handleFile('somePath', 'someBucket', creator.createFunc).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'failed-once/somePath',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+
+    it('handle file errors correctly with delayUntil', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+
+        return handleFile('delayUntil/202001011234/somePath', 'someBucket', creator.createFunc).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'failed-once/somePath',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'delayUntil/202001011234/somePath' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'delayUntil/202001011234/somePath' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+
+    it('handle file errors correctly for failed-once', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+
+        return handleFile('failed-once/somePath', 'someBucket', creator.createFunc).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'failed-twice/somePath',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'failed-once/somePath' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'failed-once/somePath' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+
+    it('handle file errors correctly for failed-twice', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+
+        return handleFile('failed-twice/somePath', 'someBucket', creator.createFunc).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'error/somePath',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'failed-twice/somePath' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'failed-twice/somePath' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+
+    it('handle file errors correctly for shouldSkipFailedFolders', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+
+        return handleFile('somePath', 'someBucket', creator.createFunc, { shouldSkipFailedFolders: true }).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'error/somePath',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+
+    it('handle file userImportTypes & shouldSkipFailedFolders', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(
+            spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' }));
+
+        const userImportTypes = {
+            kovo: 'kovo',
+            zoobooks: 'zoobooks'
+        };
+
+        return handleFile('kovo/file.json', 'someBucket', creator.createFunc, { shouldSkipFailedFolders: true, userImportTypes }).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'kovo/error/file.json',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/file.json' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/file.json' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+    it('userImportTypes & handle file errors correctly for failed-once', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+        const userImportTypes = {
+            kovo: 'kovo',
+            zoobooks: 'zoobooks'
+        };
+        return handleFile('kovo/failed-once/file.json', 'someBucket', creator.createFunc, { userImportTypes }).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'kovo/failed-twice/file.json',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/failed-once/file.json' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/failed-once/file.json' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+    it('userImportTypes & handle file errors correctly for failed-twice', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+        const userImportTypes = {
+            kovo: 'kovo',
+            zoobooks: 'zoobooks'
+        };
+        return handleFile('kovo/failed-twice/file.json', 'someBucket', creator.createFunc, { userImportTypes }).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'kovo/error/file.json',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/failed-twice/file.json' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/failed-twice/file.json' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+    it('userImportTypes & handle file errors correctly', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        const getObjectSpy = spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        const deleteObjectSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+        const userImportTypes = {
+            kovo: 'kovo',
+            zoobooks: 'zoobooks'
+        };
+
+        return handleFile('kovo/file.json', 'someBucket', creator.createFunc, { userImportTypes }).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch((err) => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'kovo/failed-once/file.json',
+                Body: '{ "test": "val" }'
+            });
+
+            expect(deleteObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/file.json' });
+            expect(getObjectSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'kovo/file.json' });
+            expect(creator.createFunc).toHaveBeenCalled();
+            expect(err).toEqual({ message: 'THIS FUNCTION FAILED' });
+        });
+    });
+    it('userImportTypes & handle file with bad userImportTypes', () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+        const userImportTypes = {
+            duck: 'duck'
+        };
+
+        return handleFile('kovo/file.json', 'someBucket', creator.createFunc, { userImportTypes }).then(() => {
+            throw new Error('This function should have rejected');
+        }).catch(() => {
+            expect(putObjectSpy).toHaveBeenCalledWith({
+                Bucket: 'someBucket',
+                Key: 'pathAndEventMisMatchError/kovo/file.json',
+                Body: '{ "test": "val" }'
+            });
+        });
+    });
+    it('should throw if nesting error folders', async () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+
+        try {
+            await handleFile('error/error/file.json', 'someBucket', creator.createFunc);
+        } catch (e) {
+            expect(e).toBeDefined();
+            expect(putObjectSpy).not.toHaveBeenCalled();
+        }
+
+    });
+    it('isNestedFailurePath: true when the folder path stacks two failure stages', () => {
+        expect(isNestedFailurePath('failed-once/error/file.json')).toBe(true);
+    });
+    it('isNestedFailurePath: false for a single failure stage', () => {
+        expect(isNestedFailurePath('error/file.json')).toBe(false);
+    });
+    it('isNestedFailurePath: false when only the FILENAME contains a stage token', () => {
+        // Regression for audit finding #8: a user file named "errors.csv" is not nested, so it
+        // ladders normally to error/ and dead-letters instead of looping forever.
+        expect(isNestedFailurePath('failed-once/errors.csv')).toBe(false);
+        expect(isNestedFailurePath('error/failed-once-list.csv')).toBe(false);
+    });
+    it('should skip blank-string bodies', async () => {
+        const creator = { createFunc: () => Promise.resolve() };
+
+        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('   '));
+        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
+        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
+        const txSpy  = spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({}));
+
+        const res = await handleFile('somePath', 'someBucket', creator.createFunc);
+
+        expect(res).toBeUndefined();
+        expect(deleteSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
+        expect(putSpy).not.toHaveBeenCalled();
+        expect(txSpy).not.toHaveBeenCalled();
+    });
+
+    it('should skip bodies that parse to an empty object', async () => {
+        const creator = { createFunc: () => Promise.resolve() };
+
+        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{}'));
+        const deleteSpy = spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve({}));
+        const putSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve({}));
+        const txSpy  = spyOn(creator, 'createFunc').and.returnValue(Promise.resolve({}));
+
+        const res = await handleFile('somePath', 'someBucket', creator.createFunc);
+
+        expect(res).toBeUndefined();
+        expect(deleteSpy).toHaveBeenCalledWith({ Bucket: 'someBucket', Key: 'somePath' });
+        expect(putSpy).not.toHaveBeenCalled();
+        expect(txSpy).not.toHaveBeenCalled();
+    });
+});