@rockcarver/frodo-lib 0.19.2 → 2.0.0-1

package/esm/ops/ResourceTypeOps.test.mjs

@@ -35,19 +35,29 @@
  * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
  * in case things don't function as expected
  */
+import { state } from '../index';
 import * as ResourceTypeOps from './ResourceTypeOps';
 import { autoSetupPolly } from '../utils/AutoSetupPolly';
 autoSetupPolly();
 async function stageResourceType(type, create = true) {
   // delete if exists, then create
   try {
-    await ResourceTypeOps.getResourceType(type.uuid);
-    await ResourceTypeOps.deleteResourceType(type.uuid);
+    await ResourceTypeOps.getResourceType({
+      resourceTypeUuid: type.uuid,
+      state
+    });
+    await ResourceTypeOps.deleteResourceType({
+      resourceTypeUuid: type.uuid,
+      state
+    });
   } catch (error) {
     // ignore
   } finally {
     if (create) {
-      await ResourceTypeOps.createResourceType(type);
+      await ResourceTypeOps.createResourceType({
+        resourceTypeData: type,
+        state
+      });
     }
   }
 }
@@ -339,7 +349,9 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.getResourceTypes).toBeDefined();
       });
       test('1: Get all resource types', async () => {
-        const response = await ResourceTypeOps.getResourceTypes();
+        const response = await ResourceTypeOps.getResourceTypes({
+          state
+        });
         expect(response).toMatchSnapshot();
       });
     });
