@forge/storage 0.0.0-experimental-490cfcf → 0.0.0-experimental-85df747

package/out/__test__/global-storage.test.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("../errors");
 const global_storage_1 = require("../global-storage");
-const queries_1 = require("../queries");
+const gql_queries_1 = require("../gql-queries");
 const contextAri = 'app-ari';
 const getStorage = (apiClientMock) => new global_storage_1.GlobalStorage(() => contextAri, apiClientMock);
 const getApiClientMock = (response, statusCode = 200) => {
@@ -25,6 +25,28 @@ const INVALID_CURSOR_ERROR = {
         errorType: 'INVALID_CURSOR'
     }
 };
+const schemas = [
+    {
+        name: 'cars',
+        attributes: {
+            model: { type: 'string' },
+            make: { type: 'string' },
+            year: { type: 'float' }
+        },
+        indexes: [
+            {
+                name: 'by-year',
+                partition: ['year'],
+                range: ['model']
+            },
+            {
+                name: 'by-make',
+                partition: ['make'],
+                range: ['model']
+            }
+        ]
+    }
+];
 describe('GlobalStorage', () => {
     function verifyApiClientCalledWith(apiClientMock, variables, query) {
         expect(apiClientMock).toHaveBeenCalledWith('/forge/entities/graphql', expect.objectContaining({
@@ -128,13 +150,6 @@ describe('GlobalStorage', () => {
             expect(apiClientMock).toHaveBeenCalled();
             await expect(response).rejects.toThrow(errors_1.APIError.forErrorCode('CURSOR_INVALID', 'error message'));
         });
-        it('should throw an error if the storage API returns a non 200 status code', async () => {
-            const apiClientMock = getApiClientMock(undefined, 400);
-            const globalStorage = getStorage(apiClientMock);
-            const response = globalStorage.get('testKey');
-            expect(apiClientMock).toHaveBeenCalled();
-            await expect(response).rejects.toThrow(errors_1.APIError.forStatus(400));
-        });
         it('should throw an error if the response is not a valid JSON', async () => {
             const apiClientMock = getApiClientMockInvalidJson('test', 200);
             const globalStorage = getStorage(apiClientMock);
@@ -319,6 +334,211 @@ describe('GlobalStorage', () => {
             });
         });
     });
+    describe('getEntity', () => {
+        it('should call the storage API, passing the provided entity name and entity key and returning the stored value', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStoredCustomEntity: {
+                        value: 'testValue'
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            const returnedValue = await globalStorage.getEntity('testEntityName', 'testEntityKey');
+            verifyApiClientCalledWith(apiClientMock, {
+                contextAri,
+                entityName: 'testEntityName',
+                key: 'testEntityKey'
+            });
+            expect(returnedValue).toEqual('testValue');
+        });
+        it('should call the storage API, passing the provided entity key and returning undefined if the key doesnt exist', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStoredCustomEntity: {
+                        value: null
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            const returnedValue = await globalStorage.getEntity('testEntityName', 'testEntityKey');
+            verifyApiClientCalledWith(apiClientMock, {
+                contextAri,
+                entityName: 'testEntityName',
+                key: 'testEntityKey'
+            });
+            expect(returnedValue).toEqual(undefined);
+        });
+        it('should call the storage API, passing the provided key and returning the stored falsey value 0', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStoredCustomEntity: {
+                        value: 0
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            const returnedValue = await globalStorage.getEntity('testEntityName', 'testEntityKey');
+            verifyApiClientCalledWith(apiClientMock, {
+                contextAri,
+                entityName: 'testEntityName',
+                key: 'testEntityKey'
+            });
+            expect(returnedValue).toEqual(0);
+        });
+        it('should call the storage API, passing the provided key and returning the stored empty string', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStoredCustomEntity: {
+                        value: ''
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            const returnedValue = await globalStorage.getEntity('testEntityName', 'testEntityKey');
+            verifyApiClientCalledWith(apiClientMock, {
+                contextAri,
+                entityName: 'testEntityName',
+                key: 'testEntityKey'
+            });
+            expect(returnedValue).toEqual('');
+        });
+        it('should throw an error with the returned status for non-200 status codes', async () => {
+            const apiClientMock = getApiClientMock(undefined, 400);
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.getEntity('testEntityName', 'testEntityKey');
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forStatus(400));
+        });
+        it('should throw an error with the returned error message for failed responses', async () => {
+            const apiClientMock = getApiClientMock({
+                errors: [INVALID_CURSOR_ERROR]
+            }, 200);
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.getEntity('testEntityName', 'testEntityKey');
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forErrorCode('CURSOR_INVALID', 'error message'));
+        });
+        it('should throw an error if the response is not a valid JSON', async () => {
+            const apiClientMock = getApiClientMockInvalidJson('test', 200);
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.getEntity('testEntityName', 'testEntityKey');
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forUnexpected('Response text was not a valid JSON: test'));
+        });
+    });
+    describe('setEntity', () => {
+        it('should call the storage API, passing the provided entity name, entity key and value', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStorageCustomEntity: {
+                        setAppStoredCustomEntity: {
+                            success: true
+                        }
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            await globalStorage.setEntity('testEntityName', 'testEntityKey', 'testValue');
+            verifyApiClientCalledWith(apiClientMock, {
+                input: {
+                    contextAri,
+                    entityName: 'testEntityName',
+                    key: 'testEntityKey',
+                    value: 'testValue'
+                }
+            });
+        });
+        it('should throw an error if the storage API returns successful = false', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStorageCustomEntity: {
+                        setAppStoredCustomEntity: {
+                            success: false,
+                            errors: [INVALID_CURSOR_ERROR]
+                        }
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.setEntity('testEntityName', 'testEntityKey', 'testValue');
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forErrorCode('INVALID_CURSOR', 'error message'));
+        });
+        it('should throw an error if the storage API returns a non 200 status code', async () => {
+            const apiClientMock = getApiClientMockInvalidJson('', 400);
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.setEntity('testEntityName', 'testEntityKey', 'testValue');
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forStatus(400));
+        });
+        it('should throw a 500 error if success=false but no errors were returned', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStorageCustomEntity: {
+                        setAppStoredCustomEntity: {
+                            success: false
+                        }
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            await expect(globalStorage.setEntity('testEntityName', 'testEntityKey', 'testValue')).rejects.toThrow(errors_1.APIError.forStatus(500));
+            verifyApiClientCalledWith(apiClientMock, {
+                input: {
+                    contextAri,
+                    entityName: 'testEntityName',
+                    key: 'testEntityKey',
+                    value: 'testValue'
+                }
+            });
+        });
+    });
+    describe('deleteEntity', () => {
+        it('should call the storage API, passing the provided entity name and key', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStorageCustomEntity: {
+                        deleteAppStoredCustomEntity: {
+                            success: true
+                        }
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            await globalStorage.deleteEntity('testEntityName', 'testEntityKey');
+            verifyApiClientCalledWith(apiClientMock, {
+                input: {
+                    contextAri,
+                    entityName: 'testEntityName',
+                    key: 'testEntityKey'
+                }
+            });
+        });
+        it('should throw an error if the storage API returns successful = false', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    appStorageCustomEntity: {
+                        deleteAppStoredCustomEntity: {
+                            success: false,
+                            errors: [INVALID_CURSOR_ERROR]
+                        }
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.deleteEntity('testEntityKey', 'testEntityKey');
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forErrorCode('CURSOR_INVALID', 'error message'));
+        });
+        it('should throw an error if the storage API returns a non 200 status code and has no body', async () => {
+            const apiClientMock = getApiClientMockInvalidJson('', 400);
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.deleteEntity('testEntityKey', 'testEntityKey');
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forStatus(400));
+        });
+    });
     describe('list', () => {
         it('should call the storage API with the provided parameters', async () => {
             const apiClientMock = getApiClientMock({
@@ -347,7 +567,7 @@ describe('GlobalStorage', () => {
                 where,
                 cursor,
                 limit
-            }, queries_1.listQuery(contextAri, {}).query);
+            }, gql_queries_1.UntypedQueries.listQuery(contextAri, {}).query);
             expect(response).toEqual(expect.objectContaining({
                 results: [
                     { key: 'key1', value: 'testValue' },
@@ -384,7 +604,7 @@ describe('GlobalStorage', () => {
                 where,
                 cursor,
                 limit
-            }, queries_1.listQueryForCleanup(contextAri, {}).query);
+            }, gql_queries_1.UntypedQueries.listQueryForCleanup(contextAri, {}).query);
             expect(response).toEqual(expect.objectContaining({
                 results: [
                     { key: 'key1', value: 'testValue' },
@@ -409,7 +629,7 @@ describe('GlobalStorage', () => {
                 where: null,
                 cursor: null,
                 limit: null
-            }, queries_1.listQuery(contextAri, {}).query);
+            }, gql_queries_1.UntypedQueries.listQuery(contextAri, {}).query);
         });
         it('should handle an empty result set', async () => {
             const apiClientMock = getApiClientMock({
@@ -450,4 +670,65 @@ describe('GlobalStorage', () => {
             await expect(response).rejects.toThrow(errors_1.APIError.forStatus(400));
         });
     });
+    describe('upsertCustomEntity', () => {
+        it('should call the storage API, passing the provided entities', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    customSchema: {
+                        createCustomSchema: {
+                            success: true
+                        }
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            await globalStorage.upsertCustomEntities(schemas);
+            verifyApiClientCalledWith(apiClientMock, {
+                input: {
+                    schemas
+                }
+            });
+        });
+        it('should throw an error if the storage API returns successful = false', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    customSchema: {
+                        createCustomSchema: {
+                            success: false,
+                            errors: [INVALID_CURSOR_ERROR]
+                        }
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.upsertCustomEntities(schemas);
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forErrorCode('INVALID_CURSOR', 'error message'));
+        });
+        it('should throw an error if the storage API returns a non 200 status code', async () => {
+            const apiClientMock = getApiClientMockInvalidJson('', 400);
+            const globalStorage = getStorage(apiClientMock);
+            const response = globalStorage.upsertCustomEntities(schemas);
+            expect(apiClientMock).toHaveBeenCalled();
+            await expect(response).rejects.toThrow(errors_1.APIError.forStatus(400));
+        });
+        it('should throw a 500 error if success=false but no errors were returned', async () => {
+            const apiClientMock = getApiClientMock({
+                data: {
+                    customSchema: {
+                        createCustomSchema: {
+                            success: false
+                        }
+                    }
+                }
+            });
+            const globalStorage = getStorage(apiClientMock);
+            await expect(globalStorage.upsertCustomEntities(schemas)).rejects.toThrow(errors_1.APIError.forStatus(500));
+            verifyApiClientCalledWith(apiClientMock, {
+                input: {
+                    schemas
+                }
+            });
+        });
+    });
 });