@@ -348,13 +360,19 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.getResourceType).toBeDefined();
       });
       test(`1: Get existing resource type by uuid [${type1.uuid} - ${type1.name}]`, async () => {
-        const response = await ResourceTypeOps.getResourceType(type1.uuid);
+        const response = await ResourceTypeOps.getResourceType({
+          resourceTypeUuid: type1.uuid,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
       test('2: Get non-existing resource type by uuid [00000000-0000-0000-0000-000000000000]', async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.getResourceType('00000000-0000-0000-0000-000000000000');
+          await ResourceTypeOps.getResourceType({
+            resourceTypeUuid: '00000000-0000-0000-0000-000000000000',
+            state
+          });
         } catch (error) {
           expect(error.response.data).toMatchSnapshot();
         }
@@ -365,13 +383,19 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.getResourceTypeByName).toBeDefined();
       });
       test(`1: Get existing resource type by name [${type2.name} - ${type2.uuid}]`, async () => {
-        const response = await ResourceTypeOps.getResourceTypeByName(type2.name);
+        const response = await ResourceTypeOps.getResourceTypeByName({
+          resourceTypeName: type2.name,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
       test('2: Get non-existing resource type by name [DoesNotExist]', async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.getResourceTypeByName('DoesNotExist');
+          await ResourceTypeOps.getResourceTypeByName({
+            resourceTypeName: 'DoesNotExist',
+            state
+          });
         } catch (error) {
           expect(error.message).toMatchSnapshot();
         }
@@ -382,13 +406,19 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.createResourceType).toBeDefined();
       });
       test(`1: Create non-existing resource type [${type3.uuid} - ${type3.name}]`, async () => {
-        const response = await ResourceTypeOps.createResourceType(type3);
+        const response = await ResourceTypeOps.createResourceType({
+          resourceTypeData: type3,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
       test(`2: Create existing resource type [${type4.uuid} - ${type4.name}]`, async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.createResourceType(type4);
+          await ResourceTypeOps.createResourceType({
+            resourceTypeData: type4,
+            state
+          });
         } catch (error) {
           expect(error.response.data).toMatchSnapshot();
         }
@@ -399,13 +429,21 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.updateResourceType).toBeDefined();
       });
       test(`1: Update existing resource type [${type5.uuid} - ${type5.name}]`, async () => {
-        const response = await ResourceTypeOps.updateResourceType(type5.uuid, type5);
+        const response = await ResourceTypeOps.updateResourceType({
+          resourceTypeUuid: type5.uuid,
+          resourceTypeData: type5,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
       test(`2: Update non-existing resource type [${type6.uuid} - ${type6.name}]`, async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.updateResourceType(type6.uuid, type6);
+          await ResourceTypeOps.updateResourceType({
+            resourceTypeUuid: type6.uuid,
+            resourceTypeData: type6,
+            state
+          });
         } catch (error) {
           expect(error.response.data).toMatchSnapshot();
         }
@@ -416,7 +454,10 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.exportResourceType).toBeDefined();
       });
       test(`1: Export existing resource type by uuid [${type9.uuid} - ${type9.name}]`, async () => {
-        const response = await ResourceTypeOps.exportResourceType(type9.uuid);
+        const response = await ResourceTypeOps.exportResourceType({
+          resourceTypeUuid: type9.uuid,
+          state
+        });
         expect(response).toMatchSnapshot({
           meta: expect.any(Object)
         });
@@ -424,7 +465,10 @@ describe('ResourceTypeOps', () => {
       test('2: Export non-existing resource type by uuid [00000000-0000-0000-0000-000000000000]', async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.exportResourceType('00000000-0000-0000-0000-000000000000');
+          await ResourceTypeOps.exportResourceType({
+            resourceTypeUuid: '00000000-0000-0000-0000-000000000000',
+            state
+          });
         } catch (error) {
           expect(error.message).toMatchSnapshot();
         }
@@ -435,7 +479,10 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.exportResourceTypeByName).toBeDefined();
       });
       test(`1: Export existing resource type by name [${type10.name} - ${type10.uuid}]`, async () => {
-        const response = await ResourceTypeOps.exportResourceTypeByName(type10.name);
+        const response = await ResourceTypeOps.exportResourceTypeByName({
+          resourceTypeName: type10.name,
+          state
+        });
         expect(response).toMatchSnapshot({
           meta: expect.any(Object)
         });
@@ -443,7 +490,10 @@ describe('ResourceTypeOps', () => {
       test('2: Export non-existing resource type by name [DoesNotExist]', async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.exportResourceTypeByName('DoesNotExist');
+          await ResourceTypeOps.exportResourceTypeByName({
+            resourceTypeName: 'DoesNotExist',
+            state
+          });
         } catch (error) {
           expect(error.message).toMatchSnapshot();
         }
@@ -454,7 +504,9 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.exportResourceTypes).toBeDefined();
       });
       test('1: Export all resource types', async () => {
-        const response = await ResourceTypeOps.exportResourceTypes();
+        const response = await ResourceTypeOps.exportResourceTypes({
+          state
+        });
         expect(response).toMatchSnapshot({
           meta: expect.any(Object)
         });
@@ -465,13 +517,21 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.importResourceType).toBeDefined();
       });
       test(`1: Import existing resource type by uuid [${import1.uuid} - ${import1.name}]`, async () => {
-        const response = await ResourceTypeOps.importResourceType(import1.uuid, import1.type);
+        const response = await ResourceTypeOps.importResourceType({
+          resourceTypeUuid: import1.uuid,
+          importData: import1.type,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
       test('2: Import non-existing resource type by uuid [00000000-0000-0000-0000-000000000000]', async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.importResourceType('00000000-0000-0000-0000-000000000000', import1.type);
+          await ResourceTypeOps.importResourceType({
+            resourceTypeUuid: '00000000-0000-0000-0000-000000000000',
+            importData: import1.type,
+            state
+          });
         } catch (error) {
           expect(error.message).toMatchSnapshot();
         }
@@ -482,13 +542,21 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.importResourceTypeByName).toBeDefined();
       });
       test(`1: Export existing resource type by name [${import2.name} - ${import2.uuid}]`, async () => {
-        const response = await ResourceTypeOps.importResourceTypeByName(import2.name, import2.type);
+        const response = await ResourceTypeOps.importResourceTypeByName({
+          resourceTypeName: import2.name,
+          importData: import2.type,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
       test('2: Export non-existing resource type by name [DoesNotExist]', async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.importResourceTypeByName('DoesNotExist', import2.type);
+          await ResourceTypeOps.importResourceTypeByName({
+            resourceTypeName: 'DoesNotExist',
+            importData: import2.type,
+            state
+          });
         } catch (error) {
           expect(error.message).toMatchSnapshot();
         }
@@ -499,7 +567,10 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.importFirstResourceType).toBeDefined();
       });
       test('1: Import first resource type', async () => {
-        const response = await ResourceTypeOps.importFirstResourceType(import3.type);
+        const response = await ResourceTypeOps.importFirstResourceType({
+          importData: import3.type,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
     });
@@ -508,7 +579,10 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.importResourceTypes).toBeDefined();
       });
       test('1: Import all resource types', async () => {
-        const response = await ResourceTypeOps.importResourceTypes(import4.type);
+        const response = await ResourceTypeOps.importResourceTypes({
+          importData: import4.type,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
     });
@@ -521,13 +595,19 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.deleteResourceType).toBeDefined();
       });
       test(`1: Delete existing resource type [${type7.uuid} - ${type7.name}]`, async () => {
-        const response = await ResourceTypeOps.deleteResourceType(type7.uuid);
+        const response = await ResourceTypeOps.deleteResourceType({
+          resourceTypeUuid: type7.uuid,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
       test('2: Delete non-existing resource type [00000000-0000-0000-0000-000000000000]', async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.deleteResourceType('00000000-0000-0000-0000-000000000000');
+          await ResourceTypeOps.deleteResourceType({
+            resourceTypeUuid: '00000000-0000-0000-0000-000000000000',
+            state
+          });
         } catch (error) {
           expect(error.response.data).toMatchSnapshot();
         }
@@ -538,13 +618,19 @@ describe('ResourceTypeOps', () => {
         expect(ResourceTypeOps.deleteResourceType).toBeDefined();
       });
       test(`1: Delete existing resource type by name [${type8.name} - ${type8.uuid}]`, async () => {
-        const response = await ResourceTypeOps.deleteResourceTypeByName(type8.name);
+        const response = await ResourceTypeOps.deleteResourceTypeByName({
+          resourceTypeName: type8.name,
+          state
+        });
         expect(response).toMatchSnapshot();
       });
       test('2: Delete non-existing resource type by name [DoesNotExist]', async () => {
         expect.assertions(1);
         try {
-          await ResourceTypeOps.deleteResourceTypeByName('DoesNotExist');
+          await ResourceTypeOps.deleteResourceTypeByName({
+            resourceTypeName: 'DoesNotExist',
+            state
+          });
         } catch (error) {
           expect(error.message).toMatchSnapshot();
         }